grepmax 0.1.0

package/dist/commands/codex.js

@@ -0,0 +1,98 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uninstallCodex = exports.installCodex = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const commander_1 = require("commander");
+const shell = process.env.SHELL || (process.platform === "win32" ? "cmd.exe" : "/bin/sh");
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+const SKILL = `
+---
+name: osgrep
+description: Semantic code search and call-graph tracing via osgrep.
+---
+
+## ⚠️ CRITICAL: Handling "Indexing" State
+If the tool output says **"Indexing"**, **"Building"**, or **"Syncing"**:
+1. **STOP.** Do not hallucinate results.
+2. **INFORM** the user: "The semantic index is still building. Results are partial."
+3. **ASK** if they want to proceed or wait.
+
+## Commands
+- Search: \`osgrep "auth logic" --compact\`
+- Trace: \`osgrep trace "AuthService"\`
+`;
+function installPlugin() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // 1. Register the MCP Tool
+            // 'osgrep mcp' acts as the server.
+            yield execAsync("codex mcp add osgrep osgrep mcp", {
+                shell,
+                env: process.env,
+            });
+            console.log("✅ osgrep MCP tool registered with Codex");
+            // 2. Add Instructions to AGENTS.md
+            const destPath = node_path_1.default.join(node_os_1.default.homedir(), ".codex", "AGENTS.md");
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(destPath), { recursive: true });
+            const content = node_fs_1.default.existsSync(destPath)
+                ? node_fs_1.default.readFileSync(destPath, "utf-8")
+                : "";
+            // Only append if not present
+            if (!content.includes("name: osgrep")) {
+                node_fs_1.default.appendFileSync(destPath, "\n" + SKILL);
+                console.log("✅ osgrep skill instructions added to Codex");
+            }
+            else {
+                console.log("ℹ️  osgrep skill instructions already present");
+            }
+        }
+        catch (error) {
+            console.error(`❌ Error installing Codex plugin: ${error}`);
+            process.exit(1);
+        }
+    });
+}
+function uninstallPlugin() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield execAsync("codex mcp remove osgrep", { shell, env: process.env });
+            console.log("✅ osgrep MCP tool removed");
+        }
+        catch (e) {
+            /* ignore if not found */
+        }
+        const destPath = node_path_1.default.join(node_os_1.default.homedir(), ".codex", "AGENTS.md");
+        if (node_fs_1.default.existsSync(destPath)) {
+            let content = node_fs_1.default.readFileSync(destPath, "utf-8");
+            // Naive removal: strictly matches the block we added.
+            // For robust removal, you might need regex, but this works if the string is exact.
+            if (content.includes(SKILL)) {
+                content = content.replace(SKILL, "").trim();
+                node_fs_1.default.writeFileSync(destPath, content);
+                console.log("✅ osgrep instructions removed from AGENTS.md");
+            }
+        }
+    });
+}
+exports.installCodex = new commander_1.Command("install-codex")
+    .description("Install osgrep for Codex")
+    .action(installPlugin);
+exports.uninstallCodex = new commander_1.Command("uninstall-codex")
+    .description("Uninstall osgrep from Codex")
+    .action(uninstallPlugin);

package/dist/commands/doctor.js

@@ -0,0 +1,92 @@
+"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.doctor = void 0;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const commander_1 = require("commander");
+const config_1 = require("../config");
+const exit_1 = require("../lib/utils/exit");
+const project_root_1 = require("../lib/utils/project-root");
+exports.doctor = new commander_1.Command("doctor")
+    .description("Check osgrep health and paths")
+    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    console.log("🏥 osgrep Doctor\n");
+    const root = config_1.PATHS.globalRoot;
+    const models = config_1.PATHS.models;
+    const grammars = config_1.PATHS.grammars;
+    const modelIds = [config_1.MODEL_IDS.embed, config_1.MODEL_IDS.colbert];
+    const checkDir = (name, p) => {
+        const exists = fs.existsSync(p);
+        const symbol = exists ? "✅" : "❌";
+        console.log(`${symbol} ${name}: ${p}`);
+    };
+    checkDir("Root", root);
+    checkDir("Models", models);
+    checkDir("Grammars", grammars);
+    const modelStatuses = modelIds.map((id) => {
+        const modelPath = path.join(models, ...id.split("/"));
+        return { id, path: modelPath, exists: fs.existsSync(modelPath) };
+    });
+    modelStatuses.forEach(({ id, path: p, exists }) => {
+        const symbol = exists ? "✅" : "❌";
+        console.log(`${symbol} Model: ${id} (${p})`);
+    });
+    const missingModels = modelStatuses.filter(({ exists }) => !exists);
+    if (missingModels.length > 0) {
+        console.log("❌ Some models are missing; osgrep will try bundled copies first, then download.");
+    }
+    console.log(`\nLocal Project: ${process.cwd()}`);
+    const projectRoot = (0, project_root_1.findProjectRoot)(process.cwd());
+    if (projectRoot) {
+        console.log(`✅ Index found at: ${path.join(projectRoot, ".osgrep")}`);
+    }
+    else {
+        console.log(`ℹ️  No index found in current directory (run 'osgrep index' to create one)`);
+    }
+    console.log(`\nSystem: ${os.platform()} ${os.arch()} | Node: ${process.version}`);
+    console.log("\nIf you see ✅ everywhere, you are ready to search!");
+    yield (0, exit_1.gracefulExit)();
+}));

package/dist/commands/droid.js

@@ -0,0 +1,189 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uninstallDroid = exports.installDroid = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const commander_1 = require("commander");
+const SKILL = `
+---
+name: osgrep
+description: Semantic code search and call-graph tracing for AI agents. Finds code by concept, surfaces roles (ORCHESTRATION vs DEFINITION), and traces dependencies.
+allowed-tools: "Bash(osgrep:*), Read"
+license: Apache-2.0
+---
+
+## ⚠️ CRITICAL: Handling "Indexing" State
+If any \`osgrep\` command returns a status indicating **"Indexing"**, **"Building"**, or **"Syncing"**:
+1. **STOP** your current train of thought.
+2. **INFORM** the user: "The semantic index is currently building. Search results will be incomplete."
+3. **ASK**: "Do you want me to proceed with partial results, or wait for indexing to finish?"
+   *(Do not assume you should proceed without confirmation).*
+
+## Core Commands
+- Search: \`osgrep "how does auth work" --compact\`
+- Trace: \`osgrep trace "AuthService"\`
+- Symbols: \`osgrep symbols "Auth"\`
+
+## Output (Default = Compact TSV)
+- One line per hit: \`path\\tlines\\tscore\\trole\\tconf\\tdefined\\tpreview\`
+- Roles: \`ORCH\` (Orchestration), \`DEF\` (Definition), \`IMPL\` (Implementation).
+- **Note:** If output is empty but valid, say "No semantic matches found."
+
+## Typical Workflow
+
+1. **Discover**
+   \`\`\`bash
+   osgrep "worker pool lifecycle" --compact
+   \`\`\`
+
+2. **Explore**
+   \`\`\`bash
+   osgrep symbols Worker
+   \`\`\`
+
+3. **Trace**
+   \`\`\`bash
+   osgrep trace WorkerPool
+   \`\`\`
+
+4. **Read**
+   \`\`\`bash
+   Read src/lib/workers/pool.ts:112-186
+   \`\`\`
+`;
+function resolveDroidRoot() {
+    const root = node_path_1.default.join(node_os_1.default.homedir(), ".factory");
+    if (!node_fs_1.default.existsSync(root)) {
+        throw new Error(`Factory Droid directory not found at ${root}. Run Factory Droid once to initialize.`);
+    }
+    return root;
+}
+function writeFileIfChanged(filePath, content) {
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
+    const already = node_fs_1.default.existsSync(filePath)
+        ? node_fs_1.default.readFileSync(filePath, "utf-8")
+        : undefined;
+    if (already !== content)
+        node_fs_1.default.writeFileSync(filePath, content);
+}
+function parseJsonWithComments(content) {
+    const stripped = content
+        .split("\n")
+        .map((line) => line.replace(/^\s*\/\/.*$/, ""))
+        .join("\n");
+    try {
+        return JSON.parse(stripped);
+    }
+    catch (_a) {
+        return {};
+    }
+}
+function loadSettings(settingsPath) {
+    if (!node_fs_1.default.existsSync(settingsPath))
+        return {};
+    return parseJsonWithComments(node_fs_1.default.readFileSync(settingsPath, "utf-8"));
+}
+function saveSettings(settingsPath, settings) {
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(settingsPath), { recursive: true });
+    node_fs_1.default.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+}
+function mergeHooks(existing, incoming) {
+    const merged = existing ? JSON.parse(JSON.stringify(existing)) : {};
+    for (const [event, entries] of Object.entries(incoming)) {
+        const current = merged[event] || [];
+        for (const entry of entries) {
+            // Simple duplicate check based on command string
+            const cmd = entry.hooks[0].command;
+            if (!current.some((c) => c.hooks[0].command === cmd)) {
+                current.push(entry);
+            }
+        }
+        merged[event] = current;
+    }
+    return merged;
+}
+// --- MAIN INSTALLER ---
+function installPlugin() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const root = resolveDroidRoot();
+        const hooksDir = node_path_1.default.join(root, "hooks", "osgrep");
+        const skillsDir = node_path_1.default.join(root, "skills", "osgrep");
+        const settingsPath = node_path_1.default.join(root, "settings.json");
+        // 1. Install Hook Scripts (Start/Stop Daemon)
+        // We expect these files to exist in your dist/hooks folder
+        const startJsPath = node_path_1.default.join(hooksDir, "osgrep_start.js");
+        const stopJsPath = node_path_1.default.join(hooksDir, "osgrep_stop.js");
+        // Create these scripts dynamically if we don't want to read from dist
+        const startScript = `
+const { spawn } = require("child_process");
+const fs = require("fs");
+const out = fs.openSync("/tmp/osgrep.log", "a");
+const child = spawn("osgrep", ["serve"], { detached: true, stdio: ["ignore", out, out] });
+child.unref();
+`;
+        const stopScript = `
+const { spawnSync, execSync } = require("child_process");
+try { execSync("pkill -f 'osgrep serve'"); } catch {}
+`;
+        writeFileIfChanged(startJsPath, startScript.trim());
+        writeFileIfChanged(stopJsPath, stopScript.trim());
+        // 2. Install Skill (with Indexing Warning)
+        writeFileIfChanged(node_path_1.default.join(skillsDir, "SKILL.md"), SKILL.trimStart());
+        // 3. Configure Settings
+        const hookConfig = {
+            SessionStart: [
+                {
+                    matcher: "startup|resume",
+                    hooks: [
+                        { type: "command", command: `node "${startJsPath}"`, timeout: 10 },
+                    ],
+                },
+            ],
+            SessionEnd: [
+                {
+                    hooks: [
+                        { type: "command", command: `node "${stopJsPath}"`, timeout: 10 },
+                    ],
+                },
+            ],
+        };
+        const settings = loadSettings(settingsPath);
+        settings.enableHooks = true;
+        settings.allowBackgroundProcesses = true;
+        settings.hooks = mergeHooks(settings.hooks, hookConfig);
+        saveSettings(settingsPath, settings);
+        console.log(`✅ osgrep installed for Factory Droid (Hooks + Skill)`);
+    });
+}
+function uninstallPlugin() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const root = resolveDroidRoot();
+        const hooksDir = node_path_1.default.join(root, "hooks", "osgrep");
+        const skillsDir = node_path_1.default.join(root, "skills", "osgrep");
+        if (node_fs_1.default.existsSync(hooksDir))
+            node_fs_1.default.rmSync(hooksDir, { recursive: true, force: true });
+        if (node_fs_1.default.existsSync(skillsDir))
+            node_fs_1.default.rmSync(skillsDir, { recursive: true, force: true });
+        console.log("✅ osgrep removed from Factory Droid");
+        console.log("NOTE: You may want to manually clean up 'hooks' in ~/.factory/settings.json");
+    });
+}
+exports.installDroid = new commander_1.Command("install-droid")
+    .description("Install osgrep for Factory Droid")
+    .action(installPlugin);
+exports.uninstallDroid = new commander_1.Command("uninstall-droid")
+    .description("Uninstall osgrep from Factory Droid")
+    .action(uninstallPlugin);

package/dist/commands/index.js

@@ -0,0 +1,125 @@
+"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.index = void 0;
+const path = __importStar(require("node:path"));
+const commander_1 = require("commander");
+const grammar_loader_1 = require("../lib/index/grammar-loader");
+const sync_helpers_1 = require("../lib/index/sync-helpers");
+const syncer_1 = require("../lib/index/syncer");
+const setup_helpers_1 = require("../lib/setup/setup-helpers");
+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");
+exports.index = new commander_1.Command("index")
+    .description("Index the current directory and create searchable store")
+    .option("-d, --dry-run", "Dry run the indexing process (no actual file syncing)", false)
+    .option("-p, --path <dir>", "Path to index (defaults to current directory)", "")
+    .option("-r, --reset", "Remove existing index and re-index from scratch", false)
+    .option("-v, --verbose", "Show detailed progress with file names", false)
+    .action((_args, cmd) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const options = cmd.optsWithGlobals();
+    let vectorDb = null;
+    try {
+        yield (0, setup_helpers_1.ensureSetup)();
+        const indexRoot = options.path
+            ? path.resolve(options.path)
+            : process.cwd();
+        const projectRoot = (_a = (0, project_root_1.findProjectRoot)(indexRoot)) !== null && _a !== void 0 ? _a : indexRoot;
+        const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
+        vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
+        if (options.reset) {
+            console.log(`Resetting index at ${paths.osgrepDir}...`);
+            // We do NOT manually drop/rm here anymore to avoid race conditions.
+            // The syncer handles it inside the lock.
+        }
+        // Ensure grammars are present before indexing (silent if already exist)
+        yield (0, grammar_loader_1.ensureGrammars)(console.log, { silent: true });
+        const { spinner, onProgress } = (0, sync_helpers_1.createIndexingSpinner)(projectRoot, "Indexing...", { verbose: options.verbose });
+        try {
+            const result = yield (0, syncer_1.initialSync)({
+                projectRoot,
+                dryRun: options.dryRun,
+                reset: options.reset,
+                onProgress,
+            });
+            if (options.dryRun) {
+                spinner.succeed(`Dry run complete(${result.processed} / ${result.total}) • would have indexed ${result.indexed} `);
+                console.log((0, sync_helpers_1.formatDryRunSummary)(result, {
+                    actionDescription: "would have indexed",
+                    includeTotal: true,
+                }));
+                return;
+            }
+            const failedSuffix = result.failedFiles > 0 ? ` • ${result.failedFiles} failed` : "";
+            spinner.succeed(`Indexing complete(${result.processed} / ${result.total}) • indexed ${result.indexed}${failedSuffix} `);
+        }
+        catch (e) {
+            spinner.fail("Indexing failed");
+            throw e;
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error("Failed to index:", message);
+        process.exitCode = 1;
+    }
+    finally {
+        if (vectorDb) {
+            try {
+                yield vectorDb.close();
+            }
+            catch (err) {
+                console.error("Failed to close VectorDB:", err);
+            }
+        }
+        const code = typeof process.exitCode === "number"
+            ? process.exitCode
+            : process.exitCode === undefined
+                ? 0
+                : 1;
+        yield (0, exit_1.gracefulExit)(code);
+    }
+}));

package/dist/commands/list.js

@@ -0,0 +1,120 @@
+"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.list = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const commander_1 = require("commander");
+const exit_1 = require("../lib/utils/exit");
+const project_root_1 = require("../lib/utils/project-root");
+const style = {
+    bold: (s) => `\x1b[1m${s}\x1b[22m`,
+    dim: (s) => `\x1b[2m${s}\x1b[22m`,
+    green: (s) => `\x1b[32m${s}\x1b[39m`,
+};
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+function formatDate(date) {
+    const now = new Date();
+    const diff = now.getTime() - date.getTime();
+    const seconds = Math.floor(diff / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return `${days}d ago`;
+    if (hours > 0)
+        return `${hours}h ago`;
+    if (minutes > 0)
+        return `${minutes}m ago`;
+    return "just now";
+}
+function getDirectorySize(dirPath) {
+    let totalSize = 0;
+    try {
+        const items = fs.readdirSync(dirPath);
+        for (const item of items) {
+            const itemPath = path.join(dirPath, item);
+            const stats = fs.statSync(itemPath);
+            if (stats.isDirectory()) {
+                totalSize += getDirectorySize(itemPath);
+            }
+            else {
+                totalSize += stats.size;
+            }
+        }
+    }
+    catch (_a) { }
+    return totalSize;
+}
+exports.list = new commander_1.Command("list")
+    .description("Show the current project's .osgrep contents")
+    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const projectRoot = (_a = (0, project_root_1.findProjectRoot)(process.cwd())) !== null && _a !== void 0 ? _a : process.cwd();
+    const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
+    const entries = [
+        { label: "LanceDB", dir: paths.lancedbDir },
+        { label: "Cache", dir: paths.cacheDir },
+    ];
+    console.log(`\n${style.bold("Project")}: ${style.green(projectRoot)}`);
+    console.log(`${style.dim("Data directory")}: ${paths.osgrepDir}\n`);
+    for (const entry of entries) {
+        if (!fs.existsSync(entry.dir)) {
+            console.log(`${entry.label}: ${style.dim("not created yet")}`);
+            continue;
+        }
+        const stats = fs.statSync(entry.dir);
+        const size = getDirectorySize(entry.dir);
+        console.log(`${entry.label}: ${style.green(formatSize(size))} ${style.dim(`(updated ${formatDate(stats.mtime)})`)}`);
+    }
+    yield (0, exit_1.gracefulExit)();
+}));