codehere 0.6.0-alpha.1 → 0.6.0

package/dist/index.js

@@ -480,10 +480,12 @@ program
     .option('-p, --port <number>', 'Port to listen on', '3773')
     .option('--host <host>', 'Host to bind to', '127.0.0.1')
     .option('--no-open', "Don't auto-open the browser")
+    .option('--cloud', 'Enable cloud sync — push session state to codehere.uk/app for remote monitoring')
     .action(async (options) => {
     const port = parseInt(options?.port ?? '3773', 10);
     const host = options?.host ?? '127.0.0.1';
     const shouldOpen = options?.open !== false;
+    const cloud = options?.cloud === true;
     const url = `http://${host}:${port}/`;
     const openBrowser = async () => {
         if (!shouldOpen)
@@ -551,11 +553,23 @@ program
         console.log(colors.bold('Tasks:') + '    ' + url);
         console.log(colors.bold('History:') + '  ' + `http://${host}:${port}/history`);
         console.log(colors.bold('MCP:') + '      ' + `http://${host}:${port}/mcp`);
+        if (cloud) {
+            console.log(colors.bold('Cloud:') + '     ' + 'https://codehere.uk/app');
+        }
         newline();
         console.log(colors.dim('  Press Ctrl+C to stop'));
         newline();
+        // Start cloud sync if enabled
+        if (cloud) {
+            const { startCloudSync } = await import('./infrastructure/protocols/cloud-sync.js');
+            startCloudSync();
+        }
         await openBrowser();
         process.on('SIGINT', () => {
+            if (cloud) {
+                const { stopCloudSync } = require('./infrastructure/protocols/cloud-sync.js');
+                stopCloudSync();
+            }
             server.close();
             console.log(colors.dim('\ncodehere stopped'));
             process.exit(0);

package/dist/infrastructure/orchestration/context-handoff.js

@@ -0,0 +1,143 @@
+/**
+ * context-handoff — structured cross-session context handoff protocol (P2).
+ *
+ * Bridges P0's auto-failover trigger with P1's graphify-ts context packs.
+ * When a session fails over (or a new session spawns), the handoff loader
+ * finds the most relevant context pack from recent session logs and injects
+ * it as a system hint so the replacement agent inherits continuity.
+ *
+ * Protocol:
+ *   1. loadHandoffContext(cwd, { fromSessionId?, sessionId?, maxAgeMs? })
+ *      — scans .codehere/context-packs.jsonl for the most relevant pack
+ *   2. enrichPromptWithHandoff(prompt, cwd, handoff)
+ *      — merges the handoff context into a prompt string
+ *   3. session handoff is automatic during failover (wired in session-manager)
+ *
+ * Handoff format (injected as system hint):
+ *   [handoff: previous agent=<agent>, completed=<status>, pack=<packId>]
+ *   Previous work summary: <pack.payloadPreview or compiled summary>
+ *   ---
+ *   <original prompt>
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+// ── Constants ──────────────────────────────────────────────────────────────────
+const CONTEXT_PACKS_DIR = '.codehere';
+const CONTEXT_PACKS_FILE = 'context-packs.jsonl';
+const DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
+const DEFAULT_MIN_NODES = 5;
+// ── Session log scanning ───────────────────────────────────────────────────────
+/**
+ * Load all recent context packs from disk, sorted by timestamp (newest first).
+ */
+function loadAllPacks(cwd) {
+    const packsFile = join(cwd, CONTEXT_PACKS_DIR, CONTEXT_PACKS_FILE);
+    if (!existsSync(packsFile)) {
+        return [];
+    }
+    try {
+        const content = readFileSync(packsFile, 'utf-8');
+        const lines = content.split('\n').filter(Boolean);
+        return lines.map((line) => JSON.parse(line)).reverse();
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Find the most relevant handoff context from previous sessions.
+ *
+ * Priority:
+ *   1. Same workspace, same prompt keywords (most recent pack)
+ *   2. Same workspace, any pack (most recent)
+ *   3. Fallback: no handoff
+ */
+export function loadHandoffContext(cwd, { fromSessionId, maxAgeMs = DEFAULT_MAX_AGE_MS, minNodes = DEFAULT_MIN_NODES } = {}) {
+    const now = Date.now();
+    const packs = loadAllPacks(cwd);
+    // Filter by age
+    const recent = packs.filter((p) => {
+        const ts = p.timestamp;
+        return ts && (now - ts) < maxAgeMs;
+    });
+    // Prefer packs with enough graph structure to be useful
+    const structured = recent.filter((p) => {
+        const nodes = p.nodeCount ?? 0;
+        return nodes >= minNodes;
+    });
+    if (structured.length === 0)
+        return null;
+    const last = structured[0];
+    return {
+        packId: String(last.packId ?? ''),
+        agent: String(last.agent ?? 'unknown'),
+        prompt: String(last.prompt ?? ''),
+        status: String(last.status ?? 'unknown'),
+        timestamp: last.timestamp,
+        nodeCount: last.nodeCount,
+        edgeCount: last.edgeCount,
+        task: String(last.task ?? 'explain'),
+        payloadPreview: String(last.payloadPreview ?? ''),
+    };
+}
+// ── Prompt enrichment ──────────────────────────────────────────────────────────
+/**
+ * Inject handoff context into a prompt.
+ *
+ * Returns the enriched prompt string with the handoff as a system hint
+ * prepended before the original prompt. Returns the original prompt
+ * if no handoff is available.
+ */
+export function enrichPromptWithHandoff(prompt, handoff) {
+    if (!handoff)
+        return prompt;
+    const handoffLine = `[handoff: agent=${handoff.agent}, pack=${handoff.packId}, ${handoff.nodeCount} nodes, ${handoff.edgeCount} edges]`;
+    const preview = handoff.payloadPreview ? ` ${handoff.payloadPreview.slice(0, 800)}` : '';
+    return [
+        `[Previous session context — ${handoffLine}]`,
+        `This workspace has recent structural context from a prior session.`,
+        `For details, refer to the knowledge graph at the workspace root.`,
+        `---`,
+        prompt,
+    ].join('\n');
+}
+// ── Failover handoff (P2 integration point) ────────────────────────────────────
+/**
+ * Build a handoff context for a failover target.
+ *
+ * When session A fails and session B auto-spawns as replacement,
+ * this loads the most recent pack from the same workspace and
+ * merges it into the prompt so B has continuity with A's work.
+ */
+export function buildFailoverHandoff(cwd, { failedAgent, failedPrompt }) {
+    // Load most recent pack from workspace
+    const pack = loadHandoffContext(cwd, { maxAgeMs: DEFAULT_MAX_AGE_MS, minNodes: 3 });
+    if (!pack)
+        return null;
+    // Enrich the prompt with the handoff
+    const enrichedPrompt = enrichPromptWithHandoff(failedPrompt, {
+        ...pack,
+        agent: failedAgent,
+        status: 'failed',
+    });
+    return {
+        ...pack,
+        agent: failedAgent,
+        prompt: enrichedPrompt,
+        status: 'failed',
+    };
+}
+// ── Handoff summary (for UI / API) ─────────────────────────────────────────────
+/**
+ * Generate a human-readable handoff summary for the dashboard.
+ */
+export function formatHandoffSummary(handoff) {
+    const ageMs = Date.now() - handoff.timestamp;
+    const ageStr = ageMs < 60_000
+        ? `${Math.round(ageMs / 1000)}s ago`
+        : ageMs < 3600_000
+            ? `${Math.round(ageMs / 60_000)}m ago`
+            : `${Math.round(ageMs / 3600_000)}h ago`;
+    return `Previous session (${handoff.agent}) completed ${ageStr}. ${handoff.nodeCount} nodes, ${handoff.edgeCount} edges in workspace graph.`;
+}
+//# sourceMappingURL=context-handoff.js.map

package/dist/infrastructure/orchestration/failover-config.js

@@ -0,0 +1,77 @@
+/**
+ * Failover config loader — v0.6.x rate-limit fail-over wedge (Slice C).
+ *
+ * Reads `failoverChain` from `~/.codehere/config.json` and validates it
+ * against the known agent ids. Returns the validated chain or undefined
+ * if the user has not configured one (caller falls back to the default).
+ *
+ * Config shape (~/.codehere/config.json):
+ *   {
+ *     "version": "0.6.0",
+ *     "failover": {
+ *       "chain": ["codex", "claude-code", "aider"]
+ *     }
+ *   }
+ *
+ * If `failover.chain` is missing, empty, or invalid, returns undefined
+ * so the caller uses DEFAULT_FAILOVER_CHAIN from failover-policy.ts.
+ *
+ * Slice C scope: config read + validation. Slice D wires it into
+ * SessionManager so the resolved chain flows into the resolver.
+ */
+import { readFileSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { validateFailoverChain } from './failover-policy.js';
+const GLOBAL_CONFIG_PATH = join(homedir(), '.codehere', 'config.json');
+/**
+ * Load failover configuration from ~/.codehere/config.json.
+ * Returns undefined if the config file does not exist or has no failover section.
+ *
+ * Safe to call at any time — no side effects, no caching, no I/O errors
+ * propagated (returns undefined on any read failure).
+ */
+export function loadFailoverConfig() {
+    if (!existsSync(GLOBAL_CONFIG_PATH))
+        return undefined;
+    try {
+        const raw = JSON.parse(readFileSync(GLOBAL_CONFIG_PATH, 'utf-8'));
+        if (!raw || typeof raw !== 'object')
+            return undefined;
+        const failover = raw.failover;
+        if (!failover || typeof failover !== 'object')
+            return undefined;
+        const config = {};
+        // Validate chain if present
+        if (Array.isArray(failover.chain)) {
+            try {
+                config.chain = validateFailoverChain(failover.chain);
+            }
+            catch {
+                // Invalid chain — skip it, caller uses default
+                config.chain = undefined;
+            }
+        }
+        // autoFailover — boolean, defaults to false
+        if (typeof failover.autoFailover === 'boolean') {
+            config.autoFailover = failover.autoFailover;
+        }
+        return config;
+    }
+    catch {
+        // Config file exists but is malformed — return undefined so caller
+        // falls back to defaults without crashing.
+        return undefined;
+    }
+}
+/**
+ * Get the resolved failover chain: user-configured if present, else default.
+ * Pure function — no I/O. Caller loads config and passes it in.
+ */
+export function resolveChain(userChain) {
+    if (userChain && userChain.length > 0)
+        return userChain;
+    // Re-export the default from failover-policy
+    return ['claude-code', 'codex', 'aider', 'opencode', 'gemini'];
+}
+//# sourceMappingURL=failover-config.js.map

package/dist/infrastructure/orchestration/graphify-context.js

@@ -0,0 +1,256 @@
+/**
+ * graphify-context — shared structural memory layer (P1).
+ *
+ * Wraps `graphify-ts` CLI to compile compact context packs for agent prompts.
+ * Every spawn can optionally get a graphify context pack that replaces
+ * raw file reads + unstructured JSONL scans.
+ *
+ * All functions are synchronous (execFileSync) to slot into the sync
+ * spawn() call chain without breaking the API.
+ *
+ * P1 integration points:
+ *   - Session spawn: inject context pack into prompt prefix
+ *   - Failover handoff (P2): replacement agent inherits the same pack
+ *   - S7 compaction (future): use graph to prune stale session logs
+ *   - PM-brain routing (future): community_overview for agent selection
+ */
+import { execFileSync } from 'child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+// ── Constants ──────────────────────────────────────────────────────────────────
+const GRAPHIFY_OUT = 'graphify-out';
+const GRAPH_JSON = 'graph.json';
+const CONTEXT_PACKS_DIR = '.codehere';
+const CONTEXT_PACKS_FILE = 'context-packs.jsonl';
+// ── Helpers ────────────────────────────────────────────────────────────────────
+function getGraphPath(cwd) {
+    return join(cwd, GRAPHIFY_OUT, GRAPH_JSON);
+}
+function getGraphStats(cwd) {
+    const graphPath = getGraphPath(cwd);
+    try {
+        if (!existsSync(graphPath)) {
+            return { nodeCount: 0, edgeCount: 0 };
+        }
+        const graphJson = JSON.parse(readFileSync(graphPath, 'utf-8'));
+        return {
+            nodeCount: graphJson.nodes?.length ?? 0,
+            edgeCount: graphJson.edges?.length ?? 0,
+        };
+    }
+    catch {
+        return { nodeCount: 0, edgeCount: 0 };
+    }
+}
+// ── Graph management (sync) ────────────────────────────────────────────────────
+/**
+ * Build or update the knowledge graph for a workspace directory.
+ * Writes to <cwd>/graphify-out/graph.json (graphify-ts default).
+ * Synchronous — runs synchronously so it can be called from spawn().
+ */
+export function buildGraphSync(cwd, { incremental = true } = {}) {
+    const startTime = Date.now();
+    const graphPath = getGraphPath(cwd);
+    const args = ['generate', cwd];
+    if (incremental && existsSync(graphPath)) {
+        args.push('--update');
+    }
+    try {
+        execFileSync('npx', ['graphify-ts', ...args], {
+            cwd,
+            stdio: 'ignore',
+            timeout: 120_000,
+        });
+    }
+    catch {
+        // Non-zero exit is fine — graphify-ts returns 1 when no files changed.
+        // Also swallow ENOENT (graphify-ts not installed) — degrade gracefully.
+    }
+    return { elapsedMs: Date.now() - startTime };
+}
+// ── Context pack compilation (sync) ────────────────────────────────────────────
+/**
+ * Compile a compact context pack for a prompt + workspace.
+ * Synchronous — calls graphify-ts pack and returns the payload.
+ */
+export function compileContextPackSync(prompt, cwd, { task = 'explain', budget = 3000, } = {}) {
+    const startTime = Date.now();
+    const graphPath = getGraphPath(cwd);
+    // Build graph if it doesn't exist yet
+    if (!existsSync(graphPath)) {
+        buildGraphSync(cwd, { incremental: false });
+    }
+    // Degrade gracefully if graph still doesn't exist
+    if (!existsSync(graphPath)) {
+        return null;
+    }
+    try {
+        const output = execFileSync('npx', [
+            'graphify-ts', 'pack', prompt,
+            '--graph', graphPath,
+            '--task', task,
+            '--budget', String(budget),
+        ], {
+            cwd,
+            encoding: 'utf-8',
+            maxBuffer: 512 * 1024,
+            timeout: 30_000,
+        });
+        const { nodeCount, edgeCount } = getGraphStats(cwd);
+        return {
+            graphPath,
+            payload: output.trim(),
+            budget,
+            task,
+            nodeCount,
+            edgeCount,
+            elapsedMs: Date.now() - startTime,
+            packId: randomUUID(),
+        };
+    }
+    catch {
+        // graphify-ts may return non-zero or hit timeout — degrade gracefully.
+        return null;
+    }
+}
+/**
+ * Compile a context pack from a session's final state (prompt + artifacts + steps).
+ * Used for P1 session-exit persistence and P2 handoff enrichment.
+ */
+export function compileSessionPackSync(cwd, { prompt, artifacts, steps, agent }) {
+    // Combine prompt + artifacts + steps into a rich prompt for the pack
+    const sessionContext = [
+        prompt,
+        agent ? `Agent: ${agent}` : undefined,
+        artifacts ? `Artifacts:\n${artifacts}` : undefined,
+        steps ? `Steps taken:\n${steps}` : undefined,
+    ].filter(Boolean).join('\n\n');
+    return compileContextPackSync(sessionContext, cwd, { task: 'impact', budget: 2500 });
+}
+// ── Context pack persistence ───────────────────────────────────────────────────
+/**
+ * Persist a context pack to disk for cross-session handoff (P2).
+ * Returns the path to the packs file.
+ */
+export function persistContextPack(pack, cwd) {
+    const packsDir = join(cwd, CONTEXT_PACKS_DIR);
+    if (!existsSync(packsDir)) {
+        mkdirSync(packsDir, { recursive: true });
+    }
+    const packsFile = join(packsDir, CONTEXT_PACKS_FILE);
+    const entry = {
+        packId: pack.packId,
+        timestamp: Date.now(),
+        task: pack.task,
+        nodeCount: pack.nodeCount,
+        edgeCount: pack.edgeCount,
+        graphPath: pack.graphPath,
+        payloadPreview: pack.payload.slice(0, 500), // truncate for log
+        payloadLength: pack.payload.length,
+    };
+    writeFileSync(packsFile, JSON.stringify(entry) + '\n', { flag: 'a' });
+    return packsFile;
+}
+/**
+ * Load the most recent context pack from disk (for P2 handoff).
+ */
+export function loadRecentContextPack(cwd) {
+    const packsFile = join(cwd, CONTEXT_PACKS_DIR, CONTEXT_PACKS_FILE);
+    if (!existsSync(packsFile)) {
+        return null;
+    }
+    try {
+        const lines = readFileSync(packsFile, 'utf-8').split('\n').filter(Boolean);
+        if (lines.length === 0)
+            return null;
+        const lastEntry = JSON.parse(lines[lines.length - 1]);
+        return {
+            packId: lastEntry.packId,
+            graphPath: lastEntry.graphPath,
+            payload: '', // payload is truncated in disk storage
+            budget: 3000,
+            task: lastEntry.task,
+            nodeCount: lastEntry.nodeCount,
+            edgeCount: lastEntry.edgeCount,
+            elapsedMs: 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ── Prompt enrichment (sync) ───────────────────────────────────────────────────
+/**
+ * Prepend a context pack to a prompt if graphify-ts is available.
+ *
+ * Synchronous — can be called directly from spawn().
+ * Returns the original prompt if graphify-ts fails or is unavailable.
+ *
+ * Respects CODEHERE_GRAPHIFY env var:
+ *   - unset or "auto" (default): compile on spawn if graph doesn't exist
+ *   - "force": always compile, even if pack exists
+ *   - "off": skip entirely
+ */
+export function enrichPromptWithPackSync(prompt, cwd, { force = false } = {}) {
+    const mode = process.env.CODEHERE_GRAPHIFY ?? 'auto';
+    if (mode === 'off')
+        return prompt;
+    // Check for existing pack to avoid recompiling on every spawn
+    const existingPack = loadRecentContextPack(cwd);
+    const graphPath = getGraphPath(cwd);
+    const graphExists = existsSync(graphPath);
+    if (!force && existingPack && graphExists) {
+        // Reuse existing pack — just enrich the prompt with a compact reference
+        const reference = `[graphify-ts context pack: ${existingPack.nodeCount} nodes, ${existingPack.edgeCount} edges, pack=${existingPack.packId}]`;
+        return `[graphify context: ${reference} — agent should call retrieve() for full pack]\n\n${prompt}`;
+    }
+    // Compile a fresh pack
+    const pack = compileContextPackSync(prompt, cwd, { task: 'explain', budget: 2500 });
+    if (!pack) {
+        return prompt;
+    }
+    // Persist for P2 handoff
+    persistContextPack(pack, cwd);
+    // Prepend context pack as a system hint so the agent sees it first
+    return [
+        `[graphify-ts context pack — ${pack.nodeCount} nodes, ${pack.edgeCount} edges, ${pack.elapsedMs}ms]`,
+        pack.payload,
+        '---',
+        prompt,
+    ].join('\n\n');
+}
+// ── Graph querying (sync) ──────────────────────────────────────────────────────
+/**
+ * Query the knowledge graph for a question.
+ * Useful for PM-brain routing and structured context handoff (P2).
+ */
+export function queryGraphSync(question, cwd, { maxTokens = 2000 } = {}) {
+    const startTime = Date.now();
+    const graphPath = getGraphPath(cwd);
+    if (!existsSync(graphPath)) {
+        return null;
+    }
+    try {
+        const output = execFileSync('npx', [
+            'graphify-ts', 'query', question,
+            '--graph', graphPath,
+            '--budget', String(maxTokens),
+        ], {
+            cwd,
+            encoding: 'utf-8',
+            maxBuffer: 256 * 1024,
+            timeout: 15_000,
+        });
+        return {
+            question,
+            answer: output.trim(),
+            elapsedMs: Date.now() - startTime,
+            graphPath,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=graphify-context.js.map