opencode-autognosis 2.0.0 → 2.0.2

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.d.ts

@@ -1,5 +1,6 @@
-export default function plugin(): {
-    tools: {
-        [key: string]: any;
+export declare const AutognosisPlugin: () => Promise<{
+    tool: {
+        [x: string]: any;
     };
-};
+}>;
+export default AutognosisPlugin;

package/dist/index.js

@@ -5,9 +5,10 @@ import { chunkCardsTools } from "./chunk-cards.js";
 import { activeSetTools } from "./activeset.js";
 import { moduleSummariesTools } from "./module-summaries.js";
 import { performanceTools } from "./performance-optimization.js";
-export default function plugin() {
+import { graphTools } from "./database.js";
+export const AutognosisPlugin = async () => {
     return {
-        tools: {
+        tool: {
             ...systemTools(),
             ...gitWorktreeTools(),
             ...testingTools(),
@@ -15,6 +16,8 @@ export default function plugin() {
             ...activeSetTools(),
             ...moduleSummariesTools(),
             ...performanceTools(),
+            ...graphTools(),
         },
     };
-}
+};
+export default AutognosisPlugin;

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,6 +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");
@@ -13,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
@@ -593,10 +596,45 @@ async function getAllSourceFiles() {
     return sourceFiles;
 }
 async function indexFile(filePath) {
-    // Simplified indexing - would create chunk cards, analyze symbols, etc.
-    // For now, just touch the file to update its timestamp
-    const stats = await fs.stat(filePath);
-    // Indexing logic would go here
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        await ensureChunkDir();
+        const ast = parseFileAST(filePath, content);
+        const chunkTypes = ["summary", "api", "invariant"];
+        // Generate file hash for ID consistency
+        const fileHash = calculateHash(filePath);
+        for (const chunkType of chunkTypes) {
+            const cardId = `${path.basename(filePath)}-${chunkType}-${fileHash.slice(0, 8)}`;
+            const cardPath = path.join(CHUNK_DIR, `${cardId}.json`);
+            let chunkContent = "";
+            if (chunkType === "summary")
+                chunkContent = await generateSummaryChunk(content, filePath, ast);
+            else if (chunkType === "api")
+                chunkContent = await generateApiChunk(content, filePath, ast);
+            else if (chunkType === "invariant")
+                chunkContent = await generateInvariantChunk(content, filePath, ast);
+            const chunkCard = {
+                id: cardId,
+                file_path: filePath,
+                chunk_type: chunkType,
+                content: chunkContent,
+                metadata: {
+                    created_at: new Date().toISOString(),
+                    updated_at: new Date().toISOString(),
+                    hash: calculateHash(chunkContent),
+                    dependencies: await extractDependencies(content, ast, filePath),
+                    symbols: extractSymbolsFromAST(ast, content) || extractSymbols(content, filePath),
+                    complexity_score: calculateComplexity(content)
+                }
+            };
+            await fs.writeFile(cardPath, JSON.stringify(chunkCard, null, 2));
+            // Sync to SQLite Index
+            getDb().ingestChunkCard(chunkCard);
+        }
+    }
+    catch (error) {
+        log(`Failed to index file ${filePath}`, error);
+    }
 }
 async function runBackgroundIndexing(taskId, indexingState) {
     try {
@@ -606,11 +644,65 @@ async function runBackgroundIndexing(taskId, indexingState) {
         task.status = "running";
         task.started_at = new Date().toISOString();
         await fs.writeFile(taskPath, JSON.stringify(task, null, 2));
-        // Simulate background indexing work
-        for (let i = 0; i < 10; i++) {
-            task.progress = (i + 1) * 10;
+        // Determine files to index
+        const force_full = task.metadata?.force_full || false;
+        let filesToIndex = [];
+        if (force_full) {
+            filesToIndex = await getAllSourceFiles();
+        }
+        else {
+            // For incremental, we try to use git diff. If that fails or returns empty,
+            // we might default to all files or just recent ones. For robustness here:
+            try {
+                const { stdout: gitDiff } = await runCmd(`git diff --name-only --since="${indexingState.last_indexed}"`);
+                const changedFiles = gitDiff.split('\n').filter(Boolean);
+                if (changedFiles.length > 0) {
+                    filesToIndex = changedFiles;
+                }
+                else {
+                    // If no changes detected by git, maybe we don't need to do anything?
+                    // But if forced or state is stale, maybe we should.
+                    // For background task simplicity, if not full, and no git changes, we index nothing or check simple timestamps.
+                    // Let's rely on getAllSourceFiles filtering if we wanted robust check.
+                    // Here, we'll just check timestamps of all source files against last_indexed.
+                    const allFiles = await getAllSourceFiles();
+                    filesToIndex = [];
+                    for (const f of allFiles) {
+                        const fp = path.join(PROJECT_ROOT, f);
+                        if (fsSync.existsSync(fp)) {
+                            const stats = await fs.stat(fp);
+                            if (stats.mtime.toISOString() > indexingState.last_indexed) {
+                                filesToIndex.push(f);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                // Fallback to full scan if git fails
+                filesToIndex = await getAllSourceFiles();
+            }
+        }
+        const total = filesToIndex.length;
+        let processed = 0;
+        if (total === 0) {
+            task.progress = 100;
+            task.status = "completed";
+            task.completed_at = new Date().toISOString();
             await fs.writeFile(taskPath, JSON.stringify(task, null, 2));
-            await new Promise(resolve => setTimeout(resolve, 1000));
+            return;
+        }
+        for (const file of filesToIndex) {
+            const filePath = path.join(PROJECT_ROOT, file);
+            if (fsSync.existsSync(filePath)) {
+                await indexFile(filePath);
+            }
+            processed++;
+            // Update progress periodically
+            if (processed % 5 === 0 || processed === total) {
+                task.progress = Math.round((processed / total) * 100);
+                await fs.writeFile(taskPath, JSON.stringify(task, null, 2));
+            }
         }
         // Complete task
         task.status = "completed";
@@ -621,11 +713,18 @@ async function runBackgroundIndexing(taskId, indexingState) {
     catch (error) {
         // Update task with error
         const taskPath = path.join(PERF_DIR, `${taskId}.json`);
-        const task = JSON.parse(await fs.readFile(taskPath, 'utf-8'));
-        task.status = "failed";
-        task.error = error instanceof Error ? error.message : `${error}`;
-        task.completed_at = new Date().toISOString();
-        await fs.writeFile(taskPath, JSON.stringify(task, null, 2));
+        try {
+            if (fsSync.existsSync(taskPath)) {
+                const task = JSON.parse(await fs.readFile(taskPath, 'utf-8'));
+                task.status = "failed";
+                task.error = error instanceof Error ? error.message : `${error}`;
+                task.completed_at = new Date().toISOString();
+                await fs.writeFile(taskPath, JSON.stringify(task, null, 2));
+            }
+        }
+        catch (writeError) {
+            log("Failed to update task error state", writeError);
+        }
     }
 }
 function calculateMetricsSummary(metrics) {

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;
+}