codehere 0.2.2 → 0.3.0-rc.10

package/dist/presentation/cli/repl.js

@@ -0,0 +1,474 @@
+/**
+ * Interactive REPL for codehere.
+ *
+ * Bare `codehere` (no args) drops here — the CLI surface, parallel to the
+ * web UI at `codehere start`. Type a task in plain English; the Conductor
+ * routes to the right specialist; events stream to the terminal; you get
+ * the next prompt when the task completes.
+ *
+ * Why this exists:
+ * - The v0.2 REPL was removed in D7 along with the rest of the v0.2 CLI
+ *   surface. That trim went too far — it removed a CLI entry point users
+ *   relied on. rc.6 brings it back, this time backed by the v0.3
+ *   Conductor (rule-based routing) instead of v0.2's smart-route.
+ * - codehere is "PM you talk to" — terminal users should be able to talk
+ *   to it in the terminal, not be forced to a web UI. Both surfaces, both
+ *   first-class.
+ *
+ * What's here:
+ * - Read a line → route via Conductor → spawn specialist → stream events
+ *   to stdout → await completion → next prompt
+ * - `/agents` lists installed specialists and the routing rules
+ * - `/status` shows recent audit activity
+ * - `/quit` (or Ctrl+C / Ctrl+D) exits cleanly
+ */
+import readline from 'readline';
+import { colors, newline } from '../../ui.js';
+import { getVersion } from '../../utils/version.js';
+import { SessionManager, availableAgents } from '../../infrastructure/orchestration/session-manager.js';
+const SLASH_COMMANDS = [
+    // Task commands · describe the work, the Conductor routes
+    {
+        name: 'fix',
+        aliases: ['edit'],
+        args: '<file> <instruction>',
+        description: 'fix or edit a file (Conductor routes to Aider by default)',
+        action: 'task',
+        promptTemplate: (args) => {
+            const parts = args.split(/\s+/);
+            const file = parts[0];
+            const instr = parts.slice(1).join(' ');
+            return `fix ${file}: ${instr}`;
+        },
+    },
+    {
+        name: 'explain',
+        aliases: ['e'],
+        args: '<file>',
+        description: 'explain a file (Conductor routes to Claude Code by default)',
+        action: 'task',
+        promptTemplate: (args) => `explain this file in plain English: ${args}`,
+    },
+    {
+        name: 'review',
+        aliases: ['r'],
+        args: '<file>',
+        description: 'review a file for bugs and risks (routes to Claude Code)',
+        action: 'task',
+        promptTemplate: (args) => `review ${args} for bugs, security issues, and risks. List concrete findings.`,
+    },
+    {
+        name: 'plan',
+        aliases: ['p'],
+        args: '<instruction>',
+        description: 'plan a complex task into steps (routes to Codex/Claude Code)',
+        action: 'task',
+        promptTemplate: (args) => `plan: ${args}. Break down into concrete steps before any execution.`,
+    },
+    {
+        name: 'test',
+        args: '<file or area>',
+        description: 'add or write tests (routes to Codex)',
+        action: 'task',
+        promptTemplate: (args) => `add tests for ${args}. Cover edge cases and likely failure modes.`,
+    },
+    // Meta · don't spawn agents · run locally
+    { name: 'agents', aliases: ['a'], description: 'list installed specialists + routing rules', action: 'meta' },
+    { name: 'status', aliases: ['s'], description: 'last 24h activity from the audit log', action: 'meta' },
+    { name: 'trust', args: '[path]', description: 'scan a path for security issues (default: current dir)', action: 'meta' },
+    { name: 'history', aliases: ['hist'], description: 'recent prompts in this session', action: 'meta' },
+    { name: 'web', description: 'launch the web UI at :3773 (in another terminal)', action: 'meta' },
+    { name: 'undo', description: 'undo the last edit (queued for v0.5 · F3 memory layer)', action: 'meta' },
+    { name: 'cost', description: 'usage / cost (alias for /status in v0.3)', action: 'meta' },
+    { name: 'clear', description: 'clear the screen', action: 'meta' },
+    { name: 'help', aliases: ['?'], description: 'show this help', action: 'meta' },
+    { name: 'quit', aliases: ['exit', 'q'], description: 'exit (Ctrl+C / Ctrl+D also work)', action: 'meta' },
+];
+function findSlashCommand(input) {
+    const parts = input.trim().split(/\s+/);
+    const head = parts[0].toLowerCase();
+    for (const cmd of SLASH_COMMANDS) {
+        if (cmd.name === head || (cmd.aliases ?? []).includes(head)) {
+            return { command: cmd, args: parts.slice(1).join(' ').trim() };
+        }
+    }
+    return null;
+}
+export async function runInteractiveRepl(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const history = [];
+    newline();
+    console.log(colors.bold('codehere ') + colors.dim('v' + getVersion()));
+    console.log(colors.dim('Talk to your AI coding agents. Type a task to delegate; or use a /command.'));
+    newline();
+    console.log(colors.dim('  /fix /explain /review /plan      delegate a task; Conductor picks the specialist'));
+    console.log(colors.dim('  /agents /status /trust /history  show state, no agent spawn'));
+    console.log(colors.dim('  /help                            full command list'));
+    console.log(colors.dim('  ↑/↓ history  ·  Ctrl+L clear  ·  Ctrl+C / Ctrl+D exit'));
+    newline();
+    const installed = availableAgents().filter((a) => a.installed);
+    if (installed.length === 0) {
+        console.log(colors.yellow('  No specialist agents installed. Install at least one to delegate tasks:'));
+        console.log(colors.dim('    npm install -g @anthropic-ai/claude-code'));
+        console.log(colors.dim('    npm install -g @openai/codex'));
+        console.log(colors.dim('    brew install aider'));
+        console.log(colors.dim('    curl -fsSL https://opencode.ai/install | bash'));
+        newline();
+        console.log(colors.dim('You can still use ') +
+            colors.cyan('/status') +
+            colors.dim(', ') +
+            colors.cyan('codehere trust .') +
+            colors.dim(', and the safety hook here.'));
+        newline();
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: colors.cyan('› '),
+        terminal: true,
+        historySize: 200,
+    });
+    const manager = SessionManager.getInstance();
+    const promptNext = () => {
+        rl.setPrompt(colors.cyan('› '));
+        rl.prompt();
+    };
+    rl.on('close', () => {
+        newline();
+        console.log(colors.dim('Goodbye.'));
+        process.exit(0);
+    });
+    rl.on('SIGINT', () => {
+        rl.close();
+    });
+    promptNext();
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            promptNext();
+            continue;
+        }
+        history.push(trimmed);
+        // Slash commands first
+        if (trimmed.startsWith('/')) {
+            const found = findSlashCommand(trimmed.slice(1));
+            if (!found) {
+                console.log(colors.yellow(`  Unknown command: ${trimmed.split(/\s+/)[0]}`));
+                console.log(colors.dim('  Run /help to see all commands.'));
+                promptNext();
+                continue;
+            }
+            const { command, args } = found;
+            switch (command.name) {
+                case 'quit':
+                    rl.close();
+                    return;
+                case 'help':
+                    printSlashCommandHelp();
+                    break;
+                case 'clear':
+                    console.clear();
+                    newline();
+                    console.log(colors.bold('codehere ') + colors.dim('v' + getVersion()));
+                    newline();
+                    break;
+                case 'agents':
+                    printAgentsAndRoutingRules();
+                    break;
+                case 'status':
+                    await printStatusSummary();
+                    break;
+                case 'history':
+                    printHistory(history);
+                    break;
+                case 'web':
+                    console.log(colors.dim('  Tip: run ') +
+                        colors.cyan('codehere start') +
+                        colors.dim(' in another terminal to launch the web UI at http://127.0.0.1:3773'));
+                    break;
+                case 'trust':
+                    await runTrustScan(args || '.');
+                    break;
+                case 'cost':
+                    // v0.3 doesn't separate cost tracking — show the same dashboard as /status
+                    await printStatusSummary();
+                    break;
+                case 'undo':
+                    console.log(colors.dim('  /undo is queued for v0.5 (F3 memory layer).'));
+                    console.log(colors.dim('  For now, use git: ') + colors.cyan('git diff') + colors.dim(' / ') + colors.cyan('git checkout -- <file>'));
+                    break;
+                default: {
+                    // Task slash command (/fix, /explain, /review, /plan, /test) → Conductor
+                    if (command.action !== 'task' || !command.promptTemplate)
+                        break;
+                    if (!args) {
+                        console.log(colors.yellow(`  Usage: /${command.name}${command.args ? ' ' + command.args : ''}`));
+                        break;
+                    }
+                    if (installed.length === 0) {
+                        console.log(colors.yellow('  No specialist installed — install one and try again.'));
+                        break;
+                    }
+                    const promptText = command.promptTemplate(args);
+                    try {
+                        await runTask(promptText, cwd, manager);
+                    }
+                    catch (err) {
+                        console.log(colors.red('  ✗ ') + (err instanceof Error ? err.message : String(err)));
+                    }
+                    newline();
+                }
+            }
+            promptNext();
+            continue;
+        }
+        // Legacy non-slash syntax for backwards-compat with v0.2 muscle memory
+        // (commit 796d4b7's REPL accepted these forms without /).
+        const lower = trimmed.toLowerCase();
+        const legacyMatch = lower.startsWith('explain ') || lower.startsWith('e ')
+            ? { name: 'explain', argsAt: lower.startsWith('explain ') ? 8 : 2 }
+            : lower.startsWith('fix ') || lower.startsWith('edit ')
+                ? { name: 'fix', argsAt: lower.startsWith('fix ') ? 4 : 5 }
+                : lower.startsWith('review ')
+                    ? { name: 'review', argsAt: 7 }
+                    : lower.startsWith('plan ')
+                        ? { name: 'plan', argsAt: 5 }
+                        : null;
+        if (legacyMatch) {
+            const cmd = SLASH_COMMANDS.find((c) => c.name === legacyMatch.name);
+            if (cmd?.promptTemplate) {
+                const args = trimmed.substring(legacyMatch.argsAt).trim();
+                if (!args) {
+                    console.log(colors.yellow(`  Usage: /${cmd.name}${cmd.args ? ' ' + cmd.args : ''}`));
+                }
+                else if (installed.length === 0) {
+                    console.log(colors.yellow('  No specialist installed — install one and try again.'));
+                }
+                else {
+                    try {
+                        await runTask(cmd.promptTemplate(args), cwd, manager);
+                    }
+                    catch (err) {
+                        console.log(colors.red('  ✗ ') + (err instanceof Error ? err.message : String(err)));
+                    }
+                }
+                newline();
+                promptNext();
+                continue;
+            }
+        }
+        // Plain text → delegate via Conductor
+        if (installed.length === 0) {
+            console.log(colors.yellow('  No specialist installed — install one and try again.'));
+            promptNext();
+            continue;
+        }
+        try {
+            await runTask(trimmed, cwd, manager);
+        }
+        catch (err) {
+            console.log(colors.red('  ✗ ') + (err instanceof Error ? err.message : String(err)));
+        }
+        newline();
+        promptNext();
+    }
+}
+/**
+ * Run `codehere trust <path>` inline. Spawns the trust command as a child
+ * process so the existing rendering / scoring logic is reused as-is.
+ */
+async function runTrustScan(target) {
+    const { spawn } = await import('child_process');
+    const { fileURLToPath } = await import('url');
+    const { join, dirname } = await import('path');
+    // dist/presentation/cli/repl.js → walk up to dist/index.js
+    const here = fileURLToPath(import.meta.url);
+    const cliPath = join(dirname(here), '..', '..', 'index.js');
+    await new Promise((resolve) => {
+        const child = spawn('node', [cliPath, 'trust', target], { stdio: 'inherit' });
+        child.on('close', () => resolve());
+        child.on('error', (err) => {
+            console.log(colors.red('  ✗ ') + err.message);
+            resolve();
+        });
+    });
+}
+function printSlashCommandHelp() {
+    const formatRow = (cmd) => {
+        const aliases = cmd.aliases?.length ? colors.dim(' (/' + cmd.aliases.join(', /') + ')') : '';
+        const cmdLabel = '/' + cmd.name + (cmd.args ? ' ' + cmd.args : '');
+        console.log('    ' + colors.cyan(cmdLabel.padEnd(34)) + colors.dim(cmd.description) + aliases);
+    };
+    newline();
+    console.log(colors.bold('Slash commands'));
+    console.log(colors.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    newline();
+    console.log(colors.bold('  Tasks') + colors.dim(' — describe the work; Conductor routes to the right specialist'));
+    for (const cmd of SLASH_COMMANDS.filter((c) => c.action === 'task'))
+        formatRow(cmd);
+    newline();
+    console.log(colors.bold('  Meta') + colors.dim(' — run locally, no agent spawn'));
+    for (const cmd of SLASH_COMMANDS.filter((c) => c.action === 'meta'))
+        formatRow(cmd);
+    newline();
+    console.log(colors.bold('  Or just type'));
+    console.log(colors.dim('    Plain text without / → Conductor routes (e.g. "review src/auth.ts" → claude-code)'));
+    console.log(colors.dim('    Legacy v0.2 syntax: ') + colors.cyan('explain src/auth.ts') + colors.dim(' / ') + colors.cyan('fix file "instr"') + colors.dim(' also work without /'));
+    newline();
+}
+function printHistory(history) {
+    newline();
+    if (history.length === 0) {
+        console.log(colors.dim('  No prompts yet in this session.'));
+        newline();
+        return;
+    }
+    console.log(colors.bold('  Recent prompts:'));
+    history.slice(-10).forEach((h, i) => {
+        const preview = h.length > 70 ? h.slice(0, 67) + '…' : h;
+        console.log(colors.dim(`    ${(i + 1).toString().padStart(2, ' ')}. `) + preview);
+    });
+    newline();
+}
+/**
+ * Run a single task and exit — bypass the REPL prompt loop.
+ * Use case: `codehere "review src/auth.ts"` or scripts piping a task in.
+ */
+export async function runOneShot(prompt, cwd = process.cwd()) {
+    const installed = availableAgents().filter((a) => a.installed);
+    if (installed.length === 0) {
+        console.log(colors.yellow('  No specialist installed. Install one (see `codehere setup`) and try again.'));
+        process.exit(1);
+    }
+    const manager = SessionManager.getInstance();
+    try {
+        await runTask(prompt, cwd, manager);
+    }
+    catch (err) {
+        console.log(colors.red('  ✗ ') + (err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+    }
+}
+async function runTask(prompt, cwd, manager) {
+    const session = manager.spawn(prompt, 'conductor', { cwd });
+    const startedLabel = colors.dim('  ┌─ ') + colors.bold(session.sessionId.slice(0, 8)) + colors.dim(' · ' + new Date(session.startedAt).toLocaleTimeString());
+    console.log(startedLabel);
+    await new Promise((resolve) => {
+        const unsubscribe = session.subscribe((event) => {
+            renderEvent(event);
+            if (event.type === 'codehere:complete' || event.type === 'codehere:error' || event.type === 'exit') {
+                unsubscribe();
+                resolve();
+            }
+        });
+    });
+    const finalStatus = session.status;
+    const verdict = finalStatus === 'completed' ? colors.green('  └─ done') : finalStatus === 'killed' ? colors.yellow('  └─ killed') : colors.red('  └─ ' + finalStatus);
+    console.log(verdict);
+}
+function renderEvent(event) {
+    switch (event.type) {
+        case 'codehere:conductor-routing': {
+            const data = event.data;
+            console.log(colors.dim('  │ ') +
+                colors.bold('routing → ') +
+                colors.cyan(data.delegatedTo ?? '?') +
+                colors.dim(' · ' + (data.reason ?? '')));
+            break;
+        }
+        case 'codehere:steps': {
+            // Step snapshots replay frequently — skip the noisy ones; the UI handles them
+            break;
+        }
+        case 'stdout':
+        case 'stderr': {
+            const data = event.data;
+            const line = data?.line;
+            if (line) {
+                const text = String(line).trimEnd();
+                if (text)
+                    console.log(colors.dim('  │ ') + text);
+            }
+            break;
+        }
+        case 'error': {
+            const data = event.data;
+            if (data?.message)
+                console.log(colors.red('  │ ✗ ') + data.message);
+            break;
+        }
+        case 'codehere:complete':
+        case 'exit': {
+            // handled by runTask's verdict line
+            break;
+        }
+        default:
+            // Other event types — quiet by default to keep the REPL readable
+            break;
+    }
+}
+function printAgentsAndRoutingRules() {
+    newline();
+    console.log(colors.bold('  Installed specialists:'));
+    const all = availableAgents();
+    for (const a of all) {
+        const tag = a.installed ? colors.green('  ✓ ') : colors.dim('  · ');
+        const status = a.installed ? '' : colors.dim('  (not installed)');
+        console.log(tag + colors.cyan(a.id.padEnd(14)) + colors.dim(a.label) + status);
+    }
+    newline();
+    console.log(colors.bold('  Routing (rule-based; LLM classifier in v0.4):'));
+    console.log(colors.dim('    review · audit · explain → claude-code'));
+    console.log(colors.dim('    refactor · restructure → codex'));
+    console.log(colors.dim('    fix · patch · bugfix → aider'));
+    console.log(colors.dim('    scaffold · generate · bootstrap → opencode'));
+    console.log(colors.dim('    add tests · write tests → codex'));
+    console.log(colors.dim('    (anything else) → claude-code'));
+    newline();
+}
+async function printStatusSummary() {
+    newline();
+    try {
+        const { existsSync, readFileSync } = await import('fs');
+        const { join } = await import('path');
+        const { homedir } = await import('os');
+        const auditPath = process.env.CODEHERE_AUDIT_FILE || join(homedir(), '.codehere', 'audit', 'hook-events.jsonl');
+        if (!existsSync(auditPath)) {
+            console.log(colors.dim('  No audit log yet. Run a task or `codehere hook install`.'));
+            newline();
+            return;
+        }
+        const lines = readFileSync(auditPath, 'utf-8').split('\n').filter(Boolean).slice(-10);
+        const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+        let actions = 0;
+        let blocked = 0;
+        let trustSum = 0;
+        let trustN = 0;
+        for (const line of lines) {
+            try {
+                const entry = JSON.parse(line);
+                const ts = entry.timestamp ? Date.parse(entry.timestamp) : 0;
+                if (ts < cutoff)
+                    continue;
+                actions++;
+                if (entry.blocked)
+                    blocked++;
+                if (typeof entry.riskScore === 'number') {
+                    trustSum += 100 - entry.riskScore;
+                    trustN++;
+                }
+            }
+            catch {
+                /* skip malformed line */
+            }
+        }
+        const avgTrust = trustN > 0 ? Math.round(trustSum / trustN) : null;
+        console.log(colors.bold('  Last 24h:'));
+        console.log(`    ${actions} actions · ${blocked} blocked${avgTrust !== null ? ` · avg trust ${avgTrust}` : ''}`);
+    }
+    catch (err) {
+        console.log(colors.dim('  Could not read audit log: ' + (err instanceof Error ? err.message : String(err))));
+    }
+    newline();
+}
+//# sourceMappingURL=repl.js.map

package/dist/ui.js

@@ -39,7 +39,7 @@ export function printContextSummary(files, maxShow = 3) {
     const shown = unique.slice(0, maxShow);
     const more = unique.length - maxShow;
     console.log(colors.dim('Context:'));
-    shown.forEach(f => console.log(colors.dim(`  - ${f}`)));
+    shown.forEach((f) => console.log(colors.dim(`  - ${f}`)));
     if (more > 0) {
         console.log(colors.dim(`  ... and ${more} more file${more > 1 ? 's' : ''}`));
     }
@@ -147,35 +147,35 @@ export function info(message) {
 // Create professional table - minimal styling
 export function createTable(headers, rows) {
     const table = new Table({
-        head: headers.map(h => colors.bold(h)),
+        head: headers.map((h) => colors.bold(h)),
         style: {
             head: [],
             border: ['gray'],
             compact: false,
         },
         chars: {
-            'top': '─',
+            top: '─',
             'top-mid': '┬',
             'top-left': '┌',
             'top-right': '┐',
-            'bottom': '─',
+            bottom: '─',
             'bottom-mid': '┴',
             'bottom-left': '└',
             'bottom-right': '┘',
-            'left': '│',
+            left: '│',
             'left-mid': '├',
-            'mid': '─',
+            mid: '─',
             'mid-mid': '┼',
-            'right': '│',
+            right: '│',
             'right-mid': '┤',
-            'middle': '│',
+            middle: '│',
         },
         colWidths: headers.map((_, i) => {
-            const maxWidth = Math.max(headers[i].length, ...rows.map(row => (row[i] || '').length));
+            const maxWidth = Math.max(headers[i].length, ...rows.map((row) => (row[i] || '').length));
             return Math.min(maxWidth + 2, 50);
         }),
     });
-    rows.forEach(row => table.push(row));
+    rows.forEach((row) => table.push(row));
     return table;
 }
 // Format file path - subtle
@@ -436,7 +436,7 @@ export function showSlashCommandMenu() {
     newline();
     console.log(colors.bold('  Slash commands'));
     newline();
-    const maxNameLen = Math.max(...SLASH_COMMANDS.map(c => c.name.length + c.args.length)) + 1;
+    const maxNameLen = Math.max(...SLASH_COMMANDS.map((c) => c.name.length + c.args.length)) + 1;
     for (const cmd of SLASH_COMMANDS) {
         const signature = `/${cmd.name}${cmd.args ? ' ' + cmd.args : ''}`;
         const pad = ' '.repeat(Math.max(0, maxNameLen + 2 - signature.length + 8));

package/package.json

@@ -1,115 +1,77 @@
 {
   "name": "codehere",
-  "version": "0.2.2",
-  "description": "Know what your AI agent actually did — scans every AI write before it touches your codebase",
+  "version": "0.3.0-rc.10",
+  "description": "A PM for your AI coding agents. Delegate, orchestrate, and audit Claude Code, Codex, Aider, and OpenCode from one local web UI — every AI action traced, every file scored.",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
-    "codehere": "dist/index.js"
+    "codehere": "dist/index.js",
+    "ch": "dist/index.js"
   },
   "files": [
     "dist",
     "README.md",
     "LICENSE"
   ],
+  "engines": {
+    "node": ">=20"
+  },
   "scripts": {
+    "prebuild": "rm -rf dist",
     "build": "tsc",
-    "prepublishOnly": "npm run build && find dist -name '*.map' -delete && find dist -name '*.d.ts' -delete",
+    "postbuild": "chmod +x dist/index.js",
+    "repomap": "node scripts/gen-repo-map.mjs",
+    "prepublishOnly": "npm run build && find dist -name '*.map' -delete && find dist -name '*.d.ts' -delete && find dist -name '*.d.ts.map' -delete",
     "start": "node dist/index.js",
-    "start:api": "npm run build && node dist/api/server.js",
     "dev": "tsx src/index.ts",
-    "dev:api": "tsx api/server.ts",
     "test": "npm run build && vitest run",
-    "test:unit": "npm run build && tsx test/unit/run-unit-tests.ts",
-    "test:cli": "npm run build && tsx test/integration/run-cli-tests.ts",
     "test:watch": "vitest",
     "lint": "eslint src/ --ext .ts",
     "format": "prettier --write 'src/**/*.ts' 'test/**/*.ts'",
     "format:check": "prettier --check 'src/**/*.ts' 'test/**/*.ts'",
-    "test:integration": "npm run build && tsx test/integration/run-integration-tests.ts",
-    "test:scenarios": "npm run build && tsx test/scenarios/real-world-scenarios.ts",
-    "test:security": "npm run build && tsx test/security/sast-scanner.test.ts",
-    "test:security-gate": "npm run build && tsx test/security/security-gate.test.ts",
-    "test:git-workflow": "npm run build && tsx test/git/git-workflow.test.ts",
-    "test:git-react": "npm run build && tsx test/git/react-git-integration.test.ts",
-    "test:memory": "npm run build && tsx test/memory/memory-system.test.ts",
-    "test:performance": "npm run build && tsx test/performance/performance-analysis.test.ts",
-    "test:context-depth": "npm run build && tsx test/context-depth/context-depth.test.ts",
-    "test:compound-instruction": "npm run build && tsx test/compound-instruction/compound-instruction.test.ts",
-    "check-api": "npm run build && tsx -e \"import('./dist/utils/check-api-status.js').then(m => m.checkAPIStatus().then(s => { console.log(s.canProceed ? '✅ ' + s.message : '❌ ' + s.message); process.exit(s.canProceed ? 0 : 1); }))\"",
-    "test:all": "npm run build && npm run test:integration && npm run test:scenarios && npm run test:security && npm run test:security-gate && npm run test:git-workflow && npm run test:memory && npm run test:performance",
-    "test:coverage": "c8 npm run test:unit && c8 report --reporter=text --reporter=html",
-    "test:rerank": "tsx test/rerank-integration.test.ts",
-    "eval:command-r": "tsx test/command-a-evaluation.test.ts",
-    "test:verification": "npm run build && node test-verification-simple.js",
-    "measure:metrics": "npm run build && node test/measure-metrics.js",
-    "analyze:feedback": "tsx scripts/analyze-feedback.ts",
-    "check:trust": "tsx scripts/check-trust-thresholds.ts",
-    "smoke:cohere": "npm run build && tsx scripts/smoke-cohere.ts",
-    "smoke:openai": "npm run build && tsx scripts/smoke-openai.ts",
-    "test:real-providers": "npm run build && tsx test/integration/real-provider-comprehensive.test.ts",
-    "test:user-flows": "npm run build && tsx test/integration/user-flow-validation.test.ts"
+    "sbom": "npm sbom --sbom-format=spdx --omit=dev"
   },
   "keywords": [
-    "ai-coding-agent",
-    "code-security",
-    "sast",
+    "ai-coding-agents",
+    "agent-orchestration",
+    "audit-trail",
     "trust-scoring",
     "ai-safety",
-    "multi-agent",
-    "orchestration",
+    "ai-governance",
     "claude-code",
-    "cursor",
-    "coding-assistant",
-    "cli-tool",
-    "code-review",
+    "codex",
+    "aider",
+    "opencode",
     "hook-system",
-    "audit-trail",
+    "sast",
+    "cli-tool",
     "typescript"
   ],
-  "author": "Muhammad Ega",
+  "author": "The codehere authors",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/muhammadegaa/codehere.git"
+    "url": "git+https://github.com/muhammadegaa/codehere.git"
   },
   "bugs": {
     "url": "https://github.com/muhammadegaa/codehere/issues"
   },
   "homepage": "https://codehere.uk",
-  "logo": "https://codehere.uk/icon.svg",
   "dependencies": {
     "boxen": "^8.0.1",
     "chalk": "^5.3.0",
     "cli-progress": "^3.12.0",
     "cli-table3": "^0.6.5",
-    "cohere-ai": "^7.7.0",
     "commander": "^11.1.0",
-    "cors": "^2.8.5",
-    "diff": "^5.1.0",
     "dotenv": "^16.3.1",
-    "express": "^5.1.0",
-    "get-tsconfig": "^4.13.0",
-    "inquirer": "^13.0.1",
-    "ora": "^7.0.1",
-    "resolve-pkg-maps": "^1.0.0",
-    "sql.js": "^1.10.3",
-    "tiktoken": "^1.0.10",
-    "wrap-ansi": "^9.0.2"
+    "ora": "^7.0.1"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/cli-progress": "^3.11.5",
-    "@types/cors": "^2.8.19",
-    "@types/diff": "^5.0.8",
-    "@types/express": "^5.0.5",
     "@types/node": "^20.19.25",
-    "@types/sql.js": "^1.4.8",
-    "@types/supertest": "^6.0.3",
-    "c8": "^10.1.3",
     "eslint": "^10.2.0",
     "prettier": "^3.8.3",
-    "supertest": "^7.1.4",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.58.2",