Skip to content

armgit / SOMA

Public Imported from GitHub
0

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

App: „Open folder“ (Ordner-Modus) und „Copy path for agent app“

Kai-Jungsthoefel5b2a9425d873
diff --git a/app/package.json b/app/package.json
index 627fe13..6d272ab 100644
--- a/app/package.json
+++ b/app/package.json
@@ -17,6 +17,7 @@
"test:measure": "npm run build && node test/measure.mjs",
"test:stepview": "npm run build && node test/stepview.mjs",
"test:cadquery": "npm run build && node test/cadquery.mjs",
+ "test:folder": "npm run build && node test/folder.mjs",
"test:groups": "npm run build && node test/groups.mjs",
"test:section": "npm run build && node test/section.mjs",
"test:explode": "npm run build && node test/explode.mjs",
diff --git a/app/src/main/dialogs.ts b/app/src/main/dialogs.ts
index 725661e..25d12d8 100644
--- a/app/src/main/dialogs.ts
+++ b/app/src/main/dialogs.ts
@@ -60,6 +60,22 @@ export async function chooseCadQueryScript(win: BrowserWindow | null): Promise<s
return r.canceled || !r.filePaths[0] ? null : r.filePaths[0];
}
+/** Ordner für „Open folder“ (Ordner-Modus). null: abgebrochen. */
+export async function chooseFolder(win: BrowserWindow | null): Promise<string | null> {
+ if (testMode()) return nextAnswer<string | null>('Open folder');
+ const opts = { title: 'Open folder', defaultPath: documentsDir(), buttonLabel: 'Open folder', properties: ['openDirectory' as const, 'createDirectory' as const] };
+ const r = win ? await dialog.showOpenDialog(win, opts) : await dialog.showOpenDialog(opts);
+ return r.canceled || !r.filePaths[0] ? null : r.filePaths[0];
+}
+
+/** Skript, das im geöffneten Ordner das Modell baut. null: abgebrochen. */
+export async function chooseEntryScript(win: BrowserWindow | null, dir: string): Promise<string | null> {
+ if (testMode()) return nextAnswer<string | null>('Entry script');
+ const opts = { title: 'Script that builds the model', defaultPath: dir, filters: [{ name: 'Python script', extensions: ['py'] }], properties: ['openFile' as const] };
+ const r = win ? await dialog.showOpenDialog(win, opts) : await dialog.showOpenDialog(opts);
+ return r.canceled || !r.filePaths[0] ? null : r.filePaths[0];
+}
+
/** Markdown-Dateien, die als eigene Skills übernommen werden (E78). Leere Liste: abgebrochen. */
export async function chooseSkillFiles(win: BrowserWindow | null): Promise<string[]> {
if (testMode()) return nextAnswer<string[] | null>('Import skills') ?? [];
diff --git a/app/src/main/folders.ts b/app/src/main/folders.ts
new file mode 100644
index 0000000..e891ed5
--- /dev/null
+++ b/app/src/main/folders.ts
@@ -0,0 +1,235 @@
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { SOMA_VERSION } from '../shared/version';
+import { resolveInside } from './files';
+import { skillBackupsDir, skillDirs, templateDir, workspacesDir } from './paths';
+import { BEGIN as SKILLS_BEGIN, END as SKILLS_END, applyDefaultSkills, writeAtomic } from './skills';
+import { API_VERSION, folderOf, getSkillDefaults, isProjectId, type ProjectJson } from './workspace';
+
+/**
+ * Ordner-Modus („Open folder“): SOMA in einem Ordner des Nutzers, etwa einem Repository. Der Ordner gehört ihm. Die App
+ * legt nur ihren Teil an (.soma/ mit eigener .gitignore, bei Bedarf model.py) und ergänzt AGENTS.md um einen Abschnitt
+ * zwischen Markierungen, CLAUDE.md um einen Verweis darauf. Vorher sagt ein Hinweis, was angelegt und was geändert wird
+ * (Wunsch des Nutzers). Geänderte Dateien kommen vorher in die Sicherungen. Git rührt die App hier nicht an.
+ */
+
+export const FOLDER_BEGIN = '<!-- soma:folder -->';
+export const FOLDER_END = '<!-- /soma:folder -->';
+const CLAUDE_REF = '@AGENTS.md';
+/** Kopf der AGENTS.md eines ganzen SOMA-Modells (Vorlage). Ein solcher Ordner (etwa ein geklontes Modell) bleibt, wie er ist. */
+const TEMPLATE_HEAD = '# Instructions for the coding agent (managed by the app';
+/** Paketliste im Ordner-Modus: Eine requirements.txt im Ordner gehört dem Nutzer (packages.ts, env.py). */
+const FOLDER_REQUIREMENTS = '.soma/requirements.txt';
+
+/** Zwischenergebnisse der App in .soma/, relativ zu .soma/ (wie die .gitignore der Vorlage). project.json und Skills bleiben sichtbar. */
+const SOMA_GITIGNORE = `# Written by SOMA: intermediate results of the app, regenerated
+model.glb
+model.map.json
+build.json
+zip-info.json
+feedback/
+geometry/
+anim/
+results/
+drawings/
+env/
+help/
+`;
+
+const FOLDER_GIT = `## Version history (git)
+
+SOMA does not manage Git in this folder. If the folder is a repository, the app shows its commits as a timeline under the 3D view, but it does not commit or restore anything here.
+
+- Commit only when the user asks, and follow the conventions of this repository.
+- Do not rewrite history unless the user asks for it explicitly.
+`;
+
+const read = (file: string): string | null => { try { return fs.readFileSync(file, 'utf8'); } catch { return null; } };
+const readJson = <T>(file: string): T | null => { try { return JSON.parse(fs.readFileSync(file, 'utf8')) as T; } catch { return null; } };
+
+/** Ein ganzes SOMA-Modell (AGENTS.md aus der Vorlage), etwa ein geklontes Repository eines Modells. */
+export function isFullModel(dir: string): boolean {
+ return (read(path.join(dir, 'AGENTS.md')) ?? '').trimStart().startsWith(TEMPLATE_HEAD);
+}
+
+/** Reines CadQuery-Skript (E100): ohne soma, mit show_object oder result. Dann gilt der Kompatibilitätsmodus beim Bauen. */
+function isPlainScript(file: string): boolean {
+ const text = read(file) ?? '';
+ return !/^\s*(from\s+soma\b|import\s+soma\b)/m.test(text) && /\bshow_object\s*\(|^\s*result\s*=/m.test(text);
+}
+
+/**
+ * Abschnitt für AGENTS.md, gebaut aus der AGENTS.md der Vorlage: ab „Project layout“, mit eigenem Kopf, ohne die Regeln
+ * zum Committen (die App verwaltet Git hier nicht), mit der Einstiegsdatei statt model.py und der Paketliste in .soma/.
+ * `skills`: die bisherige Liste der Skills (zwischen ihren Markierungen), sonst die leere aus der Vorlage.
+ */
+export function folderSection(entry: string, plain: boolean, skills?: string): string {
+ const tpl = (read(path.join(templateDir(), 'AGENTS.md')) ?? '').replace(/\r\n/g, '\n');
+ const at = tpl.indexOf('## Project layout');
+ let body = at >= 0 ? tpl.slice(at) : tpl;
+ body = body.replace(/## Version history \(git\)\n[\s\S]*?(?=\n## )/, FOLDER_GIT);
+ body = body.replace(/`requirements\.txt`/g, `\`${FOLDER_REQUIREMENTS}\``);
+ if (entry !== 'model.py') body = body.replace(/model\.py/g, entry);
+ if (skills) {
+ const a = body.indexOf(SKILLS_BEGIN), z = body.indexOf(SKILLS_END);
+ if (a >= 0 && z > a) body = body.slice(0, a) + skills + body.slice(z + SKILLS_END.length);
+ }
+ const head = [
+ FOLDER_BEGIN,
+ '# SOMA (written by the app, do not edit this section)',
+ '',
+ 'The SOMA app writes and replaces everything between the two `soma:folder` markers. The rest of this file belongs to the folder.',
+ '',
+ `A person designs a 3D model with code in this folder, together with you. The model is written in Python with CadQuery, the entry point is \`${entry}\`. The SOMA app shows the result in a 3D viewer next to the terminal.`,
+ '',
+ ];
+ if (plain) {
+ head.push(`\`${entry}\` is a plain CadQuery script (\`show_object\` or \`result\`). SOMA builds it in a compatibility mode. Keep its style and leave rules 1, 2 and 9 aside unless the user asks to switch to \`add_part\`.`, '');
+ }
+ return `${head.join('\n')}${body.trim()}\n${FOLDER_END}`;
+}
+
+/** Bisherige Liste der Skills im Abschnitt, mit Markierungen. */
+function currentSkills(section: string): string | undefined {
+ const a = section.indexOf(SKILLS_BEGIN), z = section.indexOf(SKILLS_END);
+ return a >= 0 && z > a ? section.slice(a, z + SKILLS_END.length) : undefined;
+}
+
+/** Text mit dem Abschnitt: ersetzt einen vorhandenen, sonst angehängt (Zeilenenden wie in der Datei). */
+function withSection(cur: string | null, section: (old: string | undefined) => string): string {
+ if (cur == null) return `${section(undefined)}\n`;
+ const eol = cur.includes('\r\n') ? '\r\n' : '\n';
+ const norm = cur.replace(/\r\n/g, '\n');
+ const a = norm.indexOf(FOLDER_BEGIN), z = norm.indexOf(FOLDER_END);
+ const next = a >= 0 && z > a
+ ? norm.slice(0, a) + section(currentSkills(norm.slice(a, z))) + norm.slice(z + FOLDER_END.length)
+ : `${norm.replace(/\s*$/, '')}\n\n${section(undefined)}\n`;
+ return next.replace(/\n/g, eol);
+}
+
+const hasSection = (text: string | null) => !!text && text.includes(FOLDER_BEGIN) && text.includes(FOLDER_END);
+const hasClaudeRef = (text: string | null) => !!text && text.toLowerCase().includes(CLAUDE_REF.toLowerCase());
+
+/** Python-Dateien direkt im Ordner, für die Frage nach der Einstiegsdatei. */
+export function topLevelScripts(dir: string): string[] {
+ try { return fs.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && /\.py$/i.test(e.name)).map((e) => e.name); } catch { return []; }
+}
+
+export interface FolderPlan {
+ dir: string;
+ /** Einstiegsdatei relativ zum Ordner (mit /). */
+ entry: string;
+ /** model.py aus der Vorlage anlegen. */
+ createModel: boolean;
+ /** Was angelegt und was geändert wird, als Zeilen für den Hinweis. Beides leer: Der Ordner ist schon eingerichtet. */
+ create: string[];
+ change: string[];
+}
+
+/** Was „Open folder“ in `dir` anlegen und ändern würde. Liest nur. */
+export function planFolder(dir: string, entry: string, createModel: boolean): FolderPlan {
+ const create: string[] = [];
+ const change: string[] = [];
+ const pj = readJson<ProjectJson>(path.join(dir, '.soma', 'project.json'));
+ if (!fs.existsSync(path.join(dir, '.soma'))) create.push('.soma/ app data, cache and skills (intermediate results are ignored by Git)');
+ else if (!pj) create.push('.soma/project.json ID and settings of the model');
+ else if (pj.entry !== entry) change.push(`.soma/project.json entry point ${entry}`);
+ if (createModel) create.push('model.py a model from the template with an example part');
+ if (!isFullModel(dir)) {
+ const agents = read(path.join(dir, 'AGENTS.md'));
+ if (agents == null) create.push('AGENTS.md instructions for the agent');
+ else if (!hasSection(agents)) change.push('AGENTS.md adds a section for SOMA at the end');
+ const claude = read(path.join(dir, 'CLAUDE.md'));
+ if (claude == null) create.push('CLAUDE.md points Claude Code to AGENTS.md');
+ else if (!hasClaudeRef(claude)) change.push('CLAUDE.md adds a line that points to AGENTS.md');
+ }
+ if ((create.length || change.length) && !fs.existsSync(path.join(dir, 'output'))) create.push('output/ the result of each build (model.step)');
+ return { dir, entry, createModel, create, change };
+}
+
+/** Kopie einer Datei des Nutzers in die Sicherungen, bevor die App sie ändert. */
+function backupFile(file: string, backupDir: string): void {
+ fs.mkdirSync(backupDir, { recursive: true });
+ fs.copyFileSync(file, path.join(backupDir, path.basename(file)));
+}
+
+/**
+ * Richtet den Ordner nach `plan` ein und gibt die Kennung des Modells zurück. Eine Kennung aus .soma/project.json bleibt,
+ * außer ein anderer Ordner oder ein Arbeitsordner der App hat schon dieselbe (kopierter Ordner): dann eine neue.
+ * `backupRoot`: dort landen die Fassungen geänderter Dateien.
+ */
+export function applyFolder(plan: FolderPlan, backupRoot: string): { id: string; newId: boolean } {
+ const { dir, entry } = plan;
+ const pjFile = path.join(dir, '.soma', 'project.json');
+ const old = readJson<ProjectJson>(pjFile);
+ const taken = (id: string) => {
+ const other = folderOf(id);
+ if (other && fs.existsSync(other) && !sameDir(other, dir)) return true;
+ return !other && fs.existsSync(path.join(workspacesDir(), id));
+ };
+ const keep = old && isProjectId(old.id) && !taken(old.id);
+ const id = keep ? old.id : randomUUID();
+ const backupDir = path.join(backupRoot, `${id}-folder-${new Date().toISOString().replace(/[:.]/g, '-')}`);
+ const full = isFullModel(dir);
+
+ fs.mkdirSync(path.join(dir, '.soma'), { recursive: true });
+ const ignore = path.join(dir, '.soma', '.gitignore');
+ if (!full && !fs.existsSync(ignore)) fs.writeFileSync(ignore, SOMA_GITIGNORE);
+ if (plan.createModel) fs.copyFileSync(path.join(templateDir(), 'model.py'), resolveInside(dir, 'model.py'));
+
+ const pj: ProjectJson = old
+ ? { ...old, id, entry }
+ : { id, name: path.basename(dir), api_version: API_VERSION, app_version: SOMA_VERSION, entry, main_output: 'output/model.step', created: new Date().toISOString(), requirements: FOLDER_REQUIREMENTS };
+ if (!old || old.id !== id || old.entry !== entry) writeAtomic(pjFile, JSON.stringify(pj, null, 2));
+
+ if (!full) {
+ writeFolderFiles(dir, entry, backupDir);
+ // Skills nach den Vorgaben (E46), nur beim ersten Einrichten. Ihre Liste kommt in den Abschnitt von AGENTS.md
+ if (!old) {
+ const skills = applyDefaultSkills(dir, skillDirs(), skillBackupsDir(id), getSkillDefaults());
+ writeAtomic(pjFile, JSON.stringify({ ...pj, ...(skills.always.length ? { skills: skills.always } : {}), ...(skills.demand.length ? { skills_on_demand: skills.demand } : {}) }, null, 2));
+ }
+ }
+ return { id, newId: !!old && !keep };
+}
+
+/** AGENTS.md mit dem Abschnitt und CLAUDE.md mit dem Verweis schreiben, soweit nötig. Geänderte Dateien vorher sichern. */
+function writeFolderFiles(dir: string, entry: string, backupDir: string): void {
+ const agentsFile = path.join(dir, 'AGENTS.md');
+ const plain = isPlainScript(path.join(dir, entry));
+ const cur = read(agentsFile);
+ const next = withSection(cur, (skills) => folderSection(entry, plain, skills));
+ if (next !== cur) {
+ if (cur != null) backupFile(agentsFile, backupDir);
+ writeAtomic(agentsFile, next);
+ }
+ const claudeFile = path.join(dir, 'CLAUDE.md');
+ const claude = read(claudeFile);
+ if (claude == null) writeAtomic(claudeFile, `${CLAUDE_REF}\n`);
+ else if (!hasClaudeRef(claude)) {
+ backupFile(claudeFile, backupDir);
+ const eol = claude.includes('\r\n') ? '\r\n' : '\n';
+ writeAtomic(claudeFile, `${claude.replace(/\s*$/, '')}${eol}${eol}<!-- SOMA: instructions for the 3D model are in AGENTS.md -->${eol}${CLAUDE_REF}${eol}`);
+ }
+}
+
+/**
+ * Beim Öffnen: Den Abschnitt in AGENTS.md auf den Stand dieser App bringen (neue Vorlage, andere Einstiegsdatei). Nur
+ * wenn er schon da ist, die Liste der Skills bleibt. Die alte Fassung kommt in die Sicherungen. Fehlt der Abschnitt
+ * (vom Nutzer entfernt), bleibt das so: „Open folder“ fragt beim nächsten Mal wieder.
+ */
+export function refreshFolderSection(dir: string, entry: string, backupRoot: string, id: string): void {
+ const agentsFile = path.join(dir, 'AGENTS.md');
+ const cur = read(agentsFile);
+ if (!hasSection(cur)) return;
+ const next = withSection(cur, (skills) => folderSection(entry, isPlainScript(path.join(dir, entry)), skills));
+ if (next === cur) return;
+ backupFile(agentsFile, path.join(backupRoot, `${id}-folder-${new Date().toISOString().replace(/[:.]/g, '-')}`));
+ writeAtomic(agentsFile, next);
+}
+
+function sameDir(a: string, b: string): boolean {
+ const real = (p: string) => { try { return fs.realpathSync.native(p).toLowerCase(); } catch { return path.resolve(p).toLowerCase(); } };
+ return real(a) === real(b);
+}
diff --git a/app/src/main/main.ts b/app/src/main/main.ts
index c93da29..9978868 100644
--- a/app/src/main/main.ts
+++ b/app/src/main/main.ts
@@ -77,10 +77,18 @@ function registerIpc(ctl: ProjectController): void {
ipcMain.handle('project:saveState', () => ctl.saveState());
ipcMain.handle('project:save', (_e, saveAs?: boolean) => ctl.save(!!saveAs));
ipcMain.handle('project:openZip', () => ctl.openZip());
+ ipcMain.handle('project:openFolder', () => ctl.openFolder());
ipcMain.handle('project:exportZip', () => ctl.exportZip());
ipcMain.handle('project:createFromCadQuery', () => ctl.createFromCadQuery());
ipcMain.handle('project:exportCadQuery', () => ctl.exportCadQuery());
ipcMain.handle('project:reveal', () => ctl.reveal());
+ // Agenten-Apps (Claude Desktop, Codex-App) öffnen den Arbeitsordner selbst. `soma` finden sie über .soma/env (AGENTS.md)
+ ipcMain.handle('project:copyPath', (): FileOpResult => {
+ const dir = ctl.session?.dir;
+ if (!dir) return { ok: false, error: 'No model is open.' };
+ if (process.env.SOMA_TEST === '1') testClipboard = dir; else clipboard.writeText(dir);
+ return { ok: true, path: dir };
+ });
ipcMain.handle('project:setThumb', (_e, dataUrl: string) => {
const m = /^data:image\/jpeg;base64,([A-Za-z0-9+/=]+)$/.exec(String(dataUrl));
if (!m || m[1].length > 2_000_000 || !ctl.session) return;
diff --git a/app/src/main/packages.ts b/app/src/main/packages.ts
index 3dfce20..960b6ce 100644
--- a/app/src/main/packages.ts
+++ b/app/src/main/packages.ts
@@ -2,6 +2,7 @@ import { spawn, type ChildProcess } from 'node:child_process';
import fs from 'node:fs';
import path from 'node:path';
import { samePath } from './animations';
+import { resolveInside } from './files';
import { pythonExe, warmDir } from './paths';
/**
@@ -122,10 +123,22 @@ function basePackages(env: string): Set<string> {
} catch { return new Set(); }
}
+/**
+ * Paketliste des Modells, wie `requirements_path` in python/soma/env.py: Ein geöffneter Ordner (Ordner-Modus) hat sie in
+ * .soma/, eine requirements.txt dort gehört dem Nutzer. project.json nennt sie dann unter "requirements".
+ */
+export function requirementsFile(dir: string): string {
+ try {
+ const rel = (JSON.parse(fs.readFileSync(path.join(dir, '.soma', 'project.json'), 'utf8')) as { requirements?: unknown }).requirements;
+ if (typeof rel === 'string' && rel) return resolveInside(dir, rel);
+ } catch { /* Vorgabe */ }
+ return path.join(dir, 'requirements.txt');
+}
+
/** Zeilen aus requirements.txt, die in der Projektumgebung fehlen oder dort eine andere Version haben. */
function missingLines(dir: string): Requirement[] {
let text: string;
- try { text = fs.readFileSync(path.join(dir, 'requirements.txt'), 'utf8'); } catch { return []; }
+ try { text = fs.readFileSync(requirementsFile(dir), 'utf8'); } catch { return []; }
const { env } = envPaths(dir);
const have = installedInEnv(env);
const base = basePackages(env);
@@ -150,7 +163,7 @@ export async function installMissing(dir: string): Promise<string | null> {
if (!missing.length) return null;
const { env, python } = envPaths(dir);
let options: string[] = [];
- try { options = parseRequirements(fs.readFileSync(path.join(dir, 'requirements.txt'), 'utf8')).filter((r) => !r.name).map((r) => r.line); } catch { /* nur die Pakete */ }
+ try { options = parseRequirements(fs.readFileSync(requirementsFile(dir), 'utf8')).filter((r) => !r.name).map((r) => r.line); } catch { /* nur die Pakete */ }
const list = path.join(env, 'restore-requirements.txt');
try { fs.writeFileSync(list, [...options, ...missing.map((r) => r.line)].join('\n') + '\n'); } catch (e) {
return `Could not write the package list: ${e instanceof Error ? e.message : String(e)}`;
diff --git a/app/src/main/paths.ts b/app/src/main/paths.ts
index de8c7bf..a1ae635 100644
--- a/app/src/main/paths.ts
+++ b/app/src/main/paths.ts
@@ -10,6 +10,8 @@ export function userDataDir(): string {
}
export const workspacesDir = () => path.join(userDataDir(), 'workspaces');
+/** Geöffnete Ordner (Ordner-Modus): Kennung des Modells → Pfad. Ihre Modelle liegen nicht unter workspaces/. */
+export const foldersFile = () => path.join(userDataDir(), 'folders.json');
/** Zweite Kopie des Projektzustands ausserhalb des Arbeitsordners (E27). */
export const projectStateDir = () => path.join(userDataDir(), 'projects');
export const appStateFile = () => path.join(userDataDir(), 'state.json');
diff --git a/app/src/main/projects.ts b/app/src/main/projects.ts
index e9bdfeb..32abed5 100644
--- a/app/src/main/projects.ts
+++ b/app/src/main/projects.ts
@@ -12,12 +12,13 @@ import { DrawingBuilder, isDrawingFile, readDrawingList } from './drawings';
import { resolveInside } from './files';
import { BuildManager, buildIsStale, currentBuild, newestSourceMtime, runSoma } from './build';
import { checkRequest, RenderService, type RenderRequest } from './render';
-import { choose, chooseCadQueryScript, chooseExportTarget, choosePath, documentsDir, trashItem } from './dialogs';
+import { choose, chooseCadQueryScript, chooseEntryScript, chooseExportTarget, chooseFolder, choosePath, documentsDir, trashItem } from './dialogs';
+import { applyFolder, planFolder, refreshFolderSection, topLevelScripts } from './folders';
import { GitRepo, type GitStatus } from './git';
import { MeasureService } from './measure';
import { ensureEnv, envIsCurrent, installMissing, missingPackages } from './packages';
import { checkParamValue, isParamValue, readUserParams, writeUserParams } from './params';
-import { backupsDir, helpDir, previewsDir, skillBackupsDir, skillDirs } from './paths';
+import { backupsDir, helpDir, previewsDir, skillBackupsDir, skillDirs, userDataDir } from './paths';
import { syncHelpImages } from './help';
import { HELP_SKILL } from '../shared/help';
import { stepPreview, storeBuildAsPreview, type StepStamp } from './previews';
@@ -27,7 +28,7 @@ import {
import { TerminalManager } from './terminals';
import { watchProject } from './watcher';
import {
- backupWorkspace, createProject, discardWorkspace, extractProject, forgetProject, getAppState, inspectProject, isProjectId, isUntouched, patchAppState, projectDir,
+ backupWorkspace, createProject, discardWorkspace, extractProject, folderId, forgetProject, getAppState, inspectProject, isFolderProject, isProjectId, isUntouched, patchAppState, projectDir, registerFolder,
getSkillDefaults, readProjectJson, readSkillModes, renameProject, setLastProject, setSkillDefault, stampAppVersion, updateProjectSkills,
} from './workspace';
import { readZipTexts, saveProjectZip, ZIP_INFO_PATH, type ZipInfo } from './zip';
@@ -36,6 +37,8 @@ import { readZipTexts, saveProjectZip, ZIP_INFO_PATH, type ZipInfo } from './zip
interface Session {
id: string;
dir: string;
+ /** Geöffneter Ordner des Nutzers (Ordner-Modus, folders.ts): kein git init, Snapshot, Restore oder Speichern als .soma. */
+ folder: boolean;
builds: BuildManager;
terminals: TerminalManager;
git: GitRepo;
@@ -96,7 +99,7 @@ export class ProjectController {
info(): ProjectInfo {
const s = this.need();
const { name, problems } = inspectProject(s.id);
- return { id: s.id, name, dir: s.dir, problems, autoBuild: s.builds.autoBuild };
+ return { id: s.id, name, dir: s.dir, problems, autoBuild: s.builds.autoBuild, folder: s.folder, entry: readProjectJson(s.id)?.entry || 'model.py' };
}
close(): void {
@@ -133,10 +136,18 @@ export class ProjectController {
// Dasselbe Modell neu öffnen (etwa „Arbeitsstand behalten“ beim Öffnen seiner Datei) verwirft es nie
if (this.session?.id === id) this.close(); else await this.leave();
const dir = projectDir(id);
+ const folder = isFolderProject(id);
+ if (folder && !fs.existsSync(dir)) throw new Error(`The folder no longer exists: ${dir}. Open it again with “Open folder” at its new place.`);
const builds = new BuildManager(dir);
const terminals = new TerminalManager(this.wc, dir);
const git = new GitRepo(dir);
- void git.ensureIgnored(); // ältere Projekte: Zwischenergebnisse auch aus den Commits des Agenten heraushalten
+ // Ältere Projekte: Zwischenergebnisse auch aus den Commits des Agenten heraushalten. Im Ordner-Modus gehört das Repository
+ // dem Nutzer, dort hält .soma/.gitignore die Zwischenergebnisse heraus
+ if (!folder) void git.ensureIgnored();
+ else {
+ try { refreshFolderSection(dir, readProjectJson(id)?.entry || 'model.py', backupsDir(), id); }
+ catch (e) { console.error('[soma] Could not update the SOMA section in AGENTS.md:', e); }
+ }
syncHelpImages(dir, helpDir()); // Bilder der Anleitung (E83) fehlen nach dem Öffnen einer .soma-Datei oder sind von einer älteren App
const anims = new AnimBuilder(dir, () => this.send('anim:changed'));
const drawings = new DrawingBuilder(dir, () => this.send('drawings:changed'));
@@ -145,7 +156,7 @@ export class ProjectController {
// Projektumgebung (E67): Meist steht sie schon, sonst legt `soma env` sie in rund 0,5 s an. Die Terminals kennen ihre
// Pfade vorab, gewartet wird nur vor dem Installieren von Paketen
const env = envIsCurrent(dir) ? Promise.resolve(null) : ensureEnv(dir);
- const session: Session = { id, dir, builds, terminals, git, measure: new MeasureService(dir), anims, drawings, stopWatch, signature: '', env, stepStamps: new Map(), stepJobs: new Map(), poll: setInterval(() => void this.pollGit(), POLL_MS) };
+ const session: Session = { id, dir, folder, builds, terminals, git, measure: new MeasureService(dir), anims, drawings, stopWatch, signature: '', env, stepStamps: new Map(), stepJobs: new Map(), poll: setInterval(() => void this.pollGit(), POLL_MS) };
this.session = session;
void env.then((err) => { if (err) { console.error('[soma]', err); builds.reportPackageError(err); } });
builds.on('status', (st) => {
@@ -166,6 +177,75 @@ export class ProjectController {
return info;
}
+ /**
+ * „Open folder“ (Ordner-Modus): SOMA in einem Ordner des Nutzers. Erst die Einstiegsdatei klären, dann sagt ein Hinweis,
+ * was angelegt und was geändert wird (Wunsch des Nutzers), mit Abbrechen. Ein schon eingerichteter Ordner öffnet ohne Frage.
+ */
+ async openFolder(): Promise<OpenResult> {
+ const picked = await chooseFolder(this.getWin());
+ if (!picked) return { cancelled: true };
+ const dir = path.resolve(picked);
+ if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return { cancelled: false, error: `Not a folder: ${dir}` };
+ const inside = (a: string, b: string) => { const r = path.relative(b, a); return r === '' || (!r.startsWith('..') && !path.isAbsolute(r)); };
+ if (inside(dir, userDataDir()) || inside(userDataDir(), dir)) return { cancelled: false, error: 'This folder holds the app data of SOMA. Choose another folder.' };
+
+ // Schon eingetragen (gleicher Ordner): nur die Einstiegsdatei aus project.json prüfen
+ const pj = (() => { try { return JSON.parse(fs.readFileSync(path.join(dir, '.soma', 'project.json'), 'utf8')) as { entry?: unknown }; } catch { return null; } })();
+ let entry = typeof pj?.entry === 'string' && pj.entry && fs.existsSync(path.join(dir, pj.entry)) ? pj.entry : null;
+ let createModel = false;
+ if (!entry && fs.existsSync(path.join(dir, 'model.py'))) entry = 'model.py';
+ if (!entry) {
+ const scripts = topLevelScripts(dir);
+ if (!scripts.length) { createModel = true; entry = 'model.py'; }
+ else {
+ const c = await choose(this.getWin(), {
+ title: 'Open folder',
+ message: 'Which script builds the model?',
+ detail: `The folder has no model.py, but other Python scripts (${scripts.slice(0, 5).join(', ')}${scripts.length > 5 ? ' …' : ''}). ` +
+ 'Choose the one that builds the model (plain CadQuery with show_object or result works too), or start a new model.py from the template.',
+ buttons: ['Choose script …', 'Create model.py', 'Cancel'],
+ });
+ if (c === 1) { createModel = true; entry = 'model.py'; }
+ else if (c !== 0) return { cancelled: true };
+ else {
+ const file = await chooseEntryScript(this.getWin(), dir);
+ if (!file) return { cancelled: true };
+ const rel = path.relative(dir, file);
+ if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return { cancelled: false, error: 'The script must be inside the folder.' };
+ entry = rel.split(path.sep).join('/');
+ }
+ }
+ }
+
+ const plan = planFolder(dir, entry, createModel);
+ if (plan.create.length || plan.change.length) {
+ const lines: string[] = [];
+ if (plan.create.length) lines.push('Creates:', ...plan.create.map((l) => ` ${l}`));
+ if (plan.change.length) lines.push(...(lines.length ? [''] : []), 'Changes:', ...plan.change.map((l) => ` ${l}`), '', 'Changed files are backed up first.');
+ lines.push('', 'Your other files stay as they are. SOMA does not create a Git repository or commit here.');
+ const c = await choose(this.getWin(), {
+ title: 'Open folder',
+ message: plan.change.length ? `SOMA creates and changes files in ${path.basename(dir)}.` : `SOMA creates files in ${path.basename(dir)}.`,
+ detail: `${dir}\n\n${lines.join('\n')}`,
+ buttons: ['Open', 'Cancel'],
+ });
+ if (c !== 0) return { cancelled: true };
+ }
+ let id: string;
+ try {
+ const r = applyFolder(plan, backupsDir());
+ id = r.id;
+ const known = folderId(dir);
+ if (known && known !== id) forgetProject(known); // derselbe Ordner unter alter Kennung (project.json ersetzt)
+ registerFolder(id, dir);
+ patchAppState(id, {}); // zweite Kopie des Projektzustands (E27)
+ } catch (e) {
+ return { cancelled: false, error: `The folder could not be set up: ${e instanceof Error ? e.message : String(e)}` };
+ }
+ await this.open(id);
+ return { cancelled: false, opened: true };
+ }
+
async create(name?: string): Promise<ProjectInfo> {
const { id } = await createProject(name);
return this.open(id);
@@ -255,7 +335,8 @@ export class ProjectController {
// 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;
+ if (s.folder) unsaved = false; // der Ordner ist das Modell, es gibt keine Modelldatei
+ else if (!app.zipPath) unsaved = true;
else if (hasRepo) unsaved = st.dirty || st.head !== (app.savedHead ?? null);
else unsaved = newestSourceMtime(s.dir) > (app.savedAt ?? 0); // ohne Git bleibt nur der Zeitvergleich
return { zipPath: app.zipPath ?? null, savedHead: app.savedHead ?? null, head: st.head, dirtyFiles: st.changed, unsaved, hasRepo, savedAt: app.zipPath ? app.savedAt ?? null : null };
@@ -410,12 +491,13 @@ export class ProjectController {
await s.builds.whenIdle();
if (s.builds.status.state === 'error') warnings.push('The last build failed. The ZIP contains the last successful version of output/model.step.');
let dirty = false;
- if (await s.git.isRepo()) {
+ // Im Ordner-Modus geht das Repository des Nutzers nicht mit und wird nicht umgepackt
+ if (!s.folder && await s.git.isRepo()) {
try { await s.git.pack(); } catch { /* nur größer */ }
dirty = (await s.git.status()).dirty;
}
- const info: ZipInfo = { savedAt: new Date().toISOString(), head: await s.git.head(), id: s.id, name: pj?.name ?? s.id, ...(dirty ? { dirty } : {}) };
- await saveProjectZip(s.dir, dest, info);
+ const info: ZipInfo = { savedAt: new Date().toISOString(), head: s.folder ? null : await s.git.head(), id: s.id, name: pj?.name ?? s.id, ...(dirty ? { dirty } : {}) };
+ await saveProjectZip(s.dir, dest, info, !s.folder);
patchAppState(s.id, { exportDir: path.dirname(dest) });
return { ok: true, files: [dest], target: dest, ...(warnings.length ? { warnings } : {}) };
} catch (e) {
@@ -430,6 +512,7 @@ export class ProjectController {
*/
async save(saveAs = false): Promise<SaveResult> {
const s = this.need();
+ if (s.folder) return { cancelled: false, error: 'This model is a folder: its files are saved in place. Export › Everything as ZIP makes a copy as a file.' };
const app = getAppState(s.id);
let zipPath = saveAs ? undefined : app.zipPath;
if (zipPath && !fs.existsSync(path.dirname(zipPath))) zipPath = undefined; // Zielordner weg (z. B. USB-Stick ab): neu fragen
@@ -511,6 +594,18 @@ export class ProjectController {
const dir = projectDir(id);
const remember = () => patchAppState(id, { zipPath, savedHead: info?.head ?? null, savedAt: Date.now() });
+ // Die Datei ist ein Export eines geöffneten Ordners: den Ordner nie ersetzen, nur ihn öffnen
+ if (isFolderProject(id)) {
+ const c = await choose(this.getWin(), {
+ title: 'Open model', message: 'This file is a copy of a model you opened as a folder.',
+ detail: `The folder: ${dir}\nSOMA does not replace a folder of yours with a file. To work on the file separately, open it on another computer or move the folder first.`,
+ buttons: ['Open the folder', 'Cancel'],
+ });
+ if (c !== 0) return { cancelled: true };
+ await this.open(id);
+ return { cancelled: false, opened: true };
+ }
+
if (!fs.existsSync(dir)) {
try { await extractProject(zipPath, id); } catch (e) { return { cancelled: false, error: `Unpacking failed: ${e instanceof Error ? e.message : String(e)}` }; }
remember();
@@ -557,7 +652,8 @@ export class ProjectController {
async gitLog(): Promise<GitLog> {
const s = this.need();
- const problems = await s.git.problems();
+ // Im Ordner-Modus ist das Repository Sache des Nutzers: anderer Branch oder gar keins ist kein Problem
+ const problems = s.folder ? [] : await s.git.problems();
const hasRepo = await s.git.isRepo();
const commits = hasRepo ? await s.git.log() : [];
const st = hasRepo ? await s.git.status() : { changed: 0, head: null };
@@ -668,6 +764,7 @@ export class ProjectController {
async restore(hash: string): Promise<RestoreResult> {
const s = this.need();
+ if (s.folder) return { cancelled: false, error: 'SOMA does not restore versions in a folder you opened. Use Git or your agent for that.' };
const commit = (await s.git.log()).find((c) => c.hash === hash);
if (!commit) return { cancelled: false, error: 'This version no longer exists in the history.' };
const c = await choose(this.getWin(), {
@@ -1022,9 +1119,20 @@ export class ProjectController {
* Modell geht ohne Rückfrage. Das gerade geöffnete Modell nicht (erst ein anderes öffnen).
*/
async remove(id: string): Promise<RemoveResult> {
- if (!isProjectId(id) || !fs.existsSync(projectDir(id))) return { removed: false, error: 'This model no longer exists on this computer.' };
+ // Ein fehlender Ordner (Ordner-Modus) lässt sich trotzdem aus der Liste nehmen
+ if (!isProjectId(id) || (!fs.existsSync(projectDir(id)) && !isFolderProject(id))) return { removed: false, error: 'This model no longer exists on this computer.' };
if (this.session?.id === id) return { removed: false, error: 'The open model cannot be removed. Open another one first.' };
const dir = projectDir(id);
+ // Ein geöffneter Ordner gehört dem Nutzer: nur aus der Liste nehmen, der Ordner bleibt
+ if (isFolderProject(id)) {
+ const c = await choose(this.getWin(), {
+ title: 'Remove model', message: `Remove “${readProjectJson(id)?.name ?? path.basename(dir)}” from the list?`,
+ detail: `The folder stays as it is: ${dir}\n“Open folder” brings it back.`, buttons: ['Remove', 'Cancel'],
+ });
+ if (c !== 0) return { removed: false, cancelled: true };
+ forgetProject(id);
+ return { removed: true };
+ }
if (!(await isUntouched(id))) {
const name = readProjectJson(id)?.name ?? id.slice(0, 8);
const app = getAppState(id);
diff --git a/app/src/main/skills.ts b/app/src/main/skills.ts
index 9ee8df0..6562f0f 100644
--- a/app/src/main/skills.ts
+++ b/app/src/main/skills.ts
@@ -48,8 +48,8 @@ function inLibrary<T>(lib: Map<string, T>, id: string): T | undefined {
return lib.get(id) ?? lib.get(currentSkillId(id));
}
export const SKILLS_DIR = '.soma/skills';
-const BEGIN = '<!-- soma:skills -->';
-const END = '<!-- /soma:skills -->';
+export const BEGIN = '<!-- soma:skills -->';
+export const END = '<!-- /soma:skills -->';
/** Überschrift der Liste „Bei Bedarf“ in AGENTS.md, trennt sie von „Immer“. */
const DEMAND_HEAD = '### Read when relevant';
export const MAX_BYTES = 256 * 1024;
diff --git a/app/src/main/workspace.ts b/app/src/main/workspace.ts
index 9bab866..377476c 100644
--- a/app/src/main/workspace.ts
+++ b/app/src/main/workspace.ts
@@ -5,7 +5,7 @@ import type { ProjectListEntry, SkillMode } from '../shared/types';
import { SOMA_VERSION, isNewerVersion } from '../shared/version';
import { runSoma } from './build';
import { GitRepo } from './git';
-import { appStateFile, backupsDir, editBackupsDir, previewsDir, projectStateDir, skillBackupsDir, skillDirs, templateDir, thumbnailsDir, workspacesDir } from './paths';
+import { appStateFile, backupsDir, editBackupsDir, foldersFile, previewsDir, projectStateDir, skillBackupsDir, skillDirs, templateDir, thumbnailsDir, workspacesDir } from './paths';
import { SKILLS_DIR, applyDefaultSkills, currentSkillId, isSkillId, isSkillMode, type SkillDefaults, type SkillModes } from './skills';
import { extractZip } from './zip';
@@ -27,6 +27,8 @@ export interface ProjectJson {
skills_on_demand?: string[];
/** Einstellungen der Skills je Kennung, nur vom Standard abweichende Werte (auch für ausgeschaltete Skills). */
skill_settings?: Record<string, Record<string, number | string>>;
+ /** Paketliste (E67), wenn nicht requirements.txt: im Ordner-Modus .soma/requirements.txt (packages.ts, env.py). */
+ requirements?: string;
}
/** Zweite Kopie des Projektzustands in den App-Daten (E27) plus Angaben, die nur die App braucht. */
@@ -46,7 +48,39 @@ export const isProjectId = (id: string) => UUID.test(id);
export function projectDir(id: string): string {
if (!isProjectId(id)) throw new Error(`Invalid project ID: ${id}`);
- return path.join(workspacesDir(), id);
+ return folderOf(id) ?? path.join(workspacesDir(), id);
+}
+
+/**
+ * Ordner-Modus: Modelle in einem Ordner des Nutzers, den er mit „Open folder“ geöffnet hat. Der Ordner gehört ihm: Die App
+ * legt dort kein Git an, verschiebt und löscht ihn nie (E69 und „Remove“ gelten nicht), sie schreibt nur ihren Teil
+ * (.soma/, den Abschnitt in AGENTS.md, folders.ts).
+ */
+function readFolders(): Record<string, string> {
+ const all = readJson<Record<string, unknown>>(foldersFile()) ?? {};
+ const out: Record<string, string> = {};
+ for (const [id, dir] of Object.entries(all)) if (isProjectId(id) && typeof dir === 'string' && path.isAbsolute(dir)) out[id] = dir;
+ return out;
+}
+
+export const folderOf = (id: string): string | null => readFolders()[id] ?? null;
+export const isFolderProject = (id: string): boolean => folderOf(id) !== null;
+/** Kennung, unter der ein Ordner schon eingetragen ist (gleicher Ordner, auch über Kurznamen oder andere Schreibweise). */
+export function folderId(dir: string): string | null {
+ const real = (p: string) => { try { return fs.realpathSync.native(p).toLowerCase(); } catch { return path.resolve(p).toLowerCase(); } };
+ const want = real(dir);
+ return Object.entries(readFolders()).find(([, d]) => real(d) === want)?.[0] ?? null;
+}
+
+export function registerFolder(id: string, dir: string): void {
+ writeJson(foldersFile(), { ...readFolders(), [id]: path.resolve(dir) });
+}
+
+function unregisterFolder(id: string): void {
+ const all = readFolders();
+ if (!(id in all)) return;
+ delete all[id];
+ writeJson(foldersFile(), all);
}
const stateFile = (id: string) => path.join(projectStateDir(), `${id}.json`);
@@ -175,7 +209,8 @@ export function inspectProject(id: string): { name: string; problems: string[] }
for (const s of [pj?.skills, pj?.skills_on_demand].flatMap((x) => (Array.isArray(x) ? x : [])).filter(isSkillId)) {
if (!fs.existsSync(path.join(dir, SKILLS_DIR, `${s}.md`))) problems.push(`The skill “${s}” is switched on, but ${SKILLS_DIR}/${s}.md is missing.`);
}
- for (const bad of ['.venv', 'venv', 'env']) {
+ // Ein geöffneter Ordner darf eigene Umgebungen haben, sie gehören dem Nutzer
+ for (const bad of isFolderProject(id) ? [] : ['.venv', 'venv', 'env']) {
if (fs.existsSync(path.join(dir, bad, 'pyvenv.cfg'))) problems.push(`The project contains its own Python environment (${bad}/). It is ignored and not packed into the saved file.`);
}
return { name: pj?.name ?? backup?.name ?? id, problems };
@@ -183,14 +218,21 @@ export function inspectProject(id: string): { name: string; problems: string[] }
export function listProjects(): ProjectListEntry[] {
const root = workspacesDir();
- if (!fs.existsSync(root)) return [];
const out: ProjectListEntry[] = [];
- for (const id of fs.readdirSync(root)) {
- if (!isProjectId(id)) continue;
+ const folders = readFolders();
+ for (const id of fs.existsSync(root) ? fs.readdirSync(root) : []) {
+ if (!isProjectId(id) || folders[id]) continue;
const dir = path.join(root, id);
const pj = readJson<ProjectJson>(path.join(dir, '.soma', 'project.json'));
out.push({ id, name: pj?.name ?? id.slice(0, 8), modified: fs.statSync(dir).mtimeMs, saved: !!getAppState(id).zipPath });
}
+ // Geöffnete Ordner: Fehlt einer (verschoben, umbenannt, Laufwerk ab), bleibt er mit Hinweis in der Liste (E28: melden)
+ for (const [id, dir] of Object.entries(folders)) {
+ const pj = readJson<ProjectJson>(path.join(dir, '.soma', 'project.json'));
+ let modified = 0;
+ try { modified = fs.statSync(path.join(dir, '.soma')).mtimeMs; } catch { /* fehlt */ }
+ out.push({ id, name: pj?.name ?? path.basename(dir), modified, saved: true, folder: dir, ...(fs.existsSync(dir) ? {} : { missing: true }) });
+ }
return out.sort((a, b) => b.modified - a.modified);
}
@@ -265,6 +307,7 @@ export function setSkillBase(id: string, hash: string | null): void {
* Unter Windows hält ein eben beendetes Terminal den Ordner noch kurz als aktuelles Verzeichnis fest, daher mehrere Versuche.
*/
export async function backupWorkspace(id: string): Promise<string> {
+ if (isFolderProject(id)) throw new Error('This model is a folder of yours. SOMA does not move it.');
const src = projectDir(id);
const stamp = new Date().toISOString().replace(/[:.]/g, '-');
const dst = path.join(backupsDir(), `${id}-${stamp}`);
@@ -297,6 +340,7 @@ const hasFiles = (dir: string): boolean => {
*/
export async function isUntouched(id: string): Promise<boolean> {
try {
+ if (isFolderProject(id)) return false; // ein Ordner des Nutzers verschwindet nie von selbst
const dir = projectDir(id);
if (!fs.existsSync(dir) || getAppState(id).zipPath) return false;
if (UNTRACKED_CONTENT.some((rel) => hasFiles(path.join(dir, rel)))) return false;
@@ -315,6 +359,7 @@ export async function isUntouched(id: string): Promise<boolean> {
*/
export function forgetProject(id: string): void {
if (!isProjectId(id)) return;
+ unregisterFolder(id);
for (const p of [stateFile(id), path.join(previewsDir(), id), path.join(thumbnailsDir(), `${id}.jpg`)]) {
try { fs.rmSync(p, { recursive: true, force: true }); } catch { /* Cache, nächstes Mal */ }
}
@@ -326,6 +371,7 @@ export function forgetProject(id: string): void {
* halb gelöschten Ordner zu hinterlassen. Klappt es nicht, bleibt das Modell stehen. Liefert true, wenn es weg ist.
*/
export async function discardWorkspace(id: string): Promise<boolean> {
+ if (isFolderProject(id)) return false;
const src = projectDir(id);
const tmp = path.join(workspacesDir(), `.tmp-verworfen-${randomUUID()}`);
for (let attempt = 0; ; attempt++) {
diff --git a/app/src/main/zip.ts b/app/src/main/zip.ts
index 09252b7..35aeec6 100644
--- a/app/src/main/zip.ts
+++ b/app/src/main/zip.ts
@@ -27,13 +27,13 @@ const SKIP_PATHS = new Set(['.soma/geometry', '.soma/anim', '.soma/results', '.s
const STORED = /^\.git\/objects\/|\.(png|jpe?g|webp|mp4|webm|zip|soma|gz|7z|pack)$/i;
const MAX_UNPACKED = 2 * 1024 ** 3;
-function collect(root: string): string[] {
+function collect(root: string, withGit: boolean): string[] {
const out: string[] = [];
const walk = (dir: string, rel: string) => {
for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
const r = rel ? `${rel}/${e.name}` : e.name;
if (e.isSymbolicLink()) continue;
- if (e.isDirectory()) { if (!SKIP_DIRS.has(e.name) && !SKIP_PATHS.has(r)) walk(path.join(dir, e.name), r); continue; }
+ if (e.isDirectory()) { if (!SKIP_DIRS.has(e.name) && !SKIP_PATHS.has(r) && (withGit || r !== '.git')) walk(path.join(dir, e.name), r); continue; }
if (SKIP_FILES.has(r) || (r.startsWith('.git/') && r.endsWith('.lock'))) continue;
out.push(r);
}
@@ -43,8 +43,9 @@ function collect(root: string): string[] {
}
/** Packt den Projektordner (inklusive .git) atomar in `zipPath`: erst eine .part-Datei, dann umbenennen. */
-export async function saveProjectZip(dir: string, zipPath: string, info: ZipInfo): Promise<{ files: number; bytes: number }> {
- const files = collect(dir);
+/** `withGit`: false für einen geöffneten Ordner (Ordner-Modus): Sein Repository gehört dem Nutzer und geht nicht mit. */
+export async function saveProjectZip(dir: string, zipPath: string, info: ZipInfo, withGit = true): Promise<{ files: number; bytes: number }> {
+ const files = collect(dir, withGit);
const zip = new yazl.ZipFile();
for (const rel of files) if (rel !== ZIP_INFO_PATH) zip.addFile(path.join(dir, rel), rel, { compress: !STORED.test(rel) });
zip.addBuffer(Buffer.from(JSON.stringify(info, null, 2)), ZIP_INFO_PATH);
diff --git a/app/src/preload/preload.ts b/app/src/preload/preload.ts
index 8248174..fb90113 100644
--- a/app/src/preload/preload.ts
+++ b/app/src/preload/preload.ts
@@ -14,12 +14,14 @@ const api: SomaApi = {
saveState: () => ipcRenderer.invoke('project:saveState'),
save: (saveAs) => ipcRenderer.invoke('project:save', saveAs),
openZip: () => ipcRenderer.invoke('project:openZip'),
+ openFolder: () => ipcRenderer.invoke('project:openFolder'),
exportZip: () => ipcRenderer.invoke('project:exportZip'),
createFromCadQuery: () => ipcRenderer.invoke('project:createFromCadQuery'),
onCadQueryStep: (cb) => { ipcRenderer.on('cadquery:step', (_e, s) => cb(s)); },
exportCadQuery: () => ipcRenderer.invoke('project:exportCadQuery'),
onSaveState: (cb) => { ipcRenderer.on('save:state', (_e, st) => cb(st)); },
reveal: () => ipcRenderer.invoke('project:reveal'),
+ copyPath: () => ipcRenderer.invoke('project:copyPath'),
setThumb: (dataUrl) => ipcRenderer.invoke('project:setThumb', dataUrl),
thumb: (id) => ipcRenderer.invoke('project:thumb', id),
remove: (id) => ipcRenderer.invoke('project:remove', id),
diff --git a/app/src/renderer/index.html b/app/src/renderer/index.html
index 4f6b9b0..b4a4e13 100644
--- a/app/src/renderer/index.html
+++ b/app/src/renderer/index.html
@@ -415,6 +415,7 @@
<button id="btn-new" class="mi" role="menuitem"><i data-icon="plus" data-size="15"></i><span>New model</span><span class="k">Ctrl N</span></button>
<button id="btn-new-cq" class="mi" role="menuitem" title="A model from an existing CadQuery script (.py). The script stays as it is, the original is kept in inputs/."><i data-icon="f-py" data-size="15"></i><span>New from CadQuery script …</span></button>
<button id="btn-open" class="mi" role="menuitem"><i data-icon="folder" data-size="15"></i><span>Open …</span><span class="k">Ctrl O</span></button>
+ <button id="btn-open-folder" class="mi" role="menuitem" title="Use SOMA in a folder of yours, for example a repository. SOMA says what it creates and changes there before it starts."><i data-icon="folder" data-size="15"></i><span>Open folder …</span></button>
<div id="recent-wrap"><div class="msep"></div><div class="mh">RECENT</div><div id="recent-list"></div></div>
<div class="msep"></div>
<button id="btn-save-menu" class="mi" role="menuitem"><span class="noico"></span><span>Save</span><span class="k">Ctrl S</span></button>
@@ -473,6 +474,8 @@
<div id="agent-list"></div>
<div class="msep"></div>
<button id="btn-term-plain" class="mi" role="menuitem"><i data-icon="term" data-size="15" data-stroke="2"></i><span>Empty terminal</span></button>
+ <div class="msep"></div>
+ <button id="btn-copy-path" class="mi two" role="menuitem"><i data-icon="copy" data-size="15"></i><span class="t"><span>Copy path for agent app</span><span class="sub">For Claude Desktop, the Codex app and others: open this folder there. SOMA shows their changes.</span></span></button>
</div>
<div id="menu-problems" class="menu wide" role="dialog" aria-label="Project issues" hidden>
@@ -588,6 +591,7 @@
<div id="menu-start-new" class="menu" role="menu" hidden>
<button id="start-new-tpl" class="mi two" role="menuitem"><i data-icon="plus" data-size="15"></i><span class="t"><span>From template</span><span class="sub">Example part, terminal in the model folder</span></span><span class="k">Ctrl N</span></button>
<button id="start-new-cq" class="mi two" role="menuitem" title="A model from an existing CadQuery script (.py). The script stays as it is, the original is kept in inputs/."><i data-icon="f-py" data-size="15"></i><span class="t"><span>From CadQuery script …</span><span class="sub">The script stays as it is, the original is kept in inputs/</span></span></button>
+ <button id="start-open-folder" class="mi two" role="menuitem"><i data-icon="folder" data-size="15"></i><span class="t"><span>Open folder …</span><span class="sub">Use SOMA in a folder of yours, for example a repository</span></span></button>
</div>
<!-- Einstellungen (E78): Fenster über der App, zuerst die Bibliothek der Skills. Inhalt rechts baut settings.ts -->
diff --git a/app/src/renderer/main.ts b/app/src/renderer/main.ts
index d29bcb3..cc001ac 100644
--- a/app/src/renderer/main.ts
+++ b/app/src/renderer/main.ts
@@ -145,7 +145,7 @@ function showCode(on: boolean): void {
if (on && !code.activeFile) {
const e = selection ? partEntry(selection.partId) : undefined;
if (e?.file && e.line) void code.open(e.file, { ...lineRange(e), label: e.name, color: partInfo(e.id)?.color });
- else if (project) void code.open('model.py');
+ else if (project) void code.open(project.entry);
}
renderLayout();
renderDrawingsRail();
@@ -1159,7 +1159,10 @@ async function onProject(p: ProjectInfo): Promise<void> {
if (panel === 'skills') void skills.refresh();
paramsPanel.reset();
if (panel === 'params') void paramsPanel.refresh();
- if (codeOpen) void code.open('model.py'); // die Code-Spalte bleibt offen, dann nicht leer
+ if (codeOpen) void code.open(p.entry); // die Code-Spalte bleibt offen, dann nicht leer
+ // Ordner-Modus: Der Ordner ist das Modell (kein Speichern als .soma), den Verlauf gibt es nur zum Ansehen
+ versions.setReadOnly(p.folder);
+ $('btn-save').hidden = $('btn-saveas').hidden = p.folder;
resetViewLists();
applyDisplayDefaults();
selection = null;
@@ -1202,12 +1205,13 @@ function renderSaveState(st: SaveState): void {
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 = 'Not saved yet'; }
+ if (project?.folder) { dot.style.background = unsaved ? 'var(--warn)' : 'var(--ok)'; text = unsaved ? 'Folder · unsaved edits' : 'Folder'; }
+ else if (!st.zipPath) { dot.style.background = 'var(--warn)'; text = 'Not saved yet'; }
else if (unsaved) { dot.style.background = 'var(--warn)'; text = `Not saved${st.savedAt ? ` · last ${fmtWhen(st.savedAt)}` : ''}`; }
else { dot.style.background = 'var(--ok)'; text = `Saved${st.savedAt ? ` · ${fmtWhen(st.savedAt)}` : ''}`; }
const b = $('save-badge');
b.replaceChildren(dot, text);
- b.title = st.zipPath ? `File: ${st.zipPath}` : 'Not saved yet. Ctrl+S saves.';
+ b.title = project?.folder ? `Folder: ${project.dir}\nChanges are saved in the folder itself.` : st.zipPath ? `File: ${st.zipPath}` : 'Not saved yet. Ctrl+S saves.';
versions.setSaved(st.zipPath ? st.savedHead : null);
document.title = `SOMA – ${project?.name ?? ''}${unsaved ? ' ●' : ''}`;
}
@@ -1249,6 +1253,15 @@ let saving = false;
*/
async function doSave(saveAs = false): Promise<void> {
if (saving) return;
+ // Ordner-Modus: Strg+S schreibt nur die Eingaben im Editor in den Ordner, eine .soma-Datei gibt es nicht
+ if (project?.folder) {
+ const c = await code.saveAll();
+ if (!c.ok) toast('Not everything in the editor could be saved (see the note in the code).', 'error');
+ else if (c.saved.length) { toast(`Saved in the folder: ${c.saved.join(', ')}`, 'ok'); if (c.saved.some(affectsBuild)) await api.build.run(); }
+ else toast('Nothing to save. This model is the folder itself. Export › Everything as ZIP makes a copy as a file.', 'info');
+ void refreshSaveState();
+ return;
+ }
saving = true;
const btn = $<HTMLButtonElement>('btn-save');
const label = btn.innerHTML;
@@ -1306,6 +1319,14 @@ function closeCadQueryBusy(): void {
}
/** Neues Modell aus einem CadQuery-Skript (E100). Die Hinweise des Imports (Kompatibilitätsmodus, Werte) zeigt ein Toast. */
+/** „Open folder“ (Ordner-Modus): Fragen und Hinweis stellt der Hauptprozess. */
+async function doOpenFolder(): Promise<boolean> {
+ if (!(await leaveEditor('Open folder'))) return false;
+ const r = await api.project.openFolder().catch((e: unknown) => ({ cancelled: false, opened: false, error: e instanceof Error ? e.message : String(e) }));
+ if (r.error) toast(r.error, 'error');
+ return !!r.opened;
+}
+
async function doNewFromCadQuery(): Promise<CadQueryImportResult | null> {
if (!(await leaveEditor('New model'))) return null;
let r: CadQueryImportResult;
@@ -1322,7 +1343,11 @@ async function doBuild(): Promise<void> {
if (!r.ok) { toast('Not everything could be saved (see the note in the code panel). The build waits until then.', 'error'); return; }
await api.build.run();
}
-const openProject = async (id: string) => { if (await leaveEditor('Open model')) await api.project.open(id); };
+const openProject = async (id: string) => {
+ if (!(await leaveEditor('Open model'))) return;
+ // Ein geöffneter Ordner kann fehlen (verschoben, Laufwerk ab): Der Hauptprozess sagt es
+ await api.project.open(id).catch((e: unknown) => toast(String(e instanceof Error ? e.message : e).replace(/^Error invoking remote method '[^']+': (Error: )?/, ''), 'error'));
+};
// F3 klappt den Strukturbaum auf und zu wie in CATIA (E82, Vorschlag aus dem Entwurf). Nicht beim Schreiben in Code, Terminal oder Feldern
window.addEventListener('keydown', (e) => {
@@ -1364,6 +1389,7 @@ $('btn-doc').addEventListener('click', () => { void renderRecent().then(() => me
$('btn-new').addEventListener('click', () => void doNew());
$('btn-new-cq').addEventListener('click', () => { menus.close(); void doNewFromCadQuery(); });
$('btn-open').addEventListener('click', () => void doOpen());
+$('btn-open-folder').addEventListener('click', () => { menus.close(); void doOpenFolder().then((ok) => { if (ok) showStart(false); }); });
$('btn-save').addEventListener('click', () => void doSave(false));
$('btn-save-menu').addEventListener('click', () => void doSave(false));
$('btn-saveas').addEventListener('click', () => void doSave(true));
@@ -1636,6 +1662,9 @@ function renderAgentMenu(): void {
}
$('btn-term-add').addEventListener('click', () => { renderAgentMenu(); menus.toggle($('menu-agents'), $('btn-term-add')); });
$('btn-term-plain').addEventListener('click', () => void terminals.add({ title: 'Terminal' }));
+$('btn-copy-path').addEventListener('click', () => void api.project.copyPath().then((r) => {
+ toast(r.ok ? 'Path copied. Open it as the project folder in your agent app.' : r.error ?? 'The path could not be copied.', r.ok ? 'ok' : 'error');
+}));
// ---- Trennleisten -----------------------------------------------------------------------------------------------
@@ -1680,21 +1709,24 @@ async function showStart(on: boolean): Promise<void> {
void api.project.thumb(p.id).then((url) => { if (url) th.replaceChildren(el('img', { src: url, alt: '' })); });
const cur = p.id === project?.id;
// Viele heißen „New model“: Ob es je gespeichert wurde, hilft beim Wiederfinden und beim Aufräumen
- const when = p.saved ? `changed ${fmtWhen(p.modified, true)}` : fmtWhen(p.modified, true);
- const card = el('button', { className: 'recent' + (cur ? ' cur' : ''), title: cur ? 'Currently open' : `Open ${p.name}` },
+ const when = p.folder ? (p.missing ? '' : `changed ${fmtWhen(p.modified, true)}`) : p.saved ? `changed ${fmtWhen(p.modified, true)}` : fmtWhen(p.modified, true);
+ // Ordner-Modus: Der Ordner steht im Tooltip, fehlt er, sagt die Karte es
+ const title = cur ? 'Currently open' : p.folder ? `Open ${p.name}\nFolder: ${p.folder}` : `Open ${p.name}`;
+ const card = el('button', { className: 'recent' + (cur ? ' cur' : ''), title },
th, cur && el('span', { className: 'tag', textContent: 'Open' }),
el('div', { className: 'meta' }, el('b', { textContent: p.name }),
- el('span', { className: 'sub' }, el('span', { textContent: when }), !p.saved && el('span', { className: 'unsaved', textContent: 'never saved' }))));
+ el('span', { className: 'sub' }, p.folder && el('span', { className: 'c3', textContent: 'Folder' }), when && el('span', { textContent: when }),
+ !p.saved && el('span', { className: 'unsaved', textContent: 'never saved' }), p.missing && el('span', { className: 'unsaved', textContent: 'folder missing' }))));
card.addEventListener('click', () => { if (!cur) void openProject(p.id); showStart(false); });
const item = el('div', { className: 'recent-item' }, card);
item.dataset.name = p.name.toLowerCase();
if (cur) return item;
// Entfernen (E69): Arbeitsordner in den Papierkorb, die Rückfrage im Hauptprozess sagt, was dabei verloren geht
- const rm = el('button', { className: 'recent-rm', title: `Remove “${p.name}” from this computer`, ariaLabel: `Remove ${p.name}` }, icon('trash', 14));
+ const rm = el('button', { className: 'recent-rm', title: p.folder ? `Remove “${p.name}” from the list. The folder stays.` : `Remove “${p.name}” from this computer`, ariaLabel: `Remove ${p.name}` }, icon('trash', 14));
rm.addEventListener('click', () => void (async () => {
const r = await api.project.remove(p.id).catch((e: unknown) => ({ removed: false, error: e instanceof Error ? e.message : String(e) }));
if (r.error) toast(r.error, 'error');
- if (r.removed) { toast(`“${p.name}” removed. The working folder is in the Recycle Bin.`, 'ok'); void showStart(true); }
+ if (r.removed) { toast(p.folder ? `“${p.name}” removed from the list. The folder stays as it is.` : `“${p.name}” removed. The working folder is in the Recycle Bin.`, 'ok'); void showStart(true); }
})());
item.append(rm);
return item;
@@ -1753,6 +1785,7 @@ $('start-empty-open').addEventListener('click', startOpen);
$('start-new-more').addEventListener('click', () => menus.toggle($('menu-start-new'), $('start-new-more'), 'right'));
$('start-new-cq').addEventListener('click', () => void doNewFromCadQuery());
$('start-empty-cq').addEventListener('click', () => void doNewFromCadQuery());
+$('start-open-folder').addEventListener('click', () => { menus.close(); void doOpenFolder().then((ok) => { if (ok) showStart(false); }); });
$('btn-start-tip-help').addEventListener('click', () => void help.open());
/**
* Pille „neue Version“ neben der Versionsnummer: neueste Version unter GitHub Releases (updates.ts, einmal je Sitzung). Ein
diff --git a/app/src/renderer/versions.ts b/app/src/renderer/versions.ts
index 37a8d0e..0da9c84 100644
--- a/app/src/renderer/versions.ts
+++ b/app/src/renderer/versions.ts
@@ -37,6 +37,8 @@ export class VersionsBar {
private log: GitLog = { commits: [], problems: [], head: null, dirtyFiles: 0 };
private previewHash: string | null = null;
private savedHead: string | null = null;
+ /** Ordner-Modus: Verlauf nur ansehen, die App stellt dort nichts wieder her. */
+ private readOnly = false;
private seq = 0;
private logSeq = 0;
@@ -49,6 +51,11 @@ export class VersionsBar {
/** Der alte Stand, der gerade als Vorschau zu sehen ist. */
get previewed(): CommitInfo | null { return this.previewHash ? this.log.commits.find((c) => c.hash === this.previewHash) ?? null : null; }
+ setReadOnly(on: boolean): void {
+ this.readOnly = on;
+ this.render();
+ }
+
/** Stand der letzten Speicherung, für den grünen Punkt. */
setSaved(head: string | null): void {
if (head === this.savedHead) return;
@@ -160,7 +167,7 @@ export class VersionsBar {
ui.bannerSub.textContent = `${previewCommit.subject} · ${who(previewCommit)} · ${fmtWhen(previewCommit.date, true)}`;
ui.bannerSub.title = ui.bannerSub.textContent;
}
- ui.restore.hidden = !previewCommit;
+ ui.restore.hidden = !previewCommit || this.readOnly;
ui.live.hidden = !previewCommit;
ui.problem.hidden = problems.length === 0;
ui.problem.textContent = problems.join(' ');
diff --git a/app/src/shared/types.ts b/app/src/shared/types.ts
index 2f0dcc5..9fc0072 100644
--- a/app/src/shared/types.ts
+++ b/app/src/shared/types.ts
@@ -8,10 +8,15 @@ export interface ProjectInfo {
/** Gefundene Auffaelligkeiten im Projekt (nur melden, nie automatisch reparieren, E28). */
problems: string[];
autoBuild: boolean;
+ /** Geöffneter Ordner des Nutzers (Ordner-Modus): kein Speichern als .soma, Verlauf nur lesen. */
+ folder: boolean;
+ /** Einstiegsdatei laut project.json (meist model.py). */
+ entry: string;
}
/** `saved`: Es gibt eine Modelldatei dazu (das Modell wurde mindestens einmal gespeichert). */
-export interface ProjectListEntry { id: string; name: string; modified: number; saved?: boolean }
+/** `folder`: geöffneter Ordner (Ordner-Modus) mit seinem Pfad, `missing`: den Ordner gibt es nicht mehr. */
+export interface ProjectListEntry { id: string; name: string; modified: number; saved?: boolean; folder?: string; missing?: boolean }
/** Modell von der Startseite entfernen (E69). `cancelled`: Rückfrage abgebrochen, nichts geändert. */
export interface RemoveResult { removed: boolean; cancelled?: boolean; error?: string }
@@ -433,6 +438,8 @@ export interface SomaApi {
save(saveAs?: boolean): Promise<SaveResult>;
/** Öffnet eine Modelldatei (.soma, auch .zip, E79). */
openZip(): Promise<OpenResult>;
+ /** „Open folder“ (Ordner-Modus): Ordner wählen, Hinweis, was angelegt und geändert wird, dann öffnen. */
+ openFolder(): Promise<OpenResult>;
/** Das ganze Modell als ZIP exportieren (E79), ohne Snapshot. Die Modelldatei bleibt, wie sie ist. */
exportZip(): Promise<ExportResult>;
/** Neues Modell aus einem CadQuery-Skript (E100): Dateidialog, Import, erster Build. */
@@ -444,6 +451,8 @@ export interface SomaApi {
onSaveState(cb: (s: SaveState) => void): void;
/** Zeigt die Modelldatei im Dateimanager (noch nicht gespeichert: den Arbeitsordner). */
reveal(): Promise<void>;
+ /** Pfad des Arbeitsordners in die Zwischenablage, für Agenten-Apps außerhalb der App (Claude Desktop, Codex-App). */
+ copyPath(): Promise<FileOpResult>;
/** Vorschaubild des offenen Modells für die Startseite (JPEG als Data-URL). */
setThumb(dataUrl: string): Promise<void>;
thumb(id: string): Promise<string | null>;
diff --git a/app/test/folder.mjs b/app/test/folder.mjs
new file mode 100644
index 0000000..6b652df
--- /dev/null
+++ b/app/test/folder.mjs
@@ -0,0 +1,146 @@
+// Test für „Open folder“ (Ordner-Modus): SOMA in einem Ordner des Nutzers. Ein Git-Repository mit eigener AGENTS.md,
+// CLAUDE.md und requirements.txt und einem reinen CadQuery-Skript: Abbrechen im Hinweis ändert nichts. Öffnen legt .soma/
+// an, ergänzt AGENTS.md um den Abschnitt und CLAUDE.md um den Verweis (mit Sicherung), lässt requirements.txt und Git in
+// Ruhe (kein Commit, keine Konfiguration), baut das Skript. Kein Speichern als .soma, kein Wiederherstellen, Verlauf ohne
+// Probleme. Erneutes Öffnen fragt nichts. Verlassen und Entfernen lassen den Ordner stehen. Ein leerer Ordner bekommt
+// model.py aus der Vorlage, ein kopierter Ordner eine neue Kennung, ein fehlender Ordner wird gemeldet.
+// Aufruf: node test/run-all.mjs folder (nach npm run build).
+import { exec } from 'dugite';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { checker, cleanup, sleep, startApp } from './harness.mjs';
+
+const t = checker();
+const { check } = t;
+let app;
+const work = fs.mkdtempSync(path.join(os.tmpdir(), 'soma-folder-'));
+const repo = path.join(work, 'Repo');
+const empty = path.join(work, 'Leer');
+const read = (dir, rel) => { try { return fs.readFileSync(path.join(dir, rel), 'utf8'); } catch { return null; } };
+const git = async (...args) => (await exec(['-c', 'user.name=Test', '-c', '[email protected]', ...args], repo)).stdout.trim();
+// Fehler aus dem Hauptprozess kommen im Renderer als „Error invoking remote method …“ an
+const tryEv = (ev, fn, arg) => ev(fn, arg).then((v) => ({ v }), (e) => ({ err: String(e?.message ?? e) }));
+
+const AGENTS = '# My rules\n\nUse tabs.\n';
+const CLAUDE = '# Claude\n\nBe brief.\n';
+const REQS = 'numpy\n# mine\nrequests>=2\n';
+const SCRIPT = 'import cadquery as cq\n\nbox = cq.Workplane().box(30, 20, 10)\nshow_object(box, name="Box")\n';
+
+try {
+ fs.mkdirSync(repo);
+ fs.mkdirSync(empty);
+ fs.writeFileSync(path.join(repo, 'AGENTS.md'), AGENTS);
+ fs.writeFileSync(path.join(repo, 'CLAUDE.md'), CLAUDE);
+ fs.writeFileSync(path.join(repo, 'requirements.txt'), REQS);
+ fs.writeFileSync(path.join(repo, 'part.py'), SCRIPT);
+ fs.writeFileSync(path.join(repo, 'helper.py'), 'X = 1\n');
+ await git('init', '-b', 'develop');
+ await git('add', '-A');
+ await git('commit', '-m', 'Start');
+ const head0 = await git('rev-parse', 'HEAD');
+ const config0 = read(repo, '.git/config');
+
+ app = await startApp({ name: 'folder' });
+ const { ev, waitFor } = app;
+ await waitFor('Projekt und Build', () => !!window.__t && !!window.__t.project() && window.__t.status().state === 'ok', 90000);
+ const first = await ev(() => window.__t.project());
+ check('Ein normales Modell ist kein Ordner-Modell', first.folder === false && first.entry === 'model.py');
+
+ // ---- 1) Abbrechen im Hinweis: nichts ändert sich ----
+ await app.answers([repo, 0, path.join(repo, 'part.py'), 1]);
+ const r1 = await ev(() => window.soma.project.openFolder());
+ check('Hinweis abgebrochen: nichts angelegt oder geändert', r1.cancelled === true && !fs.existsSync(path.join(repo, '.soma'))
+ && read(repo, 'AGENTS.md') === AGENTS && read(repo, 'CLAUDE.md') === CLAUDE, JSON.stringify(r1));
+
+ // ---- 2) Öffnen ----
+ await app.answers([repo, 0, path.join(repo, 'part.py'), 0]);
+ const r2 = await ev(() => window.soma.project.openFolder());
+ check('Ordner geöffnet', r2.opened === true, JSON.stringify(r2));
+ await waitFor('Ordner gebaut', () => window.__t.project()?.folder && window.__t.status().state === 'ok' && window.__t.partCount() === 1, 120000).catch(() => {});
+ const p = await ev(() => window.__t.project());
+ check('Projekt ist der Ordner, Einstieg part.py, Teil aus show_object im Viewer', p.folder === true && p.entry === 'part.py' && fs.realpathSync.native(p.dir).toLowerCase() === fs.realpathSync.native(repo).toLowerCase()
+ && (await ev(() => window.__t.partCount())) === 1, `${p.dir} ${p.entry} ${JSON.stringify(await ev(() => window.__t.status()))}`);
+ const pj = JSON.parse(read(repo, '.soma/project.json'));
+ check('.soma/project.json: Kennung, Einstieg, Paketliste in .soma/', pj.id === p.id && pj.entry === 'part.py' && pj.requirements === '.soma/requirements.txt');
+ check('Kein Arbeitsordner unter workspaces/ für dieses Modell', !fs.existsSync(path.join(app.ud, 'workspaces', p.id)));
+ const agents = read(repo, 'AGENTS.md');
+ check('AGENTS.md: eigener Text bleibt vorn, Abschnitt für SOMA dahinter', agents.startsWith(AGENTS.trim()) && agents.includes('<!-- soma:folder -->') && agents.includes('<!-- /soma:folder -->')
+ && agents.indexOf('Use tabs.') < agents.indexOf('<!-- soma:folder -->'));
+ check('Abschnitt: Einstieg part.py, Kompatibilitätsmodus, keine Pflicht zu committen, Skills-Liste', agents.includes('the entry point is `part.py`') && agents.includes('compatibility mode')
+ && !agents.includes('commit it: `git add -A`') && agents.includes('SOMA does not manage Git in this folder') && agents.includes('<!-- soma:skills -->') && agents.includes('.soma/requirements.txt'));
+ check('CLAUDE.md: eigener Text bleibt, Verweis auf AGENTS.md dazu', read(repo, 'CLAUDE.md').startsWith(CLAUDE.trim()) && read(repo, 'CLAUDE.md').includes('@AGENTS.md'));
+ const backups = fs.readdirSync(path.join(app.ud, 'workspace-backups')).filter((n) => n.startsWith(`${p.id}-folder-`));
+ check('Alte AGENTS.md und CLAUDE.md in den Sicherungen', backups.some((b) => read(path.join(app.ud, 'workspace-backups', b), 'AGENTS.md') === AGENTS
+ && read(path.join(app.ud, 'workspace-backups', b), 'CLAUDE.md') === CLAUDE), backups.join(', '));
+ check('requirements.txt des Nutzers unverändert (auch nach dem Build)', read(repo, 'requirements.txt') === REQS);
+ check('Git: kein Commit, Branch und Konfiguration unverändert', (await git('rev-parse', 'HEAD')) === head0 && (await git('branch', '--show-current')) === 'develop' && read(repo, '.git/config') === config0);
+ const porcelain = (await git('status', '--porcelain', '--untracked-files=all')).split('\n').map((l) => l.slice(3));
+ check('Git sieht keine Zwischenergebnisse aus .soma/ (eigene .gitignore)', !porcelain.some((f) => /^\.soma\/(model\.glb|model\.map\.json|build\.json|geometry\/|env\/)/.test(f))
+ && porcelain.includes('.soma/project.json'), porcelain.join(' | '));
+
+ // ---- 3) Kein Speichern als .soma, kein Wiederherstellen, Verlauf ohne Probleme ----
+ const sv = await ev(() => window.soma.project.save(false));
+ check('Speichern als .soma: Hinweis statt Datei', !!sv.error && /folder/.test(sv.error), JSON.stringify(sv).slice(0, 120));
+ check('Speicherstand: nichts ungespeichert, Speichern-Knopf ausgeblendet', (await ev(() => window.soma.project.saveState())).unsaved === false && (await ev(() => document.getElementById('btn-save').hidden)));
+ const log = await ev(() => window.soma.versions.log());
+ check('Verlauf: Commit des Repositorys, keine Meldung zum Branch', log.commits.length === 1 && log.problems.length === 0, JSON.stringify(log.problems));
+ const rs = await ev((h) => window.soma.versions.restore(h), head0);
+ check('Wiederherstellen abgelehnt, Git unverändert', !!rs.error && (await git('rev-parse', 'HEAD')) === head0);
+
+ // ---- 4) Erneut öffnen: keine Frage ----
+ await app.answers([repo]);
+ const r4 = await ev(() => window.soma.project.openFolder());
+ check('Eingerichteter Ordner öffnet ohne Rückfrage, gleiche Kennung', r4.opened === true && (await ev(() => window.__t.project())).id === p.id, JSON.stringify(r4));
+
+ // ---- 5) Verlassen und Entfernen lassen den Ordner stehen ----
+ await ev(() => window.soma.project.create());
+ await waitFor('anderes Modell', (id) => window.__t.project()?.id !== id && !window.__t.project().folder, 60000, p.id);
+ check('Nach dem Verlassen: Ordner unverändert da (E69 gilt nicht)', fs.existsSync(path.join(repo, 'part.py')) && fs.existsSync(path.join(repo, '.soma', 'project.json')));
+ const list = await ev(() => window.soma.project.list());
+ const entry = list.find((e) => e.id === p.id);
+ check('Startseite: Eintrag mit Pfad des Ordners', !!entry?.folder && !entry.missing && entry.name === 'Repo', JSON.stringify(entry));
+ await app.answers([0]);
+ const rm = await ev((id) => window.soma.project.remove(id), p.id);
+ check('Entfernen: nur aus der Liste, Ordner bleibt', rm.removed === true && fs.existsSync(path.join(repo, 'part.py')) && fs.existsSync(path.join(repo, '.soma'))
+ && !(await ev(() => window.soma.project.list())).some((e) => e.id === p.id), JSON.stringify(rm));
+
+ // ---- 6) Leerer Ordner: model.py aus der Vorlage ----
+ await app.answers([empty, 0]);
+ const r6 = await ev(() => window.soma.project.openFolder());
+ await waitFor('leerer Ordner gebaut', () => window.__t.project()?.folder && window.__t.status().state === 'ok' && window.__t.partCount() > 0, 120000).catch(() => {});
+ const pe = await ev(() => window.__t.project());
+ check('Leerer Ordner: model.py, AGENTS.md mit Abschnitt, CLAUDE.md, Build ok', r6.opened === true && pe.entry === 'model.py' && fs.existsSync(path.join(empty, 'model.py'))
+ && read(empty, 'AGENTS.md')?.startsWith('<!-- soma:folder -->') && read(empty, 'CLAUDE.md') === '@AGENTS.md\n' && !fs.existsSync(path.join(empty, '.git')), JSON.stringify(r6));
+
+ // ---- 7) Kopierter Ordner: neue Kennung ----
+ const copy = path.join(work, 'Kopie');
+ fs.cpSync(empty, copy, { recursive: true, filter: (src) => !src.includes(`${path.sep}.soma${path.sep}env`) });
+ await app.answers([copy]);
+ const r7 = await ev(() => window.soma.project.openFolder());
+ const pc = await ev(() => window.__t.project());
+ check('Kopie: eigene Kennung, Original bleibt eingetragen', r7.opened === true && pc.id !== pe.id && JSON.parse(read(copy, '.soma/project.json')).id === pc.id
+ && (await ev(() => window.soma.project.list())).some((e) => e.id === pe.id), `${pc.id} / ${pe.id}`);
+
+ // ---- 8) Fehlender Ordner ----
+ await ev(() => window.soma.project.create());
+ await waitFor('anderes Modell', (id) => window.__t.project()?.id !== id, 60000, pc.id);
+ await sleep(1500); // Shells geben den Ordner frei
+ fs.renameSync(copy, `${copy}-weg`);
+ const gone = (await ev(() => window.soma.project.list())).find((e) => e.id === pc.id);
+ check('Startseite: verschobener Ordner als fehlend markiert', gone?.missing === true, JSON.stringify(gone));
+ const op = await tryEv(ev, (id) => window.soma.project.open(id), pc.id);
+ check('Öffnen eines fehlenden Ordners: Meldung', !!op.err && op.err.includes('no longer exists'), op.err?.slice(0, 160));
+ await app.answers([0]);
+ check('Fehlenden Ordner aus der Liste nehmen', (await ev((id) => window.soma.project.remove(id), pc.id)).removed === true);
+
+ const errs = app.page.errors.filter((e) => !/favicon/i.test(e));
+ check('Keine Konsolenfehler im Renderer', errs.length === 0, errs.slice(0, 2).join(' | ').slice(0, 120));
+} catch (e) {
+ console.log('ABBRUCH:', e);
+ t.fail();
+}
+if (app) { await app.stop(); cleanup(app.ud); }
+cleanup(work);
+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/helpshots-spec.mjs b/app/test/helpshots-spec.mjs
index 0d0ae8f..1d95b9f 100644
--- a/app/test/helpshots-spec.mjs
+++ b/app/test/helpshots-spec.mjs
@@ -47,6 +47,7 @@ export const SHOTS = [
{ label: 'New tab', sel: '#btn-term-add', at: 'r' },
{ label: 'Start agent', sel: '#agent-list', at: 'r', box: true },
{ label: 'Empty terminal', sel: '#btn-term-plain', at: 'r' },
+ { label: 'Copy path for agent app', sel: '#btn-copy-path', at: 'r' },
],
},
{
diff --git a/app/test/packages.mjs b/app/test/packages.mjs
index b62ae48..23cf52b 100644
--- a/app/test/packages.mjs
+++ b/app/test/packages.mjs
@@ -5,6 +5,7 @@
// installieren lässt, wird gemeldet und bleibt in der Liste. Ohne Netz: pip holt die Testpakete aus einem lokalen Ordner.
// Aufruf: node test/run-all.mjs packages (nach npm run build).
import { exec } from 'dugite';
+import { execFile } from 'node:child_process';
import fs from 'node:fs';
import net from 'node:net';
import os from 'node:os';
@@ -43,6 +44,9 @@ const listZip = (p) => new Promise((resolve, reject) => yauzl.open(p, { lazyEntr
z.readEntry();
}));
+// Temp-Pfade können Kurznamen (NAME~1) enthalten: nicht als Zeichenkette vergleichen
+const samePath = (a, b) => { try { return fs.realpathSync.native(a).toLowerCase() === fs.realpathSync.native(b).toLowerCase(); } catch { return false; } };
+
const dirSize = (d) => {
let n = 0;
for (const e of fs.readdirSync(d, { withFileTypes: true })) n += e.isDirectory() ? dirSize(path.join(d, e.name)) : fs.statSync(path.join(d, e.name)).size;
@@ -76,6 +80,24 @@ try {
check('.gitignore der Vorlage nennt .soma/env/', fs.readFileSync(path.join(dir, '.gitignore'), 'utf8').includes('.soma/env/'));
check('Ohne Zusatzpakete entsteht keine requirements.txt', !fs.existsSync(req));
+ // ---- 1b) Agenten-App außerhalb der App (Claude Desktop, Codex-App): Pfad kopieren, soma über .soma/env ----
+ await ev(() => document.getElementById('btn-copy-path').click());
+ check('„Copy path for agent app“ kopiert den Arbeitsordner', samePath(await ev(() => window.soma.test.clipboard()), dir)
+ && /Path copied/.test(await ev(() => window.__t.toast().text)));
+ // Wie in einer Agenten-App: kein Python im PATH, keine Umgebungsvariablen der Terminals
+ const bare = { ...process.env, PATH: path.join(process.env.SystemRoot ?? 'C:\\Windows', 'System32'), SOMA_APP: '', SOMA_APP_TOKEN: '', SOMA_PROJECT: '' };
+ const envPy = path.join(envDir, process.platform === 'win32' ? 'Scripts/python.exe' : 'bin/python');
+ const runPy = (...args) => new Promise((resolve) => execFile(envPy, ['-m', 'soma', ...args], { cwd: dir, env: bare, timeout: 120000 }, (e, out, err) => resolve(`${out}${err}`)));
+ const outB = await runPy('build');
+ check('`python -m soma build` aus .soma/env ohne PATH', /Build ok/.test(outB), outB.trim().slice(-200));
+ const outR = await runPy('render', '--out', 'renders/agent-app.png');
+ check('`soma render` findet die App über bridge.json (ohne SOMA_APP)', fs.existsSync(path.join(dir, 'renders', 'agent-app.png')), outR.trim().slice(-200));
+ // CalculiX liegt neben der Basis, nicht in .soma/env: aus der Projektumgebung muss soma es trotzdem finden (sonst nur der eigene Löser)
+ const ccxOf = (py) => new Promise((resolve) => execFile(py, ['-c', 'from soma import ccx; print("CCX", ccx.version())'], { cwd: dir, env: bare, timeout: 60000 }, (e, out, err) => resolve(`${out}${err}`.trim())));
+ const basePy = JSON.parse(fs.readFileSync(path.join(envDir, 'soma-env.json'), 'utf8')).base_python;
+ const [ccxEnv, ccxBase] = [await ccxOf(envPy), await ccxOf(basePy)];
+ check('CalculiX wird aus .soma/env gefunden wie aus der Basis', ccxEnv === ccxBase && /^CCX /.test(ccxEnv), `${ccxEnv} / Basis ${ccxBase}`);
+
// ---- 2) pip im Terminal ----
const tid = await ev(() => window.__t.terminals.activeId);
const termText = () => ev((id) => window.__t.termText(id), tid);
diff --git a/app/test/run-all.mjs b/app/test/run-all.mjs
index 99494b9..9274652 100644
--- a/app/test/run-all.mjs
+++ b/app/test/run-all.mjs
@@ -11,7 +11,7 @@ import path from 'node:path';
const DIR = import.meta.dirname;
// Längste zuerst, damit sie nicht am Ende allein laufen
-const ALL = ['animation', 'fem', 'versions', 'smoke', 'editor', 'skills', 'params', 'explode', 'fasteners', 'drawing', 'drawview', 'section', 'measure', 'stepview', 'cadquery', 'groups', 'dxf', 'packages', 'settings', 'tutorial', 'updates', 'buildlock', 'unit'];
+const ALL = ['animation', 'fem', 'versions', 'smoke', 'editor', 'skills', 'params', 'explode', 'fasteners', 'drawing', 'drawview', 'section', 'measure', 'stepview', 'cadquery', 'folder', 'groups', 'dxf', 'packages', 'settings', 'tutorial', 'updates', 'buildlock', 'unit'];
const SLOW = ['animation', 'fem'];
const args = process.argv.slice(2);
const all = args.includes('--all');