grepmax 0.12.2 → 0.12.3

package/dist/commands/codex.js

@@ -21,46 +21,62 @@ const node_util_1 = require("node:util");
 const commander_1 = require("commander");
 const shell = process.env.SHELL || (process.platform === "win32" ? "cmd.exe" : "/bin/sh");
 const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
-const SKILL = `
----
-name: gmax
-description: Semantic code search and call-graph tracing via gmax.
----
-
-## ⚠️ CRITICAL: Handling "Indexing" State
-If the tool output says **"Indexing"**, **"Building"**, or **"Syncing"**:
-1. **STOP.** Do not hallucinate results.
-2. **INFORM** the user: "The semantic index is still building. Results are partial."
-3. **ASK** if they want to proceed or wait.
-
-## Commands
-- Search: \`gmax "auth logic" --compact\`
-- Trace: \`gmax trace "AuthService"\`
-`;
+const AGENTS_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".codex", "AGENTS.md");
+const SKILL_START = "<!-- gmax:start -->";
+const SKILL_END = "<!-- gmax:end -->";
+function getPackageRoot() {
+    return node_path_1.default.resolve(__dirname, "../..");
+}
+function loadSkill() {
+    const skillPath = node_path_1.default.join(getPackageRoot(), "plugins", "grepmax", "skills", "grepmax", "SKILL.md");
+    try {
+        return node_fs_1.default.readFileSync(skillPath, "utf-8");
+    }
+    catch (_a) {
+        return [
+            "---",
+            "name: gmax",
+            "description: Semantic code search. Use alongside grep - grep for exact strings, gmax for concepts.",
+            "---",
+            "",
+            'Use `gmax "query" --agent` for semantic search.',
+        ].join("\n");
+    }
+}
+function writeSkillToAgents(skill) {
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(AGENTS_PATH), { recursive: true });
+    const block = `${SKILL_START}\n${skill.trim()}\n${SKILL_END}`;
+    if (!node_fs_1.default.existsSync(AGENTS_PATH)) {
+        node_fs_1.default.writeFileSync(AGENTS_PATH, block);
+        return;
+    }
+    const content = node_fs_1.default.readFileSync(AGENTS_PATH, "utf-8");
+    // Check if file has any gmax content (markers or legacy)
+    if (content.includes("gmax")) {
+        // Remove all gmax content and rewrite with just our block
+        const markerRe = new RegExp(`\n?${SKILL_START}[\\s\\S]*?${SKILL_END}\n?`, "g");
+        const cleaned = content.replace(markerRe, "");
+        // Remove legacy content (everything between --- blocks mentioning gmax)
+        const withoutLegacy = cleaned.replace(/---[\s\S]*?(?:gmax|--compact)[\s\S]*?(?=\n<!-- |$)/, "").trim();
+        node_fs_1.default.writeFileSync(AGENTS_PATH, withoutLegacy ? `${withoutLegacy}\n\n${block}` : block);
+    }
+    else {
+        node_fs_1.default.writeFileSync(AGENTS_PATH, `${content.trim()}\n\n${block}`);
+    }
+}
 function installPlugin() {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            // 1. Register the MCP Tool
-            // 'gmax mcp' acts as the server.
+            // 1. Register MCP tool
             yield execAsync("codex mcp add gmax gmax mcp", {
                 shell,
                 env: process.env,
             });
             console.log("✅ gmax MCP tool registered with Codex");
-            // 2. Add Instructions to AGENTS.md
-            const destPath = node_path_1.default.join(node_os_1.default.homedir(), ".codex", "AGENTS.md");
-            node_fs_1.default.mkdirSync(node_path_1.default.dirname(destPath), { recursive: true });
-            const content = node_fs_1.default.existsSync(destPath)
-                ? node_fs_1.default.readFileSync(destPath, "utf-8")
-                : "";
-            // Only append if not present
-            if (!content.includes("name: gmax")) {
-                node_fs_1.default.appendFileSync(destPath, `\n${SKILL}`);
-                console.log("✅ gmax skill instructions added to Codex");
-            }
-            else {
-                console.log("ℹ️  gmax skill instructions already present");
-            }
+            // 2. Write SKILL to AGENTS.md (idempotent)
+            const skill = loadSkill();
+            writeSkillToAgents(skill);
+            console.log("✅ gmax skill instructions written to", AGENTS_PATH);
         }
         catch (error) {
             console.error(`❌ Error installing Codex plugin: ${error}`);
@@ -74,17 +90,16 @@ function uninstallPlugin() {
             yield execAsync("codex mcp remove gmax", { shell, env: process.env });
             console.log("✅ gmax MCP tool removed");
         }
-        catch (_e) {
+        catch (_a) {
             /* ignore if not found */
         }
-        const destPath = node_path_1.default.join(node_os_1.default.homedir(), ".codex", "AGENTS.md");
-        if (node_fs_1.default.existsSync(destPath)) {
-            let content = node_fs_1.default.readFileSync(destPath, "utf-8");
-            // Naive removal: strictly matches the block we added.
-            // For robust removal, you might need regex, but this works if the string is exact.
-            if (content.includes(SKILL)) {
-                content = content.replace(SKILL, "").trim();
-                node_fs_1.default.writeFileSync(destPath, content);
+        if (node_fs_1.default.existsSync(AGENTS_PATH)) {
+            let content = node_fs_1.default.readFileSync(AGENTS_PATH, "utf-8");
+            // Remove marked block
+            const markerRe = new RegExp(`\n?${SKILL_START}[\\s\\S]*?${SKILL_END}\n?`, "g");
+            if (markerRe.test(content)) {
+                content = content.replace(markerRe, "").trim();
+                node_fs_1.default.writeFileSync(AGENTS_PATH, content || "");
                 console.log("✅ gmax instructions removed from AGENTS.md");
             }
         }

package/dist/commands/droid.js

@@ -13,57 +13,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uninstallDroid = exports.installDroid = void 0;
+const node_child_process_1 = require("node:child_process");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const commander_1 = require("commander");
-const SKILL = `
----
-name: gmax
-description: Semantic code search and call-graph tracing for AI agents. Finds code by concept, surfaces roles (ORCHESTRATION vs DEFINITION), and traces dependencies.
-allowed-tools: "Bash(gmax:*), Read"
-license: Apache-2.0
----
-
-## ⚠️ CRITICAL: Handling "Indexing" State
-If any \`gmax\` command returns a status indicating **"Indexing"**, **"Building"**, or **"Syncing"**:
-1. **STOP** your current train of thought.
-2. **INFORM** the user: "The semantic index is currently building. Search results will be incomplete."
-3. **ASK**: "Do you want me to proceed with partial results, or wait for indexing to finish?"
-   *(Do not assume you should proceed without confirmation).*
-
-## Core Commands
-- Search: \`gmax "how does auth work" --compact\`
-- Trace: \`gmax trace "AuthService"\`
-- Symbols: \`gmax symbols "Auth"\`
-
-## Output (Default = Compact TSV)
-- One line per hit: \`path\\tlines\\tscore\\trole\\tconf\\tdefined\\tpreview\`
-- Roles: \`ORCH\` (Orchestration), \`DEF\` (Definition), \`IMPL\` (Implementation).
-- **Note:** If output is empty but valid, say "No semantic matches found."
-
-## Typical Workflow
-
-1. **Discover**
-   \`\`\`bash
-   gmax "worker pool lifecycle" --compact
-   \`\`\`
-
-2. **Explore**
-   \`\`\`bash
-   gmax symbols Worker
-   \`\`\`
-
-3. **Trace**
-   \`\`\`bash
-   gmax trace WorkerPool
-   \`\`\`
-
-4. **Read**
-   \`\`\`bash
-   Read src/lib/workers/pool.ts:112-186
-   \`\`\`
-`;
 function resolveDroidRoot() {
     const root = node_path_1.default.join(node_os_1.default.homedir(), ".factory");
     if (!node_fs_1.default.existsSync(root)) {
@@ -71,6 +25,37 @@ function resolveDroidRoot() {
     }
     return root;
 }
+function resolveGmaxBin() {
+    try {
+        return (0, node_child_process_1.execSync)("which gmax", { encoding: "utf-8", stdio: "pipe" }).trim();
+    }
+    catch (_a) {
+        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))
+            return candidate;
+        return "gmax";
+    }
+}
+function getPackageRoot() {
+    return node_path_1.default.resolve(__dirname, "../..");
+}
+function loadSkill() {
+    const skillPath = node_path_1.default.join(getPackageRoot(), "plugins", "grepmax", "skills", "grepmax", "SKILL.md");
+    try {
+        return node_fs_1.default.readFileSync(skillPath, "utf-8");
+    }
+    catch (_a) {
+        return [
+            "---",
+            "name: gmax",
+            "description: Semantic code search.",
+            "---",
+            "",
+            'Use `gmax "query" --agent` for semantic search.',
+        ].join("\n");
+    }
+}
 function writeFileIfChanged(filePath, content) {
     node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
     const already = node_fs_1.default.existsSync(filePath)
@@ -105,7 +90,6 @@ function mergeHooks(existing, incoming) {
     for (const [event, entries] of Object.entries(incoming)) {
         const current = merged[event] || [];
         for (const entry of entries) {
-            // Simple duplicate check based on command string
             const cmd = entry.hooks[0].command;
             if (!current.some((c) => c.hooks[0].command === cmd)) {
                 current.push(entry);
@@ -115,37 +99,56 @@ function mergeHooks(existing, incoming) {
     }
     return merged;
 }
-// --- MAIN INSTALLER ---
+// --- Installer ---
 function installPlugin() {
     return __awaiter(this, void 0, void 0, function* () {
         const root = resolveDroidRoot();
+        const gmaxBin = resolveGmaxBin();
         const hooksDir = node_path_1.default.join(root, "hooks", "gmax");
         const skillsDir = node_path_1.default.join(root, "skills", "gmax");
         const settingsPath = node_path_1.default.join(root, "settings.json");
-        // 1. Install Hook Scripts (Start/Stop Daemon)
-        // We expect these files to exist in your dist/hooks folder
-        const startJsPath = node_path_1.default.join(hooksDir, "gmax_start.js");
-        const stopJsPath = node_path_1.default.join(hooksDir, "gmax_stop.js");
-        // Create these scripts dynamically if we don't want to read from dist
+        // 1. Install hook scripts (start/stop daemon)
         const startScript = `
-const { spawn } = require("child_process");
+const { execFileSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
-const logDir = path.join(require("os").homedir(), ".gmax", "logs");
-fs.mkdirSync(logDir, { recursive: true });
-const out = fs.openSync(path.join(logDir, "gmax.log"), "a");
-const child = spawn("gmax", ["serve"], { detached: true, stdio: ["ignore", out, out] });
-child.unref();
-`;
+const os = require("os");
+
+const BIN = "${gmaxBin}";
+
+function resolveGmax() {
+  if (fs.existsSync(BIN)) return BIN;
+  try {
+    return require("child_process").execSync("which gmax", { encoding: "utf-8" }).trim();
+  } catch { return null; }
+}
+
+function isProjectRegistered() {
+  try {
+    const projectsPath = path.join(os.homedir(), ".gmax", "projects.json");
+    const projects = JSON.parse(fs.readFileSync(projectsPath, "utf-8"));
+    const cwd = process.cwd();
+    return projects.some((p) => cwd.startsWith(p.root));
+  } catch { return false; }
+}
+
+const bin = resolveGmax();
+if (bin && isProjectRegistered()) {
+  try { execFileSync(bin, ["watch", "--daemon", "-b"], { timeout: 5000, stdio: "ignore" }); } catch {}
+}
+`.trim();
         const stopScript = `
-const { spawnSync, execSync } = require("child_process");
-try { execSync("gmax serve stop", { stdio: "ignore" }); } catch {}
-`;
-        writeFileIfChanged(startJsPath, startScript.trim());
-        writeFileIfChanged(stopJsPath, stopScript.trim());
-        // 2. Install Skill (with Indexing Warning)
-        writeFileIfChanged(node_path_1.default.join(skillsDir, "SKILL.md"), SKILL.trimStart());
-        // 3. Configure Settings
+const { execFileSync } = require("child_process");
+try { execFileSync("gmax", ["watch", "stop", "--all"], { stdio: "ignore", timeout: 5000 }); } catch {}
+`.trim();
+        const startJsPath = node_path_1.default.join(hooksDir, "gmax_start.js");
+        const stopJsPath = node_path_1.default.join(hooksDir, "gmax_stop.js");
+        writeFileIfChanged(startJsPath, startScript);
+        writeFileIfChanged(stopJsPath, stopScript);
+        // 2. Install SKILL (read from package root)
+        const skill = loadSkill();
+        writeFileIfChanged(node_path_1.default.join(skillsDir, "SKILL.md"), skill.trim());
+        // 3. Configure settings
         const hookConfig = {
             SessionStart: [
                 {
@@ -168,7 +171,7 @@ try { execSync("gmax serve stop", { stdio: "ignore" }); } catch {}
         settings.allowBackgroundProcesses = true;
         settings.hooks = mergeHooks(settings.hooks, hookConfig);
         saveSettings(settingsPath, settings);
-        console.log(`✅ gmax installed for Factory Droid (Hooks + Skill)`);
+        console.log("✅ gmax installed for Factory Droid (Hooks + Skill)");
     });
 }
 function uninstallPlugin() {

package/dist/commands/plugin.js

@@ -107,7 +107,7 @@ function getClients() {
             isInstalled: () => {
                 const p = path.join(os.homedir(), ".codex", "AGENTS.md");
                 try {
-                    return fs.existsSync(p) && fs.readFileSync(p, "utf-8").includes("name: gmax");
+                    return fs.existsSync(p) && fs.readFileSync(p, "utf-8").includes("gmax");
                 }
                 catch (_a) {
                     return false;

package/dist/lib/search/searcher.js

@@ -394,7 +394,18 @@ class Searcher {
                     ftsSearchFailed = true;
                     this.ftsAvailable = false;
                     const msg = e instanceof Error ? e.message : String(e);
-                    console.warn(`[Searcher] FTS search failed (will retry later): ${msg}`);
+                    if (msg.includes("position")) {
+                        // FTS index lacks positional data — rebuild it
+                        try {
+                            yield this.db.createFTSIndex(true);
+                            this.ftsAvailable = true;
+                            console.warn("[Searcher] Rebuilt FTS index with position support — retry search");
+                        }
+                        catch (_k) { }
+                    }
+                    else {
+                        console.warn(`[Searcher] FTS search failed (will retry later): ${msg}`);
+                    }
                 }
             }
             if (signal === null || signal === void 0 ? void 0 : signal.aborted) {

package/dist/lib/store/vector-db.js

@@ -260,18 +260,37 @@ class VectorDB {
         });
     }
     createFTSIndex() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (rebuild = false) {
             const table = yield this.ensureTable();
+            if (rebuild) {
+                try {
+                    yield table.dropIndex("content_idx");
+                }
+                catch (_a) { }
+            }
             try {
                 yield table.createIndex("content", {
-                    config: lancedb.Index.fts(),
+                    config: lancedb.Index.fts({ withPosition: true }),
                 });
             }
             catch (e) {
                 const msg = e instanceof Error ? e.message : String(e);
-                if (!msg.includes("already exists")) {
-                    console.warn("Failed to create FTS index:", e);
+                if (msg.includes("already exists")) {
+                    return;
+                }
+                // If position error, try dropping and recreating
+                if (msg.includes("position")) {
+                    try {
+                        yield table.dropIndex("content_idx");
+                        yield table.createIndex("content", {
+                            config: lancedb.Index.fts({ withPosition: true }),
+                        });
+                        (0, logger_1.log)("vectordb", "Rebuilt FTS index with position support");
+                        return;
+                    }
+                    catch (_b) { }
                 }
+                console.warn("Failed to create FTS index:", e);
             }
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.12.2",
+  "version": "0.12.3",
   "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.12.2",
+  "version": "0.12.3",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",

package/scripts/postinstall.js

@@ -1,78 +1,121 @@
 #!/usr/bin/env node
 /**
- * Postinstall: sync plugin files (SKILL.md, hooks, plugin.json) to
- * the Claude Code plugin cache if it exists. This ensures `npm update -g grepmax`
- * automatically updates the skill instructions without needing `gmax install-claude-code`.
+ * Postinstall: sync plugin files to all installed integrations.
+ * Runs after `npm install -g grepmax@latest` to automatically update
+ * skills, hooks, and configs without manual re-installation.
+ *
+ * Supported integrations:
+ * - Claude Code: sync skills/hooks to plugin cache
+ * - OpenCode: re-run installer (regenerates tool shim + plugin)
+ * - Codex: re-run installer (updates AGENTS.md + MCP registration)
+ * - Factory Droid: re-run installer (updates skills + hooks)
  */
 const fs = require("node:fs");
 const path = require("node:path");
 const os = require("node:os");
+const { execSync } = require("node:child_process");
 
-const pluginCacheBase = path.join(os.homedir(), ".claude", "plugins", "cache", "grepmax", "grepmax");
 const sourcePlugin = path.join(__dirname, "..", "plugins", "grepmax");
 
-if (!fs.existsSync(pluginCacheBase) || !fs.existsSync(sourcePlugin)) {
-  // Plugin not installed via Claude Code — skip silently
-  process.exit(0);
-}
+// --- Claude Code: sync files to plugin cache ---
+const pluginCacheBase = path.join(
+  os.homedir(),
+  ".claude",
+  "plugins",
+  "cache",
+  "grepmax",
+  "grepmax",
+);
 
-// Find installed version directories
-let entries;
-try {
-  entries = fs.readdirSync(pluginCacheBase, { withFileTypes: true });
-} catch {
-  process.exit(0);
-}
+if (fs.existsSync(pluginCacheBase) && fs.existsSync(sourcePlugin)) {
+  let entries;
+  try {
+    entries = fs.readdirSync(pluginCacheBase, { withFileTypes: true });
+  } catch {
+    entries = [];
+  }
 
-const versionDirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
-if (versionDirs.length === 0) process.exit(0);
+  const versionDirs = entries
+    .filter((e) => e.isDirectory())
+    .map((e) => e.name);
 
-// Sync files to each installed version
-function copyRecursive(src, dest) {
-  if (!fs.existsSync(src)) return;
-  const stat = fs.statSync(src);
-  if (stat.isDirectory()) {
-    fs.mkdirSync(dest, { recursive: true });
-    for (const entry of fs.readdirSync(src)) {
-      copyRecursive(path.join(src, entry), path.join(dest, entry));
+  function copyRecursive(src, dest) {
+    if (!fs.existsSync(src)) return;
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+      fs.mkdirSync(dest, { recursive: true });
+      for (const entry of fs.readdirSync(src)) {
+        copyRecursive(path.join(src, entry), path.join(dest, entry));
+      }
+    } else {
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      fs.copyFileSync(src, dest);
     }
-  } else {
-    fs.mkdirSync(path.dirname(dest), { recursive: true });
-    fs.copyFileSync(src, dest);
   }
-}
 
-for (const ver of versionDirs) {
-  const destDir = path.join(pluginCacheBase, ver);
-  try {
-    // Sync skills
-    copyRecursive(
-      path.join(sourcePlugin, "skills"),
-      path.join(destDir, "skills"),
-    );
-    // Sync hooks
-    copyRecursive(
-      path.join(sourcePlugin, "hooks"),
-      path.join(destDir, "hooks"),
-    );
-    // Sync hooks.json
-    const hooksJson = path.join(sourcePlugin, "hooks.json");
-    if (fs.existsSync(hooksJson)) {
-      fs.copyFileSync(hooksJson, path.join(destDir, "hooks.json"));
+  for (const ver of versionDirs) {
+    const destDir = path.join(pluginCacheBase, ver);
+    try {
+      copyRecursive(
+        path.join(sourcePlugin, "skills"),
+        path.join(destDir, "skills"),
+      );
+      copyRecursive(
+        path.join(sourcePlugin, "hooks"),
+        path.join(destDir, "hooks"),
+      );
+      const hooksJson = path.join(sourcePlugin, "hooks.json");
+      if (fs.existsSync(hooksJson)) {
+        fs.copyFileSync(hooksJson, path.join(destDir, "hooks.json"));
+      }
+    } catch {
+      // Best-effort
     }
-  } catch {
-    // 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");
+// --- 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
-  }
+    execSync("gmax install-opencode", { stdio: "ignore", timeout: 10000 });
+  } catch {}
+}
+
+// --- Codex: re-run installer if AGENTS.md has gmax skill ---
+const codexAgentsPath = path.join(os.homedir(), ".codex", "AGENTS.md");
+if (fs.existsSync(codexAgentsPath)) {
+  try {
+    const content = fs.readFileSync(codexAgentsPath, "utf-8");
+    if (content.includes("gmax")) {
+      execSync("gmax install-codex", { stdio: "ignore", timeout: 10000 });
+    }
+  } catch {}
+}
+
+// --- Factory Droid: re-run installer if skill exists ---
+const droidSkillPath = path.join(
+  os.homedir(),
+  ".factory",
+  "skills",
+  "gmax",
+  "SKILL.md",
+);
+if (fs.existsSync(droidSkillPath)) {
+  try {
+    execSync("gmax install-droid", { stdio: "ignore", timeout: 10000 });
+  } catch {}
 }