grepmax 0.24.0 → 0.25.0

package/dist/lib/index/file-policy.js

@@ -0,0 +1,273 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectFilePolicy = exports.IgnorePolicyReadError = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const ignore_1 = __importDefault(require("ignore"));
+const config_1 = require("../../config");
+const file_utils_1 = require("../utils/file-utils");
+const path_containment_1 = require("../utils/path-containment");
+const ignore_patterns_1 = require("./ignore-patterns");
+class IgnorePolicyReadError extends Error {
+    constructor(protectedPath, cause) {
+        super(`Unable to read ignore policy under ${protectedPath}`);
+        this.protectedPath = protectedPath;
+        this.cause = cause;
+        this.name = "IgnorePolicyReadError";
+    }
+}
+exports.IgnorePolicyReadError = IgnorePolicyReadError;
+class ProjectFilePolicy {
+    constructor(projectRoot, options = {}) {
+        var _a, _b;
+        this.ignoreCache = new Map();
+        this.projectRoot = path.resolve(projectRoot);
+        try {
+            this.canonicalRoot = fs.realpathSync(this.projectRoot);
+        }
+        catch (_c) {
+            // Root availability is classified by the walker. Construction must not
+            // turn a transient mount/root failure into a permanently wedged watcher.
+            this.canonicalRoot = null;
+        }
+        this.ignoreFiles = (_a = options.ignoreFiles) !== null && _a !== void 0 ? _a : [".gitignore", ".gmaxignore"];
+        this.rootFilter = (0, ignore_1.default)().add([
+            ...ignore_patterns_1.DEFAULT_IGNORE_PATTERNS,
+            ".git",
+            ".gmax",
+            ...((_b = options.additionalPatterns) !== null && _b !== void 0 ? _b : []),
+        ]);
+    }
+    isPolicyFile(absPath) {
+        return this.ignoreFiles.includes(path.basename(absPath));
+    }
+    invalidateIgnoreCache() {
+        this.ignoreCache.clear();
+    }
+    isLexicallyContained(absPath) {
+        return (0, path_containment_1.isPathWithin)(this.projectRoot, path.resolve(absPath));
+    }
+    normalizeEventPath(absPath) {
+        const resolved = path.resolve(absPath);
+        if (this.isLexicallyContained(resolved))
+            return resolved;
+        if (!this.canonicalRoot || !(0, path_containment_1.isPathWithin)(this.canonicalRoot, resolved)) {
+            return null;
+        }
+        return path.resolve(this.projectRoot, path.relative(this.canonicalRoot, resolved));
+    }
+    relative(absPath) {
+        return path.relative(this.projectRoot, absPath).split(path.sep).join("/");
+    }
+    loadIgnoreScope(dir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existing = this.ignoreCache.get(dir);
+            if (existing)
+                return existing;
+            const pending = (() => __awaiter(this, void 0, void 0, function* () {
+                let filter = null;
+                for (const fileName of this.ignoreFiles) {
+                    try {
+                        const content = yield fs.promises.readFile(path.join(dir, fileName), "utf8");
+                        if (!filter)
+                            filter = (0, ignore_1.default)();
+                        filter.add(content);
+                    }
+                    catch (err) {
+                        if (err.code !== "ENOENT") {
+                            throw new IgnorePolicyReadError(dir, err);
+                        }
+                    }
+                }
+                return { dir, filter };
+            }))();
+            this.ignoreCache.set(dir, pending);
+            void pending.catch(() => {
+                if (this.ignoreCache.get(dir) === pending)
+                    this.ignoreCache.delete(dir);
+            });
+            return pending;
+        });
+    }
+    scopeDirectories(throughDir) {
+        const relative = path.relative(this.projectRoot, throughDir);
+        if (!relative)
+            return [this.projectRoot];
+        const parts = relative.split(path.sep).filter(Boolean);
+        const dirs = [this.projectRoot];
+        let current = this.projectRoot;
+        for (const part of parts) {
+            current = path.join(current, part);
+            dirs.push(current);
+        }
+        return dirs;
+    }
+    classifyPath(absPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resolved = path.resolve(absPath);
+            if (!this.isLexicallyContained(resolved)) {
+                return { status: "excluded", reason: "outside project root" };
+            }
+            try {
+                const stat = yield fs.promises.lstat(resolved);
+                const isRoot = resolved === this.projectRoot;
+                if (stat.isSymbolicLink() && !isRoot) {
+                    return { status: "excluded", reason: "symbolic link" };
+                }
+                const canonical = yield fs.promises.realpath(resolved);
+                if (!this.canonicalRoot) {
+                    this.canonicalRoot = yield fs.promises.realpath(this.projectRoot);
+                }
+                const expected = path.resolve(this.canonicalRoot, path.relative(this.projectRoot, resolved));
+                if (canonical !== expected) {
+                    return { status: "excluded", reason: "symlinked ancestor" };
+                }
+                return {
+                    status: "present",
+                    stat: isRoot && stat.isSymbolicLink()
+                        ? yield fs.promises.stat(resolved)
+                        : stat,
+                    resolved,
+                };
+            }
+            catch (err) {
+                if (err.code === "ENOENT") {
+                    return { status: "missing" };
+                }
+                return { status: "error", error: err, protectedPath: resolved };
+            }
+        });
+    }
+    ignoredByPolicy(absPath, isDirectory, loadThroughDir, includeLastScope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rootRelative = this.relative(absPath);
+            const rootTest = isDirectory ? `${rootRelative}/` : rootRelative;
+            if (rootRelative && this.rootFilter.ignores(rootTest)) {
+                return "default ignore policy";
+            }
+            const dirs = this.scopeDirectories(loadThroughDir);
+            const scopes = yield Promise.all(dirs.map((dir) => this.loadIgnoreScope(dir)));
+            const applicable = includeLastScope ? scopes : scopes.slice(0, -1);
+            for (const scope of applicable) {
+                if (!scope.filter)
+                    continue;
+                const relative = path
+                    .relative(scope.dir, absPath)
+                    .split(path.sep)
+                    .join("/");
+                if (!relative)
+                    continue;
+                const testPath = isDirectory ? `${relative}/` : relative;
+                if (scope.filter.ignores(testPath))
+                    return "project ignore policy";
+            }
+            return null;
+        });
+    }
+    classifyFile(absPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isPolicyFile(absPath)) {
+                return { status: "excluded", reason: "ignore policy file" };
+            }
+            const classified = yield this.classifyPath(absPath);
+            if (classified.status !== "present")
+                return classified;
+            if (!classified.stat.isFile()) {
+                return { status: "excluded", reason: "not a regular file" };
+            }
+            try {
+                const ignored = yield this.ignoredByPolicy(classified.resolved, false, path.dirname(classified.resolved), true);
+                if (ignored)
+                    return { status: "excluded", reason: ignored };
+            }
+            catch (error) {
+                return {
+                    status: "error",
+                    error,
+                    protectedPath: error instanceof IgnorePolicyReadError
+                        ? error.protectedPath
+                        : path.dirname(classified.resolved),
+                };
+            }
+            if (!(0, file_utils_1.isIndexableFile)(classified.resolved, classified.stat.size)) {
+                return { status: "excluded", reason: "non-indexable file" };
+            }
+            if (classified.stat.size === 0 ||
+                classified.stat.size > config_1.MAX_FILE_SIZE_BYTES) {
+                return { status: "excluded", reason: "invalid file size" };
+            }
+            return { status: "indexable", stat: classified.stat };
+        });
+    }
+    classifyDirectory(absPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const classified = yield this.classifyPath(absPath);
+            if (classified.status !== "present")
+                return classified;
+            if (!classified.stat.isDirectory()) {
+                return { status: "excluded", reason: "not a directory" };
+            }
+            try {
+                const ignored = yield this.ignoredByPolicy(classified.resolved, true, classified.resolved, false);
+                if (ignored)
+                    return { status: "excluded", reason: ignored };
+            }
+            catch (error) {
+                return {
+                    status: "error",
+                    error,
+                    protectedPath: error instanceof IgnorePolicyReadError
+                        ? error.protectedPath
+                        : classified.resolved,
+                };
+            }
+            return { status: "traverse" };
+        });
+    }
+}
+exports.ProjectFilePolicy = ProjectFilePolicy;

package/dist/lib/index/ignore-patterns.js

@@ -25,6 +25,7 @@ exports.DEFAULT_IGNORE_PATTERNS = [
     "coverage",
     "venv",
     ".venv",
+    "site-packages",
     ".tox",
     ".mypy_cache",
     ".pytest_cache",
@@ -33,6 +34,7 @@ exports.DEFAULT_IGNORE_PATTERNS = [
     ".gradle",
     ".m2",
     "vendor",
+    "lancedb",
     ".claude",
     ".gmax",
     ".gmax.json",
@@ -99,6 +101,8 @@ exports.DEFAULT_IGNORE_PATTERNS = [
     "credentials.*",
     // IDE and OS files
     ".DS_Store",
+    "**/*.tmp.*",
+    "**/*.sb-*",
     "**/.idea/**",
     "**/.vscode/**",
     "Thumbs.db",

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

@@ -70,8 +70,14 @@ function readGlobalConfig() {
     }
 }
 function writeGlobalConfig(config) {
+    const existing = readGlobalConfig();
+    const merged = Object.assign(Object.assign({}, existing), config);
+    if (config.queryLog === undefined)
+        merged.queryLog = existing.queryLog;
+    if (config.llmEnabled === undefined)
+        merged.llmEnabled = existing.llmEnabled;
     fs.mkdirSync(path.dirname(GLOBAL_CONFIG_PATH), { recursive: true });
-    fs.writeFileSync(GLOBAL_CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`);
+    fs.writeFileSync(GLOBAL_CONFIG_PATH, `${JSON.stringify(merged, null, 2)}\n`);
 }
 /**
  * Resolve the effective model IDs for a given tier.
@@ -95,13 +101,13 @@ function readIndexConfig(configPath) {
     }
 }
 function writeIndexConfig(configPath, extra) {
-    var _a;
+    var _a, _b, _c, _d, _e;
     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, modelTier: tierName, 
+        embedMode: (_b = existing === null || existing === void 0 ? void 0 : existing.embedMode) !== null && _b !== void 0 ? _b : readGlobalConfig().embedMode, mlxModel: (_c = existing === null || existing === void 0 ? void 0 : existing.mlxModel) !== null && _c !== void 0 ? _c : readGlobalConfig().mlxModel, modelTier: tierName, queryLog: (_d = existing === null || existing === void 0 ? void 0 : existing.queryLog) !== null && _d !== void 0 ? _d : readGlobalConfig().queryLog, llmEnabled: (_e = existing === null || existing === void 0 ? void 0 : existing.llmEnabled) !== null && _e !== void 0 ? _e : readGlobalConfig().llmEnabled, 
         // Model identity from current run
         embedModel: tierIds.embed, colbertModel: tierIds.colbert, vectorDim: tierIds.vectorDim, indexedAt: new Date().toISOString() }, extra);
     fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
@@ -112,7 +118,15 @@ function writeIndexConfig(configPath, extra) {
  */
 function writeSetupConfig(configPath, prefs) {
     const existing = readIndexConfig(configPath);
-    const config = Object.assign(Object.assign({}, existing), { embedMode: prefs.embedMode, mlxModel: prefs.mlxModel, modelTier: prefs.modelTier });
+    const config = Object.assign(Object.assign({}, existing), { embedMode: prefs.embedMode });
+    if ("mlxModel" in prefs) {
+        if (prefs.mlxModel === undefined)
+            delete config.mlxModel;
+        else
+            config.mlxModel = prefs.mlxModel;
+    }
+    if (prefs.modelTier !== undefined)
+        config.modelTier = prefs.modelTier;
     fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
 }
 function checkModelMismatch(configPath) {