opencode-autognosis 0.1.5 → 1.0.1

package/dist/index.d.ts

@@ -1 +1,5 @@
-export {};
+export default function plugin(): {
+    tools: {
+        [key: string]: any;
+    };
+};

package/dist/index.js

@@ -1,80 +1,8 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
 import { systemTools } from "./system-tools.js";
-async function main() {
-    const server = new McpServer({
-        name: "opencode-autognosis",
-        version: "0.1.5",
-    });
-    const tools = systemTools();
-    const register = (toolName, zodSchema) => {
-        const toolDef = tools[toolName];
-        server.registerTool(toolName, {
-            description: toolDef.description,
-            inputSchema: zodSchema,
-        }, async (args) => {
-            try {
-                const result = await toolDef.execute(args);
-                return {
-                    content: [{ type: "text", text: typeof result === 'string' ? result : JSON.stringify(result, null, 2) }],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [{ type: "text", text: `Error: ${error.message}` }],
-                    isError: true,
-                };
-            }
-        });
+export default function plugin() {
+    return {
+        tools: {
+            ...systemTools(),
+        },
     };
-    register("fast_search", z.object({
-        query: z.string(),
-        mode: z.enum(["filename", "content"]).optional().default("filename"),
-        path: z.string().optional().default(".")
-    }).shape);
-    register("structural_search", z.object({
-        pattern: z.string(),
-        path: z.string().optional().default("."),
-        plan_id: z.string().optional()
-    }).shape);
-    register("read_slice", z.object({
-        file: z.string(),
-        start_line: z.number(),
-        end_line: z.number(),
-        plan_id: z.string().optional()
-    }).shape);
-    register("symbol_query", z.object({
-        symbol: z.string()
-    }).shape);
-    register("jump_to_symbol", z.object({
-        symbol: z.string(),
-        plan_id: z.string().optional()
-    }).shape);
-    register("autognosis_init", z.object({
-        mode: z.enum(["plan", "apply"]).optional().default("plan"),
-        token: z.string().optional()
-    }).shape);
-    register("brief_fix_loop", z.object({
-        symbol: z.string(),
-        intent: z.string()
-    }).shape);
-    register("prepare_patch", z.object({
-        plan_id: z.string().optional(),
-        message: z.string()
-    }).shape);
-    register("validate_patch", z.object({
-        patch_path: z.string(),
-        timeout_ms: z.number().optional().default(30000)
-    }).shape);
-    register("finalize_plan", z.object({
-        plan_id: z.string(),
-        outcome: z.string()
-    }).shape);
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
 }
-main().catch((error) => {
-    console.error("Fatal error in Autognosis MCP Server:", error);
-    process.exit(1);
-});

package/dist/services/logger.d.ts

@@ -0,0 +1 @@
+export declare function log(message: string, data?: unknown): void;

package/dist/services/logger.js

@@ -0,0 +1,17 @@
+import { appendFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const LOG_FILE = join(homedir(), ".opencode-autognosis.log");
+// Start a fresh session block
+writeFileSync(LOG_FILE, `
+--- Autognosis Session started: ${new Date().toISOString()} ---
+`, { flag: "a" });
+export function log(message, data) {
+    const timestamp = new Date().toISOString();
+    const line = data
+        ? `[${timestamp}] ${message}: ${JSON.stringify(data)}
+`
+        : `[${timestamp}] ${message}
+`;
+    appendFileSync(LOG_FILE, line);
+}

package/dist/system-tools.d.ts

@@ -1,210 +1,3 @@
 export declare function systemTools(): {
-    autognosis_init: {
-        description: string;
-        parameters: {
-            type: string;
-            properties: {
-                mode: {
-                    type: string;
-                    enum: string[];
-                    default: string;
-                };
-                token: {
-                    type: string;
-                };
-            };
-            required: string[];
-        };
-        execute: ({ mode, token }: {
-            mode: string;
-            token?: string;
-        }) => Promise<string | undefined>;
-    };
-    fast_search: {
-        description: string;
-        parameters: {
-            type: string;
-            properties: {
-                query: {
-                    type: string;
-                };
-                mode: {
-                    type: string;
-                    enum: string[];
-                    default: string;
-                };
-                path: {
-                    type: string;
-                };
-            };
-            required: string[];
-        };
-        execute: ({ query, mode, path: searchPath }: {
-            query: string;
-            mode?: string;
-            path?: string;
-        }) => Promise<string>;
-    };
-    structural_search: {
-        description: string;
-        parameters: {
-            type: string;
-            properties: {
-                pattern: {
-                    type: string;
-                };
-                path: {
-                    type: string;
-                    default: string;
-                };
-                plan_id: {
-                    type: string;
-                };
-            };
-            required: string[];
-        };
-        execute: ({ pattern, path: searchPath, plan_id }: {
-            pattern: string;
-            path?: string;
-            plan_id?: string;
-        }) => Promise<string>;
-    };
-    read_slice: {
-        description: string;
-        parameters: {
-            type: string;
-            properties: {
-                file: {
-                    type: string;
-                };
-                start_line: {
-                    type: string;
-                };
-                end_line: {
-                    type: string;
-                };
-                plan_id: {
-                    type: string;
-                };
-            };
-            required: string[];
-        };
-        execute: ({ file, start_line, end_line, plan_id }: {
-            file: string;
-            start_line: number;
-            end_line: number;
-            plan_id?: string;
-        }) => Promise<string>;
-    };
-    symbol_query: {
-        description: string;
-        parameters: {
-            type: string;
-            properties: {
-                symbol: {
-                    type: string;
-                };
-            };
-            required: string[];
-        };
-        execute: ({ symbol }: {
-            symbol: string;
-        }) => Promise<string>;
-    };
-    jump_to_symbol: {
-        description: string;
-        parameters: {
-            type: string;
-            properties: {
-                symbol: {
-                    type: string;
-                };
-                plan_id: {
-                    type: string;
-                };
-            };
-            required: string[];
-        };
-        execute: ({ symbol, plan_id }: {
-            symbol: string;
-            plan_id?: string;
-        }) => Promise<string>;
-    };
-    brief_fix_loop: {
-        description: string;
-        parameters: {
-            type: string;
-            properties: {
-                symbol: {
-                    type: string;
-                };
-                intent: {
-                    type: string;
-                };
-            };
-            required: string[];
-        };
-        execute: ({ symbol, intent }: {
-            symbol: string;
-            intent: string;
-        }) => Promise<string>;
-    };
-    prepare_patch: {
-        description: string;
-        parameters: {
-            type: string;
-            properties: {
-                plan_id: {
-                    type: string;
-                };
-                message: {
-                    type: string;
-                };
-            };
-            required: string[];
-        };
-        execute: ({ plan_id, message }: {
-            plan_id?: string;
-            message: string;
-        }) => Promise<string>;
-    };
-    validate_patch: {
-        description: string;
-        parameters: {
-            type: string;
-            properties: {
-                patch_path: {
-                    type: string;
-                };
-                timeout_ms: {
-                    type: string;
-                    default: number;
-                };
-            };
-            required: string[];
-        };
-        execute: ({ patch_path, timeout_ms }: {
-            patch_path: string;
-            timeout_ms?: number;
-        }) => Promise<string>;
-    };
-    finalize_plan: {
-        description: string;
-        parameters: {
-            type: string;
-            properties: {
-                plan_id: {
-                    type: string;
-                };
-                outcome: {
-                    type: string;
-                };
-            };
-            required: string[];
-        };
-        execute: ({ plan_id, outcome }: {
-            plan_id: string;
-            outcome: string;
-        }) => Promise<string>;
-    };
+    [key: string]: any;
 };

package/dist/system-tools.js

@@ -1,21 +1,29 @@
+import { tool } from "@opencode-ai/plugin";
 import { exec } from "node:child_process";
 import * as fs from "node:fs/promises";
 import * as fsSync from "node:fs";
 import * as path from "node:path";
 import { promisify } from "node:util";
-import { fileURLToPath } from "node:url";
 import * as crypto from "node:crypto";
 const execAsync = promisify(exec);
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PROJECT_ROOT = process.cwd();
 const OPENCODE_DIR = path.join(PROJECT_ROOT, ".opencode");
 const CACHE_DIR = path.join(OPENCODE_DIR, "cache");
-const ASSETS_DIR = path.join(__dirname, "../assets");
-let pendingInitToken = null;
-let pendingInitPlan = null;
+// Internal logging
+function log(message, data) {
+    // console.error is used here for internal debugging as standard console.log may interfere with tool outputs
+    console.error(`[Autognosis] ${message}`, data || '');
+}
+// =============================================================================
+// HELPERS
+// =============================================================================
 async function runCmd(cmd, cwd = PROJECT_ROOT, timeoutMs = 30000) {
     try {
-        const { stdout, stderr } = await execAsync(cmd, { cwd, maxBuffer: 10 * 1024 * 1024, timeout: timeoutMs });
+        const { stdout, stderr } = await execAsync(cmd, {
+            cwd,
+            maxBuffer: 10 * 1024 * 1024,
+            timeout: timeoutMs
+        });
         return { stdout: stdout.trim(), stderr: stderr.trim() };
     }
     catch (error) {
@@ -26,17 +34,12 @@ async function runCmd(cmd, cwd = PROJECT_ROOT, timeoutMs = 30000) {
     }
 }
 async function checkBinary(bin) {
-    const { error } = await runCmd(`${bin} --version`, PROJECT_ROOT, 5000);
-    return !error;
-}
-async function getPatterns() {
-    const patternsPath = path.join(ASSETS_DIR, "patterns.json");
     try {
-        const content = await fs.readFile(patternsPath, "utf-8");
-        return JSON.parse(content).patterns || [];
+        const { error } = await runCmd(`${bin} --version`, PROJECT_ROOT, 5000);
+        return !error;
     }
     catch (e) {
-        return [];
+        return false;
     }
 }
 async function ensureCache() {
@@ -87,170 +90,183 @@ async function maintainSymbolIndex() {
     }
     return { rebuilt: false, status: "ok" };
 }
+// =============================================================================
+// TOOLS
+// =============================================================================
 export function systemTools() {
+    let pendingInitToken = null; // State for init token
     return {
-        autognosis_init: {
+        autognosis_init: tool({
             description: "Initialize or check the Autognosis environment. Two-phase: 'plan' (default) generates a token, 'apply' executes it.",
-            parameters: { type: "object", properties: { mode: { type: "string", enum: ["plan", "apply"], default: "plan" }, token: { type: "string" } }, required: ["mode"] },
-            execute: async ({ mode = "plan", token }) => {
+            args: {
+                mode: tool.schema.enum(["plan", "apply"]).optional().default("plan"),
+                token: tool.schema.string().optional()
+            },
+            async execute({ mode, token }) {
+                log("Tool call: autognosis_init", { mode });
                 if (mode === "plan") {
-                    const checks = { rg: await checkBinary("rg"), fd: await checkBinary("fd"), sg: await checkBinary("sg"), ctags: await checkBinary("ctags"), git: await checkBinary("git") };
+                    const checks = {
+                        rg: await checkBinary("rg"),
+                        fd: await checkBinary("fd"),
+                        sg: await checkBinary("sg"),
+                        ctags: await checkBinary("ctags"),
+                        git: await checkBinary("git")
+                    };
                     const actions = [];
                     if (!fsSync.existsSync(CACHE_DIR))
                         actions.push(`Create cache directory: ${CACHE_DIR}`);
-                    else
-                        actions.push(`Verify cache directory: ${CACHE_DIR} (exists)`);
-                    const newToken = crypto.randomBytes(4).toString("hex");
-                    pendingInitToken = newToken;
-                    pendingInitPlan = { checks, actions };
-                    return JSON.stringify({ status: "PLAN_READY", system_checks: checks, planned_actions: actions, confirm_token: newToken, instruction: "Review the plan. To execute, call autognosis_init(mode='apply', token='...')" }, null, 2);
+                    pendingInitToken = crypto.randomBytes(4).toString("hex");
+                    return JSON.stringify({
+                        status: "PLAN_READY",
+                        system_checks: checks,
+                        planned_actions: actions,
+                        confirm_token: pendingInitToken,
+                        instruction: `Call autognosis_init(mode='apply', token='${pendingInitToken}')`
+                    }, null, 2);
                 }
-                else if (mode === "apply") {
-                    if (!pendingInitToken || !token || token !== pendingInitToken)
-                        return JSON.stringify({ status: "ERROR", message: "Invalid or expired confirmation token. Run mode='plan' first." });
+                else {
+                    if (!pendingInitToken || token !== pendingInitToken) {
+                        return JSON.stringify({ status: "ERROR", message: "Invalid token. Run mode='plan' first." });
+                    }
                     await ensureCache();
                     pendingInitToken = null;
-                    pendingInitPlan = null;
-                    return JSON.stringify({ status: "SUCCESS", message: "Autognosis initialized.", cache_dir: CACHE_DIR });
+                    return JSON.stringify({ status: "SUCCESS", message: "Autognosis initialized." });
                 }
             }
-        },
-        fast_search: {
+        }),
+        fast_search: tool({
             description: "Fast content or filename search using ripgrep (rg) and fd.",
-            parameters: { type: "object", properties: { query: { type: "string" }, mode: { type: "string", enum: ["filename", "content"], default: "filename" }, path: { type: "string" } }, required: ["query"] },
-            execute: async ({ query, mode = "filename", path: searchPath = "." }) => {
+            args: {
+                query: tool.schema.string(),
+                mode: tool.schema.enum(["filename", "content"]).optional().default("filename"),
+                path: tool.schema.string().optional().default(".")
+            },
+            async execute({ query, mode, path: searchPath }) {
+                log("Tool call: fast_search", { query, mode, searchPath });
                 if (mode === "content") {
                     if (!(await checkBinary("rg")))
-                        return "Error: 'rg' (ripgrep) is not installed. fast_search content mode unavailable.";
+                        return "Error: 'rg' not installed.";
                     const { stdout } = await runCmd(`rg -n --column "${query}" "${searchPath}"`);
                     if (!stdout)
                         return "No matches found.";
-                    return stdout.split('\n').slice(0, 50).join('\n') + (stdout.split('\n').length > 50 ? "\n... (truncated)" : "");
+                    return stdout.split('\n').slice(0, 50).join('\n');
                 }
                 else {
                     if (!(await checkBinary("fd")))
-                        return "Error: 'fd' is not installed. fast_search filename mode unavailable.";
+                        return "Error: 'fd' not installed.";
                     const { stdout } = await runCmd(`fd "${query}" "${searchPath}"`);
                     if (!stdout)
                         return "No files found.";
-                    return stdout.split('\n').slice(0, 50).join('\n') + (stdout.split('\n').length > 50 ? "\n... (truncated)" : "");
-                }
-            }
-        },
-        structural_search: {
-            description: "Search code using ast-grep patterns or patterns.json IDs.",
-            parameters: { type: "object", properties: { pattern: { type: "string" }, path: { type: "string", default: "." }, plan_id: { type: "string" } }, required: ["pattern"] },
-            execute: async ({ pattern, path: searchPath = ".", plan_id }) => {
-                if (!(await checkBinary("sg")))
-                    return JSON.stringify({ error: "Degraded Mode: 'sg' (ast-grep) not found.", results: [], plan_id: plan_id || "OFF-PLAN" });
-                const knownPatterns = await getPatterns();
-                const known = knownPatterns.find((p) => p.name === pattern);
-                const cmd = known ? `sg scan -p "${known.pattern}" "${searchPath}" --json` : `sg scan -p "${pattern}" "${searchPath}" --json`;
-                const { stdout } = await runCmd(cmd);
-                let results = [];
-                try {
-                    results = JSON.parse(stdout);
+                    return stdout.split('\n').slice(0, 50).join('\n');
                 }
-                catch (e) { }
-                return JSON.stringify({ results: results.slice(0, 50), truncated: results.length > 50, plan_id: plan_id || "OFF-PLAN" }, null, 2);
             }
-        },
-        read_slice: {
+        }),
+        read_slice: tool({
             description: "Read a specific slice of a file.",
-            parameters: { type: "object", properties: { file: { type: "string" }, start_line: { type: "number" }, end_line: { type: "number" }, plan_id: { type: "string" } }, required: ["file", "start_line", "end_line"] },
-            execute: async ({ file, start_line, end_line, plan_id }) => {
+            args: {
+                file: tool.schema.string(),
+                start_line: tool.schema.number(),
+                end_line: tool.schema.number()
+            },
+            async execute({ file, start_line, end_line }) {
+                log("Tool call: read_slice", { file, start_line, end_line });
                 const { stdout, stderr } = await runCmd(`sed -n '${start_line},${end_line}p;${end_line + 1}q' "${file}"`);
                 if (stderr)
-                    return `Error reading slice: ${stderr}`;
-                return JSON.stringify({ file, start_line, end_line, content: stdout, plan_id: plan_id || "OFF-PLAN" }, null, 2);
+                    return `Error: ${stderr}`;
+                return JSON.stringify({ file, start_line, end_line, content: stdout }, null, 2);
             }
-        },
-        symbol_query: {
+        }),
+        symbol_query: tool({
             description: "Query the symbol index. Rebuilds automatically if stale.",
-            parameters: { type: "object", properties: { symbol: { type: "string" } }, required: ["symbol"] },
-            execute: async ({ symbol }) => {
+            args: {
+                symbol: tool.schema.string()
+            },
+            async execute({ symbol }) {
+                log("Tool call: symbol_query", { symbol });
                 const maint = await maintainSymbolIndex();
                 if (maint.status === "unavailable")
-                    return JSON.stringify({ error: "Symbol index unavailable", reason: maint.reason });
+                    return JSON.stringify({ error: maint.reason });
                 const tagsFile = path.join(CACHE_DIR, "tags");
-                if (await checkBinary("readtags")) {
-                    const { stdout } = await runCmd(`readtags -t "${tagsFile}" "${symbol}"`);
-                    return JSON.stringify({ matches: stdout.split('\n').filter(Boolean), metadata: maint }, null, 2);
-                }
-                else {
-                    const { stdout: grepOut } = await runCmd(`grep -P "^${symbol}\t" "${tagsFile}"`);
-                    return JSON.stringify({ matches: grepOut.split('\n').filter(Boolean), metadata: maint, note: "using_grep_fallback" }, null, 2);
-                }
+                const { stdout: grepOut } = await runCmd(`grep -P "^${symbol}\t" "${tagsFile}"`);
+                return JSON.stringify({ matches: grepOut.split('\n').filter(Boolean), metadata: maint }, null, 2);
             }
-        },
-        jump_to_symbol: {
+        }),
+        jump_to_symbol: tool({
             description: "Jump to a symbol's definition by querying the index and reading the slice.",
-            parameters: { type: "object", properties: { symbol: { type: "string" }, plan_id: { type: "string" } }, required: ["symbol"] },
-            execute: async ({ symbol, plan_id }) => {
+            args: {
+                symbol: tool.schema.string()
+            },
+            async execute({ symbol }) {
+                log("Tool call: jump_to_symbol", { symbol });
                 const maint = await maintainSymbolIndex();
                 if (maint.status !== "ok")
-                    return JSON.stringify({ error: "Index unavailable", reason: maint.reason });
+                    return JSON.stringify({ error: maint.reason });
                 const tagsFile = path.join(CACHE_DIR, "tags");
                 const { stdout: tagLine } = await runCmd(`grep -P "^${symbol}\t" "${tagsFile}" | head -n 1`);
                 if (!tagLine)
                     return JSON.stringify({ found: false, symbol });
-                const parts = tagLine.split('\t');
-                const file = parts[1];
-                let line = 1;
+                const file = tagLine.split('\t')[1];
                 const { stdout: grepLine } = await runCmd(`grep -n "${symbol}" "${file}" | head -n 1`);
-                if (grepLine)
-                    line = parseInt(grepLine.split(':')[0], 10);
+                const line = grepLine ? parseInt(grepLine.split(':')[0], 10) : 1;
                 const start = Math.max(1, line - 5);
                 const end = line + 15;
                 const { stdout: slice } = await runCmd(`sed -n '${start},${end}p;${end + 1}q' "${file}"`);
-                return JSON.stringify({ symbol, resolved_location: { file, line }, slice: { start, end, content: slice }, plan_id: plan_id || "OFF-PLAN" }, null, 2);
+                return JSON.stringify({ symbol, resolved_location: { file, line }, slice: { start, end, content: slice } }, null, 2);
             }
-        },
-        brief_fix_loop: {
+        }),
+        brief_fix_loop: tool({
             description: "The Action Planner. Generates a bounded worklist for a symbol and intent.",
-            parameters: { type: "object", properties: { symbol: { type: "string" }, intent: { type: "string" } }, required: ["symbol", "intent"] },
-            execute: async ({ symbol, intent }) => {
-                const planId = `plan-${Date.now()}-${crypto.randomBytes(2).toString("hex")}`;
-                return JSON.stringify({ plan_id: planId, symbol, intent, status: "PLAN_GENERATED", instructions: "Use this plan_id for all subsequent operations.", mock_worklist: [{ file: "src/example.ts", reason: "Direct dependency", heat: "high" }] }, null, 2);
+            args: {
+                symbol: tool.schema.string(),
+                intent: tool.schema.string()
+            },
+            async execute({ symbol, intent }) {
+                log("Tool call: brief_fix_loop", { symbol, intent });
+                const planId = `plan-${Date.now()}`;
+                return JSON.stringify({ plan_id: planId, symbol, intent, status: "PLAN_GENERATED" }, null, 2);
             }
-        },
-        prepare_patch: {
-            description: "Generate a .diff artifact for the current changes, tied to a plan.",
-            parameters: { type: "object", properties: { plan_id: { type: "string" }, message: { type: "string" } }, required: ["message"] },
-            execute: async ({ plan_id, message }) => {
+        }),
+        prepare_patch: tool({
+            description: "Generate a .diff artifact for the current changes.",
+            args: {
+                message: tool.schema.string()
+            },
+            async execute({ message }) {
+                log("Tool call: prepare_patch", { message });
                 await ensureCache();
                 const patchPath = path.join(CACHE_DIR, `patch-${Date.now()}.diff`);
                 const { stdout } = await runCmd("git diff");
                 if (!stdout)
                     return "No changes to patch.";
-                const content = `// META: plan_id=${plan_id || "NONE"}\n// META: message=${message}\n\n${stdout}`;
-                await fs.writeFile(patchPath, content);
+                await fs.writeFile(patchPath, `// MSG: ${message}\n\n${stdout}`);
                 return `Patch saved to ${patchPath}`;
             }
-        },
-        validate_patch: {
-            description: "Validate a patch by applying it in a fresh worktree. Enforces timeout.",
-            parameters: { type: "object", properties: { patch_path: { type: "string" }, timeout_ms: { type: "number", default: 30000 } }, required: ["patch_path"] },
-            execute: async ({ patch_path, timeout_ms = 30000 }) => {
-                const start = Date.now();
-                const { error, timedOut } = await runCmd(`git apply --check "${patch_path}"`, PROJECT_ROOT, timeout_ms);
-                if (timedOut)
-                    return JSON.stringify({ status: "TIMEOUT", checked: ["git_apply_check"], failed_at: "git_apply_check", duration: Date.now() - start });
-                if (error)
-                    return JSON.stringify({ status: "FAILED", checks: { git_apply_check: "failed" }, error: error.message });
-                return JSON.stringify({ status: "SUCCESS", checks: { git_apply_check: "passed" }, duration: Date.now() - start, note: "Patch is valid against current HEAD." }, null, 2);
+        }),
+        validate_patch: tool({
+            description: "Validate a patch by applying it in a fresh worktree.",
+            args: {
+                patch_path: tool.schema.string()
+            },
+            async execute({ patch_path }) {
+                log("Tool call: validate_patch", { patch_path });
+                const { error } = await runCmd(`git apply --check "${patch_path}"`);
+                return error ? `FAILED: ${error.message}` : "SUCCESS: Patch is valid against current HEAD.";
             }
-        },
-        finalize_plan: {
+        }),
+        finalize_plan: tool({
             description: "Finalize a plan, logging metrics and cleaning cache.",
-            parameters: { type: "object", properties: { plan_id: { type: "string" }, outcome: { type: "string" } }, required: ["plan_id", "outcome"] },
-            execute: async ({ plan_id, outcome }) => {
+            args: {
+                plan_id: tool.schema.string(),
+                outcome: tool.schema.string()
+            },
+            async execute({ plan_id, outcome }) {
+                log("Tool call: finalize_plan", { plan_id, outcome });
                 await ensureCache();
                 const report = { plan_id, outcome, time: new Date().toISOString() };
                 await fs.appendFile(path.join(CACHE_DIR, "gaps.jsonl"), JSON.stringify(report) + "\n");
                 const deleted = await cleanCache();
-                return `Plan finalized. Metrics logged. Cache hygiene: deleted ${deleted} old items.`;
+                return `Finalized. Cache hygiene: deleted ${deleted} old items.`;
             }
-        }
+        })
     };
 }

package/package.json

@@ -1,30 +1,29 @@
 {
   "name": "opencode-autognosis",
-  "version": "0.1.5",
+  "version": "1.0.1",
   "description": "Transforms OpenCode agents into 'miniature engineers' with deep codebase awareness. Includes fast structural search (ast-grep), instant symbol navigation (ctags), and a disciplined 'Plan → Execute → Patch' workflow.",
   "type": "module",
-  "exports": {
-    ".": "./dist/index.js"
-  },
-  "types": "./dist/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
     "dist",
     "assets",
-    "commands",
     "LICENSE",
-    "README.md",
-    "gemini-extension.json"
+    "README.md"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "prepublishOnly": "npm run build"
   },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "zod": "^3.0.0"
+  "opencode": {
+    "type": "plugin",
+    "hooks": []
   },
   "devDependencies": {
+    "@opencode-ai/plugin": "^1.0.162",
+    "@opencode-ai/sdk": "^1.1.40",
     "@types/node": "^20.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "zod": "^4.3.6"
   }
 }

package/commands/autognosis/init.toml

@@ -1,13 +0,0 @@
-description = "Initialize or check the Autognosis environment"
-
-# The command executes the tool via the agent
-# Or it can just be a prompt that calls the tool
-prompt = """
-Please run the autognosis_init tool with the following arguments:
-mode = "{{mode}}"
-token = "{{token}}"
-"""
-
-[parameters]
-mode = { type = "string", description = "The mode to run in (plan or apply)", default = "plan" }
-token = { type = "string", description = "The confirmation token for apply mode" }

package/gemini-extension.json

@@ -1,12 +0,0 @@
-{
-  "name": "opencode-autognosis",
-  "version": "0.1.3",
-  "description": "Autognosis extension for Gemini CLI",
-  "mcpServers": {
-    "autognosis": {
-      "command": "node",
-      "args": ["${extensionPath}/dist/index.js"],
-      "cwd": "${extensionPath}"
-    }
-  }
-}