Desktop app for designing parametric 3D models in CadQuery together with the coding agent of your choice
TypeScript 3d-modeling3d-printing3d-printing-toolsagentagentic-aiai-cadcadcadqueryclaude-codecodexelectronfemllmmacdmakeropencodeparametric-designpythonsteptext-to-cad
App: Editor im Code-Panel (CodeMirror 6, E39, E40)
Kai-Jungsthoefelfea8c85ec95e
diff --git a/app/package-lock.json b/app/package-lock.jsonindex 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.jsonindex 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.mdindex 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.tsindex 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.tsindex 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.tsindex 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): voidvoid 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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 Dialogetest: 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.tsindex 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.htmlindex 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.tsindex 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.cssindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.mjsnew file mode 100644index 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.mjsindex 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();