@jaimevalasek/aioson 1.5.1 → 1.7.0

package/src/commands/hooks-install.js

@@ -0,0 +1,347 @@
+'use strict';
+
+/**
+ * aioson hooks:install [projectDir] --agent=<name> --tool=<claude|antigravity|codex|all>
+ *
+ * Installs AIOSON event hooks into the AI tool's settings file.
+ * After installation, every Write/Edit/Bash tool call and session stop
+ * automatically emits a runtime event to SQLite — no manual aioson calls needed.
+ *
+ * Supported tools:
+ *   --tool=claude      → ~/.claude/settings.json
+ *   --tool=antigravity → ~/.gemini/antigravity/hooks.json  (+ .agents/hooks.json in project)
+ *   --tool=codex       → ~/.codex/config.yaml  (limited: no hook system, documents workaround)
+ *   --tool=all         → installs for all detected tools
+ */
+
+const path = require('node:path');
+const fs = require('node:fs/promises');
+const os = require('node:os');
+
+const HOME = os.homedir();
+
+// ─── Config file paths ────────────────────────────────────────────────────────
+
+const CONFIG_PATHS = {
+  claude: path.join(HOME, '.claude', 'settings.json'),
+  antigravity: path.join(HOME, '.gemini', 'antigravity', 'hooks.json'),
+  antigravity_workspace: '.agents/hooks.json' // relative to project
+};
+
+// ─── Hook command templates ───────────────────────────────────────────────────
+
+function makeEmitCommand(agentName, source) {
+  // $PWD is the project directory at hook execution time
+  return `aioson hooks:emit "$PWD" --agent=${agentName} --source=${source} 2>/dev/null || true`;
+}
+
+function makeDoneCommand(agentName) {
+  return `aioson agent:done "$PWD" --agent=${agentName} --summary="Session ended via ${agentName} hook" 2>/dev/null || true`;
+}
+
+// ─── Claude Code ─────────────────────────────────────────────────────────────
+
+function buildClaudeHooks(agentName) {
+  const emitCmd = makeEmitCommand(agentName, 'claude');
+  const doneCmd = makeDoneCommand(agentName);
+
+  return {
+    PostToolUse: [
+      {
+        matcher: 'Write|Edit|MultiEdit',
+        hooks: [{ type: 'command', command: emitCmd }]
+      },
+      {
+        matcher: 'Bash',
+        hooks: [{ type: 'command', command: emitCmd }]
+      },
+      {
+        matcher: 'Task|TodoWrite',
+        hooks: [{ type: 'command', command: emitCmd }]
+      }
+    ],
+    Stop: [
+      {
+        hooks: [{ type: 'command', command: doneCmd }]
+      }
+    ]
+  };
+}
+
+async function installClaudeHooks(agentName, dryRun, logger) {
+  const configPath = CONFIG_PATHS.claude;
+  await fs.mkdir(path.dirname(configPath), { recursive: true });
+
+  let existing = {};
+  try {
+    existing = JSON.parse(await fs.readFile(configPath, 'utf8'));
+  } catch { /* file doesn't exist yet */ }
+
+  const newHooks = buildClaudeHooks(agentName);
+
+  // Merge: add AIOSON hooks without removing existing ones
+  const merged = { ...existing };
+  if (!merged.hooks) merged.hooks = {};
+
+  for (const [event, hookList] of Object.entries(newHooks)) {
+    if (!merged.hooks[event]) {
+      merged.hooks[event] = hookList;
+    } else {
+      // Remove any existing AIOSON hooks (to avoid duplicates on reinstall)
+      const filtered = merged.hooks[event].filter((entry) => {
+        const cmd = entry.hooks?.[0]?.command || '';
+        return !cmd.includes('aioson hooks:emit') && !cmd.includes('aioson agent:done');
+      });
+      merged.hooks[event] = [...filtered, ...hookList];
+    }
+  }
+
+  if (!dryRun) {
+    await fs.writeFile(configPath, JSON.stringify(merged, null, 2), 'utf8');
+    logger.log(`  ✓ Claude Code — ${configPath}`);
+  } else {
+    logger.log(`  [dry-run] Would write: ${configPath}`);
+    logger.log(`  Hooks to add:`);
+    logger.log(`    PostToolUse (Write|Edit|MultiEdit|Bash|Task|TodoWrite) → hooks:emit`);
+    logger.log(`    Stop → agent:done`);
+  }
+
+  return { tool: 'claude', configPath, hooks: newHooks };
+}
+
+// ─── Antigravity ─────────────────────────────────────────────────────────────
+
+function buildAntigravityHooks(agentName) {
+  const emitCmd = makeEmitCommand(agentName, 'antigravity');
+  const doneCmd = makeDoneCommand(agentName);
+  const startCmd = `aioson live:start "$PWD" --agent=${agentName} --tool=antigravity --no-launch 2>/dev/null || true`;
+
+  return {
+    SessionStart: [{ type: 'command', command: startCmd }],
+    PostToolUse: [
+      { matcher: 'Write|Edit|MultiEdit', hooks: [{ type: 'command', command: emitCmd }] },
+      { matcher: 'Bash', hooks: [{ type: 'command', command: emitCmd }] },
+      { matcher: 'Task|TodoWrite', hooks: [{ type: 'command', command: emitCmd }] }
+    ],
+    SessionEnd: [{ type: 'command', command: doneCmd }],
+    Stop: [{ type: 'command', command: doneCmd }]
+  };
+}
+
+async function installAntigravityHooks(agentName, projectDir, dryRun, logger) {
+  const globalPath = CONFIG_PATHS.antigravity;
+  const workspacePath = path.join(projectDir, CONFIG_PATHS.antigravity_workspace);
+
+  const hooks = buildAntigravityHooks(agentName);
+
+  if (!dryRun) {
+    await fs.mkdir(path.dirname(globalPath), { recursive: true });
+    await fs.mkdir(path.dirname(workspacePath), { recursive: true });
+
+    // Global hooks
+    let globalExisting = {};
+    try { globalExisting = JSON.parse(await fs.readFile(globalPath, 'utf8')); } catch { /* new file */ }
+    const mergedGlobal = mergeAntigravityHooks(globalExisting, hooks);
+    await fs.writeFile(globalPath, JSON.stringify(mergedGlobal, null, 2), 'utf8');
+    logger.log(`  ✓ Antigravity global — ${globalPath}`);
+
+    // Workspace hooks (project-scoped, takes priority)
+    let wsExisting = {};
+    try { wsExisting = JSON.parse(await fs.readFile(workspacePath, 'utf8')); } catch { /* new file */ }
+    const mergedWs = mergeAntigravityHooks(wsExisting, hooks);
+    await fs.writeFile(workspacePath, JSON.stringify(mergedWs, null, 2), 'utf8');
+    logger.log(`  ✓ Antigravity workspace — ${workspacePath}`);
+  } else {
+    logger.log(`  [dry-run] Would write: ${globalPath}`);
+    logger.log(`  [dry-run] Would write: ${workspacePath}`);
+    logger.log(`  Hooks to add: SessionStart → live:start, PostToolUse → hooks:emit, SessionEnd/Stop → agent:done`);
+  }
+
+  return { tool: 'antigravity', globalPath, workspacePath, hooks };
+}
+
+function mergeAntigravityHooks(existing, newHooks) {
+  const merged = { ...existing };
+  if (!merged.hooks) merged.hooks = {};
+
+  for (const [event, entries] of Object.entries(newHooks)) {
+    const existingEntries = Array.isArray(merged.hooks[event]) ? merged.hooks[event] : [];
+    // Remove previous AIOSON entries
+    const filtered = existingEntries.filter((e) => {
+      const cmd = (e.command || e.hooks?.[0]?.command || '');
+      return !cmd.includes('aioson');
+    });
+    const newEntries = Array.isArray(entries) ? entries : [entries];
+    merged.hooks[event] = [...filtered, ...newEntries];
+  }
+
+  return merged;
+}
+
+// ─── Codex (OpenAI) ───────────────────────────────────────────────────────────
+
+async function installCodexHooks(agentName, dryRun, logger) {
+  // Codex CLI does not have a native hook system as of 2026.
+  // The workaround: add a shell alias that wraps `codex` and calls live:start before / agent:done after.
+  const configPath = path.join(HOME, '.codex', 'config.yaml');
+  const wrapperPath = path.join(HOME, '.codex', 'aioson-wrapper.sh');
+
+  const wrapperScript = `#!/bin/bash
+# AIOSON session wrapper for Codex CLI
+# Generated by: aioson hooks:install --tool=codex --agent=${agentName}
+# Usage: replace \`codex\` calls with \`codex-aioson\` OR add to .bashrc:
+#   alias codex='${wrapperPath}'
+
+PROJECT_DIR="\${1:-$PWD}"
+AGENT="${agentName}"
+
+# Start live session before Codex runs
+aioson live:start "$PROJECT_DIR" --agent="$AGENT" --tool=codex --no-launch 2>/dev/null || true
+
+# Run Codex with all original arguments
+codex-bin "$@"
+EXIT_CODE=$?
+
+# Register session end
+aioson agent:done "$PROJECT_DIR" --agent="$AGENT" --summary="Codex session ended" 2>/dev/null || true
+
+exit $EXIT_CODE
+`;
+
+  if (!dryRun) {
+    await fs.mkdir(path.dirname(wrapperPath), { recursive: true });
+    await fs.writeFile(wrapperPath, wrapperScript, 'utf8');
+    await fs.chmod(wrapperPath, 0o755);
+    logger.log(`  ✓ Codex wrapper — ${wrapperPath}`);
+    logger.log(`  ⚠ Codex has no native hooks. Add this to ~/.bashrc:`);
+    logger.log(`    alias codex='${wrapperPath}'`);
+    logger.log(`  Or rename: mv $(which codex) $(which codex)-bin`);
+  } else {
+    logger.log(`  [dry-run] Would write: ${wrapperPath}`);
+    logger.log(`  ⚠ Codex has no native hook system. Wrapper script approach only.`);
+  }
+
+  return { tool: 'codex', wrapperPath, limited: true };
+}
+
+// ─── Detection ───────────────────────────────────────────────────────────────
+
+async function detectInstalledTools() {
+  const detected = [];
+  const checks = [
+    { tool: 'claude', path: path.join(HOME, '.claude') },
+    { tool: 'antigravity', path: path.join(HOME, '.gemini', 'antigravity') },
+    { tool: 'codex', path: path.join(HOME, '.codex') }
+  ];
+
+  for (const { tool, path: p } of checks) {
+    try {
+      await fs.access(p);
+      detected.push(tool);
+    } catch { /* not installed */ }
+  }
+
+  return detected;
+}
+
+// ─── Main ─────────────────────────────────────────────────────────────────────
+
+async function runHooksInstall({ args, options = {}, logger }) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const agentName = options.agent ? String(options.agent).replace(/^@/, '') : 'dev';
+  const dryRun = options['dry-run'] || options.dryRun || false;
+  let tool = options.tool ? String(options.tool).trim().toLowerCase() : 'all';
+
+  if (tool === 'all') {
+    const detected = await detectInstalledTools();
+    if (detected.length === 0) {
+      logger.log('No supported AI tools detected. Install Claude Code, Antigravity, or Codex first.');
+      return { ok: false, reason: 'no_tools_detected' };
+    }
+    logger.log(`Detected tools: ${detected.join(', ')}`);
+    tool = detected.join(',');
+  }
+
+  const tools = tool.split(',').map((t) => t.trim()).filter(Boolean);
+  const results = [];
+
+  logger.log(`Hooks Install — agent: @${agentName}${dryRun ? ' [dry-run]' : ''}`);
+  logger.log('─'.repeat(50));
+
+  for (const t of tools) {
+    try {
+      if (t === 'claude') {
+        results.push(await installClaudeHooks(agentName, dryRun, logger));
+      } else if (t === 'antigravity') {
+        results.push(await installAntigravityHooks(agentName, projectDir, dryRun, logger));
+      } else if (t === 'codex') {
+        results.push(await installCodexHooks(agentName, dryRun, logger));
+      } else {
+        logger.log(`  ⚠ Unknown tool: ${t} — supported: claude, antigravity, codex`);
+      }
+    } catch (err) {
+      logger.log(`  ✗ ${t}: ${err.message}`);
+      results.push({ tool: t, error: err.message });
+    }
+  }
+
+  logger.log('─'.repeat(50));
+
+  if (!dryRun) {
+    logger.log('');
+    logger.log('Hooks installed. From now on:');
+    logger.log('  • Every file write/edit → logged as artifact event');
+    logger.log('  • Every bash command → logged as step_done event');
+    logger.log('  • Session end → logged as agent:done');
+    logger.log('');
+    logger.log('To verify: aioson live:status . --agent=' + agentName);
+    logger.log('To uninstall: aioson hooks:uninstall --tool=' + tools.join(','));
+  }
+
+  if (options.json) {
+    return { ok: true, results, agentName, dryRun };
+  }
+
+  return { ok: true, results, agentName, dryRun };
+}
+
+async function runHooksUninstall({ args, options = {}, logger }) {
+  const agentName = options.agent ? String(options.agent).replace(/^@/, '') : 'dev';
+  const dryRun = options['dry-run'] || options.dryRun || false;
+  const tool = options.tool ? String(options.tool).trim().toLowerCase() : 'claude';
+  const tools = tool.split(',').map((t) => t.trim()).filter(Boolean);
+
+  logger.log(`Hooks Uninstall — agent: @${agentName}${dryRun ? ' [dry-run]' : ''}`);
+  logger.log('─'.repeat(50));
+
+  for (const t of tools) {
+    if (t === 'claude') {
+      try {
+        const configPath = CONFIG_PATHS.claude;
+        const existing = JSON.parse(await fs.readFile(configPath, 'utf8'));
+        if (existing.hooks) {
+          for (const event of Object.keys(existing.hooks)) {
+            existing.hooks[event] = (existing.hooks[event] || []).filter((entry) => {
+              const cmd = entry.hooks?.[0]?.command || entry.command || '';
+              return !cmd.includes('aioson hooks:emit') && !cmd.includes('aioson agent:done') && !cmd.includes('aioson live:start');
+            });
+            if (existing.hooks[event].length === 0) delete existing.hooks[event];
+          }
+          if (Object.keys(existing.hooks).length === 0) delete existing.hooks;
+        }
+        if (!dryRun) {
+          await fs.writeFile(configPath, JSON.stringify(existing, null, 2), 'utf8');
+          logger.log(`  ✓ Claude Code hooks removed — ${configPath}`);
+        } else {
+          logger.log(`  [dry-run] Would remove AIOSON hooks from: ${configPath}`);
+        }
+      } catch {
+        logger.log(`  Claude Code settings not found — nothing to remove`);
+      }
+    }
+  }
+
+  return { ok: true };
+}
+
+module.exports = { runHooksInstall, runHooksUninstall };

package/src/commands/init.js

@@ -5,6 +5,17 @@ const path = require('node:path');
 const { installTemplate } = require('../installer');
 const { applyAgentLocale } = require('../locales');
 const { resolvePromptTool } = require('../prompt-tool');
+const { runInstallWizard } = require('../install-wizard');
+const { renderRevealAnimation, renderInstallSummary, renderProgress } = require('../install-animation');
+const { getCliVersion } = require('../version');
+
+// Complete profile used when --all is passed (skip wizard, install everything)
+const ALL_PROFILE = {
+  tools: ['claude', 'codex', 'gemini', 'opencode'],
+  uses: ['development', 'squads'],
+  design: 'all',
+  locale: 'en'
+};
 
 async function directoryIsEmpty(dirPath) {
   try {
@@ -25,6 +36,8 @@ async function runInit({ args, options, logger, t }) {
   const targetDir = path.resolve(process.cwd(), projectName);
   const force = Boolean(options.force);
   const dryRun = Boolean(options['dry-run']);
+  const noInteractive = Boolean(options['no-interactive']);
+  const installAll = Boolean(options.all);
   const requestedLanguage = options.lang || options.language;
   const promptTool = resolvePromptTool(options.tool);
 
@@ -34,15 +47,33 @@ async function runInit({ args, options, logger, t }) {
     throw new Error(t('init.non_empty_dir', { targetDir }));
   }
 
+  // Run wizard for new projects (TTY only) — unless --all skips it
+  const isTTY = process.stdin.isTTY && process.stdout.isTTY;
+  let installProfile = null;
+
+  if (installAll) {
+    // --all: skip wizard, install complete
+    installProfile = ALL_PROFILE;
+    if (isTTY && !dryRun) {
+      logger.log(t('init_all.installing_full', { projectName }));
+    }
+  } else if (!noInteractive && !dryRun && isTTY) {
+    installProfile = await runInstallWizard({ noInteractive, t });
+    // null = user cancelled → fall back to full install
+  }
+
   const result = await installTemplate(targetDir, {
     overwrite: true,
     dryRun,
-    mode: 'init'
+    mode: 'init',
+    installProfile,
+    onProgress: isTTY && !dryRun ? renderProgress : null
   });
 
+  const effectiveLocale = requestedLanguage || (installProfile && installProfile.locale) || null;
   let localeApply = null;
-  if (requestedLanguage) {
-    localeApply = await applyAgentLocale(targetDir, requestedLanguage, { dryRun });
+  if (effectiveLocale) {
+    localeApply = await applyAgentLocale(targetDir, effectiveLocale, { dryRun });
     if (dryRun) {
       logger.log(t('locale_apply.dry_run_applied', { locale: localeApply.locale }));
     } else {
@@ -50,22 +81,32 @@ async function runInit({ args, options, logger, t }) {
     }
   }
 
-  logger.log(t('init.created_at', { targetDir }));
-  logger.log(t('init.files_copied', { count: result.copied.length }));
-  if (result.skipped.length > 0) {
-    logger.log(t('init.files_skipped', { count: result.skipped.length }));
+  // Reveal animation + summary (TTY only, not dry-run)
+  if (isTTY && !dryRun) {
+    const version = await getCliVersion();
+    await renderRevealAnimation(version);
+    renderInstallSummary({ result, installProfile });
+    logger.log('');
+    logger.log(t('init.step_cd', { projectName }));
+  } else {
+    logger.log(t('init.created_at', { targetDir }));
+    logger.log(t('init.files_copied', { count: result.copied.length }));
+    if (result.skipped.length > 0) {
+      logger.log(t('init.files_skipped', { count: result.skipped.length }));
+    }
+    logger.log(t('init.next_steps'));
+    logger.log(t('init.step_cd', { projectName }));
+    logger.log(t('init.step_setup'));
+    logger.log(t('init.step_agents'));
+    logger.log(t('init.step_agent_prompt', { tool: promptTool }));
   }
-  logger.log(t('init.next_steps'));
-  logger.log(t('init.step_cd', { projectName }));
-  logger.log(t('init.step_setup'));
-  logger.log(t('init.step_agents'));
-  logger.log(t('init.step_agent_prompt', { tool: promptTool }));
 
   return {
     ok: true,
     targetDir,
     ...result,
-    localeApply
+    localeApply,
+    installProfile
   };
 }
 

package/src/commands/install.js

@@ -2,14 +2,19 @@
 
 const path = require('node:path');
 const { detectFramework } = require('../detector');
-const { installTemplate } = require('../installer');
+const { installTemplate, readInstallProfile } = require('../installer');
 const { applyAgentLocale } = require('../locales');
 const { resolvePromptTool } = require('../prompt-tool');
+const { runInstallWizard } = require('../install-wizard');
+const { renderRevealAnimation, renderInstallSummary, renderProgress } = require('../install-animation');
+const { getCliVersion } = require('../version');
 
 async function runInstall({ args, options, logger, t }) {
   const targetDir = path.resolve(process.cwd(), args[0] || '.');
   const force = Boolean(options.force);
   const dryRun = Boolean(options['dry-run']);
+  const noInteractive = Boolean(options['no-interactive']);
+  const reconfigure = Boolean(options.reconfigure);
   const requestedLanguage = options.lang || options.language;
   const promptTool = resolvePromptTool(options.tool);
 
@@ -23,16 +28,42 @@ async function runInstall({ args, options, logger, t }) {
     logger.log(t('install.framework_not_detected'));
   }
 
+  // Decide install profile
+  let installProfile = null;
+  const isTTY = process.stdin.isTTY && process.stdout.isTTY;
+
+  if (!noInteractive && isTTY && !dryRun) {
+    const existingProfile = await readInstallProfile(targetDir);
+    if (!existingProfile || reconfigure) {
+      installProfile = await runInstallWizard({
+        noInteractive,
+        existingProfile: reconfigure ? existingProfile : null,
+        t
+      });
+      // null = user cancelled → fall back to full install
+    } else {
+      installProfile = existingProfile;
+      logger.log(t('install.using_saved_profile'));
+    }
+  }
+
+  // When reconfigure, we need overwrite=true so changed profile is reflected
+  const overwrite = force || reconfigure;
+
   const result = await installTemplate(targetDir, {
-    overwrite: force,
+    overwrite,
     dryRun,
     mode: 'install',
-    frameworkDetection: detection.framework
+    frameworkDetection: detection.framework,
+    installProfile,
+    onProgress: isTTY && !dryRun ? renderProgress : null
   });
 
+  // Locale: explicit --lang flag wins over profile, profile wins over nothing
+  const effectiveLocale = requestedLanguage || (installProfile && installProfile.locale) || null;
   let localeApply = null;
-  if (requestedLanguage) {
-    localeApply = await applyAgentLocale(targetDir, requestedLanguage, { dryRun });
+  if (effectiveLocale) {
+    localeApply = await applyAgentLocale(targetDir, effectiveLocale, { dryRun });
     if (dryRun) {
       logger.log(t('locale_apply.dry_run_applied', { locale: localeApply.locale }));
     } else {
@@ -40,13 +71,20 @@ async function runInstall({ args, options, logger, t }) {
     }
   }
 
-  logger.log(t('install.done_at', { targetDir }));
-  logger.log(t('install.files_copied', { count: result.copied.length }));
-  logger.log(t('install.files_skipped', { count: result.skipped.length }));
-  logger.log(t('install.next_steps'));
-  logger.log(t('install.step_setup_context'));
-  logger.log(t('install.step_agents'));
-  logger.log(t('install.step_agent_prompt', { tool: promptTool }));
+  // Reveal animation + summary (TTY only, not dry-run)
+  if (isTTY && !dryRun) {
+    const version = await getCliVersion();
+    await renderRevealAnimation(version);
+    renderInstallSummary({ result, installProfile });
+  } else {
+    logger.log(t('install.done_at', { targetDir }));
+    logger.log(t('install.files_copied', { count: result.copied.length }));
+    logger.log(t('install.files_skipped', { count: result.skipped.length }));
+    logger.log(t('install.next_steps'));
+    logger.log(t('install.step_setup_context'));
+    logger.log(t('install.step_agents'));
+    logger.log(t('install.step_agent_prompt', { tool: promptTool }));
+  }
 
   if (result.isExistingProject) {
     logger.log('');
@@ -59,7 +97,8 @@ async function runInstall({ args, options, logger, t }) {
     targetDir,
     detection,
     ...result,
-    localeApply
+    localeApply,
+    installProfile
   };
 }