grepmax 0.11.3 → 0.12.1

package/dist/commands/opencode.js

@@ -27,7 +27,6 @@ function resolveGmaxBin() {
         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))
@@ -38,76 +37,36 @@ function resolveGmaxBin() {
 function buildShimContent(gmaxBin) {
     return `
 import { tool } from "@opencode-ai/plugin";
+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" };
+    }
+  }
 
-const SKILL = \`
----
-name: gmax
-description: Semantic code search. Use alongside grep - grep for exact strings, gmax for concepts.
----
-
-## When to use what
-
-- **Know the exact string/symbol?** → grep/ripgrep (fastest)
-- **Know the file already?** → Read tool directly
-- **Searching by concept/behavior?** → gmax "query" --agent (semantic search)
-- **Need full function body?** → gmax extract <symbol> (complete source)
-- **Quick symbol overview?** → gmax peek <symbol> (signature + callers + callees)
-- **Need file structure?** → gmax skeleton <path>
-- **Need call flow?** → gmax trace <symbol>
-
-## Primary command
-
-Use --agent for compact, token-efficient output (one line per result):
-
-gmax "where do we handle authentication" --agent
-gmax "database connection pooling" --role ORCHESTRATION --agent -m 5
-gmax "error handling" --lang ts --exclude tests/ --agent
-
-Output: file:line symbol [ROLE] — signature_hint
-
-All search flags: --agent -m <n> --per-file <n> --root <dir> --file <name> --exclude <prefix> --lang <ext> --role <role> --symbol --imports --name <regex> -C <n> --skeleton --explain --context-for-llm --budget <tokens>
-
-## Commands
-
-### Core
-gmax "query" --agent              # semantic search (compact output)
-gmax extract <symbol>             # full function body with line numbers
-gmax peek <symbol>                # signature + callers + callees
-gmax trace <symbol> -d 2          # call graph (multi-hop)
-gmax skeleton <path>              # file structure (signatures only)
-gmax symbols --agent              # list all indexed symbols
-
-### Analysis
-gmax diff [ref] --agent           # search scoped to git changes
-gmax test <symbol> --agent        # find tests via reverse call graph
-gmax impact <symbol> --agent      # dependents + affected tests
-gmax similar <symbol> --agent     # vector-to-vector similarity
-gmax context "topic" --budget 4k  # token-budgeted topic summary
-
-### Project
-gmax project --agent              # languages, structure, key symbols
-gmax related <file> --agent       # dependencies + dependents
-gmax recent --agent               # recently modified files
-gmax status --agent               # all indexed projects
-
-### Management
-gmax add                          # add + index current directory
-gmax index                        # reindex current project
-gmax doctor --fix                 # health check + auto-repair
-
-## Tips
-
-- Be specific. "auth" is vague. "where does the server validate JWT tokens" is specific.
-- Use --role ORCHESTRATION to skip type definitions and find actual logic.
-- Use --symbol when the query is a function/class name — gets search + trace in one shot.
-- Don't search for exact strings — use grep for that. gmax finds concepts.
-- If search returns nothing, run: gmax add
-\`;
-
-const GMAX_BIN = "${gmaxBin}";
+  // 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', '--agent']")
@@ -115,7 +74,7 @@ export default tool({
   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.
@@ -133,12 +92,20 @@ Please wait for indexing to complete before searching.\`;
 })`;
 }
 function buildPluginContent(gmaxBin) {
-    return `import { execFileSync } from "node:child_process";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
+    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";
 
-const GMAX_BIN = "${gmaxBin}";
+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 {
@@ -151,26 +118,23 @@ function isProjectRegistered() {
   }
 }
 
+function startDaemon() {
+  const bin = resolveGmaxBin();
+  if (!bin || !isProjectRegistered()) return;
+  try {
+    execFileSync(bin, ["watch", "--daemon", "-b"], {
+      timeout: 5000,
+      stdio: "ignore",
+    });
+  } catch {}
+}
+
 export const GmaxPlugin = async () => {
-  // Start daemon on session creation if project is indexed
-  if (isProjectRegistered()) {
-    try {
-      execFileSync(GMAX_BIN, ["watch", "--daemon", "-b"], {
-        timeout: 5000,
-        stdio: "ignore",
-      });
-    } catch {}
-  }
+  startDaemon();
 
   return {
     "session.created": async () => {
-      if (!isProjectRegistered()) return;
-      try {
-        execFileSync(GMAX_BIN, ["watch", "--daemon", "-b"], {
-          timeout: 5000,
-          stdio: "ignore",
-        });
-      } catch {}
+      startDaemon();
     },
   };
 };
@@ -181,19 +145,17 @@ function install() {
         var _a;
         try {
             // 1. Delete legacy plugin
-            for (const legacy of [LEGACY_PLUGIN_PATH]) {
-                if (node_fs_1.default.existsSync(legacy)) {
-                    try {
-                        node_fs_1.default.unlinkSync(legacy);
-                        console.log("Deleted legacy plugin at", legacy);
-                    }
-                    catch (_b) { }
+            if (node_fs_1.default.existsSync(LEGACY_PLUGIN_PATH)) {
+                try {
+                    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);

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/commands/watch.js

@@ -44,6 +44,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.watch = void 0;
 const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const commander_1 = require("commander");
 const config_1 = require("../config");
@@ -79,6 +80,16 @@ exports.watch = new commander_1.Command("watch")
         if (options.background) {
             // Skip spawn if daemon already running — prevents process accumulation
             // when SessionStart hook fires on every session/clear/resume
+            const pidFile = config_1.PATHS.daemonPidFile;
+            try {
+                const existingPid = Number.parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
+                if (existingPid) {
+                    process.kill(existingPid, 0); // throws if dead
+                    process.exit(0); // alive — skip
+                }
+            }
+            catch (_c) { }
+            // Also check socket as fallback
             const { isDaemonRunning } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
             if (yield isDaemonRunning()) {
                 process.exit(0);

package/dist/config.js

@@ -95,6 +95,7 @@ exports.PATHS = {
     grammars: path.join(GLOBAL_ROOT, "grammars"),
     logsDir: path.join(GLOBAL_ROOT, "logs"),
     daemonSocket: path.join(GLOBAL_ROOT, "daemon.sock"),
+    daemonPidFile: path.join(GLOBAL_ROOT, "daemon.pid"),
     // Centralized index storage — one database for all indexed directories
     lancedbDir: path.join(GLOBAL_ROOT, "lancedb"),
     cacheDir: path.join(GLOBAL_ROOT, "cache"),

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/dist/lib/daemon/daemon.js

@@ -81,11 +81,27 @@ class Daemon {
                 yield (0, process_1.killProcess)(w.pid);
                 (0, watcher_store_1.unregisterWatcher)(w.pid);
             }
-            // 2. Stale socket cleanup
+            // 2. PID file — atomic dedup guard
+            const pidFile = config_1.PATHS.daemonPidFile;
+            try {
+                // Check if another daemon is alive
+                const existingPid = Number.parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
+                if (existingPid && existingPid !== process.pid) {
+                    try {
+                        process.kill(existingPid, 0); // throws if dead
+                        console.error("[daemon] Another daemon is already running (PID:", existingPid + ")");
+                        process.exit(0);
+                    }
+                    catch (_a) { }
+                }
+            }
+            catch (_b) { }
+            fs.writeFileSync(pidFile, String(process.pid));
+            // 3. Stale socket cleanup
             try {
                 fs.unlinkSync(config_1.PATHS.daemonSocket);
             }
-            catch (_a) { }
+            catch (_c) { }
             // 3. Open shared resources
             try {
                 fs.mkdirSync(config_1.PATHS.cacheDir, { recursive: true });
@@ -99,10 +115,19 @@ class Daemon {
             }
             // 4. Register daemon (only after resources are open)
             (0, watcher_store_1.registerDaemon)(process.pid);
-            // 5. Subscribe to all registered projects
+            // 5. Subscribe to all registered projects (skip missing directories)
             const projects = (0, project_registry_1.listProjects)().filter((p) => p.status === "indexed");
             for (const p of projects) {
-                yield this.watchProject(p.root);
+                if (!fs.existsSync(p.root)) {
+                    console.log(`[daemon] Skipping ${path.basename(p.root)} — directory not found`);
+                    continue;
+                }
+                try {
+                    yield this.watchProject(p.root);
+                }
+                catch (err) {
+                    console.error(`[daemon] Failed to watch ${path.basename(p.root)}:`, err);
+                }
             }
             // 6. Heartbeat
             this.heartbeatInterval = setInterval(() => {
@@ -253,12 +278,16 @@ class Daemon {
                 catch (_d) { }
             }
             this.subscriptions.clear();
-            // Close server + socket
+            // Close server + socket + PID file
             (_a = this.server) === null || _a === void 0 ? void 0 : _a.close();
             try {
                 fs.unlinkSync(config_1.PATHS.daemonSocket);
             }
             catch (_e) { }
+            try {
+                fs.unlinkSync(config_1.PATHS.daemonPidFile);
+            }
+            catch (_f) { }
             // Unregister all
             for (const root of this.processors.keys()) {
                 (0, watcher_store_1.unregisterWatcherByRoot)(root);
@@ -269,11 +298,11 @@ class Daemon {
             try {
                 yield ((_b = this.metaCache) === null || _b === void 0 ? void 0 : _b.close());
             }
-            catch (_f) { }
+            catch (_g) { }
             try {
                 yield ((_c = this.vectorDb) === null || _c === void 0 ? void 0 : _c.close());
             }
-            catch (_g) { }
+            catch (_h) { }
             console.log("[daemon] Shutdown complete");
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.11.3",
+  "version": "0.12.1",
   "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.3",
+  "version": "0.12.1",
   "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
+  }
+}