ctx-cc 3.5.0 → 4.1.0

package/src/hooks.js

@@ -0,0 +1,218 @@
+import fs from 'fs';
+import path from 'path';
+import { readState, writeState } from './state.js';
+
+const CTX_HOOK_MARKER = '// CTX_HOOKS';
+
+/**
+ * Hook definitions that CTX generates for Claude Code settings.json.
+ * Each hook has: event, matcher (optional), command, description.
+ */
+const HOOK_DEFINITIONS = {
+  // Record agent completion in STATE.json
+  subagentCompletion: {
+    event: 'SubagentStop',
+    command: `node -e "
+      const fs=require('fs'),p=require('path');
+      const d=p.join(process.cwd(),'.ctx','STATE.json');
+      if(!fs.existsSync(d))process.exit(0);
+      const s=JSON.parse(fs.readFileSync(d,'utf-8'));
+      const h=s.agentHistory||[];
+      for(let i=h.length-1;i>=0;i--){
+        if(!h[i].completedAt){h[i].completedAt=new Date().toISOString();break;}
+      }
+      s.session={...s.session,lastActivity:new Date().toISOString()};
+      fs.writeFileSync(d,JSON.stringify(s,null,2)+'\\n');
+    "`,
+    description: 'Record agent completion in STATE.json',
+    configKey: 'hooks.subagentCompletion',
+    default: true,
+  },
+
+  // Block commits without test file changes
+  blockCommitWithoutTests: {
+    event: 'PreToolUse',
+    matcher: 'Bash',
+    command: `node -e "
+      const cmd=process.env.TOOL_INPUT||'';
+      if(!/git commit/.test(cmd))process.exit(0);
+      const {execSync}=require('child_process');
+      try{
+        const diff=execSync('git diff --cached --name-only',{encoding:'utf-8'});
+        const files=diff.trim().split('\\n');
+        const hasCode=files.some(f=>/\\.(js|ts|jsx|tsx|py|go|rs)$/.test(f));
+        const hasTest=files.some(f=>/\\.(test|spec)\\.|__tests__/.test(f));
+        if(hasCode&&!hasTest){
+          console.error('CTX: Commit blocked — code changes without tests.');
+          console.error('Files: '+files.filter(f=>/\\.(js|ts|jsx|tsx|py|go|rs)$/.test(f)).join(', '));
+          process.exit(2);
+        }
+      }catch{}
+    "`,
+    description: 'Block commits without corresponding test changes',
+    configKey: 'hooks.blockCommitWithoutTests',
+    default: false,
+  },
+
+  // Enforce TDD mode (strict/warn/off)
+  tddEnforcement: {
+    event: 'PreToolUse',
+    matcher: 'Bash',
+    command: `node -e "
+      const cmd=process.env.TOOL_INPUT||'';
+      if(!/git commit/.test(cmd))process.exit(0);
+      const fs=require('fs'),p=require('path');
+      const cfgPath=p.join(process.cwd(),'.ctx','config.json');
+      let mode='off';
+      try{const c=JSON.parse(fs.readFileSync(cfgPath,'utf-8'));mode=c.hooks?.tddMode||'off';}catch{}
+      if(mode==='off')process.exit(0);
+      const {execSync}=require('child_process');
+      try{
+        const diff=execSync('git diff --cached --name-only',{encoding:'utf-8'});
+        const files=diff.trim().split('\\n');
+        const hasCode=files.some(f=>/\\.(js|ts|jsx|tsx|py|go|rs)$/.test(f)&&!/\\.(test|spec)\\.|__tests__/.test(f));
+        const hasTest=files.some(f=>/\\.(test|spec)\\.|__tests__/.test(f));
+        if(hasCode&&!hasTest){
+          if(mode==='strict'){
+            console.error('CTX TDD: Commit blocked — write tests first.');
+            process.exit(2);
+          }else if(mode==='warn'){
+            console.error('CTX TDD Warning: Code changes without tests.');
+          }
+        }
+      }catch{}
+    "`,
+    description: 'TDD enforcement (strict/warn/off)',
+    configKey: 'hooks.tddMode',
+    default: 'off',
+  },
+};
+
+/**
+ * Generate Claude Code hooks section for settings.json.
+ * Reads current config to determine which hooks are enabled.
+ *
+ * Returns an array of hook objects ready for settings.json.
+ */
+export function generateHooks(config = {}) {
+  const hooks = [];
+  const hooksConfig = config.hooks || {};
+
+  for (const [key, def] of Object.entries(HOOK_DEFINITIONS)) {
+    const configValue = getNestedValue(hooksConfig, key);
+    const enabled = configValue !== undefined ? configValue : def.default;
+
+    // Skip disabled hooks
+    if (enabled === false || enabled === 'off') continue;
+
+    const hook = {
+      type: def.event,
+      command: `${CTX_HOOK_MARKER} ${def.command.replace(/\n\s*/g, ' ').trim()}`,
+    };
+
+    if (def.matcher) {
+      hook.matcher = def.matcher;
+    }
+
+    hooks.push(hook);
+  }
+
+  return hooks;
+}
+
+/**
+ * Write hooks to .claude/settings.json, preserving user's existing hooks.
+ */
+export function syncHooks(settingsDir, config = {}) {
+  const settingsPath = path.join(settingsDir, 'settings.json');
+  let settings = {};
+
+  // Read existing settings
+  try {
+    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+  } catch {}
+
+  // Preserve user hooks (non-CTX)
+  const existingHooks = settings.hooks || {};
+  const userHooks = {};
+
+  for (const [event, hookList] of Object.entries(existingHooks)) {
+    if (Array.isArray(hookList)) {
+      userHooks[event] = hookList.filter(h => !h.command?.includes(CTX_HOOK_MARKER));
+    }
+  }
+
+  // Generate CTX hooks
+  const ctxHooks = generateHooks(config);
+
+  // Merge: group by event type
+  const merged = { ...userHooks };
+  for (const hook of ctxHooks) {
+    const event = hook.type;
+    if (!merged[event]) merged[event] = [];
+    merged[event].push({
+      matcher: hook.matcher || undefined,
+      command: hook.command,
+    });
+  }
+
+  // Clean up empty arrays
+  for (const [key, val] of Object.entries(merged)) {
+    if (Array.isArray(val) && val.length === 0) delete merged[key];
+  }
+
+  settings.hooks = merged;
+
+  // Write back
+  if (!fs.existsSync(settingsDir)) fs.mkdirSync(settingsDir, { recursive: true });
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+
+  return { hooksGenerated: ctxHooks.length, settingsPath };
+}
+
+/**
+ * List all available hooks with their current status.
+ */
+export function listHooks(config = {}) {
+  const hooksConfig = config.hooks || {};
+  const result = [];
+
+  for (const [key, def] of Object.entries(HOOK_DEFINITIONS)) {
+    const configValue = getNestedValue(hooksConfig, key);
+    const status = configValue !== undefined ? configValue : def.default;
+
+    result.push({
+      key,
+      event: def.event,
+      description: def.description,
+      configKey: def.configKey,
+      status: status === false ? 'disabled' : status === true ? 'enabled' : String(status),
+      default: def.default,
+    });
+  }
+
+  return result;
+}
+
+/**
+ * Format hooks list for display.
+ */
+export function formatHooksList(hooks) {
+  const lines = [];
+  const maxKey = Math.max(20, ...hooks.map(h => h.configKey.length));
+
+  for (const h of hooks) {
+    const icon = h.status === 'disabled' || h.status === 'off' ? '○' : '●';
+    lines.push(`  ${icon} ${h.configKey.padEnd(maxKey)}  ${h.status.padEnd(10)}  ${h.description}`);
+  }
+
+  return lines.join('\n');
+}
+
+// --- internal ---
+
+function getNestedValue(obj, key) {
+  return key.split('.').reduce((o, k) => o?.[k], obj);
+}
+
+export { HOOK_DEFINITIONS, CTX_HOOK_MARKER };

package/src/install.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import readline from 'readline';
+import { saveCapabilityManifest } from './capabilities.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -15,7 +15,6 @@ const VERSION = JSON.parse(
 const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
 const green = (s) => `\x1b[32m${s}\x1b[0m`;
 const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
-const red = (s) => `\x1b[31m${s}\x1b[0m`;
 const dim = (s) => `\x1b[2m${s}\x1b[0m`;
 const bold = (s) => `\x1b[1m${s}\x1b[0m`;
 
@@ -28,23 +27,18 @@ function printBanner() {
   ╚██████╗   ██║   ██╔╝ ██╗
    ╚═════╝   ╚═╝   ╚═╝  ╚═╝
 `));
-  console.log(`  ${bold('CTX 3.3')} ${dim(`v${VERSION}`)}`);
+  console.log(`  ${bold('CTX 4.0')} ${dim(`v${VERSION}`)}`);
   console.log('  Intelligent workflow orchestration for Claude Code.');
-  console.log('  20 agents. Learning system. Predictive planning. Self-healing.\n');
+  console.log('  26 agents. 7 skills. Hooks. Phase-based lifecycle.\n');
 }
 
 function copyDir(src, dest) {
-  if (!fs.existsSync(dest)) {
-    fs.mkdirSync(dest, { recursive: true });
-  }
-
+  if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
   const entries = fs.readdirSync(src, { withFileTypes: true });
   let count = 0;
-
   for (const entry of entries) {
     const srcPath = path.join(src, entry.name);
     const destPath = path.join(dest, entry.name);
-
     if (entry.isDirectory()) {
       count += copyDir(srcPath, destPath);
     } else {
@@ -52,20 +46,16 @@ function copyDir(src, dest) {
       count++;
     }
   }
-
   return count;
 }
 
 function removeDir(dir) {
-  if (fs.existsSync(dir)) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
+  if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true, force: true });
 }
 
 export async function install(options) {
   printBanner();
 
-  // Determine target directory
   const homeDir = process.env.HOME || process.env.USERPROFILE;
   let targetBase;
 
@@ -77,19 +67,18 @@ export async function install(options) {
     console.log(`  Installing ${cyan('globally')} to ${cyan('~/.claude')}\n`);
   }
 
-  // Check for existing installation
   const commandsDir = path.join(targetBase, 'commands', 'ctx');
-  const agentsDir = targetBase === path.join(homeDir, '.claude')
-    ? path.join(targetBase, 'agents')
-    : path.join(targetBase, 'agents');
+  const agentsDir = path.join(targetBase, 'agents');
+  const skillsDir = path.join(targetBase, 'skills');
+  const hooksDir = path.join(targetBase, 'hooks');
   const ctxDir = path.join(targetBase, 'ctx');
 
+  // Check existing installation
   if (fs.existsSync(commandsDir) && !options.force) {
     const existingVersion = getExistingVersion(ctxDir);
     if (existingVersion) {
       console.log(yellow(`  ⚠ CTX ${existingVersion} is already installed.`));
       console.log(`    Use ${cyan('--force')} to reinstall.\n`);
-
       if (existingVersion === VERSION) {
         console.log(green('  ✓ Already up to date.\n'));
         process.exit(0);
@@ -97,56 +86,77 @@ export async function install(options) {
     }
   }
 
-  // Clean install - remove existing
+  // Clean previous installation
   if (options.force || !fs.existsSync(commandsDir)) {
     console.log('  Cleaning previous installation...');
     removeDir(commandsDir);
     removeDir(ctxDir);
-    // Only remove ctx-* agents, not all agents
-    if (fs.existsSync(agentsDir)) {
-      const agents = fs.readdirSync(agentsDir);
-      for (const agent of agents) {
-        if (agent.startsWith('ctx-')) {
-          fs.unlinkSync(path.join(agentsDir, agent));
-        }
-      }
-    }
+    // Only remove ctx-* agents and ctx-* skills
+    cleanupPrefixed(agentsDir, 'ctx-');
+    cleanupPrefixed(skillsDir, 'ctx-');
+    cleanupPrefixed(hooksDir, 'ctx-');
   }
 
   // Create directories
   fs.mkdirSync(commandsDir, { recursive: true });
   fs.mkdirSync(ctxDir, { recursive: true });
   fs.mkdirSync(agentsDir, { recursive: true });
+  fs.mkdirSync(skillsDir, { recursive: true });
+  fs.mkdirSync(hooksDir, { recursive: true });
 
-  // Copy commands
+  // 1. Install commands (slash commands)
   const srcCommands = path.join(packageRoot, 'commands');
   if (fs.existsSync(srcCommands)) {
     const count = copyDir(srcCommands, commandsDir);
     console.log(green(`  ✓`) + ` Installed commands/ctx (${count} files)`);
 
-    // Also copy ctx.md to commands root so /ctx works directly
+    // Copy ctx.md to commands root so /ctx works directly
     const mainRouter = path.join(commandsDir, 'ctx.md');
     const rootRouter = path.join(targetBase, 'commands', 'ctx.md');
     if (fs.existsSync(mainRouter)) {
       fs.copyFileSync(mainRouter, rootRouter);
-      console.log(green(`  ✓`) + ` Installed /ctx command`);
+      console.log(green(`  ✓`) + ` Installed /ctx router command`);
     }
   }
 
-  // Copy agents
+  // 2. Install agents (subagents with native frontmatter)
   const srcAgents = path.join(packageRoot, 'agents');
   if (fs.existsSync(srcAgents)) {
-    const agents = fs.readdirSync(srcAgents);
+    const agents = fs.readdirSync(srcAgents).filter(f => f.endsWith('.md'));
     for (const agent of agents) {
-      fs.copyFileSync(
-        path.join(srcAgents, agent),
-        path.join(agentsDir, agent)
-      );
+      fs.copyFileSync(path.join(srcAgents, agent), path.join(agentsDir, agent));
     }
-    console.log(green(`  ✓`) + ` Installed agents (${agents.length} files)`);
+    console.log(green(`  ✓`) + ` Installed agents (${agents.length} subagents)`);
   }
 
-  // Copy references
+  // 3. Install skills (progressive disclosure)
+  const srcSkills = path.join(packageRoot, 'skills');
+  if (fs.existsSync(srcSkills)) {
+    const skillDirs = fs.readdirSync(srcSkills, { withFileTypes: true })
+      .filter(d => d.isDirectory() && d.name.startsWith('ctx-'));
+    for (const dir of skillDirs) {
+      const destSkillDir = path.join(skillsDir, dir.name);
+      copyDir(path.join(srcSkills, dir.name), destSkillDir);
+    }
+    console.log(green(`  ✓`) + ` Installed skills (${skillDirs.length} skills)`);
+  }
+
+  // 4. Install hooks (deterministic enforcement scripts)
+  const srcHooks = path.join(packageRoot, 'hooks');
+  if (fs.existsSync(srcHooks)) {
+    const hookFiles = fs.readdirSync(srcHooks).filter(f => f.endsWith('.js'));
+    for (const hookFile of hookFiles) {
+      const destFile = path.join(hooksDir, `ctx-${hookFile}`);
+      fs.copyFileSync(path.join(srcHooks, hookFile), destFile);
+    }
+    console.log(green(`  ✓`) + ` Installed hooks (${hookFiles.length} scripts)`);
+  }
+
+  // 5. Generate/merge settings.json with hooks
+  mergeHooksIntoSettings(targetBase, hooksDir);
+  console.log(green(`  ✓`) + ` Configured hooks in settings.json`);
+
+  // 6. Install references and templates
   const srcRefs = path.join(packageRoot, 'references');
   const destRefs = path.join(ctxDir, 'references');
   if (fs.existsSync(srcRefs)) {
@@ -154,7 +164,6 @@ export async function install(options) {
     console.log(green(`  ✓`) + ` Installed references (${count} files)`);
   }
 
-  // Copy templates
   const srcTemplates = path.join(packageRoot, 'templates');
   const destTemplates = path.join(ctxDir, 'templates');
   if (fs.existsSync(srcTemplates)) {
@@ -162,13 +171,11 @@ export async function install(options) {
     console.log(green(`  ✓`) + ` Installed templates (${count} files)`);
   }
 
-  // Copy workflows
-  const srcWorkflows = path.join(packageRoot, 'workflows');
-  const destWorkflows = path.join(ctxDir, 'workflows');
-  if (fs.existsSync(srcWorkflows)) {
-    const count = copyDir(srcWorkflows, destWorkflows);
-    console.log(green(`  ✓`) + ` Installed workflows (${count} files)`);
-  }
+  // Generate capability-manifest.json template from DEFAULT_CAPABILITIES.
+  // /ctx:init copies this into each project's .ctx/ so the PreToolUse hook
+  // (hooks/pre-tool-use.js) has a manifest to enforce against.
+  saveCapabilityManifest(destTemplates);
+  console.log(green(`  ✓`) + ` Generated capability-manifest.json template`);
 
   // Write VERSION file
   fs.writeFileSync(path.join(ctxDir, 'VERSION'), VERSION);
@@ -176,10 +183,78 @@ export async function install(options) {
 
   // Success message
   console.log(`\n  ${green('Done!')} Launch Claude Code and run ${cyan('/ctx:help')}.`);
-  console.log(`\n  ${dim('GitHub:')} https://github.com/jufjuf/CTX`);
+  console.log(`
+  ${bold('What was installed:')}
+    ${dim('Agents:')}   ~/.claude/agents/ctx-*.md     (26 subagents)
+    ${dim('Skills:')}   ~/.claude/skills/ctx-*/        (7 skills)
+    ${dim('Commands:')} ~/.claude/commands/ctx/         (slash commands)
+    ${dim('Hooks:')}    ~/.claude/hooks/ctx-*.js        (3 hook scripts)
+    ${dim('Config:')}   ~/.claude/settings.json         (hooks registered)
+`);
+  console.log(`  ${dim('GitHub:')} https://github.com/jufjuf/CTX`);
   console.log(`  ${dim('Report issues:')} https://github.com/jufjuf/CTX/issues\n`);
 }
 
+// --- Helpers ---
+
+function cleanupPrefixed(dir, prefix) {
+  if (!fs.existsSync(dir)) return;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith(prefix)) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        removeDir(fullPath);
+      } else {
+        fs.unlinkSync(fullPath);
+      }
+    }
+  }
+}
+
+function mergeHooksIntoSettings(targetBase, hooksDir) {
+  const settingsPath = path.join(targetBase, 'settings.json');
+  let settings = {};
+
+  // Read existing settings
+  try {
+    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+  } catch {}
+
+  // Preserve non-CTX hooks
+  const existingHooks = settings.hooks || {};
+  const userHooks = {};
+  for (const [event, hookList] of Object.entries(existingHooks)) {
+    if (Array.isArray(hookList)) {
+      userHooks[event] = hookList.filter(h => !h.command?.includes('ctx-'));
+    }
+  }
+
+  // Add CTX hooks (referencing installed script files)
+  const ctxHooks = {
+    SubagentStop: [
+      { command: `node ${path.join(hooksDir, 'ctx-subagent-stop.js')}` }
+    ],
+    PreToolUse: [
+      { command: `node ${path.join(hooksDir, 'ctx-pre-tool-use.js')}` }
+    ],
+    PostToolUse: [
+      { command: `node ${path.join(hooksDir, 'ctx-post-tool-use.js')}` }
+    ],
+  };
+
+  // Merge
+  const merged = {};
+  for (const [event, hooks] of Object.entries({ ...userHooks, ...ctxHooks })) {
+    const userList = userHooks[event] || [];
+    const ctxList = ctxHooks[event] || [];
+    merged[event] = [...userList, ...ctxList];
+  }
+
+  settings.hooks = merged;
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+}
+
 function getExistingVersion(ctxDir) {
   const versionFile = path.join(ctxDir, 'VERSION');
   if (fs.existsSync(versionFile)) {