codehere 0.1.1 → 0.2.2

package/dist/presentation/cli/commands/help-command.js

@@ -2,83 +2,166 @@
  * Help Command
  * Provides contextual help for Codehere commands
  */
-import { colors, separator, newline, sectionHeader, createTable, } from '../../../ui.js';
+import { colors, newline, } from '../../../ui.js';
 const COMMAND_INFO = {
+    // === Safety & Trust (no API key needed) ===
+    'hook': {
+        name: 'hook',
+        description: 'Install, manage, and monitor the safety hook for AI coding agents',
+        usage: 'codehere hook <action>',
+        examples: [
+            'codehere hook install',
+            'codehere hook status',
+            'codehere hook log',
+            'codehere hook uninstall',
+        ],
+        related: ['trust', 'status'],
+    },
+    'trust': {
+        name: 'trust',
+        description: 'Scan your project for security issues — instant score, no API key needed',
+        usage: 'codehere trust [path] [options]',
+        examples: [
+            'codehere trust .',
+            'codehere trust src/api/',
+            'codehere trust --json',
+            'codehere trust --ci',
+            'codehere trust --badge',
+        ],
+        options: [
+            { flag: '--json', description: 'Output results as JSON' },
+            { flag: '--ci', description: 'Exit 1 if score drops below threshold' },
+            { flag: '--badge', description: 'Generate a shields.io badge for your README' },
+        ],
+        related: ['report', 'hook'],
+    },
+    'report': {
+        name: 'report',
+        description: 'Generate a shareable security audit report for your project',
+        usage: 'codehere report [options]',
+        examples: [
+            'codehere report',
+            'codehere report --simple',
+            'codehere report --json',
+            'codehere report --out audit.md',
+        ],
+        options: [
+            { flag: '--simple', description: 'Plain English report for non-technical readers' },
+            { flag: '--json', description: 'Machine-readable JSON output' },
+            { flag: '--out <file>', description: 'Write report to a file' },
+        ],
+        related: ['trust', 'status'],
+    },
+    'status': {
+        name: 'status',
+        description: 'Dashboard — what your AI agents have been doing',
+        usage: 'codehere status [options]',
+        examples: [
+            'codehere status',
+            'codehere status --sessions',
+            'codehere status --json',
+        ],
+        options: [
+            { flag: '--sessions', description: 'Show session breakdown with risk levels' },
+            { flag: '--json', description: 'Output as JSON' },
+        ],
+        related: ['hook', 'trust'],
+    },
+    'serve': {
+        name: 'serve',
+        description: 'Start MCP server — expose codehere tools to AI desktop clients',
+        usage: 'codehere serve [options]',
+        examples: [
+            'codehere serve',
+            'codehere serve --show-config',
+        ],
+        options: [
+            { flag: '--show-config', description: 'Print MCP config for Claude Desktop or Cursor' },
+        ],
+        related: ['hook'],
+    },
+    // === AI-Powered (needs API key) ===
     'ask': {
         name: 'ask',
         description: 'Ask questions about your codebase using natural language',
         usage: 'codehere ask "<question>"',
         examples: [
             'codehere ask "How does authentication work?"',
-            'codehere ask "What design patterns are used in this codebase?"',
-            'codehere ask "How is the database connection managed?"',
+            'codehere ask "What design patterns are used?"',
         ],
         related: ['explain', 'smart'],
     },
+    'fix': {
+        name: 'fix',
+        description: 'Apply AI-powered fixes to your code with safety pipeline',
+        usage: 'codehere fix <file> "<instruction>"',
+        examples: [
+            'codehere fix src/api.ts "add input validation"',
+            'codehere fix src/auth.ts "switch to bcrypt hashing"',
+        ],
+        related: ['plan', 'trust'],
+    },
     'explain': {
         name: 'explain',
-        description: 'Get detailed explanations of specific code files or functions',
-        usage: 'codehere explain <filepath> [context]',
+        description: 'Get detailed explanations of code files or functions',
+        usage: 'codehere explain <filepath>',
         examples: [
             'codehere explain src/utils.ts',
             'codehere explain src/services/auth.ts',
-            'codehere explain src/api/users.ts "focus on error handling"',
         ],
         related: ['ask', 'smart'],
     },
     'plan': {
         name: 'plan',
-        description: 'Generate a hierarchical plan for complex multi-step tasks',
+        description: 'Generate a step-by-step plan for complex tasks',
         usage: 'codehere plan "<goal>" [options]',
         examples: [
-            'codehere plan "implement user authentication system"',
-            'codehere plan "refactor user service to use dependency injection"',
-            'codehere plan "add comprehensive logging" --execute',
+            'codehere plan "implement user authentication"',
+            'codehere plan "refactor to dependency injection" --execute',
         ],
         options: [
             { flag: '--execute', description: 'Execute the plan after generation' },
-            { flag: '--review', description: 'Enable review & feedback capture (used for trust scoring and Validation Mode)' },
         ],
-        related: ['orchestrate', 'smart'],
+        related: ['orchestrate', 'fix'],
     },
     'orchestrate': {
         name: 'orchestrate',
-        description: 'Orchestrate multi-agent workflows (plan, execute, validate)',
+        description: 'Orchestrate multi-agent workflows — plan, execute, validate',
         usage: 'codehere orchestrate "<goal>" [options]',
         examples: [
-            'codehere orchestrate "implement user authentication system"',
-            'codehere orchestrate "add comprehensive logging across services"',
-            'codehere orchestrate "refactor authentication to JWT" --mode full',
+            'codehere orchestrate "implement auth system"',
+            'codehere orchestrate "add logging across services" --mode full',
         ],
         options: [
-            { flag: '--mode <mode>', description: 'Orchestration mode: plan, execute, full (default: full)' },
-            { flag: '--review', description: 'Enable review & feedback capture (used for trust scoring and Validation Mode)' },
+            { flag: '--mode <mode>', description: 'Mode: plan, execute, full (default: full)' },
         ],
         related: ['plan', 'smart'],
     },
-    'react': {
-        name: 'react',
-        description: 'Use ReAct reasoning loop for complex problem-solving',
-        usage: 'codehere react "<query>"',
+    'index': {
+        name: 'index',
+        description: 'Build semantic index of your codebase for AI queries',
+        usage: 'codehere index [options]',
         examples: [
-            'codehere react "debug why login is failing"',
-            'codehere react "find and fix the memory leak"',
-            'codehere react "optimize the slow query in user service"',
+            'codehere index',
+            'codehere index --repo ./my-project',
         ],
-        related: ['ask', 'orchestrate'],
+        options: [
+            { flag: '--repo <path>, -r <path>', description: 'Repository path (default: current directory)' },
+        ],
+        related: ['ask'],
     },
     'setup': {
         name: 'setup',
-        description: 'Interactive setup wizard for first-time users',
+        description: 'Interactive setup wizard',
         usage: 'codehere setup [options]',
         examples: [
             'codehere setup',
             'codehere setup --force',
         ],
         options: [
-            { flag: '--force, -f', description: 'Force reconfiguration even if already set up' },
+            { flag: '--force, -f', description: 'Force reconfiguration' },
         ],
-        related: ['config'],
+        related: ['config', 'hook'],
     },
     'config': {
         name: 'config',
@@ -86,37 +169,20 @@ const COMMAND_INFO = {
         usage: 'codehere config [action] [key] [value]',
         examples: [
             'codehere config',
-            'codehere config get autoCommit',
-            'codehere config set autoCommit true',
             'codehere config set temperature 0.5',
-            'codehere config reset',
-        ],
-        related: ['setup'],
-    },
-    'index': {
-        name: 'index',
-        description: 'Build semantic embeddings index of your codebase',
-        usage: 'codehere index [options]',
-        examples: [
-            'codehere index',
-            'codehere index --repo ./my-project',
         ],
-        options: [
-            { flag: '--repo <path>, -r <path>', description: 'Repository path (default: current directory)' },
-        ],
-        related: [],
+        related: ['setup', 'cost'],
     },
-    'smart': {
-        name: 'smart',
-        description: 'Unified intelligent command that routes to the right tool automatically',
-        usage: 'codehere "<query>"',
+    'cost': {
+        name: 'cost',
+        description: 'View API cost tracking and budget status',
+        usage: 'codehere cost [action]',
         examples: [
-            'codehere "How does authentication work?"',
-            'codehere "add error handling to src/utils.ts"',
-            'codehere "implement user authentication system"',
-            'codehere "refactor user service to use dependency injection"',
+            'codehere cost',
+            'codehere cost summary',
+            'codehere cost reset',
         ],
-        related: ['ask', 'plan', 'orchestrate'],
+        related: ['config', 'status'],
     },
 };
 const ALL_COMMANDS = Object.keys(COMMAND_INFO);
@@ -197,76 +263,61 @@ function displayCommandHelp(commandName) {
         return;
     }
     newline();
-    console.log(separator('═', 80));
-    console.log(colors.bold(`Codehere - Help: ${command.name}`));
-    console.log(separator('═', 80));
-    newline();
-    // Description
-    sectionHeader('Description');
-    console.log(colors.dim(command.description));
+    console.log(colors.bold(command.name) + colors.dim(' — ' + command.description));
     newline();
-    // Usage
-    sectionHeader('Usage');
-    console.log(colors.cyan(command.usage));
+    console.log(colors.bold('Usage'));
+    console.log('  ' + colors.cyan(command.usage));
     newline();
-    // Examples
-    sectionHeader('Examples');
+    console.log(colors.bold('Examples'));
     command.examples.forEach(example => {
         console.log(colors.dim('  $ ') + colors.cyan(example));
     });
     newline();
-    // Options
     if (command.options && command.options.length > 0) {
-        sectionHeader('Options');
-        const optionRows = command.options.map(opt => [opt.flag, opt.description]);
-        const optionsTable = createTable(['Flag', 'Description'], optionRows);
-        console.log(optionsTable.toString());
+        console.log(colors.bold('Options'));
+        command.options.forEach(opt => {
+            console.log('  ' + colors.cyan(opt.flag.padEnd(24)) + colors.dim(opt.description));
+        });
         newline();
     }
-    // Related commands
     if (command.related && command.related.length > 0) {
-        sectionHeader('Related Commands');
+        console.log(colors.bold('Related'));
         command.related.forEach(related => {
-            console.log(colors.dim('  • ') + colors.cyan(`codehere help ${related}`));
+            console.log('  ' + colors.cyan(`codehere help ${related}`));
         });
         newline();
     }
-    // Additional help
-    console.log(colors.dim(`For more information, run: ${colors.cyan('codehere --help')}`));
-    newline();
 }
 /**
  * Display general help (all commands overview)
  */
+function printCmd(name, desc) {
+    console.log('  ' + colors.cyan(name.padEnd(14)) + colors.dim(desc));
+}
 function displayGeneralHelp() {
     newline();
-    console.log(separator('═', 80));
-    console.log(colors.bold('Codehere - AI Coding Assistant'));
-    console.log(separator('═', 80));
+    console.log(colors.bold('codehere') + colors.dim(' — AI coding agent with built-in safety'));
     newline();
-    console.log(colors.bold('Usage:'));
-    console.log(colors.cyan('  codehere [command] [options]'));
-    console.log(colors.cyan('  codehere "<query>"              # Unified intelligent command'));
+    console.log(colors.bold('Safety & Trust') + colors.dim(' (no API key needed)'));
+    for (const cmd of ['hook', 'trust', 'report', 'status', 'serve']) {
+        printCmd(cmd, COMMAND_INFO[cmd].description);
+    }
     newline();
-    sectionHeader('Commands');
-    const commandRows = ALL_COMMANDS.map(cmd => {
-        const info = COMMAND_INFO[cmd];
-        return [cmd, info.description];
-    });
-    const commandsTable = createTable(['Command', 'Description'], commandRows);
-    console.log(commandsTable.toString());
+    console.log(colors.bold('AI-Powered') + colors.dim(' (needs API key)'));
+    for (const cmd of ['ask', 'fix', 'explain', 'plan', 'index']) {
+        printCmd(cmd, COMMAND_INFO[cmd].description);
+    }
     newline();
-    sectionHeader('Getting Started');
-    console.log(colors.dim('  1. ') + colors.cyan('codehere setup') + colors.dim('                    - Configure your environment'));
-    console.log(colors.dim('  2. ') + colors.cyan('codehere index') + colors.dim('                     - Index your codebase'));
-    console.log(colors.dim('  3. ') + colors.cyan('codehere "your question"') + colors.dim('          - Start using Codehere'));
+    console.log(colors.bold('Configuration'));
+    printCmd('setup', COMMAND_INFO['setup'].description);
     newline();
-    sectionHeader('Getting Help');
-    console.log(colors.dim('  • ') + colors.cyan('codehere --help') + colors.dim('                    - Show this help message'));
-    console.log(colors.dim('  • ') + colors.cyan('codehere help <command>') + colors.dim('            - Get help for a specific command'));
-    console.log(colors.dim('  • ') + colors.cyan('codehere help setup') + colors.dim('                 - Example: Setup wizard help'));
+    console.log(colors.bold('Getting Started'));
+    console.log(colors.dim('  1. ') + colors.cyan('codehere hook install') + colors.dim('   Start scanning every AI write'));
+    console.log(colors.dim('  2. ') + colors.cyan('codehere trust .') + colors.dim('       Scan your project (no API key)'));
+    console.log(colors.dim('  3. ') + colors.cyan('codehere setup') + colors.dim('         Configure AI provider'));
     newline();
-    console.log(colors.dim('For comprehensive documentation, see: ') + colors.cyan('docs/GETTING_STARTED.md'));
+    console.log(colors.dim('Run ') + colors.cyan('codehere help <command>') + colors.dim(' for details on any command.'));
+    console.log(colors.dim('Run ') + colors.cyan('codehere help --all') + colors.dim(' to see all commands.'));
     newline();
 }
 /**

package/dist/presentation/cli/commands/hook-command.js

@@ -0,0 +1,272 @@
+/**
+ * CLI Command: hook
+ *
+ * Manages Claude Code SDK hook integration.
+ * Intercepts every Claude Code tool call and runs Layer 0 security scan.
+ *
+ * Usage:
+ *   codehere hook install          # Add hooks to ~/.claude/settings.json
+ *   codehere hook uninstall        # Remove hooks
+ *   codehere hook status           # Show current hook config and recent events
+ *   codehere hook log              # Show recent audit log
+ *   codehere hook log --tail 50    # Last 50 events
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, copyFileSync, unlinkSync, rmdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+import { generateHookConfig, AUDIT_FILE } from '../../../infrastructure/hooks/claude-sdk-hook.js';
+import { colors, success, error, warning, info, newline, sectionHeader } from '../../../ui.js';
+// ── Skills management ─────────────────────────────────────────────────────────
+const SKILLS_TARGET_DIR = join(homedir(), '.claude', 'commands', 'codehere');
+function getSkillsSourceDir() {
+    // When running from dist/, the .claude/commands dir is at package root
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    // dist/presentation/cli/commands → ../../../../.claude/commands
+    return join(__dirname, '..', '..', '..', '..', '.claude', 'commands');
+}
+function installSkills() {
+    const sourceDir = getSkillsSourceDir();
+    if (!existsSync(sourceDir))
+        return false;
+    if (!existsSync(SKILLS_TARGET_DIR)) {
+        mkdirSync(SKILLS_TARGET_DIR, { recursive: true });
+    }
+    const files = readdirSync(sourceDir).filter(f => f.endsWith('.md'));
+    for (const file of files) {
+        copyFileSync(join(sourceDir, file), join(SKILLS_TARGET_DIR, file));
+    }
+    return files.length > 0;
+}
+function uninstallSkills() {
+    if (!existsSync(SKILLS_TARGET_DIR))
+        return;
+    try {
+        for (const file of readdirSync(SKILLS_TARGET_DIR)) {
+            unlinkSync(join(SKILLS_TARGET_DIR, file));
+        }
+        rmdirSync(SKILLS_TARGET_DIR);
+    }
+    catch { /* ignore */ }
+}
+function skillsInstalled() {
+    return existsSync(SKILLS_TARGET_DIR) &&
+        readdirSync(SKILLS_TARGET_DIR).some(f => f.endsWith('.md'));
+}
+const SETTINGS_PATH = join(homedir(), '.claude', 'settings.json');
+// ── helpers ──────────────────────────────────────────────────────────────────
+function readSettings() {
+    if (!existsSync(SETTINGS_PATH))
+        return {};
+    try {
+        return JSON.parse(readFileSync(SETTINGS_PATH, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function writeSettings(settings) {
+    const dir = join(homedir(), '.claude');
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + '\n');
+}
+function isInstalled(settings) {
+    const hooks = (settings.hooks ?? {});
+    const preToolUse = (hooks.PreToolUse ?? []);
+    return preToolUse.some(entry => entry.hooks?.some(h => h.command?.includes('codehere scan-tool')));
+}
+// ── command ───────────────────────────────────────────────────────────────────
+export async function executeHookCommand(subcommand, options = {}) {
+    const sub = subcommand ?? 'status';
+    switch (sub) {
+        case 'install': {
+            const settings = readSettings();
+            if (isInstalled(settings)) {
+                console.log(warning('codehere hooks already installed'));
+                console.log(colors.dim(`  Config: ${SETTINGS_PATH}`));
+                console.log(colors.dim('  Run `codehere hook status` to see details'));
+                newline();
+                return;
+            }
+            const hookConfig = generateHookConfig({
+                logOnly: options.logOnly,
+                blockMode: options.blockMode,
+            });
+            // Merge with existing hooks config
+            const existingHooks = settings.hooks ?? {};
+            const mergedHooks = { ...existingHooks };
+            for (const [eventName, handlers] of Object.entries(hookConfig)) {
+                const existing = mergedHooks[eventName] ?? [];
+                mergedHooks[eventName] = [...existing, ...handlers];
+            }
+            settings.hooks = mergedHooks;
+            writeSettings(settings);
+            const skillsOk = installSkills();
+            console.log(success('codehere hooks installed'));
+            newline();
+            console.log(colors.bold('What happens now:'));
+            console.log('  Every Bash, Edit, Write, and MultiEdit call your AI makes is');
+            console.log('  scanned by codehere before it executes.');
+            console.log('  Zero API calls. < 5ms per scan. Runs entirely on your machine.');
+            newline();
+            console.log(colors.bold('Scan covers:'));
+            console.log('  • Prompt injection & jailbreak attempts');
+            console.log('  • Credential theft (API keys, SSH keys, env vars)');
+            console.log('  • Destructive operations (rm -rf, DB drops, force push)');
+            console.log('  • Code injection (curl|bash, reverse shells)');
+            console.log('  • Supply chain attacks (typosquatting packages)');
+            console.log('  • OWASP Top 10 patterns (SQLi, XSS, hardcoded secrets)');
+            newline();
+            console.log(colors.bold('Audit log:'));
+            console.log(colors.dim(`  ${AUDIT_FILE}`));
+            newline();
+            if (options.logOnly) {
+                console.log(warning('Mode: log-only (no blocking). Run without --log-only to enable blocking.'));
+                newline();
+            }
+            console.log(colors.dim('  Config written to: ' + SETTINGS_PATH));
+            if (skillsOk) {
+                console.log(colors.dim(`  Skills installed to: ${SKILLS_TARGET_DIR}`));
+                newline();
+                console.log(colors.bold('Slash commands now available in your AI assistant:'));
+                console.log(colors.dim('  /codehere:trust        — scan current project'));
+                console.log(colors.dim('  /codehere:report       — generate shareable audit report'));
+                console.log(colors.dim('  /codehere:audit        — pre-merge security check'));
+                console.log(colors.dim('  /codehere:hook-status  — check hook health'));
+            }
+            newline();
+            console.log(colors.dim('  Restart your AI assistant for changes to take effect.'));
+            newline();
+            break;
+        }
+        case 'uninstall': {
+            const settings = readSettings();
+            if (!isInstalled(settings)) {
+                console.log(info('codehere hooks are not installed'));
+                return;
+            }
+            const hooks = settings.hooks;
+            for (const [eventName, handlers] of Object.entries(hooks)) {
+                if (Array.isArray(handlers)) {
+                    hooks[eventName] = handlers.filter((entry) => !entry.hooks?.some((h) => h.command?.includes('codehere scan-tool')));
+                }
+            }
+            writeSettings(settings);
+            uninstallSkills();
+            console.log(success('codehere hooks and skills removed'));
+            console.log(colors.dim('Restart your AI assistant for changes to take effect.'));
+            newline();
+            break;
+        }
+        case 'status': {
+            const settings = readSettings();
+            const installed = isInstalled(settings);
+            sectionHeader('codehere Hook Status');
+            newline();
+            if (installed) {
+                console.log(success('Running') + '  Intercepting every tool call before it executes.');
+            }
+            else {
+                console.log(warning('Not installed') + '  Run `codehere hook install` to activate.');
+            }
+            newline();
+            const skills = skillsInstalled();
+            if (skills) {
+                console.log(info('Skills') + '  /codehere:trust  /codehere:report  /codehere:audit  /codehere:hook-status');
+            }
+            else {
+                console.log(colors.dim('Skills:   not installed (run `codehere hook install` to add)'));
+            }
+            newline();
+            console.log(colors.dim('Config:   ') + SETTINGS_PATH);
+            console.log(colors.dim('Audit log:') + ' ' + AUDIT_FILE);
+            newline();
+            // Autonomous mode callout
+            console.log(colors.bold('Autonomous mode (shift+tab)'));
+            console.log(colors.dim('  When Claude Code runs without approval prompts, this hook is your'));
+            console.log(colors.dim('  last line of defense. Every tool call is scanned before it executes.'));
+            console.log(colors.dim('  After a session: `codehere status --sessions` to review what happened.'));
+            newline();
+            // Show recent audit stats
+            if (existsSync(AUDIT_FILE)) {
+                const lines = readFileSync(AUDIT_FILE, 'utf-8')
+                    .split('\n')
+                    .filter(Boolean)
+                    .slice(-1000); // last 1000 events
+                if (lines.length > 0) {
+                    const entries = lines.map(l => {
+                        try {
+                            return JSON.parse(l);
+                        }
+                        catch {
+                            return null;
+                        }
+                    }).filter(Boolean);
+                    const total = entries.length;
+                    const blocked = entries.filter((e) => e.blocked).length;
+                    const critical = entries.filter((e) => (e.criticalFindings ?? 0) > 0).length;
+                    console.log(colors.bold('What it\'s seen') + colors.dim(' (last 1000 events):'));
+                    console.log(`  ${colors.cyan(String(total))} tool calls scanned`);
+                    console.log(`  ${blocked > 0 ? colors.red(String(blocked)) : colors.green('none')} blocked`);
+                    console.log(`  ${critical > 0 ? colors.red(String(critical)) : colors.green('none')} with critical findings`);
+                    newline();
+                    if (blocked > 0) {
+                        console.log(colors.dim('  Run `codehere status --sessions` to see which sessions had blocks.'));
+                        newline();
+                    }
+                }
+            }
+            else {
+                console.log(colors.dim('  No events logged yet — run Claude Code and it\'ll start tracking.'));
+                newline();
+            }
+            break;
+        }
+        case 'log': {
+            const tail = options.tail ?? 20;
+            if (!existsSync(AUDIT_FILE)) {
+                console.log(info('No audit log yet'));
+                console.log(colors.dim('  Run `codehere hook install` first'));
+                return;
+            }
+            const lines = readFileSync(AUDIT_FILE, 'utf-8')
+                .split('\n')
+                .filter(Boolean)
+                .slice(-tail);
+            if (lines.length === 0) {
+                console.log(info('Audit log is empty'));
+                return;
+            }
+            sectionHeader(`Hook Audit Log (last ${lines.length})`);
+            newline();
+            for (const line of lines) {
+                try {
+                    const entry = JSON.parse(line);
+                    const ts = new Date(entry.timestamp).toLocaleTimeString();
+                    const status = entry.blocked
+                        ? colors.red('[BLOCKED]')
+                        : colors.green('[ALLOW]  ');
+                    const risk = entry.riskScore > 0
+                        ? colors.yellow(` risk:${entry.riskScore}`)
+                        : '';
+                    const tool = colors.cyan(entry.toolName.padEnd(10));
+                    const preview = entry.toolInput.substring(0, 60).replace(/\n/g, ' ');
+                    console.log(`  ${ts}  ${status}  ${tool}${risk}  ${colors.dim(preview)}`);
+                }
+                catch {
+                    // skip malformed line
+                }
+            }
+            newline();
+            break;
+        }
+        default: {
+            console.log(error(`Unknown subcommand: ${sub}`));
+            console.log(colors.dim('Usage: codehere hook install|uninstall|status|log'));
+            process.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=hook-command.js.map

package/dist/presentation/cli/commands/knowledge-command.js

@@ -21,7 +21,7 @@ export async function executeKnowledgeCommand(action, args, options = {}) {
         codebaseId: codebaseInfo.rootPath,
     });
     try {
-        console.log(createBanner('Knowledge Management', 'Preserved knowledge from codebase'));
+        console.log(createBanner('Knowledge', 'What we know about your code'));
         newline();
         const codebaseId = codebaseInfo.codebaseId;
         console.log(colors.dim(`Codebase: ${codebaseInfo.rootPath} (${codebaseInfo.type})`));
@@ -38,7 +38,7 @@ export async function executeKnowledgeCommand(action, args, options = {}) {
                 console.log(colors.bold('Searching knowledge...'));
                 const knowledge = await knowledgeAccess.query(codebaseId, query, options.limit || 10);
                 if (knowledge.length === 0) {
-                    console.log(warning('No knowledge found matching your query.'));
+                    console.log(warning('Nothing matches that search.'));
                     return;
                 }
                 console.log(success(`Found ${knowledge.length} knowledge item(s):\n`));
@@ -61,7 +61,7 @@ export async function executeKnowledgeCommand(action, args, options = {}) {
                     ? await knowledgeAccess.getByType(codebaseId, type, options.limit || 20)
                     : await knowledgeAccess.query(codebaseId, '', options.limit || 20);
                 if (knowledge.length === 0) {
-                    console.log(warning('No knowledge found.'));
+                    console.log(warning('Nothing saved yet.'));
                     return;
                 }
                 console.log(success(`Found ${knowledge.length} knowledge item(s):\n`));
@@ -105,7 +105,7 @@ export async function executeKnowledgeCommand(action, args, options = {}) {
                 }
                 console.log(colors.bold(`Extracting knowledge from ${filepath}...`));
                 await knowledgeExtractor.extractFromFile(filepath, codebaseId, codebaseInfo.rootPath);
-                console.log(success('Knowledge extraction complete.'));
+                console.log(success('Knowledge extracted.'));
                 break;
             }
             default: