grepmax 0.7.0

package/dist/commands/serve.js

@@ -0,0 +1,512 @@
+"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.serve = void 0;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const http = __importStar(require("node:http"));
+const path = __importStar(require("node:path"));
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const grammar_loader_1 = require("../lib/index/grammar-loader");
+const index_config_1 = require("../lib/index/index-config");
+const sync_helpers_1 = require("../lib/index/sync-helpers");
+const syncer_1 = require("../lib/index/syncer");
+const watcher_1 = require("../lib/index/watcher");
+const searcher_1 = require("../lib/search/searcher");
+const setup_helpers_1 = require("../lib/setup/setup-helpers");
+const meta_cache_1 = require("../lib/store/meta-cache");
+const vector_db_1 = require("../lib/store/vector-db");
+const exit_1 = require("../lib/utils/exit");
+const project_root_1 = require("../lib/utils/project-root");
+const server_registry_1 = require("../lib/utils/server-registry");
+function isMlxServerUp() {
+    const port = parseInt(process.env.MLX_EMBED_PORT || "8100", 10);
+    return new Promise((resolve) => {
+        const req = http.get({ hostname: "127.0.0.1", port, path: "/health", timeout: 2000 }, (res) => {
+            res.resume();
+            resolve(res.statusCode === 200);
+        });
+        req.on("error", () => resolve(false));
+        req.on("timeout", () => {
+            req.destroy();
+            resolve(false);
+        });
+    });
+}
+function startMlxServer(mlxModel) {
+    // Look for mlx-embed-server relative to the osgrep package
+    const candidates = [
+        path.resolve(__dirname, "../../mlx-embed-server"),
+        path.resolve(__dirname, "../mlx-embed-server"),
+    ];
+    const serverDir = candidates.find((d) => fs.existsSync(path.join(d, "server.py")));
+    if (!serverDir)
+        return null;
+    const logPath = "/tmp/mlx-embed-server.log";
+    const out = fs.openSync(logPath, "a");
+    const env = Object.assign({}, process.env);
+    if (mlxModel) {
+        env.MLX_EMBED_MODEL = mlxModel;
+    }
+    const child = (0, node_child_process_1.spawn)("uv", ["run", "python", "server.py"], {
+        cwd: serverDir,
+        detached: true,
+        stdio: ["ignore", out, out],
+        env,
+    });
+    child.unref();
+    return child;
+}
+exports.serve = new commander_1.Command("serve")
+    .description("Run osgrep as a background server with live indexing")
+    .option("-p, --port <port>", "Port to listen on", process.env.OSGREP_PORT || "4444")
+    .option("-b, --background", "Run in background", false)
+    .option("--cpu", "Use CPU-only embeddings (skip MLX GPU server)", false)
+    .option("--no-idle-timeout", "Disable the 30-minute idle shutdown", false)
+    .action((_args, cmd) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const options = cmd.optsWithGlobals();
+    let port = parseInt(options.port, 10);
+    const startPort = port;
+    const projectRoot = (_a = (0, project_root_1.findProjectRoot)(process.cwd())) !== null && _a !== void 0 ? _a : process.cwd();
+    // Check if already running
+    const existing = (0, server_registry_1.getServerForProject)(projectRoot);
+    if (existing && (0, server_registry_1.isProcessRunning)(existing.pid)) {
+        console.log(`Server already running for ${projectRoot} (PID: ${existing.pid}, Port: ${existing.port})`);
+        return;
+    }
+    if (options.background) {
+        const args = process.argv
+            .slice(2)
+            .filter((arg) => arg !== "-b" && arg !== "--background");
+        const logDir = path.join(config_1.PATHS.globalRoot, "logs");
+        fs.mkdirSync(logDir, { recursive: true });
+        const safeName = path
+            .basename(projectRoot)
+            .replace(/[^a-zA-Z0-9._-]/g, "_");
+        const logFile = path.join(logDir, `server-${safeName}.log`);
+        const out = fs.openSync(logFile, "a");
+        const err = fs.openSync(logFile, "a");
+        const child = (0, node_child_process_1.spawn)(process.argv[0], [process.argv[1], ...args], {
+            detached: true,
+            stdio: ["ignore", out, err],
+            cwd: process.cwd(),
+            env: Object.assign(Object.assign({}, process.env), { OSGREP_BACKGROUND: "true" }),
+        });
+        child.unref();
+        console.log(`Started background server (PID: ${child.pid})`);
+        return;
+    }
+    const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
+    const projectName = path.basename(projectRoot);
+    // Propagate project root to worker processes
+    process.env.OSGREP_PROJECT_ROOT = projectRoot;
+    // Determine embed mode: --cpu flag overrides, then config, then default
+    // Default to GPU on Apple Silicon, CPU everywhere else
+    const isAppleSilicon = process.arch === "arm64" && process.platform === "darwin";
+    const indexConfig = (0, index_config_1.readIndexConfig)(paths.configPath);
+    const useGpu = options.cpu
+        ? false
+        : ((_b = indexConfig === null || indexConfig === void 0 ? void 0 : indexConfig.embedMode) !== null && _b !== void 0 ? _b : (isAppleSilicon ? "gpu" : "cpu")) === "gpu";
+    const mlxModel = indexConfig === null || indexConfig === void 0 ? void 0 : indexConfig.mlxModel;
+    // MLX GPU embed server — started when GPU mode is active.
+    let mlxChild = null;
+    if (!useGpu) {
+        console.log(`[serve:${projectName}] CPU-only mode`);
+    }
+    else {
+        const mlxUp = yield isMlxServerUp();
+        if (mlxUp) {
+            console.log(`[serve:${projectName}] MLX GPU server already running`);
+        }
+        else {
+            mlxChild = startMlxServer(mlxModel);
+            if (mlxChild) {
+                console.log(`[serve] Starting MLX GPU embed server (PID: ${mlxChild.pid})${mlxModel ? ` [${mlxModel}]` : ""}`);
+                let ready = false;
+                for (let i = 0; i < 30; i++) {
+                    yield new Promise((r) => setTimeout(r, 1000));
+                    if (yield isMlxServerUp()) {
+                        console.log(`[serve:${projectName}] MLX GPU server ready`);
+                        ready = true;
+                        break;
+                    }
+                }
+                if (!ready) {
+                    console.error(`[serve:${projectName}] MLX GPU server failed to start. Run with --cpu to use CPU embeddings.`);
+                    process.exitCode = 1;
+                    return;
+                }
+            }
+            else {
+                console.error(`[serve:${projectName}] MLX server not found. Run with --cpu to use CPU embeddings.`);
+                process.exitCode = 1;
+                return;
+            }
+        }
+    }
+    try {
+        yield (0, setup_helpers_1.ensureSetup)();
+        yield (0, grammar_loader_1.ensureGrammars)(console.log, { silent: true });
+        // Initial sync is self-contained (creates+closes its own VectorDB+MetaCache).
+        if (!process.env.OSGREP_BACKGROUND) {
+            const { spinner, onProgress } = (0, sync_helpers_1.createIndexingSpinner)(projectRoot, "Indexing before starting server...");
+            try {
+                yield (0, syncer_1.initialSync)({ projectRoot, onProgress });
+                spinner.succeed("Initial index ready. Starting server...");
+            }
+            catch (e) {
+                spinner.fail("Indexing failed");
+                throw e;
+            }
+        }
+        else {
+            yield (0, syncer_1.initialSync)({ projectRoot });
+        }
+        // Open long-lived resources for serving + watching.
+        const vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
+        const metaCache = new meta_cache_1.MetaCache(paths.lmdbPath);
+        const searcher = new searcher_1.Searcher(vectorDb);
+        // Start live file watcher
+        let fileWatcher = (0, watcher_1.startWatcher)({
+            projectRoot,
+            vectorDb,
+            metaCache,
+            osgrepDir: paths.osgrepDir,
+            onReindex: (files, durationMs) => {
+                console.log(`[watch:${projectName}] Reindexed ${files} file${files !== 1 ? "s" : ""} (${(durationMs / 1000).toFixed(1)}s)`);
+            },
+        });
+        console.log(`[serve:${projectName}] File watcher active`);
+        // Idle timeout: shut down if no searches for 30 minutes
+        // Disabled when started by MCP server (--no-idle-timeout)
+        let lastActivity = Date.now();
+        if (options.idleTimeout) {
+            const IDLE_TIMEOUT_MS = 30 * 60 * 1000;
+            const idleCheck = setInterval(() => {
+                if (Date.now() - lastActivity > IDLE_TIMEOUT_MS) {
+                    console.log(`[serve:${projectName}] Idle timeout reached, shutting down.`);
+                    clearInterval(idleCheck);
+                    process.kill(process.pid, "SIGTERM");
+                }
+            }, 60000);
+            idleCheck.unref();
+        }
+        const server = http.createServer((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            try {
+                if (req.method === "GET" && req.url === "/health") {
+                    lastActivity = Date.now();
+                    res.statusCode = 200;
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify({ status: "ok" }));
+                    return;
+                }
+                if (req.method === "GET" && req.url === "/stats") {
+                    try {
+                        const dbStats = yield vectorDb.getStats();
+                        const cfg = (0, index_config_1.readIndexConfig)(paths.configPath);
+                        const stats = {
+                            files: dbStats.chunks > 0
+                                ? yield vectorDb.getDistinctFileCount()
+                                : 0,
+                            chunks: dbStats.chunks,
+                            totalBytes: dbStats.totalBytes,
+                            vectorDim: (_a = cfg === null || cfg === void 0 ? void 0 : cfg.vectorDim) !== null && _a !== void 0 ? _a : null,
+                            embedMode: (_b = cfg === null || cfg === void 0 ? void 0 : cfg.embedMode) !== null && _b !== void 0 ? _b : (isAppleSilicon ? "gpu" : "cpu"),
+                            model: (_c = cfg === null || cfg === void 0 ? void 0 : cfg.embedModel) !== null && _c !== void 0 ? _c : null,
+                            mlxModel: (_d = cfg === null || cfg === void 0 ? void 0 : cfg.mlxModel) !== null && _d !== void 0 ? _d : null,
+                            indexedAt: (_e = cfg === null || cfg === void 0 ? void 0 : cfg.indexedAt) !== null && _e !== void 0 ? _e : null,
+                            watching: fileWatcher !== null,
+                        };
+                        res.statusCode = 200;
+                        res.setHeader("Content-Type", "application/json");
+                        res.end(JSON.stringify(stats));
+                    }
+                    catch (err) {
+                        res.statusCode = 500;
+                        res.setHeader("Content-Type", "application/json");
+                        res.end(JSON.stringify({
+                            error: (err === null || err === void 0 ? void 0 : err.message) || "stats_failed",
+                        }));
+                    }
+                    return;
+                }
+                if (req.method === "POST" && req.url === "/search") {
+                    lastActivity = Date.now();
+                    const chunks = [];
+                    let totalSize = 0;
+                    let aborted = false;
+                    req.on("data", (chunk) => {
+                        if (aborted)
+                            return;
+                        totalSize += chunk.length;
+                        if (totalSize > 1000000) {
+                            aborted = true;
+                            res.statusCode = 413;
+                            res.setHeader("Content-Type", "application/json");
+                            res.end(JSON.stringify({ error: "payload_too_large" }));
+                            req.destroy();
+                            return;
+                        }
+                        chunks.push(chunk);
+                    });
+                    req.on("end", () => __awaiter(void 0, void 0, void 0, function* () {
+                        if (aborted)
+                            return;
+                        try {
+                            const body = chunks.length
+                                ? JSON.parse(Buffer.concat(chunks).toString("utf-8"))
+                                : {};
+                            const query = typeof body.query === "string" ? body.query : "";
+                            const limit = typeof body.limit === "number" ? body.limit : 10;
+                            let searchPath = "";
+                            if (typeof body.path === "string") {
+                                const resolvedPath = path.resolve(projectRoot, body.path);
+                                const rootPrefix = projectRoot.endsWith(path.sep)
+                                    ? projectRoot
+                                    : `${projectRoot}${path.sep}`;
+                                // Normalize paths for consistency (Windows/Linux)
+                                const normalizedRootPrefix = path.normalize(rootPrefix);
+                                const normalizedResolvedPath = path.normalize(resolvedPath);
+                                if (normalizedResolvedPath !== projectRoot &&
+                                    !normalizedResolvedPath.startsWith(normalizedRootPrefix)) {
+                                    res.statusCode = 400;
+                                    res.setHeader("Content-Type", "application/json");
+                                    res.end(JSON.stringify({ error: "invalid_path" }));
+                                    return;
+                                }
+                                searchPath = path.relative(projectRoot, resolvedPath);
+                            }
+                            // Add AbortController for cancellation
+                            const ac = new AbortController();
+                            req.on("close", () => {
+                                if (req.complete)
+                                    return;
+                                ac.abort();
+                            });
+                            res.on("close", () => {
+                                if (res.writableFinished)
+                                    return;
+                                ac.abort();
+                            });
+                            const result = yield searcher.search(query, limit, { rerank: true }, undefined, searchPath, undefined, // intent
+                            ac.signal);
+                            if (ac.signal.aborted) {
+                                // Request was cancelled, don't write response if possible
+                                // (Though usually 'close' means the socket is gone anyway)
+                                return;
+                            }
+                            res.statusCode = 200;
+                            res.setHeader("Content-Type", "application/json");
+                            res.end(JSON.stringify({ results: result.data }));
+                        }
+                        catch (err) {
+                            if (err instanceof Error && err.name === "AbortError") {
+                                // Request cancelled
+                                return;
+                            }
+                            res.statusCode = 500;
+                            res.setHeader("Content-Type", "application/json");
+                            res.end(JSON.stringify({
+                                error: (err === null || err === void 0 ? void 0 : err.message) || "search_failed",
+                            }));
+                        }
+                    }));
+                    req.on("error", (err) => {
+                        console.error(`[serve:${projectName}] request error:`, err);
+                        aborted = true;
+                    });
+                    return;
+                }
+                res.statusCode = 404;
+                res.end();
+            }
+            catch (err) {
+                console.error(`[serve:${projectName}] request handler error:`, err);
+                if (!res.headersSent) {
+                    res.statusCode = 500;
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify({ error: "internal_error" }));
+                }
+            }
+        }));
+        server.on("error", (e) => {
+            if (e.code === "EADDRINUSE") {
+                const nextPort = port + 1;
+                if (nextPort < startPort + 10) {
+                    console.log(`Port ${port} in use, retrying with ${nextPort}...`);
+                    port = nextPort;
+                    server.close(() => {
+                        server.listen(port);
+                    });
+                    return;
+                }
+                console.error(`Could not find an open port between ${startPort} and ${startPort + 9}`);
+            }
+            console.error(`[serve:${projectName}] server error:`, e);
+            // Ensure we exit if server fails to start
+            process.exit(1);
+        });
+        server.listen(port, () => {
+            const address = server.address();
+            const actualPort = typeof address === "object" && address ? address.port : port;
+            if (!process.env.OSGREP_BACKGROUND) {
+                console.log(`osgrep server listening on http://localhost:${actualPort} (${projectRoot})`);
+            }
+            (0, server_registry_1.registerServer)({
+                pid: process.pid,
+                port: actualPort,
+                projectRoot,
+                startTime: Date.now(),
+            });
+        });
+        const shutdown = () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, server_registry_1.unregisterServer)(process.pid);
+            // Stop file watcher first
+            if (fileWatcher) {
+                try {
+                    yield fileWatcher.close();
+                }
+                catch (_a) { }
+                fileWatcher = null;
+            }
+            // Stop MLX server if we started it
+            if (mlxChild === null || mlxChild === void 0 ? void 0 : mlxChild.pid) {
+                try {
+                    process.kill(mlxChild.pid, "SIGTERM");
+                }
+                catch (_b) { }
+            }
+            // Properly await server close
+            yield new Promise((resolve, reject) => {
+                server.close((err) => {
+                    if (err) {
+                        console.error("Error closing server:", err);
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+                // Timeout fallback in case close hangs
+                setTimeout(resolve, 5000);
+            });
+            // Clean close of owned resources
+            try {
+                metaCache.close();
+            }
+            catch (e) {
+                console.error("Error closing meta cache:", e);
+            }
+            try {
+                yield vectorDb.close();
+            }
+            catch (e) {
+                console.error("Error closing vector DB:", e);
+            }
+            yield (0, exit_1.gracefulExit)();
+        });
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error("Serve failed:", message);
+        process.exitCode = 1;
+        yield (0, exit_1.gracefulExit)(1);
+    }
+}));
+exports.serve
+    .command("status")
+    .description("Show status of background servers")
+    .action(() => {
+    const servers = (0, server_registry_1.listServers)();
+    if (servers.length === 0) {
+        console.log("No running servers found.");
+        return;
+    }
+    console.log("Running servers:");
+    servers.forEach((s) => {
+        console.log(`- PID: ${s.pid} | Port: ${s.port} | Root: ${s.projectRoot}`);
+    });
+});
+exports.serve
+    .command("stop")
+    .description("Stop background servers")
+    .option("--all", "Stop all servers", false)
+    .action((options) => {
+    var _a;
+    if (options.all) {
+        const servers = (0, server_registry_1.listServers)();
+        let count = 0;
+        servers.forEach((s) => {
+            try {
+                process.kill(s.pid, "SIGTERM");
+                count++;
+            }
+            catch (e) {
+                console.error(`Failed to stop PID ${s.pid}:`, e);
+            }
+        });
+        console.log(`Stopped ${count} servers.`);
+    }
+    else {
+        const projectRoot = (_a = (0, project_root_1.findProjectRoot)(process.cwd())) !== null && _a !== void 0 ? _a : process.cwd();
+        const server = (0, server_registry_1.getServerForProject)(projectRoot);
+        if (server) {
+            try {
+                process.kill(server.pid, "SIGTERM");
+                console.log(`Stopped server for ${projectRoot} (PID: ${server.pid})`);
+            }
+            catch (e) {
+                console.error(`Failed to stop PID ${server.pid}:`, e);
+            }
+        }
+        else {
+            console.log(`No server found for ${projectRoot}`);
+        }
+    }
+});

package/dist/commands/setup.js

@@ -0,0 +1,162 @@
+"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.setup = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const p = __importStar(require("@clack/prompts"));
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const grammar_loader_1 = require("../lib/index/grammar-loader");
+const index_config_1 = require("../lib/index/index-config");
+const setup_helpers_1 = require("../lib/setup/setup-helpers");
+const exit_1 = require("../lib/utils/exit");
+const project_root_1 = require("../lib/utils/project-root");
+const MLX_MODELS = [
+    {
+        value: "ibm-granite/granite-embedding-small-english-r2",
+        label: "Granite Small (general purpose, 384-dim)",
+    },
+];
+exports.setup = new commander_1.Command("setup")
+    .description("Interactive setup: download models, choose embedding mode")
+    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    p.intro("osgrep setup");
+    // Step 1: Download ONNX models + grammars (existing behavior)
+    try {
+        yield (0, setup_helpers_1.ensureSetup)();
+    }
+    catch (error) {
+        p.cancel("Setup failed");
+        console.error(error);
+        process.exit(1);
+    }
+    // Download grammars
+    const grammarSpinner = p.spinner();
+    grammarSpinner.start("Checking Tree-sitter grammars...");
+    yield (0, grammar_loader_1.ensureGrammars)(undefined, { silent: true });
+    grammarSpinner.stop("Grammars ready");
+    // Step 2: Show model status
+    const modelIds = [config_1.MODEL_IDS.embed, config_1.MODEL_IDS.colbert];
+    const modelStatuses = modelIds.map((id) => {
+        const modelPath = path.join(config_1.PATHS.models, ...id.split("/"));
+        return { id, exists: fs.existsSync(modelPath) };
+    });
+    modelStatuses.forEach(({ id, exists }) => {
+        p.log.info(`${exists ? "✓" : "✗"} ${id}`);
+    });
+    // Check skiplist
+    const colbertPath = path.join(config_1.PATHS.models, ...config_1.MODEL_IDS.colbert.split("/"));
+    const skiplistPath = path.join(colbertPath, "skiplist.json");
+    if (!fs.existsSync(skiplistPath)) {
+        try {
+            const url = `https://huggingface.co/${config_1.MODEL_IDS.colbert}/resolve/main/skiplist.json`;
+            const response = yield fetch(url);
+            if (response.ok) {
+                const buffer = yield response.arrayBuffer();
+                fs.writeFileSync(skiplistPath, Buffer.from(buffer));
+                p.log.success("Skiplist downloaded");
+            }
+        }
+        catch (_c) {
+            p.log.warn("Skiplist download failed (will use fallback)");
+        }
+    }
+    // Step 3: Interactive embed mode selection
+    const paths = (0, project_root_1.ensureProjectPaths)(process.cwd());
+    const existingConfig = (0, index_config_1.readIndexConfig)(paths.configPath);
+    const embedMode = yield p.select({
+        message: "Embedding mode",
+        options: [
+            {
+                value: "cpu",
+                label: "CPU only",
+                hint: "ONNX — works everywhere",
+            },
+            {
+                value: "gpu",
+                label: "GPU (MLX)",
+                hint: "Apple Silicon only, faster indexing + search",
+            },
+        ],
+        initialValue: (_a = existingConfig === null || existingConfig === void 0 ? void 0 : existingConfig.embedMode) !== null && _a !== void 0 ? _a : (process.arch === "arm64" && process.platform === "darwin"
+            ? "gpu"
+            : "cpu"),
+    });
+    if (p.isCancel(embedMode)) {
+        p.cancel("Setup cancelled");
+        yield (0, exit_1.gracefulExit)();
+        return;
+    }
+    let mlxModel;
+    if (embedMode === "gpu") {
+        const modelChoice = yield p.select({
+            message: "MLX embedding model",
+            options: MLX_MODELS.map((m) => ({
+                value: m.value,
+                label: m.label,
+            })),
+            initialValue: (_b = existingConfig === null || existingConfig === void 0 ? void 0 : existingConfig.mlxModel) !== null && _b !== void 0 ? _b : MLX_MODELS[0].value,
+        });
+        if (p.isCancel(modelChoice)) {
+            p.cancel("Setup cancelled");
+            yield (0, exit_1.gracefulExit)();
+            return;
+        }
+        mlxModel = modelChoice;
+    }
+    // Step 4: Write config
+    (0, index_config_1.writeSetupConfig)(paths.configPath, { embedMode, mlxModel });
+    // Step 5: Warn about reindex if mode/model changed
+    if ((existingConfig === null || existingConfig === void 0 ? void 0 : existingConfig.indexedAt) &&
+        (existingConfig.embedMode !== embedMode ||
+            existingConfig.mlxModel !== mlxModel)) {
+        p.log.warn("Embedding mode changed. Run `osgrep serve` to reindex with the new settings.");
+    }
+    p.outro(embedMode === "gpu"
+        ? `Ready — GPU mode with ${mlxModel}`
+        : "Ready — CPU mode");
+    yield (0, exit_1.gracefulExit)();
+}));