grepmax 0.1.0 → 0.2.0

package/dist/lib/index/index-config.js

@@ -3,7 +3,7 @@
  * Index configuration — tracks which models built the current index.
  * Prevents searching with incompatible vectors after a model swap.
  *
- * Also stores user preferences from `osgrep setup` (embed mode, MLX model).
+ * Also stores user preferences from `gmax setup` (embed mode, MLX model).
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -39,12 +39,47 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.readGlobalConfig = readGlobalConfig;
+exports.writeGlobalConfig = writeGlobalConfig;
+exports.getModelIdsForTier = getModelIdsForTier;
 exports.readIndexConfig = readIndexConfig;
 exports.writeIndexConfig = writeIndexConfig;
 exports.writeSetupConfig = writeSetupConfig;
 exports.checkModelMismatch = checkModelMismatch;
 const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
 const config_1 = require("../../config");
+const GLOBAL_CONFIG_PATH = path.join(config_1.PATHS.globalRoot, "config.json");
+function readGlobalConfig() {
+    try {
+        const raw = fs.readFileSync(GLOBAL_CONFIG_PATH, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch (_a) {
+        const tier = config_1.MODEL_TIERS[config_1.DEFAULT_MODEL_TIER];
+        return {
+            modelTier: config_1.DEFAULT_MODEL_TIER,
+            vectorDim: tier.vectorDim,
+            embedMode: "cpu",
+        };
+    }
+}
+function writeGlobalConfig(config) {
+    fs.mkdirSync(path.dirname(GLOBAL_CONFIG_PATH), { recursive: true });
+    fs.writeFileSync(GLOBAL_CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`);
+}
+/**
+ * Resolve the effective model IDs for a given tier.
+ */
+function getModelIdsForTier(tierName) {
+    var _a;
+    const tier = (_a = config_1.MODEL_TIERS[tierName]) !== null && _a !== void 0 ? _a : config_1.MODEL_TIERS[config_1.DEFAULT_MODEL_TIER];
+    return {
+        embed: tier.onnxModel,
+        colbert: config_1.MODEL_IDS.colbert,
+        vectorDim: tier.vectorDim,
+    };
+}
 function readIndexConfig(configPath) {
     try {
         const raw = fs.readFileSync(configPath, "utf-8");
@@ -55,32 +90,37 @@ function readIndexConfig(configPath) {
     }
 }
 function writeIndexConfig(configPath, extra) {
+    var _a;
     const existing = readIndexConfig(configPath);
+    const tierName = (_a = existing === null || existing === void 0 ? void 0 : existing.modelTier) !== null && _a !== void 0 ? _a : readGlobalConfig().modelTier;
+    const tierIds = getModelIdsForTier(tierName);
     const config = Object.assign({ 
         // Preserve user preferences from setup
-        embedMode: existing === null || existing === void 0 ? void 0 : existing.embedMode, mlxModel: existing === null || existing === void 0 ? void 0 : existing.mlxModel, 
+        embedMode: existing === null || existing === void 0 ? void 0 : existing.embedMode, mlxModel: existing === null || existing === void 0 ? void 0 : existing.mlxModel, modelTier: tierName, 
         // Model identity from current run
-        embedModel: config_1.MODEL_IDS.embed, colbertModel: config_1.MODEL_IDS.colbert, vectorDim: config_1.CONFIG.VECTOR_DIM, indexedAt: new Date().toISOString() }, extra);
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+        embedModel: tierIds.embed, colbertModel: tierIds.colbert, vectorDim: tierIds.vectorDim, indexedAt: new Date().toISOString() }, extra);
+    fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
 }
 /**
  * Write only user preferences without touching model identity fields.
- * Used by `osgrep setup` before any indexing has happened.
+ * Used by `gmax setup` before any indexing has happened.
  */
 function writeSetupConfig(configPath, prefs) {
     const existing = readIndexConfig(configPath);
-    const config = Object.assign(Object.assign({}, existing), { embedMode: prefs.embedMode, mlxModel: prefs.mlxModel });
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    const config = Object.assign(Object.assign({}, existing), { embedMode: prefs.embedMode, mlxModel: prefs.mlxModel, modelTier: prefs.modelTier });
+    fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
 }
 function checkModelMismatch(configPath) {
     const stored = readIndexConfig(configPath);
     if (!stored)
         return false; // No config yet — first index
-    if (stored.embedModel !== config_1.MODEL_IDS.embed)
+    const globalConfig = readGlobalConfig();
+    const tierIds = getModelIdsForTier(globalConfig.modelTier);
+    if (stored.embedModel && stored.embedModel !== tierIds.embed)
         return true;
-    if (stored.colbertModel !== config_1.MODEL_IDS.colbert)
+    if (stored.colbertModel && stored.colbertModel !== tierIds.colbert)
         return true;
-    if (stored.vectorDim !== undefined && stored.vectorDim !== config_1.CONFIG.VECTOR_DIM)
+    if (stored.vectorDim !== undefined && stored.vectorDim !== tierIds.vectorDim)
         return true;
     return false;
 }

package/dist/lib/index/sync-helpers.js

@@ -56,7 +56,7 @@ function createIndexingSpinner(root, label = "Indexing files...", options = {})
                     info.filePath.startsWith("Processing") ||
                     info.filePath.startsWith("Checking for changes"))) {
                 spinner.text = info.filePath;
-                if (process.env.OSGREP_DEBUG_INDEX === "1") {
+                if (process.env.GMAX_DEBUG_INDEX === "1") {
                     console.log(`[progress] ${info.filePath}`);
                 }
                 return;

package/dist/lib/index/syncer.js

@@ -57,10 +57,11 @@ const meta_cache_1 = require("../store/meta-cache");
 const vector_db_1 = require("../store/vector-db");
 const file_utils_1 = require("../utils/file-utils");
 const lock_1 = require("../utils/lock");
+const project_registry_1 = require("../utils/project-registry");
 const project_root_1 = require("../utils/project-root");
 const pool_1 = require("../workers/pool");
-const walker_1 = require("./walker");
 const index_config_1 = require("./index-config");
+const walker_1 = require("./walker");
 function flushBatch(db, meta, vectors, pendingMeta, pendingDeletes, dryRun) {
     return __awaiter(this, void 0, void 0, function* () {
         if (dryRun)
@@ -87,6 +88,16 @@ function createNoopMetaCache() {
                 return new Set(store.keys());
             });
         },
+        getKeysWithPrefix(prefix) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const keys = new Set();
+                for (const k of store.keys()) {
+                    if (k.startsWith(prefix))
+                        keys.add(k);
+                }
+                return keys;
+            });
+        },
         put: (filePath, entry) => {
             store.set(filePath, entry);
         },
@@ -101,15 +112,20 @@ function initialSync(options) {
         var _a, e_1, _b, _c;
         const { projectRoot, dryRun = false, reset = false, onProgress, signal, } = options;
         const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
+        const resolvedRoot = path.resolve(projectRoot);
+        // Path prefix for scoping — all absolute paths for this project start with this
+        const rootPrefix = resolvedRoot.endsWith("/")
+            ? resolvedRoot
+            : `${resolvedRoot}/`;
         // Propagate project root to worker processes
-        process.env.OSGREP_PROJECT_ROOT = paths.root;
+        process.env.GMAX_PROJECT_ROOT = paths.root;
         let lock = null;
         const vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
         const treatAsEmptyCache = reset && dryRun;
         let metaCache = null;
         try {
             if (!dryRun) {
-                lock = yield (0, lock_1.acquireWriterLockWithRetry)(paths.osgrepDir);
+                lock = yield (0, lock_1.acquireWriterLockWithRetry)(paths.dataDir);
                 // Open MetaCache only after lock is acquired
                 metaCache = new meta_cache_1.MetaCache(paths.lmdbPath);
             }
@@ -117,33 +133,28 @@ function initialSync(options) {
                 metaCache = createNoopMetaCache();
             }
             if (!dryRun) {
-                const hasRows = yield vectorDb.hasAnyRows();
-                const hasMeta = (yield metaCache.getAllKeys()).size > 0;
-                const isInconsistent = (hasRows && !hasMeta) || (!hasRows && hasMeta);
+                // Scope checks to this project's paths only
+                const projectKeys = yield metaCache.getKeysWithPrefix(rootPrefix);
                 const modelChanged = (0, index_config_1.checkModelMismatch)(paths.configPath);
-                if (reset || isInconsistent || modelChanged) {
+                if (reset || modelChanged) {
                     if (modelChanged) {
                         const stored = (0, index_config_1.readIndexConfig)(paths.configPath);
                         console.warn(`[syncer] Embedding model changed: ${stored === null || stored === void 0 ? void 0 : stored.embedModel} → ${config_1.MODEL_IDS.embed}. Forcing full re-index.`);
                     }
-                    else if (isInconsistent) {
-                        console.warn("[syncer] Detected inconsistent state (VectorDB/MetaCache mismatch). Forcing re-sync.");
-                    }
-                    yield vectorDb.drop();
-                    metaCache.close();
-                    try {
-                        fs.rmSync(paths.lmdbPath, { force: true });
+                    // Only delete this project's data from the centralized store
+                    yield vectorDb.deletePathsWithPrefix(rootPrefix);
+                    for (const key of projectKeys) {
+                        metaCache.delete(key);
                     }
-                    catch (_d) { }
-                    metaCache = new meta_cache_1.MetaCache(paths.lmdbPath);
                 }
             }
             let total = 0;
             onProgress === null || onProgress === void 0 ? void 0 : onProgress({ processed: 0, indexed: 0, total, filePath: "Scanning..." });
             const pool = (0, pool_1.getWorkerPool)();
+            // Get only this project's cached paths (scoped by prefix)
             const cachedPaths = dryRun || treatAsEmptyCache
                 ? new Set()
-                : yield metaCache.getAllKeys();
+                : yield metaCache.getKeysWithPrefix(rootPrefix);
             const seenPaths = new Set();
             const visitedRealPaths = new Set();
             const batch = [];
@@ -196,12 +207,12 @@ function initialSync(options) {
                 yield flushLock;
             });
             const isTimeoutError = (err) => { var _a; return err instanceof Error && ((_a = err.message) === null || _a === void 0 ? void 0 : _a.toLowerCase().includes("timed out")); };
-            const processFileWithRetry = (relPath, absPath) => __awaiter(this, void 0, void 0, function* () {
+            const processFileWithRetry = (absPath) => __awaiter(this, void 0, void 0, function* () {
                 let retries = 0;
                 while (true) {
                     try {
                         return yield pool.processFile({
-                            path: relPath,
+                            path: absPath,
                             absolutePath: absPath,
                         });
                     }
@@ -227,18 +238,16 @@ function initialSync(options) {
                 }
             });
             try {
-                for (var _e = true, _f = __asyncValues((0, walker_1.walk)(paths.root, {
-                    additionalPatterns: ["**/.git/**", "**/.osgrep/**"], // exclude .git and .osgrep explicitly if walker doesn't
-                })), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
-                    _c = _g.value;
-                    _e = false;
+                for (var _d = true, _e = __asyncValues((0, walker_1.walk)(paths.root, {
+                    additionalPatterns: ["**/.git/**", "**/.gmax/**", "**/.osgrep/**"],
+                })), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
                     const relPath = _c;
                     if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                         shouldSkipCleanup = true;
                         break;
                     }
-                    // Walker yields relative paths
-                    // if (ignoreFilter.ignores(relPath)) continue; // Handled by walker
                     const absPath = path.join(paths.root, relPath);
                     // Check real path to avoid duplicates and loops
                     try {
@@ -247,7 +256,7 @@ function initialSync(options) {
                             continue;
                         visitedRealPaths.add(realPath);
                     }
-                    catch (_h) {
+                    catch (_g) {
                         // Skip broken symlinks or inaccessible files
                         continue;
                     }
@@ -263,18 +272,19 @@ function initialSync(options) {
                             if (!(0, file_utils_1.isIndexableFile)(absPath, stats.size)) {
                                 return;
                             }
+                            // Use absolute path as the key for MetaCache
                             const cached = treatAsEmptyCache
                                 ? undefined
-                                : metaCache.get(relPath);
+                                : metaCache.get(absPath);
                             if (cached &&
                                 cached.mtimeMs === stats.mtimeMs &&
                                 cached.size === stats.size) {
                                 processed += 1;
-                                seenPaths.add(relPath);
+                                seenPaths.add(absPath);
                                 markProgress(relPath);
                                 return;
                             }
-                            const result = yield processFileWithRetry(relPath, absPath);
+                            const result = yield processFileWithRetry(absPath);
                             const metaEntry = {
                                 hash: result.hash,
                                 mtimeMs: result.mtimeMs,
@@ -282,41 +292,41 @@ function initialSync(options) {
                             };
                             if (result.shouldDelete) {
                                 if (!dryRun) {
-                                    pendingDeletes.add(relPath);
-                                    pendingMeta.set(relPath, metaEntry);
+                                    pendingDeletes.add(absPath);
+                                    pendingMeta.set(absPath, metaEntry);
                                     yield flush(false);
                                 }
                                 processed += 1;
-                                seenPaths.add(relPath);
+                                seenPaths.add(absPath);
                                 markProgress(relPath);
                                 return;
                             }
                             if (cached && cached.hash === result.hash) {
                                 if (!dryRun) {
-                                    metaCache.put(relPath, metaEntry);
+                                    metaCache.put(absPath, metaEntry);
                                 }
                                 processed += 1;
-                                seenPaths.add(relPath);
+                                seenPaths.add(absPath);
                                 markProgress(relPath);
                                 return;
                             }
                             if (dryRun) {
                                 processed += 1;
                                 indexed += 1;
-                                seenPaths.add(relPath);
+                                seenPaths.add(absPath);
                                 markProgress(relPath);
                                 return;
                             }
-                            pendingDeletes.add(relPath);
+                            pendingDeletes.add(absPath);
                             if (result.vectors.length > 0) {
                                 batch.push(...result.vectors);
-                                pendingMeta.set(relPath, metaEntry);
+                                pendingMeta.set(absPath, metaEntry);
                                 indexed += 1;
                             }
                             else {
-                                pendingMeta.set(relPath, metaEntry);
+                                pendingMeta.set(absPath, metaEntry);
                             }
-                            seenPaths.add(relPath);
+                            seenPaths.add(absPath);
                             processed += 1;
                             markProgress(relPath);
                             yield flush(false);
@@ -325,10 +335,10 @@ function initialSync(options) {
                             const code = err === null || err === void 0 ? void 0 : err.code;
                             if (code === "ENOENT") {
                                 // Treat missing files as deletions.
-                                pendingDeletes.add(relPath);
-                                pendingMeta.delete(relPath);
+                                pendingDeletes.add(absPath);
+                                pendingMeta.delete(absPath);
                                 if (!dryRun) {
-                                    metaCache.delete(relPath);
+                                    metaCache.delete(absPath);
                                 }
                                 processed += 1;
                                 markProgress(relPath);
@@ -337,7 +347,7 @@ function initialSync(options) {
                             }
                             failedFiles += 1;
                             processed += 1;
-                            seenPaths.add(relPath);
+                            seenPaths.add(absPath);
                             console.error(`[sync] Failed to process ${relPath}:`, err);
                             markProgress(relPath);
                         }
@@ -347,7 +357,7 @@ function initialSync(options) {
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
-                    if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
                 }
                 finally { if (e_1) throw e_1.error; }
             }
@@ -370,6 +380,7 @@ function initialSync(options) {
                 });
                 yield vectorDb.createFTSIndex();
             }
+            // Stale cleanup: only remove paths scoped to this project's root
             const stale = Array.from(cachedPaths).filter((p) => !seenPaths.has(p));
             if (!dryRun && stale.length > 0 && !shouldSkipCleanup) {
                 yield vectorDb.deletePaths(stale);
@@ -380,6 +391,17 @@ function initialSync(options) {
             // Write model config so future runs can detect model changes
             if (!dryRun) {
                 (0, index_config_1.writeIndexConfig)(paths.configPath);
+                // Register project in global registry
+                const globalConfig = (0, index_config_1.readGlobalConfig)();
+                (0, project_registry_1.registerProject)({
+                    root: paths.root,
+                    name: path.basename(paths.root),
+                    vectorDim: globalConfig.vectorDim,
+                    modelTier: globalConfig.modelTier,
+                    embedMode: globalConfig.embedMode,
+                    lastIndexed: new Date().toISOString(),
+                    chunkCount: indexed,
+                });
             }
             // Finalize total so callers can display a meaningful summary.
             total = processed;

package/dist/lib/index/walker.js

@@ -86,7 +86,7 @@ function getIgnoreFilter(dir, ignoreFiles) {
                     filter = (0, ignore_1.default)();
                 filter.add(content);
             }
-            catch (err) {
+            catch (_err) {
                 // Ignore missing files
             }
         }
@@ -95,7 +95,7 @@ function getIgnoreFilter(dir, ignoreFiles) {
 }
 function walk(rootDir_1) {
     return __asyncGenerator(this, arguments, function* walk_1(rootDir, options = {}) {
-        const ignoreFiles = options.ignoreFiles || [".gitignore", ".osgrepignore"];
+        const ignoreFiles = options.ignoreFiles || [".gitignore", ".gmaxignore"];
         const rootParams = (0, ignore_1.default)().add(ignore_patterns_1.DEFAULT_IGNORE_PATTERNS);
         if (options.additionalPatterns) {
             rootParams.add(options.additionalPatterns);
@@ -125,7 +125,7 @@ function _walk(currentDir, rootDir, stack, ignoreFiles) {
         try {
             entries = yield __await(fs.readdir(currentDir, { withFileTypes: true }));
         }
-        catch (err) {
+        catch (_err) {
             return yield __await(void 0);
         }
         for (const entry of entries) {

package/dist/lib/index/watcher.js

@@ -56,7 +56,7 @@ const pool_1 = require("../workers/pool");
 exports.WATCHER_IGNORE_PATTERNS = [
     "**/node_modules/**",
     "**/.git/**",
-    "**/.osgrep/**",
+    "**/.gmax/**",
     "**/dist/**",
     "**/build/**",
     "**/out/**",
@@ -66,12 +66,12 @@ exports.WATCHER_IGNORE_PATTERNS = [
     "**/venv/**",
     "**/.next/**",
     "**/lancedb/**",
-    /(^|[\/\\])\../, // dotfiles
+    /(^|[/\\])\../, // dotfiles
 ];
 const DEBOUNCE_MS = 2000;
 const FTS_REBUILD_INTERVAL_MS = 5 * 60 * 1000;
 function startWatcher(opts) {
-    const { projectRoot, vectorDb, metaCache, osgrepDir, onReindex } = opts;
+    const { projectRoot, vectorDb, metaCache, dataDir, onReindex } = opts;
     const pending = new Map();
     let debounceTimer = null;
     let processing = false;
@@ -104,7 +104,7 @@ function startWatcher(opts) {
         const start = Date.now();
         let reindexed = 0;
         try {
-            const lock = yield (0, lock_1.acquireWriterLockWithRetry)(osgrepDir, {
+            const lock = yield (0, lock_1.acquireWriterLockWithRetry)(dataDir, {
                 maxRetries: 3,
                 retryDelayMs: 500,
             });

package/dist/lib/output/formatter.js

@@ -143,7 +143,7 @@ function formatTrace(graph) {
         lines.push("");
     }
     // 2. Center (The Symbol)
-    lines.push(style.bold("▶ " + graph.center.symbol));
+    lines.push(style.bold(`▶ ${graph.center.symbol}`));
     lines.push(`  ${style.dim(`Defined in ${graph.center.file}:${graph.center.line}`)}`);
     lines.push(`  ${style.dim(`Role: ${graph.center.role}`)}`);
     lines.push("");

package/dist/lib/search/searcher.js

@@ -137,7 +137,7 @@ class Searcher {
         // Item 6: Anchors are recall helpers, not rank contenders
         if (record.is_anchor) {
             // Minimal penalty to break ties
-            const anchorPenalty = Number.parseFloat((_a = process.env.OSGREP_ANCHOR_PENALTY) !== null && _a !== void 0 ? _a : "") || 0.99;
+            const anchorPenalty = Number.parseFloat((_a = process.env.GMAX_ANCHOR_PENALTY) !== null && _a !== void 0 ? _a : "") || 0.99;
             adjusted *= anchorPenalty;
         }
         else {
@@ -197,7 +197,7 @@ class Searcher {
         const isTestPath = /(^|\/)(__tests__|tests?|specs?|benchmark)(\/|$)/i.test(pathStr) ||
             /\.(test|spec)\.[cm]?[jt]sx?$/i.test(pathStr);
         if (isTestPath) {
-            const testPenalty = Number.parseFloat((_c = process.env.OSGREP_TEST_PENALTY) !== null && _c !== void 0 ? _c : "") || 0.5;
+            const testPenalty = Number.parseFloat((_c = process.env.GMAX_TEST_PENALTY) !== null && _c !== void 0 ? _c : "") || 0.5;
             adjusted *= testPenalty;
         }
         if (pathStr.endsWith(".md") ||
@@ -206,7 +206,7 @@ class Searcher {
             pathStr.endsWith(".json") ||
             pathStr.endsWith(".lock") ||
             pathStr.includes("/docs/")) {
-            const docPenalty = Number.parseFloat((_d = process.env.OSGREP_DOC_PENALTY) !== null && _d !== void 0 ? _d : "") || 0.6;
+            const docPenalty = Number.parseFloat((_d = process.env.GMAX_DOC_PENALTY) !== null && _d !== void 0 ? _d : "") || 0.6;
             adjusted *= docPenalty; // Downweight docs/data
         }
         // Import-only penalty
@@ -297,7 +297,7 @@ class Searcher {
                 // For now, let's just rely on boosting.
             }
             const whereClause = whereClauseParts.length > 0 ? whereClauseParts.join(" AND ") : undefined;
-            const envPreK = Number.parseInt((_d = process.env.OSGREP_PRE_K) !== null && _d !== void 0 ? _d : "", 10);
+            const envPreK = Number.parseInt((_d = process.env.GMAX_PRE_K) !== null && _d !== void 0 ? _d : "", 10);
             const PRE_RERANK_K = Number.isFinite(envPreK) && envPreK > 0
                 ? envPreK
                 : Math.max(finalLimit * 5, 500);
@@ -363,17 +363,17 @@ class Searcher {
                 .filter(Boolean);
             // Item 8: Widen PRE_RERANK_K
             // Retrieve a wide set for Stage 1 filtering
-            const envStage1 = Number.parseInt((_e = process.env.OSGREP_STAGE1_K) !== null && _e !== void 0 ? _e : "", 10);
+            const envStage1 = Number.parseInt((_e = process.env.GMAX_STAGE1_K) !== null && _e !== void 0 ? _e : "", 10);
             const STAGE1_K = Number.isFinite(envStage1) && envStage1 > 0 ? envStage1 : 200;
             const topCandidates = fused.slice(0, STAGE1_K);
             // Item 9: Two-stage rerank
             // Stage 1: Cheap pooled cosine filter
             let stage2Candidates = topCandidates;
-            const envStage2K = Number.parseInt((_f = process.env.OSGREP_STAGE2_K) !== null && _f !== void 0 ? _f : "", 10);
+            const envStage2K = Number.parseInt((_f = process.env.GMAX_STAGE2_K) !== null && _f !== void 0 ? _f : "", 10);
             const STAGE2_K = Number.isFinite(envStage2K) && envStage2K > 0 ? envStage2K : 40;
-            const envRerankTop = Number.parseInt((_g = process.env.OSGREP_RERANK_TOP) !== null && _g !== void 0 ? _g : "", 10);
+            const envRerankTop = Number.parseInt((_g = process.env.GMAX_RERANK_TOP) !== null && _g !== void 0 ? _g : "", 10);
             const RERANK_TOP = Number.isFinite(envRerankTop) && envRerankTop > 0 ? envRerankTop : 20;
-            const envBlend = Number.parseFloat((_h = process.env.OSGREP_RERANK_BLEND) !== null && _h !== void 0 ? _h : "");
+            const envBlend = Number.parseFloat((_h = process.env.GMAX_RERANK_BLEND) !== null && _h !== void 0 ? _h : "");
             const FUSED_WEIGHT = Number.isFinite(envBlend) && envBlend >= 0 ? envBlend : 0.5;
             if (queryPooled && topCandidates.length > STAGE2_K) {
                 const cosineScores = topCandidates.map((doc) => {
@@ -439,7 +439,7 @@ class Searcher {
             // Item 10: Per-file diversification
             const seenFiles = new Map();
             const diversified = [];
-            const envMaxPerFile = Number.parseInt((_j = process.env.OSGREP_MAX_PER_FILE) !== null && _j !== void 0 ? _j : "", 10);
+            const envMaxPerFile = Number.parseInt((_j = process.env.GMAX_MAX_PER_FILE) !== null && _j !== void 0 ? _j : "", 10);
             const MAX_PER_FILE = Number.isFinite(envMaxPerFile) && envMaxPerFile > 0 ? envMaxPerFile : 3;
             for (const item of uniqueScored) {
                 const path = item.record.path || "";

package/dist/lib/setup/model-loader.js

@@ -50,9 +50,9 @@ const path = __importStar(require("node:path"));
 const node_worker_threads_1 = require("node:worker_threads");
 const config_1 = require("../../config");
 const HOMEDIR = os.homedir();
-const CACHE_DIR = path.join(HOMEDIR, ".osgrep", "models");
-const LOG_MODELS = process.env.OSGREP_DEBUG_MODELS === "1" ||
-    process.env.OSGREP_DEBUG_MODELS === "true";
+const CACHE_DIR = path.join(HOMEDIR, ".gmax", "models");
+const LOG_MODELS = process.env.GMAX_DEBUG_MODELS === "1" ||
+    process.env.GMAX_DEBUG_MODELS === "true";
 /**
  * Triggers the download of models by spawning a worker thread.
  * This prevents the main thread from loading onnxruntime, avoiding exit crashes.

package/dist/lib/setup/setup-helpers.js

@@ -58,7 +58,7 @@ function getPaths() {
     };
 }
 /**
- * Idempotent helper that ensures osgrep directories and models exist.
+ * Idempotent helper that ensures gmax directories and models exist.
  * Returns status about work performed so callers can decide what to show.
  */
 function ensureSetup() {
@@ -67,9 +67,7 @@ function ensureSetup() {
         const dirs = [paths.root, paths.models, paths.grammars];
         const needsDirs = dirs.some((dir) => !fs.existsSync(dir));
         let createdDirs = false;
-        const dirSpinner = !silent && needsDirs
-            ? (0, ora_1.default)("Preparing osgrep directories...").start()
-            : null;
+        const dirSpinner = !silent && needsDirs ? (0, ora_1.default)("Preparing gmax directories...").start() : null;
         try {
             if (needsDirs) {
                 dirs.forEach((dir) => {

package/dist/lib/skeleton/body-fields.js

@@ -114,6 +114,18 @@ exports.BODY_FIELDS = {
         class_declaration: null, // Container (class/interface/enum)
         object_declaration: null, // Container (object/companion)
     },
+    bash: {
+        function_definition: "body", // positional fallback → compound_statement
+    },
+    scala: {
+        function_definition: "body", // positional — expression bodies
+        class_definition: null, // Container
+        object_definition: null, // Container
+        trait_definition: null, // Container
+    },
+    lua: {
+        function_declaration: "body", // named "body" field → block
+    },
 };
 /**
  * Container types - these hold methods/functions but shouldn't be elided themselves.
@@ -139,6 +151,14 @@ exports.CONTAINER_TYPES = {
         "protocol_body",
     ],
     kotlin: ["class_declaration", "class_body", "object_declaration"],
+    bash: [],
+    scala: [
+        "class_definition",
+        "object_definition",
+        "trait_definition",
+        "template_body",
+    ],
+    lua: [],
 };
 /**
  * Check if a node type is a container (holds methods).

package/dist/lib/skeleton/retriever.js

@@ -28,7 +28,7 @@ function getStoredSkeleton(db, filePath) {
             }
             return null;
         }
-        catch (e) {
+        catch (_e) {
             // If table doesn't exist or query fails, return null
             return null;
         }

package/dist/lib/skeleton/skeletonizer.js

@@ -205,7 +205,11 @@ class Skeletonizer {
             // Try named field first, then fall back to finding child by type
             // (some grammars like Kotlin use positional children, not named fields)
             const bodyNode = ((_a = node.childForFieldName) === null || _a === void 0 ? void 0 : _a.call(node, bodyFieldName)) ||
-                (node.namedChildren || []).find((c) => c.type === "function_body" || c.type === bodyFieldName) ||
+                (node.namedChildren || []).find((c) => c.type === "function_body" ||
+                    c.type === "compound_statement" ||
+                    c.type === "block" ||
+                    c.type === "template_body" ||
+                    c.type === bodyFieldName) ||
                 null;
             if (bodyNode) {
                 const summary = this.createSummary(bodyNode, langId, opts);
@@ -359,7 +363,9 @@ class Skeletonizer {
         const seen = new Set();
         const extract = (n) => {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-            if (n.type === "call_expression" || n.type === "call") {
+            if (n.type === "call_expression" ||
+                n.type === "call" ||
+                n.type === "function_call") {
                 const func = (_a = n.childForFieldName) === null || _a === void 0 ? void 0 : _a.call(n, "function");
                 if (func) {
                     let funcName = func.text;

package/dist/lib/skeleton/summary-formatter.js

@@ -60,7 +60,6 @@ function getCommentPrefix(style) {
             return "#";
         case "dash":
             return "--";
-        case "slash":
         default:
             return "//";
     }
@@ -85,8 +84,6 @@ function getCommentStyle(langId) {
  * Format the skeleton file header comment.
  */
 function formatSkeletonHeader(filePath, tokenEstimate, langId) {
-    const prefix = langId
-        ? getCommentPrefix(getCommentStyle(langId))
-        : "//";
+    const prefix = langId ? getCommentPrefix(getCommentStyle(langId)) : "//";
     return `${prefix} ${filePath} (skeleton, ~${tokenEstimate} tokens)`;
 }