opencode-autognosis 2.0.4 → 2.2.0

package/dist/services/mlx.js

@@ -0,0 +1,53 @@
+import { exec } 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_MLX_MODEL = "sentence-transformers/all-MiniLM-L6-v2";
+export class MLXService {
+    isAvailable = null;
+    async checkAvailability() {
+        if (this.isAvailable !== null)
+            return this.isAvailable;
+        try {
+            await execAsync('python3 -c "import mlx.core; import sentence_transformers"');
+            this.isAvailable = true;
+        }
+        catch {
+            this.isAvailable = false;
+        }
+        return this.isAvailable;
+    }
+    async setup() {
+        try {
+            Logger.log("MLX", "Setting up MLX dependencies...");
+            await execAsync("pip3 install mlx sentence-transformers huggingface_hub");
+            this.isAvailable = true;
+            return "MLX and sentence-transformers installed successfully.";
+        }
+        catch (error) {
+            throw new Error(`MLX setup failed: ${error.message}`);
+        }
+    }
+    async getEmbedding(text, model = DEFAULT_MLX_MODEL) {
+        if (!text || !text.trim())
+            return [];
+        // Escape text for python string
+        const escapedText = text.replace(/"/g, '\\"').replace(/\n/g, ' ');
+        // MLX optimized sentence-transformers execution
+        const pyScript = "\nimport mlx.core as mx\nfrom sentence_transformers import SentenceTransformer\nimport json\nimport sys\n\ntry:\n    model = SentenceTransformer(\"${model}\")\n    # Move to GPU if available (MLX default)\n    embeddings = model.encode([\"${escapedText}\"])\n    print(json.dumps(embeddings[0].tolist()))\nexcept Exception as e:\n    print(json.dumps({\"error\": str(e)}))\n    sys.exit(1)\n";
+        try {
+            const { stdout } = await execAsync(`python3 -c '${pyScript}'`);
+            const result = JSON.parse(stdout);
+            if (result.error)
+                throw new Error(result.error);
+            return result;
+        }
+        catch (error) {
+            Logger.log("MLX", "Embedding failed", error);
+            return [];
+        }
+    }
+}
+export const mlxService = new MLXService();

package/dist/services/policy.d.ts

@@ -0,0 +1,12 @@
+export interface PolicyViolation {
+    file: string;
+    line: number;
+    message: string;
+    severity: "error" | "warning";
+}
+export declare class PolicyEngine {
+    private rules;
+    checkContent(file: string, content: string): PolicyViolation[];
+    checkDiff(diff: string): PolicyViolation[];
+}
+export declare const policyEngine: PolicyEngine;

package/dist/services/policy.js

@@ -0,0 +1,59 @@
+import * as fsSync from "node:fs";
+import * as path from "node:path";
+import { Logger } from "./logger.js";
+export class PolicyEngine {
+    rules = [
+        {
+            name: "No Debug Logs",
+            pattern: /console\.(log|debug|info)\(/,
+            message: "Direct console logging is forbidden in production code.",
+            severity: "error"
+        },
+        {
+            name: "No TODO Debt",
+            pattern: /\/\/\s*TODO/,
+            message: "New TODOs must be linked to a ticket ID.",
+            severity: "warning"
+        },
+        {
+            name: "Forbidden Eval",
+            pattern: /eval\(/,
+            message: "Use of 'eval' is strictly forbidden for security reasons.",
+            severity: "error"
+        }
+    ];
+    checkContent(file, content) {
+        const violations = [];
+        const lines = content.split('\n');
+        for (const rule of this.rules) {
+            lines.forEach((line, index) => {
+                if (rule.pattern.test(line)) {
+                    violations.push({
+                        file,
+                        line: index + 1,
+                        message: rule.message,
+                        severity: rule.severity
+                    });
+                }
+            });
+        }
+        return violations;
+    }
+    checkDiff(diff) {
+        // Check only added lines in diffs
+        const addedLines = diff.split('\n').filter(l => l.startsWith('+') && !l.startsWith('+++'));
+        const violations = [];
+        for (const rule of this.rules) {
+            if (rule.pattern.test(addedLines.join('\n'))) {
+                violations.push({
+                    file: "diff",
+                    line: 0,
+                    message: `[Policy: ${rule.name}] ${rule.message}`,
+                    severity: rule.severity
+                });
+            }
+        }
+        return violations;
+    }
+}
+export const policyEngine = new PolicyEngine();

package/dist/services/tui.d.ts

@@ -0,0 +1,8 @@
+export declare class TUIService {
+    private client;
+    setClient(client: any): void;
+    showProgress(title: string, progress: number, message: string): Promise<void>;
+    showSuccess(title: string, message: string): Promise<void>;
+    showError(title: string, message: string): Promise<void>;
+}
+export declare const tui: TUIService;

package/dist/services/tui.js

@@ -0,0 +1,43 @@
+export class TUIService {
+    client;
+    setClient(client) {
+        this.client = client;
+    }
+    async showProgress(title, progress, message) {
+        if (!this.client)
+            return;
+        try {
+            await this.client.tui.showToast({
+                body: {
+                    title: `[${progress}%] ${title}`,
+                    message,
+                    variant: "info"
+                }
+            });
+        }
+        catch (e) {
+            // Ignore if TUI not available
+        }
+    }
+    async showSuccess(title, message) {
+        if (!this.client)
+            return;
+        try {
+            await this.client.tui.showToast({
+                body: { title, message, variant: "success" }
+            });
+        }
+        catch (e) { }
+    }
+    async showError(title, message) {
+        if (!this.client)
+            return;
+        try {
+            await this.client.tui.showToast({
+                body: { title, message, variant: "error" }
+            });
+        }
+        catch (e) { }
+    }
+}
+export const tui = new TUIService();

package/dist/services/watcher.d.ts

@@ -0,0 +1,8 @@
+export declare class CodeWatcher {
+    private watcher;
+    start(): void;
+    stop(): void;
+    private handleFileChange;
+    private handleFileDelete;
+}
+export declare const codeWatcher: CodeWatcher;

package/dist/services/watcher.js

@@ -0,0 +1,50 @@
+import chokidar, { FSWatcher } from "chokidar";
+import * as path from "node:path";
+import { indexFile } from "../performance-optimization.js";
+import { Logger } from "./logger.js";
+const PROJECT_ROOT = process.cwd();
+export class CodeWatcher {
+    watcher = null;
+    start() {
+        if (this.watcher)
+            return;
+        Logger.log("Watcher", "Starting live codebase watcher...");
+        this.watcher = chokidar.watch(PROJECT_ROOT, {
+            ignored: [
+                "**/node_modules/**",
+                "**/dist/**",
+                "**/build/**",
+                "**/.opencode/**"
+            ],
+            persistent: true,
+            ignoreInitial: true
+        });
+        this.watcher
+            .on("add", (filePath) => this.handleFileChange("added", filePath))
+            .on("change", (filePath) => this.handleFileChange("changed", filePath))
+            .on("unlink", (filePath) => this.handleFileDelete(filePath));
+    }
+    stop() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+    }
+    async handleFileChange(event, filePath) {
+        const ext = path.extname(filePath);
+        const supportedExts = [".ts", ".js", ".tsx", ".jsx", ".cpp", ".c", ".h", ".hpp", ".swift", ".py", ".go", ".rs"];
+        if (supportedExts.includes(ext)) {
+            Logger.log("Watcher", `File ${event}: ${filePath}`);
+            try {
+                await indexFile(filePath);
+            }
+            catch (e) {
+                Logger.log("Watcher", `Failed to index ${filePath}`, e);
+            }
+        }
+    }
+    handleFileDelete(filePath) {
+        Logger.log("Watcher", `File deleted: ${filePath}`);
+    }
+}
+export const codeWatcher = new CodeWatcher();

package/dist/system-tools.js

@@ -7,6 +7,7 @@ import { promisify } from "node:util";
 import * as crypto from "node:crypto";
 import { Logger } from "./services/logger.js";
 import { getDb } from "./database.js";
+import { tui } from "./services/tui.js";
 const execAsync = promisify(exec);
 const PROJECT_ROOT = process.cwd();
 const OPENCODE_DIR = path.join(PROJECT_ROOT, ".opencode");
@@ -305,10 +306,12 @@ export function systemTools() {
                 // Spawn background worker
                 (async () => {
                     getDb().updateJob(jobId, { status: "running", progress: 10 });
+                    await tui.showProgress("Patch Validation", 10, "Creating temporary worktree...");
                     const tempWorktree = path.join(PROJECT_ROOT, ".opencode", "temp-" + jobId);
                     try {
                         await runCmd(`git worktree add -d "${tempWorktree}"`);
                         getDb().updateJob(jobId, { progress: 30 });
+                        await tui.showProgress("Patch Validation", 30, "Applying diff...");
                         const content = await fs.readFile(patch_path, "utf-8");
                         const parts = content.split('\n\n');
                         const diffOnly = parts.length > 1 ? parts.slice(1).join('\n\n') : content;
@@ -318,6 +321,7 @@ export function systemTools() {
                         if (applyError)
                             throw new Error(`Apply failed: ${applyError.message}`);
                         getDb().updateJob(jobId, { progress: 60 });
+                        await tui.showProgress("Patch Validation", 60, "Running build verification...");
                         let buildStatus = "SKIPPED";
                         if (fsSync.existsSync(path.join(tempWorktree, "package.json"))) {
                             const { error: buildError } = await runCmd("npm run build", tempWorktree);
@@ -332,9 +336,11 @@ export function systemTools() {
                             progress: 100,
                             result: JSON.stringify({ apply: "OK", build: buildStatus })
                         });
+                        await tui.showSuccess("Validation Complete", `Apply: OK, Build: ${buildStatus}`);
                     }
                     catch (error) {
                         getDb().updateJob(jobId, { status: "failed", error: error.message });
+                        await tui.showError("Validation Failed", error.message);
                     }
                     finally {
                         try {

package/dist/unified-api.js

@@ -1,10 +1,14 @@
 import { tool } from "@opencode-ai/plugin";
+import * as fsSync from "node:fs";
+import * as path from "node:path";
 import { systemTools } from "./system-tools.js";
 import { activeSetTools } from "./activeset.js";
 import { chunkCardsTools } from "./chunk-cards.js";
 import { moduleSummariesTools } from "./module-summaries.js";
 import { performanceTools } from "./performance-optimization.js";
-import { graphTools } from "./database.js";
+import { graphTools, getDb } from "./database.js";
+import { policyEngine } from "./services/policy.js";
+const PROJECT_ROOT = process.cwd();
 // Aggregate all internal tools
 const internal = {
     ...systemTools(),
@@ -14,6 +18,50 @@ const internal = {
     ...performanceTools(),
     ...graphTools(),
 };
+async function scoutPlugins() {
+    const plugins = new Set();
+    try {
+        const config = JSON.parse(fsSync.readFileSync(path.join(PROJECT_ROOT, "opencode.jsonc"), "utf-8"));
+        if (config.plugin)
+            config.plugin.forEach((p) => plugins.add(p));
+    }
+    catch { } // Ignore errors if config file doesn't exist
+    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
+    return Array.from(plugins);
+}
+async function updateBridgePrompt(plugins) {
+    const bridgePath = "/Users/user/.config/opencode/prompts/bridge.md";
+    if (!fsSync.existsSync(bridgePath))
+        return "bridge.md not found at " + bridgePath;
+    const toolsSection = `
+## Current Consolidated Tools (Autognosis v2.2)
+- code_search: Universal search (semantic, symbol, filename, content).
+- code_analyze: Deep structural analysis and impact reports.
+- code_context: Working memory (ActiveSet) management and LRU eviction.
+- code_read: Precise symbol jumping and file slicing.
+- code_propose: Planning, patch generation, PR promotion, and Intent indexing.
+- code_status: System health, background jobs, compliance, and Multi-Agent Blackboard.
+- code_setup: Environment initialization, AI setup, and Architectural Boundaries.
+
+## Other Detected Plugins
+${plugins.filter(p => p !== "opencode-autognosis").map(p => `- ${p}`).join('\n')}
+`;
+    let content = fsSync.readFileSync(bridgePath, "utf-8");
+    if (content.includes("## Current Consolidated Tools")) {
+        content = content.replace(/## Current Consolidated Tools[\s\S]*?(?=\n#|$)/, toolsSection);
+    }
+    else {
+        content += "\n" + toolsSection;
+    }
+    fsSync.writeFileSync(bridgePath, content);
+    return "Updated bridge.md with consolidated tools and detected plugins.";
+}
 export function unifiedTools() {
     return {
         code_search: tool({
@@ -38,7 +86,7 @@ export function unifiedTools() {
             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"),
-                mode: tool.schema.enum(["summary", "api", "invariant", "module", "impact", "reasoning"]).optional().default("summary"),
+                mode: tool.schema.enum(["summary", "api", "invariant", "module", "impact", "reasoning", "callers"]).optional().default("summary"),
                 force: tool.schema.boolean().optional().default(false),
                 plan_id: tool.schema.string().optional()
             },
@@ -47,6 +95,7 @@ export function unifiedTools() {
                     case "module": return internal.module_synthesize.execute({ file_path: args.target, force_resynthesize: args.force });
                     case "impact": return internal.brief_fix_loop.execute({ symbol: args.target, intent: "impact_analysis" });
                     case "reasoning": return internal.module_hierarchical_reasoning.execute({ module_id: args.target });
+                    case "callers": return internal.graph_search_symbols.execute({ query: args.target });
                     default: return internal.chunk_create_card.execute({ file_path: args.target, chunk_type: args.mode, force_recreate: args.force });
                 }
             }
@@ -54,18 +103,22 @@ export function unifiedTools() {
         code_context: tool({
             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"]),
-                target: tool.schema.string().optional().describe("ActiveSet ID or Chunk IDs (comma separated)"),
-                name: tool.schema.string().optional().describe("Name for new ActiveSet"),
+                action: tool.schema.enum(["create", "load", "add", "remove", "status", "list", "close", "evict"]),
+                target: tool.schema.string().optional().describe("ActiveSet ID or Chunk IDs"),
+                name: tool.schema.string().optional(),
+                limit: tool.schema.number().optional().default(5).describe("Eviction limit"),
                 plan_id: tool.schema.string().optional()
             },
             async execute(args) {
-                const chunk_ids = args.target?.split(',').map(s => s.trim());
                 switch (args.action) {
-                    case "create": return internal.activeset_create.execute({ name: args.name || "Context", chunk_ids });
+                    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: chunk_ids });
-                    case "remove": return internal.activeset_remove_chunks.execute({ chunk_ids: chunk_ids });
+                    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) });
+                    }
                     case "list": return internal.activeset_list.execute({});
                     case "close": return internal.activeset_close.execute({});
                     default: return internal.activeset_get_current.execute({});
@@ -82,73 +135,145 @@ export function unifiedTools() {
                 plan_id: tool.schema.string().optional()
             },
             async execute(args) {
-                if (args.symbol)
+                if (args.symbol) {
+                    getDb().logAccess(args.symbol, args.plan_id);
                     return internal.jump_to_symbol.execute({ symbol: args.symbol, plan_id: args.plan_id });
+                }
                 if (args.file && args.start_line && args.end_line) {
+                    getDb().logAccess(args.file, args.plan_id);
                     return internal.read_slice.execute({ file: args.file, start_line: args.start_line, end_line: args.end_line, plan_id: args.plan_id });
                 }
                 throw new Error("Either 'symbol' or 'file' with line range must be provided.");
             }
         }),
         code_propose: tool({
-            description: "Plan and propose changes. Generates worklists, diffs, and validates them.",
+            description: "Plan, propose, and promote changes. Includes patch generation, Intent indexing, and PR promotion.",
             args: {
-                action: tool.schema.enum(["plan", "patch", "validate", "finalize"]),
-                symbol: tool.schema.string().optional().describe("Locus symbol for plan"),
-                intent: tool.schema.string().optional().describe("Work intent (e.g. refactor)"),
-                message: tool.schema.string().optional().describe("Commit message for patch"),
-                patch_path: tool.schema.string().optional().describe("Path to .diff file"),
+                action: tool.schema.enum(["plan", "patch", "validate", "finalize", "promote"]),
+                symbol: tool.schema.string().optional(),
+                intent: tool.schema.string().optional(),
+                reasoning: tool.schema.string().optional().describe("Detailed reasoning for the change (Decision Indexing)"),
+                message: tool.schema.string().optional(),
+                patch_path: tool.schema.string().optional(),
+                branch: tool.schema.string().optional(),
                 plan_id: tool.schema.string().optional(),
                 outcome: tool.schema.string().optional()
             },
             async execute(args) {
                 switch (args.action) {
                     case "plan": return internal.brief_fix_loop.execute({ symbol: args.symbol, intent: args.intent });
-                    case "patch": return internal.prepare_patch.execute({ message: args.message, plan_id: args.plan_id });
-                    case "validate": return internal.validate_patch.execute({ patch_path: args.patch_path, plan_id: args.plan_id });
+                    case "patch": {
+                        const { stdout: diff } = await internal.runCmd("git diff");
+                        const violations = policyEngine.checkDiff(diff);
+                        if (violations.some(v => v.severity === "error")) {
+                            return JSON.stringify({ status: "POLICY_VIOLATION", violations, message: "Patch rejected by policy engine." }, null, 2);
+                        }
+                        const res = await internal.prepare_patch.execute({ message: args.message, plan_id: args.plan_id });
+                        const json = JSON.parse(res);
+                        if (json.status === "SUCCESS" && args.reasoning) {
+                            getDb().storeIntent(json.patch_id, args.reasoning, args.plan_id || "adhoc");
+                        }
+                        return res;
+                    }
+                    case "validate": {
+                        // Architectural Boundary Check
+                        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);
+                            }
+                        }
+                        return internal.validate_patch.execute({ patch_path: args.patch_path, plan_id: args.plan_id });
+                    }
+                    case "promote": {
+                        const branch = args.branch || `autognosis-fix-${Date.now()}`;
+                        const { execSync } = await import("node:child_process");
+                        try {
+                            execSync(`git checkout -b ${branch}`);
+                            execSync(`git apply ${args.patch_path}`);
+                            execSync(`git add . && git commit -m "${args.message || 'Automated promotion'}"`);
+                            execSync(`gh pr create --title "${args.message}" --body "Automated promotion from Autognosis v2."`);
+                            return JSON.stringify({ status: "SUCCESS", promoted_to: branch, pr: "OPENED" }, null, 2);
+                        }
+                        catch (e) {
+                            return JSON.stringify({ status: "ERROR", message: e.message }, null, 2);
+                        }
+                    }
                     case "finalize": return internal.finalize_plan.execute({ plan_id: args.plan_id, outcome: args.outcome });
                 }
             }
         }),
         code_status: tool({
-            description: "Monitor system health, background jobs, and plan metrics.",
+            description: "Monitor system health, background jobs, compliance, and Multi-Agent Blackboard.",
             args: {
-                mode: tool.schema.enum(["stats", "hot_files", "jobs", "plan"]).optional().default("stats"),
+                mode: tool.schema.enum(["stats", "hot_files", "jobs", "plan", "doctor", "blackboard"]).optional().default("stats"),
+                action: tool.schema.enum(["post", "read"]).optional(),
+                topic: tool.schema.string().optional().default("general"),
+                message: tool.schema.string().optional(),
                 job_id: tool.schema.string().optional(),
                 plan_id: tool.schema.string().optional(),
                 path: tool.schema.string().optional().default("")
             },
             async execute(args) {
                 switch (args.mode) {
+                    case "blackboard": {
+                        if (args.action === "post") {
+                            getDb().postToBlackboard("Agent", args.message, args.topic);
+                            return JSON.stringify({ status: "SUCCESS", message: "Posted to blackboard." });
+                        }
+                        return JSON.stringify({ status: "SUCCESS", entries: getDb().readBlackboard(args.topic) });
+                    }
                     case "hot_files": return internal.journal_query_hot_files.execute({ path_prefix: args.path });
                     case "jobs": return internal.graph_background_status.execute({ job_id: args.job_id });
                     case "plan": return internal.graph_get_plan_metrics.execute({ plan_id: args.plan_id });
+                    case "doctor": {
+                        const stats = getDb().getStats();
+                        let logSnippet = "";
+                        try {
+                            logSnippet = fsSync.readFileSync(path.join(PROJECT_ROOT, ".opencode", "logs", "autognosis.log"), "utf-8").split('\n').slice(-20).join('\n');
+                        }
+                        catch (e) { }
+                        return JSON.stringify({ status: "HEALTHY", stats, recent_logs: logSnippet }, null, 2);
+                    }
                     default: return internal.graph_stats.execute({});
                 }
             }
         }),
         code_setup: tool({
-            description: "One-time setup and maintenance tasks (AI, Git Journal, Indexing).",
+            description: "Setup and maintenance tasks (AI, Git Journal, Indexing, Prompt Scouting, Arch Boundaries).",
             args: {
-                action: tool.schema.enum(["init", "ai", "index", "journal"]),
-                model: tool.schema.string().optional().describe("AI Model name"),
-                limit: tool.schema.number().optional().describe("History limit")
+                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().describe("Source target pattern"),
+                target: tool.schema.string().optional().describe("Target target pattern (forbidden)")
             },
             async execute(args) {
                 switch (args.action) {
-                    case "ai": return internal.autognosis_setup_ai.execute({ model: args.model });
+                    case "arch_rule": {
+                        getDb().addArchRule(args.source, args.target);
+                        return JSON.stringify({ status: "SUCCESS", message: `Architecture rule added: ${args.source} cannot import ${args.target}` });
+                    }
+                    case "ai": return internal.autognosis_setup_ai.execute({ provider: args.provider, model: args.model });
                     case "index": return internal.perf_incremental_index.execute({ background: true });
                     case "journal": return internal.journal_build.execute({ limit: args.limit });
-                    default: return internal.autognosis_init.execute({ mode: "apply", token: "adhoc" }); // Simplified
+                    case "scout": {
+                        const plugins = await scoutPlugins();
+                        return updateBridgePrompt(plugins);
+                    }
+                    default: return internal.autognosis_init.execute({ mode: "apply", token: "adhoc" });
                 }
             }
         }),
         internal_call: tool({
-            description: "Advanced access to specialized internal tools. Use only when unified tools are insufficient.",
-            args: {
-                tool_name: tool.schema.string().describe("Internal tool name"),
-                args: tool.schema.any().describe("Arguments for the internal tool")
-            },
+            description: "Advanced access to specialized internal tools.",
+            args: { tool_name: tool.schema.string(), args: tool.schema.any() },
             async execute({ tool_name, args }) {
                 const target = internal[tool_name];
                 if (!target)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-autognosis",
-  "version": "2.0.4",
+  "version": "2.2.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",
@@ -48,10 +48,12 @@
     "@opencode-ai/sdk": "^1.1.40",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^20.0.0",
+    "bun-types": "^1.3.8",
     "typescript": "^5.0.0",
     "zod": "^4.3.6"
   },
   "dependencies": {
-    "better-sqlite3": "^12.6.2"
+    "better-sqlite3": "^12.6.2",
+    "chokidar": "^5.0.0"
   }
 }