create-claude-rails 0.1.2 → 0.3.0

package/README.md

@@ -49,7 +49,7 @@ hooks.
 - **`/onboard`** — conversational project interview, re-runnable as the
   project matures.
 - **`/seed`** — detects new tech in your project, proposes expertise.
-- **`/upgrade`** — conversational merge when Claude on Rails updates.
+- **`/cor-upgrade`** — conversational merge when Claude on Rails updates.
 
 ## How It Works
 
@@ -97,7 +97,7 @@ scripts/
 ├── pib-db.js        # work tracking CLI (if installed)
 └── ...              # triage tools (if audit installed)
 
-.pibrc.json          # installation metadata
+.corrc.json          # installation metadata
 ```
 
 ## Upgrading
@@ -106,7 +106,7 @@ scripts/
 npx create-claude-rails            # re-run to add modules
 ```
 
-In Claude Code, run `/upgrade` for conversational merge of upstream
+In Claude Code, run `/cor-upgrade` for conversational merge of upstream
 changes with your customizations.
 
 ## Philosophy

package/lib/cli.js

@@ -1,10 +1,12 @@
 const prompts = require('prompts');
 const path = require('path');
 const fs = require('fs');
+const crypto = require('crypto');
 const { copyTemplates } = require('./copy');
 const { mergeSettings } = require('./settings-merge');
 const { create: createMetadata, read: readMetadata } = require('./metadata');
 const { setupDb } = require('./db-setup');
+const { reset } = require('./reset');
 
 const VERSION = require('../package.json').version;
 
@@ -20,13 +22,15 @@ const MODULES = {
     description: 'Block destructive git ops (force push, hard reset). Track skill usage via JSONL telemetry.',
     mandatory: false,
     default: true,
+    lean: true,
     templates: ['hooks/git-guardrails.sh', 'hooks/skill-telemetry.sh', 'hooks/skill-tool-telemetry.sh'],
   },
   'work-tracking': {
-    name: 'Work Tracking (pib-db)',
-    description: 'Lightweight SQLite task/project tracker. Gives orient something to scan, debrief something to close.',
+    name: 'Work Tracking (pib-db or markdown)',
+    description: 'Track work items for orient/debrief. Default: SQLite (pib-db). Also supports markdown (tasks.md) or external systems. Choice made during /onboard.',
     mandatory: false,
     default: true,
+    lean: false,
     templates: ['scripts/pib-db.js', 'scripts/pib-db-schema.sql'],
     needsDb: true,
   },
@@ -35,6 +39,7 @@ const MODULES = {
     description: 'Structured implementation planning with perspective critique and execution checkpoints.',
     mandatory: false,
     default: true,
+    lean: true,
     templates: ['skills/plan', 'skills/execute', 'skills/investigate'],
   },
   'compliance': {
@@ -42,6 +47,7 @@ const MODULES = {
     description: 'Scoped instructions that load by path. Enforcement pipeline for promoting patterns to rules.',
     mandatory: false,
     default: true,
+    lean: false,
     templates: ['rules/enforcement-pipeline.md', 'memory/patterns/_pattern-template.md', 'memory/patterns/pattern-intelligence-first.md'],
   },
   'audit': {
@@ -49,6 +55,7 @@ const MODULES = {
     description: 'Periodic expert-perspective analysis with structured triage. Most compute-intensive module.',
     mandatory: false,
     default: true,
+    lean: true,
     templates: [
       'skills/audit', 'skills/pulse', 'skills/triage-audit',
       'skills/perspectives',
@@ -58,17 +65,19 @@ const MODULES = {
     ],
   },
   'lifecycle': {
-    name: 'Lifecycle (onboard + seed + upgrade)',
-    description: 'Conversational onboarding, capability seeding from tech signals, upgrade merges.',
+    name: 'Lifecycle (onboard + seed + cor-upgrade + link)',
+    description: 'Conversational onboarding, capability seeding, upgrade merges, local dev linking.',
     mandatory: false,
     default: true,
-    templates: ['skills/onboard', 'skills/seed', 'skills/upgrade'],
+    lean: true,
+    templates: ['skills/onboard', 'skills/seed', 'skills/cor-upgrade', 'skills/link', 'skills/unlink', 'skills/publish', 'skills/extract'],
   },
   'validate': {
     name: 'Validate',
     description: 'Structural validation checks with unified summary. Define your own validators.',
     mandatory: false,
     default: true,
+    lean: false,
     templates: ['skills/validate'],
   },
 };
@@ -85,7 +94,7 @@ function detectProjectState(dir) {
   const entries = fs.readdirSync(dir);
   const signals = entries.filter(e => PROJECT_SIGNALS.includes(e));
   const hasClaude = entries.includes('.claude');
-  const hasPibrc = fs.existsSync(path.join(dir, '.pibrc.json'));
+  const hasPibrc = fs.existsSync(path.join(dir, '.corrc.json'));
 
   if (hasPibrc) return 'existing-install';
   if (signals.length > 0) return 'existing-project';
@@ -98,17 +107,23 @@ function parseArgs(argv) {
   const args = argv.slice(2);
   const flags = {
     yes: false,
+    lean: false,
     noDb: false,
     dryRun: false,
     help: false,
+    reset: false,
+    force: false,
     targetDir: '.',
   };
 
   for (const arg of args) {
     if (arg === '--yes' || arg === '-y') flags.yes = true;
+    else if (arg === '--lean') flags.lean = true;
     else if (arg === '--no-db') flags.noDb = true;
     else if (arg === '--dry-run') flags.dryRun = true;
     else if (arg === '--help' || arg === '-h') flags.help = true;
+    else if (arg === '--reset') flags.reset = true;
+    else if (arg === '--force') flags.force = true;
     else if (!arg.startsWith('-')) flags.targetDir = arg;
   }
 
@@ -121,16 +136,22 @@ function printHelp() {
 
   Options:
     --yes, -y     Accept all defaults, no prompts
+    --lean        Install core modules only (no work-tracking, compliance, validate)
     --no-db       Skip work tracking database setup
     --dry-run     Show what would be copied without writing
+    --reset       Remove CoR files (uses manifest for safety)
+    --force       With --reset: remove even customized files
     --help, -h    Show this help
 
   Examples:
     npx create-claude-rails                 Interactive setup in current dir
     npx create-claude-rails my-project      Set up in ./my-project/
     npx create-claude-rails --yes           Install everything, no questions
+    npx create-claude-rails --lean          Session loop + planning + perspectives
     npx create-claude-rails --yes --no-db   Install everything except DB
     npx create-claude-rails --dry-run       Preview what would be installed
+    npx create-claude-rails --reset         Remove CoR files safely
+    npx create-claude-rails --reset --dry-run  Preview what --reset would do
 `);
 }
 
@@ -142,6 +163,12 @@ async function run() {
     return;
   }
 
+  if (flags.reset) {
+    const projectDir = path.resolve(flags.targetDir);
+    await reset(projectDir, { dryRun: flags.dryRun, force: flags.force });
+    return;
+  }
+
   console.log('');
   console.log('  🚂 Claude on Rails v' + VERSION);
   console.log('  Opinionated process scaffolding for Claude Code projects');
@@ -159,7 +186,7 @@ async function run() {
   if (dirState === 'existing-install') {
     const existing = readMetadata(projectDir);
     console.log(`  Found existing installation (v${existing.version}, installed ${existing.installedAt.split('T')[0]})`);
-    if (!flags.yes) {
+    if (!flags.yes && !flags.lean) {
       const { proceed } = await prompts({
         type: 'confirm',
         name: 'proceed',
@@ -173,7 +200,7 @@ async function run() {
     }
   } else if (dirState === 'existing-project') {
     console.log(`  Detected existing project in ${projectDir}`);
-    if (!flags.yes) {
+    if (!flags.yes && !flags.lean) {
       const { action } = await prompts({
         type: 'select',
         name: 'action',
@@ -217,7 +244,18 @@ async function run() {
   let skippedModules = {};
   let includeDb = !flags.noDb;
 
-  if (flags.yes) {
+  if (flags.lean) {
+    selectedModules = Object.entries(MODULES)
+      .filter(([, mod]) => mod.mandatory || mod.lean)
+      .map(([key]) => key);
+    includeDb = false;
+    const skippedKeys = Object.keys(MODULES).filter(k => !selectedModules.includes(k));
+    for (const k of skippedKeys) {
+      skippedModules[k] = 'Skipped by --lean install';
+    }
+    console.log(`  Lean install: ${selectedModules.length} modules (session-loop, hooks, planning, audit, lifecycle).`);
+    console.log(`  Skipped: ${skippedKeys.join(', ')}.\n`);
+  } else if (flags.yes) {
     selectedModules = Object.keys(MODULES);
     if (flags.noDb) {
       includeDb = false;
@@ -229,16 +267,36 @@ async function run() {
     }
     console.log(`  Installing all ${selectedModules.length} modules.${flags.noDb ? ' (skipping work-tracking DB)' : ''}\n`);
   } else {
-    const { installAll } = await prompts({
-      type: 'confirm',
-      name: 'installAll',
-      message: 'Install everything? (Y skips individual module questions)',
-      initial: true,
+    const { installMode } = await prompts({
+      type: 'select',
+      name: 'installMode',
+      message: 'How much do you want to install?',
+      choices: [
+        { title: 'Everything — all modules, full setup', value: 'full' },
+        { title: 'Lean — session loop + planning + perspectives (no DB, compliance, validate)', value: 'lean' },
+        { title: 'Custom — choose modules individually', value: 'custom' },
+      ],
     });
 
-    if (installAll) {
+    if (!installMode) {
+      console.log('  Cancelled.');
+      return;
+    }
+
+    if (installMode === 'full') {
       selectedModules = Object.keys(MODULES);
       console.log(`\n  Installing all ${selectedModules.length} modules.\n`);
+    } else if (installMode === 'lean') {
+      selectedModules = Object.entries(MODULES)
+        .filter(([, mod]) => mod.mandatory || mod.lean)
+        .map(([key]) => key);
+      includeDb = false;
+      const skippedKeys = Object.keys(MODULES).filter(k => !selectedModules.includes(k));
+      for (const k of skippedKeys) {
+        skippedModules[k] = 'Skipped by lean install';
+      }
+      console.log(`\n  Lean install: ${selectedModules.length} modules.`);
+      console.log(`  Skipped: ${skippedKeys.join(', ')}.\n`);
     } else {
       for (const [key, mod] of Object.entries(MODULES)) {
         if (mod.mandatory) {
@@ -290,6 +348,21 @@ async function run() {
   let totalCopied = 0;
   let totalSkipped = 0;
   let totalOverwritten = 0;
+  const allManifest = {}; // relPath -> hash for all written files
+
+  function hashContent(content) {
+    return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+  }
+
+  // Compute the relative path from projectDir for manifest entries
+  function manifestPath(tmpl) {
+    if (tmpl.startsWith('skills/') || tmpl.startsWith('hooks/') || tmpl.startsWith('rules/')) {
+      return '.claude/' + tmpl;
+    } else if (tmpl.startsWith('scripts/')) {
+      return tmpl;
+    }
+    return '.claude/' + tmpl;
+  }
 
   for (const modKey of selectedModules) {
     const mod = MODULES[modKey];
@@ -323,23 +396,33 @@ async function run() {
         totalCopied += results.copied.length;
         totalSkipped += results.skipped.length;
         totalOverwritten += results.overwritten.length;
+        // Collect manifest entries — prefix with the dest-relative path
+        const prefix = manifestPath(tmpl);
+        for (const [relFile, hash] of Object.entries(results.manifest)) {
+          allManifest[prefix + '/' + relFile] = hash;
+        }
       } else {
         const destDir = path.dirname(destPath);
         if (!flags.dryRun && !fs.existsSync(destDir)) {
           fs.mkdirSync(destDir, { recursive: true });
         }
 
+        const incoming = fs.readFileSync(srcPath, 'utf8');
+        const incomingHash = hashContent(incoming);
+        const mPath = manifestPath(tmpl);
+
         if (fs.existsSync(destPath)) {
           const existingContent = fs.readFileSync(destPath, 'utf8');
-          const incoming = fs.readFileSync(srcPath, 'utf8');
           if (existingContent === incoming) {
             totalSkipped++;
+            allManifest[mPath] = incomingHash;
             continue;
           }
 
           if (flags.yes) {
             // --yes: keep existing files (safe default)
             totalSkipped++;
+            allManifest[mPath] = incomingHash;
           } else {
             const response = await prompts({
               type: 'select',
@@ -357,10 +440,12 @@ async function run() {
             } else {
               totalSkipped++;
             }
+            allManifest[mPath] = incomingHash;
           }
         } else {
           if (!flags.dryRun) fs.copyFileSync(srcPath, destPath);
           totalCopied++;
+          allManifest[mPath] = incomingHash;
         }
       }
     }
@@ -403,8 +488,9 @@ async function run() {
       modules: selectedModules,
       skipped: skippedModules,
       version: VERSION,
+      manifest: allManifest,
     });
-    console.log('  📝 Created .pibrc.json');
+    console.log('  📝 Created .corrc.json');
   }
 
   // --- Summary ---

package/lib/copy.js

@@ -1,13 +1,18 @@
 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 } = {}) {
-  const results = { copied: [], skipped: [], overwritten: [] };
+  const results = { copied: [], skipped: [], overwritten: [], manifest: {} };
   await walkAndCopy(src, dest, src, results, dryRun, skipConflicts, skipPhases);
   return results;
 }
@@ -32,17 +37,21 @@ async function walkAndCopy(srcRoot, destRoot, currentSrc, results, dryRun, skipC
       }
       await walkAndCopy(srcRoot, destRoot, srcPath, results, dryRun, skipConflicts, skipPhases);
     } else {
+      const incoming = fs.readFileSync(srcPath, 'utf8');
+      const incomingHash = hashContent(incoming);
+
       if (fs.existsSync(destPath)) {
         const existing = fs.readFileSync(destPath, 'utf8');
-        const incoming = fs.readFileSync(srcPath, 'utf8');
 
         if (existing === incoming) {
           results.skipped.push(relPath);
+          results.manifest[relPath] = incomingHash;
           continue;
         }
 
         if (skipConflicts) {
           results.skipped.push(relPath);
+          results.manifest[relPath] = incomingHash;
           continue;
         }
 
@@ -60,6 +69,7 @@ async function walkAndCopy(srcRoot, destRoot, currentSrc, results, dryRun, skipC
         if (!response.action) {
           // User cancelled
           results.skipped.push(relPath);
+          results.manifest[relPath] = incomingHash;
           continue;
         }
 
@@ -77,11 +87,14 @@ async function walkAndCopy(srcRoot, destRoot, currentSrc, results, dryRun, skipC
           } 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) {
@@ -90,6 +103,7 @@ async function walkAndCopy(srcRoot, destRoot, currentSrc, results, dryRun, skipC
           fs.copyFileSync(srcPath, destPath);
         }
         results.copied.push(relPath);
+        results.manifest[relPath] = incomingHash;
       }
     }
   }

package/lib/metadata.js

@@ -1,7 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 
-const METADATA_FILE = '.pibrc.json';
+const METADATA_FILE = '.corrc.json';
 
 function metadataPath(projectDir) {
   return path.join(projectDir, METADATA_FILE);
@@ -18,13 +18,14 @@ function write(projectDir, data) {
   fs.writeFileSync(file, JSON.stringify(data, null, 2) + '\n');
 }
 
-function create(projectDir, { modules, skipped, version }) {
+function create(projectDir, { modules, skipped, version, manifest = {} }) {
   const data = {
     version,
     installedAt: new Date().toISOString(),
     upstreamPackage: 'create-claude-rails',
     modules: {},
     skipped: {},
+    manifest,
   };
 
   for (const mod of modules) {

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 on Rails — 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-rails",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Claude on Rails — opinionated process scaffolding for Claude Code projects",
   "bin": {
     "create-claude-rails": "bin/create-claude-rails.js"