@zvec/zvec-grep 0.1.0

package/dist/engine/pipeline/indexing/root-paths.js

@@ -0,0 +1,151 @@
+import { realpathSync, statSync } from "node:fs";
+import { dirname, relative } from "node:path";
+import { EngineError } from "../../errors/index.js";
+import { pathPatternMatches } from "../../utils/glob.js";
+import { isPathInside, normalizePath, toDisplayPath } from "../../utils/path.js";
+export function validateRootPaths(paths) {
+    const roots = paths.map(normalizeRootPath);
+    const domains = roots.map(rootPathToScanDomain);
+    for (let leftIndex = 0; leftIndex < domains.length; leftIndex++) {
+        for (let rightIndex = leftIndex + 1; rightIndex < domains.length; rightIndex++) {
+            const left = domains[leftIndex];
+            const right = domains[rightIndex];
+            if (scanDomainsOverlap(left, right)) {
+                throw new EngineError("Collection root paths overlap", {
+                    code: "ZVEC_GREP.ENGINE.SCANNER.OVERLAPPING_ROOT_PATHS",
+                    context: `left=${left.root.absolutePath} right=${right.root.absolutePath}`,
+                });
+            }
+        }
+    }
+    return roots;
+}
+export function normalizeRootPath(path) {
+    if (typeof path === "string") {
+        return {
+            absolutePath: normalizePath(path),
+            recursive: true,
+        };
+    }
+    return {
+        ...path,
+        absolutePath: normalizePath(path.absolutePath),
+        recursive: path.recursive,
+    };
+}
+export function fileBelongsToRootPath(absolutePath, rootPath) {
+    const normalizedPath = normalizePath(absolutePath);
+    if (!isPathInside(rootPath.absolutePath, normalizedPath)) {
+        return false;
+    }
+    const relativePath = toDisplayPath(relative(rootPath.absolutePath, normalizedPath));
+    return matchesRootPatterns(relativePath, rootPath);
+}
+export function matchesRootPatterns(relativePath, rootPath) {
+    if (matchesAny(relativePath, rootPath.exclude)) {
+        return false;
+    }
+    if (!rootPath.include || rootPath.include.length === 0) {
+        return true;
+    }
+    return matchesAny(relativePath, rootPath.include);
+}
+export function matchesRootIncludePatterns(relativePath, rootPath) {
+    return matchesAny(relativePath, rootPath.include);
+}
+export function matchesRootExcludePatterns(relativePath, rootPath) {
+    return matchesAny(relativePath, rootPath.exclude);
+}
+function rootPathToScanDomain(root) {
+    let info;
+    try {
+        info = statSync(root.absolutePath, { throwIfNoEntry: false });
+    }
+    catch (cause) {
+        throw new EngineError("Collection root path could not be inspected", {
+            code: "ZVEC_GREP.ENGINE.SCANNER.ROOT_PATH_STAT_FAILED",
+            context: `rootPath=${root.absolutePath}`,
+            cause,
+        });
+    }
+    if (!info) {
+        throw new EngineError("Collection root path does not exist", {
+            code: "ZVEC_GREP.ENGINE.SCANNER.ROOT_PATH_MISSING",
+            context: `rootPath=${root.absolutePath}`,
+        });
+    }
+    const kind = info.isFile()
+        ? "file"
+        : info.isDirectory()
+            ? "directory"
+            : null;
+    if (!kind) {
+        throw new EngineError("Collection root path must be a file or directory", {
+            code: "ZVEC_GREP.ENGINE.SCANNER.UNSUPPORTED_ROOT_PATH",
+            context: `rootPath=${root.absolutePath}`,
+        });
+    }
+    let realPath;
+    try {
+        realPath = normalizePath(realpathSync(root.absolutePath));
+    }
+    catch (cause) {
+        throw new EngineError("Collection root path could not be resolved", {
+            code: "ZVEC_GREP.ENGINE.SCANNER.ROOT_PATH_REALPATH_FAILED",
+            context: `rootPath=${root.absolutePath}`,
+            cause,
+        });
+    }
+    return {
+        root,
+        realPath,
+        kind,
+        stat: info,
+    };
+}
+function scanDomainsOverlap(left, right) {
+    if (sameFileIdentity(left, right)) {
+        return true;
+    }
+    if (left.kind === "file" && right.kind === "file") {
+        return false;
+    }
+    if (left.kind === "directory" && right.kind === "directory") {
+        return directoryDomainsOverlap(left, right);
+    }
+    const directory = left.kind === "directory" ? left : right;
+    const file = left.kind === "file" ? left : right;
+    return directoryCoversFile(directory, file.realPath);
+}
+function sameFileIdentity(left, right) {
+    return left.realPath === right.realPath
+        || (left.stat.dev === right.stat.dev
+            && left.stat.ino !== 0
+            && left.stat.ino === right.stat.ino);
+}
+function directoryDomainsOverlap(left, right) {
+    if (left.realPath === right.realPath) {
+        return true;
+    }
+    return directoryCoversDirectory(left, right.realPath)
+        || directoryCoversDirectory(right, left.realPath);
+}
+function directoryCoversDirectory(directory, childDirectoryPath) {
+    return directory.root.recursive && isPathInside(directory.realPath, childDirectoryPath);
+}
+function directoryCoversFile(directory, filePath) {
+    if (!isPathInside(directory.realPath, filePath)) {
+        return false;
+    }
+    return directory.root.recursive || dirname(filePath) === directory.realPath;
+}
+function matchesAny(relativePath, patterns) {
+    if (!patterns || patterns.length === 0) {
+        return false;
+    }
+    return patterns.some((pattern) => patternMatches(pattern, relativePath));
+}
+function patternMatches(pattern, relativePath) {
+    return pathPatternMatches(pattern, relativePath);
+}
+//# sourceMappingURL=root-paths.js.map

package/dist/engine/pipeline/indexing/root-paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-paths.js","sourceRoot":"","sources":["../../../../src/engine/pipeline/indexing/root-paths.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAc,MAAM,SAAS,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGjF,MAAM,UAAU,iBAAiB,CAAC,KAAqC;IACrE,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;IAC3C,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;IAEhD,KAAK,IAAI,SAAS,GAAG,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,CAAC;QAChE,KAAK,IAAI,UAAU,GAAG,SAAS,GAAG,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,CAAC;YAC/E,MAAM,IAAI,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;YAChC,MAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;YAElC,IAAI,kBAAkB,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC;gBACpC,MAAM,IAAI,WAAW,CAAC,+BAA+B,EAAE;oBACrD,IAAI,EAAE,iDAAiD;oBACvD,OAAO,EAAE,QAAQ,IAAI,CAAC,IAAI,CAAC,YAAY,UAAU,KAAK,CAAC,IAAI,CAAC,YAAY,EAAE;iBAC3E,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAGD,MAAM,UAAU,iBAAiB,CAAC,IAAuB;IACvD,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC7B,OAAO;YACL,YAAY,EAAE,aAAa,CAAC,IAAI,CAAC;YACjC,SAAS,EAAE,IAAI;SAChB,CAAC;IACJ,CAAC;IAED,OAAO;QACL,GAAG,IAAI;QACP,YAAY,EAAE,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC;QAC9C,SAAS,EAAE,IAAI,CAAC,SAAS;KAC1B,CAAC;AACJ,CAAC;AAGD,MAAM,UAAU,qBAAqB,CACnC,YAAoB,EACpB,QAAkB;IAElB,MAAM,cAAc,GAAG,aAAa,CAAC,YAAY,CAAC,CAAC;IAEnD,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,YAAY,EAAE,cAAc,CAAC,EAAE,CAAC;QACzD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,YAAY,GAAG,aAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC,CAAC;IAEpF,OAAO,mBAAmB,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;AACrD,CAAC;AAGD,MAAM,UAAU,mBAAmB,CAAC,YAAoB,EAAE,QAAkB;IAC1E,IAAI,UAAU,CAAC,YAAY,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QAC/C,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IAAI,CAAC,QAAQ,CAAC,OAAO,IAAI,QAAQ,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,UAAU,CAAC,YAAY,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;AACpD,CAAC;AAGD,MAAM,UAAU,0BAA0B,CAAC,YAAoB,EAAE,QAAkB;IACjF,OAAO,UAAU,CAAC,YAAY,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;AACpD,CAAC;AAGD,MAAM,UAAU,0BAA0B,CAAC,YAAoB,EAAE,QAAkB;IACjF,OAAO,UAAU,CAAC,YAAY,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;AACpD,CAAC;AAWD,SAAS,oBAAoB,CAAC,IAAc;IAC1C,IAAI,IAAuB,CAAC;IAE5B,IAAI,CAAC;QACH,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC,CAAC;IAChE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,WAAW,CAAC,6CAA6C,EAAE;YACnE,IAAI,EAAE,gDAAgD;YACtD,OAAO,EAAE,YAAY,IAAI,CAAC,YAAY,EAAE;YACxC,KAAK;SACN,CAAC,CAAC;IACL,CAAC;IAED,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,WAAW,CAAC,qCAAqC,EAAE;YAC3D,IAAI,EAAE,4CAA4C;YAClD,OAAO,EAAE,YAAY,IAAI,CAAC,YAAY,EAAE;SACzC,CAAC,CAAC;IACL,CAAC;IAED,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,EAAE;QACxB,CAAC,CAAC,MAAM;QACR,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE;YAClB,CAAC,CAAC,WAAW;YACb,CAAC,CAAC,IAAI,CAAC;IAEX,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,WAAW,CAAC,kDAAkD,EAAE;YACxE,IAAI,EAAE,gDAAgD;YACtD,OAAO,EAAE,YAAY,IAAI,CAAC,YAAY,EAAE;SACzC,CAAC,CAAC;IACL,CAAC;IAED,IAAI,QAAgB,CAAC;IAErB,IAAI,CAAC;QACH,QAAQ,GAAG,aAAa,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;IAC5D,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,WAAW,CAAC,4CAA4C,EAAE;YAClE,IAAI,EAAE,oDAAoD;YAC1D,OAAO,EAAE,YAAY,IAAI,CAAC,YAAY,EAAE;YACxC,KAAK;SACN,CAAC,CAAC;IACL,CAAC;IAED,OAAO;QACL,IAAI;QACJ,QAAQ;QACR,IAAI;QACJ,IAAI,EAAE,IAAI;KACX,CAAC;AACJ,CAAC;AAGD,SAAS,kBAAkB,CAAC,IAAoB,EAAE,KAAqB;IACrE,IAAI,gBAAgB,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC;QAClC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;QAClD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW,IAAI,KAAK,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;QAC5D,OAAO,uBAAuB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAC9C,CAAC;IAED,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,KAAK,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;IAC3D,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;IAEjD,OAAO,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;AACvD,CAAC;AAGD,SAAS,gBAAgB,CAAC,IAAoB,EAAE,KAAqB;IACnE,OAAO,IAAI,CAAC,QAAQ,KAAK,KAAK,CAAC,QAAQ;WAClC,CACD,IAAI,CAAC,IAAI,CAAC,GAAG,KAAK,KAAK,CAAC,IAAI,CAAC,GAAG;eAC7B,IAAI,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;eACnB,IAAI,CAAC,IAAI,CAAC,GAAG,KAAK,KAAK,CAAC,IAAI,CAAC,GAAG,CACpC,CAAC;AACN,CAAC;AAGD,SAAS,uBAAuB,CAAC,IAAoB,EAAE,KAAqB;IAC1E,IAAI,IAAI,CAAC,QAAQ,KAAK,KAAK,CAAC,QAAQ,EAAE,CAAC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,wBAAwB,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC;WAChD,wBAAwB,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;AACtD,CAAC;AAGD,SAAS,wBAAwB,CAAC,SAAyB,EAAE,kBAA0B;IACrF,OAAO,SAAS,CAAC,IAAI,CAAC,SAAS,IAAI,YAAY,CAAC,SAAS,CAAC,QAAQ,EAAE,kBAAkB,CAAC,CAAC;AAC1F,CAAC;AAGD,SAAS,mBAAmB,CAAC,SAAyB,EAAE,QAAgB;IACtE,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC;QAChD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,SAAS,CAAC,IAAI,CAAC,SAAS,IAAI,OAAO,CAAC,QAAQ,CAAC,KAAK,SAAS,CAAC,QAAQ,CAAC;AAC9E,CAAC;AAGD,SAAS,UAAU,CAAC,YAAoB,EAAE,QAAuC;IAC/E,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;AAC3E,CAAC;AAGD,SAAS,cAAc,CAAC,OAAe,EAAE,YAAoB;IAC3D,OAAO,kBAAkB,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;AACnD,CAAC"}

package/dist/engine/pipeline/indexing/scanner/index.d.ts

@@ -0,0 +1,5 @@
+import type { FileInfo, RootPath } from "../../../types.js";
+export type ScanResult = {
+    files: FileInfo[];
+};
+export declare function scanRootPaths(collectionId: string, rootPaths: readonly RootPath[]): Promise<ScanResult>;

package/dist/engine/pipeline/indexing/scanner/index.js

@@ -0,0 +1,504 @@
+import { open, readFile, readdir, stat } from "node:fs/promises";
+import { basename, extname, join, relative } from "node:path";
+import { sha256Text } from "../../../utils/hash.js";
+import { normalizePathPattern, pathPatternMatches, pathPatternMightMatchDescendant, } from "../../../utils/glob.js";
+import { normalizePath, toDisplayPath } from "../../../utils/path.js";
+import { matchesRootExcludePatterns, matchesRootIncludePatterns, matchesRootPatterns, normalizeRootPath, validateRootPaths, } from "../root-paths.js";
+const DEFAULT_MAX_FILE_SIZE_BYTES = 1 * 1024 * 1024;
+const BINARY_SNIFF_BYTES = 8192;
+const BINARY_CONTROL_CHAR_RATIO = 0.30;
+const DEFAULT_IGNORED_DIRECTORY_NAMES = [
+    "node_modules",
+    "vendor",
+    "dist",
+    "build",
+    "out",
+    "target",
+    "coverage",
+    "__pycache__",
+    "venv",
+    ".venv",
+    "env",
+    ".tox",
+    ".eggs",
+    "Pods",
+    ".next",
+    ".nuxt",
+    ".svelte-kit",
+    ".turbo",
+    ".vite",
+    ".parcel-cache",
+    ".cache",
+    ".gradle",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".ruff_cache",
+    "tmp",
+    "temp",
+    "logs",
+];
+const HARD_SKIP_HIDDEN_NAMES = new Set([
+    ".git",
+    ".zvec-grep",
+]);
+const DEFAULT_IGNORE_RULES = DEFAULT_IGNORED_DIRECTORY_NAMES.map((pattern) => ({
+    basePath: "",
+    pattern,
+    negated: false,
+    directoryOnly: true,
+    anchored: false,
+    hasSlash: false,
+}));
+const BINARY_EXTENSIONS = new Set([
+    ".zip",
+    ".tar",
+    ".gz",
+    ".bz2",
+    ".xz",
+    ".7z",
+    ".rar",
+    ".exe",
+    ".dll",
+    ".dylib",
+    ".so",
+    ".a",
+    ".o",
+    ".obj",
+    ".wasm",
+    ".class",
+    ".jar",
+    ".pdf",
+    ".doc",
+    ".docx",
+    ".ppt",
+    ".pptx",
+    ".xls",
+    ".xlsx",
+    ".mp3",
+    ".mp4",
+    ".mov",
+    ".avi",
+    ".mkv",
+    ".db",
+    ".sqlite",
+]);
+const CODE_FORMATS = {
+    ".c": "c",
+    ".cc": "cpp",
+    ".cpp": "cpp",
+    ".cxx": "cpp",
+    ".h": "cpp",
+    ".hpp": "cpp",
+    ".go": "go",
+    ".java": "java",
+    ".js": "javascript",
+    ".jsx": "jsx",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".ts": "typescript",
+    ".tsx": "tsx",
+    ".py": "python",
+    ".rs": "rust",
+    ".rb": "ruby",
+    ".php": "php",
+    ".swift": "swift",
+    ".kt": "kotlin",
+    ".kts": "kotlin",
+    ".cs": "csharp",
+    ".scala": "scala",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".zsh": "bash",
+    ".sql": "sql",
+    ".css": "css",
+    ".scss": "scss",
+    ".less": "less",
+    ".vue": "vue",
+    ".svelte": "svelte",
+};
+const DATA_FORMATS = {
+    ".csv": "csv",
+    ".json": "json",
+    ".jsonc": "json",
+    ".toml": "toml",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+};
+const TEXT_FORMATS = {
+    ".md": "markdown",
+    ".mdx": "markdown",
+    ".rst": "rst",
+    ".txt": "text",
+    ".html": "html",
+    ".htm": "html",
+    ".xml": "xml",
+};
+const IMAGE_FORMATS = {
+    ".gif": "gif",
+    ".jpeg": "jpeg",
+    ".jpg": "jpeg",
+    ".png": "png",
+    ".webp": "webp",
+};
+export async function scanRootPaths(collectionId, rootPaths) {
+    const validatedRootPaths = validateRootPaths(rootPaths);
+    const files = [];
+    for (const rootPath of validatedRootPaths) {
+        await scanRootPath(collectionId, rootPath, files);
+    }
+    return { files };
+}
+async function scanRootPath(collectionId, rootPath, files) {
+    const root = normalizeRootPath(rootPath);
+    const info = await stat(root.absolutePath).catch(() => null);
+    if (!info) {
+        return;
+    }
+    if (info.isFile()) {
+        const file = await readFileInfo(collectionId, root, root.absolutePath);
+        if (file) {
+            files.push(file);
+        }
+        return;
+    }
+    if (!info.isDirectory()) {
+        return;
+    }
+    if (HARD_SKIP_HIDDEN_NAMES.has(basename(root.absolutePath))) {
+        return;
+    }
+    await walk(collectionId, root, root.absolutePath, files, DEFAULT_IGNORE_RULES);
+}
+async function walk(collectionId, rootPath, currentPath, files, parentIgnoreRules) {
+    let entries;
+    const ignoreRules = [
+        ...parentIgnoreRules,
+        ...await readGitIgnoreRules(rootPath, currentPath),
+    ];
+    try {
+        entries = await readdir(currentPath, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const absolutePath = join(currentPath, entry.name);
+        const relativePath = toDisplayPath(relative(rootPath.absolutePath, absolutePath));
+        if (entry.isDirectory()) {
+            if (!rootPath.recursive) {
+                continue;
+            }
+            const ignoreMatch = matchIgnoreRules(relativePath, true, ignoreRules);
+            if (HARD_SKIP_HIDDEN_NAMES.has(entry.name)
+                || matchesRootExcludePatterns(relativePath, rootPath)
+                || (ignoreMatch.ignored && !ignoredPathExplicitlyIncluded(relativePath, rootPath, ignoreMatch))
+                || shouldSkipHiddenDirectory(entry.name, relativePath, rootPath, ignoreMatch.matchedNegation)) {
+                continue;
+            }
+            await walk(collectionId, rootPath, absolutePath, files, ignoreRules);
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+        const ignoreMatch = matchIgnoreRules(relativePath, false, ignoreRules);
+        if (ignoreMatch.ignored && !ignoredPathExplicitlyIncluded(relativePath, rootPath, ignoreMatch)) {
+            continue;
+        }
+        if (shouldSkipHiddenFile(entry.name, relativePath, rootPath, ignoreMatch.matchedNegation)) {
+            continue;
+        }
+        if (!matchesRootPatterns(relativePath, rootPath)) {
+            continue;
+        }
+        const file = await readFileInfo(collectionId, rootPath, absolutePath);
+        if (file) {
+            files.push(file);
+        }
+    }
+}
+function isHiddenName(name) {
+    return name.startsWith(".") && name !== "." && name !== "..";
+}
+async function readGitIgnoreRules(rootPath, currentPath) {
+    const content = await readFile(join(currentPath, ".gitignore"), "utf8").catch(() => null);
+    if (content === null) {
+        return [];
+    }
+    const basePath = toDisplayPath(relative(rootPath.absolutePath, currentPath));
+    return parseGitIgnoreRules(content, basePath);
+}
+function parseGitIgnoreRules(content, basePath) {
+    const rules = [];
+    for (const rawLine of content.split(/\r?\n/)) {
+        const rule = parseGitIgnoreRule(rawLine, basePath);
+        if (rule) {
+            rules.push(rule);
+        }
+    }
+    return rules;
+}
+function parseGitIgnoreRule(line, basePath) {
+    let pattern = line.trim();
+    if (pattern.length === 0 || pattern.startsWith("#")) {
+        return null;
+    }
+    let negated = false;
+    if (pattern.startsWith("\\#") || pattern.startsWith("\\!")) {
+        pattern = pattern.slice(1);
+    }
+    else if (pattern.startsWith("!")) {
+        negated = true;
+        pattern = pattern.slice(1).trim();
+    }
+    if (pattern.length === 0) {
+        return null;
+    }
+    const directoryOnly = pattern.endsWith("/");
+    pattern = directoryOnly ? pattern.replace(/\/+$/, "") : pattern;
+    const anchored = pattern.startsWith("/");
+    pattern = anchored ? pattern.replace(/^\/+/, "") : pattern;
+    pattern = normalizePathPattern(pattern);
+    if (pattern.length === 0) {
+        return null;
+    }
+    return {
+        basePath,
+        pattern,
+        negated,
+        directoryOnly,
+        anchored,
+        hasSlash: pattern.includes("/"),
+    };
+}
+function matchIgnoreRules(relativePath, isDirectory, rules) {
+    let ignored = false;
+    let matchedNegation = false;
+    let matchedRule;
+    for (const rule of rules) {
+        if (!ignoreRuleMatches(rule, relativePath, isDirectory)) {
+            continue;
+        }
+        ignored = !rule.negated;
+        matchedNegation = rule.negated;
+        matchedRule = rule;
+    }
+    return {
+        ignored,
+        matchedNegation,
+        matchedRule,
+    };
+}
+function ignoredPathExplicitlyIncluded(relativePath, rootPath, ignoreMatch) {
+    if (!ignoreMatch.ignored || !ignoreMatch.matchedRule || !rootPath.include) {
+        return false;
+    }
+    return rootPath.include.some((pattern) => includePatternNamesIgnoredPath(pattern, relativePath, ignoreMatch.matchedRule.pattern));
+}
+function includePatternNamesIgnoredPath(includePattern, relativePath, ignoredPattern) {
+    const normalizedInclude = normalizePathPattern(includePattern);
+    const normalizedRelativePath = normalizePathPattern(relativePath);
+    const ignoredSegments = ignoredPattern.split("/");
+    if (!pathPatternMightMatchDescendant(normalizedInclude, normalizedRelativePath)
+        && !pathPatternMatches(normalizedInclude, normalizedRelativePath)) {
+        return false;
+    }
+    return normalizedInclude.split("/").some((segment) => ignoredSegments.some((ignoredSegment) => includeSegmentNamesIgnoredPath(segment, ignoredSegment)));
+}
+function includeSegmentNamesIgnoredPath(segment, ignoredSegment) {
+    if (segment === "*" || segment === "**" || segment === "?") {
+        return false;
+    }
+    return segmentMatches(segment, ignoredSegment);
+}
+function ignoreRuleMatches(rule, relativePath, isDirectory) {
+    const path = relativeToIgnoreRuleBase(relativePath, rule.basePath);
+    if (path === null || path.length === 0) {
+        return false;
+    }
+    if (rule.directoryOnly) {
+        if (rule.anchored || rule.hasSlash) {
+            return pathPatternMatches(rule.pattern, path);
+        }
+        return pathContainsMatchingSegment(path, rule.pattern);
+    }
+    if (rule.anchored || rule.hasSlash) {
+        return pathPatternMatches(rule.pattern, path);
+    }
+    if (isDirectory && pathContainsMatchingSegment(path, rule.pattern)) {
+        return true;
+    }
+    return segmentMatches(rule.pattern, basename(path));
+}
+function relativeToIgnoreRuleBase(relativePath, basePath) {
+    if (basePath.length === 0) {
+        return relativePath;
+    }
+    if (relativePath === basePath) {
+        return "";
+    }
+    const prefix = `${basePath}/`;
+    return relativePath.startsWith(prefix)
+        ? relativePath.slice(prefix.length)
+        : null;
+}
+function pathContainsMatchingSegment(path, pattern) {
+    return path.split("/").some((segment) => segmentMatches(pattern, segment));
+}
+function segmentMatches(pattern, segment) {
+    return pathPatternMatches(pattern, segment);
+}
+function shouldSkipHiddenDirectory(name, relativePath, rootPath, unignoredByGitIgnore) {
+    if (!isHiddenName(name)) {
+        return false;
+    }
+    if (unignoredByGitIgnore) {
+        return false;
+    }
+    return !matchesRootIncludePatterns(relativePath, rootPath)
+        && !hasIncludeDescendant(relativePath, rootPath.include);
+}
+function shouldSkipHiddenFile(name, relativePath, rootPath, unignoredByGitIgnore) {
+    if (unignoredByGitIgnore) {
+        return false;
+    }
+    return isHiddenName(name) && !matchesRootIncludePatterns(relativePath, rootPath);
+}
+function hasIncludeDescendant(relativePath, includePatterns) {
+    if (!includePatterns || includePatterns.length === 0) {
+        return false;
+    }
+    return includePatterns.some((pattern) => includePatternDeclaresHiddenDirectory(pattern, relativePath)
+        && pathPatternMightMatchDescendant(pattern, relativePath));
+}
+function includePatternDeclaresHiddenDirectory(pattern, relativePath) {
+    const name = basename(relativePath);
+    if (!isHiddenName(name)) {
+        return true;
+    }
+    return normalizePathPattern(pattern)
+        .split("/")
+        .some((segment) => hiddenPatternSegmentMatches(segment, name));
+}
+function hiddenPatternSegmentMatches(patternSegment, name) {
+    if (!patternSegment.startsWith(".")) {
+        return false;
+    }
+    if (!patternSegment.includes("*") && !patternSegment.includes("?")) {
+        return patternSegment === name;
+    }
+    return segmentGlobToRegExp(patternSegment).test(name);
+}
+function segmentGlobToRegExp(pattern) {
+    let expression = "^";
+    for (const char of pattern) {
+        if (char === "*") {
+            expression += "[^/]*";
+        }
+        else if (char === "?") {
+            expression += "[^/]";
+        }
+        else {
+            expression += escapeRegExp(char);
+        }
+    }
+    return new RegExp(`${expression}$`);
+}
+function escapeRegExp(value) {
+    return value.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
+}
+async function readFileInfo(collectionId, rootPath, absolutePath) {
+    const info = await stat(absolutePath).catch(() => null);
+    if (!info || !info.isFile()) {
+        return null;
+    }
+    if (info.size === 0 || info.size > DEFAULT_MAX_FILE_SIZE_BYTES) {
+        return null;
+    }
+    const detected = detectFileType(absolutePath);
+    if (!detected) {
+        return null;
+    }
+    if (detected.kind !== "image" && await isLikelyBinaryFile(absolutePath)) {
+        return null;
+    }
+    return {
+        id: makeFileId(collectionId, absolutePath),
+        collectionId,
+        absolutePath,
+        relativePath: toDisplayPath(relative(rootPath.absolutePath, absolutePath)),
+        rootPath: rootPath.absolutePath,
+        sizeBytes: info.size,
+        lastModifiedTime: info.mtimeMs,
+        kind: detected.kind,
+        format: detected.format,
+    };
+}
+async function isLikelyBinaryFile(path) {
+    let handle;
+    try {
+        handle = await open(path, "r");
+        const buffer = Buffer.alloc(BINARY_SNIFF_BYTES);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        if (bytesRead === 0) {
+            return false;
+        }
+        let suspicious = 0;
+        for (let index = 0; index < bytesRead; index++) {
+            const value = buffer[index];
+            if (value === 0) {
+                return true;
+            }
+            if (isSuspiciousControlByte(value)) {
+                suspicious++;
+            }
+        }
+        return suspicious / bytesRead > BINARY_CONTROL_CHAR_RATIO;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+function isSuspiciousControlByte(value) {
+    return value < 32
+        && value !== 7
+        && value !== 8
+        && value !== 9
+        && value !== 10
+        && value !== 12
+        && value !== 13
+        && value !== 27;
+}
+function detectFileType(path) {
+    const name = basename(path);
+    if (name === "Dockerfile") {
+        return { kind: "code", format: "dockerfile" };
+    }
+    if (name === "Makefile") {
+        return { kind: "code", format: "makefile" };
+    }
+    const extension = extname(name).toLowerCase();
+    if (extension in CODE_FORMATS) {
+        return { kind: "code", format: CODE_FORMATS[extension] };
+    }
+    if (extension in DATA_FORMATS) {
+        return { kind: "data", format: DATA_FORMATS[extension] };
+    }
+    if (extension in TEXT_FORMATS) {
+        return { kind: "text", format: TEXT_FORMATS[extension] };
+    }
+    if (extension in IMAGE_FORMATS) {
+        return { kind: "image", format: IMAGE_FORMATS[extension] };
+    }
+    if (BINARY_EXTENSIONS.has(extension)) {
+        return null;
+    }
+    return { kind: "text", format: extension ? extension.slice(1) : "text" };
+}
+function makeFileId(collectionId, absolutePath) {
+    return sha256Text(`${collectionId}\0${normalizePath(absolutePath)}`);
+}
+//# sourceMappingURL=index.js.map