codehere 0.6.0-alpha.1 → 0.6.1

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

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

@@ -19,6 +19,7 @@ import { join } from 'path';
 import { promisify } from 'util';
 import { ProgressAggregator } from './progress-aggregator.js';
 import { applyMemoryPrefix } from './memory-injector.js';
+import { mirrorToolCallToAudit } from '../hooks/mirror-tool-call-to-audit.js';
 import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
 const execFileAsync = promisify(execFile);
 const HEADLESS_FLAGS = ['run', '--format', 'json'];
@@ -142,6 +143,46 @@ export function spawnOpenCode(prompt, options = {}) {
             if (txt)
                 textAccum += txt + '\n';
         }
+        // #114 — cross-vendor audit mirror for opencode (closes the gap left by
+        // #110 slice 4, which wired Codex/Aider/Gemini but deferred opencode).
+        // OpenCode's `run --format json` emits `tool_use` events with shape
+        // { type: 'tool_use', part: { tool: 'bash'|'read'|'write'|..., state:
+        // { input: {...}, output, status, ... } } } (verified via deepwiki +
+        // takopi cheatsheet). Same post-hoc visibility surface as Codex/Aider/
+        // Gemini — no synchronous block until upstream pre-tool hooks land.
+        if (event.type === 'tool_use') {
+            const part = event.data?.part;
+            const rawTool = String(part?.tool ?? 'tool').toLowerCase();
+            // Normalize to Claude-cased tool names so /history filter chips group
+            // cross-vendor (a bash call from claude-code and opencode show under
+            // the same "Bash" filter chip).
+            const toolNameMap = {
+                bash: 'Bash',
+                read: 'Read',
+                write: 'Write',
+                edit: 'Edit',
+                grep: 'Grep',
+                glob: 'Glob',
+                webfetch: 'WebFetch',
+                websearch: 'WebSearch',
+                task: 'Task',
+            };
+            const toolName = toolNameMap[rawTool] ?? rawTool;
+            const input = part?.state?.input ?? {};
+            const inputStr = (typeof input.command === 'string' && input.command) ||
+                (typeof input.file_path === 'string' && input.file_path) ||
+                (typeof input.path === 'string' && input.path) ||
+                (typeof input.pattern === 'string' && input.pattern) ||
+                (typeof input.query === 'string' && input.query) ||
+                JSON.stringify(input).slice(0, 500);
+            mirrorToolCallToAudit({
+                sessionId,
+                agent: 'opencode',
+                toolName,
+                toolInput: String(inputStr),
+                cwd,
+            });
+        }
         if (!errorEmitted) {
             const data = event.data;
             let text = '';