create-claude-cabinet 0.8.4 → 0.9.0

package/lib/cli.js

@@ -33,7 +33,7 @@ const MODULES = {
     mandatory: false,
     default: true,
     lean: false,
-    templates: ['scripts/pib-db.js', 'scripts/pib-db-schema.sql'],
+    templates: ['scripts/pib-db.js', 'scripts/pib-db-schema.sql', 'scripts/work-tracker-server.mjs', 'scripts/work-tracker-ui.html'],
     needsDb: true,
   },
   'planning': {
@@ -42,7 +42,7 @@ const MODULES = {
     mandatory: false,
     default: true,
     lean: true,
-    templates: ['skills/plan', 'skills/execute', 'skills/investigate'],
+    templates: ['skills/plan', 'skills/execute', 'skills/execute-plans', 'skills/investigate'],
   },
   'compliance': {
     name: 'Compliance Stack (rules + enforcement)',
@@ -107,6 +107,22 @@ const MODULES = {
   },
 };
 
+/** Recursively collect all relative file paths under a directory. */
+function walkDir(dir, base) {
+  if (!base) base = dir;
+  const results = [];
+  if (!fs.existsSync(dir)) return results;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walkDir(full, base));
+    } else {
+      results.push(path.relative(base, full));
+    }
+  }
+  return results;
+}
+
 // Signals that a directory contains a real project (not just empty)
 const PROJECT_SIGNALS = [
   'package.json', 'Cargo.toml', 'requirements.txt', 'pyproject.toml',
@@ -572,24 +588,152 @@ async function run() {
     }
   }
 
-  // --- Clean up files removed upstream ---
-  // Phase files are excluded from the manifest (they're user-customized),
-  // so skip them during cleanup even if they were in the old manifest.
+  // --- Manifest key migration (act:d1f16bee) ---
+  // When CC renames directories (e.g., perspectives/ → cabinet-*/), old manifest
+  // keys no longer match new template paths. Migrate keys BEFORE cleanup so the
+  // cleanup loop doesn't treat renamed files as removed.
+  if (Object.keys(existingManifest).length > 0) {
+    const existing = readMetadata(projectDir);
+    const fromVersion = existing.version;
+    let migrationCount = 0;
+    // v0.5.x → v0.6.x: perspectives/ → cabinet-*/
+    if (fromVersion && /^0\.[0-5]\./.test(fromVersion)) {
+      for (const key of Object.keys(existingManifest)) {
+        const match = key.match(/\.claude\/skills\/perspectives\/([^/]+)\//);
+        if (match) {
+          const newKey = key.replace(`perspectives/${match[1]}/`, `cabinet-${match[1]}/`);
+          existingManifest[newKey] = existingManifest[key];
+          delete existingManifest[key];
+          migrationCount++;
+        }
+      }
+    }
+    // Future manifest key migrations go here
+    if (migrationCount > 0) {
+      console.log(`  🔄 Migrated ${migrationCount} manifest key${migrationCount === 1 ? '' : 's'} for directory rename`);
+    }
+  }
+
+  // --- Clean up files removed upstream (safeguarded) ---
+  // Four safeguards prevent the v0.6.8 incident from recurring:
+  //   S1: Classify — only delete files that map to a known CC template path
+  //   S2: Scope — only delete files from modules the user selected
+  //   S3: Itemize — list all deletions and confirm before proceeding
+  //   S4: Backup — copy files to .cc-backup/<timestamp>/ before deletion
   if (Object.keys(existingManifest).length > 0) {
-    let totalRemoved = 0;
+    // S1: Build complete template path set (ALL modules) for classification
+    const allTemplatePaths = new Set();
+    for (const mod of Object.values(MODULES)) {
+      for (const tmpl of mod.templates || []) {
+        const srcPath = path.join(templateRoot, tmpl);
+        if (fs.existsSync(srcPath) && fs.statSync(srcPath).isDirectory()) {
+          for (const rel of walkDir(srcPath)) {
+            allTemplatePaths.add(manifestPath(tmpl) + '/' + rel);
+          }
+        } else if (fs.existsSync(srcPath)) {
+          allTemplatePaths.add(manifestPath(tmpl));
+        }
+      }
+    }
+
+    // S2: Build selected-module template paths for scoping
+    const selectedTemplatePaths = new Set();
+    for (const modKey of selectedModules) {
+      const mod = MODULES[modKey];
+      for (const tmpl of mod.templates || []) {
+        const srcPath = path.join(templateRoot, tmpl);
+        if (fs.existsSync(srcPath) && fs.statSync(srcPath).isDirectory()) {
+          for (const rel of walkDir(srcPath)) {
+            selectedTemplatePaths.add(manifestPath(tmpl) + '/' + rel);
+          }
+        } else if (fs.existsSync(srcPath)) {
+          selectedTemplatePaths.add(manifestPath(tmpl));
+        }
+      }
+    }
+
+    // Build CC template skill name set for project-skill guard (act:4ac281ba)
+    const ccSkillNames = new Set();
+    for (const mod of Object.values(MODULES)) {
+      for (const tmpl of mod.templates || []) {
+        if (tmpl.startsWith('skills/')) {
+          const skillName = tmpl.split('/')[1];
+          ccSkillNames.add(skillName);
+        }
+      }
+    }
+
+    // Collect files that would be removed
+    const toRemove = [];
     for (const oldPath of Object.keys(existingManifest)) {
       if (!allManifest[oldPath]) {
         // Skip phase files — they may be user-customized
         if (/\/phases\//.test(oldPath)) continue;
+
+        // S1: Only delete if the path maps to a known CC template
+        if (!allTemplatePaths.has(oldPath)) {
+          console.log(`  Keeping non-template file: ${oldPath}`);
+          continue;
+        }
+
+        // S2: Only delete from selected modules (don't purge deselected modules)
+        if (!selectedTemplatePaths.has(oldPath)) {
+          continue;
+        }
+
+        // Project-skill guard: never delete skills CC didn't create
+        const skillDirMatch = oldPath.match(/^\.claude\/skills\/([^/]+)\//);
+        if (skillDirMatch && !ccSkillNames.has(skillDirMatch[1])) {
+          console.log(`  Keeping project skill: ${oldPath}`);
+          continue;
+        }
+
         const fullPath = path.join(projectDir, oldPath);
         if (fs.existsSync(fullPath)) {
-          if (!flags.dryRun) fs.unlinkSync(fullPath);
-          totalRemoved++;
+          toRemove.push(oldPath);
         }
       }
     }
-    if (totalRemoved > 0) {
-      console.log(`  🧹 Removed ${totalRemoved} file${totalRemoved === 1 ? '' : 's'} no longer in upstream`);
+
+    // S3: Itemize and confirm before deleting
+    if (toRemove.length > 0) {
+      console.log(`\n  Files no longer in upstream (${toRemove.length}):`);
+      for (const f of toRemove) {
+        console.log(`    - ${f}`);
+      }
+
+      let confirmed = flags.yes;
+      if (!confirmed && !flags.dryRun) {
+        const response = await prompts({
+          type: 'confirm',
+          name: 'confirmed',
+          message: `Remove ${toRemove.length} file${toRemove.length === 1 ? '' : 's'}?`,
+          initial: false,
+        });
+        confirmed = response.confirmed;
+      }
+
+      if (confirmed && !flags.dryRun) {
+        // S4: Backup before deleting
+        const backupDir = path.join(projectDir, '.cc-backup', new Date().toISOString().replace(/[:.]/g, '-'));
+        fs.mkdirSync(backupDir, { recursive: true });
+        for (const filePath of toRemove) {
+          const src = path.join(projectDir, filePath);
+          const dest = path.join(backupDir, filePath);
+          fs.mkdirSync(path.dirname(dest), { recursive: true });
+          fs.copyFileSync(src, dest);
+        }
+        console.log(`  📦 Backed up ${toRemove.length} file${toRemove.length === 1 ? '' : 's'} to ${path.relative(projectDir, backupDir)}/`);
+
+        for (const filePath of toRemove) {
+          fs.unlinkSync(path.join(projectDir, filePath));
+        }
+        console.log(`  🧹 Removed ${toRemove.length} file${toRemove.length === 1 ? '' : 's'} no longer in upstream`);
+      } else if (flags.dryRun) {
+        console.log(`  [dry run — ${toRemove.length} file${toRemove.length === 1 ? '' : 's'} would be removed]`);
+      } else {
+        console.log('  Skipped file removal.');
+      }
     }
   }
 

package/lib/copy.js

@@ -45,6 +45,19 @@ async function walkAndCopy(srcRoot, destRoot, currentSrc, results, dryRun, skipC
       if (fs.existsSync(destPath)) {
         const existing = fs.readFileSync(destPath, 'utf8');
 
+        // Phase file guard (act:98d74381) — independent of skipPhases flag.
+        // If a phase file on disk has been customized (differs from template
+        // and isn't empty), never overwrite it regardless of other flags.
+        if (relPath.includes('phases' + path.sep) || relPath.includes('phases/')) {
+          const trimmedExisting = existing.trim();
+          if (trimmedExisting !== '' && trimmedExisting !== incoming.trim()) {
+            results.skipped.push(relPath);
+            results.manifest[relPath] = hashContent(existing);
+            console.log(`  Preserved customized phase: ${displayPath}`);
+            continue;
+          }
+        }
+
         if (existing === incoming) {
           results.skipped.push(relPath);
           results.manifest[relPath] = incomingHash;

package/lib/omega-setup.js

@@ -7,17 +7,18 @@ const OMEGA_HOME = path.join(os.homedir(), '.claude-cabinet');
 const VENV_DIR = path.join(OMEGA_HOME, 'omega-venv');
 const VENV_PYTHON = path.join(VENV_DIR, 'bin', 'python3');
 
-// Ordered by preference: stable Cellar symlinks first, newest Python first.
+// Ordered by preference: 3.13 first (ONNX runtime segfaults on 3.14 during
+// shutdown — exit 139, triggers macOS crash dialogs). 3.14 last as fallback.
 // Apple Silicon paths, then Intel Mac paths, then PATH fallback.
 const PYTHON_CANDIDATES = [
-  '/opt/homebrew/opt/python@3.14/bin/python3.14',
   '/opt/homebrew/opt/python@3.13/bin/python3.13',
   '/opt/homebrew/opt/python@3.12/bin/python3.12',
   '/opt/homebrew/opt/python@3.11/bin/python3.11',
-  '/usr/local/opt/python@3.14/bin/python3.14',
+  '/opt/homebrew/opt/python@3.14/bin/python3.14',
   '/usr/local/opt/python@3.13/bin/python3.13',
   '/usr/local/opt/python@3.12/bin/python3.12',
   '/usr/local/opt/python@3.11/bin/python3.11',
+  '/usr/local/opt/python@3.14/bin/python3.14',
   '/opt/homebrew/bin/python3',
   '/usr/local/bin/python3',
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-cabinet",
-  "version": "0.8.4",
+  "version": "0.9.0",
   "description": "Claude Cabinet — opinionated process scaffolding for Claude Code projects",
   "bin": {
     "create-claude-cabinet": "bin/create-claude-cabinet.js"

package/templates/scripts/cabinet-memory-adapter.py

@@ -149,6 +149,7 @@ def cmd_store():
         text: the memory content (required)
         type: event_type for omega (default: "lesson")
         tags: list of tags (stored in metadata, optional)
+        project: project name (default: basename of cwd)
     """
     data = _read_stdin()
     omega = _import_omega()
@@ -163,12 +164,14 @@ def cmd_store():
 
     try:
         event_type = data.get("type", "lesson")
+        project = data.get("project", os.path.basename(os.getcwd()))
         metadata = {}
         if data.get("tags"):
             metadata["tags"] = data["tags"]
         result = omega.store(
             text,
             event_type=event_type,
+            project=project,
             metadata=metadata if metadata else None,
         )
         _output({"ok": True, "id": result if isinstance(result, str) else None})
@@ -177,11 +180,17 @@ def cmd_store():
 
 
 def cmd_query():
-    """Query memories by text.
+    """Query memories by text with tiered project scoping.
 
     Reads JSON from stdin with fields:
         text: the query text (required)
         limit: max results (default: 5)
+        type: filter by event_type (optional)
+        project: project name for scoping (default: basename of cwd)
+        scope: "project" (default), "all", or "tiered"
+            - "project": only memories from this project
+            - "all": memories from all projects
+            - "tiered": project-scoped first, then cross-project to fill limit
     """
     data = _read_stdin()
     omega = _import_omega()
@@ -197,29 +206,131 @@ def cmd_query():
     try:
         limit = data.get("limit", 5)
         event_type = data.get("type")
-        results = omega.query(
-            text,
-            limit=limit,
-            event_type=event_type,
-        )
+        project = data.get("project", os.path.basename(os.getcwd()))
+        scope = data.get("scope", "tiered")
+
+        def _parse_results(results):
+            """Normalize query results into a list of dicts.
+
+            omega.query() returns a formatted markdown string. We parse it
+            back into structured data. Also queries the DB to get the project
+            field for each memory (not included in the formatted output).
+            """
+            if isinstance(results, (list, tuple)):
+                out = []
+                for r in results:
+                    if isinstance(r, dict):
+                        out.append({
+                            "text": r.get("content", r.get("text", str(r))),
+                            "type": r.get("event_type", "unknown"),
+                            "score": r.get("score", 0),
+                            "project": r.get("project", ""),
+                            "id": r.get("node_id", ""),
+                        })
+                    else:
+                        out.append({"text": str(r)})
+                return out
+
+            if not isinstance(results, str) or not results.strip():
+                return []
+
+            # Parse formatted markdown from omega.query()
+            # Format: ## N. [type] `mem-xxx` (str: 0.xx)\ncontent\n*timestamp*
+            import re
+            entries = []
+            blocks = re.split(r'\n## \d+\.', results)
+            for block in blocks:
+                block = block.strip()
+                if not block:
+                    continue
+                id_match = re.search(r'`(mem-[a-f0-9]+)`', block)
+                type_match = re.search(r'\[(\w+)\]', block)
+                score_match = re.search(r'str: ([\d.]+)', block)
+                # Content is everything after the first line, minus the timestamp
+                lines = block.split('\n')
+                content_lines = [l for l in lines[1:] if not l.startswith('*')]
+                content = '\n'.join(content_lines).strip()
+
+                if not id_match:
+                    continue  # skip header/noise lines
+                entry = {
+                    "text": content,
+                    "type": type_match.group(1) if type_match else "unknown",
+                    "score": float(score_match.group(1)) if score_match else 0,
+                    "id": id_match.group(1) if id_match else "",
+                    "project": "",
+                }
+                entries.append(entry)
+
+            # Enrich with project from DB
+            if entries:
+                try:
+                    import sqlite3
+                    db_path = os.path.expanduser("~/.omega/omega.db")
+                    conn = sqlite3.connect(db_path)
+                    ids = [e["id"] for e in entries if e["id"]]
+                    if ids:
+                        placeholders = ",".join("?" * len(ids))
+                        rows = conn.execute(
+                            f"SELECT node_id, project FROM memories WHERE node_id IN ({placeholders})",
+                            ids,
+                        ).fetchall()
+                        proj_map = {r[0]: r[1] or "" for r in rows}
+                        for e in entries:
+                            e["project"] = proj_map.get(e["id"], "")
+                    conn.close()
+                except Exception:
+                    pass  # D3: project enrichment is best-effort
+
+            return entries
+
+        # All scopes fetch from omega broadly, then filter in the adapter.
+        # omega.query() doesn't reliably pass project_path to the store,
+        # so we do project filtering ourselves.
+        over_fetch = limit * 3  # fetch extra so filtering still yields enough
+
+        if scope == "all":
+            results = omega.query(text, limit=over_fetch, event_type=event_type)
+            parsed = _parse_results(results)[:limit]
+            _output({"ok": True, "results": parsed, "scope": "all"})
+
+        elif scope == "project":
+            results = omega.query(text, limit=over_fetch, event_type=event_type)
+            parsed = _parse_results(results)
+            filtered = [m for m in parsed if m.get("project") == project][:limit]
+            _output({"ok": True, "results": filtered, "scope": "project", "project": project})
+
+        else:  # tiered (default)
+            results = omega.query(text, limit=over_fetch, event_type=event_type)
+            parsed = _parse_results(results)
+
+            # Tier 1: project-scoped
+            project_memories = [m for m in parsed if m.get("project") == project][:limit]
+            for m in project_memories:
+                m["tier"] = "project"
+
+            # Tier 2: cross-project to fill remaining slots
+            remaining = limit - len(project_memories)
+            cross_memories = []
+            if remaining > 0:
+                seen_ids = {m["id"] for m in project_memories if m["id"]}
+                for m in parsed:
+                    if m.get("project") != project and m.get("id") not in seen_ids:
+                        m["tier"] = "cross-project"
+                        cross_memories.append(m)
+                        if len(cross_memories) >= remaining:
+                            break
+
+            combined = project_memories + cross_memories
+            _output({
+                "ok": True,
+                "results": combined,
+                "scope": "tiered",
+                "project": project,
+                "project_count": len(project_memories),
+                "cross_project_count": len(cross_memories),
+            })
 
-        # query() returns a formatted string of results
-        if isinstance(results, str):
-            _output({"ok": True, "results": results})
-        elif isinstance(results, (list, tuple)):
-            memories = []
-            for r in results:
-                if isinstance(r, dict):
-                    memories.append({
-                        "text": r.get("content", r.get("text", str(r))),
-                        "type": r.get("event_type", "unknown"),
-                        "score": r.get("score", 0),
-                    })
-                else:
-                    memories.append({"text": str(r)})
-            _output({"ok": True, "memories": memories})
-        else:
-            _output({"ok": True, "results": str(results)})
     except Exception as e:
         _error(f"query failed: {e}")
 
@@ -278,6 +389,7 @@ def cmd_list():
     Returns all memories so delete can target the correct ID.
     Reads JSON from stdin with optional fields:
         type: filter by event_type (optional)
+        project: filter by project (optional)
         limit: max results (default: 50)
     """
     data = _read_stdin()
@@ -291,21 +403,28 @@ def cmd_list():
 
         conn = sqlite3.connect(db_path)
         event_type = data.get("type")
+        project = data.get("project")
         limit = data.get("limit", 50)
 
+        where_clauses = []
+        params = []
         if event_type:
-            rows = conn.execute(
-                "SELECT node_id, content, event_type, created_at FROM memories WHERE event_type = ? ORDER BY created_at DESC LIMIT ?",
-                (event_type, limit),
-            ).fetchall()
-        else:
-            rows = conn.execute(
-                "SELECT node_id, content, event_type, created_at FROM memories ORDER BY created_at DESC LIMIT ?",
-                (limit,),
-            ).fetchall()
+            where_clauses.append("event_type = ?")
+            params.append(event_type)
+        if project:
+            where_clauses.append("project = ?")
+            params.append(project)
+
+        where = f"WHERE {' AND '.join(where_clauses)}" if where_clauses else ""
+        params.append(limit)
+
+        rows = conn.execute(
+            f"SELECT node_id, content, event_type, project, created_at FROM memories {where} ORDER BY created_at DESC LIMIT ?",
+            params,
+        ).fetchall()
 
         memories = [
-            {"id": r[0], "text": r[1], "type": r[2], "created": r[3]}
+            {"id": r[0], "text": r[1], "type": r[2], "project": r[3] or "", "created": r[4]}
             for r in rows
         ]
         _output({"ok": True, "memories": memories, "count": len(memories)})