create-claude-cabinet 0.6.0

package/lib/copy.js

@@ -0,0 +1,152 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const prompts = require('prompts');
+
+function hashContent(content) {
+  return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+
+/**
+ * Recursively copy files from src to dest, surfacing conflicts.
+ * Returns { copied: string[], skipped: string[], overwritten: string[] }
+ */
+async function copyTemplates(src, dest, { dryRun = false, skipConflicts = false, skipPhases = false, projectRoot = null, existingManifest = {} } = {}) {
+  const results = { copied: [], skipped: [], overwritten: [], manifest: {} };
+  await walkAndCopy(src, dest, src, results, dryRun, skipConflicts, skipPhases, projectRoot, existingManifest);
+  return results;
+}
+
+async function walkAndCopy(srcRoot, destRoot, currentSrc, results, dryRun, skipConflicts, skipPhases, projectRoot, existingManifest) {
+  const entries = fs.readdirSync(currentSrc, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(currentSrc, entry.name);
+    const relPath = path.relative(srcRoot, srcPath);
+    const destPath = path.join(destRoot, relPath);
+    // Display path relative to project root for clearer conflict prompts
+    const displayPath = projectRoot ? path.relative(projectRoot, destPath) : relPath;
+
+    if (entry.isDirectory()) {
+      // Skip phases/ directories — absent phase files use skeleton defaults,
+      // which is the correct behavior for most adopters. Phase files are
+      // only created when the user customizes behavior via /onboard.
+      if (skipPhases && entry.name === 'phases') {
+        continue;
+      }
+      if (!dryRun && !fs.existsSync(destPath)) {
+        fs.mkdirSync(destPath, { recursive: true });
+      }
+      await walkAndCopy(srcRoot, destRoot, srcPath, results, dryRun, skipConflicts, skipPhases, projectRoot, existingManifest);
+    } else {
+      const incoming = fs.readFileSync(srcPath, 'utf8');
+      const incomingHash = hashContent(incoming);
+
+      if (fs.existsSync(destPath)) {
+        const existing = fs.readFileSync(destPath, 'utf8');
+
+        if (existing === incoming) {
+          results.skipped.push(relPath);
+          results.manifest[relPath] = incomingHash;
+          continue;
+        }
+
+        if (skipConflicts) {
+          // Check if file is upstream-managed (in the old manifest).
+          // If so, overwrite — it can't be customized (hook enforces this).
+          // If not, skip — it's project-created content.
+          const manifestKey = projectRoot
+            ? path.relative(projectRoot, destPath)
+            : relPath;
+          if (existingManifest[manifestKey]) {
+            if (!dryRun) fs.copyFileSync(srcPath, destPath);
+            results.overwritten.push(relPath);
+            results.manifest[relPath] = incomingHash;
+          } else {
+            results.skipped.push(relPath);
+            results.manifest[relPath] = incomingHash;
+          }
+          continue;
+        }
+
+        const response = await prompts({
+          type: 'select',
+          name: 'action',
+          message: `File exists: ${displayPath}`,
+          choices: [
+            { title: 'Keep existing', value: 'keep' },
+            { title: 'Overwrite with template', value: 'overwrite' },
+            { title: 'Show diff', value: 'diff' },
+          ],
+        });
+
+        if (!response.action) {
+          // User cancelled
+          results.skipped.push(relPath);
+          results.manifest[relPath] = incomingHash;
+          continue;
+        }
+
+        if (response.action === 'diff') {
+          showDiff(existing, incoming, relPath);
+          const followUp = await prompts({
+            type: 'confirm',
+            name: 'overwrite',
+            message: `Overwrite ${relPath}?`,
+            initial: false,
+          });
+          if (followUp.overwrite && !dryRun) {
+            fs.copyFileSync(srcPath, destPath);
+            results.overwritten.push(relPath);
+          } else {
+            results.skipped.push(relPath);
+          }
+          results.manifest[relPath] = incomingHash;
+        } else if (response.action === 'overwrite') {
+          if (!dryRun) fs.copyFileSync(srcPath, destPath);
+          results.overwritten.push(relPath);
+          results.manifest[relPath] = incomingHash;
+        } else {
+          results.skipped.push(relPath);
+          results.manifest[relPath] = incomingHash;
+        }
+      } else {
+        if (!dryRun) {
+          const dir = path.dirname(destPath);
+          if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+          fs.copyFileSync(srcPath, destPath);
+        }
+        results.copied.push(relPath);
+        results.manifest[relPath] = incomingHash;
+      }
+    }
+  }
+}
+
+function showDiff(existing, incoming, relPath) {
+  const existingLines = existing.split('\n');
+  const incomingLines = incoming.split('\n');
+
+  console.log(`\n--- ${relPath} (existing)`);
+  console.log(`+++ ${relPath} (template)`);
+  console.log('');
+
+  // Simple line-by-line comparison
+  const maxLines = Math.max(existingLines.length, incomingLines.length);
+  for (let i = 0; i < maxLines; i++) {
+    const a = existingLines[i];
+    const b = incomingLines[i];
+    if (a === b) continue;
+    if (a !== undefined && b !== undefined) {
+      console.log(`  ${i + 1}: - ${a}`);
+      console.log(`  ${i + 1}: + ${b}`);
+    } else if (a !== undefined) {
+      console.log(`  ${i + 1}: - ${a}`);
+    } else {
+      console.log(`  ${i + 1}: + ${b}`);
+    }
+  }
+  console.log('');
+}
+
+module.exports = { copyTemplates };

package/lib/db-setup.js

@@ -0,0 +1,51 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Set up the PIB database in the target project.
+ * - Copies pib-db.js and schema to scripts/
+ * - Runs npm init if no package.json
+ * - Installs better-sqlite3
+ * - Runs pib-db init
+ */
+function setupDb(projectDir) {
+  const scriptsDir = path.join(projectDir, 'scripts');
+  const results = [];
+
+  // Check if package.json exists; if not, init
+  const pkgPath = path.join(projectDir, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    console.log('  Initializing package.json...');
+    execSync('npm init -y', { cwd: projectDir, stdio: 'pipe' });
+    results.push('Created package.json');
+  }
+
+  // pib-db.js uses ESM imports — ensure package.json has "type": "module"
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+  if (pkg.type !== 'module') {
+    pkg.type = 'module';
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+    results.push('Set package.json type to "module"');
+  }
+
+  // Install better-sqlite3 if not already installed
+  const nodeModules = path.join(projectDir, 'node_modules', 'better-sqlite3');
+  if (!fs.existsSync(nodeModules)) {
+    console.log('  Installing better-sqlite3...');
+    execSync('npm install better-sqlite3', { cwd: projectDir, stdio: 'pipe' });
+    results.push('Installed better-sqlite3');
+  }
+
+  // Initialize the database
+  const dbScript = path.join(scriptsDir, 'pib-db.js');
+  if (fs.existsSync(dbScript)) {
+    console.log('  Initializing database...');
+    execSync(`node ${dbScript} init`, { cwd: projectDir, stdio: 'pipe' });
+    results.push('Initialized pib.db');
+  }
+
+  return results;
+}
+
+module.exports = { setupDb };

package/lib/metadata.js

@@ -0,0 +1,42 @@
+const fs = require('fs');
+const path = require('path');
+
+const METADATA_FILE = '.corrc.json';
+
+function metadataPath(projectDir) {
+  return path.join(projectDir, METADATA_FILE);
+}
+
+function read(projectDir) {
+  const file = metadataPath(projectDir);
+  if (!fs.existsSync(file)) return null;
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+function write(projectDir, data) {
+  const file = metadataPath(projectDir);
+  fs.writeFileSync(file, JSON.stringify(data, null, 2) + '\n');
+}
+
+function create(projectDir, { modules, skipped, version, manifest = {} }) {
+  const data = {
+    version,
+    installedAt: new Date().toISOString(),
+    upstreamPackage: 'create-claude-cabinet',
+    modules: {},
+    skipped: {},
+    manifest,
+  };
+
+  for (const mod of modules) {
+    data.modules[mod] = true;
+  }
+  for (const [mod, reason] of Object.entries(skipped)) {
+    data.skipped[mod] = reason;
+  }
+
+  write(projectDir, data);
+  return data;
+}
+
+module.exports = { read, write, create, metadataPath, METADATA_FILE };

package/lib/reset.js

@@ -0,0 +1,193 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { read: readMetadata, METADATA_FILE } = require('./metadata');
+const { DEFAULT_HOOKS } = require('./settings-merge');
+
+// CoR-managed hook command patterns — used to identify hooks to remove
+const COR_HOOK_PATTERNS = [
+  '.claude/hooks/git-guardrails.sh',
+  '.claude/hooks/skill-telemetry.sh',
+  '.claude/hooks/skill-tool-telemetry.sh',
+];
+
+function hashContent(content) {
+  return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+
+/**
+ * Reconstruct manifest from module list for 0.1.x installs that lack one.
+ * Maps module names to their expected template paths using the MODULES
+ * definition from cli.js. Returns a best-effort manifest with no hashes.
+ */
+function reconstructManifest(metadata) {
+  // We don't import MODULES to avoid circular deps — use a static mapping
+  // that covers the known 0.1.x template structure.
+  console.log('  ⚠ No manifest found (0.1.x install). Reconstructing from modules...');
+  console.log('    All files will be treated as unmodified (no hash data).\n');
+  return {};
+}
+
+/**
+ * Remove CoR files from a project using the manifest for safety.
+ *
+ * For each manifest entry:
+ * - Hash matches → remove (unmodified CoR file)
+ * - Hash differs → skip with [CUSTOMIZED] warning (unless --force)
+ * - File missing → skip (already removed)
+ *
+ * Files NOT in the manifest are left alone (user-created, onboard-generated).
+ */
+async function reset(projectDir, { dryRun = false, force = false } = {}) {
+  console.log('');
+  console.log('  🗄️  Claude Cabinet — Reset');
+  console.log('');
+
+  if (dryRun) {
+    console.log('  [dry run — no files will be removed]\n');
+  }
+
+  const metadata = readMetadata(projectDir);
+  if (!metadata) {
+    console.log('  No .corrc.json found — nothing to reset.');
+    return;
+  }
+
+  console.log(`  Found installation (v${metadata.version}, installed ${metadata.installedAt.split('T')[0]})`);
+  console.log('');
+
+  let manifest = metadata.manifest;
+  if (!manifest || Object.keys(manifest).length === 0) {
+    manifest = reconstructManifest(metadata);
+    if (Object.keys(manifest).length === 0) {
+      console.log('  Could not reconstruct manifest. Use --force to remove all CoR directories.\n');
+      if (!force) return;
+    }
+  }
+
+  const removed = [];
+  const customized = [];
+  const missing = [];
+  const forced = [];
+
+  // Process each manifest entry
+  for (const [relPath, installedHash] of Object.entries(manifest)) {
+    const fullPath = path.join(projectDir, relPath);
+
+    if (!fs.existsSync(fullPath)) {
+      missing.push(relPath);
+      continue;
+    }
+
+    const currentContent = fs.readFileSync(fullPath, 'utf8');
+    const currentHash = hashContent(currentContent);
+
+    if (currentHash === installedHash) {
+      // Unmodified — safe to remove
+      if (!dryRun) {
+        fs.unlinkSync(fullPath);
+        cleanEmptyDirs(path.dirname(fullPath), projectDir);
+      }
+      removed.push(relPath);
+    } else if (force) {
+      // Modified but --force used
+      if (!dryRun) {
+        fs.unlinkSync(fullPath);
+        cleanEmptyDirs(path.dirname(fullPath), projectDir);
+      }
+      forced.push(relPath);
+    } else {
+      customized.push(relPath);
+    }
+  }
+
+  // Clean CoR hooks from settings.json
+  const settingsPath = path.join(projectDir, '.claude', 'settings.json');
+  let hooksRemoved = 0;
+  if (fs.existsSync(settingsPath)) {
+    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    if (settings.hooks) {
+      for (const [event, hookGroups] of Object.entries(settings.hooks)) {
+        const filtered = hookGroups.filter(group => {
+          const commands = group.hooks.map(h => h.command);
+          return !commands.some(cmd => COR_HOOK_PATTERNS.includes(cmd));
+        });
+        const removedCount = hookGroups.length - filtered.length;
+        hooksRemoved += removedCount;
+        if (filtered.length === 0) {
+          delete settings.hooks[event];
+        } else {
+          settings.hooks[event] = filtered;
+        }
+      }
+      if (Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
+      }
+      if (!dryRun) {
+        if (Object.keys(settings).length === 0) {
+          fs.unlinkSync(settingsPath);
+        } else {
+          fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+        }
+      }
+    }
+  }
+
+  // Remove .corrc.json last
+  const pibrcPath = path.join(projectDir, METADATA_FILE);
+  if (!dryRun && fs.existsSync(pibrcPath)) {
+    fs.unlinkSync(pibrcPath);
+  }
+
+  // Print summary
+  if (removed.length > 0) {
+    console.log(`  ✅ Removed ${removed.length} unmodified file${removed.length === 1 ? '' : 's'}`);
+    for (const f of removed) console.log(`     [REMOVED] ${f}`);
+  }
+
+  if (forced.length > 0) {
+    console.log(`  ⚠ Force-removed ${forced.length} customized file${forced.length === 1 ? '' : 's'}`);
+    for (const f of forced) console.log(`     [FORCED]  ${f}`);
+  }
+
+  if (customized.length > 0) {
+    console.log(`  ⏭ Skipped ${customized.length} customized file${customized.length === 1 ? '' : 's'} (use --force to remove)`);
+    for (const f of customized) console.log(`     [CUSTOMIZED] ${f}`);
+  }
+
+  if (missing.length > 0) {
+    console.log(`  ℹ ${missing.length} manifest file${missing.length === 1 ? '' : 's'} already removed`);
+  }
+
+  if (hooksRemoved > 0) {
+    console.log(`  🔧 Removed ${hooksRemoved} CoR hook${hooksRemoved === 1 ? '' : 's'} from settings.json`);
+  }
+
+  if (!dryRun) {
+    console.log(`  📝 Removed ${METADATA_FILE}`);
+  }
+
+  console.log('\n  Reset complete.\n');
+}
+
+/**
+ * Remove empty directories up to (but not including) the stop directory.
+ */
+function cleanEmptyDirs(dir, stopDir) {
+  const resolved = path.resolve(dir);
+  const stop = path.resolve(stopDir);
+
+  if (resolved === stop || !resolved.startsWith(stop)) return;
+
+  try {
+    const entries = fs.readdirSync(resolved);
+    if (entries.length === 0) {
+      fs.rmdirSync(resolved);
+      cleanEmptyDirs(path.dirname(resolved), stopDir);
+    }
+  } catch {
+    // Directory doesn't exist or not empty — stop
+  }
+}
+
+module.exports = { reset };

package/lib/settings-merge.js

@@ -0,0 +1,93 @@
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_HOOKS = {
+  PreToolUse: [
+    {
+      matcher: 'Bash',
+      hooks: [
+        {
+          type: 'command',
+          command: '.claude/hooks/git-guardrails.sh',
+        },
+      ],
+    },
+    {
+      matcher: 'Edit|Write',
+      hooks: [
+        {
+          type: 'command',
+          command: '.claude/hooks/cor-upstream-guard.sh',
+        },
+      ],
+    },
+  ],
+  UserPromptSubmit: [
+    {
+      matcher: '',
+      hooks: [
+        {
+          type: 'command',
+          command: '.claude/hooks/skill-telemetry.sh',
+        },
+      ],
+    },
+  ],
+  PostToolUse: [
+    {
+      matcher: 'Skill',
+      hooks: [
+        {
+          type: 'command',
+          command: '.claude/hooks/skill-tool-telemetry.sh',
+        },
+      ],
+    },
+  ],
+};
+
+/**
+ * Merge PIB hooks into the project's .claude/settings.json.
+ * Creates the file if it doesn't exist. Preserves existing hooks.
+ */
+function mergeSettings(projectDir, { includeDb = true } = {}) {
+  const settingsDir = path.join(projectDir, '.claude');
+  const settingsPath = path.join(settingsDir, 'settings.json');
+
+  if (!fs.existsSync(settingsDir)) {
+    fs.mkdirSync(settingsDir, { recursive: true });
+  }
+
+  let settings = {};
+  if (fs.existsSync(settingsPath)) {
+    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  }
+
+  if (!settings.hooks) settings.hooks = {};
+
+  // Merge each hook event type
+  for (const [event, newHooks] of Object.entries(DEFAULT_HOOKS)) {
+    if (!settings.hooks[event]) {
+      settings.hooks[event] = newHooks;
+    } else {
+      // Add hooks that don't already exist (check by command path)
+      for (const newHook of newHooks) {
+        const existingCommands = settings.hooks[event].flatMap(h =>
+          h.hooks.map(hh => hh.command)
+        );
+        const newCommands = newHook.hooks.map(h => h.command);
+        const alreadyExists = newCommands.every(cmd =>
+          existingCommands.includes(cmd)
+        );
+        if (!alreadyExists) {
+          settings.hooks[event].push(newHook);
+        }
+      }
+    }
+  }
+
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+  return settingsPath;
+}
+
+module.exports = { mergeSettings, DEFAULT_HOOKS };

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "create-claude-cabinet",
+  "version": "0.6.0",
+  "description": "Claude Cabinet — opinionated process scaffolding for Claude Code projects",
+  "bin": {
+    "create-claude-cabinet": "bin/create-claude-cabinet.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "templates/"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "scaffolding",
+    "process",
+    "ai",
+    "workflow"
+  ],
+  "author": "Oren Magid",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "prompts": "^2.4.2"
+  }
+}