opencode-autognosis 2.0.1 → 2.0.4

package/dist/index.js

@@ -1,20 +1,8 @@
-import { systemTools } from "./system-tools.js";
-import { gitWorktreeTools } from "./git-worktree.js";
-import { testingTools } from "./testing-infrastructure.js";
-import { chunkCardsTools } from "./chunk-cards.js";
-import { activeSetTools } from "./activeset.js";
-import { moduleSummariesTools } from "./module-summaries.js";
-import { performanceTools } from "./performance-optimization.js";
+import { unifiedTools } from "./unified-api.js";
 export const AutognosisPlugin = async () => {
     return {
         tool: {
-            ...systemTools(),
-            ...gitWorktreeTools(),
-            ...testingTools(),
-            ...chunkCardsTools(),
-            ...activeSetTools(),
-            ...moduleSummariesTools(),
-            ...performanceTools(),
+            ...unifiedTools(),
         },
     };
 };

package/dist/module-summaries.js

@@ -3,13 +3,14 @@ import * as fs from "node:fs/promises";
 import * as fsSync from "node:fs";
 import * as path from "node:path";
 import * as crypto from "node:crypto";
+import { Logger } from "./services/logger.js";
 const PROJECT_ROOT = process.cwd();
 const OPENCODE_DIR = path.join(PROJECT_ROOT, ".opencode");
 const CHUNK_DIR = path.join(OPENCODE_DIR, "chunks");
 const MODULE_DIR = path.join(OPENCODE_DIR, "modules");
 // Internal logging
 function log(message, data) {
-    console.error(`[ModuleSummaries] ${message}`, data || '');
+    Logger.log("ModuleSummaries", message, data);
 }
 // =============================================================================
 // HELPERS

package/dist/performance-optimization.js

@@ -5,7 +5,9 @@ import * as fsSync from "node:fs";
 import * as path from "node:path";
 import { promisify } from "node:util";
 import * as crypto from "node:crypto";
+import { getDb } from "./database.js";
 import { CHUNK_DIR, ensureChunkDir, calculateHash, calculateComplexity, parseFileAST, generateSummaryChunk, generateApiChunk, generateInvariantChunk, extractDependencies, extractSymbolsFromAST, extractSymbols } from "./chunk-cards.js";
+import { Logger } from "./services/logger.js";
 const execAsync = promisify(exec);
 const PROJECT_ROOT = process.cwd();
 const OPENCODE_DIR = path.join(PROJECT_ROOT, ".opencode");
@@ -14,7 +16,7 @@ const PERF_DIR = path.join(OPENCODE_DIR, "performance");
 const METRICS_DIR = path.join(OPENCODE_DIR, "metrics");
 // Internal logging
 function log(message, data) {
-    console.error(`[Performance] ${message}`, data || '');
+    Logger.log("Performance", message, data);
 }
 // =============================================================================
 // HELPERS
@@ -431,29 +433,40 @@ export function performanceTools() {
             description: "Check status of background tasks and operations.",
             args: {
                 task_id: tool.schema.string().optional().describe("Specific task ID to check"),
-                task_type: tool.schema.enum(["indexing", "caching", "cleanup", "analysis"]).optional().describe("Filter by task type")
+                task_type: tool.schema.enum(["indexing", "caching", "cleanup", "analysis", "validation", "setup"]).optional().describe("Filter by task type")
             },
             async execute({ task_id, task_type }) {
                 log("Tool call: perf_background_status", { task_id, task_type });
                 try {
+                    const tasks = [];
+                    // 1. Check DB Jobs
+                    if (task_id) {
+                        const job = getDb().getJob(task_id);
+                        if (job)
+                            tasks.push(job);
+                    }
+                    else {
+                        const dbJobs = getDb().listJobs(task_type, 10);
+                        tasks.push(...dbJobs);
+                    }
+                    // 2. Check File-based tasks
                     await ensurePerfDirs();
                     const files = await fs.readdir(PERF_DIR);
-                    const tasks = [];
                     for (const file of files) {
                         if (file.startsWith('task-') && file.endsWith('.json')) {
                             try {
                                 const taskPath = path.join(PERF_DIR, file);
                                 const task = JSON.parse(await fs.readFile(taskPath, 'utf-8'));
-                                // Apply filters
                                 if (task_id && task.id !== task_id)
                                     continue;
                                 if (task_type && task.type !== task_type)
                                     continue;
-                                tasks.push(task);
-                            }
-                            catch (error) {
-                                // Skip corrupted files
+                                // Avoid duplication if already in DB (shouldn't happen with new ID scheme)
+                                if (!tasks.some(t => t.id === task.id)) {
+                                    tasks.push(task);
+                                }
                             }
+                            catch (error) { }
                         }
                     }
                     return JSON.stringify({
@@ -626,6 +639,8 @@ async function indexFile(filePath) {
                 }
             };
             await fs.writeFile(cardPath, JSON.stringify(chunkCard, null, 2));
+            // Sync to SQLite Index
+            getDb().ingestChunkCard(chunkCard);
         }
     }
     catch (error) {
@@ -719,7 +734,7 @@ async function runBackgroundIndexing(taskId, indexingState) {
             }
         }
         catch (writeError) {
-            console.error("Failed to update task error state", writeError);
+            log("Failed to update task error state", writeError);
         }
     }
 }

package/dist/services/logger.d.ts

@@ -1 +1,4 @@
-export declare function log(message: string, data?: unknown): void;
+export declare class Logger {
+    private static formatMessage;
+    static log(module: string, message: string, data?: unknown): void;
+}

package/dist/services/logger.js

@@ -1,17 +1,40 @@
-import { appendFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-const LOG_FILE = join(homedir(), ".opencode-autognosis.log");
-// Start a fresh session block
-writeFileSync(LOG_FILE, `
---- Autognosis Session started: ${new Date().toISOString()} ---
-`, { flag: "a" });
-export function log(message, data) {
-    const timestamp = new Date().toISOString();
-    const line = data
-        ? `[${timestamp}] ${message}: ${JSON.stringify(data)}
-`
-        : `[${timestamp}] ${message}
-`;
-    appendFileSync(LOG_FILE, line);
+import * as fs from "node:fs";
+import * as path from "node:path";
+const PROJECT_ROOT = process.cwd();
+const LOG_DIR = path.join(PROJECT_ROOT, ".opencode", "logs");
+const LOG_FILE = path.join(LOG_DIR, "autognosis.log");
+// Ensure log directory exists
+try {
+    if (!fs.existsSync(LOG_DIR)) {
+        fs.mkdirSync(LOG_DIR, { recursive: true });
+    }
+}
+catch (e) {
+    // Ignore error if we can't create directory (e.g. read-only fs)
+}
+export class Logger {
+    static formatMessage(module, message, data) {
+        const timestamp = new Date().toISOString();
+        let dataStr = "";
+        if (data) {
+            try {
+                dataStr = typeof data === "string" ? data : JSON.stringify(data);
+            }
+            catch {
+                dataStr = "[Circular/Unserializable]";
+            }
+        }
+        return `[${timestamp}] [${module}] ${message} ${dataStr}\n`;
+    }
+    static log(module, message, data) {
+        const line = this.formatMessage(module, message, data);
+        try {
+            // Append to log file synchronously to ensure write
+            fs.appendFileSync(LOG_FILE, line);
+        }
+        catch (e) {
+            // Fallback: strictly avoid console.log/error to prevent TUI breakage.
+            // We essentially swallow the log if file write fails.
+        }
+    }
 }

package/dist/services/ollama.d.ts

@@ -0,0 +1,11 @@
+export declare const DEFAULT_EMBEDDING_MODEL = "nomic-embed-text";
+export declare const OLLAMA_BASE_URL = "http://127.0.0.1:11434";
+export declare class OllamaService {
+    isInstalled(): Promise<boolean>;
+    isRunning(): Promise<boolean>;
+    install(): Promise<string>;
+    startServer(): Promise<void>;
+    pullModel(model?: string): Promise<void>;
+    getEmbedding(text: string, model?: string): Promise<number[]>;
+}
+export declare const ollama: OllamaService;

package/dist/services/ollama.js

@@ -0,0 +1,132 @@
+import { exec, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Logger } from "./logger.js";
+const execAsync = promisify(exec);
+export const DEFAULT_EMBEDDING_MODEL = "nomic-embed-text";
+export const OLLAMA_BASE_URL = "http://127.0.0.1:11434";
+export class OllamaService {
+    async isInstalled() {
+        try {
+            await execAsync("which ollama");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async isRunning() {
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 1000);
+            const res = await fetch(`${OLLAMA_BASE_URL}/api/version`, { signal: controller.signal });
+            clearTimeout(timeoutId);
+            return res.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    async install() {
+        const platform = process.platform;
+        try {
+            if (platform === "darwin") {
+                // Try Homebrew first
+                try {
+                    await execAsync("which brew");
+                    await execAsync("brew install ollama");
+                    return "Installed via Homebrew";
+                }
+                catch {
+                    // Fallback to script
+                    await execAsync("curl -fsSL https://ollama.com/install.sh | sh");
+                    return "Installed via official script";
+                }
+            }
+            else if (platform === "linux") {
+                await execAsync("curl -fsSL https://ollama.com/install.sh | sh");
+                return "Installed via official script";
+            }
+            else {
+                throw new Error("Automatic installation only supported on macOS and Linux. Please install Ollama manually.");
+            }
+        }
+        catch (error) {
+            throw new Error(`Installation failed: ${error.message}`);
+        }
+    }
+    async startServer() {
+        if (await this.isRunning())
+            return;
+        // Start in background
+        const logFile = fs.openSync(path.join(process.cwd(), ".opencode", "ollama.log"), "a");
+        const child = spawn("ollama", ["serve"], {
+            detached: true,
+            stdio: ["ignore", logFile, logFile]
+        });
+        child.unref();
+        // Wait for it to come up
+        let attempts = 0;
+        while (attempts < 10) {
+            await new Promise(r => setTimeout(r, 1000));
+            if (await this.isRunning())
+                return;
+            attempts++;
+        }
+        throw new Error("Ollama server failed to start within 10 seconds");
+    }
+    async pullModel(model = DEFAULT_EMBEDDING_MODEL) {
+        // Check if exists
+        try {
+            const res = await fetch(`${OLLAMA_BASE_URL}/api/tags`);
+            const data = await res.json();
+            const models = data.models || [];
+            if (models.some((m) => m.name.includes(model))) {
+                return; // Already exists
+            }
+        }
+        catch { }
+        // Pull model (this blocks, usually handled via CLI)
+        // We'll use the API to pull so we can await it
+        const res = await fetch(`${OLLAMA_BASE_URL}/api/pull`, {
+            method: "POST",
+            body: JSON.stringify({ name: model }),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to pull model ${model}`);
+        // Read stream to completion to ensure it's done
+        const reader = res.body?.getReader();
+        if (reader) {
+            while (true) {
+                const { done } = await reader.read();
+                if (done)
+                    break;
+            }
+        }
+    }
+    async getEmbedding(text, model = DEFAULT_EMBEDDING_MODEL) {
+        if (!text || !text.trim())
+            return [];
+        try {
+            const res = await fetch(`${OLLAMA_BASE_URL}/api/embeddings`, {
+                method: "POST",
+                body: JSON.stringify({
+                    model,
+                    prompt: text
+                })
+            });
+            if (!res.ok) {
+                const errText = await res.text();
+                throw new Error(`Ollama API error: ${res.status} ${errText}`);
+            }
+            const data = await res.json();
+            return data.embedding;
+        }
+        catch (error) {
+            Logger.log("Ollama", "Embedding failed", error);
+            return [];
+        }
+    }
+}
+export const ollama = new OllamaService();

package/dist/system-tools.js

@@ -5,14 +5,15 @@ import * as fsSync from "node:fs";
 import * as path from "node:path";
 import { promisify } from "node:util";
 import * as crypto from "node:crypto";
+import { Logger } from "./services/logger.js";
+import { getDb } from "./database.js";
 const execAsync = promisify(exec);
 const PROJECT_ROOT = process.cwd();
 const OPENCODE_DIR = path.join(PROJECT_ROOT, ".opencode");
 const CACHE_DIR = path.join(OPENCODE_DIR, "cache");
 // Internal logging
 function log(message, data) {
-    // console.error is used here for internal debugging as standard console.log may interfere with tool outputs
-    console.error(`[Autognosis] ${message}`, data || '');
+    Logger.log("Autognosis", message, data);
 }
 // =============================================================================
 // HELPERS
@@ -94,7 +95,10 @@ async function maintainSymbolIndex() {
 // TOOLS
 // =============================================================================
 export function systemTools() {
-    let pendingInitToken = null; // State for init token
+    let pendingInitToken = null;
+    const record = (planId, tool, args) => {
+        getDb().recordExecution(planId, tool, args, !!planId);
+    };
     return {
         autognosis_init: tool({
             description: "Initialize or check the Autognosis environment. Two-phase: 'plan' (default) generates a token, 'apply' executes it.",
@@ -104,6 +108,7 @@ export function systemTools() {
             },
             async execute({ mode, token }) {
                 log("Tool call: autognosis_init", { mode });
+                record(undefined, "autognosis_init", { mode });
                 if (mode === "plan") {
                     const checks = {
                         rg: await checkBinary("rg"),
@@ -139,10 +144,12 @@ export function systemTools() {
             args: {
                 query: tool.schema.string(),
                 mode: tool.schema.enum(["filename", "content"]).optional().default("filename"),
-                path: tool.schema.string().optional().default(".")
+                path: tool.schema.string().optional().default("."),
+                plan_id: tool.schema.string().optional().describe("Associated Plan ID")
             },
-            async execute({ query, mode, path: searchPath }) {
-                log("Tool call: fast_search", { query, mode, searchPath });
+            async execute({ query, mode, path: searchPath, plan_id }) {
+                log("Tool call: fast_search", { query, mode, searchPath, plan_id });
+                record(plan_id, "fast_search", { query, mode, searchPath });
                 if (mode === "content") {
                     if (!(await checkBinary("rg")))
                         return "Error: 'rg' not installed.";
@@ -166,10 +173,12 @@ export function systemTools() {
             args: {
                 file: tool.schema.string(),
                 start_line: tool.schema.number(),
-                end_line: tool.schema.number()
+                end_line: tool.schema.number(),
+                plan_id: tool.schema.string().optional().describe("Associated Plan ID")
             },
-            async execute({ file, start_line, end_line }) {
-                log("Tool call: read_slice", { file, start_line, end_line });
+            async execute({ file, start_line, end_line, plan_id }) {
+                log("Tool call: read_slice", { file, start_line, end_line, plan_id });
+                record(plan_id, "read_slice", { file, start_line, end_line });
                 const { stdout, stderr } = await runCmd(`sed -n '${start_line},${end_line}p;${end_line + 1}q' "${file}"`);
                 if (stderr)
                     return `Error: ${stderr}`;
@@ -179,10 +188,12 @@ export function systemTools() {
         symbol_query: tool({
             description: "Query the symbol index. Rebuilds automatically if stale.",
             args: {
-                symbol: tool.schema.string()
+                symbol: tool.schema.string(),
+                plan_id: tool.schema.string().optional().describe("Associated Plan ID")
             },
-            async execute({ symbol }) {
-                log("Tool call: symbol_query", { symbol });
+            async execute({ symbol, plan_id }) {
+                log("Tool call: symbol_query", { symbol, plan_id });
+                record(plan_id, "symbol_query", { symbol });
                 const maint = await maintainSymbolIndex();
                 if (maint.status === "unavailable")
                     return JSON.stringify({ error: maint.reason });
@@ -194,10 +205,12 @@ export function systemTools() {
         jump_to_symbol: tool({
             description: "Jump to a symbol's definition by querying the index and reading the slice.",
             args: {
-                symbol: tool.schema.string()
+                symbol: tool.schema.string(),
+                plan_id: tool.schema.string().optional().describe("Associated Plan ID")
             },
-            async execute({ symbol }) {
-                log("Tool call: jump_to_symbol", { symbol });
+            async execute({ symbol, plan_id }) {
+                log("Tool call: jump_to_symbol", { symbol, plan_id });
+                record(plan_id, "jump_to_symbol", { symbol });
                 const maint = await maintainSymbolIndex();
                 if (maint.status !== "ok")
                     return JSON.stringify({ error: maint.reason });
@@ -223,34 +236,121 @@ export function systemTools() {
             async execute({ symbol, intent }) {
                 log("Tool call: brief_fix_loop", { symbol, intent });
                 const planId = `plan-${Date.now()}`;
-                return JSON.stringify({ plan_id: planId, symbol, intent, status: "PLAN_GENERATED" }, null, 2);
+                record(planId, "brief_fix_loop", { symbol, intent });
+                const maint = await maintainSymbolIndex();
+                const tagsFile = path.join(CACHE_DIR, "tags");
+                const { stdout: tagLine } = await runCmd(`grep -P "^${symbol}\t" "${tagsFile}" | head -n 1`);
+                const locusFile = tagLine ? tagLine.split('\t')[1] : null;
+                let dependents = [];
+                let hotFiles = [];
+                if (locusFile) {
+                    dependents = getDb().findDependents(locusFile);
+                    hotFiles = getDb().getHotFiles('', 20);
+                }
+                const worklist = dependents.map(d => ({
+                    file: d,
+                    is_hot: hotFiles.some(h => h.path === d),
+                    reason: "Dependency impact"
+                }));
+                return JSON.stringify({
+                    plan_id: planId,
+                    symbol,
+                    intent,
+                    locus: { file: locusFile },
+                    worklist,
+                    status: "PLAN_GENERATED",
+                    metadata: {
+                        fingerprint: maint.status,
+                        generated_at: new Date().toISOString()
+                    }
+                }, null, 2);
             }
         }),
         prepare_patch: tool({
             description: "Generate a .diff artifact for the current changes.",
             args: {
-                message: tool.schema.string()
+                message: tool.schema.string(),
+                plan_id: tool.schema.string().optional().describe("Associated Plan ID")
             },
-            async execute({ message }) {
-                log("Tool call: prepare_patch", { message });
+            async execute({ message, plan_id }) {
+                log("Tool call: prepare_patch", { message, plan_id });
+                record(plan_id, "prepare_patch", { message });
                 await ensureCache();
-                const patchPath = path.join(CACHE_DIR, `patch-${Date.now()}.diff`);
-                const { stdout } = await runCmd("git diff");
-                if (!stdout)
+                const patchId = `patch-${Date.now()}`;
+                const patchPath = path.join(CACHE_DIR, `${patchId}.diff`);
+                const { stdout: diff } = await runCmd("git diff");
+                if (!diff)
                     return "No changes to patch.";
-                await fs.writeFile(patchPath, `// MSG: ${message}\n\n${stdout}`);
-                return `Patch saved to ${patchPath}`;
+                const header = {
+                    patch_id: patchId,
+                    plan_id: plan_id || "adhoc",
+                    message,
+                    created_at: new Date().toISOString()
+                };
+                await fs.writeFile(patchPath, `// PATCH_METADATA: ${JSON.stringify(header)}\n\n${diff}`);
+                return JSON.stringify({ status: "SUCCESS", patch_id: patchId, path: patchPath }, null, 2);
             }
         }),
         validate_patch: tool({
-            description: "Validate a patch by applying it in a fresh worktree.",
+            description: "Validate a patch by applying it in a fresh worktree and running build (Background Job).",
             args: {
-                patch_path: tool.schema.string()
+                patch_path: tool.schema.string(),
+                plan_id: tool.schema.string().optional().describe("Associated Plan ID")
             },
-            async execute({ patch_path }) {
-                log("Tool call: validate_patch", { patch_path });
-                const { error } = await runCmd(`git apply --check "${patch_path}"`);
-                return error ? `FAILED: ${error.message}` : "SUCCESS: Patch is valid against current HEAD.";
+            async execute({ patch_path, plan_id }) {
+                log("Tool call: validate_patch (background)", { patch_path, plan_id });
+                record(plan_id, "validate_patch", { patch_path });
+                const jobId = `job-validate-${Date.now()}`;
+                getDb().createJob(jobId, "validation", { patch_path, plan_id });
+                // Spawn background worker
+                (async () => {
+                    getDb().updateJob(jobId, { status: "running", progress: 10 });
+                    const tempWorktree = path.join(PROJECT_ROOT, ".opencode", "temp-" + jobId);
+                    try {
+                        await runCmd(`git worktree add -d "${tempWorktree}"`);
+                        getDb().updateJob(jobId, { progress: 30 });
+                        const content = await fs.readFile(patch_path, "utf-8");
+                        const parts = content.split('\n\n');
+                        const diffOnly = parts.length > 1 ? parts.slice(1).join('\n\n') : content;
+                        const tempDiff = path.join(tempWorktree, "valid.diff");
+                        await fs.writeFile(tempDiff, diffOnly);
+                        const { error: applyError } = await runCmd(`git apply "${tempDiff}"`, tempWorktree);
+                        if (applyError)
+                            throw new Error(`Apply failed: ${applyError.message}`);
+                        getDb().updateJob(jobId, { progress: 60 });
+                        let buildStatus = "SKIPPED";
+                        if (fsSync.existsSync(path.join(tempWorktree, "package.json"))) {
+                            const { error: buildError } = await runCmd("npm run build", tempWorktree);
+                            buildStatus = buildError ? "FAILED" : "SUCCESS";
+                        }
+                        else if (fsSync.existsSync(path.join(tempWorktree, "Package.swift"))) {
+                            const { error: buildError } = await runCmd("swift build", tempWorktree);
+                            buildStatus = buildError ? "FAILED" : "SUCCESS";
+                        }
+                        getDb().updateJob(jobId, {
+                            status: "completed",
+                            progress: 100,
+                            result: JSON.stringify({ apply: "OK", build: buildStatus })
+                        });
+                    }
+                    catch (error) {
+                        getDb().updateJob(jobId, { status: "failed", error: error.message });
+                    }
+                    finally {
+                        try {
+                            await runCmd(`git worktree remove -f "${tempWorktree}"`);
+                            if (fsSync.existsSync(tempWorktree))
+                                await fs.rm(tempWorktree, { recursive: true, force: true });
+                        }
+                        catch (e) { }
+                    }
+                })();
+                return JSON.stringify({
+                    status: "STARTED",
+                    message: "Validation started in background.",
+                    job_id: jobId,
+                    instruction: "Use perf_background_status to check progress."
+                }, null, 2);
             }
         }),
         finalize_plan: tool({
@@ -261,11 +361,17 @@ export function systemTools() {
             },
             async execute({ plan_id, outcome }) {
                 log("Tool call: finalize_plan", { plan_id, outcome });
-                await ensureCache();
-                const report = { plan_id, outcome, time: new Date().toISOString() };
+                record(plan_id, "finalize_plan", { outcome });
+                const metrics = getDb().getPlanMetrics(plan_id);
+                const report = {
+                    plan_id,
+                    outcome,
+                    metrics,
+                    finished_at: new Date().toISOString()
+                };
                 await fs.appendFile(path.join(CACHE_DIR, "gaps.jsonl"), JSON.stringify(report) + "\n");
                 const deleted = await cleanCache();
-                return `Finalized. Cache hygiene: deleted ${deleted} old items.`;
+                return JSON.stringify({ status: "FINALIZED", report, cache_cleared: deleted }, null, 2);
             }
         })
     };

package/dist/testing-infrastructure.js

@@ -5,6 +5,7 @@ import * as fsSync from "node:fs";
 import * as path from "node:path";
 import { promisify } from "node:util";
 import * as crypto from "node:crypto";
+import { Logger } from "./services/logger.js";
 const execAsync = promisify(exec);
 const PROJECT_ROOT = process.cwd();
 const OPENCODE_DIR = path.join(PROJECT_ROOT, ".opencode");
@@ -12,7 +13,7 @@ const TEST_DIR = path.join(OPENCODE_DIR, "tests");
 const BENCHMARK_DIR = path.join(OPENCODE_DIR, "benchmarks");
 // Internal logging
 function log(message, data) {
-    console.error(`[Testing] ${message}`, data || '');
+    Logger.log("Testing", message, data);
 }
 // =============================================================================
 // HELPERS

package/dist/unified-api.d.ts

@@ -0,0 +1,3 @@
+export declare function unifiedTools(): {
+    [key: string]: any;
+};