opencode-autognosis 2.0.1 → 2.0.2

package/dist/activeset.js

@@ -3,12 +3,13 @@ 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 ACTIVESET_DIR = path.join(OPENCODE_DIR, "activesets");
 // Internal logging
 function log(message, data) {
-    console.error(`[ActiveSet] ${message}`, data || '');
+    Logger.log("ActiveSet", message, data);
 }
 // =============================================================================
 // HELPERS

package/dist/chunk-cards.js

@@ -6,6 +6,8 @@ import * as path from "node:path";
 import { promisify } from "node:util";
 import * as crypto from "node:crypto";
 import ts from "typescript";
+import { getDb } from "./database.js";
+import { Logger } from "./services/logger.js";
 const execAsync = promisify(exec);
 const PROJECT_ROOT = process.cwd();
 const OPENCODE_DIR = path.join(PROJECT_ROOT, ".opencode");
@@ -13,7 +15,7 @@ export const CHUNK_DIR = path.join(OPENCODE_DIR, "chunks");
 const CACHE_DIR = path.join(OPENCODE_DIR, "cache");
 // Internal logging
 function log(message, data) {
-    console.error(`[ChunkCards] ${message}`, data || '');
+    Logger.log("ChunkCards", message, data);
 }
 // =============================================================================
 // HELPERS
@@ -158,6 +160,8 @@ export function chunkCardsTools() {
                     };
                     // Save chunk card
                     await fs.writeFile(cardPath, JSON.stringify(chunkCard, null, 2));
+                    // Sync to SQLite Index
+                    getDb().ingestChunkCard(chunkCard);
                     return JSON.stringify({
                         status: "SUCCESS",
                         card: chunkCard,
@@ -297,6 +301,8 @@ export function chunkCardsTools() {
                         }, null, 2);
                     }
                     await fs.unlink(cardPath);
+                    // Remove from SQLite Index
+                    getDb().deleteChunkCard(card_id);
                     return JSON.stringify({
                         status: "SUCCESS",
                         message: `Card deleted: ${card_id}`

package/dist/database.d.ts

@@ -0,0 +1,36 @@
+import type { ChunkCard } from "./chunk-cards.js";
+export declare class CodeGraphDB {
+    private db;
+    private workerRunning;
+    constructor();
+    private initialize;
+    private startWorker;
+    private processEmbeddingQueue;
+    /**
+     * Syncs a ChunkCard (JSON) into the SQLite Index.
+     * This is an "Upsert" operation.
+     */
+    ingestChunkCard(card: ChunkCard): void;
+    /**
+     * Remove a card from the index
+     */
+    deleteChunkCard(cardId: string): void;
+    findDependents(filePath: string): string[];
+    searchSymbols(query: string): any[];
+    semanticSearch(query: string, limit?: number): Promise<any[]>;
+    private cosineSimilarity;
+    getStats(): {
+        files: number;
+        chunks: number;
+        symbols: number;
+        dependencies: number;
+        embeddings: {
+            completed: number;
+            pending: number;
+        };
+    };
+}
+export declare function getDb(): CodeGraphDB;
+export declare function graphTools(): {
+    [key: string]: any;
+};

package/dist/database.js

@@ -0,0 +1,399 @@
+import Database from "better-sqlite3";
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { tool } from "@opencode-ai/plugin";
+import { ollama, DEFAULT_EMBEDDING_MODEL } from "./services/ollama.js";
+const PROJECT_ROOT = process.cwd();
+const OPENCODE_DIR = path.join(PROJECT_ROOT, ".opencode");
+const DB_PATH = path.join(OPENCODE_DIR, "autognosis.db");
+export class CodeGraphDB {
+    db;
+    workerRunning = false;
+    constructor() {
+        // Ensure directory exists
+        if (!fs.existsSync(OPENCODE_DIR)) {
+            fs.mkdirSync(OPENCODE_DIR, { recursive: true });
+        }
+        this.db = new Database(DB_PATH);
+        this.initialize();
+        // Start background worker
+        this.startWorker();
+    }
+    initialize() {
+        // Enable WAL mode for concurrency and performance
+        this.db.pragma('journal_mode = WAL');
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS files (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        path TEXT UNIQUE NOT NULL,
+        hash TEXT,
+        last_indexed DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS chunks (
+        id TEXT PRIMARY KEY,
+        file_id INTEGER,
+        type TEXT,
+        complexity_score REAL,
+        content_summary TEXT,
+        embedding BLOB,
+        FOREIGN KEY(file_id) REFERENCES files(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS embedding_queue (
+        chunk_id TEXT PRIMARY KEY,
+        text_to_embed TEXT,
+        status TEXT DEFAULT 'pending', -- pending, processing, failed
+        retries INTEGER DEFAULT 0,
+        FOREIGN KEY(chunk_id) REFERENCES chunks(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS symbols (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        chunk_id TEXT,
+        name TEXT NOT NULL,
+        kind TEXT, -- 'function', 'class', 'interface', etc.
+        FOREIGN KEY(chunk_id) REFERENCES chunks(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS dependencies (
+        source_chunk_id TEXT,
+        target_path TEXT,
+        FOREIGN KEY(source_chunk_id) REFERENCES chunks(id) ON DELETE CASCADE
+      );
+
+      -- Indexes for performance
+      CREATE INDEX IF NOT EXISTS idx_files_path ON files(path);
+      CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
+      CREATE INDEX IF NOT EXISTS idx_dependencies_target ON dependencies(target_path);
+    `);
+        // Migrations
+        try {
+            this.db.exec("ALTER TABLE chunks ADD COLUMN embedding BLOB");
+        }
+        catch { }
+    }
+    async startWorker() {
+        if (this.workerRunning)
+            return;
+        this.workerRunning = true;
+        // Run periodically
+        setInterval(async () => {
+            try {
+                await this.processEmbeddingQueue();
+            }
+            catch (e) {
+                // console.error("Worker error:", e);
+            }
+        }, 5000); // Check every 5s
+    }
+    async processEmbeddingQueue() {
+        // Check if Ollama is ready
+        if (!(await ollama.isRunning()))
+            return;
+        // Get next task
+        const task = this.db.prepare(`
+      SELECT chunk_id, text_to_embed, retries 
+      FROM embedding_queue 
+      WHERE status = 'pending' 
+      ORDER BY rowid ASC 
+      LIMIT 1
+    `).get();
+        if (!task)
+            return;
+        // Mark processing
+        this.db.prepare("UPDATE embedding_queue SET status = 'processing' WHERE chunk_id = ?").run(task.chunk_id);
+        try {
+            // Generate embedding
+            const vector = await ollama.getEmbedding(task.text_to_embed);
+            if (vector.length > 0) {
+                // Store blob (Float32Array to Buffer)
+                const buffer = Buffer.from(new Float32Array(vector).buffer);
+                const updateChunk = this.db.prepare("UPDATE chunks SET embedding = ? WHERE id = ?");
+                const deleteQueue = this.db.prepare("DELETE FROM embedding_queue WHERE chunk_id = ?");
+                const txn = this.db.transaction(() => {
+                    updateChunk.run(buffer, task.chunk_id);
+                    deleteQueue.run(task.chunk_id);
+                });
+                txn();
+            }
+            else {
+                throw new Error("Empty vector returned");
+            }
+        }
+        catch (error) {
+            if (task.retries > 3) {
+                // Give up
+                this.db.prepare("UPDATE embedding_queue SET status = 'failed' WHERE chunk_id = ?").run(task.chunk_id);
+            }
+            else {
+                // Retry
+                this.db.prepare("UPDATE embedding_queue SET status = 'pending', retries = retries + 1 WHERE chunk_id = ?").run(task.chunk_id);
+            }
+        }
+    }
+    /**
+     * Syncs a ChunkCard (JSON) into the SQLite Index.
+     * This is an "Upsert" operation.
+     */
+    ingestChunkCard(card) {
+        const insertFile = this.db.prepare(`
+      INSERT INTO files (path, hash, last_indexed)
+      VALUES (?, ?, CURRENT_TIMESTAMP)
+      ON CONFLICT(path) DO UPDATE SET
+        hash = excluded.hash,
+        last_indexed = CURRENT_TIMESTAMP
+      RETURNING id
+    `);
+        const insertChunk = this.db.prepare(`
+      INSERT INTO chunks (id, file_id, type, complexity_score, content_summary)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        complexity_score = excluded.complexity_score,
+        content_summary = excluded.content_summary
+    `);
+        const queueEmbedding = this.db.prepare(`
+      INSERT INTO embedding_queue (chunk_id, text_to_embed)
+      VALUES (?, ?)
+      ON CONFLICT(chunk_id) DO UPDATE SET
+        text_to_embed = excluded.text_to_embed,
+        status = 'pending',
+        retries = 0
+    `);
+        const insertSymbol = this.db.prepare(`
+      INSERT INTO symbols (chunk_id, name, kind) VALUES (?, ?, 'unknown')
+    `);
+        const insertDep = this.db.prepare(`
+      INSERT INTO dependencies (source_chunk_id, target_path) VALUES (?, ?)
+    `);
+        const deleteOldSymbols = this.db.prepare('DELETE FROM symbols WHERE chunk_id = ?');
+        const deleteOldDeps = this.db.prepare('DELETE FROM dependencies WHERE source_chunk_id = ?');
+        const transaction = this.db.transaction(() => {
+            // 1. Upsert File
+            const fileRes = insertFile.get(card.file_path, card.metadata.hash);
+            const fileId = fileRes.id;
+            // 2. Upsert Chunk
+            insertChunk.run(card.id, fileId, card.chunk_type, card.metadata.complexity_score, card.content.slice(0, 500) // Store preview
+            );
+            // 3. Queue for Embedding
+            // Use the summary or content as the text to embed
+            const textToEmbed = `${card.chunk_type.toUpperCase()} for ${path.basename(card.file_path)}\n\n${card.content.slice(0, 2000)}`;
+            queueEmbedding.run(card.id, textToEmbed);
+            // 4. Replace Symbols
+            deleteOldSymbols.run(card.id);
+            for (const sym of card.metadata.symbols) {
+                insertSymbol.run(card.id, sym);
+            }
+            // 5. Replace Dependencies
+            deleteOldDeps.run(card.id);
+            for (const dep of card.metadata.dependencies) {
+                insertDep.run(card.id, dep);
+            }
+        });
+        transaction();
+    }
+    /**
+     * Remove a card from the index
+     */
+    deleteChunkCard(cardId) {
+        this.db.prepare('DELETE FROM chunks WHERE id = ?').run(cardId);
+    }
+    // ===========================================================================
+    // QUERY METHODS
+    // ===========================================================================
+    findDependents(filePath) {
+        // Find all chunks that depend on this file path
+        // Note: dependency paths might be relative or absolute, simplistic matching for now
+        const query = this.db.prepare(`
+      SELECT DISTINCT f.path 
+      FROM files f
+      JOIN chunks c ON f.id = c.file_id
+      JOIN dependencies d ON c.id = d.source_chunk_id
+      WHERE d.target_path LIKE ? OR d.target_path = ?
+    `);
+        // Attempt to match exact path or likely relative imports (simplistic)
+        const basename = path.basename(filePath);
+        const results = query.all(`%/${basename}%`, basename);
+        return results.map(r => r.path);
+    }
+    searchSymbols(query) {
+        const stmt = this.db.prepare(`
+      SELECT s.name, c.type, f.path 
+      FROM symbols s
+      JOIN chunks c ON s.chunk_id = c.id
+      JOIN files f ON c.file_id = f.id
+      WHERE s.name LIKE ?
+      LIMIT 20
+    `);
+        return stmt.all(`%${query}%`);
+    }
+    async semanticSearch(query, limit = 10) {
+        if (!(await ollama.isRunning())) {
+            throw new Error("Ollama is not running. Please run 'autognosis_setup_ai' first.");
+        }
+        const queryVec = await ollama.getEmbedding(query);
+        if (queryVec.length === 0)
+            return [];
+        // Get all embeddings from DB
+        // SQLite doesn't have vector math, so we fetch all and sort in JS
+        // Optimizations: In future, use sqlite-vec or filter by complexity/type first
+        const chunks = this.db.prepare(`
+      SELECT c.id, c.content_summary, c.type, f.path, c.embedding
+      FROM chunks c
+      JOIN files f ON c.file_id = f.id
+      WHERE c.embedding IS NOT NULL
+    `).all();
+        const results = chunks.map(chunk => {
+            const vector = new Float32Array(chunk.embedding.buffer, chunk.embedding.byteOffset, chunk.embedding.byteLength / 4);
+            const similarity = this.cosineSimilarity(queryVec, vector);
+            return { ...chunk, similarity, embedding: undefined }; // Don't return blob
+        });
+        results.sort((a, b) => b.similarity - a.similarity);
+        return results.slice(0, limit);
+    }
+    cosineSimilarity(vecA, vecB) {
+        let dot = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < vecA.length; i++) {
+            dot += vecA[i] * vecB[i];
+            normA += vecA[i] * vecA[i];
+            normB += vecB[i] * vecB[i];
+        }
+        return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+    }
+    getStats() {
+        const files = this.db.prepare('SELECT COUNT(*) as c FROM files').get();
+        const symbols = this.db.prepare('SELECT COUNT(*) as c FROM symbols').get();
+        const deps = this.db.prepare('SELECT COUNT(*) as c FROM dependencies').get();
+        const chunks = this.db.prepare('SELECT COUNT(*) as c FROM chunks').get();
+        const embedded = this.db.prepare('SELECT COUNT(*) as c FROM chunks WHERE embedding IS NOT NULL').get();
+        const queue = this.db.prepare("SELECT COUNT(*) as c FROM embedding_queue WHERE status = 'pending'").get();
+        return {
+            files: files.c,
+            chunks: chunks.c,
+            symbols: symbols.c,
+            dependencies: deps.c,
+            embeddings: {
+                completed: embedded.c,
+                pending: queue.c
+            }
+        };
+    }
+}
+// Singleton instance for the plugin
+let dbInstance = null;
+export function getDb() {
+    if (!dbInstance) {
+        dbInstance = new CodeGraphDB();
+    }
+    return dbInstance;
+}
+export function graphTools() {
+    return {
+        autognosis_setup_ai: tool({
+            description: "Configure local AI capabilities (Ollama). Checks installation, installs if needed, and pulls the embedding model.",
+            args: {
+                model: tool.schema.string().optional().default(DEFAULT_EMBEDDING_MODEL).describe("Embedding model to pull")
+            },
+            async execute({ model }) {
+                try {
+                    const installed = await ollama.isInstalled();
+                    let statusMsg = "Ollama is installed.";
+                    if (!installed) {
+                        statusMsg = await ollama.install();
+                    }
+                    await ollama.startServer();
+                    await ollama.pullModel(model);
+                    return JSON.stringify({
+                        status: "SUCCESS",
+                        message: `${statusMsg} Server is running. Model ${model} is ready.`,
+                        config: {
+                            model,
+                            base_url: "http://127.0.0.1:11434"
+                        }
+                    }, null, 2);
+                }
+                catch (error) {
+                    return JSON.stringify({ status: "ERROR", message: String(error) }, null, 2);
+                }
+            }
+        }),
+        graph_semantic_search: tool({
+            description: "Search the codebase using natural language (Vector/Semantic Search). Requires AI setup.",
+            args: {
+                query: tool.schema.string().describe("Natural language query"),
+                limit: tool.schema.number().optional().default(10).describe("Max results")
+            },
+            async execute({ query, limit }) {
+                try {
+                    const results = await getDb().semanticSearch(query, limit);
+                    return JSON.stringify({
+                        status: "SUCCESS",
+                        query,
+                        results
+                    }, null, 2);
+                }
+                catch (error) {
+                    return JSON.stringify({ status: "ERROR", message: String(error) }, null, 2);
+                }
+            }
+        }),
+        graph_query_dependents: tool({
+            description: "Find all files that depend on a specific file (upstream impact analysis).",
+            args: {
+                file_path: tool.schema.string().describe("File path to analyze"),
+            },
+            async execute({ file_path }) {
+                try {
+                    const dependents = getDb().findDependents(file_path);
+                    return JSON.stringify({
+                        status: "SUCCESS",
+                        file_path,
+                        dependents,
+                        count: dependents.length
+                    }, null, 2);
+                }
+                catch (error) {
+                    return JSON.stringify({ status: "ERROR", message: String(error) }, null, 2);
+                }
+            }
+        }),
+        graph_search_symbols: tool({
+            description: "Fast fuzzy search for symbols (functions, classes) across the entire codebase index.",
+            args: {
+                query: tool.schema.string().describe("Symbol name query"),
+            },
+            async execute({ query }) {
+                try {
+                    const results = getDb().searchSymbols(query);
+                    return JSON.stringify({
+                        status: "SUCCESS",
+                        query,
+                        results,
+                        count: results.length
+                    }, null, 2);
+                }
+                catch (error) {
+                    return JSON.stringify({ status: "ERROR", message: String(error) }, null, 2);
+                }
+            }
+        }),
+        graph_stats: tool({
+            description: "Get statistics about the Code Graph Index.",
+            args: {},
+            async execute() {
+                try {
+                    const stats = getDb().getStats();
+                    return JSON.stringify({
+                        status: "SUCCESS",
+                        stats
+                    }, null, 2);
+                }
+                catch (error) {
+                    return JSON.stringify({ status: "ERROR", message: String(error) }, null, 2);
+                }
+            }
+        })
+    };
+}

package/dist/git-worktree.js

@@ -5,13 +5,14 @@ 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");
 const WORKTREE_DIR = path.join(OPENCODE_DIR, "worktrees");
 // Internal logging
 function log(message, data) {
-    console.error(`[GitWorktree] ${message}`, data || '');
+    Logger.log("GitWorktree", message, data);
 }
 // =============================================================================
 // HELPERS
@@ -202,8 +203,8 @@ export function gitWorktreeTools() {
                         }, null, 2);
                     }
                     // Create initial commit if needed
-                    const { stdout: log } = await runCmd("git log --oneline -1");
-                    if (!log || log.includes("Initial commit")) {
+                    const { stdout: gitLog } = await runCmd("git log --oneline -1");
+                    if (!gitLog || gitLog.includes("Initial commit")) {
                         await runCmd(`git commit --allow-empty -m "${message}"`);
                     }
                     let worktreePath = null;
@@ -214,7 +215,7 @@ export function gitWorktreeTools() {
                         if (fsSync.existsSync(worktreePath)) {
                             const { error: removeError } = await runCmd(`git worktree remove ${worktreePath}`);
                             if (removeError) {
-                                console.error("[GitWorktree] Warning: Failed to remove existing worktree", removeError);
+                                log("Warning: Failed to remove existing worktree", removeError);
                             }
                         }
                         // Create new worktree

package/dist/index.js

@@ -5,6 +5,7 @@ import { chunkCardsTools } from "./chunk-cards.js";
 import { activeSetTools } from "./activeset.js";
 import { moduleSummariesTools } from "./module-summaries.js";
 import { performanceTools } from "./performance-optimization.js";
+import { graphTools } from "./database.js";
 export const AutognosisPlugin = async () => {
     return {
         tool: {
@@ -15,6 +16,7 @@ export const AutognosisPlugin = async () => {
             ...activeSetTools(),
             ...moduleSummariesTools(),
             ...performanceTools(),
+            ...graphTools(),
         },
     };
 };

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
@@ -626,6 +628,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 +723,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,14 @@ 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");
 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

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-autognosis",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "Advanced RAG-powered codebase awareness for OpenCode agents. Features Chunk Cards synthesis, hierarchical reasoning, ActiveSet working memory, and performance optimization for enterprise-scale repositories.",
   "type": "module",
   "main": "dist/index.js",
@@ -46,8 +46,12 @@
   "devDependencies": {
     "@opencode-ai/plugin": "^1.0.162",
     "@opencode-ai/sdk": "^1.1.40",
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0",
     "zod": "^4.3.6"
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.6.2"
   }
 }