opencode-autognosis 2.4.0 → 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;

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);

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.4)
+## 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 management and LRU eviction.
 - code_read: Precise reading with Mutex Lock checks and Graffiti retrieval.
-- code_propose: Planning, patching, validation, and PR promotion. Now features surgical test scoping.
+- code_propose: Planning, patching, validation, and PR promotion.
 - code_status: Dashboard, background jobs, blackboard, and resource locks.
-- code_setup: Environment initialization and architectural boundaries.
+- 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"),
@@ -173,8 +217,8 @@ export function unifiedTools() {
                 throw new Error("Either 'symbol' or 'file' must be provided.");
             }
         }),
-        code_propose: tool({
-            description: "Plan, propose, and promote changes. Includes patch generation, surgical test scoping, and PR promotion.",
+        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().describe("Locus symbol for plan"),
@@ -216,7 +260,6 @@ export function unifiedTools() {
                         return res;
                     }
                     case "validate": {
-                        // 1. Arch Check
                         const { stdout: diff } = await internal.runCmd("git diff --name-only");
                         const changedFiles = diff.split('\n').filter(Boolean);
                         for (const file of changedFiles) {
@@ -228,13 +271,10 @@ export function unifiedTools() {
                                     return JSON.stringify({ status: "ARCH_VIOLATION", file, forbidden_import: imp, rule: violation }, null, 2);
                             }
                         }
-                        // 2. Surgical Test Scoping
                         let focusTests = [];
-                        if (args.symbol) {
+                        if (args.symbol)
                             focusTests = getDb().findAffectedTests(args.symbol);
-                        }
                         getDb().postToBlackboard(agentName, `Validating patch ${args.patch_path}. Scoped tests: ${focusTests.length}`, "pulse");
-                        // Call validation with scoped tests hint
                         return internal.validate_patch.execute({ patch_path: args.patch_path, plan_id: args.plan_id, tests: focusTests });
                     }
                     case "promote": {
@@ -259,7 +299,7 @@ export function unifiedTools() {
                 }
             }
         }),
-        code_status: tool({
+        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", "dashboard"]).optional().default("stats"),
@@ -283,11 +323,11 @@ export function unifiedTools() {
                         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';
+                            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';
+                        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`;
                         }
@@ -335,15 +375,15 @@ export function unifiedTools() {
                 }
             }
         }),
-        code_setup: tool({
+        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"),
                 model: tool.schema.string().optional(),
                 limit: tool.schema.number().optional(),
-                source: tool.schema.string().optional(),
-                target: tool.schema.string().optional()
+                source: tool.schema.string().optional().describe("Source target pattern"),
+                target: tool.schema.string().optional().describe("Target target pattern (forbidden)")
             },
             async execute(args) {
                 switch (args.action) {
@@ -362,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() },
@@ -372,5 +430,6 @@ export function unifiedTools() {
                 return target.execute(args);
             }
         })
-    };
+    });
+    return api;
 }

package/package.json

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