grepmax 0.26.13 → 0.26.15

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "grepmax",
       "source": "./plugins/grepmax",
       "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
-      "version": "0.26.13",
+      "version": "0.26.15",
       "author": {
         "name": "Robert Owens",
         "email": "robowens@me.com"

package/dist/commands/doctor.js

@@ -56,6 +56,7 @@ const lock_1 = require("../lib/utils/lock");
 const mlx_hf_cache_1 = require("../lib/utils/mlx-hf-cache");
 const project_registry_1 = require("../lib/utils/project-registry");
 const project_root_1 = require("../lib/utils/project-root");
+const root_availability_1 = require("../lib/utils/root-availability");
 function formatSize(bytes) {
     if (bytes < 1024)
         return `${bytes} B`;
@@ -197,6 +198,7 @@ exports.doctor = new commander_1.Command("doctor")
     let needsOptimize = false;
     let staleLock = false;
     const orphanedProjects = [];
+    const unavailableProjects = [];
     try {
         const { VectorDB, findStaleLanceTempFiles, sweepStaleLanceTempFiles } = yield Promise.resolve().then(() => __importStar(require("../lib/store/vector-db")));
         const db = new VectorDB(config_1.PATHS.lancedbDir);
@@ -250,12 +252,21 @@ exports.doctor = new commander_1.Command("doctor")
         // Daemon status
         const { isDaemonRunning } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
         const daemonUp = yield isDaemonRunning();
-        // Project registry health
+        // Project registry health.
+        //
+        // A root can be unreadable for two very different reasons, and only one of
+        // them is the project's fault. An unplugged external drive or a downed
+        // network share leaves the project perfectly intact — deregistering it
+        // would strand its vectors in the shared table with no owning project and
+        // would not come back when the volume returns. Only a root whose volume is
+        // mounted, and whose directory is still gone, is actually orphaned.
         const projects = (0, project_registry_1.listProjects)();
         for (const p of projects) {
-            if (!fs.existsSync(p.root)) {
+            const availability = (0, root_availability_1.classifyRoot)(p.root);
+            if (availability === "missing")
                 orphanedProjects.push(p.root);
-            }
+            else if (availability === "unavailable")
+                unavailableProjects.push(p.root);
         }
         // Compute warning flags
         //
@@ -313,6 +324,7 @@ exports.doctor = new commander_1.Command("doctor")
                 `lock=${lockStatus.split(" ")[0]}`,
                 `daemon=${daemonUp ? "running" : "stopped"}`,
                 `orphaned=${orphanedProjects.length}`,
+                `offline=${unavailableProjects.length}`,
                 `stale_temp=${staleTempFiles.length}`,
                 `stale_temp_bytes=${staleTempBytes}`,
                 `stale_chunker=${staleChunkerProjects.length}`,
@@ -455,13 +467,19 @@ exports.doctor = new commander_1.Command("doctor")
             if (legacyNotice)
                 console.log(legacyNotice);
             // Projects
+            if (unavailableProjects.length > 0) {
+                console.log(`INFO  Offline projects: ${unavailableProjects.length} (volume not mounted — kept, reconnect to resume)`);
+                for (const up of unavailableProjects) {
+                    console.log(`       - ${up}`);
+                }
+            }
             if (orphanedProjects.length > 0) {
                 console.log(`WARN  Orphaned projects: ${orphanedProjects.length} (directories no longer exist)`);
                 for (const op of orphanedProjects) {
                     console.log(`       - ${op}`);
                 }
             }
-            else if (projects.length > 0) {
+            else if (projects.length > 0 && unavailableProjects.length === 0) {
                 console.log(`ok  Projects: ${projects.length} registered, all directories exist`);
             }
             // Cache Coherence
@@ -563,6 +581,9 @@ exports.doctor = new commander_1.Command("doctor")
                     console.log(`ok  Optimize complete (${via})`);
                 fixed++;
             }
+            // Only roots whose volume is mounted and whose directory is still gone
+            // reach this list — projects on an unplugged drive are classified
+            // `unavailable` and never enter it, so --fix cannot deregister them.
             if (orphanedProjects.length > 0) {
                 for (const op of orphanedProjects) {
                     (0, project_registry_1.removeProject)(op);

package/dist/lib/daemon/daemon.js

@@ -67,6 +67,7 @@ const logger_1 = require("../utils/logger");
 const operation_coordinator_1 = require("../utils/operation-coordinator");
 const process_1 = require("../utils/process");
 const project_registry_1 = require("../utils/project-registry");
+const root_availability_1 = require("../utils/root-availability");
 const watcher_store_1 = require("../utils/watcher-store");
 const pool_1 = require("../workers/pool");
 const ipc_handler_1 = require("./ipc-handler");
@@ -352,7 +353,10 @@ class Daemon {
             const indexed = allProjects.filter((p) => p.status === "indexed");
             for (const p of indexed) {
                 if (!fs.existsSync(p.root)) {
-                    console.log(`[daemon] Skipping ${path.basename(p.root)} — directory not found`);
+                    // Skipping is already the safe behavior — the project keeps its registry
+                    // entry and its vectors either way. Naming the reason keeps an unplugged
+                    // drive from reading like data loss in the log.
+                    console.log(`[daemon] Skipping ${path.basename(p.root)} — ${(0, root_availability_1.describeRoot)(p.root)}`);
                     continue;
                 }
                 try {

package/dist/lib/index/syncer.js

@@ -324,9 +324,13 @@ function initialSync(options) {
                         yield currentFlush;
                         (0, logger_1.debug)("index", `flush done: ${Date.now() - flushStart}ms`);
                         flushCount++;
-                        // Periodically compact during sync to prevent fragment accumulation
+                        // Periodically compact during sync to prevent fragment accumulation.
+                        // Uses the shared threshold deliberately: a hardcoded 30 here meant
+                        // the full-index path kept compacting at the old rate long after the
+                        // threshold was raised to 400, re-triggering the whole-table rewrite
+                        // that raising it exists to avoid.
                         if (flushCount % 10 === 0) {
-                            yield vectorDb.compactIfNeeded(30);
+                            yield vectorDb.compactIfNeeded(config_1.FRAGMENT_COMPACT_THRESHOLD);
                         }
                     }
                     catch (err) {

package/dist/lib/utils/file-utils.js

@@ -187,22 +187,115 @@ function isIndexableFile(filePath, size) {
 function isIndexablePath(filePath) {
     return isIndexableFile(filePath);
 }
-// Well-known machine-generated markers emitted at the top of codegen output.
-// Tools (protoc, graphql-codegen, Apollo, Relay, Go `stringer`, OpenAPI, etc.)
-// stamp one of these in a banner comment. Matched against only the first few KB
-// because the banner is always at the very top — this keeps a hand-written
-// "do not edit this section" note deep in a real file from being misclassified.
-const GENERATED_MARKER = /@generated\b|\bDO NOT EDIT\b|Code generated by |auto-?generated by |This (?:file|code) (?:is|was) (?:\w+[ -])?generated|machine generated|@autogenerated\b/i;
+// Markers that only ever appear in a codegen banner. Any one of these, on its
+// own, is enough. Tools (protoc, graphql-codegen, Apollo, Relay, Go `stringer`,
+// OpenAPI) stamp one of these; doc generators fence their output with the
+// `generated-body` / `AUTO-GENERATED-CONTENT` style directives.
+const STRONG_GENERATED_MARKER = /@generated\b|@autogenerated\b|\bCode generated by |\bauto-?generated by |\bThis (?:file|code) (?:is|was) (?:\w+[ -])?generated|\bmachine[ -]generated\b|\bauto-?generated[-_ ]?content\b|\bgenerated[-_](?:body|content|section|block)\b|\bBEGIN GENERATED\b/i;
+// "DO NOT EDIT" is not proof of codegen on its own — humans write it on prose
+// they want left alone (archived vendor snapshots, verbatim captures). Real
+// codegen banners pair it with a generation word, so require that pairing.
+const DO_NOT_EDIT_MARKER = /\bDO NOT EDIT\b/i;
+const GENERATION_CONTEXT = /generat|codegen|autogen/i;
 const GENERATED_SNIFF_BYTES = 2048;
+const DOC_LIKE_EXTENSIONS = /\.(?:md|mdx|markdown|txt|rst|adoc|asciidoc)$/i;
+/**
+ * Extract the leading banner: the run of shebang, frontmatter, blank, and
+ * comment lines at the very top, stopping at the first line of actual code.
+ *
+ * Scanning raw head bytes instead was the bug this replaces. Two ways it
+ * misfired, both silently erasing hand-written files from the index:
+ *
+ *  - A *generator* was classified as its own output, because the banner it
+ *    emits appears as a string literal in its body
+ *    (`lines.push('# Auto-generated by ...')`).
+ *  - A comment quoting another file's rules ("its README says do not edit")
+ *    counted as a banner.
+ *
+ * A real codegen banner precedes all code, so anchoring here removes both
+ * without weakening detection.
+ *
+ * In doc-like files `#` starts a heading, not a comment, so only frontmatter
+ * and HTML comments count — otherwise the whole document body would be read as
+ * banner.
+ */
+function leadingBanner(head, filePath) {
+    var _a, _b;
+    const docLike = filePath ? DOC_LIKE_EXTENSIONS.test(filePath) : false;
+    const lines = head.split("\n");
+    const banner = [];
+    let i = 0;
+    if (!docLike && ((_a = lines[0]) === null || _a === void 0 ? void 0 : _a.startsWith("#!"))) {
+        banner.push(lines[0]);
+        i = 1;
+    }
+    // YAML frontmatter is metadata, not code — a generated-doc marker often sits
+    // directly after it.
+    if (((_b = lines[i]) === null || _b === void 0 ? void 0 : _b.trim()) === "---") {
+        banner.push(lines[i]);
+        i++;
+        while (i < lines.length && lines[i].trim() !== "---")
+            banner.push(lines[i++]);
+        if (i < lines.length)
+            banner.push(lines[i++]);
+    }
+    let blockEnd;
+    for (; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (blockEnd) {
+            banner.push(line);
+            if (trimmed.includes(blockEnd))
+                blockEnd = undefined;
+            continue;
+        }
+        if (trimmed === "") {
+            banner.push(line);
+            continue;
+        }
+        if (trimmed.startsWith("<!--")) {
+            banner.push(line);
+            if (!trimmed.includes("-->"))
+                blockEnd = "-->";
+            continue;
+        }
+        if (!docLike) {
+            if (trimmed.startsWith("/*")) {
+                banner.push(line);
+                if (!trimmed.includes("*/"))
+                    blockEnd = "*/";
+                continue;
+            }
+            if (trimmed.startsWith("//") ||
+                trimmed.startsWith("#") ||
+                trimmed.startsWith("--") ||
+                trimmed.startsWith(";") ||
+                trimmed.startsWith("*")) {
+                banner.push(line);
+                continue;
+            }
+        }
+        break; // first real line of content — the banner is over
+    }
+    return banner.join("\n");
+}
 /**
  * Detect machine-generated source by its banner. Generated files flood both the
  * vector index and the symbol graph (codegen types rank as god nodes), so they
  * are skipped at index time. Path globs in `ignore-patterns.ts` catch the
  * obvious filenames; this catches the rest by content.
+ *
+ * `filePath` is optional but worth passing: without it, doc-like files are
+ * scanned with code comment rules, so a markdown `# Heading` reads as a comment.
  */
-function isGeneratedContent(buffer) {
+function isGeneratedContent(buffer, filePath) {
     const head = buffer.subarray(0, GENERATED_SNIFF_BYTES).toString("utf-8");
-    return GENERATED_MARKER.test(head);
+    const banner = leadingBanner(head, filePath);
+    if (!banner.trim())
+        return false;
+    if (STRONG_GENERATED_MARKER.test(banner))
+        return true;
+    return DO_NOT_EDIT_MARKER.test(banner) && GENERATION_CONTEXT.test(banner);
 }
 function formatDenseSnippet(text, maxLength = 1500) {
     const clean = text !== null && text !== void 0 ? text : "";

package/dist/lib/utils/root-availability.js

@@ -0,0 +1,105 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyRoot = classifyRoot;
+exports.isRootUnavailable = isRootUnavailable;
+exports.describeRoot = describeRoot;
+const fs = __importStar(require("node:fs"));
+/**
+ * Directories that hold mount points rather than user data, with how many path
+ * segments below them the mount point itself sits.
+ *
+ * `mountDepth` errs high where a platform is ambiguous (Linux uses both
+ * `/media/<volume>` and `/media/<user>/<volume>`). Overshooting biases the
+ * classifier toward `unavailable`, which is the safe direction: a wrong
+ * `unavailable` only means we decline to auto-remove a genuinely dead project,
+ * while a wrong `missing` silently deregisters a live one.
+ */
+const MOUNT_CONTAINERS = [
+    { prefix: "/Volumes", mountDepth: 1 }, // macOS
+    { prefix: "/run/media", mountDepth: 2 }, // Linux, udisks2
+    { prefix: "/media", mountDepth: 2 },
+    { prefix: "/mnt", mountDepth: 1 },
+    { prefix: "/net", mountDepth: 1 }, // autofs network mounts
+];
+function exists(p) {
+    try {
+        fs.statSync(p);
+        return true;
+    }
+    catch (_a) {
+        // A disconnected network mount can throw EIO/ETIMEDOUT rather than ENOENT.
+        // Either way the path is not readable, and the caller's container check
+        // decides whether that means unavailable or missing.
+        return false;
+    }
+}
+/**
+ * Classify a project root that may live on removable or network storage.
+ *
+ * Longest matching container wins, so `/run/media` is not shadowed by `/media`.
+ */
+function classifyRoot(root) {
+    if (exists(root))
+        return "present";
+    const container = MOUNT_CONTAINERS.filter((c) => root === c.prefix || root.startsWith(`${c.prefix}/`)).sort((a, b) => b.prefix.length - a.prefix.length)[0];
+    if (!container)
+        return "missing";
+    // The mount point is the container plus `mountDepth` segments. If it is
+    // absent, nothing is mounted there and the project is merely out of reach.
+    const rest = root.slice(container.prefix.length).split("/").filter(Boolean);
+    if (rest.length < container.mountDepth)
+        return "missing";
+    const mountPoint = `${container.prefix}/${rest.slice(0, container.mountDepth).join("/")}`;
+    return exists(mountPoint) ? "missing" : "unavailable";
+}
+/**
+ * True when the root is absent only because its volume is not mounted.
+ * Callers that delete or rewrite persistent state must check this first.
+ */
+function isRootUnavailable(root) {
+    return classifyRoot(root) === "unavailable";
+}
+/** Human-readable reason for a non-present root, for logs and doctor output. */
+function describeRoot(root) {
+    switch (classifyRoot(root)) {
+        case "present":
+            return "available";
+        case "unavailable":
+            return "volume not mounted";
+        case "missing":
+            return "directory not found";
+    }
+}

package/dist/lib/workers/orchestrator.js

@@ -256,7 +256,7 @@ class WorkerOrchestrator {
                 (0, logger_1.debug)("orch", `skip ${input.path} (empty or binary)`);
                 return { vectors: [], hash, mtimeMs, size, shouldDelete: true };
             }
-            if ((0, file_utils_1.isGeneratedContent)(buffer)) {
+            if ((0, file_utils_1.isGeneratedContent)(buffer, absolutePath)) {
                 (0, logger_1.debug)("orch", `skip ${input.path} (machine-generated header)`);
                 return { vectors: [], hash, mtimeMs, size, shouldDelete: true };
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.26.13",
+  "version": "0.26.15",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {

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

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