opencode-autognosis 2.0.0 → 2.0.2

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.0",
+  "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"
   }
 }