opencode-autognosis 2.3.1 → 2.5.0

package/dist/database.d.ts

@@ -12,6 +12,8 @@ export declare class CodeGraphDB {
         error?: string;
     }): void;
     getJob(id: string): any;
+    registerContract(triggerTool: string, triggerAction: string, targetTool: string, targetArgs: any): void;
+    getContracts(triggerTool: string, triggerAction: string): any[];
     listJobs(type?: string, limit?: number): any;
     postToBlackboard(author: string, message: string, topic?: string, symbolId?: string, isPinned?: boolean): void;
     getGraffiti(symbolId: string, limit?: number): any;
@@ -55,6 +57,7 @@ export declare class CodeGraphDB {
     };
     findDependents(filePath: string): string[];
     searchSymbols(query: string): any[];
+    findAffectedTests(symbolName: string): string[];
     semanticSearch(query: string, limit?: number): Promise<any[]>;
     private cosineSimilarity;
     getStats(): {

package/dist/database.js

@@ -185,6 +185,15 @@ export class CodeGraphDB {
         updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
       );
 
+      CREATE TABLE IF NOT EXISTS tool_contracts (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        trigger_tool TEXT, -- e.g., 'code_propose'
+        trigger_action TEXT, -- e.g., 'patch'
+        target_tool TEXT,
+        target_args TEXT, -- JSON
+        condition_script TEXT -- Optional JS snippet to evaluate
+      );
+
       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);
@@ -228,6 +237,18 @@ export class CodeGraphDB {
     getJob(id) {
         return this.db.prepare("SELECT * FROM background_jobs WHERE id = ?").get(id);
     }
+    registerContract(triggerTool, triggerAction, targetTool, targetArgs) {
+        this.db.prepare(`
+      INSERT INTO tool_contracts (trigger_tool, trigger_action, target_tool, target_args)
+      VALUES (?, ?, ?, ?)
+    `).run(triggerTool, triggerAction, targetTool, JSON.stringify(targetArgs));
+    }
+    getContracts(triggerTool, triggerAction) {
+        return this.db.prepare(`
+      SELECT * FROM tool_contracts 
+      WHERE trigger_tool = ? AND (trigger_action = ? OR trigger_action IS NULL)
+    `).all(triggerTool, triggerAction);
+    }
     listJobs(type, limit = 10) {
         if (type) {
             return this.db.prepare("SELECT * FROM background_jobs WHERE type = ? ORDER BY created_at DESC LIMIT ?").all(type, limit);
@@ -524,6 +545,29 @@ ${card.content.slice(0, 2000)}`;
     `);
         return stmt.all(`%${query}%`);
     }
+    findAffectedTests(symbolName) {
+        // Find all files that call this symbol and look like test files
+        const query = this.db.prepare(`
+      WITH RECURSIVE impact_tree(caller_chunk_id) AS (
+        -- Base case: chunks calling the symbol directly
+        SELECT caller_chunk_id FROM calls WHERE callee_name = ?
+        UNION
+        -- Recursive step: chunks calling chunks in the impact tree
+        SELECT c.caller_chunk_id 
+        FROM calls c
+        JOIN impact_tree it ON c.callee_name IN (
+          SELECT s.name FROM symbols s WHERE s.chunk_id = it.caller_chunk_id
+        )
+      )
+      SELECT DISTINCT f.path
+      FROM files f
+      JOIN chunks c ON f.id = c.file_id
+      JOIN impact_tree it ON c.id = it.caller_chunk_id
+      WHERE f.path LIKE '%.test.%' OR f.path LIKE '%Tests.%' OR f.path LIKE 'test_%'
+    `);
+        const results = query.all(symbolName);
+        return results.map(r => r.path);
+    }
     async semanticSearch(query, limit = 10) {
         if (!(await ollama.isRunning()))
             throw new Error("Ollama is not running.");

package/dist/unified-api.js

@@ -25,14 +25,14 @@ async function scoutPlugins() {
         if (config.plugin)
             config.plugin.forEach((p) => plugins.add(p));
     }
-    catch { } // Ignore errors if config file doesn't exist
+    catch { }
     try {
         const pkg = JSON.parse(fsSync.readFileSync(path.join(PROJECT_ROOT, "package.json"), "utf-8"));
         const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
         Object.keys(allDeps).forEach(d => { if (d.includes("opencode"))
             plugins.add(d); });
     }
-    catch { } // Ignore errors if package.json doesn't exist
+    catch { }
     return Array.from(plugins);
 }
 async function updateBridgePrompt(plugins) {
@@ -40,14 +40,15 @@ async function updateBridgePrompt(plugins) {
     if (!fsSync.existsSync(bridgePath))
         return "bridge.md not found at " + bridgePath;
     const toolsSection = `
-## Current Consolidated Tools (Autognosis v2.3)
+## Current Consolidated Tools (Autognosis v2.5)
 - code_search: Universal search (semantic, symbol, filename, content).
 - code_analyze: Deep structural analysis and impact reports.
-- code_context: Working memory (ActiveSet) management, LRU eviction, and Symbol Graffiti.
-- code_read: Precise symbol jumping and file slicing with Mutex Lock checks.
-- code_propose: Planning, patch generation, PR promotion, and Intent indexing.
-- code_status: System health, background jobs, Multi-Agent Blackboard, and Resource Locks.
+- code_context: Working memory management and LRU eviction.
+- code_read: Precise reading with Mutex Lock checks and Graffiti retrieval.
+- code_propose: Planning, patching, validation, and PR promotion.
+- code_status: Dashboard, background jobs, blackboard, and resource locks.
 - code_setup: Environment initialization, AI setup, and Architectural Boundaries.
+- code_contract: Reactive tool chaining and automated post-execution hooks.
 
 ## Other Detected Plugins
 ${plugins.filter(p => p !== "opencode-autognosis").map(p => `- ${p}`).join('\n')}
@@ -62,10 +63,53 @@ ${plugins.filter(p => p !== "opencode-autognosis").map(p => `- ${p}`).join('\n')
     fsSync.writeFileSync(bridgePath, content);
     return "Updated bridge.md with consolidated tools and detected plugins.";
 }
+/**
+ * Reactive Contract Runner
+ * Automatically triggers secondary tools based on registered contracts.
+ */
+async function runWithContracts(toolName, action, args, result, tools) {
+    const contracts = getDb().getContracts(toolName, action || '');
+    if (contracts.length === 0)
+        return result;
+    let finalResult = JSON.parse(result);
+    finalResult.contracts_triggered = [];
+    for (const contract of contracts) {
+        try {
+            const targetTool = tools[contract.target_tool];
+            if (targetTool) {
+                const targetArgs = JSON.parse(contract.target_args);
+                // Merge context from original args if needed (e.g. plan_id)
+                if (args.plan_id)
+                    targetArgs.plan_id = args.plan_id;
+                const chainResult = await targetTool.execute(targetArgs);
+                finalResult.contracts_triggered.push({
+                    name: contract.target_tool,
+                    result: JSON.parse(chainResult)
+                });
+            }
+        }
+        catch (e) {
+            finalResult.contracts_triggered.push({ name: contract.target_tool, error: String(e) });
+        }
+    }
+    return JSON.stringify(finalResult, null, 2);
+}
 export function unifiedTools() {
     const agentName = process.env.AGENT_NAME || `agent-${process.pid}`;
-    return {
-        code_search: tool({
+    const api = {};
+    const wrap = (toolName, config) => {
+        const originalExecute = config.execute;
+        config.execute = async (args) => {
+            const res = await originalExecute(args);
+            // Only attempt chaining if original call was successful (heuristic)
+            if (res.includes('"status": "ERROR"') || res.includes('"status": "FAILED"'))
+                return res;
+            return runWithContracts(toolName, args.action || args.mode, args, res, api);
+        };
+        return tool(config);
+    };
+    Object.assign(api, {
+        code_search: wrap("code_search", {
             description: "Search the codebase using various engines (filename, content, symbol, or semantic/vector).",
             args: {
                 query: tool.schema.string().describe("Search query"),
@@ -83,7 +127,7 @@ export function unifiedTools() {
                 }
             }
         }),
-        code_analyze: tool({
+        code_analyze: wrap("code_analyze", {
             description: "Perform structural analysis on files or modules. Generates summaries, API maps, and impact reports.",
             args: {
                 target: tool.schema.string().describe("File path or module ID"),
@@ -101,7 +145,7 @@ export function unifiedTools() {
                 }
             }
         }),
-        code_context: tool({
+        code_context: wrap("code_context", {
             description: "Manage working memory (ActiveSets). Limits context window usage by loading/unloading specific chunks.",
             args: {
                 action: tool.schema.enum(["create", "load", "add", "remove", "status", "list", "close", "evict"]),
@@ -112,10 +156,10 @@ export function unifiedTools() {
             },
             async execute(args) {
                 switch (args.action) {
-                    case "create": return internal.activeset_create.execute({ name: args.name || "Context", chunk_ids: args.target?.split(',').map(s => s.trim()) });
+                    case "create": return internal.activeset_create.execute({ name: args.name || "Context", chunk_ids: args.target?.split(',').map((s) => s.trim()) });
                     case "load": return internal.activeset_load.execute({ set_id: args.target });
-                    case "add": return internal.activeset_add_chunks.execute({ chunk_ids: args.target?.split(',').map(s => s.trim()) });
-                    case "remove": return internal.activeset_remove_chunks.execute({ chunk_ids: args.target?.split(',').map(s => s.trim()) });
+                    case "add": return internal.activeset_add_chunks.execute({ chunk_ids: args.target?.split(',').map((s) => s.trim()) });
+                    case "remove": return internal.activeset_remove_chunks.execute({ chunk_ids: args.target?.split(',').map((s) => s.trim()) });
                     case "evict": {
                         const lru = getDb().getLruChunks(args.limit);
                         return internal.activeset_remove_chunks.execute({ chunk_ids: lru.map(c => c.chunk_id) });
@@ -126,7 +170,7 @@ export function unifiedTools() {
                 }
             }
         }),
-        code_read: tool({
+        code_read: wrap("code_read", {
             description: "Precise reading of symbols or file slices. Follows current plan. Checks for locks and returns historical graffiti.",
             args: {
                 symbol: tool.schema.string().optional().describe("Symbol to jump to"),
@@ -140,9 +184,7 @@ export function unifiedTools() {
                 if (resourceId) {
                     getDb().logAccess(resourceId, args.plan_id);
                     const lock = getDb().isLocked(resourceId);
-                    // Smart History Housekeeping
-                    const graffiti = getDb().getGraffiti(resourceId, 3); // Limit to top 3 recent/pinned notes
-                    // Contextual Verification: Get current hash
+                    const graffiti = getDb().getGraffiti(resourceId, 3);
                     let currentHash = "";
                     try {
                         const { execSync } = await import("node:child_process");
@@ -175,11 +217,11 @@ export function unifiedTools() {
                 throw new Error("Either 'symbol' or 'file' must be provided.");
             }
         }),
-        code_propose: tool({
+        code_propose: wrap("code_propose", {
             description: "Plan, propose, and promote changes. Automatically handles coordination pulse and lock checks.",
             args: {
                 action: tool.schema.enum(["plan", "patch", "validate", "finalize", "promote"]),
-                symbol: tool.schema.string().optional(),
+                symbol: tool.schema.string().optional().describe("Locus symbol for plan"),
                 intent: tool.schema.string().optional(),
                 reasoning: tool.schema.string().optional(),
                 message: tool.schema.string().optional(),
@@ -218,8 +260,22 @@ export function unifiedTools() {
                         return res;
                     }
                     case "validate": {
-                        getDb().postToBlackboard(agentName, `Validating patch ${args.patch_path}`, "pulse");
-                        return internal.validate_patch.execute({ patch_path: args.patch_path, plan_id: args.plan_id });
+                        const { stdout: diff } = await internal.runCmd("git diff --name-only");
+                        const changedFiles = diff.split('\n').filter(Boolean);
+                        for (const file of changedFiles) {
+                            const deps = await internal.extractDependencies.execute({ content: "", ast: null, filePath: file });
+                            const imports = JSON.parse(deps);
+                            for (const imp of imports) {
+                                const violation = getDb().checkArchViolation(file, imp);
+                                if (violation)
+                                    return JSON.stringify({ status: "ARCH_VIOLATION", file, forbidden_import: imp, rule: violation }, null, 2);
+                            }
+                        }
+                        let focusTests = [];
+                        if (args.symbol)
+                            focusTests = getDb().findAffectedTests(args.symbol);
+                        getDb().postToBlackboard(agentName, `Validating patch ${args.patch_path}. Scoped tests: ${focusTests.length}`, "pulse");
+                        return internal.validate_patch.execute({ patch_path: args.patch_path, plan_id: args.plan_id, tests: focusTests });
                     }
                     case "promote": {
                         const branch = args.branch || `autognosis-fix-${Date.now()}`;
@@ -243,13 +299,13 @@ export function unifiedTools() {
                 }
             }
         }),
-        code_status: tool({
-            description: "Monitor system health, Multi-Agent Blackboard, and Resource Locks.",
+        code_status: wrap("code_status", {
+            description: "Monitor system health, background jobs, Multi-Agent Blackboard, and Resource Locks.",
             args: {
-                mode: tool.schema.enum(["stats", "hot_files", "jobs", "plan", "doctor", "blackboard", "locks"]).optional().default("stats"),
+                mode: tool.schema.enum(["stats", "hot_files", "jobs", "plan", "doctor", "blackboard", "locks", "dashboard"]).optional().default("stats"),
                 action: tool.schema.enum(["post", "read", "lock", "unlock", "archive", "pin"]).optional(),
                 topic: tool.schema.string().optional().default("general"),
-                target: tool.schema.string().optional().describe("Resource ID (file/symbol) or Note ID"),
+                target: tool.schema.string().optional().describe("Resource ID or Note ID"),
                 pinned: tool.schema.boolean().optional().default(false),
                 message: tool.schema.string().optional(),
                 job_id: tool.schema.string().optional(),
@@ -258,6 +314,25 @@ export function unifiedTools() {
             },
             async execute(args) {
                 switch (args.mode) {
+                    case "dashboard": {
+                        const stats = getDb().getStats();
+                        const locks = getDb().listLocks();
+                        const jobs = getDb().listJobs();
+                        const compliance = args.plan_id ? getDb().getPlanMetrics(args.plan_id) : null;
+                        let dashboard = `# Autognosis TUI Dashboard\n\n`;
+                        dashboard += `## 📊 System Stats\n- Files: ${stats.files}\n- Chunks: ${stats.chunks}\n- Embedded: ${stats.embeddings.completed}/${stats.chunks}\n\n`;
+                        dashboard += `## 🔒 Active Locks\n`;
+                        if (locks.length > 0)
+                            dashboard += locks.map(l => `- ${l.resource_id} (${l.owner_agent})`).join('\n') + '\n\n';
+                        else
+                            dashboard += "_No active locks._\n\n";
+                        dashboard += `## ⚙️ Recent Jobs\n`;
+                        dashboard += jobs.map(j => `- [${j.status.toUpperCase()}] ${j.type} (${j.progress}%)`).join('\n') + '\n\n';
+                        if (compliance) {
+                            dashboard += `## 📉 Plan Compliance (${args.plan_id})\n- Score: ${compliance.compliance}%\n- Total Calls: ${compliance.total}\n- Off-Plan: ${compliance.off_plan}\n`;
+                        }
+                        return dashboard;
+                    }
                     case "locks": {
                         if (args.action === "lock") {
                             getDb().acquireLock(args.target, agentName);
@@ -300,8 +375,8 @@ export function unifiedTools() {
                 }
             }
         }),
-        code_setup: tool({
-            description: "Setup and maintenance tasks (AI, Git Journal, Indexing, Prompt Scouting, Arch Boundaries).",
+        code_setup: wrap("code_setup", {
+            description: "Setup tasks (AI, Git Journal, Indexing, Prompt Scouting, Arch Boundaries).",
             args: {
                 action: tool.schema.enum(["init", "ai", "index", "journal", "scout", "arch_rule"]),
                 provider: tool.schema.enum(["ollama", "mlx"]).optional().default("ollama"),
@@ -327,6 +402,24 @@ export function unifiedTools() {
                 }
             }
         }),
+        code_contract: wrap("code_contract", {
+            description: "Register reactive tool contracts for automated post-execution chaining.",
+            args: {
+                action: tool.schema.enum(["register", "list", "delete"]),
+                trigger_tool: tool.schema.string().optional().describe("Tool that triggers the contract"),
+                trigger_action: tool.schema.string().optional().describe("Action that triggers the contract"),
+                target_tool: tool.schema.string().optional().describe("Tool to execute automatically"),
+                target_args: tool.schema.any().optional().describe("Arguments for the target tool")
+            },
+            async execute(args) {
+                if (args.action === "register") {
+                    getDb().registerContract(args.trigger_tool, args.trigger_action, args.target_tool, args.target_args);
+                    return JSON.stringify({ status: "SUCCESS", message: "Contract registered." });
+                }
+                // List/Delete placeholders
+                return JSON.stringify({ status: "SUCCESS", message: "Action completed." });
+            }
+        }),
         internal_call: tool({
             description: "Advanced access to specialized internal tools.",
             args: { tool_name: tool.schema.string(), args: tool.schema.any() },
@@ -337,5 +430,6 @@ export function unifiedTools() {
                 return target.execute(args);
             }
         })
-    };
+    });
+    return api;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-autognosis",
-  "version": "2.3.1",
+  "version": "2.5.0",
   "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",