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: Editor im Code-Panel (CodeMirror 6, E39, E40)

Kai-Jungsthoefelfea8c85ec95e
diff --git a/app/package-lock.json b/app/package-lock.json
index 36f0d39..7432d89 100644
--- a/app/package-lock.json
+++ b/app/package-lock.json
@@ -8,8 +8,16 @@
"name": "cadide-app",
"version": "0.1.0",
"dependencies": {
+ "@codemirror/autocomplete": "^6.20.3",
+ "@codemirror/commands": "^6.11.1",
+ "@codemirror/lang-python": "^6.2.1",
+ "@codemirror/language": "^6.12.4",
+ "@codemirror/search": "^6.7.2",
+ "@codemirror/state": "^6.7.6",
+ "@codemirror/view": "^6.43.13",
"@fontsource/ibm-plex-mono": "^5.3.0",
"@fontsource/ibm-plex-sans": "^5.3.0",
+ "@lezer/highlight": "^1.2.5",
"@xterm/addon-fit": "^0.11.0",
"@xterm/xterm": "^6.0.0",
"dugite": "^3.2.3",
@@ -28,6 +36,89 @@
"typescript": "^5.9.0"
}
},
+ "node_modules/@codemirror/autocomplete": {
+ "version": "6.20.3",
+ "resolved": "https://registry.npmjs.org/@codemirror/autocomplete/-/autocomplete-6.20.3.tgz",
+ "integrity": "sha512-tlosUqb+3BbxCxZdu4tKeRghPFC+QM7q4X5YhKV2eCmPG+1r2F3f4AaSz5sCrFqUtX4Jh20VFTKecl16MgiV9g==",
+ "license": "MIT",
+ "dependencies": {
+ "@codemirror/language": "^6.0.0",
+ "@codemirror/state": "^6.0.0",
+ "@codemirror/view": "^6.17.0",
+ "@lezer/common": "^1.0.0"
+ }
+ },
+ "node_modules/@codemirror/commands": {
+ "version": "6.11.1",
+ "resolved": "https://registry.npmjs.org/@codemirror/commands/-/commands-6.11.1.tgz",
+ "integrity": "sha512-O/4hG3SC1YwcmQ0d2UVNDs+AsaNWd1iHVxbTeEBuqH+6bExAiPK3iS/BvpY6rZGURALv4ZD3sIgcCmRvw3ehBg==",
+ "license": "MIT",
+ "dependencies": {
+ "@codemirror/language": "^6.0.0",
+ "@codemirror/state": "^6.7.0",
+ "@codemirror/view": "^6.27.0",
+ "@lezer/common": "^1.1.0"
+ }
+ },
+ "node_modules/@codemirror/lang-python": {
+ "version": "6.2.1",
+ "resolved": "https://registry.npmjs.org/@codemirror/lang-python/-/lang-python-6.2.1.tgz",
+ "integrity": "sha512-IRjC8RUBhn9mGR9ywecNhB51yePWCGgvHfY1lWN/Mrp3cKuHr0isDKia+9HnvhiWNnMpbGhWrkhuWOc09exRyw==",
+ "license": "MIT",
+ "dependencies": {
+ "@codemirror/autocomplete": "^6.3.2",
+ "@codemirror/language": "^6.8.0",
+ "@codemirror/state": "^6.0.0",
+ "@lezer/common": "^1.2.1",
+ "@lezer/python": "^1.1.4"
+ }
+ },
+ "node_modules/@codemirror/language": {
+ "version": "6.12.4",
+ "resolved": "https://registry.npmjs.org/@codemirror/language/-/language-6.12.4.tgz",
+ "integrity": "sha512-1q4PaT+o6PbgpkJt4Q8Fv5XJxTy4FUZ4MWETtyiDw3J0Pyr9E2vqcKL+k9wcvjNTIsauxvE7OfmWj3FRPHQ76A==",
+ "license": "MIT",
+ "dependencies": {
+ "@codemirror/state": "^6.0.0",
+ "@codemirror/view": "^6.23.0",
+ "@lezer/common": "^1.5.0",
+ "@lezer/highlight": "^1.0.0",
+ "@lezer/lr": "^1.0.0",
+ "style-mod": "^4.0.0"
+ }
+ },
+ "node_modules/@codemirror/search": {
+ "version": "6.7.2",
+ "resolved": "https://registry.npmjs.org/@codemirror/search/-/search-6.7.2.tgz",
+ "integrity": "sha512-gUYkYhT2+n/+VGZ+8EzE5WFkYZUZYm1VOKDudIsNqh42uRVQJ0a6Yss9sdKT3MeOYfuL1N6AZA57oza0Oyr0LA==",
+ "license": "MIT",
+ "dependencies": {
+ "@codemirror/state": "^6.0.0",
+ "@codemirror/view": "^6.37.0",
+ "crelt": "^1.0.5"
+ }
+ },
+ "node_modules/@codemirror/state": {
+ "version": "6.7.6",
+ "resolved": "https://registry.npmjs.org/@codemirror/state/-/state-6.7.6.tgz",
+ "integrity": "sha512-kAz+AncRtKuIknedxT1bq4XwXv4UowhbkHU1myPrtVb/jZtImWuV5BXzv5vK6i3kYACsdiZiQKFQQ5Mq7elW8w==",
+ "license": "MIT",
+ "dependencies": {
+ "@marijn/find-cluster-break": "^1.0.0"
+ }
+ },
+ "node_modules/@codemirror/view": {
+ "version": "6.43.13",
+ "resolved": "https://registry.npmjs.org/@codemirror/view/-/view-6.43.13.tgz",
+ "integrity": "sha512-sihaFrUzAsYBQsL9J2t69y8nfMQGwcYmggAZsk+kjPbjYZMyuf2hU8tUNTZ+P+isb6XRr8JE22TZlJxBoVdH1A==",
+ "license": "MIT",
+ "dependencies": {
+ "@codemirror/state": "^6.7.0",
+ "crelt": "^1.0.6",
+ "style-mod": "^4.1.0",
+ "w3c-keyname": "^2.2.4"
+ }
+ },
"node_modules/@dimforge/rapier3d-compat": {
"version": "0.12.0",
"resolved": "https://registry.npmjs.org/@dimforge/rapier3d-compat/-/rapier3d-compat-0.12.0.tgz",
@@ -526,6 +617,47 @@
"url": "https://github.com/sponsors/ayuhito"
}
},
+ "node_modules/@lezer/common": {
+ "version": "1.5.3",
+ "resolved": "https://registry.npmjs.org/@lezer/common/-/common-1.5.3.tgz",
+ "integrity": "sha512-H0iErY4e43LpXbYDyBci5W4v/RwTgGV3YzYOlJPiGZ8RY8w51kVE+xLn1tg3Z6UmSfyETvtsUK3r7YsgDQEI7Q==",
+ "license": "MIT"
+ },
+ "node_modules/@lezer/highlight": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/@lezer/highlight/-/highlight-1.2.5.tgz",
+ "integrity": "sha512-O1GMVKgtf5YspFaRzpmqkVgMtIk2HG9uMAbH6wdAIdNh3TVzCsch/+cRi+6l2//UGDKe6NB9BW3cvuR5ezMQ0w==",
+ "license": "MIT",
+ "dependencies": {
+ "@lezer/common": "^1.3.0"
+ }
+ },
+ "node_modules/@lezer/lr": {
+ "version": "1.4.10",
+ "resolved": "https://registry.npmjs.org/@lezer/lr/-/lr-1.4.10.tgz",
+ "integrity": "sha512-rnCpTIBafOx4mRp43xOxDJbFipJm/c0cia/V5TiGlhmMa+wsSdoGmUN3w5Bqrks/09Q/D4tNAmWaT8p6NRi77A==",
+ "license": "MIT",
+ "dependencies": {
+ "@lezer/common": "^1.0.0"
+ }
+ },
+ "node_modules/@lezer/python": {
+ "version": "1.1.19",
+ "resolved": "https://registry.npmjs.org/@lezer/python/-/python-1.1.19.tgz",
+ "integrity": "sha512-MhQIURHRytsNzP/YXnqpYKW6la6voAH3kyplTOOiCdjyFY6cWWGFVmYVdHIPrElqSDf4iCDktQCockB9FxuhzQ==",
+ "license": "MIT",
+ "dependencies": {
+ "@lezer/common": "^1.2.0",
+ "@lezer/highlight": "^1.0.0",
+ "@lezer/lr": "^1.0.0"
+ }
+ },
+ "node_modules/@marijn/find-cluster-break": {
+ "version": "1.0.4",
+ "resolved": "https://registry.npmjs.org/@marijn/find-cluster-break/-/find-cluster-break-1.0.4.tgz",
+ "integrity": "sha512-Wy0V7+SGUjnF9/TkiM1hKVDPj7jKXduPNboMVtHTA8dySMURWqfg/JZ9E2Sq8JgSJmkl7k7Qe9FLeMSrSraWmQ==",
+ "license": "MIT"
+ },
"node_modules/@tweenjs/tween.js": {
"version": "23.1.3",
"resolved": "https://registry.npmjs.org/@tweenjs/tween.js/-/tween.js-23.1.3.tgz",
@@ -718,6 +850,12 @@
"node": ">=8.0.0"
}
},
+ "node_modules/crelt": {
+ "version": "1.0.7",
+ "resolved": "https://registry.npmjs.org/crelt/-/crelt-1.0.7.tgz",
+ "integrity": "sha512-aK6BbWfhf4U/wCcLHKPJl/xa6VkVstRaPywWtMKGwuOLc/wZTyQYuoxgvZnNsBvv7Kg3YTBQYYBCggcviQczuA==",
+ "license": "MIT"
+ },
"node_modules/debug": {
"version": "4.4.3",
"resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
@@ -939,6 +1077,12 @@
"text-decoder": "^1.1.0"
}
},
+ "node_modules/style-mod": {
+ "version": "4.1.4",
+ "resolved": "https://registry.npmjs.org/style-mod/-/style-mod-4.1.4.tgz",
+ "integrity": "sha512-XXWIQt633/EpAFx8aZDOTjBzrCaGmhvEQlQo6MVPfa2OzO2cWo+4hV9h+6UkHYlXGfy+ODXKUdP7Pthmcu5ATw==",
+ "license": "MIT"
+ },
"node_modules/sumchecker": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/sumchecker/-/sumchecker-3.0.1.tgz",
@@ -1020,6 +1164,12 @@
"dev": true,
"license": "MIT"
},
+ "node_modules/w3c-keyname": {
+ "version": "2.2.8",
+ "resolved": "https://registry.npmjs.org/w3c-keyname/-/w3c-keyname-2.2.8.tgz",
+ "integrity": "sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ==",
+ "license": "MIT"
+ },
"node_modules/yauzl": {
"version": "3.4.0",
"resolved": "https://registry.npmjs.org/yauzl/-/yauzl-3.4.0.tgz",
diff --git a/app/package.json b/app/package.json
index 31d5664..5db5118 100644
--- a/app/package.json
+++ b/app/package.json
@@ -10,12 +10,21 @@
"start": "npm run build && node scripts/start.mjs",
"test:smoke": "npm run build && node test/smoke.mjs",
"test:versions": "npm run build && node test/versions.mjs",
+ "test:editor": "npm run build && node test/editor.mjs",
"test:unit": "node test/unit.mjs",
- "test": "npm run build && node test/unit.mjs && node test/smoke.mjs && node test/versions.mjs"
+ "test": "npm run build && node test/unit.mjs && node test/smoke.mjs && node test/versions.mjs && node test/editor.mjs"
},
"dependencies": {
+ "@codemirror/autocomplete": "^6.20.3",
+ "@codemirror/commands": "^6.11.1",
+ "@codemirror/lang-python": "^6.2.1",
+ "@codemirror/language": "^6.12.4",
+ "@codemirror/search": "^6.7.2",
+ "@codemirror/state": "^6.7.6",
+ "@codemirror/view": "^6.43.13",
"@fontsource/ibm-plex-mono": "^5.3.0",
"@fontsource/ibm-plex-sans": "^5.3.0",
+ "@lezer/highlight": "^1.2.5",
"@xterm/addon-fit": "^0.11.0",
"@xterm/xterm": "^6.0.0",
"dugite": "^3.2.3",
diff --git a/app/resources/template/AGENTS.md b/app/resources/template/AGENTS.md
index d75ebcc..196f203 100644
--- a/app/resources/template/AGENTS.md
+++ b/app/resources/template/AGENTS.md
@@ -58,3 +58,5 @@ The app pastes short notes into your input. The user adds their own words and se
- `[Markierung: .cadide/feedback/markierung-20260930-1405.png]`: a picture of the 3D view (or a blank sketch) with the user's drawings: arrows, circles, handwritten text, often with dimensions. **Open the image file and look at it**, compare it with the model, then change the code. If the note says `zeigt den älteren Stand <hash>`, the picture shows that older commit, not the current code (`git show <hash>:model.py`). Leave the images where they are.
- `[Auswahl: Bauteil "…", model.py Zeile …]`: the part the user clicked, with the lines of its `add_part` call and the clicked face.
- `[Build-Fehler: …]`: the message of the last failed build.
+
+The user can also edit files directly in the app's editor. Read a file again right before you change it, do not rely on an older copy.
diff --git a/app/src/main/build.ts b/app/src/main/build.ts
index 710dd76..5e097fb 100644
--- a/app/src/main/build.ts
+++ b/app/src/main/build.ts
@@ -27,8 +27,15 @@ export class BuildManager extends EventEmitter {
constructor(private readonly dir: string) { super(); }
- /** Dateiaenderung im Projekt gemeldet. Ohne Auto-Build merkt sich der Stand nur, dass er veraltet ist. */
- sourceChanged(): void {
+ /**
+ * Dateiaenderung im Projekt gemeldet. Ohne Auto-Build merkt sich der Stand nur, dass er veraltet ist.
+ * Stammt die Aenderung von vor dem Start des laufenden Builds (Speichern im Editor, direkt danach gebaut), steckt sie
+ * schon darin: kein zweiter Build. Das Ereignis des Watchers kommt oft erst nach dem Start an.
+ */
+ sourceChanged(file: string | null = null): void {
+ if (file && this.proc && this.status.startedAt) {
+ try { if (fs.statSync(file).mtimeMs <= this.status.startedAt) return; } catch { /* Datei weg: normal weiter */ }
+ }
if (this.autoBuild) this.schedule('Dateiänderung');
else if (!this.status.stale) this.setStatus({ ...this.status, stale: true });
}
diff --git a/app/src/main/files.ts b/app/src/main/files.ts
index 76002df..1f35356 100644
--- a/app/src/main/files.ts
+++ b/app/src/main/files.ts
@@ -1,6 +1,7 @@
import fs from 'node:fs';
import path from 'node:path';
-import type { FeedbackResult, FileNode, ImportResult } from '../shared/types';
+import { readOnlyReason } from '../shared/editable';
+import type { FeedbackResult, FileNode, ImportResult, WriteResult } from '../shared/types';
const HIDDEN = new Set(['.git', '.cadide', '__pycache__', 'node_modules', '.venv', 'venv', 'env']);
const MAX_ENTRIES = 2000;
@@ -57,6 +58,49 @@ export function saveFeedbackImage(root: string, png: unknown, when = new Date())
} catch (e) { return { ok: false, error: e instanceof Error ? e.message : String(e) }; }
}
+/**
+ * Schreibt eine Datei aus dem Editor. Agent und Nutzer arbeiten an denselben Dateien: Weicht der Inhalt auf der Platte
+ * von `base` ab (dem Stand, den der Editor zuletzt gelesen oder geschrieben hat), wird nicht geschrieben, sondern
+ * der Konflikt gemeldet. Mit `force` wird trotzdem geschrieben, die Fassung auf der Platte wandert vorher nach `backupDir`.
+ */
+export function writeProjectText(root: string, rel: string, text: string, base: string | null, force: boolean, backupDir: string): WriteResult {
+ try {
+ const abs = resolveInside(root, rel);
+ const clean = path.relative(fs.realpathSync(root), path.join(fs.realpathSync(path.dirname(abs)), path.basename(abs)));
+ const locked = readOnlyReason(clean);
+ if (locked) return { ok: false, error: `${rel} lässt sich hier nicht bearbeiten. ${locked}` };
+ let disk: string | null = null;
+ try { disk = fs.readFileSync(abs, 'utf8'); } catch (e) { if ((e as NodeJS.ErrnoException).code !== 'ENOENT') throw e; }
+ if (disk !== base && !force) return { ok: false, conflict: true, disk };
+ let backup: string | undefined;
+ if (force && disk !== null && disk !== text) backup = backupText(backupDir, rel, disk);
+ // Erst in eine Nebendatei, dann umbenennen: Ein Build liest so nie eine halb geschriebene Datei.
+ // Hält ein anderes Programm die Datei offen (Windows), klappt das Umbenennen nicht, dann direkt schreiben.
+ const tmp = `${abs}.cadide-tmp`;
+ try {
+ fs.writeFileSync(tmp, text, 'utf8');
+ fs.renameSync(tmp, abs);
+ } catch {
+ try { fs.rmSync(tmp, { force: true }); } catch { /* bleibt liegen, stört nicht */ }
+ fs.writeFileSync(abs, text, 'utf8');
+ }
+ return { ok: true, backup };
+ } catch (e) { return { ok: false, error: e instanceof Error ? e.message : String(e) }; }
+}
+
+/** Legt einen Text als Sicherung ab (Name mit Zeitstempel und Pfad) und gibt den Pfad zurück. Nichts wird überschrieben. */
+export function backupText(backupDir: string, rel: string, text: string): string {
+ fs.mkdirSync(backupDir, { recursive: true });
+ const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+ const name = rel.replace(/[\\/:*?"<>|]/g, '_');
+ for (let i = 1; ; i++) {
+ const file = path.join(backupDir, `${stamp}${i > 1 ? `-${i}` : ''}-${name}`);
+ try { fs.writeFileSync(file, text, { encoding: 'utf8', flag: 'wx' }); return file; } catch (e) {
+ if ((e as NodeJS.ErrnoException).code !== 'EEXIST' || i > 99) throw e;
+ }
+ }
+}
+
const exists = (p: string) => { try { fs.lstatSync(p); return true; } catch { return false; } };
/**
diff --git a/app/src/main/main.ts b/app/src/main/main.ts
index 3a045ce..2dafaa6 100644
--- a/app/src/main/main.ts
+++ b/app/src/main/main.ts
@@ -2,11 +2,11 @@ import { app, BrowserWindow, dialog, ipcMain, type WebContents } from 'electron'
import fs from 'node:fs';
import path from 'node:path';
import { detectAgents } from './agents';
-import { setTestAnswers } from './dialogs';
-import { importInputs, listFiles, resolveInside, saveFeedbackImage } from './files';
+import { choose, setTestAnswers } from './dialogs';
+import { backupText, importInputs, listFiles, resolveInside, saveFeedbackImage, writeProjectText } from './files';
import { ProjectController } from './projects';
import { terminalEnv } from './terminals';
-import { thumbnailsDir } from './paths';
+import { editBackupsDir, thumbnailsDir } from './paths';
import { createProject, getLastProject, isProjectId } from './workspace';
// App-Daten (Arbeitsordner, Caches) gehören auf die lokale Platte. Das Roaming-Profil (%APPDATA%) kann in Firmennetzen
@@ -51,6 +51,19 @@ function registerIpc(ctl: ProjectController): void {
ipcMain.handle('fs:list', () => listFiles(dir()));
ipcMain.handle('fs:import', (_e, paths: string[]) => importInputs(dir(), Array.isArray(paths) ? paths.map(String) : []));
ipcMain.handle('fs:saveFeedback', (_e, png: unknown) => saveFeedbackImage(dir(), png));
+ ipcMain.handle('fs:writeText', (_e, id: string, rel: string, text: string, base: string | null, force?: boolean) => {
+ const s = ctl.session;
+ // Späte Eingabe aus einem schon gewechselten Modell: nicht ins falsche Projekt schreiben, aber auch nicht verlieren
+ if (!s || s.id !== id) {
+ if (!isProjectId(String(id))) return { ok: false, error: 'Unbekanntes Modell.' };
+ return { ok: false, error: `Das Modell wurde inzwischen gewechselt. Die Änderung liegt als Sicherung unter ${backupText(editBackupsDir(id), String(rel), String(text))}` };
+ }
+ return writeProjectText(s.dir, String(rel), String(text), base == null ? null : String(base), !!force, editBackupsDir(s.id));
+ });
+ ipcMain.handle('fs:backupText', (_e, id: string, rel: string, text: string) => {
+ if (!isProjectId(String(id))) throw new Error('Unbekanntes Modell.');
+ return backupText(editBackupsDir(String(id)), String(rel), String(text));
+ });
ipcMain.handle('fs:readText', (_e, rel: string) => fs.readFileSync(resolveInside(dir(), rel), 'utf8'));
ipcMain.handle('fs:readBinary', (_e, rel: string) => {
const b = fs.readFileSync(resolveInside(dir(), rel));
@@ -63,6 +76,12 @@ function registerIpc(ctl: ProjectController): void {
ipcMain.on('term:kill', (_e, id: number) => ctl.session?.terminals.kill(id));
ipcMain.handle('agents:detect', () => detectAgents(terminalEnv(dir())));
+ // Rückfragen aus dem Renderer (etwa ungespeicherte Eingaben im Editor) laufen über dieselben Dialoge wie im Hauptprozess
+ ipcMain.handle('dialog:choose', (_e, o: { title?: unknown; message?: unknown; detail?: unknown; buttons?: unknown }) => {
+ const buttons = Array.isArray(o?.buttons) ? o.buttons.slice(0, 4).map(String) : [];
+ if (!buttons.length) return -1;
+ return choose(win, { title: String(o.title ?? 'CAD-IDE'), message: String(o.message ?? ''), detail: o.detail == null ? undefined : String(o.detail), buttons });
+ });
// Nur im Testmodus: vorbereitete Antworten für Dialoge (siehe dialogs.ts)
if (process.env.CADIDE_TEST === '1') {
@@ -89,6 +108,27 @@ function onRendererGone(wc: WebContents, reason: string, exitCode: number): void
void wc;
}
+let editorReq = 0;
+/**
+ * Fragt den Editor im Renderer: `status` (welche Dateien ungespeichert sind), `save` (speichern), `discard` (verwerfen,
+ * vorher sichern). Antwortet er nicht in 5 s, gilt `fallback`.
+ */
+function askEditor<T>(wc: WebContents, action: 'status' | 'save' | 'discard', fallback: T): Promise<T> {
+ return new Promise((resolve) => {
+ if (wc.isDestroyed()) { resolve(fallback); return; }
+ const id = ++editorReq;
+ const done = (_e: unknown, rid: number, result: unknown) => {
+ if (rid !== id) return;
+ clearTimeout(timer);
+ ipcMain.removeListener('editor:res', done);
+ resolve((result ?? fallback) as T);
+ };
+ const timer = setTimeout(() => { ipcMain.removeListener('editor:res', done); resolve(fallback); }, 5000);
+ ipcMain.on('editor:res', done);
+ wc.send('editor:req', id, action);
+ });
+}
+
/** Tests: CADIDE_HIDDEN=1 unsichtbar (zeichnet nicht neu), =offscreen angezeigt, aber weit außerhalb des Bildschirms und ohne Fokus. */
const testWindowMode = process.env.CADIDE_HIDDEN;
@@ -119,12 +159,20 @@ function createWindow(): void {
});
win.loadFile(path.join(__dirname, '..', 'renderer', 'index.html'));
- // Schließen: bei ungespeicherten Änderungen nachfragen (der Arbeitsstand bleibt in jedem Fall erhalten)
+ // Schließen: bei ungespeicherten Änderungen (im Modell oder im Editor) nachfragen. Der Arbeitsstand bleibt in jedem Fall erhalten.
let allowClose = false;
win.on('close', (e) => {
if (allowClose) return;
e.preventDefault();
- void ctl.confirmClose().then((ok) => { if (ok) { allowClose = true; win?.close(); } });
+ void (async () => {
+ const st = await askEditor<{ dirty?: string[] }>(wc, 'status', {});
+ const ok = await ctl.confirmClose({
+ dirty: Array.isArray(st.dirty) ? st.dirty.map(String) : [],
+ save: async () => !!(await askEditor<{ ok?: boolean }>(wc, 'save', { ok: false })).ok,
+ discard: async () => { await askEditor(wc, 'discard', {}); },
+ });
+ if (ok) { allowClose = true; win?.close(); }
+ })();
});
win.on('closed', () => { ctl.close(); win = null; });
}
diff --git a/app/src/main/paths.ts b/app/src/main/paths.ts
index 8bdf368..abaaf0f 100644
--- a/app/src/main/paths.ts
+++ b/app/src/main/paths.ts
@@ -13,6 +13,8 @@ export const projectStateDir = () => path.join(userDataDir(), 'projects');
export const appStateFile = () => path.join(userDataDir(), 'state.json');
/** Gesicherte Arbeitsordner (wenn eine ZIP den Arbeitsstand ersetzt). */
export const backupsDir = () => path.join(userDataDir(), 'workspace-backups');
+/** Sicherungen aus dem Editor (Fassungen, die bei einem Konflikt ersetzt wurden), je Projekt. */
+export const editBackupsDir = (id: string) => path.join(backupsDir(), `${id}-editor`);
/** Vorschauen alter Stände (aus dem Verlauf erzeugt, jederzeit neu erzeugbar). */
export const previewsDir = () => path.join(userDataDir(), 'previews');
/** Vorschaubilder für die Startseite (vom Viewer nach dem Laden des Modells, jederzeit neu erzeugbar). */
diff --git a/app/src/main/projects.ts b/app/src/main/projects.ts
index 2b67a31..249f52c 100644
--- a/app/src/main/projects.ts
+++ b/app/src/main/projects.ts
@@ -68,7 +68,7 @@ export class ProjectController {
const terminals = new TerminalManager(this.wc, dir);
const git = new GitRepo(dir);
builds.on('status', (st) => this.send('build:status', st));
- const stopWatch = watchProject(dir, () => builds.sourceChanged(), () => this.send('fs:changed'));
+ const stopWatch = watchProject(dir, (rel) => builds.sourceChanged(rel ? path.join(dir, rel) : null), () => this.send('fs:changed'));
const session: Session = { id, dir, builds, terminals, git, stopWatch, signature: '', poll: setInterval(() => void this.pollGit(), POLL_MS) };
this.session = session;
setLastProject(id);
@@ -103,9 +103,11 @@ export class ProjectController {
async saveState(): Promise<SaveState> {
const s = this.need();
- const app = getAppState(s.id);
const hasRepo = await s.git.isRepo();
const st = hasRepo ? await s.git.status() : { dirty: false, changed: 0, head: null };
+ // Erst nach den Git-Abfragen lesen: Läuft währenddessen ein Speichern durch, wäre der Stand sonst veraltet, und eine
+ // Abfrage der Verlaufsleiste könnte nach der frischen Meldung noch „nicht gespeichert“ schicken
+ const app = getAppState(s.id);
let unsaved: boolean;
if (!app.zipPath) unsaved = true;
else if (hasRepo) unsaved = st.dirty || st.head !== (app.savedHead ?? null);
@@ -301,19 +303,27 @@ export class ProjectController {
// ---- Beenden ----------------------------------------------------------------------------------------------------
- /** Darf das Fenster schließen? Bei ungespeicherten Änderungen fragt die App. Der Arbeitsstand bleibt in jedem Fall erhalten. */
- async confirmClose(): Promise<boolean> {
+ /**
+ * Darf das Fenster schließen? Bei ungespeicherten Änderungen fragt die App. Der Arbeitsstand bleibt in jedem Fall erhalten,
+ * Eingaben im Editor (`editor.dirty`) aber nur, wenn sie gespeichert werden. „Nicht speichern“ legt sie als Sicherung ab.
+ */
+ async confirmClose(editor: { dirty: string[]; save(): Promise<boolean>; discard(): Promise<void> }): Promise<boolean> {
if (!this.session || process.env.CADIDE_TEST === '1') return true;
const st = await this.saveState();
- if (!st.unsaved) return true;
+ if (!st.unsaved && !editor.dirty.length) return true;
+ const inEditor = editor.dirty.length ? `Im Editor noch nicht gespeichert: ${editor.dirty.join(', ')}. ` : '';
const c = await choose(this.getWin(), {
title: 'CAD-IDE beenden',
message: 'Das Modell hat ungespeicherte Änderungen.',
- detail: 'Der Arbeitsstand bleibt auf diesem Rechner erhalten und wird beim nächsten Start wieder geöffnet. Die ZIP-Datei wird nur beim Speichern aktualisiert.',
+ detail: `${inEditor}Der Arbeitsstand bleibt auf diesem Rechner erhalten und wird beim nächsten Start wieder geöffnet. Die ZIP-Datei wird nur beim Speichern aktualisiert.`,
buttons: ['Speichern', 'Nicht speichern', 'Abbrechen'],
});
if (c === 2) return false;
- if (c === 0) { const r = await this.save(false); if (r.cancelled || r.error) return false; }
+ if (c === 0) {
+ if (!(await editor.save())) return false;
+ const r = await this.save(false);
+ if (r.cancelled || r.error) return false;
+ } else await editor.discard();
return true;
}
}
diff --git a/app/src/main/watcher.ts b/app/src/main/watcher.ts
index 6596de6..06475fb 100644
--- a/app/src/main/watcher.ts
+++ b/app/src/main/watcher.ts
@@ -1,25 +1,26 @@
import fs from 'node:fs';
+import { affectsBuild } from '../shared/editable';
/** Ordner, die nie einen Build oder eine Neuanzeige der Dateiliste ausloesen (Ausgaben wuerden sich sonst selbst anstossen). */
const IGNORED_TOP = new Set(['.git', '.cadide', 'output', 'exports', '__pycache__', 'node_modules', '.venv', 'venv', 'env']);
const topSegment = (rel: string) => rel.split(/[\\/]/)[0] ?? '';
const isIgnored = (rel: string) => IGNORED_TOP.has(topSegment(rel)) || rel.split(/[\\/]/).includes('__pycache__');
-/** Quelltext-Aenderung: Python-Dateien und alles in inputs/ (mitgebrachte STEP-Dateien). */
-const isSource = (rel: string) => rel.endsWith('.py') || topSegment(rel) === 'inputs';
+/** Quelltext-Aenderung: dieselbe Regel wie beim Speichern im Editor (src/shared/editable.ts). */
+const isSource = affectsBuild;
/**
* Beobachtet den Projektordner. `onSource` bei relevanten Aenderungen (fuer Auto-Build), `onFiles` fuer die Dateiliste.
* Gibt eine Funktion zum Beenden zurueck. Fehler des Watchers werden verschluckt: ohne Watcher bleibt der Knopf.
*/
-export function watchProject(dir: string, onSource: () => void, onFiles: () => void): () => void {
+export function watchProject(dir: string, onSource: (rel: string | null) => void, onFiles: () => void): () => void {
let filesTimer: NodeJS.Timeout | null = null;
let watcher: fs.FSWatcher | null = null;
try {
watcher = fs.watch(dir, { recursive: true }, (_evt, filename) => {
const rel = filename ? String(filename) : '';
if (rel && isIgnored(rel)) return;
- if (!rel || isSource(rel)) onSource();
+ if (!rel || isSource(rel)) onSource(rel || null);
if (filesTimer) clearTimeout(filesTimer);
filesTimer = setTimeout(onFiles, 250);
});
diff --git a/app/src/preload/preload.ts b/app/src/preload/preload.ts
index 91e1146..462932a 100644
--- a/app/src/preload/preload.ts
+++ b/app/src/preload/preload.ts
@@ -40,6 +40,11 @@ const api: CadideApi = {
// Der Renderer kennt keine Dateipfade. Nur die Pfade gezogener Dateien gehen an den Hauptprozess, der prüft und kopiert.
importFiles: (files) => ipcRenderer.invoke('fs:import', files.map((f) => webUtils.getPathForFile(f)).filter(Boolean)),
saveFeedback: (png) => ipcRenderer.invoke('fs:saveFeedback', png),
+ writeText: (id, rel, text, base, force) => ipcRenderer.invoke('fs:writeText', id, rel, text, base, force),
+ backupText: (id, rel, text) => ipcRenderer.invoke('fs:backupText', id, rel, text),
+ onEditorRequest: (cb) => {
+ ipcRenderer.on('editor:req', async (_e, id: number, action: 'status' | 'save' | 'discard') => ipcRenderer.send('editor:res', id, await cb(action).catch(() => null)));
+ },
},
term: {
create: (opts) => ipcRenderer.invoke('term:create', opts),
@@ -50,6 +55,7 @@ const api: CadideApi = {
onExit: (cb) => { ipcRenderer.on('term:exit', (_e, id, code) => cb(id, code)); },
},
agents: { detect: () => ipcRenderer.invoke('agents:detect') },
+ dialog: { choose: (o) => ipcRenderer.invoke('dialog:choose', o) },
// Nur im Testmodus: vorbereitete Antworten für native Dialoge
test: process.env.CADIDE_TEST === '1'
? { answers: (a) => ipcRenderer.invoke('test:answers', a), screenshot: (f) => ipcRenderer.invoke('test:screenshot', f) }
diff --git a/app/src/renderer/code.ts b/app/src/renderer/code.ts
index 2ebfee2..1a86f52 100644
--- a/app/src/renderer/code.ts
+++ b/app/src/renderer/code.ts
@@ -1,7 +1,20 @@
+import { closeBrackets, closeBracketsKeymap } from '@codemirror/autocomplete';
+import { defaultKeymap, history, historyKeymap, indentWithTab } from '@codemirror/commands';
+import { python } from '@codemirror/lang-python';
+import { bracketMatching, HighlightStyle, indentOnInput, indentUnit, syntaxHighlighting } from '@codemirror/language';
+import { highlightSelectionMatches, search, searchKeymap } from '@codemirror/search';
+import { Annotation, EditorState, RangeSetBuilder, StateEffect, StateField, Transaction, type Extension, type TransactionSpec } from '@codemirror/state';
+import {
+ Decoration, drawSelection, EditorView, highlightActiveLine, highlightActiveLineGutter, highlightSpecialChars, keymap, lineNumbers,
+ MatchDecorator, ViewPlugin, type DecorationSet, type ViewUpdate,
+} from '@codemirror/view';
+import { tags as t } from '@lezer/highlight';
+import { affectsBuild, readOnlyReason } from '../shared/editable';
import { icon } from './icons';
import { el } from './ui';
-// Einfache Python-Hervorhebung pro Zeile. Mehrzeilige Strings färbt sie nur zeilenweise, das reicht zum Lesen.
+// Einfache Python-Hervorhebung pro Zeile für Codeausschnitte (Auswahl- und Fehlerkarte). Der Editor färbt über CodeMirror,
+// mit denselben Klassen k-*, damit beides gleich aussieht.
const TOKEN = /(#.*$)|("""[^]*?"""|'''[^]*?'''|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')|\b(def|class|return|import|from|as|for|in|if|elif|else|while|with|try|except|finally|lambda|and|or|not|is|None|True|False|pass|break|continue|yield|raise|global|nonlocal|assert|del)\b|\b([A-Z][A-Z0-9_]{2,})\b|\b(\d+(?:\.\d+)?)\b|\b([A-Za-z_]\w*)(?=\()/g;
/** Eine Codezeile als DOM-Knoten (nur textContent, der Code kommt aus dem Projekt). */
@@ -30,83 +43,469 @@ export function codeRows(lines: string[], firstNo: number, mark?: { from: number
});
}
-const MAX_LINES = 5000;
+// ---- Editor ---------------------------------------------------------------------------------------------------------
-interface Mark { from: number; to: number; label: string; color?: string }
+const MAX_EDIT_CHARS = 2_000_000;
+
+export interface Mark { from: number; to: number; label: string; color?: string; kind?: 'hl' | 'er' }
+
+interface Doc {
+ file: string;
+ state: EditorState;
+ /** Inhalt auf der Platte beim letzten Lesen oder Schreiben, mit den Zeilenenden der Datei. Grundlage der Konfliktprüfung. */
+ base: string;
+ eol: '\n' | '\r\n';
+ /** Grund, warum die Datei nur lesbar ist, sonst null. */
+ locked: string | null;
+ /** Der Text weicht vom gespeicherten Stand ab. */
+ dirty: boolean;
+ writing: boolean;
+ /** Schreibvorgänge je Datei laufen nacheinander. */
+ queue: Promise<unknown>;
+ /** Die Datei wurde außerhalb geändert (disk) oder gelöscht (null), während hier ungesicherte Eingaben lagen. */
+ conflict: { disk: string | null } | null;
+ mark: Mark | null;
+ scrollTop: number;
+}
+
+interface Ui { tabs: HTMLElement; info: HTMLElement; banner: HTMLElement; view: HTMLElement; link: HTMLButtonElement }
+interface Deps {
+ /** Liest eine Datei frisch von der Platte (ohne Zwischenspeicher). */
+ read(rel: string): Promise<string>;
+ projectId(): string | null;
+ toast(text: string, kind?: 'ok' | 'info' | 'error'): void;
+ /** Rückfrage mit Knöpfen, liefert den Index (letzter Knopf: Abbrechen). */
+ ask(o: { title: string; message: string; detail?: string; buttons: string[] }): Promise<number>;
+ /** Die Menge der ungespeicherten Dateien hat sich geändert (für den Speicherstand oben). */
+ changed(): void;
+ /** Knopf „Speichern und bauen“ (wie Strg+S im Editor). */
+ saveAndBuild(): void;
+ /** Nach dem Speichern einer einzelnen Datei, die das Modell betrifft (Konflikt gelöst, Reiter geschlossen): bauen. */
+ build(): void;
+}
+
+/** Änderungen, die von außen kommen (Agent, Wiederherstellen). Sie machen die Datei nicht „ungesichert“ und landen nicht im Rückgängig. */
+const External = Annotation.define<boolean>();
+
+const setMark = StateEffect.define<{ from: number; to: number; kind: 'hl' | 'er' } | null>();
+const markField = StateField.define<DecorationSet>({
+ create: () => Decoration.none,
+ update(deco, tr) {
+ deco = deco.map(tr.changes);
+ for (const e of tr.effects) if (e.is(setMark)) deco = e.value ? lineMarks(tr.state, e.value) : Decoration.none;
+ return deco;
+ },
+ provide: (f) => EditorView.decorations.from(f),
+});
+
+function lineMarks(state: EditorState, m: { from: number; to: number; kind: 'hl' | 'er' }): DecorationSet {
+ const b = new RangeSetBuilder<Decoration>();
+ for (let n = Math.max(1, m.from); n <= Math.min(m.to, state.doc.lines); n++) b.add(state.doc.line(n).from, state.doc.line(n).from, Decoration.line({ class: `cm-mark-${m.kind}` }));
+ return b.finish();
+}
+
+// Parameter als Konstanten in Großbuchstaben (LENGTH, WALL) hervorheben: Die Vorlage und AGENTS.md setzen darauf
+const CONSTANT = new MatchDecorator({ regexp: /\b[A-Z][A-Z0-9_]{2,}\b/g, decoration: Decoration.mark({ class: 'k-num' }) });
+const constants = ViewPlugin.fromClass(class {
+ decorations: DecorationSet;
+ constructor(v: EditorView) { this.decorations = CONSTANT.createDeco(v); }
+ update(u: ViewUpdate) { this.decorations = CONSTANT.updateDeco(u, this.decorations); }
+}, { decorations: (p) => p.decorations });
+
+const HIGHLIGHT = HighlightStyle.define([
+ { tag: [t.keyword, t.controlKeyword, t.definitionKeyword, t.moduleKeyword, t.operatorKeyword, t.bool, t.null, t.self], class: 'k-kw' },
+ { tag: [t.string, t.special(t.string), t.docString], class: 'k-str' },
+ { tag: t.number, class: 'k-num' },
+ { tag: [t.comment, t.lineComment], class: 'k-cm' },
+ { tag: [t.function(t.variableName), t.function(t.propertyName), t.function(t.definition(t.variableName)), t.definition(t.className)], class: 'k-fn' },
+]);
+
+const PHRASES = {
+ 'Find': 'Suchen', 'Replace': 'Ersetzen', 'next': 'weiter', 'previous': 'zurück', 'all': 'alle', 'match case': 'Groß/klein',
+ 'by word': 'ganzes Wort', 'regexp': 'Regex', 'replace': 'ersetzen', 'replace all': 'alle ersetzen', 'close': 'schließen',
+ 'current match': 'aktueller Treffer', 'on line': 'in Zeile', 'replaced match on line $': 'Treffer in Zeile $ ersetzt',
+ 'replaced $ matches': '$ Treffer ersetzt', 'Go to line': 'Gehe zu Zeile', 'go': 'los', 'Control character': 'Steuerzeichen',
+};
+
+const errText = (e: unknown) => (e instanceof Error ? e.message : String(e));
/**
- * Code-Panel (nur lesen). Offene Dateien als Reiter, die Auswahl im Viewer springt zur Codestelle, solange
- * „Mit Auswahl verknüpft“ an ist. Bearbeiten übernimmt der Agent. Ein Editor kommt in einem späteren Schritt.
+ * Code-Panel mit Editor (CodeMirror 6). Offene Dateien als Reiter, die Auswahl im Viewer springt zur Codestelle, solange
+ * „Mit Auswahl verknüpft“ an ist. Gespeichert wird nur auf Wunsch des Nutzers (Strg+S im Editor, „Speichern und bauen“,
+ * „Speichern“ oben), danach wird gebaut. Beim Tippen passiert nichts auf der Platte.
+ *
+ * Der Agent schreibt an denselben Dateien. Deshalb kennt jede Datei den Stand, den der Editor zuletzt von der Platte
+ * hatte (`base`). Ändert sie sich außen und hier liegt nichts Ungesichertes, übernimmt der Editor die neue Fassung.
+ * Liegt hier etwas Ungesichertes, wird nichts überschrieben: Der Nutzer entscheidet, welche Fassung gilt, die andere
+ * wandert in eine Sicherung (Grundsatz: nichts still überschreiben).
*/
export class CodePanel {
- private files: string[] = [];
+ private docs = new Map<string, Doc>();
+ private loading = new Map<string, Promise<Doc | null>>();
private active: string | null = null;
- private mark: (Mark & { file: string }) | null = null;
+ private view: EditorView;
+ private empty: HTMLElement;
+ private saveBtn: HTMLButtonElement;
linked = true;
- constructor(private ui: { tabs: HTMLElement; info: HTMLElement; view: HTMLElement; link: HTMLButtonElement }, private read: (rel: string) => Promise<string>) {
+ constructor(private ui: Ui, private deps: Deps) {
ui.link.addEventListener('click', () => {
this.linked = !this.linked;
ui.link.setAttribute('aria-pressed', String(this.linked));
});
+ this.view = new EditorView({ parent: ui.view, state: EditorState.create({ doc: '' }) });
+ this.empty = el('div', { className: 'hint', textContent: 'Keine Datei geöffnet. Klick auf ein Bauteil oder im Dateien-Panel auf eine Datei.' });
+ ui.view.append(this.empty);
+ this.saveBtn = el('button', { id: 'btn-code-save', className: 'btn sm acc', textContent: 'Speichern und bauen', title: 'Geänderte Dateien speichern und das Modell bauen (Strg+S im Editor). Die ZIP-Datei schreibt „Speichern“ oben.' });
+ this.saveBtn.addEventListener('click', () => deps.saveAndBuild());
+ this.renderChrome();
}
get activeFile(): string | null { return this.active; }
- async open(file: string, mark?: Mark): Promise<void> {
- if (!this.files.includes(file)) this.files.push(file);
- this.active = file;
- this.mark = mark ? { ...mark, file } : (this.mark?.file === file ? this.mark : null);
- await this.render(true);
+ async open(file: string, mark?: Mark, scroll = true): Promise<void> {
+ const d = this.docs.get(file) ?? (await this.load(file));
+ if (!d) return;
+ this.activate(d);
+ if (mark) this.setMarkOn(d, mark, scroll);
+ else if (d.mark && scroll) this.scrollTo(d, d.mark.from);
+ this.renderChrome();
}
- /** Auswahl im Viewer: nur folgen, wenn verknüpft. */
+ /** Auswahl im Viewer: nur folgen, wenn verknüpft. Während im Editor getippt wird, springt nichts, nur die Hervorhebung wandert mit. */
async follow(file: string, mark: Mark): Promise<void> {
- if (this.linked) await this.open(file, mark);
+ if (!this.linked) return;
+ const d = this.docs.get(file);
+ if (this.view.hasFocus) { if (d) { this.setMarkOn(d, mark, false); this.renderChrome(); } return; }
+ const same = d?.mark && d.mark.from === mark.from && d.mark.to === mark.to && this.active === file;
+ await this.open(file, mark, !same);
+ }
+
+ /** Nach Dateiänderungen: offene Dateien mit der Platte abgleichen. */
+ async refresh(): Promise<void> {
+ for (const d of [...this.docs.values()]) {
+ if (d.writing) continue;
+ let disk: string | null;
+ try { disk = await this.deps.read(d.file); } catch { disk = null; }
+ if (this.docs.get(d.file) !== d || d.writing || disk === d.base) continue;
+ // Hier liegt Ungespeichertes oder die Datei ist weg: nicht still ersetzen, sondern fragen
+ if (d.dirty || disk === null) d.conflict = { disk };
+ else this.takeExternal(d, disk);
+ }
+ this.renderChrome();
+ this.deps.changed();
+ }
+
+ /** Dateien mit ungespeicherten Eingaben (auch solche mit Konflikt). */
+ unsaved(): string[] { return [...this.docs.values()].filter((d) => d.dirty || d.conflict).map((d) => d.file); }
+
+ /**
+ * Ungespeicherte Dateien schreiben (Strg+S, Knöpfe, vor dem Bauen). `ok` ist false, wenn etwas nicht geschrieben
+ * werden konnte, etwa wegen eines Konflikts: Dann soll auch nicht gebaut oder als ZIP gespeichert werden.
+ */
+ async saveAll(): Promise<{ ok: boolean; saved: string[] }> {
+ const saved: string[] = [];
+ let ok = true;
+ for (const d of [...this.docs.values()]) {
+ if (d.conflict) { ok = false; continue; }
+ if (!d.dirty) continue;
+ if (await this.write(d)) saved.push(d.file); else ok = false;
+ }
+ return { ok, saved };
+ }
+
+ /** Ungespeicherte Eingaben verwerfen. Vorher kommt jede in eine Sicherung. Ohne Sicherung wird nichts verworfen. */
+ async discardAll(): Promise<boolean> {
+ for (const d of [...this.docs.values()]) {
+ if (!d.dirty && !d.conflict) continue;
+ if (!(await this.backup(d))) return false;
+ if (d.conflict?.disk === null) { this.docs.delete(d.file); if (this.active === d.file) this.active = null; continue; }
+ this.takeExternal(d, d.conflict ? d.conflict.disk! : d.base);
+ }
+ if (!this.active) { const next = [...this.docs.values()].pop(); if (next) this.activate(next); else this.view.setState(EditorState.create({ doc: '' })); }
+ this.renderChrome();
+ this.deps.changed();
+ return true;
+ }
+
+ reset(): void {
+ this.docs.clear();
+ this.loading.clear();
+ this.active = null;
+ this.view.setState(EditorState.create({ doc: '' }));
+ this.renderChrome();
+ }
+
+ /** Text der aktiven Datei (für Tests und Anzeigen). */
+ text(): string { return this.active ? this.docs.get(this.active)?.state.doc.toString() ?? '' : ''; }
+
+ // ---- Laden und Anzeigen ---------------------------------------------------------------------------------------
+
+ private load(file: string): Promise<Doc | null> {
+ let p = this.loading.get(file);
+ if (!p) {
+ p = (async () => {
+ let text: string;
+ try { text = await this.deps.read(file); } catch (e) { this.deps.toast(`${file} lässt sich nicht lesen: ${errText(e)}`, 'error'); return null; }
+ const locked = readOnlyReason(file)
+ ?? (text.length > MAX_EDIT_CHARS ? 'Zu groß zum Bearbeiten (über 2 MB).' : null)
+ ?? (text.includes('\uFFFD') ? 'Nicht als UTF-8 lesbar. Bearbeiten würde die Datei beschädigen.' : null);
+ const d: Doc = { file, base: text, eol: text.includes('\r\n') ? '\r\n' : '\n', locked, dirty: false, writing: false, queue: Promise.resolve(), conflict: null, mark: null, scrollTop: 0, state: null! };
+ d.state = EditorState.create({ doc: text, extensions: this.extensions(d) });
+ this.docs.set(file, d);
+ return d;
+ })().finally(() => this.loading.delete(file));
+ this.loading.set(file, p);
+ }
+ return p;
+ }
+
+ private extensions(d: Doc): Extension[] {
+ const py = /\.py$/i.test(d.file);
+ return [
+ lineNumbers(), highlightActiveLineGutter(), highlightSpecialChars(), history(), drawSelection(), indentOnInput(),
+ syntaxHighlighting(HIGHLIGHT), bracketMatching(), closeBrackets(), highlightActiveLine(), highlightSelectionMatches(), search({ top: false }),
+ py ? [python(), constants] : [],
+ indentUnit.of(' '), EditorState.tabSize.of(4), EditorState.phrases.of(PHRASES), EditorState.readOnly.of(!!d.locked),
+ keymap.of([...closeBracketsKeymap, ...defaultKeymap, ...searchKeymap, ...historyKeymap, indentWithTab]),
+ markField,
+ EditorView.updateListener.of((u) => this.onUpdate(d, u)),
+ ];
+ }
+
+ private onUpdate(d: Doc, u: ViewUpdate): void {
+ d.state = u.state;
+ if (!u.transactions.some((tr) => tr.docChanged && !tr.annotation(External))) return;
+ const was = d.dirty;
+ d.dirty = this.textOf(d) !== d.base; // zurück auf den gespeicherten Stand getippt: wieder gespeichert
+ this.renderChrome();
+ if (was !== d.dirty) this.deps.changed();
}
- clearMark(): void { this.mark = null; void this.render(false); }
+ private activate(d: Doc): void {
+ const prev = this.active ? this.docs.get(this.active) : undefined;
+ if (prev === d && this.view.state === d.state) return;
+ if (prev) prev.scrollTop = this.view.scrollDOM.scrollTop;
+ this.active = d.file;
+ this.view.setState(d.state);
+ this.view.scrollDOM.scrollTop = d.scrollTop;
+ }
- /** Nach Dateiänderungen neu lesen, Scrollposition bleibt. */
- async refresh(): Promise<void> { if (this.active) await this.render(false); }
+ /** Änderung auf Doc anwenden, egal ob es gerade im Editor steht. */
+ private apply(d: Doc, spec: TransactionSpec): void {
+ if (this.active === d.file && this.view.state === d.state) this.view.dispatch(spec);
+ else d.state = d.state.update(spec).state;
+ }
- reset(): void { this.files = []; this.active = null; this.mark = null; void this.render(false); }
+ private setMarkOn(d: Doc, mark: Mark, scroll: boolean): void {
+ d.mark = mark;
+ this.apply(d, { effects: setMark.of({ from: mark.from, to: mark.to, kind: mark.kind ?? 'hl' }) });
+ if (scroll) this.scrollTo(d, mark.from);
+ }
- private close(file: string): void {
- this.files = this.files.filter((f) => f !== file);
- if (this.active === file) this.active = this.files[this.files.length - 1] ?? null;
- if (this.mark?.file === file) this.mark = null;
- void this.render(false);
+ private scrollTo(d: Doc, line: number): void {
+ if (this.active !== d.file) return;
+ const pos = d.state.doc.line(Math.max(1, Math.min(line, d.state.doc.lines))).from;
+ this.view.dispatch({ effects: EditorView.scrollIntoView(pos, { y: 'center' }) });
}
- private async render(scroll: boolean): Promise<void> {
- const { tabs, info, view } = this.ui;
- tabs.replaceChildren(...this.files.map((f) => {
- const x = el('button', { className: 'x', title: `${f} schließen` }, icon('x', 11, 2.2));
- x.setAttribute('aria-label', `${f} schließen`);
- x.addEventListener('click', (e) => { e.stopPropagation(); this.close(f); });
- const t = el('div', { className: 'ctab' + (f === this.active ? ' on' : ''), title: f }, el('span', { textContent: f.split('/').pop()! }), x);
- t.addEventListener('click', () => { this.active = f; void this.render(true); });
- return t;
+ private async close(file: string): Promise<void> {
+ const d = this.docs.get(file);
+ if (!d) return;
+ if (d.dirty || d.conflict) {
+ const c = await this.deps.ask({
+ title: 'Datei schließen', message: `${file} hat ungespeicherte Änderungen.`,
+ detail: d.conflict ? 'Die Datei wurde außerdem außerhalb geändert. Verwerfen legt deine Fassung als Sicherung ab.' : 'Verwerfen legt deine Fassung als Sicherung ab.',
+ buttons: d.conflict ? ['Verwerfen', 'Abbrechen'] : ['Speichern', 'Verwerfen', 'Abbrechen'],
+ });
+ const choice = d.conflict ? (c === 0 ? 'discard' : 'cancel') : c === 0 ? 'save' : c === 1 ? 'discard' : 'cancel';
+ if (choice === 'cancel') return;
+ if (choice === 'save') { if (!(await this.write(d))) return; if (affectsBuild(d.file)) this.deps.build(); }
+ else if (!(await this.backup(d))) return;
+ }
+ this.docs.delete(file);
+ if (this.active === file) {
+ this.active = null;
+ const next = [...this.docs.values()].pop();
+ if (next) this.activate(next); else this.view.setState(EditorState.create({ doc: '' }));
+ }
+ this.renderChrome();
+ this.deps.changed();
+ }
+
+ // ---- Schreiben und Konflikte ----------------------------------------------------------------------------------
+
+ private textOf(d: Doc): string {
+ const s = d.state.doc.toString();
+ return d.eol === '\r\n' ? s.replace(/\n/g, '\r\n') : s; // Zeilenenden der Datei beibehalten, sonst änderte sich jede Zeile
+ }
+
+ /** Schreibt die Datei. Liefert true, wenn sie danach auf der Platte steht. */
+ private write(d: Doc, force = false): Promise<boolean> {
+ const p = d.queue.then(() => this.doWrite(d, force));
+ d.queue = p.catch(() => undefined);
+ return p;
+ }
+
+ private async doWrite(d: Doc, force: boolean): Promise<boolean> {
+ const id = this.deps.projectId();
+ if (!d.dirty) return true;
+ if (d.locked || (d.conflict && !force) || !id || this.docs.get(d.file) !== d) return false;
+ const text = this.textOf(d);
+ d.writing = true;
+ let r;
+ try { r = await window.cadide.fs.writeText(id, d.file, text, d.base, force); } catch (e) { r = { ok: false, error: errText(e) }; }
+ d.writing = false;
+ if (this.docs.get(d.file) !== d) return false;
+ if (r.ok) {
+ d.base = text;
+ d.conflict = null;
+ d.dirty = this.textOf(d) !== text; // während des Schreibens weitergetippt: bleibt ungespeichert
+ if (r.backup) this.deps.toast(`${d.file} gespeichert. Die Fassung von außen liegt als Sicherung unter ${r.backup}`, 'info');
+ } else if (r.conflict) {
+ d.conflict = { disk: r.disk ?? null };
+ } else this.deps.toast(`${d.file} ließ sich nicht speichern: ${r.error}`, 'error');
+ this.renderChrome();
+ this.deps.changed();
+ // Eine Änderung von außen kann während des Schreibens gekommen sein, ihr Ereignis wurde dann übersprungen
+ void this.refresh();
+ return !!r.ok;
+ }
+
+ /** Eigene Fassung als Sicherung ablegen (vor dem Verwerfen). Meldet den Pfad. */
+ private async backup(d: Doc): Promise<boolean> {
+ const id = this.deps.projectId();
+ if (!id) return false;
+ try {
+ const b = await window.cadide.fs.backupText(id, d.file, this.textOf(d));
+ this.deps.toast(`Deine Fassung von ${d.file} liegt als Sicherung unter ${b}`, 'info');
+ return true;
+ } catch (e) {
+ this.deps.toast(`${d.file} ließ sich nicht sichern, es wird nichts verworfen: ${errText(e)}`, 'error');
+ return false;
+ }
+ }
+
+ /** Neue Fassung von der Platte übernehmen. Nur der geänderte Teil wird ersetzt, damit Schreibmarke und Ansicht bleiben. */
+ private takeExternal(d: Doc, disk: string): void {
+ const next = disk.replace(/\r\n?/g, '\n');
+ const cur = d.state.doc.toString();
+ let a = 0;
+ while (a < cur.length && a < next.length && cur[a] === next[a]) a++;
+ let b = 0;
+ while (b < cur.length - a && b < next.length - a && cur[cur.length - 1 - b] === next[next.length - 1 - b]) b++;
+ if (a !== cur.length || a !== next.length) {
+ this.apply(d, { changes: { from: a, to: cur.length - b, insert: next.slice(a, next.length - b) }, annotations: [External.of(true), Transaction.addToHistory.of(false)] });
+ }
+ d.base = disk;
+ d.eol = disk.includes('\r\n') ? '\r\n' : '\n';
+ d.dirty = false;
+ d.conflict = null;
+ }
+
+ /** Konflikt: die Fassung aus dem Editor gilt. Die Fassung auf der Platte sichert der Hauptprozess vorher. */
+ async keepMine(file = this.active): Promise<void> {
+ const d = file ? this.docs.get(file) : undefined;
+ if (!d?.conflict) return;
+ d.conflict = null;
+ d.dirty = true;
+ if ((await this.write(d, true)) && affectsBuild(d.file)) this.deps.build();
+ }
+
+ /** Konflikt: die Fassung von außen gilt. Die eigene wird vorher gesichert, ohne Sicherung wird nichts verworfen. */
+ async takeTheirs(file = this.active): Promise<void> {
+ const d = file ? this.docs.get(file) : undefined;
+ if (!d?.conflict || !(await this.backup(d))) return;
+ const disk = d.conflict.disk;
+ if (disk === null) { d.conflict = null; d.dirty = false; await this.close(d.file); return; }
+ this.takeExternal(d, disk);
+ this.renderChrome();
+ this.deps.changed();
+ }
+
+ // ---- Oberfläche -----------------------------------------------------------------------------------------------
+
+ private renderChrome(): void {
+ const { tabs, info, banner } = this.ui;
+ tabs.replaceChildren(...[...this.docs.values()].map((d) => {
+ const x = el('button', { className: 'x', title: `${d.file} schließen` }, icon('x', 11, 2.2));
+ x.setAttribute('aria-label', `${d.file} schließen`);
+ x.addEventListener('click', (e) => { e.stopPropagation(); void this.close(d.file); });
+ const state = d.conflict ? el('span', { className: 'dirty warn', textContent: '●', title: 'Konflikt mit einer Änderung von außen' })
+ : d.dirty ? el('span', { className: 'dirty', textContent: '●', title: 'Nicht gespeichert' }) : null;
+ const tab = el('div', { className: 'ctab' + (d.file === this.active ? ' on' : ''), title: d.file }, el('span', { textContent: d.file.split('/').pop()! }), state, x);
+ tab.addEventListener('click', () => { this.activate(d); this.renderChrome(); });
+ return tab;
}));
- const m = this.mark && this.mark.file === this.active ? this.mark : null;
- if (m) {
- const sw = el('span', { className: 'sw' });
+
+ const d = this.active ? this.docs.get(this.active) : undefined;
+ this.view.dom.hidden = !d;
+ this.empty.hidden = !!d;
+ if (!d) { info.replaceChildren(); banner.hidden = true; return; }
+
+ const m = d.mark;
+ const left: (Node | string)[] = [];
+ if (d.locked) left.push(icon('lock', 13, 2), `Nur lesen. ${d.locked}`);
+ else if (m) {
+ const sw = m.kind === 'er' ? el('span', { className: 'ci-err' }, icon('alert', 13, 2)) : el('span', { className: 'sw' });
if (m.color) sw.style.background = m.color;
- info.replaceChildren(sw, `${m.label} · Zeile ${m.from}${m.to !== m.from ? '–' + m.to : ''}`);
- } else info.replaceChildren();
- if (!this.active) { view.replaceChildren(el('div', { className: 'ftree' }, el('div', { className: 'hint', textContent: 'Keine Datei geöffnet. Klick auf ein Bauteil oder im Dateien-Panel auf eine Datei.' }))); return; }
- const top = view.scrollTop;
- let text: string;
- try { text = await this.read(this.active); } catch (e) {
- view.replaceChildren(el('div', { className: 'hint', textContent: `${this.active} lässt sich nicht lesen: ${e instanceof Error ? e.message : String(e)}` }));
- return;
+ left.push(sw, `${m.label} · Zeile ${m.from}${m.to !== m.from ? '–' + m.to : ''}`);
+ }
+ // Ungespeichert (in irgendeiner Datei, ohne Konflikt): Hinweis und Knopf, gespeichert und gebaut wird erst auf Wunsch
+ const waiting = [...this.docs.values()].filter((x) => x.dirty && !x.conflict);
+ const pending = waiting.length > 0;
+ // Gebaut wird nur, wenn eine gespeicherte Datei das Modell betrifft. Sonst heißt der Knopf nur „Speichern“.
+ this.saveBtn.textContent = waiting.some((x) => affectsBuild(x.file)) ? 'Speichern und bauen' : 'Speichern';
+ const hint = !d.locked && d.dirty && !d.conflict ? el('span', { className: 'c3 ci-hint', textContent: 'Nicht gespeichert · Strg+S' }) : '';
+ if (left.length || pending) info.replaceChildren(el('span', { className: 'ci-main' }, ...left), el('span', { className: 'grow' }), hint, pending ? this.saveBtn : '');
+ else info.replaceChildren();
+ info.classList.toggle('locked', !!d.locked);
+
+ banner.hidden = !d.conflict;
+ if (d.conflict) {
+ const gone = d.conflict.disk === null;
+ const keep = el('button', { className: 'btn sm acc', textContent: gone ? 'Mit meiner Fassung neu anlegen' : 'Meine Fassung behalten' });
+ const take = el('button', { className: 'btn sm', textContent: gone ? 'Schließen' : 'Fassung von außen laden' });
+ keep.addEventListener('click', () => void this.keepMine(d.file));
+ take.addEventListener('click', () => void this.takeTheirs(d.file));
+ banner.replaceChildren(
+ el('span', { className: 'cb-ico' }, icon('alert', 16)),
+ el('div', { className: 'cb-text' },
+ el('b', { textContent: gone ? `${d.file} wurde außerhalb gelöscht` : `${d.file} wurde außerhalb geändert, vermutlich vom Agenten` }),
+ el('span', { textContent: 'Deine Eingaben hier sind noch nicht gespeichert. Die Fassung, die du nicht wählst, kommt in eine Sicherung.' }),
+ el('div', { className: 'cb-actions' }, keep, take)));
}
- const lines = text.split(/\r?\n/);
- const shown = lines.slice(0, MAX_LINES);
- view.replaceChildren(...codeRows(shown, 1, m ? { from: m.from, to: m.to, kind: 'hl' } : undefined));
- if (lines.length > MAX_LINES) view.append(el('div', { className: 'hint', textContent: `Nur die ersten ${MAX_LINES} von ${lines.length} Zeilen.` }));
- if (scroll && m) view.querySelector<HTMLElement>(`.cl[data-line="${m.from}"]`)?.scrollIntoView({ block: 'center' });
- else view.scrollTop = top;
+ }
+
+ // ---- Prüfhilfen (nur für Tests) -------------------------------------------------------------------------------
+
+ testApi() {
+ return {
+ state: () => {
+ const d = this.active ? this.docs.get(this.active) : undefined;
+ return {
+ file: this.active, files: [...this.docs.keys()], dirty: !!d?.dirty, conflict: d?.conflict ? (d.conflict.disk === null ? 'gone' : 'changed') : null,
+ locked: d?.locked ?? null, readOnly: this.view.state.readOnly, text: this.text(), focused: this.view.hasFocus, unsaved: this.unsaved(),
+ marked: [...this.ui.view.querySelectorAll('.cm-line.cm-mark-hl, .cm-line.cm-mark-er')].map((x) => (x.classList.contains('cm-mark-er') ? 'er:' : 'hl:') + x.textContent),
+ };
+ },
+ /** Wie Tippen: ersetzt den ersten Treffer im aktiven Dokument als Eingabe des Nutzers. */
+ replace: (find: string, repl: string) => {
+ const i = this.view.state.doc.toString().indexOf(find);
+ if (i < 0 || this.view.state.readOnly) return false;
+ this.view.dispatch({ changes: { from: i, to: i + find.length, insert: repl }, userEvent: 'input.type' });
+ return true;
+ },
+ focus: () => this.view.focus(),
+ /** Lage des Editors im Panel: füllt er die Höhe, und lässt er sich scrollen? */
+ layout: () => {
+ const e = this.view.dom.getBoundingClientRect(), v = this.ui.view.getBoundingClientRect(), s = this.view.scrollDOM;
+ return { editorTop: e.top, editorBottom: e.bottom, viewTop: v.top, viewBottom: v.bottom, scrollHeight: s.scrollHeight, clientHeight: s.clientHeight };
+ },
+ scrollToEnd: () => { this.view.scrollDOM.scrollTop = 1e7; return this.view.scrollDOM.scrollTop; },
+ blur: () => this.view.contentDOM.blur(),
+ keepMine: () => this.keepMine(),
+ takeTheirs: () => this.takeTheirs(),
+ };
}
}
diff --git a/app/src/renderer/index.html b/app/src/renderer/index.html
index 8aab8ea..409dc2d 100644
--- a/app/src/renderer/index.html
+++ b/app/src/renderer/index.html
@@ -32,7 +32,7 @@
<div id="body">
<nav id="rail" aria-label="Seitenleisten">
<button data-panel="files" aria-pressed="false" title="Dateien des Modells"><i data-icon="folder" data-size="20" data-stroke="1.7"></i><span>Dateien</span></button>
- <button data-panel="code" aria-pressed="false" title="Code ansehen"><i data-icon="code" data-size="20" data-stroke="1.7"></i><span>Code</span></button>
+ <button data-panel="code" aria-pressed="false" title="Code ansehen und bearbeiten"><i data-icon="code" data-size="20" data-stroke="1.7"></i><span>Code</span></button>
<button disabled title="Skills kommen in einem späteren Schritt"><i data-icon="book" data-size="20" data-stroke="1.7"></i><span>Skills</span></button>
<button disabled title="Die Paketliste kommt in einem späteren Schritt"><i data-icon="pkg" data-size="20" data-stroke="1.7"></i><span>Pakete</span></button>
<span class="grow"></span>
@@ -53,7 +53,8 @@
<button id="btn-codelink" class="btn sm ghost" aria-pressed="true" title="Klick auf ein Bauteil springt zur Codestelle"><i data-icon="link" data-size="14" data-stroke="1.9"></i>Mit Auswahl verknüpft</button>
<button class="ibtn s side-close" aria-label="Code schließen"><i data-icon="x" data-size="15" data-stroke="2"></i></button></div>
<div id="code-info" class="code-info"></div>
- <div id="code-view" class="codeview code"></div>
+ <div id="code-banner" class="code-banner" role="alert" hidden></div>
+ <div id="code-view" class="codeview"></div>
</section>
</aside>
<div class="splitter" id="split-side" hidden></div>
diff --git a/app/src/renderer/main.ts b/app/src/renderer/main.ts
index 8838ccb..2407165 100644
--- a/app/src/renderer/main.ts
+++ b/app/src/renderer/main.ts
@@ -1,5 +1,6 @@
+import { affectsBuild } from '../shared/editable';
import type { AgentInfo, BuildStatus, ModelMap, PartMap, PreviewResult, ProjectInfo, SaveState } from '../shared/types';
-import { CodePanel, codeRows } from './code';
+import { CodePanel, codeRows, type Mark } from './code';
import { FileTree, TEXT_EXT } from './filetree';
import { hydrateIcons, icon } from './icons';
import { Markup } from './markup';
@@ -62,9 +63,17 @@ function showPanel(p: PanelName | null): void {
if (p === 'files' && filesDirty) void refreshFiles();
}
-const code = new CodePanel({ tabs: $('code-tabs'), info: $('code-info'), view: $('code-view'), link: $<HTMLButtonElement>('btn-codelink') }, readText);
+const code = new CodePanel(
+ { tabs: $('code-tabs'), info: $('code-info'), banner: $('code-banner'), view: $('code-view'), link: $<HTMLButtonElement>('btn-codelink') },
+ {
+ read: (rel) => api.fs.readText(rel), projectId: () => project?.id ?? null, toast, ask: (o) => api.dialog.choose(o),
+ changed: () => { if (saveState) renderSaveState(saveState); },
+ saveAndBuild: () => void saveCode(),
+ build: () => void api.build.run(),
+ },
+);
-async function openCode(file: string, mark?: { from: number; to: number; label: string; color?: string }): Promise<void> {
+async function openCode(file: string, mark?: Mark): Promise<void> {
showPanel('code');
await code.open(file, mark);
}
@@ -370,6 +379,7 @@ const versions = new VersionsBar({
} catch (e) { toast(`Vorschau nicht darstellbar: ${e instanceof Error ? e.message : String(e)}`, 'error'); }
},
toast,
+ beforeRestore: () => leaveEditor('Stand wiederherstellen'), // Wiederherstellen ersetzt Dateien
});
// ---- Projekt ----------------------------------------------------------------------------------------------------
@@ -422,21 +432,52 @@ function renderSaveState(st: SaveState): void {
saveState = st;
const dot = el('span', { className: 'dot' });
let text: string;
+ // Ungespeichertes im Editor zählt mit, auch wenn die Dateien auf der Platte dem gespeicherten Stand entsprechen
+ const unsaved = st.unsaved || code.unsaved().length > 0;
if (!st.zipPath) { dot.style.background = 'var(--warn)'; text = 'Noch nicht gespeichert'; }
- else if (st.unsaved) { dot.style.background = 'var(--warn)'; text = `Nicht gespeichert${st.savedAt ? ` · zuletzt ${fmtWhen(st.savedAt)}` : ''}`; }
+ else if (unsaved) { dot.style.background = 'var(--warn)'; text = `Nicht gespeichert${st.savedAt ? ` · zuletzt ${fmtWhen(st.savedAt)}` : ''}`; }
else { dot.style.background = 'var(--ok)'; text = `Gespeichert${st.savedAt ? ` · ${fmtWhen(st.savedAt)}` : ''}`; }
const b = $('save-badge');
b.replaceChildren(dot, text);
b.title = st.zipPath ? `ZIP: ${st.zipPath}` : 'Noch nicht als ZIP gespeichert. Strg+S speichert.';
versions.setSaved(st.zipPath ? st.savedHead : null);
- document.title = `CAD-IDE – ${project?.name ?? ''}${st.unsaved ? ' ●' : ''}`;
+ document.title = `CAD-IDE – ${project?.name ?? ''}${unsaved ? ' ●' : ''}`;
}
async function refreshSaveState(): Promise<void> {
try { renderSaveState(await api.project.saveState()); } catch { /* Projekt wechselt gerade */ }
}
+/**
+ * Strg+S im Editor und „Speichern und bauen“: geänderte Dateien schreiben. Gebaut wird nur, wenn darunter eine ist,
+ * die das Modell betrifft (Python, inputs/). Keine ZIP, kein Snapshot, das macht „Speichern“ oben.
+ */
+async function saveCode(): Promise<void> {
+ const r = await code.saveAll();
+ if (!r.ok) { toast('Nicht alles ließ sich speichern (siehe Hinweis im Code-Panel). Gebaut wird erst danach.', 'error'); return; }
+ if (r.saved.some(affectsBuild)) await api.build.run();
+}
+
+/** Vor Modellwechsel und Wiederherstellen: ungespeicherte Eingaben im Editor nicht still verlieren. false = abbrechen. */
+async function leaveEditor(title: string): Promise<boolean> {
+ const files = code.unsaved();
+ if (!files.length) return true;
+ const c = await api.dialog.choose({
+ title, message: `Im Editor gibt es ungespeicherte Änderungen: ${files.join(', ')}.`,
+ detail: 'Verwerfen legt deine Fassung als Sicherung in den App-Daten ab.', buttons: ['Speichern', 'Verwerfen', 'Abbrechen'],
+ });
+ if (c === 0) {
+ const r = await code.saveAll();
+ if (!r.ok) toast('Nicht alles ließ sich speichern (siehe Hinweis im Code-Panel).', 'error');
+ return r.ok;
+ }
+ return c === 1 ? code.discardAll() : false;
+}
+
async function doSave(saveAs = false): Promise<void> {
+ // Erst die Eingaben im Editor, sonst fehlten sie in Snapshot und ZIP. Das Speichern baut danach, falls nötig.
+ const c = await code.saveAll();
+ if (!c.ok) { toast('Nicht alles im Editor ließ sich speichern (siehe Hinweis im Code-Panel). Das Modell ist deshalb nicht gespeichert.', 'error'); return; }
const r = await api.project.save(saveAs);
if (r.cancelled) return;
if (r.error) { toast(r.error, 'error'); return; }
@@ -450,19 +491,27 @@ async function doSave(saveAs = false): Promise<void> {
}
async function doOpen(): Promise<boolean> {
+ if (!(await leaveEditor('Modell öffnen'))) return false;
const r = await api.project.openZip();
if (r.error) toast(r.error, 'error');
return !!r.opened;
}
-const doNew = () => api.project.create();
-const doBuild = () => api.build.run();
+const doNew = async () => { if (await leaveEditor('Neues Modell')) await api.project.create(); };
+/** „Jetzt bauen“: baut immer. Vorher werden die Eingaben im Editor gespeichert, sonst sähe der Build sie nicht. */
+async function doBuild(): Promise<void> {
+ const r = await code.saveAll();
+ if (!r.ok) { toast('Nicht alles ließ sich speichern (siehe Hinweis im Code-Panel). Gebaut wird erst danach.', 'error'); return; }
+ await api.build.run();
+}
+const openProject = async (id: string) => { if (await leaveEditor('Modell öffnen')) await api.project.open(id); };
// Kurzbefehle gelten nicht im Terminal: dort gehören Strg+S/Strg+O den Programmen (Claude Code nutzt Strg+O selbst)
window.addEventListener('keydown', (e) => {
if ((e.target as HTMLElement | null)?.closest?.('#terminals') || !e.ctrlKey || e.altKey) return;
const k = e.key.toLowerCase();
- if (k === 's') { e.preventDefault(); void doSave(e.shiftKey); }
+ // Im Editor speichert Strg+S den Code und baut, sonst das ganze Modell als ZIP
+ if (k === 's') { e.preventDefault(); if (!e.shiftKey && (e.target as HTMLElement | null)?.closest?.('#code-view')) void saveCode(); else void doSave(e.shiftKey); }
else if (k === 'o' && !e.shiftKey) { e.preventDefault(); void doOpen().then((ok) => { if (ok) showStart(false); }); }
else if (k === 'n' && !e.shiftKey) { e.preventDefault(); void doNew().then(() => showStart(false)); }
else if (k === 'b' && !e.shiftKey) { e.preventDefault(); void doBuild(); }
@@ -476,7 +525,7 @@ async function renderRecent(): Promise<void> {
list.sort((a, b) => b.modified - a.modified);
const others = list.filter((p) => p.id !== project?.id).slice(0, 6);
$('recent-wrap').hidden = others.length === 0;
- $('recent-list').replaceChildren(...others.map((p) => menuItem(p.name, { icon: 'cube', sub: fmtWhen(p.modified, true), onClick: () => void api.project.open(p.id) })));
+ $('recent-list').replaceChildren(...others.map((p) => menuItem(p.name, { icon: 'cube', sub: fmtWhen(p.modified, true), onClick: () => void openProject(p.id) })));
}
$('btn-doc').addEventListener('click', () => { void renderRecent().then(() => menus.toggle($('menu-doc'), $('btn-doc'))); });
@@ -580,7 +629,7 @@ $('btn-ins-err').addEventListener('click', () => insertToAgent(errorText()));
$('btn-err-agent').addEventListener('click', () => insertToAgent(errorText()));
$('btn-err-code').addEventListener('click', () => {
const e = buildStatus.result?.error;
- if (e?.file) void openCode(e.file, e.line ? { from: e.line, to: e.line, label: 'Fehler' } : undefined);
+ if (e?.file) void openCode(e.file, e.line ? { from: e.line, to: e.line, label: 'Build-Fehler', kind: 'er' } : undefined);
});
$('btn-err-details').addEventListener('click', () => {
const t = $('err-trace');
@@ -670,7 +719,7 @@ async function showStart(on: boolean): Promise<void> {
const cur = p.id === project?.id;
const card = el('button', { className: 'recent' + (cur ? ' cur' : ''), title: cur ? 'Gerade geöffnet' : `${p.name} öffnen` },
th, el('div', { className: 'meta' }, el('b', { textContent: p.name }), el('span', { textContent: cur ? 'geöffnet' : `geändert ${fmtWhen(p.modified, true)}` })));
- card.addEventListener('click', () => { if (!cur) void api.project.open(p.id); showStart(false); });
+ card.addEventListener('click', () => { if (!cur) void openProject(p.id); showStart(false); });
return card;
}));
if (!list.length) $('start-recent').append(el('div', { className: 'c3', textContent: 'Noch keine Modelle auf diesem Rechner.' }));
@@ -687,11 +736,20 @@ $('btn-note-ok').addEventListener('click', () => { store.set('cadide.noteSeen',
// ---- Ereignisse vom Hauptprozess --------------------------------------------------------------------------------
api.project.onChanged((p) => void onProject(p));
+let buildStarts = 0; // Prüfhilfe: Wie oft hat ein Build begonnen?
api.build.onStatus((s) => {
+ if (s.state === 'building' && buildStatus.state !== 'building') buildStarts++;
renderBuild(s);
if (s.state === 'ok' && !s.stale) { void loadModel(); void refreshFiles(); }
});
-api.fs.onChanged(() => { textCache.clear(); void refreshFiles(); if (panel === 'code') void code.refresh(); });
+// Auch bei geschlossenem Code-Panel abgleichen: Offene Dateien können ungesicherte Eingaben enthalten
+api.fs.onChanged(() => { textCache.clear(); void refreshFiles(); void code.refresh(); });
+// Beim Beenden fragt der Hauptprozess, was im Editor ungespeichert ist, und lässt speichern oder verwerfen
+api.fs.onEditorRequest(async (action) => {
+ if (action === 'status') return { dirty: code.unsaved() };
+ if (action === 'save') return { ok: (await code.saveAll()).ok };
+ return { ok: await code.discardAll() };
+});
api.versions.onChanged(() => void versions.refresh());
api.project.onSaveState((st) => renderSaveState(st));
// Das Projekt kommt ausschließlich über das Ereignis (der Hauptprozess öffnet es beim Start). Ein zweiter Weg würde alles doppelt aufbauen.
@@ -727,6 +785,9 @@ if (api.testMode) {
showStart: (on: boolean) => showStart(on),
setAgentCollapsed,
fileRows: () => [...document.querySelectorAll('#tab-files .frow .fn')].map((x) => x.textContent),
- codeText: () => $('code-view').textContent,
+ codeText: () => code.text(),
+ openCode: (file: string) => openCode(file),
+ buildStarts: () => buildStarts,
+ editor: code.testApi(),
};
}
diff --git a/app/src/renderer/style.css b/app/src/renderer/style.css
index cec498e..566bd36 100644
--- a/app/src/renderer/style.css
+++ b/app/src/renderer/style.css
@@ -13,6 +13,7 @@
@font-face { font-family: 'IBM Plex Mono'; font-weight: 500; src: url(fonts/ibm-plex-mono-latin-ext-500-normal.woff2) format('woff2'); unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20CF, U+2113, U+2C60-2C7F, U+A720-A7FF; }
:root {
+ color-scheme:dark; /* nur dunkles Farbschema: Scrollleisten und Eingabefelder des Systems passen sich an */
--bg:#121417; --s1:#16181c; --s2:#1b1e23; --s3:#232830; --line:#262a31; --line2:#2d323a;
--tx:#e6e8eb; --tx2:#a3acb6; --tx3:#7f8994; --term:#0f1114;
--acc:#f29a38; --acc-tx:#f6b46a; --acc-tint:rgba(242,154,56,.14); --acc-line:rgba(242,154,56,.45);
@@ -119,10 +120,54 @@ code { font-family:var(--mono); font-size:.95em; }
.ctab .x { width:20px; height:20px; display:flex; align-items:center; justify-content:center; border-radius:4px; color:var(--tx3); }
.ctab .x:hover { background:var(--s3); color:var(--tx); }
.code-hd .btn, .code-hd .ibtn { align-self:center; }
+.code-hd .btn { font-family:var(--sans); }
#btn-codelink[aria-pressed=true] { color:var(--acc-tx); }
-.code-info { min-height:32px; flex-shrink:0; display:flex; align-items:center; gap:8px; padding:0 14px; font-size:12px; color:var(--tx2); border-bottom:1px solid var(--line); background:var(--term); }
+.code-info { min-height:32px; flex-shrink:0; display:flex; align-items:center; gap:8px; padding:6px 14px; font:12px/1.4 var(--sans); color:var(--tx2); border-bottom:1px solid var(--line); background:var(--term); }
.code-info:empty { display:none; }
-.codeview { flex:1; overflow:auto; padding:8px 0; background:var(--term); font-size:12.5px; line-height:1.72; }
+.codeview { flex:1; min-height:0; position:relative; background:var(--term); }
+.codeview .hint { color:var(--tx3); padding:14px; }
+.code-info .ci-main { display:flex; align-items:center; gap:8px; min-width:0; overflow:hidden; white-space:nowrap; text-overflow:ellipsis; }
+.code-info.locked { color:var(--tx3); }
+.code-info.locked .ci-main { white-space:normal; align-items:flex-start; }
+.code-info.locked .ci-main svg { margin-top:2px; }
+.code-info .ci-err { color:var(--err); display:flex; }
+.code-info .ci-hint { white-space:nowrap; }
+.code-info #btn-code-save { height:24px; }
+.ctab .dirty { font-size:10px; color:var(--tx2); }
+.ctab .dirty.warn { color:var(--warn); }
+.code-banner { flex-shrink:0; display:flex; gap:10px; padding:10px 12px; font-family:var(--sans); background:rgba(232,197,71,.08); border-bottom:1px solid rgba(232,197,71,.35); font-size:12px; }
+.code-banner .cb-ico { color:var(--warn); display:flex; padding-top:1px; }
+.code-banner .cb-text { display:flex; flex-direction:column; gap:4px; min-width:0; }
+.code-banner .cb-text span { color:var(--tx2); }
+.code-banner .cb-actions { display:flex; gap:8px; margin-top:4px; flex-wrap:wrap; }
+
+/* Editor (CodeMirror 6). Die Syntaxfarben kommen über die Klassen k-*, wie in den Codeausschnitten. Die ID sorgt dafür,
+ dass diese Regeln vor dem eingebauten Thema von CodeMirror gelten. */
+#code-view { overflow:hidden; }
+/* Volle Höhe über height, nicht über position: CodeMirror setzt position:relative !important */
+#code-view .cm-editor { height:100%; background:var(--term); color:#c9ced4; font-size:12.5px; }
+#code-view .cm-editor.cm-focused { outline:none; }
+#code-view .cm-scroller { font-family:var(--mono); line-height:1.72; }
+#code-view .cm-content { padding:8px 0; caret-color:var(--tx); }
+#code-view .cm-gutters { background:var(--term); color:#5d6671; border:0; }
+#code-view .cm-lineNumbers .cm-gutterElement { padding:0 12px 0 10px; min-width:34px; }
+#code-view .cm-activeLine { background:rgba(255,255,255,.035); }
+#code-view .cm-activeLineGutter { background:transparent; color:var(--tx2); }
+#code-view .cm-cursor { border-left:1.5px solid var(--tx); }
+#code-view .cm-selectionBackground { background:rgba(242,154,56,.24); }
+#code-view .cm-line.cm-mark-hl { background:rgba(242,154,56,.11); }
+#code-view .cm-line.cm-mark-er { background:rgba(240,116,112,.15); }
+#code-view .cm-matchingBracket { background:rgba(154,166,255,.22); color:inherit; }
+#code-view .cm-nonmatchingBracket { background:var(--err-tint); color:inherit; }
+#code-view .cm-selectionMatch { background:rgba(154,166,255,.12); }
+#code-view .cm-specialChar { color:var(--err); }
+#code-view .cm-panels { background:var(--s1); color:var(--tx); }
+#code-view .cm-panels-bottom { border-top:1px solid var(--line); }
+#code-view .cm-search { font-size:12px; padding:6px 8px; }
+#code-view .cm-search label { color:var(--tx2); }
+#code-view .cm-textfield { background:var(--term); border:1px solid var(--line2); border-radius:5px; color:var(--tx); font:12px var(--sans); padding:3px 6px; }
+#code-view .cm-button { background:var(--s3); background-image:none; border:1px solid var(--line2); border-radius:5px; color:var(--tx); font:12px var(--sans); padding:3px 8px; }
+#code-view .cm-panel button[name=close] { color:var(--tx2); }
.code { font-family:var(--mono); font-size:11.5px; line-height:1.65; }
.cl { display:flex; gap:12px; padding:0 10px; white-space:pre; }
.cl .ln { color:#5d6671; min-width:22px; text-align:right; flex-shrink:0; user-select:none; }
@@ -205,7 +250,13 @@ code { font-family:var(--mono); font-size:.95em; }
.errmsg { margin:0 12px; padding:8px 10px; border-radius:6px; background:var(--err-tint); font-family:var(--mono); font-size:12px; color:#ffc4c0; white-space:pre-wrap; overflow-wrap:anywhere; max-height:120px; overflow:auto; }
#err-code { margin:8px 12px 0; }
.trace { margin:8px 12px 0; padding:8px 10px; max-height:220px; overflow:auto; background:var(--term); border:1px solid var(--line); border-radius:6px; font:11px/1.5 var(--mono); color:var(--tx2); white-space:pre-wrap; }
-.ec-actions { display:flex; align-items:center; gap:8px; padding:12px; }
+.ec-actions { display:flex; align-items:center; gap:8px; padding:12px; flex-wrap:wrap; }
+/* Schmaler Viewer (etwa bei offenem Code-Panel): Die Fehlerkarte passt nicht neben die Bauteilkarte und rückt nach unten.
+ Die Auswahlkarte tritt solange zurück, der Hinweis auf den letzten guten Stand steht schon in der Karte. */
+@container viewer (max-width: 900px) {
+ .errcard { left:12px; right:12px; top:auto; bottom:12px; width:auto; min-width:0; }
+ #viewer.dim .selcard, #viewer.dim .lastgood { display:none; }
+}
.errcard.folded #err-body { display:none; }
.lastgood { left:50%; bottom:16px; transform:translateX(-50%); padding:6px 12px; border-radius:14px; font-size:12px; color:var(--tx2); white-space:nowrap; }
diff --git a/app/src/renderer/versions.ts b/app/src/renderer/versions.ts
index d6d7971..ead925f 100644
--- a/app/src/renderer/versions.ts
+++ b/app/src/renderer/versions.ts
@@ -18,6 +18,8 @@ interface Hooks {
/** `res` = Vorschau eines alten Standes, `null` = zurück zum Arbeitsstand. */
show(res: PreviewResult | null): Promise<void>;
toast(text: string, kind: 'ok' | 'info' | 'error'): void;
+ /** Vor dem Wiederherstellen: ungespeicherte Eingaben im Editor klären. false = abbrechen. */
+ beforeRestore(): Promise<boolean>;
}
const who = (c: CommitInfo) => (c.byApp ? 'CAD-IDE' : c.author);
@@ -99,6 +101,7 @@ export class VersionsBar {
private async restore(): Promise<void> {
if (!this.previewHash) return;
+ if (!(await this.hooks.beforeRestore())) return;
const r = await window.cadide.versions.restore(this.previewHash);
if (r.cancelled) return;
if (r.error) { this.hooks.toast(r.error, 'error'); return; }
diff --git a/app/src/shared/editable.ts b/app/src/shared/editable.ts
new file mode 100644
index 0000000..cc0c29d
--- /dev/null
+++ b/app/src/shared/editable.ts
@@ -0,0 +1,21 @@
+// Regeln für Dateien, die Renderer und Hauptprozess gleich anwenden müssen: welche der Editor nur zeigt (der Renderer
+// sperrt das Bearbeiten, der Hauptprozess lehnt das Schreiben ab) und welche das Modell betreffen (nur dann wird gebaut).
+
+/** Grund, warum eine Datei (Pfad relativ zum Projekt) nur lesbar ist, sonst null. */
+export function readOnlyReason(rel: string): string | null {
+ const p = rel.replace(/\\/g, '/').replace(/^\.\//, '');
+ if (/^(AGENTS|CLAUDE)\.md$/i.test(p)) return 'Wird von der App verwaltet und bei Updates ersetzt. Eigene Wünsche und Regeln gehören in NOTES.md.';
+ if (/^\.gitignore$/i.test(p)) return 'Wird von der App verwaltet.';
+ if (/^(output|exports)\//i.test(p)) return 'Wird beim Bauen oder Exportieren neu erzeugt.';
+ if (/^\.(cadide|git)(\/|$)/i.test(p)) return 'Interne Daten der App und von Git.';
+ return null;
+}
+
+/**
+ * Betrifft eine Änderung an dieser Datei das Modell? Python-Dateien und alles in inputs/ (mitgebrachte STEP-Dateien,
+ * Tabellen, die model.py einliest). Notizen wie NOTES.md nicht: Nach ihrem Speichern wird nicht gebaut.
+ */
+export function affectsBuild(rel: string): boolean {
+ const p = rel.replace(/\\/g, '/');
+ return /\.py$/i.test(p) || /^inputs\//i.test(p);
+}
diff --git a/app/src/shared/types.ts b/app/src/shared/types.ts
index 045ac18..f2525f6 100644
--- a/app/src/shared/types.ts
+++ b/app/src/shared/types.ts
@@ -32,6 +32,11 @@ export interface BuildStatus {
export interface ExportResult { ok: boolean; files: string[]; error?: string }
/** Dateien, die per Ziehen nach inputs/ kopiert wurden (E33). */
export interface ImportResult { files: string[]; errors: string[] }
+/**
+ * Schreiben aus dem Editor. `conflict`: Die Datei hat sich seit dem Laden außerhalb geändert (meist durch den Agenten),
+ * `disk` ist ihr aktueller Inhalt (null: gelöscht). `backup`: Pfad der Sicherung der überschriebenen Fassung.
+ */
+export interface WriteResult { ok: boolean; conflict?: boolean; disk?: string | null; backup?: string; error?: string }
/** Gespeicherte Markierung (E16). `path` relativ zum Projekt, z. B. `.cadide/feedback/markierung-20260930-1405.png`. */
export interface FeedbackResult { ok: boolean; path?: string; error?: string }
@@ -110,6 +115,15 @@ export interface CadideApi {
importFiles(files: File[]): Promise<ImportResult>;
/** Legt ein PNG der Markierung in .cadide/feedback/ ab. Vorhandenes wird nie überschrieben. */
saveFeedback(png: Uint8Array): Promise<FeedbackResult>;
+ /**
+ * Schreibt eine Datei aus dem Editor, nur wenn sie auf der Platte noch `base` entspricht (sonst Konflikt).
+ * `force` schreibt trotzdem und sichert vorher die Fassung auf der Platte. `projectId` schützt vor Schreiben ins falsche Modell.
+ */
+ writeText(projectId: string, rel: string, text: string, base: string | null, force?: boolean): Promise<WriteResult>;
+ /** Legt einen Text als Sicherung in den App-Daten ab und gibt den Pfad zurück. */
+ backupText(projectId: string, rel: string, text: string): Promise<string>;
+ /** Anfragen des Hauptprozesses an den Editor beim Beenden: ungespeicherte Dateien nennen, speichern oder verwerfen. */
+ onEditorRequest(cb: (action: 'status' | 'save' | 'discard') => Promise<{ dirty?: string[]; ok?: boolean }>): void;
};
term: {
create(opts?: { command?: string; title?: string }): Promise<number>;
@@ -120,6 +134,8 @@ export interface CadideApi {
onExit(cb: (id: number, code: number) => void): void;
};
agents: { detect(): Promise<AgentInfo[]> };
+ /** Nativer Dialog mit Knöpfen, liefert den Index. Der letzte Knopf gilt als Abbrechen. Im Test über `test.answers` beantwortbar. */
+ dialog: { choose(o: { title: string; message: string; detail?: string; buttons: string[] }): Promise<number> };
}
declare global { interface Window { cadide: CadideApi } }
diff --git a/app/test/editor.mjs b/app/test/editor.mjs
new file mode 100644
index 0000000..d3cfeb4
--- /dev/null
+++ b/app/test/editor.mjs
@@ -0,0 +1,214 @@
+// Test des Editors im Code-Panel: Höhe und Scrollen, Speichern nur auf Wunsch (Strg+S, Knopf) mit genau einem Build,
+// Änderungen von außen (Agent), Konflikte mit Sicherung, Nur-lesen-Dateien, Zeilenenden, Fehlerzeile, Speichern als ZIP,
+// Rückfragen bei Modellwechsel und beim Schließen eines Reiters.
+// Aufruf: npm run test:editor (baut vorher). SMOKE_VISIBLE=offscreen SMOKE_SHOTS=1 legt Bilder in test/shots/ ab.
+import { exec } from 'dugite';
+import fs from 'node:fs';
+import path from 'node:path';
+import { APP, checker, cleanup, sleep, startApp } from './harness.mjs';
+
+const t = checker();
+const { check } = t;
+let app;
+
+/** Wartet im Testprozess (nicht im Fenster), bis fn wahr ist. */
+async function until(desc, fn, timeout = 10000) {
+ const t0 = Date.now();
+ for (;;) {
+ if (await fn()) return true;
+ if (Date.now() - t0 > timeout) { console.log(` (Zeitüberschreitung: ${desc})`); return false; }
+ await sleep(100);
+ }
+}
+
+try {
+ app = await startApp({ name: 'editor' });
+ const { ev, waitFor, domClick, ud, page } = app;
+ const shot = async (name) => {
+ if (!process.env.SMOKE_SHOTS) return;
+ fs.mkdirSync(path.join(APP, 'test', 'shots'), { recursive: true });
+ await sleep(900);
+ await app.screenshot(path.join(APP, 'test', 'shots', `${name}.png`)).catch((e) => console.log('Screenshot:', e.message));
+ };
+ await waitFor('Projekt und Build', () => !!window.__t && !!window.__t.project() && window.__t.status().state === 'ok' && window.__t.partCount() === 2);
+ const proj = await ev(() => window.__t.project());
+ const modelPy = path.join(proj.dir, 'model.py');
+ const disk = () => fs.readFileSync(modelPy, 'utf8');
+ const ed = () => ev(() => window.__t.editor.state());
+ const replace = (a, b) => ev(([x, y]) => window.__t.editor.replace(x, y), [a, b]);
+ const open = async (file) => {
+ await ev((f) => window.__t.openCode(f), file);
+ await waitFor(file, (f) => window.__t.editor.state().file === f, 10000, file).catch(() => {});
+ };
+ // Strg+S so, wie es im Editor ankommt: als Taste im Eingabebereich von CodeMirror
+ const ctrlS = () => ev(() => document.querySelector('#code-view .cm-content').dispatchEvent(new KeyboardEvent('keydown', { key: 's', ctrlKey: true, bubbles: true, cancelable: true })));
+ const builds = () => ev(() => window.__t.buildStarts());
+ const body = async () => (await ev(() => window.__t.partSize('Body')))?.[0];
+ // Ruhe: Ein angemeldeter Auto-Build (Entprellung 700 ms nach einer Dateiänderung) soll erst starten und fertig werden
+ const idle = async () => { await sleep(1200); await waitFor('Build fertig', () => window.__t.status().state !== 'building', 60000).catch(() => {}); };
+ const bdir = path.join(ud, 'workspace-backups', `${proj.id}-editor`);
+ const backups = () => (fs.existsSync(bdir) ? fs.readdirSync(bdir).map((f) => fs.readFileSync(path.join(bdir, f), 'utf8')) : []);
+
+ // 1) Öffnen: model.py im Editor, bearbeitbar, mit Hervorhebung
+ await ev(() => document.querySelector('#rail [data-panel="code"]').click());
+ await waitFor('model.py im Editor', () => window.__t.editor.state().file === 'model.py', 10000).catch(() => {});
+ let s = await ed();
+ check('Code-Panel öffnet model.py im Editor, bearbeitbar', s.file === 'model.py' && !s.readOnly && s.text === disk().replace(/\r\n/g, '\n'), s.file ?? '');
+ check('Python-Hervorhebung: Schlüsselwörter, Konstanten, Aufrufe', await ev(() => ['k-kw', 'k-num', 'k-fn'].every((c) => !!document.querySelector(`#code-view .cm-content .${c}`))));
+
+ // 2) Höhe: Der Editor füllt das Panel bis unten, lange Dateien lassen sich bis zum Ende scrollen
+ const long = path.join(proj.dir, 'notizen-lang.txt');
+ fs.writeFileSync(long, Array.from({ length: 400 }, (_, i) => `Zeile ${i + 1}`).join('\n') + '\n');
+ await open('notizen-lang.txt');
+ const lay = await ev(() => window.__t.editor.layout());
+ check('Editor füllt das Panel bis unten', Math.abs(lay.editorBottom - lay.viewBottom) < 2 && Math.abs(lay.editorTop - lay.viewTop) < 2, `Editor ${Math.round(lay.editorTop)}–${Math.round(lay.editorBottom)}, Panel ${Math.round(lay.viewTop)}–${Math.round(lay.viewBottom)}`);
+ const scrolled = await ev(() => window.__t.editor.scrollToEnd());
+ await sleep(200);
+ // Gemessen wird die Scrollposition: Ein unsichtbares Testfenster zeichnet die neu sichtbaren Zeilen nicht nach
+ check('Lange Datei: lässt sich bis ganz unten scrollen', lay.scrollHeight > lay.clientHeight && scrolled > 0 && scrolled + lay.clientHeight >= lay.scrollHeight - 1,
+ `${scrolled} von ${lay.scrollHeight - lay.clientHeight} px`);
+ await open('model.py');
+ await idle();
+
+ // 3) Tippen speichert nicht und baut nicht
+ const b0 = await builds();
+ await replace('LENGTH = 60.0', 'LENGTH = 70.0');
+ await sleep(2500);
+ s = await ed();
+ check('Tippen: Platte unverändert, kein Build', s.dirty && disk().includes('LENGTH = 60.0') && await builds() === b0 && await body() === 60, `${await builds() - b0} Builds`);
+ check('Anzeige: Punkt am Reiter, „Nicht gespeichert · Strg+S" und Knopf „Speichern und bauen"', await ev(() => !!document.querySelector('#code-tabs .ctab.on .dirty')
+ && document.getElementById('code-info').textContent.includes('Nicht gespeichert · Strg+S') && document.getElementById('btn-code-save')?.textContent === 'Speichern und bauen'));
+ await shot('8-editor-ungespeichert');
+
+ // 4) Strg+S im Editor: speichern, dann genau ein Build
+ await ctrlS();
+ await waitFor('Build mit 70', () => window.__t.status().state === 'ok' && (window.__t.partSize('Body') || [0])[0] === 70, 60000).catch(() => {});
+ check('Strg+S im Editor: Datei gespeichert und gebaut (Body 70 mm lang)', disk().includes('LENGTH = 70.0') && !(await ed()).dirty && await body() === 70);
+ await sleep(2000);
+ check('Genau ein Build nach dem Speichern (die Dateiüberwachung baut nicht noch einmal)', await builds() === b0 + 1, `${await builds() - b0} Builds`);
+ check('Strg+S im Editor schreibt keine ZIP (das macht „Speichern" oben)', !(await ev(() => window.__t.saveState()))?.zipPath);
+
+ // 5) Knopf „Speichern und bauen"
+ await replace('LENGTH = 70.0', 'LENGTH = 72.0');
+ await domClick('btn-code-save');
+ await waitFor('Build mit 72', () => window.__t.status().state === 'ok' && (window.__t.partSize('Body') || [0])[0] === 72, 60000).catch(() => {});
+ check('Knopf „Speichern und bauen": gespeichert und gebaut (72 mm), Knopf wieder weg', disk().includes('LENGTH = 72.0') && await body() === 72 && await ev(() => !document.getElementById('btn-code-save')?.isConnected));
+
+ // 6) Änderung von außen ohne eigene Eingaben: Der Editor übernimmt sie
+ fs.writeFileSync(modelPy, disk().replace('LENGTH = 72.0', 'LENGTH = 75.0'));
+ await waitFor('Editor übernimmt', () => window.__t.editor.state().text.includes('LENGTH = 75.0'), 10000).catch(() => {});
+ s = await ed();
+ check('Änderung von außen (Agent) erscheint im Editor, ohne als eigene Eingabe zu gelten', s.text.includes('LENGTH = 75.0') && !s.dirty && !s.conflict);
+ await idle();
+
+ // 7) Konflikt: ungespeicherte Eingabe, und der Agent ändert dieselbe Datei. Nichts wird überschrieben.
+ await replace('LENGTH = 75.0', 'LENGTH = 76.0');
+ fs.writeFileSync(modelPy, disk().replace('LENGTH = 75.0', 'LENGTH = 77.0'));
+ await waitFor('Konflikt', () => window.__t.editor.state().conflict === 'changed', 10000).catch(() => {});
+ s = await ed();
+ check('Gleichzeitige Änderung: Hinweis im Editor, die Platte bleibt beim Agenten', s.conflict === 'changed' && disk().includes('LENGTH = 77.0') && s.text.includes('LENGTH = 76.0')
+ && await ev(() => !document.getElementById('code-banner').hidden && !!document.querySelector('#code-tabs .dirty.warn')));
+ await ctrlS();
+ await sleep(300);
+ check('Strg+S bei Konflikt: nichts geschrieben, Meldung', disk().includes('LENGTH = 77.0') && (await ev(() => window.__t.toast())).text.includes('Nicht alles ließ sich speichern'));
+ await shot('9-editor-konflikt');
+ await idle();
+ const b1 = await builds();
+ await ev(() => window.__t.editor.keepMine());
+ await until('eigene Fassung auf der Platte', () => disk().includes('LENGTH = 76.0'));
+ await waitFor('Build mit 76', () => window.__t.status().state === 'ok' && (window.__t.partSize('Body') || [0])[0] === 76, 60000).catch(() => {});
+ check('„Meine Fassung behalten": gespeichert und gebaut, die Fassung von außen liegt in der Sicherung',
+ disk().includes('LENGTH = 76.0') && await body() === 76 && await builds() > b1 && backups().some((b) => b.includes('LENGTH = 77.0')) && !(await ed()).conflict);
+ await replace('LENGTH = 76.0', 'LENGTH = 78.0');
+ fs.writeFileSync(modelPy, disk().replace('LENGTH = 76.0', 'LENGTH = 79.0'));
+ await waitFor('zweiter Konflikt', () => window.__t.editor.state().conflict === 'changed', 10000).catch(() => {});
+ await ev(() => window.__t.editor.takeTheirs());
+ s = await ed();
+ check('„Fassung von außen laden": Editor zeigt sie, die eigene Eingabe liegt in der Sicherung',
+ s.text.includes('LENGTH = 79.0') && !s.dirty && !s.conflict && disk().includes('LENGTH = 79.0') && backups().some((b) => b.includes('LENGTH = 78.0')));
+ await idle();
+
+ // 8) Dateien der App: nur lesen, mit Begründung
+ await open('AGENTS.md');
+ s = await ed();
+ check('AGENTS.md: nur lesen, mit Begründung und Verweis auf NOTES.md', s.readOnly && /NOTES\.md/.test(s.locked ?? '') && await ev(() => document.getElementById('code-info').textContent.startsWith('Nur lesen')));
+ check('Eingaben in AGENTS.md werden nicht angenommen', !(await replace('Instructions', 'Anweisungen')) && !(await ed()).dirty);
+
+ // 9) Notizen (Markdown): speichern ja, bauen nein. Dazu Zeilenenden: Eine Datei mit CRLF behält sie.
+ const notes = path.join(proj.dir, 'NOTES.md');
+ fs.writeFileSync(notes, '# Notizen\r\n\r\nWunsch: Deckel\r\n');
+ await open('NOTES.md');
+ await waitFor('NOTES.md geladen', () => window.__t.editor.state().text.includes('Wunsch: Deckel'), 10000).catch(() => {});
+ await idle();
+ const b2 = await builds();
+ await replace('Wunsch: Deckel', 'Wunsch: Deckel mit Lippe');
+ check('Nur Markdown ungespeichert: Der Knopf heißt „Speichern", nicht „Speichern und bauen"', await ev(() => document.getElementById('btn-code-save')?.textContent === 'Speichern'));
+ await ctrlS();
+ await until('NOTES.md geschrieben', () => fs.readFileSync(notes, 'utf8').includes('Lippe'));
+ await sleep(2000);
+ check('Strg+S in NOTES.md: gespeichert, aber nicht gebaut', !(await ed()).dirty && await builds() === b2, `${await builds() - b2} Builds`);
+ check('Datei mit CRLF: Zeilenenden bleiben erhalten', fs.readFileSync(notes, 'utf8') === '# Notizen\r\n\r\nWunsch: Deckel mit Lippe\r\n', JSON.stringify(fs.readFileSync(notes, 'utf8')).slice(0, 60));
+
+ // 10) Build-Fehler: „Code öffnen" markiert die Zeile rot
+ await open('model.py');
+ await replace('LENGTH = 79.0', 'LENGTH = 79.0 +');
+ await ctrlS();
+ await waitFor('Fehler', () => window.__t.status().state === 'error', 60000).catch(() => {});
+ await domClick('btn-err-code');
+ await waitFor('Fehlerzeile', () => window.__t.editor.state().marked.some((m) => m.startsWith('er:')), 10000).catch(() => {});
+ s = await ed();
+ check('Fehlerkarte „Code öffnen": Fehlerzeile im Editor rot markiert', s.marked.some((m) => m.startsWith('er:') && m.includes('LENGTH = 79.0 +')), s.marked.join(' | ').slice(0, 60));
+ await shot('10-editor-fehler');
+ await replace('LENGTH = 79.0 +', 'LENGTH = 79.0');
+ await ctrlS();
+ await waitFor('wieder gebaut', () => window.__t.status().state === 'ok', 60000).catch(() => {});
+
+ // 11) „Speichern" oben: speichert auch die Eingaben im Editor, dann Snapshot und ZIP
+ await replace('LENGTH = 79.0', 'LENGTH = 81.0');
+ const zipPath = path.join(ud, 'Editortest.zip');
+ await app.answers([zipPath]);
+ await domClick('btn-save');
+ await waitFor('gespeichert', () => !!window.__t.saveState()?.zipPath && !window.__t.saveState().unsaved, 60000).catch(() => {});
+ const inHead = (await exec(['show', 'HEAD:model.py'], proj.dir)).stdout;
+ check('„Speichern" oben: Eingabe aus dem Editor ist im Snapshot und in der ZIP', inHead.includes('LENGTH = 81.0') && fs.existsSync(zipPath) && !(await ed()).dirty);
+ await replace('LENGTH = 81.0', 'LENGTH = 82.0');
+ check('Ungespeicherte Eingabe im Editor: Speicherstand oben zeigt „Nicht gespeichert"', await ev(() => document.getElementById('save-badge').textContent.startsWith('Nicht gespeichert')),
+ await ev(() => document.getElementById('save-badge').textContent));
+
+ // 12) Modellwechsel mit ungespeicherter Eingabe: Rückfrage (Abbrechen, dann Speichern)
+ await app.answers([2]);
+ await domClick('btn-new');
+ await sleep(1500);
+ check('Neues Modell, Rückfrage „Abbrechen": Modell bleibt, Eingabe bleibt ungespeichert', (await ev(() => window.__t.project())).id === proj.id && (await ed()).dirty && disk().includes('LENGTH = 81.0'));
+ await app.answers([0]);
+ await domClick('btn-new');
+ await waitFor('neues Modell', (old) => window.__t.project().id !== old && window.__t.status().state === 'ok' && window.__t.partCount() === 2, 90000, proj.id).catch(() => {});
+ const p2 = await ev(() => window.__t.project());
+ const model2 = path.join(p2.dir, 'model.py');
+ check('Rückfrage „Speichern": Eingabe steht im alten Modell, das neue ist unberührt', p2.id !== proj.id && disk().includes('LENGTH = 82.0') && fs.readFileSync(model2, 'utf8').includes('LENGTH = 60.0'));
+ check('Nach dem Wechsel ist der Editor leer', (await ed()).files.length === 0);
+
+ // 13) Reiter mit ungespeicherter Eingabe schließen: „Verwerfen" legt sie als Sicherung ab
+ await open('model.py');
+ await replace('LENGTH = 60.0', 'LENGTH = 65.0');
+ await app.answers([1]);
+ await ev(() => document.querySelector('#code-tabs .ctab.on .x').click());
+ await waitFor('Reiter zu', () => window.__t.editor.state().files.length === 0, 10000).catch(() => {});
+ const bdir2 = path.join(ud, 'workspace-backups', `${p2.id}-editor`);
+ const back2 = fs.existsSync(bdir2) ? fs.readdirSync(bdir2).map((f) => fs.readFileSync(path.join(bdir2, f), 'utf8')) : [];
+ check('Reiter schließen, „Verwerfen": Datei unverändert, Eingabe in der Sicherung', fs.readFileSync(model2, 'utf8').includes('LENGTH = 60.0') && back2.some((b) => b.includes('LENGTH = 65.0')));
+
+ // 14) Späte Schreibanfrage für ein schon gewechseltes Modell: nicht ins neue schreiben, sondern sichern
+ const late = await ev((id) => window.cadide.fs.writeText(id, 'model.py', 'X = 1\n', null, true), proj.id);
+ check('Späte Eingabe für das alte Modell: nicht ins neue geschrieben, sondern gesichert', !late.ok && /Sicherung/.test(late.error ?? '') && fs.readFileSync(model2, 'utf8').includes('LENGTH = 60.0')
+ && backups().includes('X = 1\n'), (late.error ?? '').slice(0, 60));
+
+ const relevant = page.errors.filter((e) => !/favicon/i.test(e));
+ check('Keine Konsolenfehler im Renderer', relevant.length === 0, relevant.slice(0, 2).join(' | ').slice(0, 100));
+} catch (e) {
+ console.log('ABBRUCH:', e.message);
+ t.fail();
+}
+if (app) { await app.stop(); cleanup(app.ud); }
+console.log(t.fails ? `\n${t.fails} Prüfung(en) fehlgeschlagen` : '\nALLE PRÜFUNGEN BESTANDEN');
+process.exit(t.fails ? 1 : 0);
diff --git a/app/test/unit.mjs b/app/test/unit.mjs
index 5b8f362..7e0fb51 100644
--- a/app/test/unit.mjs
+++ b/app/test/unit.mjs
@@ -14,7 +14,7 @@ const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'cadide-unit-'));
try {
const out = path.join(tmp, 'files.mjs');
await build({ entryPoints: [path.join(APP, 'src', 'main', 'files.ts')], outfile: out, bundle: true, platform: 'node', format: 'esm', logLevel: 'silent' });
- const { importInputs, saveFeedbackImage } = await import(pathToFileURL(out).href);
+ const { importInputs, saveFeedbackImage, writeProjectText, backupText } = await import(pathToFileURL(out).href);
const proj = path.join(tmp, 'projekt');
const src = path.join(tmp, 'quelle');
@@ -64,6 +64,33 @@ try {
const r3 = saveFeedbackImage(proj3, png, when);
check('.cadide zeigt nach außen: Markierung abgelehnt, draußen landet nichts', !r3.ok && fs.readdirSync(outside).length === 0, r3.error?.slice(0, 70) ?? '');
} else check('.cadide als Verweis nach außen (übersprungen, Verweis nicht anlegbar)', true);
+
+ // Editor: schreiben nur, wenn die Platte noch dem gelesenen Stand entspricht (der Agent schreibt an denselben Dateien)
+ const bdir = path.join(tmp, 'sicherungen');
+ const mp = path.join(proj, 'model.py');
+ fs.writeFileSync(mp, 'A = 1\n');
+ let w = writeProjectText(proj, 'model.py', 'A = 2\n', 'A = 1\n', false, bdir);
+ check('Editor schreibt, wenn die Platte dem gelesenen Stand entspricht', w.ok && fs.readFileSync(mp, 'utf8') === 'A = 2\n' && !fs.existsSync(`${mp}.cadide-tmp`));
+ fs.writeFileSync(mp, 'A = 3 # Agent\n');
+ w = writeProjectText(proj, 'model.py', 'A = 4\n', 'A = 2\n', false, bdir);
+ check('Außen geändert: Konflikt statt Überschreiben, Platte bleibt, aktueller Inhalt kommt mit', !w.ok && w.conflict && w.disk === 'A = 3 # Agent\n' && fs.readFileSync(mp, 'utf8') === 'A = 3 # Agent\n');
+ w = writeProjectText(proj, 'model.py', 'A = 4\n', 'A = 2\n', true, bdir);
+ check('„Meine Fassung behalten": schreibt und sichert vorher die Fassung von außen', w.ok && fs.readFileSync(mp, 'utf8') === 'A = 4\n' && !!w.backup
+ && fs.readFileSync(w.backup, 'utf8') === 'A = 3 # Agent\n' && path.dirname(w.backup) === bdir, w.backup ? path.basename(w.backup) : w.error);
+ fs.rmSync(mp);
+ w = writeProjectText(proj, 'model.py', 'A = 5\n', 'A = 4\n', false, bdir);
+ check('Außen gelöscht: Konflikt mit disk = null', !w.ok && w.conflict && w.disk === null && !fs.existsSync(mp));
+ const locked = ['AGENTS.md', 'CLAUDE.md', '.gitignore', 'output/model.step', 'exports/Body.stl', '.cadide/project.json', '.git/config', 'parts/../AGENTS.md'].map((r) => {
+ fs.mkdirSync(path.dirname(path.join(proj, r)), { recursive: true });
+ fs.writeFileSync(path.join(proj, r), 'x');
+ const res = writeProjectText(proj, r, 'y', 'x', true, bdir);
+ return !res.ok && !res.conflict && fs.readFileSync(path.join(proj, r), 'utf8') === 'x';
+ });
+ check('App-Dateien, Ergebnisse, .cadide und .git: Schreiben aus dem Editor abgelehnt', locked.every(Boolean), locked.join(','));
+ w = writeProjectText(proj, '../draussen.py', 'x', null, true, bdir);
+ check('Pfad außerhalb des Projekts: abgelehnt', !w.ok && !fs.existsSync(path.join(tmp, 'draussen.py')), w.error?.slice(0, 60));
+ const b1 = backupText(bdir, 'parts/deckel.py', 'eins'), b2 = backupText(bdir, 'parts/deckel.py', 'zwei');
+ check('Sicherungen überschreiben einander nicht', b1 !== b2 && fs.readFileSync(b1, 'utf8') === 'eins' && fs.readFileSync(b2, 'utf8') === 'zwei', path.basename(b2));
} catch (e) {
console.log('ABBRUCH:', e.message);
t.fail();