@accelerationguy/accel 1.0.1 → 1.0.3

package/bin/install.js

@@ -489,6 +489,234 @@ function deregisterHooks() {
   }
 }
 
+// ─── User Data Paths (preserved during updates) ─────────────
+const USER_DATA_PATTERNS = [
+  // Vector user config
+  'modules/vector/vector.json',
+  'modules/vector/.vector-template/vector.json',
+  'modules/vector/sessions/',
+  // Momentum workspace data
+  'modules/momentum/data/',
+  'modules/momentum/workspace.json',
+  'modules/momentum/operator.json',
+  // Drive project state
+  'modules/drive/.drive/',
+  // Event bus (user's events and archive)
+  'events/',
+];
+
+function isUserData(relativePath) {
+  return USER_DATA_PATTERNS.some((pattern) => relativePath.startsWith(pattern));
+}
+
+// ─── Backup ─────────────────────────────────────────────────
+function createBackup() {
+  if (!fs.existsSync(ACCEL_HOME)) return null;
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const backupDir = path.join(os.homedir(), `.accel-backup-${timestamp}`);
+
+  copyRecursive(ACCEL_HOME, backupDir);
+  return backupDir;
+}
+
+// ─── Smart Update ───────────────────────────────────────────
+function updateModule(moduleId) {
+  const mod = MODULES.find((m) => m.id === moduleId);
+  if (!mod) throw new Error(`Unknown module: ${moduleId}`);
+
+  const srcDir = path.join(PACKAGE_DIR, 'modules', moduleId);
+  const destDir = path.join(ACCEL_HOME, 'modules', moduleId);
+  const commandsDir = path.join(CLAUDE_HOME, 'commands', moduleId);
+
+  // Collect user data files before update
+  const preserved = new Map();
+  if (fs.existsSync(destDir)) {
+    collectUserData(destDir, ACCEL_HOME, preserved);
+  }
+
+  // Remove old module code (but we have preserved user data in memory)
+  if (fs.existsSync(destDir)) {
+    fs.rmSync(destDir, { recursive: true, force: true });
+  }
+  if (fs.existsSync(commandsDir)) {
+    fs.rmSync(commandsDir, { recursive: true, force: true });
+  }
+
+  // Install fresh module code
+  fs.mkdirSync(destDir, { recursive: true });
+  fs.mkdirSync(commandsDir, { recursive: true });
+  copyRecursive(srcDir, destDir);
+
+  // Copy slash commands
+  const cmdSrcDirs = [
+    'commands', 'tasks', 'src/commands', 'src/tasks',
+    'skillsmith/tasks', 'skillsmith',
+    'mission-control/tasks', 'mission-control',
+  ];
+  for (const cmdDir of cmdSrcDirs) {
+    const cmdSrc = path.join(srcDir, cmdDir);
+    if (fs.existsSync(cmdSrc)) {
+      const entries = fs.readdirSync(cmdSrc);
+      for (const entry of entries) {
+        const entryPath = path.join(cmdSrc, entry);
+        if (entry.endsWith('.md') && fs.statSync(entryPath).isFile()) {
+          fs.copyFileSync(entryPath, path.join(commandsDir, entry));
+        }
+      }
+    }
+  }
+
+  // Restore user data on top of fresh code
+  let restoredCount = 0;
+  for (const [relativePath, content] of preserved) {
+    const fullPath = path.join(ACCEL_HOME, relativePath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, content);
+    restoredCount++;
+  }
+
+  // Reinstall hooks and MCP if needed
+  if (mod.hasHooks) {
+    const hooksSrc = path.join(srcDir, 'hooks');
+    const srcHooks = path.join(srcDir, 'src', 'hooks');
+    const hooksDir = fs.existsSync(hooksSrc) ? hooksSrc : fs.existsSync(srcHooks) ? srcHooks : null;
+    if (hooksDir) {
+      const hooksDest = path.join(CLAUDE_HOME, 'hooks');
+      fs.mkdirSync(hooksDest, { recursive: true });
+      copyRecursive(hooksDir, hooksDest);
+    }
+  }
+
+  if (mod.hasMcp) {
+    const mcpSrc = path.join(srcDir, 'mcp');
+    const pkgMcp = path.join(srcDir, 'src', 'packages', `momentum-mcp`);
+    const mcpDir = fs.existsSync(mcpSrc) ? mcpSrc : fs.existsSync(pkgMcp) ? pkgMcp : null;
+    if (mcpDir) {
+      const mcpDest = path.join(ACCEL_HOME, 'mcp', moduleId);
+      fs.mkdirSync(mcpDest, { recursive: true });
+      copyRecursive(mcpDir, mcpDest);
+      if (fs.existsSync(path.join(mcpDest, 'package.json'))) {
+        try {
+          execFileSync('npm', ['install', '--production', '--silent'], { cwd: mcpDest, stdio: 'pipe' });
+        } catch {}
+      }
+    }
+  }
+
+  return restoredCount;
+}
+
+function collectUserData(dir, baseDir, preserved) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === 'node_modules' || entry.name === '.git') continue;
+    const fullPath = path.join(dir, entry.name);
+    const relativePath = path.relative(baseDir, fullPath);
+
+    if (entry.isDirectory()) {
+      collectUserData(fullPath, baseDir, preserved);
+    } else if (isUserData(relativePath)) {
+      preserved.set(relativePath, fs.readFileSync(fullPath));
+    }
+  }
+}
+
+async function runUpdate() {
+  if (!fs.existsSync(MANIFEST_PATH)) {
+    console.log(`\n  ${c.yellow}Nothing to update. Run \`npx @accelerationguy/accel\` to install first.${c.reset}\n`);
+    process.exit(0);
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(MANIFEST_PATH, 'utf8'));
+  const installedVersion = manifest.version;
+  const packageJson = JSON.parse(fs.readFileSync(path.join(PACKAGE_DIR, 'package.json'), 'utf8'));
+  const newVersion = packageJson.version;
+
+  console.log(`\n  ${c.cyan}${c.bold}${BRAND} Update${c.reset}\n`);
+  console.log(`  Installed: v${installedVersion}`);
+  console.log(`  Available: v${newVersion}`);
+
+  if (installedVersion === newVersion) {
+    console.log(`\n  ${c.green}Already up to date!${c.reset}\n`);
+    process.exit(0);
+  }
+
+  // Show what's installed
+  const installedModules = Object.keys(manifest.modules);
+  console.log(`\n  Modules: ${installedModules.map((id) => {
+    const mod = MODULES.find((m) => m.id === id);
+    return mod ? mod.name : id;
+  }).join(', ')}`);
+
+  // Create backup
+  console.log(`\n  ${c.dim}Creating backup...${c.reset}`);
+  const backupDir = createBackup();
+  if (backupDir) {
+    console.log(`  ${c.green}\u2713${c.reset} Backup saved to ${backupDir}`);
+  }
+
+  // Update each installed module
+  console.log(`\n  ${c.bold}Updating...${c.reset}\n`);
+
+  const updated = [];
+  const failed = [];
+  let totalPreserved = 0;
+
+  for (const modId of installedModules) {
+    const mod = MODULES.find((m) => m.id === modId);
+    if (!mod) continue;
+    try {
+      const restoredCount = updateModule(modId);
+      totalPreserved += restoredCount;
+      updated.push(modId);
+      const preserved = restoredCount > 0 ? ` ${c.dim}(${restoredCount} user files preserved)${c.reset}` : '';
+      console.log(`  ${c.green}\u2713${c.reset} ${mod.name} updated${preserved}`);
+    } catch (e) {
+      failed.push({ id: modId, error: e.message });
+      console.log(`  ${c.red}\u2717${c.reset} ${mod.name} failed: ${e.message}`);
+    }
+  }
+
+  // Update event bus schemas
+  setupEventBus();
+
+  // Update manifest version
+  if (updated.length > 0) {
+    manifest.version = newVersion;
+    manifest.updatedAt = new Date().toISOString();
+    manifest.previousVersion = installedVersion;
+    fs.writeFileSync(MANIFEST_PATH, JSON.stringify(manifest, null, 2));
+
+    // Re-register hooks and MCP (in case format changed)
+    registerHooks(updated);
+    registerMcpServers(updated);
+    installClaudeMdBlock();
+  }
+
+  // Summary
+  console.log('');
+  if (failed.length > 0) {
+    console.log(`  ${c.yellow}${updated.length}/${installedModules.length} modules updated.${c.reset}`);
+    for (const f of failed) {
+      console.log(`  ${c.red}\u2717${c.reset} ${f.id}: ${f.error}`);
+    }
+    if (backupDir) {
+      console.log(`\n  ${c.dim}Backup at ${backupDir} — restore with: cp -R ${backupDir}/ ~/.accel/${c.reset}`);
+    }
+  } else {
+    console.log(`  ${c.green}${c.bold}Updated ${BRAND} v${installedVersion} \u2192 v${newVersion}${c.reset}`);
+    if (totalPreserved > 0) {
+      console.log(`  ${c.dim}${totalPreserved} user data files preserved (rules, workspace, configs)${c.reset}`);
+    }
+    console.log(`\n  Restart Claude Code to pick up changes.`);
+    if (backupDir) {
+      console.log(`  ${c.dim}Backup at ${backupDir} (safe to delete if everything works)${c.reset}`);
+    }
+  }
+  console.log('');
+}
+
 // ─── Event Bus Setup ────────────────────────────────────────
 function setupEventBus() {
   const eventsDir = path.join(ACCEL_HOME, 'events');
@@ -549,6 +777,7 @@ async function main() {
   const isStatus = args.includes('status');
   const isUninstall = args.includes('uninstall');
   const isUpdate = args.includes('update');
+  const isBackup = args.includes('backup');
 
   if (isStatus) {
     if (!fs.existsSync(MANIFEST_PATH)) {
@@ -564,6 +793,21 @@ async function main() {
     process.exit(0);
   }
 
+  if (isUpdate) {
+    await runUpdate();
+    process.exit(0);
+  }
+
+  if (isBackup) {
+    if (!fs.existsSync(ACCEL_HOME)) {
+      console.log(`\n  ${c.yellow}Nothing to back up. No Accelerate installation found.${c.reset}\n`);
+      process.exit(0);
+    }
+    const backupDir = createBackup();
+    console.log(`\n  ${c.green}\u2713${c.reset} Backup created at: ${backupDir}\n`);
+    process.exit(0);
+  }
+
   if (isUninstall) {
     console.log(`\n  ${c.yellow}Uninstalling ${BRAND}...${c.reset}`);
     if (fs.existsSync(ACCEL_HOME)) fs.rmSync(ACCEL_HOME, { recursive: true, force: true });

package/modules/mission-control/mission-control/tasks/status.md

@@ -1,125 +1,123 @@
 <purpose>
-Detect all installed Mission Control frameworks, report versions, health, and identify any issues. Provides a single-glance view of what's installed and working.
+Detect all installed Accelerate modules, report health, and identify issues. Single-glance view of what's installed and working.
 </purpose>
 
-<user-story>
-As a Claude Code user, I want to see what frameworks are installed and whether they're healthy, so I know if anything needs attention.
-</user-story>
-
 <when-to-use>
-- Checking what's currently installed in a workspace
-- Verifying an installation completed correctly
-- Diagnosing issues with framework behavior
-- Entry point routes here via /accel status
+- Checking what's installed
+- Verifying installation completed correctly
+- Diagnosing module issues
 </when-to-use>
 
-<context>
-@frameworks/framework-registry.md
-</context>
-
 <steps>
 
-<step name="detect_installed" priority="first">
-Check each framework's installation state.
-
-For each of the 7 frameworks, run detection checks from the registry:
-
-**Vector:**
-- Global install: check `~/.vector/vector.json` exists
-- Hook: check `~/.claude/hooks/vector-hook.py` exists
-- MCP: check `.mcp.json` has `vector-mcp` entry (workspace-level)
-- Version: grep `VECTOR_HOOK_VERSION` from hook file
-
-**Momentum:**
-- Global install: check `~/.claude/momentum-framework/` exists
-- Workspace install: check `.accel/momentum/workspace.json` exists
-- Hooks wired: check `.claude/settings.json` for `.accel/momentum/hooks/` entries
-- MCP: check `.mcp.json` has `momentum-mcp` entry
-- Data surfaces: check `.accel/momentum/data/projects.json` exists
-- Version: read from `.accel/momentum/momentum-mcp/package.json`
-
-**Drive:**
-- Install: check `~/.claude/commands/drive/` exists
-- Framework: check `~/.claude/drive-framework/` exists
-- Version: check package.json or command file headers
-
-**Ignition:**
-- Install: check `~/.claude/commands/ignition/ignition.md` exists
-- Version: read frontmatter from ignition.md
-
-**Forge:**
-- Install: check `~/.claude/commands/forge/forge.md` exists
-- Specs: check `~/.claude/forge-specs/` exists
-- Version: read frontmatter from forge.md
-
-**Radar:**
-- Framework: check `~/.claude/radar/` exists
-- Commands: check `~/.claude/commands/radar/audit.md` exists
-- Tools: check `semgrep --version`, `trivy --version`, `gitleaks --version` etc.
-- Version: grep RADAR_VERSION or count framework files
-
-Run all checks in parallel where possible.
-</step>
+<step name="read_manifest" priority="first">
+Read the Accelerate manifest to know what's installed:
 
-<step name="assess_health">
-Evaluate health of installed frameworks.
+```bash
+cat ~/.accel/manifest.json 2>/dev/null || echo "NOT_INSTALLED"
+```
+
+If NOT_INSTALLED: tell user "Accelerate is not installed. Run `npx @accelerationguy/accel` to install." and stop.
 
-For each installed framework:
+The manifest lists all installed modules, version, and install date.
+</step>
+
+<step name="detect_installed">
+Check each module's actual state. Run ALL checks in parallel:
+
+**Vector (Rules Engine):**
+- Module files: `~/.accel/modules/vector/` exists
+- User config: `~/.accel/modules/vector/vector.json` exists
+- Hook: `~/.claude/hooks/vector-hook.py` exists
+- Hook wired: `~/.claude/settings.json` has vector-hook.py in UserPromptSubmit hooks
+- MCP: `~/.mcp.json` has `vector-mcp` entry
+- Version: grep `VECTOR_HOOK_VERSION` from `~/.claude/hooks/vector-hook.py`
+
+**Momentum (Workspace State):**
+- Module files: `~/.accel/modules/momentum/` exists
+- Data: `~/.accel/modules/momentum/data/` directory exists
+- Hooks wired: `~/.claude/settings.json` has momentum hooks (active-hook.py, backlog-hook.py, momentum-pulse-check.py, psmm-injector.py, satellite-detection.py, operator.py, apex-insights.py)
+- MCP: `~/.mcp.json` has `momentum-mcp` entry
+
+**Drive (Dev Workflow):**
+- Module files: `~/.accel/modules/drive/` exists
+- Commands: `~/.claude/commands/drive/` exists
+- Command count: count .md files in `~/.claude/commands/drive/`
+
+**Ignition (Project Incubation):**
+- Module files: `~/.accel/modules/ignition/` exists
+- Commands: `~/.claude/commands/ignition/` exists
+- Command count: count .md files in `~/.claude/commands/ignition/`
+
+**Radar (Security Auditing):**
+- Module files: `~/.accel/modules/radar/` exists
+- Commands: `~/.claude/commands/radar/` exists
+- External tools: `semgrep --version`, `trivy --version`, `gitleaks --version`
+
+**Forge (Skill Builder):**
+- Module files: `~/.accel/modules/forge/` exists
+- Commands: `~/.claude/commands/forge/` exists
+
+**Mission Control (Orchestrator):**
+- Module files: `~/.accel/modules/mission-control/` exists
+- Commands: `~/.claude/commands/mission-control/` exists
+</step>
 
-1. **Wiring check**: Is it properly wired? (hooks in settings, MCP in .mcp.json)
-2. **File integrity**: Do expected files exist?
-3. **Staleness**: When was it last modified vs the source repo?
-4. **Cross-framework**: Are expected integrations present? (e.g., Drive domain in Vector)
+<step name="assess_health">
+For each module in the manifest:
 
-Health states:
-- **Healthy** — installed, wired, all files present
-- **Degraded** — installed but missing wiring or files
-- **Not installed** — framework not detected
+- **Healthy** — module files exist + commands installed + hooks/MCP wired (if applicable)
+- **Degraded** — module files exist but missing commands, hooks, or MCP wiring
+- **Not installed** — in manifest but files missing (corrupted install)
 </step>
 
 <step name="report">
-Present the status report.
-
 Format:
 ```
-Mission Control Status
+Accelerate Status (v{version})
 
-  Framework    Version   Status      Notes
-  ─────────    ───────   ──────      ─────
-  Vector         v2.0.0    Healthy     hook + MCP wired
-  Momentum         v3.0.1    Degraded    hooks not wired (run /momentum:scaffold)
-  Drive         v1.2.0    Healthy     28 commands installed
-  Ignition         v1.0.0    Healthy
-  Forge   v1.0.0    Healthy
-  Radar        v0.2.0    Healthy     10 commands, 3/8 tools installed
+  Module         Status      Notes
+  ──────         ──────      ─────
+  Vector         Healthy     hook + MCP wired
+  Momentum       Healthy     {N} hooks wired, MCP active
+  Drive          Healthy     {N} commands
+  Ignition       Healthy     {N} commands
+  Radar          Degraded    {N} commands, scan tools missing
+  Forge          Healthy     {N} commands
+  Mission Ctrl   Healthy     orchestrator active
 
-  Workspace: {workspace name from .accel/momentum/workspace.json}
-  Drift score: {from .accel/momentum/data/state.json}
-  Last groom: {date}
+  Installed: {date}
+  Modules: {count}/7
 
 Issues:
-  - {any degraded items with fix instructions}
-
-Run /accel install {framework} to install missing frameworks.
-Run /accel insights for project-level analytics.
+  - Radar: scan tools not installed
+    Fix: brew install semgrep trivy gitleaks
+
+Quick commands:
+  /momentum:scaffold  — set up workspace tracking
+  /drive:init         — initialize dev workflow
+  /ignition:ideate    — start a new project
+  /radar:audit        — run security audit
 ```
 
-If all healthy, end with: "All frameworks healthy."
-If issues found, list each with the fix command.
+If all healthy: "All modules healthy."
+If Radar tools missing: suggest brew install.
+If hooks not wired: suggest `npx @accelerationguy/accel@latest` reinstall.
 </step>
 
 </steps>
 
 <output>
-Status table showing all 7 frameworks with version, health state, and any issues. Actionable fix instructions for any degraded frameworks.
+Status table showing all modules with health state and actionable fix instructions.
 </output>
 
 <acceptance-criteria>
-- [ ] All 7 frameworks checked for installation state
-- [ ] Versions detected where possible
-- [ ] Wiring verified (hooks in settings.json, MCPs in .mcp.json)
-- [ ] Health state assigned (Healthy/Degraded/Not installed)
-- [ ] Workspace metadata included (name, drift, groom date)
-- [ ] Issues listed with fix instructions
-- [ ] Output formatted as clean, scannable table
+- [ ] Reads manifest from ~/.accel/manifest.json
+- [ ] All installed modules checked at ~/.accel/modules/{id}/
+- [ ] Commands verified at ~/.claude/commands/{id}/
+- [ ] Hooks verified in ~/.claude/settings.json (Vector, Momentum)
+- [ ] MCP verified in ~/.mcp.json (Vector, Momentum)
+- [ ] Health state assigned per module
+- [ ] Issues listed with fix commands
+- [ ] Clean table format
 </acceptance-criteria>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@accelerationguy/accel",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Accelerate — Unified Claude Code Agent Framework by Acceleration Guy",
   "bin": {
     "accel": "./bin/install.js"