grepmax 0.13.1 → 0.13.2

package/README.md

@@ -164,15 +164,15 @@ gmax "query" [options]
 
 ## Background Daemon
 
-A single daemon watches all registered projects via native OS file events (FSEvents/inotify). Changes are detected in sub-second and incrementally reindexed.
+A single daemon watches all registered projects via native OS file events (FSEvents/inotify). Changes are detected in sub-second and incrementally reindexed. All writes to LanceDB are routed through the daemon via IPC, eliminating lock contention.
 
 ```bash
-gmax watch --daemon -b        # Start daemon
+gmax watch --daemon -b        # Start daemon manually
 gmax watch stop               # Stop daemon
 gmax status                   # See all projects + watcher status
 ```
 
-The daemon auto-starts via agent plugins and shuts down after 30 minutes of inactivity.
+The daemon auto-starts when you run `gmax add`, `gmax index`, `gmax remove`, or `gmax summarize`. It shuts down after 30 minutes of inactivity.
 
 ## Architecture
 

package/dist/commands/llm.js

@@ -0,0 +1,143 @@
+"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.llm = void 0;
+const path = __importStar(require("node:path"));
+const commander_1 = require("commander");
+const exit_1 = require("../lib/utils/exit");
+function showStatus() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { isDaemonRunning, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
+        if (!(yield isDaemonRunning())) {
+            console.log("LLM server: not running (daemon not started)");
+            return;
+        }
+        const resp = yield sendDaemonCommand({ cmd: "llm-status" });
+        if (!resp.ok) {
+            console.error("Failed to get LLM status:", resp.error);
+            process.exitCode = 1;
+            return;
+        }
+        if (resp.running) {
+            const model = path.basename(String(resp.model));
+            const uptime = Number(resp.uptime) || 0;
+            const mins = Math.floor(uptime / 60);
+            const secs = uptime % 60;
+            console.log(`LLM server: running (PID: ${resp.pid}, port: ${resp.port})`);
+            console.log(`  Model: ${model}`);
+            console.log(`  Uptime: ${mins}m ${secs}s`);
+        }
+        else {
+            console.log("LLM server: not running");
+        }
+    });
+}
+exports.llm = new commander_1.Command("llm")
+    .description("Manage the local LLM server (llama-server)")
+    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield showStatus();
+    }
+    finally {
+        yield (0, exit_1.gracefulExit)();
+    }
+}));
+exports.llm
+    .command("start")
+    .description("Start the LLM server")
+    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { ensureDaemonRunning, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
+        if (!(yield ensureDaemonRunning())) {
+            console.error("Failed to start daemon");
+            process.exitCode = 1;
+            return;
+        }
+        console.log("Starting LLM server...");
+        const resp = yield sendDaemonCommand({ cmd: "llm-start" }, { timeoutMs: 90000 });
+        if (!resp.ok) {
+            console.error(`Failed: ${resp.error}`);
+            process.exitCode = 1;
+            return;
+        }
+        const model = path.basename(String(resp.model));
+        console.log(`LLM server ready (PID: ${resp.pid}, port: ${resp.port}, model: ${model})`);
+    }
+    finally {
+        yield (0, exit_1.gracefulExit)();
+    }
+}));
+exports.llm
+    .command("stop")
+    .description("Stop the LLM server")
+    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { isDaemonRunning, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
+        if (!(yield isDaemonRunning())) {
+            console.log("Daemon not running");
+            return;
+        }
+        const resp = yield sendDaemonCommand({ cmd: "llm-stop" });
+        if (!resp.ok) {
+            console.error(`Failed: ${resp.error}`);
+            process.exitCode = 1;
+            return;
+        }
+        console.log("LLM server stopped");
+    }
+    finally {
+        yield (0, exit_1.gracefulExit)();
+    }
+}));
+exports.llm
+    .command("status")
+    .description("Show LLM server status")
+    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield showStatus();
+    }
+    finally {
+        yield (0, exit_1.gracefulExit)();
+    }
+}));

package/dist/config.js

@@ -103,6 +103,9 @@ exports.PATHS = {
     lmdbPath: path.join(GLOBAL_ROOT, "cache", "meta.lmdb"),
     configPath: path.join(GLOBAL_ROOT, "config.json"),
     lockDir: GLOBAL_ROOT,
+    // LLM server (llama-server)
+    llmPidFile: path.join(GLOBAL_ROOT, "llm-server.pid"),
+    llmLogFile: path.join(GLOBAL_ROOT, "logs", "llm-server.log"),
 };
 exports.MAX_FILE_SIZE_BYTES = 1024 * 1024 * 2; // 2MB limit for indexing
 // Extensions we consider for indexing to avoid binary noise and improve relevance.

package/dist/index.js

@@ -50,6 +50,7 @@ const impact_1 = require("./commands/impact");
 const droid_1 = require("./commands/droid");
 const index_1 = require("./commands/index");
 const list_1 = require("./commands/list");
+const llm_1 = require("./commands/llm");
 const mcp_1 = require("./commands/mcp");
 const peek_1 = require("./commands/peek");
 const project_1 = require("./commands/project");
@@ -110,6 +111,7 @@ commander_1.program.addCommand(serve_1.serve);
 commander_1.program.addCommand(watch_1.watch);
 commander_1.program.addCommand(mcp_1.mcp);
 commander_1.program.addCommand(summarize_1.summarize);
+commander_1.program.addCommand(llm_1.llm);
 // Setup & diagnostics
 commander_1.program.addCommand(setup_1.setup);
 commander_1.program.addCommand(config_1.config);

package/dist/lib/daemon/daemon.js

@@ -60,6 +60,7 @@ const vector_db_1 = require("../store/vector-db");
 const process_1 = require("../utils/process");
 const project_registry_1 = require("../utils/project-registry");
 const watcher_store_1 = require("../utils/watcher-store");
+const server_1 = require("../llm/server");
 const ipc_handler_1 = require("./ipc-handler");
 const IDLE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
 const HEARTBEAT_INTERVAL_MS = 60 * 1000;
@@ -78,6 +79,7 @@ class Daemon {
         this.shuttingDown = false;
         this.pendingOps = new Set();
         this.projectLocks = new Map();
+        this.llmServer = null;
     }
     start() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -124,7 +126,9 @@ class Daemon {
                 console.error("[daemon] Failed to open shared resources:", err);
                 throw err;
             }
-            // 6. Register daemon (only after resources are open)
+            // 6. LLM server manager (constructed, not started — starts on first request)
+            this.llmServer = new server_1.LlmServer();
+            // 7. Register daemon (only after resources are open)
             (0, watcher_store_1.registerDaemon)(process.pid);
             // 7. Subscribe to all registered projects (skip missing directories)
             const projects = (0, project_registry_1.listProjects)().filter((p) => p.status === "indexed");
@@ -496,9 +500,48 @@ class Daemon {
             }));
         });
     }
+    // --- LLM server management ---
+    llmStart() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.llmServer)
+                return { ok: false, error: "daemon not initialized" };
+            try {
+                yield this.llmServer.start();
+                this.resetActivity();
+                return Object.assign({ ok: true }, this.llmServer.getStatus());
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { ok: false, error: msg };
+            }
+        });
+    }
+    llmStop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.llmServer)
+                return { ok: false, error: "daemon not initialized" };
+            try {
+                yield this.llmServer.stop();
+                return { ok: true };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { ok: false, error: msg };
+            }
+        });
+    }
+    llmStatus() {
+        if (!this.llmServer)
+            return { ok: false, error: "daemon not initialized" };
+        return Object.assign({ ok: true }, this.llmServer.getStatus());
+    }
+    llmTouch() {
+        var _a;
+        (_a = this.llmServer) === null || _a === void 0 ? void 0 : _a.touchIdle();
+    }
     shutdown() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             if (this.shuttingDown)
                 return;
             this.shuttingDown = true;
@@ -511,29 +554,34 @@ class Daemon {
             for (const processor of this.processors.values()) {
                 yield processor.close();
             }
+            // Stop LLM server if running
+            try {
+                yield ((_a = this.llmServer) === null || _a === void 0 ? void 0 : _a.stop());
+            }
+            catch (_e) { }
             // Unsubscribe all watchers
             for (const sub of this.subscriptions.values()) {
                 try {
                     yield sub.unsubscribe();
                 }
-                catch (_d) { }
+                catch (_f) { }
             }
             this.subscriptions.clear();
             // Close server + socket + PID file + lock
-            (_a = this.server) === null || _a === void 0 ? void 0 : _a.close();
+            (_b = this.server) === null || _b === void 0 ? void 0 : _b.close();
             try {
                 fs.unlinkSync(config_1.PATHS.daemonSocket);
             }
-            catch (_e) { }
+            catch (_g) { }
             try {
                 fs.unlinkSync(config_1.PATHS.daemonPidFile);
             }
-            catch (_f) { }
+            catch (_h) { }
             if (this.releaseLock) {
                 try {
                     yield this.releaseLock();
                 }
-                catch (_g) { }
+                catch (_j) { }
                 this.releaseLock = null;
             }
             // Unregister all
@@ -544,13 +592,13 @@ class Daemon {
             this.processors.clear();
             // Close shared resources
             try {
-                yield ((_b = this.metaCache) === null || _b === void 0 ? void 0 : _b.close());
+                yield ((_c = this.metaCache) === null || _c === void 0 ? void 0 : _c.close());
             }
-            catch (_h) { }
+            catch (_k) { }
             try {
-                yield ((_c = this.vectorDb) === null || _c === void 0 ? void 0 : _c.close());
+                yield ((_d = this.vectorDb) === null || _d === void 0 ? void 0 : _d.close());
             }
-            catch (_j) { }
+            catch (_l) { }
             console.log("[daemon] Shutdown complete");
         });
     }

package/dist/lib/daemon/ipc-handler.js

@@ -101,6 +101,13 @@ function handleCommand(daemon, cmd, conn) {
                     });
                     return null;
                 }
+                // --- LLM server management ---
+                case "llm-start":
+                    return yield daemon.llmStart();
+                case "llm-stop":
+                    return yield daemon.llmStop();
+                case "llm-status":
+                    return daemon.llmStatus();
                 default:
                     return { ok: false, error: `unknown command: ${cmd.cmd}` };
             }

package/dist/lib/llm/config.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLlmConfig = getLlmConfig;
+const DEFAULT_MODEL = "/Volumes/External/models/huggingface/hub/models--unsloth--Qwen3.5-35B-A3B-GGUF/Qwen3.5-35B-A3B-Q4_K_M.gguf";
+function envInt(key, fallback) {
+    const v = process.env[key];
+    if (!v)
+        return fallback;
+    const n = Number.parseInt(v, 10);
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function getLlmConfig() {
+    var _a, _b, _c;
+    return {
+        model: (_a = process.env.GMAX_LLM_MODEL) !== null && _a !== void 0 ? _a : DEFAULT_MODEL,
+        binary: (_b = process.env.GMAX_LLM_BINARY) !== null && _b !== void 0 ? _b : "llama-server",
+        host: (_c = process.env.GMAX_LLM_HOST) !== null && _c !== void 0 ? _c : "127.0.0.1",
+        port: envInt("GMAX_LLM_PORT", 8079),
+        ctxSize: envInt("GMAX_LLM_CTX_SIZE", 16384),
+        ngl: envInt("GMAX_LLM_NGL", 99),
+        maxTokens: envInt("GMAX_LLM_MAX_TOKENS", 8192),
+        idleTimeoutMin: envInt("GMAX_LLM_IDLE_TIMEOUT", 30),
+        startupWaitSec: envInt("GMAX_LLM_STARTUP_WAIT", 60),
+    };
+}

package/dist/lib/llm/server.js

@@ -0,0 +1,261 @@
+"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.LlmServer = void 0;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const http = __importStar(require("node:http"));
+const config_1 = require("../../config");
+const log_rotate_1 = require("../utils/log-rotate");
+const config_2 = require("./config");
+const HEALTH_TIMEOUT_MS = 2000;
+const POLL_INTERVAL_MS = 500;
+const STOP_GRACE_MS = 5000;
+const IDLE_CHECK_INTERVAL_MS = 5 * 60 * 1000;
+class LlmServer {
+    constructor() {
+        this.lastRequestTime = 0;
+        this.startTime = 0;
+        this.idleTimer = null;
+        this.config = (0, config_2.getLlmConfig)();
+    }
+    /** HTTP GET /v1/models — returns true if llama-server is responding. */
+    healthy() {
+        return new Promise((resolve) => {
+            const req = http.get({
+                hostname: this.config.host,
+                port: this.config.port,
+                path: "/v1/models",
+                timeout: HEALTH_TIMEOUT_MS,
+            }, (res) => {
+                res.resume();
+                resolve(res.statusCode === 200);
+            });
+            req.on("error", () => resolve(false));
+            req.on("timeout", () => {
+                req.destroy();
+                resolve(false);
+            });
+        });
+    }
+    /** Start llama-server, poll until ready, start idle watchdog. */
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.healthy())
+                return;
+            // Validate binary
+            const binary = this.config.binary;
+            try {
+                (0, node_child_process_1.execSync)(`which ${binary}`, { stdio: "ignore" });
+            }
+            catch (_a) {
+                throw new Error(`llama-server binary not found: "${binary}". Install llama.cpp or set GMAX_LLM_BINARY`);
+            }
+            // Validate model file
+            if (!fs.existsSync(this.config.model)) {
+                throw new Error(`Model file not found: "${this.config.model}". Set GMAX_LLM_MODEL to a valid .gguf path`);
+            }
+            const logFd = (0, log_rotate_1.openRotatedLog)(config_1.PATHS.llmLogFile);
+            const child = (0, node_child_process_1.spawn)(binary, [
+                "-m", this.config.model,
+                "--host", this.config.host,
+                "--port", String(this.config.port),
+                "-ngl", String(this.config.ngl),
+                "--ctx-size", String(this.config.ctxSize),
+            ], { detached: true, stdio: ["ignore", logFd, logFd] });
+            child.unref();
+            fs.closeSync(logFd);
+            const pid = child.pid;
+            if (!pid) {
+                throw new Error("Failed to spawn llama-server — no PID returned");
+            }
+            fs.writeFileSync(config_1.PATHS.llmPidFile, String(pid));
+            console.log(`[llm] Starting llama-server (PID: ${pid}, port: ${this.config.port})`);
+            // Poll until ready
+            const deadline = Date.now() + this.config.startupWaitSec * 1000;
+            while (Date.now() < deadline) {
+                yield new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+                // Check if process died
+                try {
+                    process.kill(pid, 0);
+                }
+                catch (_b) {
+                    throw new Error(`llama-server process died during startup — check ${config_1.PATHS.llmLogFile}`);
+                }
+                if (yield this.healthy()) {
+                    this.startTime = Date.now();
+                    this.lastRequestTime = Date.now();
+                    this.startIdleWatchdog();
+                    console.log("[llm] Server ready");
+                    return;
+                }
+            }
+            // Timeout — kill the process
+            try {
+                process.kill(pid, "SIGKILL");
+            }
+            catch (_c) { }
+            try {
+                fs.unlinkSync(config_1.PATHS.llmPidFile);
+            }
+            catch (_d) { }
+            throw new Error(`llama-server startup timed out after ${this.config.startupWaitSec}s — check ${config_1.PATHS.llmLogFile}`);
+        });
+    }
+    /** Stop llama-server gracefully (SIGTERM → wait → SIGKILL). */
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.stopIdleWatchdog();
+            const pid = this.readPid();
+            if (!pid)
+                return;
+            // Check if alive
+            try {
+                process.kill(pid, 0);
+            }
+            catch (_a) {
+                this.cleanupPidFile();
+                return;
+            }
+            // SIGTERM
+            try {
+                process.kill(pid, "SIGTERM");
+            }
+            catch (_b) { }
+            // Wait up to 5s
+            const deadline = Date.now() + STOP_GRACE_MS;
+            while (Date.now() < deadline) {
+                yield new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+                try {
+                    process.kill(pid, 0);
+                }
+                catch (_c) {
+                    // Process exited
+                    this.cleanupPidFile();
+                    console.log(`[llm] Server stopped (PID: ${pid})`);
+                    return;
+                }
+            }
+            // Force kill
+            try {
+                process.kill(pid, "SIGKILL");
+            }
+            catch (_d) { }
+            this.cleanupPidFile();
+            console.log(`[llm] Server force-killed (PID: ${pid})`);
+        });
+    }
+    /** Start if not running. */
+    ensure() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.healthy()) {
+                this.touchIdle();
+                return;
+            }
+            yield this.start();
+        });
+    }
+    /** Mark activity — resets idle timer. Called by inference endpoints. */
+    touchIdle() {
+        this.lastRequestTime = Date.now();
+    }
+    /** Get current status for IPC/CLI display. */
+    getStatus() {
+        const pid = this.readPid();
+        const alive = pid ? this.isAlive(pid) : false;
+        return {
+            running: alive,
+            pid: alive ? pid : null,
+            port: this.config.port,
+            model: this.config.model,
+            uptime: alive && this.startTime ? Math.floor((Date.now() - this.startTime) / 1000) : 0,
+        };
+    }
+    startIdleWatchdog() {
+        this.stopIdleWatchdog();
+        const timeoutMs = this.config.idleTimeoutMin * 60 * 1000;
+        this.idleTimer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            if (this.lastRequestTime === 0)
+                return;
+            if (Date.now() - this.lastRequestTime > timeoutMs) {
+                console.log(`[llm] Server idle for ${this.config.idleTimeoutMin}min, shutting down`);
+                yield this.stop();
+            }
+        }), IDLE_CHECK_INTERVAL_MS);
+        this.idleTimer.unref();
+    }
+    stopIdleWatchdog() {
+        if (this.idleTimer) {
+            clearInterval(this.idleTimer);
+            this.idleTimer = null;
+        }
+    }
+    readPid() {
+        try {
+            const raw = fs.readFileSync(config_1.PATHS.llmPidFile, "utf-8").trim();
+            const pid = Number.parseInt(raw, 10);
+            return Number.isFinite(pid) && pid > 0 ? pid : null;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    isAlive(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    cleanupPidFile() {
+        try {
+            fs.unlinkSync(config_1.PATHS.llmPidFile);
+        }
+        catch (_a) { }
+        this.startTime = 0;
+    }
+}
+exports.LlmServer = LlmServer;

package/package.json

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

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

@@ -24,7 +24,7 @@ Bash(gmax "auth handler" --role ORCHESTRATION --lang ts --agent -m 3)
 
 ## Project management
 
-Projects must be added before search works:
+Projects must be added before search works. These commands auto-start the daemon if not running:
 
 ```
 gmax add                        # add + index current directory