@accelerationguy/accel 1.0.0 → 1.0.2

package/bin/install.js

@@ -412,27 +412,38 @@ function registerHooks(installedModules) {
   let registered = 0;
   const hooksDir = path.join(CLAUDE_HOME, 'hooks');
 
+  // Collect all hooks per event type
+  const hooksByEvent = {};
   for (const modId of installedModules) {
     const hookDefs = HOOK_DEFINITIONS[modId];
     if (!hookDefs) continue;
 
     for (const def of hookDefs) {
+      if (!hooksByEvent[def.event]) hooksByEvent[def.event] = [];
       const hookPath = path.join(hooksDir, def.script);
-      const hookEntry = {
+      hooksByEvent[def.event].push({
         type: 'command',
         command: `python3 ${hookPath}`,
-        [ACCEL_HOOK_MARKER]: true,
-      };
-
-      if (!Array.isArray(settings.hooks[def.event])) {
-        settings.hooks[def.event] = [];
-      }
-      settings.hooks[def.event].push(hookEntry);
+      });
       registered++;
       console.log(`  ${c.green}\u2713${c.reset} Hook registered: ${def.script} (${def.event})`);
     }
   }
 
+  // Write hooks in the correct Claude Code format:
+  // { "hooks": { "EventName": [ { "matcher": "", "hooks": [...] } ] } }
+  for (const [eventName, hooks] of Object.entries(hooksByEvent)) {
+    if (!Array.isArray(settings.hooks[eventName])) {
+      settings.hooks[eventName] = [];
+    }
+    // Add one entry with all Accelerate hooks grouped together
+    settings.hooks[eventName].push({
+      matcher: '',
+      hooks: hooks,
+      [ACCEL_HOOK_MARKER]: true,
+    });
+  }
+
   if (registered > 0) {
     fs.mkdirSync(path.dirname(SETTINGS_PATH), { recursive: true });
     fs.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
@@ -457,6 +468,7 @@ function deregisterHooks() {
   for (const eventName of Object.keys(settings.hooks)) {
     if (!Array.isArray(settings.hooks[eventName])) continue;
     const before = settings.hooks[eventName].length;
+    // Remove entries that have our marker (both old flat format and new grouped format)
     settings.hooks[eventName] = settings.hooks[eventName].filter(
       (h) => !h[ACCEL_HOOK_MARKER]
     );
@@ -477,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');
@@ -537,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)) {
@@ -552,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/package.json

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