grepmax 0.11.2 → 0.12.0

package/dist/commands/opencode.js

@@ -19,14 +19,14 @@ const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const commander_1 = require("commander");
 const TOOL_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".config", "opencode", "tool", "gmax.ts");
-const PLUGIN_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".config", "opencode", "plugin", "gmax.ts");
+const PLUGIN_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".config", "opencode", "plugins", "gmax.ts");
+const LEGACY_PLUGIN_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".config", "opencode", "plugin", "gmax.ts");
 const CONFIG_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".config", "opencode", "opencode.json");
 function resolveGmaxBin() {
     try {
         return (0, node_child_process_1.execSync)("which gmax", { encoding: "utf-8" }).trim();
     }
     catch (_a) {
-        // Fall back to the path of the current process entry point
         const binDir = node_path_1.default.dirname(process.argv[1]);
         const candidate = node_path_1.default.join(binDir, "gmax");
         if (node_fs_1.default.existsSync(candidate))
@@ -37,104 +37,44 @@ function resolveGmaxBin() {
 function buildShimContent(gmaxBin) {
     return `
 import { tool } from "@opencode-ai/plugin";
-
-const SKILL = \`
----
-name: gmax
-description: Semantic code search. Use alongside grep - grep for exact strings, gmax for concepts.
-allowed-tools: "Bash(gmax:*), Read"
----
-
-## What gmax does
-
-Finds code by meaning. When you'd ask a colleague "where do we handle auth?", use gmax.
-
-- grep/ripgrep: exact string match, fast
-- gmax: concept match, finds code you couldn't grep for
-
-## Primary command
-
-gmax "where do we validate user permissions"
-
-
-Returns ~10 results with code snippets (15+ lines each). Usually enough to understand what's happening.
-
-## Output explained
-
-ORCHESTRATION src/auth/handler.ts:45
-Defines: handleAuth | Calls: validate, checkRole, respond | Score: .94
-
-export async function handleAuth(req: Request) {
-  const token = req.headers.get("Authorization");
-  const claims = await validateToken(token);
-  if (!claims) return unauthorized();
-  const allowed = await checkRole(claims.role, req.path);
-  ...
-
-- **ORCHESTRATION** = contains logic, coordinates other code
-- **DEFINITION** = types, interfaces, classes
-- **Score** = relevance (1 = best match)
-- **Calls** = what this code calls (helps you trace flow)
-
-## When to Read more
-
-The snippet often has enough context. But if you need more:
-
-# gmax found src/auth/handler.ts:45-90 as ORCH
-Read src/auth/handler.ts:45-120
-
-
-Read the specific line range, not the whole file.
-
-## Other commands
-
-# Trace call graph (who calls X, what X calls)
-gmax trace handleAuth
-
-# Skeleton of a huge file (to find which ranges to read)
-gmax skeleton src/giant-2000-line-file.ts
-
-# Just file paths when you only need locations
-gmax "authentication" --compact
-
-
-## Workflow: architecture questions
-
-# 1. Find entry points
-gmax "where do requests enter the server"
-# Review the ORCH results - code is shown
-
-# 2. If you need deeper context on a specific function
-Read src/server/handler.ts:45-120
-
-# 3. Trace to understand call flow
-gmax trace handleRequest
-
-## Tips
-
-- More words = better results. "auth" is vague. "where does the server validate JWT tokens" is specific.
-- ORCH results contain the logic - prioritize these
-- Don't read entire files. Use the line ranges gmax gives you.
-- If results seem off, rephrase your query like you'd ask a teammate
-
-## If Index is Building
-
-If you see "Indexing" or "Syncing": STOP. Tell the user the index is building. Ask if they want to wait or proceed with partial results.
-
-\`;
-
-const GMAX_BIN = "${gmaxBin}";
+import { existsSync, realpathSync, readFileSync } from "node:fs";
+import { resolve, dirname, join } from "node:path";
+import { execFileSync } from "node:child_process";
+
+// Resolve gmax binary and SKILL dynamically from the installed package.
+// This means npm install -g grepmax@latest automatically updates the SKILL
+// without needing to re-run gmax install-opencode.
+const _gmax = (() => {
+  // Binary: try hardcoded path, fall back to which
+  let bin = "${gmaxBin}";
+  if (!existsSync(bin)) {
+    try {
+      bin = execFileSync("which gmax", { encoding: "utf-8" }).trim();
+    } catch {
+      return { bin: "gmax", skill: "Semantic code search. Run: gmax 'query' --agent" };
+    }
+  }
+
+  // SKILL: read from package root
+  try {
+    const root = resolve(dirname(realpathSync(bin)), "..");
+    const skillPath = join(root, "plugins", "grepmax", "skills", "grepmax", "SKILL.md");
+    return { bin, skill: readFileSync(skillPath, "utf-8") };
+  } catch {
+    return { bin, skill: "Semantic code search. Run: gmax 'query' --agent" };
+  }
+})();
 
 export default tool({
-  description: SKILL,
+  description: _gmax.skill,
   args: {
     argv: tool.schema.array(tool.schema.string())
-      .describe("Arguments for gmax, e.g. ['search', 'user auth']")
+      .describe("Arguments for gmax, e.g. ['search', 'user auth', '--agent']")
   },
   async execute({ argv }) {
     try {
       // @ts-ignore
-      const out = await Bun.spawn([GMAX_BIN, ...argv], { stdout: "pipe" }).stdout;
+      const out = await Bun.spawn([_gmax.bin, ...argv], { stdout: "pipe" }).stdout;
       const text = await new Response(out).text();
       if (text.includes("Indexing") || text.includes("Building") || text.includes("Syncing")) {
         return \`WARN: The index is currently updating.
@@ -142,7 +82,7 @@ export default tool({
 Output so far:
 \${text.trim()}
 
-PLEASE READ THE "Indexing" WARNING IN MY SKILL DESCRIPTION.\`;
+Please wait for indexing to complete before searching.\`;
       }
       return text.trim();
     } catch (err) {
@@ -151,43 +91,90 @@ PLEASE READ THE "Indexing" WARNING IN MY SKILL DESCRIPTION.\`;
   },
 })`;
 }
+function buildPluginContent(gmaxBin) {
+    return `import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { join, resolve, dirname } from "node:path";
+import { homedir } from "node:os";
+
+function resolveGmaxBin() {
+  const hardcoded = "${gmaxBin}";
+  if (existsSync(hardcoded)) return hardcoded;
+  try {
+    return execFileSync("which gmax", { encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function isProjectRegistered() {
+  try {
+    const projectsPath = join(homedir(), ".gmax", "projects.json");
+    const projects = JSON.parse(readFileSync(projectsPath, "utf-8"));
+    const cwd = process.cwd();
+    return projects.some((p) => cwd.startsWith(p.root));
+  } catch {
+    return false;
+  }
+}
+
+function startDaemon() {
+  const bin = resolveGmaxBin();
+  if (!bin || !isProjectRegistered()) return;
+  try {
+    execFileSync(bin, ["watch", "--daemon", "-b"], {
+      timeout: 5000,
+      stdio: "ignore",
+    });
+  } catch {}
+}
+
+export const GmaxPlugin = async () => {
+  startDaemon();
+
+  return {
+    "session.created": async () => {
+      startDaemon();
+    },
+  };
+};
+`;
+}
 function install() {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         try {
             // 1. Delete legacy plugin
-            if (node_fs_1.default.existsSync(PLUGIN_PATH)) {
+            if (node_fs_1.default.existsSync(LEGACY_PLUGIN_PATH)) {
                 try {
-                    node_fs_1.default.unlinkSync(PLUGIN_PATH);
-                    console.log("Deleted legacy plugin at", PLUGIN_PATH);
-                }
-                catch (e) {
-                    console.warn("mnt: Failed to delete legacy plugin:", e);
+                    node_fs_1.default.unlinkSync(LEGACY_PLUGIN_PATH);
+                    console.log("Deleted legacy plugin at", LEGACY_PLUGIN_PATH);
                 }
+                catch (_b) { }
             }
             // 2. Resolve absolute path to gmax binary
             const gmaxBin = resolveGmaxBin();
             console.log(`   Resolved gmax binary: ${gmaxBin}`);
-            // 3. Create tool shim
+            // 3. Create tool shim (reads SKILL dynamically from package root)
             node_fs_1.default.mkdirSync(node_path_1.default.dirname(TOOL_PATH), { recursive: true });
             node_fs_1.default.writeFileSync(TOOL_PATH, buildShimContent(gmaxBin));
             console.log("✅ Created tool shim at", TOOL_PATH);
-            // 4. Register MCP
-            if (!node_fs_1.default.existsSync(CONFIG_PATH)) {
-                node_fs_1.default.mkdirSync(node_path_1.default.dirname(CONFIG_PATH), { recursive: true });
-                node_fs_1.default.writeFileSync(CONFIG_PATH, JSON.stringify({}, null, 2));
+            // 4. Create plugin for daemon startup
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(PLUGIN_PATH), { recursive: true });
+            node_fs_1.default.writeFileSync(PLUGIN_PATH, buildPluginContent(gmaxBin));
+            console.log("✅ Created plugin at", PLUGIN_PATH);
+            // 5. Clean up stale MCP registration if present
+            if (node_fs_1.default.existsSync(CONFIG_PATH)) {
+                try {
+                    const config = JSON.parse(node_fs_1.default.readFileSync(CONFIG_PATH, "utf-8") || "{}");
+                    if ((_a = config.mcp) === null || _a === void 0 ? void 0 : _a.gmax) {
+                        delete config.mcp.gmax;
+                        node_fs_1.default.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+                        console.log("✅ Removed stale MCP registration from", CONFIG_PATH);
+                    }
+                }
+                catch (_c) { }
             }
-            const config = JSON.parse(node_fs_1.default.readFileSync(CONFIG_PATH, "utf-8") || "{}");
-            if (!config.$schema)
-                config.$schema = "https://opencode.ai/config.json";
-            if (!config.mcp)
-                config.mcp = {};
-            config.mcp.gmax = {
-                type: "local",
-                command: [gmaxBin, "mcp"],
-                enabled: true,
-            };
-            node_fs_1.default.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
-            console.log("✅ Registered MCP server in", CONFIG_PATH);
         }
         catch (err) {
             console.error("❌ Installation failed:", err);
@@ -198,25 +185,30 @@ function uninstall() {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
         try {
-            // 1. Remove shim
+            // 1. Remove tool shim
             if (node_fs_1.default.existsSync(TOOL_PATH)) {
                 node_fs_1.default.unlinkSync(TOOL_PATH);
                 console.log("✅ Removed tool shim.");
             }
-            // 2. Unregister MCP
+            // 2. Remove plugin
+            if (node_fs_1.default.existsSync(PLUGIN_PATH)) {
+                node_fs_1.default.unlinkSync(PLUGIN_PATH);
+                console.log("✅ Removed plugin.");
+            }
+            // 3. Clean up legacy paths
+            if (node_fs_1.default.existsSync(LEGACY_PLUGIN_PATH)) {
+                node_fs_1.default.unlinkSync(LEGACY_PLUGIN_PATH);
+                console.log("✅ Cleaned up legacy plugin.");
+            }
+            // 4. Clean up MCP registration if present
             if (node_fs_1.default.existsSync(CONFIG_PATH)) {
                 const config = JSON.parse(node_fs_1.default.readFileSync(CONFIG_PATH, "utf-8") || "{}");
                 if ((_a = config.mcp) === null || _a === void 0 ? void 0 : _a.gmax) {
                     delete config.mcp.gmax;
                     node_fs_1.default.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
-                    console.log("✅ Unregistered MCP server.");
+                    console.log("✅ Removed MCP registration.");
                 }
             }
-            // Cleanup plugin just in case
-            if (node_fs_1.default.existsSync(PLUGIN_PATH)) {
-                node_fs_1.default.unlinkSync(PLUGIN_PATH);
-                console.log("✅ Cleaned up plugin file.");
-            }
         }
         catch (err) {
             console.error("❌ Uninstall failed:", err);

package/dist/commands/plugin.js

@@ -0,0 +1,259 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const commander_1 = require("commander");
+const exit_1 = require("../lib/utils/exit");
+function commandExists(cmd) {
+    try {
+        (0, node_child_process_1.execSync)(`which ${cmd}`, { encoding: "utf-8", stdio: "pipe" });
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function getClients() {
+    return [
+        {
+            name: "Claude Code",
+            id: "claude",
+            detect: () => commandExists("claude"),
+            isInstalled: () => fs.existsSync(path.join(os.homedir(), ".claude", "plugins", "cache", "grepmax", "grepmax")),
+            install: () => __awaiter(this, void 0, void 0, function* () {
+                const { installClaudeCode } = yield Promise.resolve().then(() => __importStar(require("./claude-code")));
+                yield installClaudeCode.parseAsync(["node", "gmax"]);
+            }),
+            uninstall: () => __awaiter(this, void 0, void 0, function* () {
+                const cacheBase = path.join(os.homedir(), ".claude", "plugins", "cache", "grepmax");
+                if (fs.existsSync(cacheBase)) {
+                    fs.rmSync(cacheBase, { recursive: true, force: true });
+                }
+                try {
+                    const { spawn } = yield Promise.resolve().then(() => __importStar(require("node:child_process")));
+                    yield new Promise((resolve) => {
+                        const child = spawn("claude", ["plugin", "marketplace", "remove", "grepmax"], { stdio: "ignore" });
+                        child.on("exit", () => resolve());
+                        child.on("error", () => resolve());
+                    });
+                }
+                catch (_a) { }
+                console.log("✅ Removed Claude Code plugin.");
+            }),
+        },
+        {
+            name: "OpenCode",
+            id: "opencode",
+            detect: () => commandExists("opencode"),
+            isInstalled: () => fs.existsSync(path.join(os.homedir(), ".config", "opencode", "tool", "gmax.ts")),
+            install: () => __awaiter(this, void 0, void 0, function* () {
+                const { installOpencode } = yield Promise.resolve().then(() => __importStar(require("./opencode")));
+                yield installOpencode.parseAsync(["node", "gmax"]);
+            }),
+            uninstall: () => __awaiter(this, void 0, void 0, function* () {
+                const { uninstallOpencode } = yield Promise.resolve().then(() => __importStar(require("./opencode")));
+                yield uninstallOpencode.parseAsync(["node", "gmax"]);
+            }),
+        },
+        {
+            name: "Codex",
+            id: "codex",
+            detect: () => commandExists("codex"),
+            isInstalled: () => {
+                const p = path.join(os.homedir(), ".codex", "AGENTS.md");
+                try {
+                    return fs.existsSync(p) && fs.readFileSync(p, "utf-8").includes("name: gmax");
+                }
+                catch (_a) {
+                    return false;
+                }
+            },
+            install: () => __awaiter(this, void 0, void 0, function* () {
+                const { installCodex } = yield Promise.resolve().then(() => __importStar(require("./codex")));
+                yield installCodex.parseAsync(["node", "gmax"]);
+            }),
+            uninstall: () => __awaiter(this, void 0, void 0, function* () {
+                const { uninstallCodex } = yield Promise.resolve().then(() => __importStar(require("./codex")));
+                yield uninstallCodex.parseAsync(["node", "gmax"]);
+            }),
+        },
+        {
+            name: "Factory Droid",
+            id: "droid",
+            detect: () => fs.existsSync(path.join(os.homedir(), ".factory")) &&
+                commandExists("droid"),
+            isInstalled: () => fs.existsSync(path.join(os.homedir(), ".factory", "skills", "gmax", "SKILL.md")),
+            install: () => __awaiter(this, void 0, void 0, function* () {
+                const { installDroid } = yield Promise.resolve().then(() => __importStar(require("./droid")));
+                yield installDroid.parseAsync(["node", "gmax"]);
+            }),
+            uninstall: () => __awaiter(this, void 0, void 0, function* () {
+                const { uninstallDroid } = yield Promise.resolve().then(() => __importStar(require("./droid")));
+                yield uninstallDroid.parseAsync(["node", "gmax"]);
+            }),
+        },
+    ];
+}
+// --- Subcommands ---
+const addCmd = new commander_1.Command("add")
+    .description("Install or update gmax plugins")
+    .argument("[client]", "Client to install (claude, opencode, codex, droid, all)")
+    .action((clientArg) => __awaiter(void 0, void 0, void 0, function* () {
+    const clients = getClients();
+    const onlyId = clientArg && clientArg !== "all" ? clientArg : undefined;
+    if (onlyId) {
+        const client = clients.find((c) => c.id === onlyId);
+        if (!client) {
+            console.error(`Unknown client: ${onlyId}`);
+            console.error(`Available: ${clients.map((c) => c.id).join(", ")}`);
+            yield (0, exit_1.gracefulExit)(1);
+            return;
+        }
+        if (!client.detect()) {
+            console.error(`${client.name} not found on this system`);
+            yield (0, exit_1.gracefulExit)(1);
+            return;
+        }
+        yield client.install();
+        yield (0, exit_1.gracefulExit)();
+        return;
+    }
+    // Install all detected
+    console.log("gmax plugin add — detecting clients...\n");
+    let installed = 0;
+    for (const client of clients) {
+        if (!client.detect()) {
+            console.log(`  skip  ${client.name} — not found`);
+            continue;
+        }
+        try {
+            yield client.install();
+            installed++;
+        }
+        catch (err) {
+            console.error(`  FAIL  ${client.name} — ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (installed === 0) {
+        console.log("\nNo supported clients found. Install one of: claude, opencode, codex, droid");
+    }
+    else {
+        console.log(`\n${installed} plugin(s) installed.`);
+    }
+    yield (0, exit_1.gracefulExit)();
+}));
+const removeCmd = new commander_1.Command("remove")
+    .description("Remove gmax plugins")
+    .argument("[client]", "Client to remove (claude, opencode, codex, droid, all)")
+    .action((clientArg) => __awaiter(void 0, void 0, void 0, function* () {
+    const clients = getClients();
+    if (clientArg && clientArg !== "all") {
+        const client = clients.find((c) => c.id === clientArg);
+        if (!client) {
+            console.error(`Unknown client: ${clientArg}`);
+            console.error(`Available: ${clients.map((c) => c.id).join(", ")}`);
+            yield (0, exit_1.gracefulExit)(1);
+            return;
+        }
+        try {
+            yield client.uninstall();
+        }
+        catch (err) {
+            console.error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        yield (0, exit_1.gracefulExit)();
+        return;
+    }
+    const installedClients = clients.filter((c) => c.isInstalled());
+    if (installedClients.length === 0) {
+        console.log("No gmax plugins currently installed.");
+        yield (0, exit_1.gracefulExit)();
+        return;
+    }
+    // No arg or "all": remove all installed
+    for (const client of installedClients) {
+        try {
+            yield client.uninstall();
+        }
+        catch (err) {
+            console.error(`  FAIL  ${client.name} — ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    console.log(`\n${installedClients.length} plugin(s) removed.`);
+    yield (0, exit_1.gracefulExit)();
+}));
+// --- Status (default action for bare `gmax plugin`) ---
+function statusAction() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const clients = getClients();
+        console.log("gmax plugins\n");
+        for (const client of clients) {
+            const detected = client.detect();
+            const installed = client.isInstalled();
+            let status;
+            if (installed)
+                status = "✅ installed";
+            else if (detected)
+                status = "—  not installed";
+            else
+                status = "—  not found";
+            console.log(`  ${client.name.padEnd(16)} ${status}`);
+        }
+        console.log("\nCommands:");
+        console.log("  gmax plugin add               Install all detected clients");
+        console.log("  gmax plugin add <client>      Install a specific client");
+        console.log("  gmax plugin remove            Remove all installed plugins");
+        console.log("  gmax plugin remove <client>   Remove a specific plugin");
+        yield (0, exit_1.gracefulExit)();
+    });
+}
+exports.plugin = new commander_1.Command("plugin")
+    .description("Manage gmax plugins for AI coding clients")
+    .action(statusAction)
+    .addCommand(addCmd)
+    .addCommand(removeCmd);

package/dist/commands/setup.js

@@ -148,6 +148,15 @@ exports.setup = new commander_1.Command("setup")
             p.log.warn("Embedding mode changed. Run `gmax serve` to apply the new settings.");
         }
     }
+    // Step 8: Install plugins for detected clients
+    const installPlugins = yield p.confirm({
+        message: "Install plugins for detected clients?",
+        initialValue: true,
+    });
+    if (!p.isCancel(installPlugins) && installPlugins) {
+        const { plugin: pluginCmd } = yield Promise.resolve().then(() => __importStar(require("./plugin")));
+        yield pluginCmd.parseAsync(["node", "gmax"]);
+    }
     p.outro(`Ready — ${selectedTier.label}, ${embedMode === "gpu" ? "GPU" : "CPU"} mode`);
     yield (0, exit_1.gracefulExit)();
 }));

package/dist/index.js

@@ -55,6 +55,7 @@ const project_1 = require("./commands/project");
 const recent_1 = require("./commands/recent");
 const related_1 = require("./commands/related");
 const opencode_1 = require("./commands/opencode");
+const plugin_1 = require("./commands/plugin");
 const remove_1 = require("./commands/remove");
 const search_1 = require("./commands/search");
 const similar_1 = require("./commands/similar");
@@ -112,12 +113,18 @@ commander_1.program.addCommand(summarize_1.summarize);
 commander_1.program.addCommand(setup_1.setup);
 commander_1.program.addCommand(config_1.config);
 commander_1.program.addCommand(doctor_1.doctor);
-// Plugin installers
+// Plugins
+commander_1.program.addCommand(plugin_1.plugin);
+// Legacy plugin installers (hidden — use `gmax plugin` instead)
+claude_code_1.installClaudeCode._hidden = true;
 commander_1.program.addCommand(claude_code_1.installClaudeCode);
+codex_1.installCodex._hidden = true;
 commander_1.program.addCommand(codex_1.installCodex);
+droid_1.installDroid._hidden = true;
 commander_1.program.addCommand(droid_1.installDroid);
 droid_1.uninstallDroid._hidden = true;
 commander_1.program.addCommand(droid_1.uninstallDroid);
+opencode_1.installOpencode._hidden = true;
 commander_1.program.addCommand(opencode_1.installOpencode);
 opencode_1.uninstallOpencode._hidden = true;
 commander_1.program.addCommand(opencode_1.uninstallOpencode);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.11.2",
+  "version": "0.12.0",
   "author": "Robert Owens <robowens@me.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {

package/plugins/grepmax/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.11.2",
+  "version": "0.12.0",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",

package/scripts/postinstall.js

@@ -64,3 +64,15 @@ for (const ver of versionDirs) {
     // Best-effort — don't fail the install
   }
 }
+
+// Sync OpenCode: re-run installer if tool shim or plugin exists
+const ocToolPath = path.join(os.homedir(), ".config", "opencode", "tool", "gmax.ts");
+const ocPluginPath = path.join(os.homedir(), ".config", "opencode", "plugins", "gmax.ts");
+if (fs.existsSync(ocToolPath) || fs.existsSync(ocPluginPath)) {
+  try {
+    const { execSync: exec } = require("node:child_process");
+    exec("gmax install-opencode", { stdio: "ignore", timeout: 10000 });
+  } catch {
+    // Best-effort — don't fail the install
+  }
+}