codehere 0.3.0-rc.5 → 0.3.0-rc.7

package/dist/index.js

@@ -14,7 +14,6 @@ import { Command } from 'commander';
 import { config } from 'dotenv';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { existsSync, readFileSync } from 'fs';
 import { executeSetupCommand } from './presentation/cli/commands/setup-command.js';
 import { executeConfigCommand } from './presentation/cli/commands/config-command.js';
 import { executeHelpCommand } from './presentation/cli/commands/help-command.js';
@@ -44,54 +43,25 @@ program
     .description('A PM for your AI coding agents. Delegate a task, watch it run, get a plain-English report with a trust score on every file.')
     .version(getVersion())
     .configureHelp({ helpWidth: 80, sortSubcommands: true });
-// Default action · show welcome + quick start (no REPL; v0.3 is web-UI-first)
+// Default action · show welcome, then drop into the interactive REPL on TTY.
+// codehere offers TWO surfaces, both first-class: the CLI REPL (here) and the
+// web UI (`codehere start`). Users pick whichever fits their workflow.
 program
-    .argument('[query]', 'Reserved — the PM intake lives at http://127.0.0.1:3773 after you run `codehere start`')
+    .argument('[query]', 'Optional initial task to delegate (otherwise enter interactive REPL)')
     .action(async (query) => {
+    // One-shot delegate: `codehere "review src/auth.ts"` runs that task and exits.
+    // Useful for scripting or quick one-offs without entering the REPL.
     if (query && query.trim()) {
-        console.error(error('Direct-query routing was removed in v0.3 (D7 trim).'));
-        console.log(colors.dim('Use the PM intake instead:'));
-        console.log('  ' + colors.cyan('codehere start') + '          → web UI at http://127.0.0.1:3773');
-        console.log('  ' + colors.cyan(`codehere task "${query.trim().slice(0, 40)}..."`) + ' → spawn via CLI');
-        process.exit(1);
+        const { runOneShot } = await import('./presentation/cli/repl.js');
+        await runOneShot(query.trim());
+        return;
     }
     if (!process.stdin.isTTY) {
         console.log(createWelcomeMessage());
         return;
     }
-    const codehereDir = join(process.env.HOME || '', '.codehere');
-    const settingsPath = join(process.env.HOME || '', '.claude', 'settings.json');
-    const hasHooks = existsSync(settingsPath) && readFileSync(settingsPath, 'utf-8').includes('codehere');
-    const hasAuditLog = existsSync(join(codehereDir, 'audit', 'hook-events.jsonl'));
-    console.log(createWelcomeMessage());
-    newline();
-    if (!hasHooks && !hasAuditLog) {
-        console.log(colors.bold("Welcome! Let's get you set up."));
-        newline();
-        console.log('  ' + colors.bold('Safety first — no API key, instant'));
-        console.log(colors.dim('  Every AI write gets scanned. Catches injections, hardcoded secrets,'));
-        console.log(colors.dim('  destructive ops, and more.'));
-        newline();
-        console.log('    → Run ' + colors.cyan('codehere hook install') + ' to activate safety');
-        console.log('    → Run ' + colors.cyan('codehere trust .') + ' to scan this project');
-        newline();
-        console.log('  ' + colors.bold('Delegate tasks — the PM for your AI coding agents'));
-        console.log(colors.dim('  Pick Claude Code, Codex, Aider, or OpenCode. codehere coordinates.'));
-        newline();
-        console.log('    → Run ' + colors.cyan('codehere start') + ' to open the task UI');
-        newline();
-    }
-    else {
-        console.log(colors.bold('Quick start:'));
-        newline();
-        console.log('  ' + colors.cyan('codehere start') + '            Task intake UI at http://127.0.0.1:3773');
-        console.log('  ' + colors.cyan('codehere status') + '           Dashboard · sessions · blocked calls');
-        console.log('  ' + colors.cyan('codehere report') + '           Generate a shareable audit report');
-        console.log('  ' + colors.cyan('codehere trust .') + '          Scan this project now');
-        newline();
-        console.log(colors.dim('  Run `codehere --help` for all commands.'));
-        newline();
-    }
+    const { runInteractiveRepl } = await import('./presentation/cli/repl.js');
+    await runInteractiveRepl();
 });
 // ── setup ────────────────────────────────────────────────────────────────────
 program

package/dist/infrastructure/orchestration/conductor-adapter.js

@@ -65,36 +65,94 @@ const ROUTING_RULES = [
 ];
 /** Default specialist when no routing rule matches. */
 const DEFAULT_SPECIALIST = 'claude-code';
+/**
+ * Tokenize a prompt for trigger matching. Splits on any non-alphanumeric
+ * boundary (whitespace, hyphens, punctuation), lowercases everything. So:
+ *
+ *   "Bug fix"        → ["bug", "fix"]
+ *   "set-up auth"    → ["set", "up", "auth"]    (trigger "set up" still matches via phrase below)
+ *   "unit-test it"   → ["unit", "test", "it"]
+ *   "prefix matter"  → ["prefix", "matter"]      (does NOT match `fix`)
+ *   "hotfixes"       → ["hotfixes"]              (does NOT match `fix`)
+ *
+ * Multi-word triggers ("add tests", "create new") are matched against the
+ * normalized prompt directly using word boundaries — so they catch
+ * "add tests" but not "added testing harness".
+ */
+function tokenize(prompt) {
+    const tokens = new Set(prompt
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean));
+    // Normalized form for multi-word phrase matching: hyphens/underscores → space,
+    // collapse runs of whitespace. Leaves alphanumerics intact.
+    const normalized = ' ' + prompt.toLowerCase().replace(/[-_]+/g, ' ').replace(/\s+/g, ' ').trim() + ' ';
+    return { tokens, normalized };
+}
+/**
+ * Test whether a routing trigger matches a prompt. Single-word triggers must
+ * appear as whole tokens (no substring matches). Multi-word triggers must
+ * appear as a phrase in the normalized prompt (with leading/trailing spaces
+ * to enforce word boundaries on the ends).
+ */
+function triggerMatches(trigger, tokens, normalized) {
+    const t = trigger.toLowerCase().trim();
+    if (!t)
+        return false;
+    if (t.includes(' ')) {
+        return normalized.includes(' ' + t + ' ');
+    }
+    return tokens.has(t);
+}
 /**
  * Pick the right specialist for a given prompt.
  *
  * Algorithm:
- *  1. Walk routing rules in order.
- *  2. For the first rule whose triggers match, walk its `preferred` list.
- *  3. Return the first preferred adapter that's installed.
- *  4. If no rule matches OR no preferred adapter is installed, fall back to
- *     `DEFAULT_SPECIALIST` if it's installed; otherwise the first-installed
- *     adapter on the list.
+ *  1. Tokenize the prompt (whole-word matching, no substring false-positives).
+ *  2. Walk routing rules in order. Stop at the first rule whose triggers match.
+ *  3. Within that rule, return the first preferred adapter that's installed.
+ *  4. If that rule had a match but none of its preferred adapters are
+ *     installed, return DEFAULT_SPECIALIST (or first installed) with a
+ *     HONEST reason that names the matched rule and the fallback.
+ *  5. If no rule matched at all, return DEFAULT_SPECIALIST (or first
+ *     installed) with a "no intent matched" reason.
  *
  * Returns null if NO specialist is installed (caller must handle).
+ *
+ * Known limitation: a prompt with multiple intents (e.g. "fix the bug and
+ * add tests") routes by the first matching rule, not the dominant intent.
+ * The v0.4 LLM classifier inherently handles dominance via confidence
+ * scoring; the rule-based path here keeps the deterministic-priority
+ * contract instead.
  */
 export function pickSpecialist(prompt, installedAgentIds) {
     if (installedAgentIds.length === 0) {
         return null;
     }
-    const lowered = prompt.toLowerCase();
+    const installedSet = new Set(installedAgentIds);
+    const { tokens, normalized } = tokenize(prompt);
     for (const rule of ROUTING_RULES) {
-        const matches = rule.triggers.some((t) => lowered.includes(t));
+        const matches = rule.triggers.some((t) => triggerMatches(t, tokens, normalized));
         if (!matches)
             continue;
+        // Rule matched. Walk preferred specialists in order.
         for (const candidate of rule.preferred) {
-            if (installedAgentIds.includes(candidate)) {
+            if (installedSet.has(candidate)) {
                 return { agentId: candidate, reason: rule.reason };
             }
         }
+        // Rule matched but none of its preferred specialists are installed.
+        // Fall through with an HONEST reason that names the matched rule + fallback,
+        // so the audit log records what actually happened (Codex review caught
+        // the prior version saying "default routing" here, which was a lie).
+        const fallbackId = installedSet.has(DEFAULT_SPECIALIST) ? DEFAULT_SPECIALIST : installedAgentIds[0];
+        return {
+            agentId: fallbackId,
+            reason: `${rule.reason} — but none of [${rule.preferred.join(', ')}] installed; falling back to ${fallbackId}`,
+        };
     }
-    // No rule matched (or no preferred specialist installed) — default routing.
-    if (installedAgentIds.includes(DEFAULT_SPECIALIST)) {
+    // No rule matched. Default routing.
+    if (installedSet.has(DEFAULT_SPECIALIST)) {
         return { agentId: DEFAULT_SPECIALIST, reason: 'default routing (no specific intent matched)' };
     }
     return { agentId: installedAgentIds[0], reason: 'fallback to first available specialist' };

package/dist/presentation/cli/repl.js

@@ -0,0 +1,265 @@
+/**
+ * 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';
+export async function runInteractiveRepl(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    newline();
+    console.log(colors.bold('codehere ') + colors.dim('v' + getVersion()));
+    console.log(colors.dim('Talk to your AI coding agents. Type a task; codehere routes to the right specialist.'));
+    newline();
+    console.log(colors.dim('  /agents       list installed specialists + routing rules'));
+    console.log(colors.dim('  /status       recent activity from the audit log'));
+    console.log(colors.dim('  /web          open the web UI at http://127.0.0.1:3773'));
+    console.log(colors.dim('  /quit         exit  (or Ctrl+C / Ctrl+D)'));
+    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,
+    });
+    const manager = SessionManager.getInstance();
+    const prompt = () => {
+        rl.setPrompt(colors.cyan('› '));
+        rl.prompt();
+    };
+    rl.on('close', () => {
+        newline();
+        console.log(colors.dim('Goodbye.'));
+        process.exit(0);
+    });
+    rl.on('SIGINT', () => {
+        // Ctrl+C: if we're idle at the prompt, exit; if a task is mid-flight the
+        // task's own kill hook handles it via session.kill() (TODO: wire up).
+        rl.close();
+    });
+    prompt();
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            prompt();
+            continue;
+        }
+        if (trimmed === '/quit' || trimmed === '/exit') {
+            rl.close();
+            return;
+        }
+        if (trimmed === '/agents') {
+            printAgentsAndRoutingRules();
+            prompt();
+            continue;
+        }
+        if (trimmed === '/status') {
+            await printStatusSummary();
+            prompt();
+            continue;
+        }
+        if (trimmed === '/web' || trimmed === '/start') {
+            console.log(colors.dim('  Tip: run ') + colors.cyan('codehere start') + colors.dim(' in another terminal to launch the web UI.'));
+            prompt();
+            continue;
+        }
+        if (trimmed.startsWith('/')) {
+            console.log(colors.yellow(`  Unknown REPL command: ${trimmed}`));
+            console.log(colors.dim('  Try /agents, /status, /web, or /quit.'));
+            prompt();
+            continue;
+        }
+        // Plain text → delegate via Conductor
+        if (installed.length === 0) {
+            console.log(colors.yellow('  No specialist installed — install one and try again.'));
+            prompt();
+            continue;
+        }
+        try {
+            await runTask(trimmed, cwd, manager);
+        }
+        catch (err) {
+            console.log(colors.red('  ✗ ') + (err instanceof Error ? err.message : String(err)));
+        }
+        newline();
+        prompt();
+    }
+}
+/**
+ * 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehere",
-  "version": "0.3.0-rc.5",
+  "version": "0.3.0-rc.7",
   "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",