grepmax 0.26.33 → 0.26.35

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.33",
+      "version": "0.26.35",
       "author": {
         "name": "Robert Owens",
         "email": "robowens@me.com"

package/dist/bin.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+"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.commandTarget = commandTarget;
+exports.registeredForm = registeredForm;
+// Entry point. Picks the gmax home before anything reads config.ts: a command
+// aimed at a project under a secondary store's prefix (src/lib/utils/stores.ts)
+// runs against that store, in-process, so the drive it lives on can always
+// eject. Only Node built-ins and stores.ts may be imported here.
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const stores_1 = require("./lib/utils/stores");
+const DIR_ARG_COMMANDS = new Set(["add", "remove"]);
+function optionValue(argv, names) {
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        for (const n of names) {
+            if (a === n && argv[i + 1])
+                return argv[i + 1];
+            if (a.startsWith(`${n}=`))
+                return a.slice(n.length + 1);
+        }
+    }
+    return undefined;
+}
+function commandTarget(argv, cwd) {
+    var _a, _b;
+    const explicit = (_b = (_a = optionValue(argv, ["--root", "--store"])) !== null && _a !== void 0 ? _a : (argv[0] === "index" ? optionValue(argv, ["--path", "-p"]) : undefined)) !== null && _b !== void 0 ? _b : process.env.GMAX_STORE;
+    if (explicit)
+        return path.resolve(cwd, explicit);
+    if (DIR_ARG_COMMANDS.has(argv[0])) {
+        const positional = argv.slice(1).find((a) => !a.startsWith("-"));
+        if (positional &&
+            (positional.includes(path.sep) ||
+                fs.existsSync(path.resolve(cwd, positional)))) {
+            return path.resolve(cwd, positional);
+        }
+    }
+    return cwd;
+}
+function selectHome() {
+    if (process.env.GMAX_HOME)
+        return;
+    const argv = process.argv.slice(2);
+    const match = (0, stores_1.matchStore)(commandTarget(argv, process.cwd()));
+    if (match.kind === "primary")
+        return;
+    if (match.kind === "offline") {
+        process.stderr.write(`gmax: this project's index lives on ${match.volume}, which is not mounted (store ${match.store.home}). Connect the drive and run the command again.\n`);
+        process.exit(2);
+    }
+    process.env.GMAX_HOME = match.store.home;
+    // A secondary store never runs a daemon: nothing may hold the drive's files
+    // open between commands, or the drive could not eject.
+    process.env.GMAX_NO_AUTOSTART = "1";
+    process.env.GMAX_SECONDARY_STORE = "1";
+    seedConfig(match.store.home);
+    alignCwdWithRegistry(match.store.home);
+}
+// Node reports the physical working directory, so a shell standing in
+// ~/Development/packages/x (a symlink onto the drive) looks like
+// /Volumes/External/dev/packages/x, while the store registered the path it was
+// given. When the physical cwd sits inside a registered root's realpath,
+// report the cwd in the registered form so project lookup finds it.
+function registeredForm(cwd, roots, real = realpathOr) {
+    for (const root of roots) {
+        const rootReal = real(root);
+        const rel = path.relative(rootReal, cwd);
+        if (rel === "" || (rel && !rel.startsWith("..") && !path.isAbsolute(rel))) {
+            return rel ? path.join(root, rel) : root;
+        }
+    }
+    return null;
+}
+function realpathOr(p) {
+    try {
+        return fs.realpathSync(p);
+    }
+    catch (_a) {
+        return path.resolve(p);
+    }
+}
+function alignCwdWithRegistry(home) {
+    let roots;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(home, "projects.json"), "utf-8"));
+        roots = parsed
+            .map((p) => p.root)
+            .filter((r) => typeof r === "string");
+    }
+    catch (_a) {
+        return;
+    }
+    const physical = process.cwd();
+    const logical = registeredForm(physical, roots);
+    if (logical && logical !== physical)
+        process.cwd = () => logical;
+}
+// A new store embeds with the same model as the primary one.
+function seedConfig(home) {
+    var _a;
+    const target = path.join(home, "config.json");
+    if (fs.existsSync(target))
+        return;
+    const primary = path.join((_a = process.env.HOME) !== null && _a !== void 0 ? _a : "", ".gmax", "config.json");
+    try {
+        fs.mkdirSync(home, { recursive: true });
+        fs.copyFileSync(primary, target);
+    }
+    catch (_b) {
+        // no primary config: the store starts from the defaults, as ~/.gmax did
+    }
+}
+if (require.main === module) {
+    selectHome();
+    require("./index");
+}

package/dist/commands/watch.js

@@ -72,6 +72,15 @@ exports.watch = new commander_1.Command("watch")
     .option("--no-idle-timeout", "Disable the 30-minute idle shutdown")
     .action((options) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b;
+    // A secondary store (src/bin.ts) never runs a daemon or a watcher: one
+    // would hold the external drive open, and its startup sweep of stale
+    // daemons judges liveness by its own home's lock and socket, so it takes
+    // the primary daemon for dead and shuts it down (seen 2026-09-22).
+    if (process.env.GMAX_SECONDARY_STORE === "1") {
+        console.error("gmax: this project's index lives on an external drive and runs in-process; it is never watched. Run `gmax index` after changing it.");
+        process.exitCode = 2;
+        return;
+    }
     // --- Daemon mode ---
     if (options.daemon) {
         if (options.path) {

package/dist/config.js

@@ -218,14 +218,23 @@ exports.MAX_WORKER_MEMORY_MB = (() => {
     return Math.min(HARD_CEILING, Math.max(2048, Math.floor((os.totalmem() / 1024 / 1024) * 0.5)));
 })();
 const HOME = os.homedir();
-const GLOBAL_ROOT = path.join(HOME, ".gmax");
+// Models, grammars and the pinned HF cache are shared by every store and always
+// live on the internal disk. GMAX_HOME moves only the data root: a secondary
+// store on an external drive (see src/lib/utils/stores.ts) sets it before this
+// module loads, so a project's index can live on the drive with its files.
+const SHARED_ROOT = path.join(HOME, ".gmax");
+const GLOBAL_ROOT = process.env.GMAX_HOME
+    ? path.resolve(process.env.GMAX_HOME)
+    : SHARED_ROOT;
 exports.PATHS = {
     globalRoot: GLOBAL_ROOT,
-    models: path.join(GLOBAL_ROOT, "models"),
-    grammars: path.join(GLOBAL_ROOT, "grammars"),
+    sharedRoot: SHARED_ROOT,
+    storesFile: path.join(SHARED_ROOT, "stores.json"),
+    models: path.join(SHARED_ROOT, "models"),
+    grammars: path.join(SHARED_ROOT, "grammars"),
     // HF cache for the MLX embed server, pinned to internal disk so the server
     // survives an unmounted external volume behind the user's HF_HOME.
-    hfDir: path.join(GLOBAL_ROOT, "hf"),
+    hfDir: path.join(SHARED_ROOT, "hf"),
     logsDir: path.join(GLOBAL_ROOT, "logs"),
     daemonSocket: path.join(GLOBAL_ROOT, "daemon.sock"),
     daemonPidFile: path.join(GLOBAL_ROOT, "daemon.pid"),

package/dist/lib/utils/autostart.js

@@ -81,6 +81,12 @@ function autostartDisabledUndo() {
         : `rm ${config_1.PATHS.autostartDisabledFile}`;
 }
 function autostartDisabledNotice() {
+    // A secondary store (src/bin.ts) runs in-process by design, not because the
+    // kill switch is on, so say that instead of naming an undo step. Callers use
+    // a non-null notice as the gate, so this must stay non-null.
+    if (process.env.GMAX_SECONDARY_STORE === "1") {
+        return `This project's index lives in ${config_1.PATHS.globalRoot} on an external drive — running in-process, not watched. Run \`gmax index\` after changing it.`;
+    }
     const undo = autostartDisabledUndo();
     if (!undo)
         return null;

package/dist/lib/utils/stores.js

@@ -0,0 +1,124 @@
+"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.storesFilePath = storesFilePath;
+exports.readStores = readStores;
+exports.volumeOf = volumeOf;
+exports.matchStore = matchStore;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+function storesFilePath(home = os.homedir()) {
+    return path.join(home, ".gmax", "stores.json");
+}
+function readStores(file = storesFilePath()) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf-8");
+    }
+    catch (_a) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed.stores))
+            return [];
+        return parsed.stores.filter((s) => !!s &&
+            typeof s.prefix === "string" &&
+            typeof s.home === "string");
+    }
+    catch (_b) {
+        return [];
+    }
+}
+// The volume a path lives on, for paths under /Volumes; null for the boot disk.
+function volumeOf(p) {
+    const parts = path.resolve(p).split(path.sep);
+    return parts[1] === "Volumes" && parts[2]
+        ? path.join("/Volumes", parts[2])
+        : null;
+}
+function realOrResolved(p) {
+    try {
+        return fs.realpathSync(p);
+    }
+    catch (_a) {
+        return path.resolve(p);
+    }
+}
+function within(child, parent) {
+    const rel = path.relative(parent, child);
+    return (rel === "" || (!!rel && !rel.startsWith("..") && !path.isAbsolute(rel)));
+}
+// A path behind a symlink (~/Development/packages -> /Volumes/External/...)
+// matches through its realpath. When the drive is ejected the symlink dangles
+// and realpath fails, so the link target is read directly to still name it.
+function candidates(target) {
+    const out = new Set([path.resolve(target), realOrResolved(target)]);
+    let cur = path.resolve(target);
+    const tail = [];
+    while (cur !== path.dirname(cur)) {
+        try {
+            if (fs.lstatSync(cur).isSymbolicLink()) {
+                const link = path.resolve(path.dirname(cur), fs.readlinkSync(cur));
+                out.add(path.join(link, ...tail.slice().reverse()));
+                break;
+            }
+        }
+        catch (_a) {
+            // not there; keep walking up
+        }
+        tail.push(path.basename(cur));
+        cur = path.dirname(cur);
+    }
+    return [...out];
+}
+function matchStore(target, stores = readStores()) {
+    var _a;
+    if (!stores.length)
+        return { kind: "primary" };
+    for (const cand of candidates(target)) {
+        for (const store of stores) {
+            if (!within(cand, path.resolve(store.prefix)))
+                continue;
+            const volume = (_a = volumeOf(store.home)) !== null && _a !== void 0 ? _a : volumeOf(store.prefix);
+            if (volume && !fs.existsSync(volume)) {
+                return { kind: "offline", store, volume };
+            }
+            return { kind: "store", store };
+        }
+    }
+    return { kind: "primary" };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.26.33",
+  "version": "0.26.35",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {
@@ -12,7 +12,7 @@
   },
   "main": "dist/index.js",
   "bin": {
-    "gmax": "dist/index.js"
+    "gmax": "dist/bin.js"
   },
   "engines": {
     "node": ">=22.12.0"
@@ -21,8 +21,8 @@
     "postinstall": "node scripts/postinstall.js",
     "prebuild": "rm -rf dist tsconfig.tsbuildinfo && mkdir -p dist",
     "build": "tsc",
-    "postbuild": "chmod +x dist/index.js",
-    "dev": "npx tsc && node dist/index.js",
+    "postbuild": "chmod +x dist/bin.js dist/index.js",
+    "dev": "npx tsc && node dist/bin.js",
     "test": "vitest run",
     "test:watch": "vitest",
     "bench:recall": "npx tsx src/eval.ts",

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

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