Skip to content

armgit / SOMA

Public Imported from GitHub
0

Desktop app for designing parametric 3D models in CadQuery together with the coding agent of your choice

App: Ordner lassen sich nach inputs/ ziehen

Kai-Jungsthoefel6c958d779459
diff --git a/app/README.md b/app/README.md
index 9e88e17..1013489 100644
--- a/app/README.md
+++ b/app/README.md
@@ -15,7 +15,7 @@ Electron-App (TypeScript) für 3D-Modelle mit einem Coding-Agenten im Terminal.
npm install
npm start # baut und startet
npm run typecheck
-npm run test:unit # Bausteine ohne Electron: Dateien nach inputs/, Markierung nach .soma/feedback/, Pfadschutz, Schreiben aus dem Editor mit Konfliktprüfung, App-Icon, Einstellungen, Kategorien und Standard der Skills (26 Prüfungen)
+npm run test:unit # Bausteine ohne Electron: Dateien und Ordner nach inputs/, Markierung nach .soma/feedback/, Pfadschutz, Schreiben aus dem Editor mit Konfliktprüfung, App-Icon, Einstellungen, Kategorien und Standard der Skills (29 Prüfungen)
npm run test:smoke # echte App, unsichtbar: Projekt, Viewer, Auswahl, Panels, Terminal, Übergabe an den Agenten, Markierung (Zeichnen, Auswählen, Verschieben, Drehen, Skalieren, Farben), Auto-Build, Fehlerfall, Export, Ansichtswürfel und Drehpunkt (61 Prüfungen)
npm run test:versions # Git-Verlauf, Speichern, Öffnen, Vorschau (auch markiert), Wiederherstellen, Störfälle (53 Prüfungen)
npm run test:editor # Editor: Höhe und Scrollen, Speichern nur auf Wunsch mit genau einem Build (nur bei Python und inputs/), Änderungen des Agenten, Konflikte mit Sicherung, Nur lesen, CRLF, Rückfragen bei Modellwechsel und Reiter schließen (29 Prüfungen)
diff --git a/app/src/main/files.ts b/app/src/main/files.ts
index d34b049..772b414 100644
--- a/app/src/main/files.ts
+++ b/app/src/main/files.ts
@@ -7,34 +7,88 @@ const HIDDEN = new Set(['.git', '.soma', '__pycache__', 'node_modules', '.venv',
const MAX_ENTRIES = 2000;
const MAX_DEPTH = 5;
const MAX_IMPORT_BYTES = 500 * 1024 * 1024;
+const MAX_IMPORT_FILES = 10000;
const MAX_FEEDBACK_BYTES = 64 * 1024 * 1024;
const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
/**
- * Kopiert gezogene Dateien nach inputs/ (E33). Der Agent bindet sie danach im Skript ein.
- * Nichts wird überschrieben: bei gleichem Namen entsteht „name (2).ext“. Ordner werden nicht übernommen.
+ * Kopiert gezogene Dateien und Ordner nach inputs/ (E33). Der Agent bindet sie danach im Skript ein.
+ * Nichts wird überschrieben: bei gleichem Namen entsteht „name (2).ext“ bzw. „ordner (2)“. Ein Ordner kommt mit
+ * allem darin, nur Verknüpfungen und .git-Ordner nicht (siehe scanFolder). Ergebnis: Dateien als Pfad, Ordner mit „/“ am Ende.
*/
export function importInputs(root: string, sources: string[]): ImportResult {
const res: ImportResult = { files: [], errors: [] };
for (const src of sources) {
const base = path.basename(src);
try {
- const st = fs.statSync(src);
- if (!st.isFile()) { res.errors.push(`${base}: Nur einzelne Dateien lassen sich übernehmen, keine Ordner.`); continue; }
- if (st.size > MAX_IMPORT_BYTES) { res.errors.push(`${base}: größer als 500 MB, nicht übernommen.`); continue; }
+ const st = fs.lstatSync(src);
+ if (st.isSymbolicLink()) { res.errors.push(`${base}: Verknüpfungen werden nicht übernommen.`); continue; }
+ if (!st.isFile() && !st.isDirectory()) { res.errors.push(`${base}: weder Datei noch Ordner, nicht übernommen.`); continue; }
const dest = resolveInside(root, 'inputs');
fs.mkdirSync(dest, { recursive: true });
- const ext = path.extname(base), stem = base.slice(0, base.length - ext.length);
- let name = base;
- for (let i = 2; fs.existsSync(path.join(dest, name)); i++) name = `${stem} (${i})${ext}`;
- // COPYFILE_EXCL: falls zwischen Prüfung und Kopie doch eine Datei entsteht, schlägt die Kopie fehl statt zu überschreiben
- fs.copyFileSync(src, resolveInside(root, `inputs/${name}`), fs.constants.COPYFILE_EXCL);
- res.files.push(`inputs/${name}`);
+ if (st.isFile()) {
+ if (st.size > MAX_IMPORT_BYTES) { res.errors.push(`${base}: größer als 500 MB, nicht übernommen.`); continue; }
+ const ext = path.extname(base), stem = base.slice(0, base.length - ext.length);
+ let name = base;
+ for (let i = 2; fs.existsSync(path.join(dest, name)); i++) name = `${stem} (${i})${ext}`;
+ // COPYFILE_EXCL: falls zwischen Prüfung und Kopie doch eine Datei entsteht, schlägt die Kopie fehl statt zu überschreiben
+ fs.copyFileSync(src, resolveInside(root, `inputs/${name}`), fs.constants.COPYFILE_EXCL);
+ res.files.push(`inputs/${name}`);
+ } else {
+ // Erst ganz durchsehen, dann kopieren: Ist der Ordner zu groß, landet gar nichts statt einer halben Kopie
+ const scan = scanFolder(src);
+ if (scan.tooBig) { res.errors.push(`${base}: ${scan.tooBig}, nicht übernommen.`); continue; }
+ let name = base;
+ for (let i = 2; fs.existsSync(path.join(dest, name)); i++) name = `${base} (${i})`;
+ const target = resolveInside(root, `inputs/${name}`);
+ // ohne recursive: gibt es den Ordner inzwischen doch, schlägt das fehl statt in einen fremden Ordner zu kopieren
+ fs.mkdirSync(target);
+ try {
+ for (const d of scan.dirs) fs.mkdirSync(path.join(target, d));
+ for (const f of scan.files) fs.copyFileSync(path.join(src, f), path.join(target, f), fs.constants.COPYFILE_EXCL);
+ } catch (e) {
+ // Der Ordner ist eben erst entstanden und gehört nur zu diesem Import, eine halbe Kopie würde den Agenten irreführen
+ fs.rmSync(target, { recursive: true, force: true });
+ throw e;
+ }
+ res.files.push(`inputs/${name}/`);
+ for (const s of scan.skipped) res.errors.push(`${base}/${s}`);
+ }
} catch (e) { res.errors.push(`${base}: ${e instanceof Error ? e.message : String(e)}`); }
}
return res;
}
+interface FolderScan { dirs: string[]; files: string[]; skipped: string[]; tooBig?: string }
+
+/**
+ * Sammelt Unterordner und Dateien eines gezogenen Ordners (relative Pfade, Eltern vor Kindern).
+ * Verknüpfungen werden nicht verfolgt (sie könnten auf beliebige Stellen des Rechners zeigen). .git-Ordner bleiben
+ * draußen: Git im Projekt würde ein eingebettetes Repository nur als Verweis ablegen, der Inhalt fehlte dann im Verlauf.
+ */
+function scanFolder(src: string): FolderScan {
+ const scan: FolderScan = { dirs: [], files: [], skipped: [] };
+ let bytes = 0;
+ const walk = (rel: string): void => {
+ for (const e of fs.readdirSync(path.join(src, rel), { withFileTypes: true })) {
+ if (scan.tooBig) return;
+ const childRel = rel ? path.join(rel, e.name) : e.name;
+ const shown = childRel.split(path.sep).join('/');
+ if (e.isSymbolicLink()) scan.skipped.push(`${shown}: Verknüpfung, nicht übernommen.`);
+ else if (e.isDirectory() && e.name === '.git') scan.skipped.push(`${shown}: eigener Git-Verlauf, nicht übernommen.`);
+ else if (e.isDirectory()) { scan.dirs.push(childRel); walk(childRel); }
+ else if (e.isFile()) {
+ scan.files.push(childRel);
+ bytes += fs.statSync(path.join(src, childRel)).size;
+ if (bytes > MAX_IMPORT_BYTES) scan.tooBig = 'zusammen größer als 500 MB';
+ else if (scan.files.length > MAX_IMPORT_FILES) scan.tooBig = `mehr als ${MAX_IMPORT_FILES} Dateien`;
+ } else scan.skipped.push(`${shown}: weder Datei noch Ordner, nicht übernommen.`);
+ }
+ };
+ walk('');
+ return scan;
+}
+
/**
* Legt ein Bild der Markierung in .soma/feedback/ ab (E16). Dort ist es nicht in Git (E11), wandert aber mit der ZIP.
* Der Name trägt Datum und Uhrzeit, bei Gleichstand kommt „-2“ dazu. Vorhandenes wird nie überschrieben.
diff --git a/app/src/renderer/index.html b/app/src/renderer/index.html
index 1601657..fdbdf78 100644
--- a/app/src/renderer/index.html
+++ b/app/src/renderer/index.html
@@ -46,7 +46,7 @@
<button id="btn-reveal" class="ibtn s" title="Im Explorer zeigen" aria-label="Im Explorer zeigen"><i data-icon="openext" data-size="15"></i></button>
<button class="ibtn s side-close" aria-label="Dateien schließen"><i data-icon="x" data-size="15" data-stroke="2"></i></button></div>
<div id="tab-files" class="ftree"></div>
- <div id="dropzone" class="dropzone"><i data-icon="upload" data-size="20"></i><b>Dateien hierher ziehen</b><span>STEP-Dateien, Bilder und Skizzen landen in <code>inputs/</code>. Vorhandenes wird nicht überschrieben.</span></div>
+ <div id="dropzone" class="dropzone"><i data-icon="upload" data-size="20"></i><b>Dateien oder Ordner hierher ziehen</b><span>STEP-Dateien, Bilder und Skizzen landen in <code>inputs/</code>. Vorhandenes wird nicht überschrieben.</span></div>
</section>
<section id="panel-skills" class="panel" aria-label="Skills" hidden>
<div class="side-hd"><b>Skills</b><span class="grow"></span>
diff --git a/app/src/renderer/main.ts b/app/src/renderer/main.ts
index 2863316..c04a303 100644
--- a/app/src/renderer/main.ts
+++ b/app/src/renderer/main.ts
@@ -107,7 +107,7 @@ async function refreshFiles(): Promise<void> {
try { files.render(await api.fs.list()); } catch { /* Projekt wechselt gerade */ }
}
-// Dateien ziehen: überall im Fenster ablegen landet in inputs/. Ohne das würde Electron die Datei als Seite öffnen.
+// Dateien und Ordner ziehen: überall im Fenster ablegen landet in inputs/. Ohne das würde Electron die Datei als Seite öffnen.
let dragDepth = 0;
const hasFiles = (e: DragEvent) => !!e.dataTransfer && [...e.dataTransfer.types].includes('Files');
document.addEventListener('dragenter', (e) => {
@@ -129,7 +129,10 @@ async function importFiles(list: File[]): Promise<void> {
showPanel('files');
const lines: string[] = [];
if (r.files.length) lines.push(`In inputs/ abgelegt: ${r.files.map((f) => f.replace(/^inputs\//, '')).join(', ')}`, 'Der Agent kann sie jetzt im Skript einbinden.');
- if (r.errors.length) lines.push(`Nicht übernommen:\n${r.errors.join('\n')}`);
+ // Ein Ordner voller Verknüpfungen soll die Meldung nicht über den Bildschirm ziehen
+ const shown = r.errors.slice(0, 8);
+ if (r.errors.length > shown.length) shown.push(`… und ${r.errors.length - shown.length} weitere`);
+ if (r.errors.length) lines.push(`Nicht übernommen:\n${shown.join('\n')}`);
if (lines.length) toast(lines.join('\n'), r.errors.length ? 'error' : 'ok');
}
diff --git a/app/test/unit.mjs b/app/test/unit.mjs
index e8f0c33..041a904 100644
--- a/app/test/unit.mjs
+++ b/app/test/unit.mjs
@@ -30,8 +30,29 @@ try {
check('Gleicher Name: nichts überschrieben, neue Namen (2) und (3)', JSON.stringify(r.files) === '["inputs/platine (2).step","inputs/platine (3).step"]'
&& fs.readFileSync(path.join(proj, 'inputs', 'platine.step'), 'utf8').startsWith('ALT'), r.files.join(','));
- r = importInputs(proj, [path.join(src, 'ordner'), path.join(src, 'fehlt.step')]);
- check('Ordner und fehlende Dateien werden gemeldet, nicht übernommen', r.files.length === 0 && r.errors.length === 2 && /Ordner/.test(r.errors[0]), r.errors.join(' | ').slice(0, 90));
+ r = importInputs(proj, [path.join(src, 'fehlt.step')]);
+ check('Fehlende Datei wird gemeldet, nicht übernommen', r.files.length === 0 && r.errors.length === 1, r.errors.join(' | ').slice(0, 90));
+
+ // Ordner: mit Unterordnern übernommen, .git und Verknüpfungen bleiben draußen, nichts überschrieben
+ const tree = path.join(src, 'ordner');
+ fs.mkdirSync(path.join(tree, 'unter', 'tiefer'), { recursive: true });
+ fs.mkdirSync(path.join(tree, 'leer'));
+ fs.mkdirSync(path.join(tree, '.git'));
+ fs.writeFileSync(path.join(tree, '.git', 'HEAD'), 'ref');
+ fs.writeFileSync(path.join(tree, 'a.step'), 'A');
+ fs.writeFileSync(path.join(tree, 'unter', 'tiefer', 'b.csv'), 'B');
+ let treeLink = true;
+ try { fs.symlinkSync(tmp, path.join(tree, 'verweis'), 'junction'); } catch { treeLink = false; }
+ r = importInputs(proj, [tree]);
+ const got = path.join(proj, 'inputs', 'ordner');
+ check('Ordner landet mit Unterordnern in inputs/', r.files[0] === 'inputs/ordner/' && fs.readFileSync(path.join(got, 'a.step'), 'utf8') === 'A'
+ && fs.readFileSync(path.join(got, 'unter', 'tiefer', 'b.csv'), 'utf8') === 'B' && fs.existsSync(path.join(got, 'leer')), r.files.join(','));
+ check('Ordner: .git und Verknüpfungen bleiben draußen und werden gemeldet', !fs.existsSync(path.join(got, '.git')) && !fs.existsSync(path.join(got, 'verweis'))
+ && r.errors.length === (treeLink ? 2 : 1) && r.errors.every((e) => e.startsWith('ordner/')), r.errors.join(' | ').slice(0, 90));
+ fs.writeFileSync(path.join(got, 'a.step'), 'ALT');
+ r = importInputs(proj, [tree]);
+ check('Ordner mit gleichem Namen: „ordner (2)“, Vorhandenes bleibt', r.files[0] === 'inputs/ordner (2)/' && fs.readFileSync(path.join(got, 'a.step'), 'utf8') === 'ALT'
+ && fs.existsSync(path.join(proj, 'inputs', 'ordner (2)', 'a.step')), r.files.join(','));
// inputs/ als Verweis nach außen: resolveInside lehnt ab (Agent könnte so Dateien außerhalb des Projekts schreiben lassen)
const outside = path.join(tmp, 'draussen');