@webship.co/workspace 1.0.0-alpha1 → 1.0.0-beta2

package/core/workspace-app/tests/unit/worktree-clone.test.js

@@ -0,0 +1,250 @@
+/**
+ * The worktree half of cmd-tools-clone.sh, tested where it is cheap to test: the
+ * shell contract and the shape of the DDEV config it produces. The end-to-end run
+ * (git worktree add, ddev start, import-db) needs Docker and a real project, so it
+ * is exercised by hand and recorded in the PR; what is asserted here is everything
+ * that can silently rot — the flags, the git detection that must work for a
+ * worktree OF a worktree, and the one key whose removal is the whole feature.
+ */
+
+const assert = require('node:assert');
+const { test } = require('node:test');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync, spawnSync } = require('child_process');
+
+const ROOT = path.join(__dirname, '..', '..', '..', '..');
+const FUN = path.join(ROOT, 'core', 'scripts', 'functions', 'fun-clone-project.sh');
+const ARGS = path.join(ROOT, 'core', 'scripts', 'args', 'arg-clone.sh');
+
+/** Run a bash snippet with the clone functions sourced. */
+function withFunctions(snippet) {
+  return execFileSync('bash', ['-c', `source ${JSON.stringify(FUN)} ; ${snippet}`],
+    { encoding: 'utf8' }).trim();
+}
+
+test('the function file is valid bash', () => {
+  assert.strictEqual(spawnSync('bash', ['-n', FUN]).status, 0);
+  assert.strictEqual(spawnSync('bash', ['-n', ARGS]).status, 0);
+});
+
+test('the worktree flags are all declared, and the worktree-only ones say so', () => {
+  const args = fs.readFileSync(ARGS, 'utf8');
+  for (const flag of ['--worktree', '--branch', '--no-build-copy', '--no-db']) {
+    assert.ok(args.includes(`'${flag}'`), `${flag} is not declared`);
+  }
+  // A flag that quietly does nothing on the copying path is worse than one that
+  // refuses, so each worktree-only flag has to be labelled in its own help.
+  for (const flag of ['--branch', '--no-build-copy']) {
+    const help = args.slice(args.indexOf(`'${flag}'`));
+    assert.match(help.slice(0, 400), /Worktree only/, `${flag} does not say it is worktree only`);
+  }
+});
+
+test('project_has_git is true for a checkout, a worktree of one, and false otherwise', () => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'wt-'));
+  try {
+    const repo = path.join(tmp, 'repo');
+    fs.mkdirSync(repo);
+    const git = (...a) => execFileSync('git', ['-C', repo, ...a], { encoding: 'utf8' });
+    execFileSync('git', ['init', '-q', '-b', 'main', repo]);
+    git('config', 'user.email', 't@t'); git('config', 'user.name', 'T');
+    fs.writeFileSync(path.join(repo, 'a'), 'a');
+    git('add', '-A'); git('commit', '-qm', 'init');
+
+    assert.strictEqual(withFunctions(`project_has_git ${JSON.stringify(repo)} && echo yes || echo no`), 'yes');
+
+    // The case a `.git` directory test gets wrong: a worktree carries .git as a FILE.
+    const wt = path.join(tmp, 'wt');
+    git('worktree', 'add', '-q', '-b', 'side', wt);
+    assert.ok(fs.statSync(path.join(wt, '.git')).isFile(), '.git in a worktree should be a file');
+    assert.strictEqual(withFunctions(`project_has_git ${JSON.stringify(wt)} && echo yes || echo no`), 'yes');
+
+    const plain = path.join(tmp, 'plain');
+    fs.mkdirSync(plain);
+    // Guard against the ambient repository: a plain dir under /tmp is outside one.
+    assert.strictEqual(withFunctions(`project_has_git ${JSON.stringify(plain)} && echo yes || echo no`), 'no');
+    assert.strictEqual(withFunctions('project_has_git && echo yes || echo no'), 'no');
+  } finally { fs.rmSync(tmp, { recursive: true, force: true }); }
+});
+
+test('ddev_config_drop_name removes the top-level name and nothing else', () => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'wt-'));
+  try {
+    const cfg = path.join(tmp, 'config.yaml');
+    // A nested `name:` belongs to a service or a hook and must survive: dropping it
+    // would silently break the project's own configuration.
+    fs.writeFileSync(cfg, [
+      'name: source-project',
+      'docroot: web',
+      'hooks:',
+      '  post-start:',
+      '    - exec: echo hi',
+      'web_environment:',
+      '  - name: KEEP_ME',
+      ''].join('\n'));
+    withFunctions(`ddev_config_drop_name ${JSON.stringify(cfg)}`);
+    const out = fs.readFileSync(cfg, 'utf8');
+    assert.ok(!/^name:/m.test(out), 'the top-level name: should be gone');
+    assert.match(out, /- name: KEEP_ME/, 'a nested name: must survive');
+    assert.match(out, /docroot: web/);
+    // Absent file: a no-op, not a failure.
+    withFunctions(`ddev_config_drop_name ${JSON.stringify(path.join(tmp, 'nope.yaml'))}`);
+  } finally { fs.rmSync(tmp, { recursive: true, force: true }); }
+});
+
+test('project_ddev_docroot reads the declared docroot, quoted or bare', () => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'wt-'));
+  try {
+    const dir = path.join(tmp, 'p'); fs.mkdirSync(path.join(dir, '.ddev'), { recursive: true });
+    const cfg = path.join(dir, '.ddev', 'config.yaml');
+    fs.writeFileSync(cfg, 'name: p\ndocroot: web\n');
+    assert.strictEqual(withFunctions(`project_ddev_docroot ${JSON.stringify(dir)}`), 'web');
+    fs.writeFileSync(cfg, 'name: p\ndocroot: "docroot"\n');
+    assert.strictEqual(withFunctions(`project_ddev_docroot ${JSON.stringify(dir)}`), 'docroot');
+    fs.writeFileSync(cfg, 'name: p\n');
+    assert.strictEqual(withFunctions(`project_ddev_docroot ${JSON.stringify(dir)}`), '');
+  } finally { fs.rmSync(tmp, { recursive: true, force: true }); }
+});
+
+test('the build copy never carries DDEV per-project generated state', () => {
+  // wtsrc.crt copied into wtcopy makes every ddev start warn "unexpected
+  // #ddev-generated", and DDEV regenerates all of it anyway. Found by running it.
+  const fun = fs.readFileSync(FUN, 'utf8');
+  const filter = fun.slice(fun.indexOf('git ls-files --others --ignored'));
+  for (const excluded of ['\\.ddev/traefik', '\\.ddev/db_snapshots', '\\.ddev/\\.', '\\.tarballs']) {
+    assert.ok(filter.includes(excluded), `the build copy does not exclude ${excluded}`);
+  }
+  // …and config.yaml must NOT be filtered out: in a project that git-ignores
+  // .ddev/ it is the one file the clone cannot start without.
+  assert.ok(!/-e '\^\\\.ddev\/\[\^\/\]\*\\\.yaml\$'/.test(filter), 'config.yaml must not be excluded');
+});
+
+test('every clone command documents the worktree option', () => {
+  const folders = ['demos', 'dev', 'products', 'profiles', 'projects', 'sandboxes', 'site-templates', 'test'];
+  for (const f of folders) {
+    const p = path.join(ROOT, f, 'cmd-tools-clone.sh');
+    if (!fs.existsSync(p)) continue;
+    assert.match(fs.readFileSync(p, 'utf8'), /--worktree/, `${f}/cmd-tools-clone.sh does not mention --worktree`);
+  }
+});
+
+test('the dashboard offers the worktree only for a git checkout', () => {
+  // The git questions live in git-info.js now (shared with the GIT plugin through api.lib); the forms stay in server.js.
+  const server = fs.readFileSync(path.join(__dirname, '..', '..', 'server.js'), 'utf8') + fs.readFileSync(path.join(__dirname, '..', '..', 'git-info.js'), 'utf8');
+  assert.match(server, /function projectHasGit/);
+  assert.match(server, /rev-parse', '--git-dir'/);
+  // The control is absent, not disabled, when there is no repository.
+  assert.match(server, /projectHasGit\(srcDir\) \? `/);
+  // And the endpoint refuses the flag rather than trusting the form.
+  assert.match(server, /is not a git checkout, so there is no repository to add a worktree to/);
+});
+
+/* --- the removal guards ------------------------------------------------------
+ * These are the destructive half. Deleting the main checkout takes the only copy
+ * of the repository with it, and deleting a worktree can take commits nobody
+ * pushed — so the refusals are asserted against real repositories rather than by
+ * reading the script.
+ */
+
+const GUARDS = path.join(ROOT, 'core', 'scripts', 'functions', 'fun-git-worktrees.sh');
+
+function withGuards(snippet) {
+  return execFileSync('bash', ['-c', `source ${JSON.stringify(GUARDS)} ; ${snippet}`],
+    { encoding: 'utf8' }).trim();
+}
+
+/** A repo with an optional linked worktree, in a temp dir. */
+function makeRepo(withWorktree) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'wtg-'));
+  const main = path.join(tmp, 'main');
+  fs.mkdirSync(main);
+  const git = (...a) => execFileSync('git', ['-C', main, ...a], { encoding: 'utf8' });
+  execFileSync('git', ['init', '-q', '-b', 'main', main]);
+  git('config', 'user.email', 't@t'); git('config', 'user.name', 'T');
+  fs.writeFileSync(path.join(main, 'a'), 'a');
+  git('add', '-A'); git('commit', '-qm', 'init');
+  let wt = '';
+  if (withWorktree) {
+    wt = path.join(tmp, 'side');
+    git('worktree', 'add', '-q', '-b', 'side', wt);
+  }
+  return { tmp, main, wt };
+}
+
+test('git_worktree_role: plain, primary and linked are told apart', () => {
+  const { tmp, main, wt } = makeRepo(true);
+  try {
+    assert.strictEqual(withGuards(`git_worktree_role ${JSON.stringify(main)}`), 'primary');
+    assert.strictEqual(withGuards(`git_worktree_role ${JSON.stringify(wt)}`), 'linked');
+    // Remove the dependent and the same folder is merely 'plain' — the role is
+    // about what depends on it, not about what it is on disk.
+    execFileSync('git', ['-C', main, 'worktree', 'remove', '--force', wt]);
+    assert.strictEqual(withGuards(`git_worktree_role ${JSON.stringify(main)}`), 'plain');
+    assert.strictEqual(withGuards(`git_worktree_role ${JSON.stringify(tmp)}`), 'none');
+  } finally { fs.rmSync(tmp, { recursive: true, force: true }); }
+});
+
+test('git_worktree_others lists the dependents and excludes the folder itself', () => {
+  const { tmp, main, wt } = makeRepo(true);
+  try {
+    const others = withGuards(`git_worktree_others ${JSON.stringify(main)}`).split('\n').filter(Boolean);
+    assert.strictEqual(others.length, 1);
+    assert.strictEqual(fs.realpathSync(others[0]), fs.realpathSync(wt));
+    const back = withGuards(`git_worktree_others ${JSON.stringify(wt)}`).split('\n').filter(Boolean);
+    assert.strictEqual(back.length, 1, 'a worktree should see the main checkout as its other');
+  } finally { fs.rmSync(tmp, { recursive: true, force: true }); }
+});
+
+test('git_worktree_unpushed and _dirty count what a delete would destroy', () => {
+  const { tmp, main } = makeRepo(false);
+  try {
+    // No remote at all: every commit is unpushed, which is the honest answer.
+    assert.strictEqual(withGuards(`git_worktree_unpushed ${JSON.stringify(main)}`), '1');
+    assert.strictEqual(withGuards(`git_worktree_dirty ${JSON.stringify(main)}`), '0');
+    fs.writeFileSync(path.join(main, 'b'), 'b');
+    // A single number, not two: `grep -c` prints 0 AND exits 1 on no match, so an
+    // `|| echo 0` fallback printed a second zero and the caller read "0 0".
+    const dirty = withGuards(`git_worktree_dirty ${JSON.stringify(main)}`);
+    assert.strictEqual(dirty, '1');
+    assert.ok(!dirty.includes('\n'), 'dirty must be one number');
+  } finally { fs.rmSync(tmp, { recursive: true, force: true }); }
+});
+
+test('remove refuses the main checkout, and --force is the only way past', () => {
+  const fun = fs.readFileSync(path.join(ROOT, 'core', 'scripts', 'functions', 'fun-remove-project.sh'), 'utf8');
+  assert.match(fun, /REFUSING to remove \$\{project\}: it is the MAIN checkout/);
+  assert.match(fun, /REFUSING to remove \$\{project\}: it holds work that is nowhere else/);
+  // The guard runs BEFORE anything is deleted — after ddev delete would be too late.
+  const guardAt = fun.indexOf('remove_project_worktree_guard "${workspace_dir}/${project}"');
+  // The REAL call, not the `ddev delete` quoted in the file's header comment —
+  // which is what the first version of this assertion matched, and it failed on
+  // correct code.
+  const deleteAt = fun.indexOf('( cd "${workspace_dir}/${project}" && ddev delete -y -O )');
+  assert.ok(guardAt > 0 && guardAt < deleteAt, 'the guard must run before ddev delete');
+  // FORCE may be unset entirely: remove_project is called from the dashboard and
+  // from other scripts that know nothing about it.
+  assert.ok(!/\[ "\$\{FORCE\}"/.test(fun), 'FORCE must be read as ${FORCE:-}');
+  // And the stale registration is pruned afterwards, or a re-clone to the same
+  // path is refused by git.
+  assert.match(fun, /remove_project_worktree_after/);
+});
+
+test('every remove command offers --force', () => {
+  for (const f of fs.readdirSync(ROOT)) {
+    const p = path.join(ROOT, f, 'cmd-tools-remove.sh');
+    if (!fs.existsSync(p)) continue;
+    assert.match(fs.readFileSync(p, 'utf8'), /'-f', '--force'/, `${f}/cmd-tools-remove.sh has no --force`);
+  }
+});
+
+test('the dashboard asks git the same questions the script does', () => {
+  // The git questions live in git-info.js now (shared with the GIT plugin through api.lib); the forms stay in server.js.
+  const server = fs.readFileSync(path.join(__dirname, '..', '..', 'server.js'), 'utf8') + fs.readFileSync(path.join(__dirname, '..', '..', 'git-info.js'), 'utf8');
+  assert.match(server, /function gitWorktreeInfo/);
+  // The warning is shown before the confirm, and force is forwarded, never assumed.
+  assert.match(server, /This is the main git checkout/);
+  assert.match(server, /This holds work that is nowhere else/);
+  assert.match(server, /form\.force === 'yes' \? ' --force' : ''/);
+});

package/{workspace-types.js → core/workspace-app/workspace-types.js}

@@ -23,12 +23,12 @@ const TYPES = {
   sites: {
     label: 'Sites — DDEV projects',
     description: 'Built Drupal sites: DDEV controls, tests, users, the full toolbelt.',
-    actions: ['build', 'folder', 'ddev', 'backup', 'clone', 'remove', 'graphify', 'ragify', 'tests', 'checks', 'users'],
+    actions: ['build', 'folder', 'ddev', 'backup', 'clone', 'remove', 'ragify', 'tests', 'checks', 'users'],
   },
   code: {
     label: 'Code — packages and repositories',
     description: 'Modules, themes, libraries, recipes: quality checks and knowledge tools, no site controls.',
-    actions: ['build', 'folder', 'backup', 'remove', 'graphify', 'ragify', 'checks'],
+    actions: ['build', 'folder', 'backup', 'remove', 'ragify', 'checks'],
   },
   files: {
     label: 'Files — documents and drafts',

package/{workspaces.js → core/workspace-app/workspaces.js}

@@ -256,10 +256,6 @@ function findRemoveScript(dir) {
   return findScript(dir, [/^cmd-tools-remove\.sh$/]);
 }
 
-function findGraphifyScript(dir) {
-  return findScript(dir, [/^cmd-tools?-graphify\.sh$/]);
-}
-
 function findRagifyScript(dir) {
   return findScript(dir, [/^cmd-tools?-ragify\.sh$/]);
 }
@@ -549,7 +545,7 @@ module.exports = {
   workspaceDir,
   findBackupScript,
   findRemoveScript,
-  findGraphifyScript,
+  findScript,
   findRagifyScript,
   findBuilderScripts,
   builderLabel,

package/package.json

@@ -1,49 +1,51 @@
 {
   "name": "@webship.co/workspace",
-  "version": "1.0.0-alpha1",
-  "description": "The Webship Workspace dashboard: a lean core (workspaces, builders, settings, the assistant shell, the plugin system) that every feature joins as a @webship.co/workspace-<name> plugin \u2014 required with npm, then activated, installed and configured.",
-  "license": "ISC",
+  "version": "1.0.0-beta2",
+  "description": "Webship Workspace: a container-based development workspace with a web dashboard. The core ships empty; workspace folders, hosting providers, git forges, container runtimes and features are @webship.co/workspace-<name> plugins you add one at a time.",
+  "license": "GPL-2.0-or-later",
   "repository": {
     "type": "git",
-    "url": "https://github.com/webship/workspace.git",
-    "directory": "core/workspace-app"
+    "url": "https://github.com/webship/workspace.git"
+  },
+  "homepage": "https://github.com/webship/workspace#readme",
+  "bin": {
+    "webship-workspace": "core/bin/workspace.js"
   },
-  "main": "server.js",
   "files": [
-    "*.js",
-    "actions",
-    "commands",
-    "docs",
-    "public",
-    "scripts",
-    "plugins/workspace-notes",
-    "screenrc",
-    "PLUGINS.md",
-    "WORKSPACES.md",
-    "README.md"
+    "core/bin",
+    "core/config/settings.template.yml",
+    "core/config/style.yml",
+    "core/config/settings.labels.yml",
+    "core/config/theme.*.yml",
+    "core/docs",
+    "core/scripts",
+    "core/workspace-app/*.js",
+    "core/workspace-app/actions",
+    "core/workspace-app/commands",
+    "core/workspace-app/docs",
+    "core/workspace-app/public",
+    "core/workspace-app/scripts",
+    "core/workspace-app/plugins/workspace-notes",
+    "core/workspace-app/tests",
+    "core/workspace-app/.ddev",
+    "core/workspace-app/package.json",
+    "core/workspace-app/cucumber.js",
+    "core/workspace-app/playwright.config.js",
+    "core/workspace-app/screenrc",
+    "core/workspace-app/PLUGINS.md",
+    "core/workspace-app/WORKSPACES.md",
+    "core/workspace-app/README.md",
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
-    "start": "node server.js",
-    "test": "npm run test:unit && npm run test:browser",
-    "test:unit": "node --test \"tests/unit/*.test.js\" \"plugins/*/tests/*.test.js\"",
-    "test:browser": "cucumber-js --config cucumber.js"
-  },
-  "dependencies": {
-    "@xterm/addon-fit": "^0.10.0",
-    "@xterm/addon-unicode11": "^0.9.0",
-    "@xterm/addon-web-links": "^0.11.0",
-    "@xterm/xterm": "^5.5.0",
-    "ace-builds": "^1.44.0",
-    "htmx.org": "^4.0.0",
-    "js-yaml": "^5.2.1",
-    "ws": "^8.21.3"
-  },
-  "devDependencies": {
-    "webship-js": "^2.0.4"
+    "test": "node --test core/workspace-app/tests/unit/workspace-bin.test.js",
+    "postinstall": "node -e \"console.log('Webship Workspace: run  webship-workspace init [dir]  to make a workspace (empty), then add plugins one at a time.')\""
   },
   "publishConfig": {
     "access": "public"
   },
-  "keywords": [],
-  "author": ""
+  "engines": {
+    "node": ">=20"
+  }
 }

package/actions/graphs.js

@@ -1,107 +0,0 @@
-/**
- * Building a project's knowledge graph, and what you do with it afterwards.
- *
- * One module per area of the dashboard, each exporting the handlers it owns keyed by the path that
- * reaches them. server.js merges the maps and dispatches; nothing here knows about routing, and
- * adding an action is adding an entry rather than another branch in a 1,250-line function.
- *
- * Every handler takes the same context: the parsed form, the response, a `send` that writes an HTML
- * fragment, and the workspace the request named.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const { esc } = require('../html');
-const { humanSize, humanTime } = require('../format');
-const { ROOT, loadWorkspaces, workspaceDir } = require('../workspaces');
-const {
-  run, jobFragment, runningJobKey, startJob, ddevProjectName, listProjects,
-  startInScreen, screenStartedHtml,
-} = require('../jobs');
-const { graphStoreDir } = require('../graphs');
-const {
-  milvusProjectName, ragInstances, ragBindings, ragInstanceFor, ragWriteBinding,
-  ragCollectionName, milvusPost, ragCollections, ragInvalidate,
-} = require('../rag');
-const {
-  findTestReports, testReportFor, invalidateTestReports, testMediaHtml, testingStackOf,
-} = require('../test-reports');
-const { NAME_RE, SCRIPT_RE } = require('../validate');
-const { commandBlock } = require('../command-block');
-const { wsUrl } = require('../urls');
-const { findGraphifyScript, findRagifyScript } = require('../workspaces');
-const { DDEV_ACTIONS } = require('../ddev');
-
-async function graphify({ form, res, send, workspace, pathname }) {
-    const dir = workspaceDir(workspace);
-    const script = findGraphifyScript(dir);
-    const projectName = String(form.projectName || '');
-    if (!script) return send('<div class="msg error">No graphify script in this workspace.</div>', 400);
-    if (!NAME_RE.test(projectName) || !listProjects(dir).includes(projectName)) {
-      return send('<div class="msg error">Unknown project.</div>', 400);
-    }
-    // graphify has no cross-process lock: two runs against one graphify-out/
-    // race on manifest.json, graph.json and cache/ast, and the loser's atomic
-    // replace silently wins, corrupting the incremental gate.
-    const jobKey = `graphify:${workspace}/${projectName}`;
-    if (runningJobKey(jobKey)) {
-      return send('<div class="msg error">A graph is already being built for this project.</div>', 409);
-    }
-    // Local AST extraction only: no API key, nothing leaves the machine. Big
-    // codebases take a while, so it gets the long build timeout.
-    const started = await startInScreen({ workspace, project: projectName, projectDir: dir, ownerDir: path.join(dir, projectName), verb: 'graphify',
-      cmdLine: `bash ${JSON.stringify(script)} ${JSON.stringify(projectName)}`, label: 'graphify' });
-    return send(screenStartedHtml(started, 'graphify', projectName), started.ok ? 200 : (started.already ? 409 : 500));
-}
-
-  // Commands the dashboard SHOWS rather than runs, with a copy button each.
-  //
-  // Two kinds end up here. `claude mcp add` writes ~/.claude.json — the CLI configuration of the
-  // person at the keyboard, not of this web request. The Upsun pulls need cloud credentials this
-  // container does not have and replace local data. Both are worth reading before they happen.
-async function graph_mcp_command({ form, res, send, workspace, pathname }) {
-    const projectName = String(form.projectName || '');
-    if (!NAME_RE.test(projectName)) return send('<div class="msg error">Unknown project.</div>', 400);
-    const graph = path.join(graphStoreDir(workspace, projectName), 'graph.json');
-    if (!fs.existsSync(graph)) return send('<div class="msg error">No graph yet — build it first.</div>', 409);
-    return send(commandBlock(
-      `Serve the ${workspace}/${projectName} graph to the Claude Code CLI`,
-      [`cd ${ROOT}/graphs && bash cmd-tools-graphs.sh ${workspace}/${projectName} -a mcp-register`,
-        `claude mcp add --scope user graph-${workspace}-${projectName} -- graphify-mcp ${graph.replace(ROOT, '~/workspace')}`],
-      'Run either one <strong>on the host</strong>, in a terminal. The first is the workspace command; '
-      + 'the second is what it runs. stdio, so there is no port and no daemon — the CLI starts the server '
-      + 'when a session needs it. Open a NEW session to see the tools; rebuilding the graph needs no '
-      + 're-registration.'));
-}
-
-  // Delete a project's graph. Bounded to graphs/<workspace>/<project> — the whole point is that a
-  // graph is regenerable, so this is the one cheap thing to throw away. The project itself is
-  // never touched: nothing of the graph lives in it.
-async function graph_remove({ form, res, send, workspace, pathname }) {
-    if (form.confirm !== 'yes') return send('<div class="msg error">Deleting requires confirmation.</div>', 400);
-    const projectName = String(form.projectName || '');
-    // The project may be gone — a graph outlives it, and that is exactly a graph worth deleting.
-    if (!NAME_RE.test(projectName)) {
-      return send('<div class="msg error">Unknown project.</div>', 400);
-    }
-    if (runningJobKey(`graphify:${workspace}/${projectName}`)) {
-      return send('<div class="msg error">A graph run is in progress for this project — wait for it to finish.</div>', 409);
-    }
-    const out = graphStoreDir(workspace, projectName);
-    let real;
-    try {
-      real = fs.realpathSync(out);
-      const base = fs.realpathSync(path.join(ROOT, 'graphs'));
-      if (!real.startsWith(base + path.sep)) throw new Error('outside');
-    } catch (_) { return send('<div class="msg assistant">No graph to delete.</div>'); }
-    fs.rmSync(real, { recursive: true, force: true });
-    res.setHeader('HX-Trigger', 'refresh-projects');
-    return send(`<div class="msg assistant">🗑️ Deleted the graph for <strong>${esc(projectName)}</strong>. Rebuild it any time from the Graph menu.</div>`);
-}
-
-module.exports = {
-  '/actions/graphify': graphify,
-  '/actions/graph-mcp-command': graph_mcp_command,
-  '/actions/graph-remove': graph_remove,
-};

package/actions/obsidian.js

@@ -1,59 +0,0 @@
-/**
- * Building and removing a project's Obsidian vault.
- *
- * Both shell out to `cmd-tools-obsidian.sh` in the project's own workspace rather than
- * reimplementing the conversion, for the same reason every other action here does: the button and
- * the command line cannot then drift apart.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const { listProjects, workspaceDir } = require('../workspaces');
-const { esc } = require('../html');
-const { jobFragment, runningJobKey, startJob } = require('../jobs');
-const { NAME_RE } = require('../validate');
-const { graphStoreDir } = require('../graphs');
-const { vaultDir } = require('../obsidian');
-
-module.exports = {
-  '/actions/obsidian': async ({ form, res, send, workspace, req }) => {
-    const dir = workspaceDir(workspace);
-    const script = 'cmd-tools-obsidian.sh';
-    const projectName = String(form.projectName || '');
-    if (!fs.existsSync(path.join(dir, script))) return send('<div class="msg error">This workspace has no Obsidian script.</div>', 400);
-    if (!NAME_RE.test(projectName) || !listProjects(dir).includes(projectName)) {
-      return send('<div class="msg error">Unknown project.</div>', 400);
-    }
-    // Said here rather than left to the script, because the menu is reached from a row that may
-    // have had its graph deleted since the page was drawn.
-    if (!fs.existsSync(path.join(graphStoreDir(workspace, projectName), 'graph.json'))) {
-      return send('<div class="msg error">No graph to convert yet — build the graph first, from the same menu.</div>', 409);
-    }
-    // One writer per vault: the build writes to a sibling directory and swaps it in, so two runs
-    // would race on that swap and the loser's vault would vanish under it.
-    const jobKey = `obsidian:${workspace}/${projectName}`;
-    if (runningJobKey(jobKey)) {
-      return send('<div class="msg error">A vault is already being built for this project.</div>', 409);
-    }
-    const id = startJob(`🗂️ Obsidian <strong>${esc(projectName)}</strong>`, 'bash', [script, projectName], dir,
-      { timeoutMs: 10 * 60 * 1000, echoLine: `bash ${script} ${projectName}`, key: jobKey });
-    return send(jobFragment(id).html);
-  },
-
-  '/actions/obsidian-remove': async ({ form, res, send, workspace }) => {
-    if (form.confirm !== 'yes') return send('<div class="msg error">Deleting requires confirmation.</div>', 400);
-    const projectName = String(form.projectName || '');
-    // The project may be long gone — a vault outlives it, and that is exactly a vault worth
-    // throwing away. So the name is validated but not looked up.
-    if (!NAME_RE.test(projectName)) return send('<div class="msg error">Unknown project.</div>', 400);
-    const dir = vaultDir(workspace, projectName);
-    if (!fs.existsSync(dir)) return send('<div class="msg">There was no vault to delete.</div>');
-    try {
-      fs.rmSync(dir, { recursive: true, force: true });
-    } catch (e) {
-      return send(`<div class="msg error">Could not delete the vault: ${esc(e.message)}</div>`, 500);
-    }
-    return send('<div class="msg">Vault deleted. The graph it was made from is untouched.</div>');
-  },
-};

package/graphs.js

@@ -1,104 +0,0 @@
-/**
- * Where a project's knowledge graph lives, and what is in it.
- *
- * The graph is kept in the graphs workspace rather than inside the project — it is tens of MB, it
- * re-diffs entirely on every rebuild, and half the projects worth mapping are repositories we ship.
- * Everything here reads that store; building one is `cmd-tools-graphify.sh`.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const { ROOT } = require('./workspaces');
-
-// Where a project's graph lives: the graphs workspace, never inside the project. graphify only
-// writes <project>/graphify-out, so cmd-tools-graphify.sh moves the result here — a graph is tens
-// of MB, it re-diffs entirely on every rebuild, and half the projects worth mapping are
-// repositories we ship.
-function graphStoreDir(wsKey, project) {
-  return path.join(ROOT, 'graphs', wsKey, project);
-}
-
-// Graph lookups per project row, memoised for 2s: projectRowsHtml is
-// re-rendered on every job poll.
-let _graphCache = new Map();
-let _graphCacheAt = 0;
-function hasGraph(wsKey, project, file) {
-  const now = Date.now();
-  if (now - _graphCacheAt > 2000) { _graphCache = new Map(); _graphCacheAt = now; }
-  const k = `${wsKey}/${project}/${file}`;
-  if (!_graphCache.has(k)) _graphCache.set(k, fs.existsSync(path.join(graphStoreDir(wsKey, project), file)));
-  return _graphCache.get(k);
-}
-
-// Node and edge counts, memoised on the graph file's identity so paging a long list re-reads
-// nothing. Keyed on mtime+size: a rebuild changes both.
-const _graphCounts = new Map();
-function graphCounts(file, stat) {
-  if (!stat) return { nodes: null, links: null };
-  const key = `${file}:${stat.mtimeMs}:${stat.size}`;
-  if (_graphCounts.has(key)) return _graphCounts.get(key);
-  let counts = { nodes: null, links: null };
-  try {
-    const d = JSON.parse(fs.readFileSync(file, 'utf8'));
-    counts = { nodes: (d.nodes || []).length, links: (d.links || d.edges || []).length };
-  } catch (_) { /* unreadable or half-written */ }
-  _graphCounts.set(key, counts);
-  return counts;
-}
-
-// Every graph in the store, as <workspace>/<project> rows. Reads the two levels the build writes
-// and nothing else, so a stray file in graphs/ cannot become a row.
-function listGraphs() {
-  const base = path.join(ROOT, 'graphs');
-  const rows = [];
-  let workspaces = [];
-  try {
-    workspaces = fs.readdirSync(base, { withFileTypes: true }).filter((e) => e.isDirectory());
-  } catch (_) {
-    return rows;
-  }
-  for (const ws of workspaces) {
-    let projects = [];
-    try {
-      projects = fs.readdirSync(path.join(base, ws.name), { withFileTypes: true }).filter((e) => e.isDirectory());
-    } catch (_) { continue; }
-    for (const pr of projects) {
-      const dir = path.join(base, ws.name, pr.name);
-      const stat = (f) => { try { return fs.statSync(path.join(dir, f)); } catch (_) { return null; } };
-      const json = stat('graph.json');
-      // The counts come from graph.json itself — .graphify_build.json carries only the excludes,
-      // so the numbers were rendering empty. Parsing is cheap enough (20ms for a 2,430-node graph)
-      // and the result is memoised on the file's mtime and size, so a re-render costs nothing.
-      const nodes_links = graphCounts(path.join(dir, 'graph.json'), json);
-      const nodes = nodes_links.nodes;
-      const links = nodes_links.links;
-      let size = 0;
-      const walk = (d) => {
-        let entries = [];
-        try { entries = fs.readdirSync(d, { withFileTypes: true }); } catch (_) { return; }
-        for (const e of entries) {
-          const full = path.join(d, e.name);
-          if (e.isDirectory()) walk(full);
-          else { try { size += fs.statSync(full).size; } catch (_) { /* gone */ } }
-        }
-      };
-      walk(dir);
-      rows.push({
-        workspace: ws.name,
-        project: pr.name,
-        name: `${ws.name}/${pr.name}`,
-        mtime: json ? json.mtime : new Date(0),
-        size,
-        nodes,
-        links,
-        hasHtml: !!stat('graph.html'),
-        hasReport: !!stat('GRAPH_REPORT.md'),
-        projectExists: fs.existsSync(path.join(ROOT, ws.name, pr.name)),
-      });
-    }
-  }
-  return rows;
-}
-
-module.exports = { graphStoreDir, hasGraph, graphCounts, listGraphs };