grepmax 0.16.5 → 0.16.9

package/README.md

@@ -60,8 +60,7 @@ gmax symbols auth                       # List indexed symbols
 ### Analysis Commands
 
 ```bash
-gmax diff main                           # Changed files vs main
-gmax diff main --query "auth changes"    # Semantic search within changes
+gmax log src/lib/auth.ts                 # Git commit history for a path or symbol
 gmax test handleAuth                     # Find tests via reverse call graph
 gmax impact handleAuth                   # Dependents + affected tests
 gmax similar handleAuth                  # Find similar code patterns
@@ -73,7 +72,6 @@ gmax context "auth system" --budget 4000 # Token-budgeted topic summary
 ```bash
 gmax project                  # Languages, structure, key symbols
 gmax related src/lib/auth.ts  # Dependencies + dependents
-gmax recent                   # Recently modified files
 gmax status                   # All indexed projects + chunk counts
 ```
 

package/dist/commands/watch.js

@@ -309,14 +309,28 @@ exports.watch
     var _a;
     const { isDaemonRunning, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
     let stoppedDaemon = false;
+    let daemonPid;
     // Try shutting down daemon first
     if (yield isDaemonRunning()) {
+        // Capture PID before IPC shutdown so the --all loop below can skip the
+        // daemon's own watcher-store entries (it registers itself under every
+        // watched project's PID — racing killProcess against the in-flight
+        // graceful shutdown is what produced "did not exit after SIGKILL"
+        // storms and the orphaned pid/sock/lock files this code path used to
+        // leave behind).
+        try {
+            const pidRaw = yield fs.promises.readFile(config_1.PATHS.daemonPidFile, "utf-8");
+            const parsed = parseInt(pidRaw.trim(), 10);
+            if (Number.isFinite(parsed) && parsed > 0)
+                daemonPid = parsed;
+        }
+        catch (_b) { }
         let parentCmd = "?";
         try {
             const { execSync } = yield Promise.resolve().then(() => __importStar(require("node:child_process")));
             parentCmd = execSync(`ps -o command= -p ${process.ppid}`, { encoding: "utf8" }).trim();
         }
-        catch (_b) { }
+        catch (_c) { }
         yield sendDaemonCommand({
             cmd: "shutdown",
             reason: "gmax-watch-stop",
@@ -325,20 +339,38 @@ exports.watch
             from_argv: process.argv.slice(0, 4),
             from_parent_cmd: parentCmd,
         });
+        // Wait for the daemon to actually exit before we start killing watcher
+        // entries — many of those entries share the daemon's PID. Poll for up
+        // to 10s; shutdown work can take a few seconds on large indexes.
+        if (daemonPid) {
+            for (let i = 0; i < 100; i++) {
+                if (!(0, watcher_store_1.isProcessRunning)(daemonPid))
+                    break;
+                yield new Promise((r) => setTimeout(r, 100));
+            }
+        }
         console.log("Daemon stopped.");
         stoppedDaemon = true;
     }
     if (options.all) {
         const watchers = (0, watcher_store_1.listWatchers)();
+        const seenPids = new Set();
+        let projectStops = 0;
         for (const w of watchers) {
+            if (daemonPid && w.pid === daemonPid)
+                continue;
+            if (seenPids.has(w.pid))
+                continue;
+            seenPids.add(w.pid);
             const killed = yield (0, process_1.killProcess)(w.pid);
             (0, watcher_store_1.unregisterWatcher)(w.pid);
+            projectStops++;
             if (!killed) {
                 console.warn(`Warning: PID ${w.pid} did not exit after SIGKILL`);
             }
         }
-        if (watchers.length > 0) {
-            console.log(`Stopped ${watchers.length} per-project watcher(s).`);
+        if (projectStops > 0) {
+            console.log(`Stopped ${projectStops} per-project watcher(s).`);
         }
         else if (!stoppedDaemon) {
             console.log("No running watchers.");

package/dist/lib/daemon/daemon.js

@@ -1310,6 +1310,24 @@ class Daemon {
                 return;
             this.shuttingDown = true;
             console.log("[daemon] Shutting down...");
+            // Drop external liveness markers FIRST so the next daemon start isn't
+            // fooled by leftover state if the long cleanup below is interrupted
+            // (uncaught exception, second SIGTERM, OOM kill mid-shutdown). The
+            // fresh-lock check in isDaemonHeartbeatFresh keyed on these — orphans
+            // here used to cause silent no-op spawns for up to 150s.
+            try {
+                fs.unlinkSync(config_1.PATHS.daemonSocket);
+            }
+            catch (_e) { }
+            try {
+                fs.unlinkSync(config_1.PATHS.daemonPidFile);
+            }
+            catch (_f) { }
+            if (this.releaseLock) {
+                const release = this.releaseLock;
+                this.releaseLock = null;
+                release().catch(() => { });
+            }
             if (this.heartbeatInterval)
                 clearInterval(this.heartbeatInterval);
             if (this.idleInterval)
@@ -1332,7 +1350,7 @@ class Daemon {
             try {
                 yield ((_a = this.llmServer) === null || _a === void 0 ? void 0 : _a.stop());
             }
-            catch (_e) { }
+            catch (_g) { }
             // Stop MLX embed server if we started it
             this.stopMlxServer();
             // Destroy worker pool to prevent orphaned child processes
@@ -1340,7 +1358,7 @@ class Daemon {
                 try {
                     yield (0, pool_1.destroyWorkerPool)();
                 }
-                catch (_f) { }
+                catch (_h) { }
             }
             // Stop poll intervals + their FSEvents recovery probes
             for (const interval of this.pollIntervals.values()) {
@@ -1356,26 +1374,11 @@ class Daemon {
                 try {
                     yield sub.unsubscribe();
                 }
-                catch (_g) { }
+                catch (_j) { }
             }
             this.subscriptions.clear();
-            // Close server + socket + PID file + lock
+            // Close server (socket/pid/lock already dropped at the top of shutdown)
             (_b = this.server) === null || _b === void 0 ? void 0 : _b.close();
-            try {
-                fs.unlinkSync(config_1.PATHS.daemonSocket);
-            }
-            catch (_h) { }
-            try {
-                fs.unlinkSync(config_1.PATHS.daemonPidFile);
-            }
-            catch (_j) { }
-            if (this.releaseLock) {
-                try {
-                    yield this.releaseLock();
-                }
-                catch (_k) { }
-                this.releaseLock = null;
-            }
             // Unregister all
             for (const root of this.processors.keys()) {
                 (0, watcher_store_1.unregisterWatcherByRoot)(root);
@@ -1386,11 +1389,11 @@ class Daemon {
             try {
                 yield ((_c = this.metaCache) === null || _c === void 0 ? void 0 : _c.close());
             }
-            catch (_l) { }
+            catch (_k) { }
             try {
                 yield ((_d = this.vectorDb) === null || _d === void 0 ? void 0 : _d.close());
             }
-            catch (_m) { }
+            catch (_l) { }
             console.log("[daemon] Shutdown complete");
         });
     }

package/dist/lib/utils/daemon-client.js

@@ -122,13 +122,30 @@ function isDaemonRunning(opts) {
  * Lock-file-based liveness probe. A running daemon refreshes daemon.lock's
  * mtime every 60s via its heartbeat loop; a fresh mtime means the daemon is
  * alive even if its socket ping times out under load.
+ *
+ * A fresh mtime alone is not proof of life — a SIGKILL'd (or OOM-killed,
+ * panicked, power-lost) daemon leaves the lock file behind with its last
+ * heartbeat mtime, fooling this check for up to HEARTBEAT_FRESH_THRESHOLD_MS.
+ * Cross-check that the PID file points at an actually-running process.
  */
 function isDaemonHeartbeatFresh() {
     try {
         const stats = fs.statSync(config_1.PATHS.daemonLockFile);
-        return Date.now() - stats.mtimeMs < HEARTBEAT_FRESH_THRESHOLD_MS;
+        if (Date.now() - stats.mtimeMs >= HEARTBEAT_FRESH_THRESHOLD_MS)
+            return false;
+        const pidRaw = fs.readFileSync(config_1.PATHS.daemonPidFile, "utf-8").trim();
+        const pid = parseInt(pidRaw, 10);
+        if (!Number.isFinite(pid) || pid <= 0)
+            return false;
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
     }
-    catch (_a) {
+    catch (_b) {
         return false;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.16.5",
+  "version": "0.16.9",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {
@@ -14,6 +14,27 @@
   "bin": {
     "gmax": "dist/index.js"
   },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "prebuild": "mkdir -p dist",
+    "build": "tsc",
+    "postbuild": "chmod +x dist/index.js",
+    "dev": "npx tsc && node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "benchmark": "./run-benchmark.sh",
+    "benchmark:index": "./run-benchmark.sh $HOME/gmax-benchmarks --index",
+    "benchmark:agent": "npx tsx src/bench/benchmark-agent.ts",
+    "benchmark:chart": "npx tsx src/bench/generate-benchmark-chart.ts",
+    "format": "biome check --write .",
+    "format:check": "biome check .",
+    "lint": "biome lint .",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "pnpm build",
+    "preversion": "pnpm test && pnpm typecheck",
+    "version": "bash scripts/sync-versions.sh && git add -A",
+    "postversion": "git push origin main && git push origin v$npm_package_version && gh release create v$npm_package_version --generate-notes --title v$npm_package_version && sleep 5 && gh run watch $(gh run list --workflow=release.yml --branch v$npm_package_version --limit 1 --json databaseId --jq '.[0].databaseId') --exit-status && sleep 30 && npm cache clean --force && npm install -g grepmax@$npm_package_version"
+  },
   "keywords": [
     "grepmax",
     "grep",
@@ -65,25 +86,5 @@
     "typescript": "^6.0.2",
     "vite": "^8.0.3",
     "vitest": "^4.1.2"
-  },
-  "scripts": {
-    "postinstall": "node scripts/postinstall.js",
-    "prebuild": "mkdir -p dist",
-    "build": "tsc",
-    "postbuild": "chmod +x dist/index.js",
-    "dev": "npx tsc && node dist/index.js",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "benchmark": "./run-benchmark.sh",
-    "benchmark:index": "./run-benchmark.sh $HOME/gmax-benchmarks --index",
-    "benchmark:agent": "npx tsx src/bench/benchmark-agent.ts",
-    "benchmark:chart": "npx tsx src/bench/generate-benchmark-chart.ts",
-    "format": "biome check --write .",
-    "format:check": "biome check .",
-    "lint": "biome lint .",
-    "typecheck": "tsc --noEmit",
-    "preversion": "pnpm test && pnpm typecheck",
-    "version": "bash scripts/sync-versions.sh && git add -A",
-    "postversion": "git push origin main && git push origin v$npm_package_version && gh release create v$npm_package_version --generate-notes --title v$npm_package_version && sleep 5 && gh run watch $(gh run list --workflow=release.yml --branch v$npm_package_version --limit 1 --json databaseId --jq '.[0].databaseId') --exit-status && sleep 30 && npm cache clean --force && npm install -g grepmax@$npm_package_version"
   }
-}
+}

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

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

package/plugins/grepmax/hooks/start.js

@@ -187,8 +187,10 @@ Understand:
   gmax trace <symbol>                call graph (--inbound = callers + snippets)
   gmax test <symbol>                 tests for symbol
   gmax impact <symbol>               blast radius
+  gmax related <file>                file deps + dependents
 
 Survey:
+  gmax project                       codebase overview (langs, structure, key symbols)
   gmax skeleton <file>               file structure (file path, NOT a directory)
   gmax context "topic" --budget 4000 multi-file topic summary
   gmax log <path-or-symbol>          git commits (replaces recent/diff)
@@ -196,7 +198,7 @@ Survey:
 
 Scope flags: --root <name|path>, --in <subpath>, --exclude <subpath>.
 Roles in results: [DEFI] [ORCH] [IMPL] [DOCS].
-Recovery: "not added yet" → gmax add; stale results → gmax index.`,
+Recovery: "not added yet" → gmax add; stale → gmax index; broken → gmax doctor --fix.`,
     },
   };
   process.stdout.write(JSON.stringify(response));

package/plugins/grepmax/skills/grepmax/SKILL.md

@@ -40,7 +40,7 @@ If search returns "This project hasn't been added to gmax yet", run `Bash(gmax a
 
 ### Search — `gmax "query" --agent`
 
-The `--agent` flag produces compact, token-efficient output for AI agents. It is supported on: `search`, `trace`, `symbols`, `related`, `recent`, `status`, and `project`.
+The `--agent` flag produces compact, token-efficient output for AI agents. It works on most commands — `search`, `peek`, `extract`, `trace`, `test`, `impact`, `similar`, `log`, `related`, `symbols`, `status`, `project`, `context`, `skeleton`, and `doctor`.
 
 ```
 gmax "where do we handle authentication" --agent
@@ -196,12 +196,12 @@ Agentic Q&A: a local LLM autonomously uses gmax tools (search, trace, peek, impa
 ```
 gmax status                                # show all indexed projects
 gmax status --agent                        # compact: name\tchunks\tage\tstatus
-gmax recent --agent                        # compact: path\tage
 gmax related src/file.ts --agent           # compact: dep:/rev: path\tcount
 gmax project --agent                       # compact: key\tvalue pairs
 gmax index                                 # reindex current directory
 gmax config                                # view/change settings
 gmax doctor                                # health check
+gmax doctor --fix                          # auto-repair (compact, prune, clear stale locks)
 gmax llm on/off/start/stop/status          # manage local LLM server
 ```
 
@@ -215,7 +215,7 @@ gmax llm on/off/start/stop/status          # manage local LLM server
 6. **Skeleton** — `Bash(gmax skeleton <path>)` before reading large files, or use `--skeleton` on search
 7. **Read** — `Read file:line` for specific ranges identified by search/skeleton
 8. **Trace** — `Bash(gmax trace <symbol>)` for deep call flow (multi-hop)
-9. **Diff** — `Bash(gmax diff [ref])` to see what changed and search within changes
+9. **Log** — `Bash(gmax log <path-or-symbol>)` for git commit history on a path or symbol
 10. **Test** — `Bash(gmax test <symbol>)` to find tests covering a symbol before editing
 11. **Impact** — `Bash(gmax impact <symbol>)` for blast radius before significant changes
 12. **Similar** — `Bash(gmax similar <symbol>)` to find similar patterns for DRY analysis
@@ -225,7 +225,7 @@ gmax llm on/off/start/stop/status          # manage local LLM server
 
 ## Tips
 
-- **Use `--agent` for compact output** — supported on search, trace, symbols, related, recent, status, project.
+- **Use `--agent` for compact output** — works on most commands: search, peek, extract, trace, log, test, impact, similar, related, status, project, doctor.
 - **Be specific.** 5+ words. "auth" returns noise. "where does the server validate JWT tokens" is specific.
 - **Use `--role ORCHESTRATION`** to skip type definitions and find the actual logic.
 - **Use `--symbol`** when the query is a function/class name — gets search + trace in one call.