@angri450/zvec-grep 0.2.2

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

@@ -0,0 +1,776 @@
+import { lstat, open, readFile, readdir, realpath, stat, } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep, } from "node:path";
+import { detectFileType } from "../../../file-type.js";
+import { resolveMaxFileSizeBytes } from "../../../file-size-policy.js";
+import { sha256Text } from "../../../utils/hash.js";
+import { matchesFileSelection, resolveFileTypePatterns, } from "../../../utils/file-selection.js";
+import { normalizePathPattern, pathPatternMatches, pathPatternMightMatchDescendant, } from "../../../utils/glob.js";
+import { normalizePath, toDisplayPath } from "../../../utils/path.js";
+import { matchesRootExcludePatterns, matchesRootPatterns, normalizeRootPath, validateRootPaths, } from "../root-paths.js";
+const BINARY_SNIFF_BYTES = 8192;
+const BINARY_CONTROL_CHAR_RATIO = 0.3;
+const MAX_GITIGNORE_CACHE_ENTRIES = 4_096;
+const DEFAULT_IGNORED_DIRECTORY_NAMES = [
+    "node_modules",
+    "vendor",
+    "thirdparty",
+    "third_party",
+    "external",
+    "deps",
+    "dist",
+    "build",
+    "out",
+    "target",
+    "coverage",
+    "generated",
+    "__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",
+    "locale",
+    "locales",
+    "translations",
+];
+const DEFAULT_IGNORED_FILE_PATTERNS = [
+    // Cross-ecosystem dependency resolution output. These files remain
+    // available to exact rg search and can be restored with an explicit include.
+    "*.lock",
+    "*.lockb",
+    "*-lock.json",
+    "*-lock.yaml",
+    "npm-shrinkwrap.json",
+    "go.sum",
+    "*.resolved",
+    // Generated localization, browser, and compiler artifacts.
+    "*.po",
+    "*.pot",
+    "*.map",
+    "*.min.*",
+    "*.bundle.*",
+    // General generated-source naming conventions outside generated directories.
+    "*.generated.*",
+    "*.gen.*",
+    "*.designer.*",
+    "*.pb.*",
+    "*_pb2.*",
+    "*.g.*",
+    // Raster assets require an explicitly selected path to enter the semantic
+    // index. Exact search behavior is unaffected.
+    "*.gif",
+    "*.jpeg",
+    "*.jpg",
+    "*.png",
+    "*.webp",
+];
+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,
+    })),
+    ...DEFAULT_IGNORED_FILE_PATTERNS.map((pattern) => ({
+        basePath: "",
+        pattern,
+        negated: false,
+        directoryOnly: false,
+        anchored: false,
+        hasSlash: false,
+    })),
+];
+const gitIgnoreRuleCache = new Map();
+function knownFilesByPath(files) {
+    return new Map((files ?? []).map((file) => [normalizePath(file.absolutePath), file]));
+}
+export async function scanRootPaths(workspaceIndexId, rootPaths, options = {}) {
+    const validatedRootPaths = validateRootPaths(rootPaths);
+    const files = [];
+    const diagnostics = createScanDiagnostics();
+    const knownFiles = knownFilesByPath(options.knownFiles);
+    for (const rootPath of validatedRootPaths) {
+        throwIfAborted(options.signal);
+        await scanRootPath(workspaceIndexId, rootPath, files, diagnostics, options.signal, knownFiles);
+    }
+    return { files, diagnostics };
+}
+export async function scanFilePath(workspaceIndexId, rootPaths, absolutePath, options = {}) {
+    const files = [];
+    const diagnostics = createScanDiagnostics();
+    const knownFiles = knownFilesByPath(options.knownFiles);
+    for (const rootPath of matchingRootPaths(rootPaths, absolutePath)) {
+        throwIfAborted(options.signal);
+        const root = normalizeRootPath(rootPath);
+        const targetInfo = await lstat(absolutePath).catch(() => null);
+        const followedInfo = targetInfo?.isSymbolicLink() && root.follow
+            ? await stat(absolutePath).catch(() => null)
+            : targetInfo;
+        if (!followedInfo?.isFile()) {
+            continue;
+        }
+        if (!root.recursive && dirname(absolutePath) !== root.absolutePath) {
+            continue;
+        }
+        const relativePath = toDisplayPath(relative(root.absolutePath, absolutePath));
+        const rules = await ignoreRulesForDirectory(root, dirname(absolutePath));
+        const fileTypes = await resolveFileTypePatterns(root.fileTypes, root.excludedFileTypes);
+        if (!pathCanBeScanned(root, relativePath, basename(absolutePath), false, rules) ||
+            !matchesFileSelection(relativePath, root, fileTypes) ||
+            (await hasExcludedNestedGitAncestor(root, absolutePath, false))) {
+            continue;
+        }
+        const file = await readFileInfo(workspaceIndexId, root, absolutePath, diagnostics, knownFiles);
+        if (file) {
+            files.push(file);
+        }
+    }
+    return { files: dedupeFiles(files), diagnostics };
+}
+export async function pathCanAffectIndex(rootPaths, absolutePath, isDirectory) {
+    for (const configuredRoot of rootPaths) {
+        const root = normalizeRootPath(configuredRoot);
+        const pathFromRoot = relative(root.absolutePath, absolutePath);
+        if (isAbsolute(pathFromRoot) ||
+            pathFromRoot === ".." ||
+            pathFromRoot.startsWith(`..${sep}`)) {
+            continue;
+        }
+        if (pathFromRoot.length === 0) {
+            return true;
+        }
+        const depth = pathFromRoot.split(sep).filter(Boolean).length;
+        if ((!root.recursive &&
+            (isDirectory || dirname(absolutePath) !== root.absolutePath)) ||
+            (root.maxDepth !== undefined &&
+                (isDirectory ? depth >= root.maxDepth : depth > root.maxDepth))) {
+            continue;
+        }
+        const relativePath = toDisplayPath(pathFromRoot);
+        const rules = await ignoreRulesForDirectory(root, dirname(absolutePath));
+        if (!pathCanBeScanned(root, relativePath, basename(absolutePath), isDirectory, rules) ||
+            (await hasExcludedNestedGitAncestor(root, absolutePath, isDirectory))) {
+            continue;
+        }
+        if (isDirectory) {
+            return true;
+        }
+        const fileTypes = await resolveFileTypePatterns(root.fileTypes, root.excludedFileTypes);
+        if (matchesFileSelection(relativePath, root, fileTypes)) {
+            return true;
+        }
+    }
+    return false;
+}
+export async function scanDirectoryPath(workspaceIndexId, rootPaths, absolutePath, options = {}) {
+    const files = [];
+    const diagnostics = createScanDiagnostics();
+    const knownFiles = knownFilesByPath(options.knownFiles);
+    for (const rootPath of matchingRootPaths(rootPaths, absolutePath)) {
+        throwIfAborted(options.signal);
+        const root = normalizeRootPath(rootPath);
+        if (!root.recursive && absolutePath !== root.absolutePath) {
+            continue;
+        }
+        const info = await lstat(absolutePath).catch(() => null);
+        const followedInfo = info?.isSymbolicLink() && root.follow
+            ? await stat(absolutePath).catch(() => null)
+            : info;
+        if (!followedInfo?.isDirectory()) {
+            continue;
+        }
+        const relativePath = toDisplayPath(relative(root.absolutePath, absolutePath));
+        const parentRules = await ignoreRulesForDirectory(root, dirname(absolutePath));
+        const fileTypes = await resolveFileTypePatterns(root.fileTypes, root.excludedFileTypes);
+        if (relativePath &&
+            (!pathCanBeScanned(root, relativePath, basename(absolutePath), true, parentRules) ||
+                (await hasExcludedNestedGitAncestor(root, absolutePath, true)))) {
+            continue;
+        }
+        const rootRealPath = await realpath(root.absolutePath).catch(() => root.absolutePath);
+        const directoryRealPath = await realpath(absolutePath).catch(() => absolutePath);
+        const depth = relativePath.split("/").filter(Boolean).length;
+        await walk(workspaceIndexId, root, absolutePath, files, diagnostics, parentRules, fileTypes, new Set([rootRealPath, directoryRealPath]), depth, options.signal, knownFiles);
+    }
+    return { files: dedupeFiles(files), diagnostics };
+}
+async function hasExcludedNestedGitAncestor(rootPath, absolutePath, includeTarget) {
+    const pathFromRoot = relative(rootPath.absolutePath, absolutePath);
+    const segments = pathFromRoot.split(sep).filter(Boolean);
+    const directorySegments = includeTarget ? segments : segments.slice(0, -1);
+    let current = rootPath.absolutePath;
+    for (const segment of directorySegments) {
+        current = join(current, segment);
+        const relativeDirectory = toDisplayPath(relative(rootPath.absolutePath, current));
+        if ((await isNestedGitRepositoryDirectory(current)) &&
+            !nestedGitRepositoryExplicitlyIncluded(relativeDirectory, rootPath)) {
+            return true;
+        }
+    }
+    return false;
+}
+function matchingRootPaths(rootPaths, absolutePath) {
+    return validateRootPaths(rootPaths).filter((rootPath) => {
+        const root = normalizeRootPath(rootPath);
+        const pathFromRoot = relative(root.absolutePath, absolutePath);
+        return (!isAbsolute(pathFromRoot) &&
+            pathFromRoot !== ".." &&
+            !pathFromRoot.startsWith(`..${sep}`));
+    });
+}
+async function ignoreRulesForDirectory(rootPath, directory) {
+    const pathFromRoot = relative(rootPath.absolutePath, directory);
+    if (isAbsolute(pathFromRoot) ||
+        pathFromRoot === ".." ||
+        pathFromRoot.startsWith(`..${sep}`)) {
+        return [...DEFAULT_IGNORE_RULES];
+    }
+    const rules = [
+        ...(rootPath.noIgnore ? [] : DEFAULT_IGNORE_RULES),
+        ...(await readConfiguredIgnoreRules(rootPath)),
+    ];
+    let current = rootPath.absolutePath;
+    if (!rootPath.noIgnore) {
+        rules.push(...(await readGitIgnoreRules(rootPath, current)));
+    }
+    if (!pathFromRoot) {
+        return rules;
+    }
+    for (const segment of pathFromRoot.split(sep).filter(Boolean)) {
+        current = join(current, segment);
+        if (!rootPath.noIgnore) {
+            rules.push(...(await readGitIgnoreRules(rootPath, current)));
+        }
+    }
+    return rules;
+}
+function pathCanBeScanned(rootPath, relativePath, name, isDirectory, ignoreRules) {
+    if (relativePath
+        .split("/")
+        .some((segment) => HARD_SKIP_HIDDEN_NAMES.has(segment))) {
+        return false;
+    }
+    const ignoreMatch = matchIgnoreRules(relativePath, isDirectory, ignoreRules);
+    if (ignoreMatch.ignored &&
+        !ignoredPathExplicitlyIncluded(relativePath, rootPath, ignoreMatch)) {
+        return false;
+    }
+    if (matchesRootExcludePatterns(relativePath, rootPath)) {
+        return false;
+    }
+    if (isDirectory) {
+        return !shouldSkipHiddenDirectory(name, relativePath, rootPath);
+    }
+    return (!shouldSkipHiddenFile(name, relativePath, rootPath) &&
+        matchesRootPatterns(relativePath, rootPath));
+}
+function dedupeFiles(files) {
+    return [...new Map(files.map((file) => [file.id, file])).values()];
+}
+async function scanRootPath(workspaceIndexId, rootPath, files, diagnostics, signal, knownFiles = new Map()) {
+    throwIfAborted(signal);
+    const root = normalizeRootPath(rootPath);
+    const fileTypes = await resolveFileTypePatterns(root.fileTypes, root.excludedFileTypes);
+    const info = await stat(root.absolutePath).catch(() => null);
+    if (!info) {
+        return;
+    }
+    if (info.isFile()) {
+        const relativePath = basename(root.absolutePath);
+        const file = matchesFileSelection(relativePath, root, fileTypes)
+            ? await readFileInfo(workspaceIndexId, root, root.absolutePath, diagnostics, knownFiles)
+            : null;
+        if (file) {
+            files.push(file);
+        }
+        return;
+    }
+    if (!info.isDirectory()) {
+        return;
+    }
+    if (HARD_SKIP_HIDDEN_NAMES.has(basename(root.absolutePath))) {
+        return;
+    }
+    const rootRealPath = await realpath(root.absolutePath).catch(() => root.absolutePath);
+    await walk(workspaceIndexId, root, root.absolutePath, files, diagnostics, [
+        ...(root.noIgnore ? [] : DEFAULT_IGNORE_RULES),
+        ...(await readConfiguredIgnoreRules(root)),
+    ], fileTypes, new Set([rootRealPath]), 0, signal, knownFiles);
+}
+async function walk(workspaceIndexId, rootPath, currentPath, files, diagnostics, parentIgnoreRules, fileTypes, visitedDirectories, depth, signal, knownFiles = new Map()) {
+    throwIfAborted(signal);
+    let entries;
+    const ignoreRules = [
+        ...parentIgnoreRules,
+        ...(rootPath.noIgnore
+            ? []
+            : await readGitIgnoreRules(rootPath, currentPath)),
+    ];
+    try {
+        entries = await readdir(currentPath, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        throwIfAborted(signal);
+        const absolutePath = join(currentPath, entry.name);
+        const relativePath = toDisplayPath(relative(rootPath.absolutePath, absolutePath));
+        let isDirectory = entry.isDirectory();
+        let isFile = entry.isFile();
+        if (entry.isSymbolicLink() && rootPath.follow) {
+            const target = await stat(absolutePath).catch(() => null);
+            isDirectory = target?.isDirectory() === true;
+            isFile = target?.isFile() === true;
+        }
+        if (isDirectory) {
+            if (!rootPath.recursive) {
+                continue;
+            }
+            if (rootPath.maxDepth !== undefined && depth + 1 >= rootPath.maxDepth) {
+                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)) {
+                continue;
+            }
+            if ((await isNestedGitRepositoryDirectory(absolutePath)) &&
+                !nestedGitRepositoryExplicitlyIncluded(relativePath, rootPath)) {
+                continue;
+            }
+            const realDirectory = await realpath(absolutePath).catch(() => null);
+            if (!realDirectory || visitedDirectories.has(realDirectory)) {
+                continue;
+            }
+            visitedDirectories.add(realDirectory);
+            await walk(workspaceIndexId, rootPath, absolutePath, files, diagnostics, ignoreRules, fileTypes, visitedDirectories, depth + 1, signal, knownFiles);
+            continue;
+        }
+        if (!isFile) {
+            continue;
+        }
+        if (rootPath.maxDepth !== undefined && depth + 1 > rootPath.maxDepth) {
+            continue;
+        }
+        if (HARD_SKIP_HIDDEN_NAMES.has(entry.name)) {
+            continue;
+        }
+        const ignoreMatch = matchIgnoreRules(relativePath, false, ignoreRules);
+        if (ignoreMatch.ignored &&
+            !ignoredPathExplicitlyIncluded(relativePath, rootPath, ignoreMatch)) {
+            continue;
+        }
+        if (shouldSkipHiddenFile(entry.name, relativePath, rootPath)) {
+            continue;
+        }
+        if (!matchesRootPatterns(relativePath, rootPath)) {
+            continue;
+        }
+        if (!matchesFileSelection(relativePath, rootPath, fileTypes)) {
+            continue;
+        }
+        const file = await readFileInfo(workspaceIndexId, rootPath, absolutePath, diagnostics, knownFiles);
+        throwIfAborted(signal);
+        if (file) {
+            files.push(file);
+        }
+    }
+}
+function throwIfAborted(signal) {
+    if (!signal?.aborted) {
+        return;
+    }
+    throw signal.reason instanceof Error
+        ? signal.reason
+        : new Error("Indexing was cancelled.");
+}
+function isHiddenName(name) {
+    return name.startsWith(".") && name !== "." && name !== "..";
+}
+async function readGitIgnoreRules(rootPath, currentPath) {
+    const ignorePath = join(currentPath, ".gitignore");
+    const content = await readFile(ignorePath, "utf8").catch(() => null);
+    const basePath = toDisplayPath(relative(rootPath.absolutePath, currentPath));
+    const cacheKey = `${ignorePath}\0${basePath}`;
+    if (content === null) {
+        gitIgnoreRuleCache.delete(cacheKey);
+        return [];
+    }
+    const cached = gitIgnoreRuleCache.get(cacheKey);
+    if (cached?.content === content) {
+        return cached.rules;
+    }
+    const rules = parseGitIgnoreRules(content, basePath);
+    gitIgnoreRuleCache.set(cacheKey, { content, rules });
+    if (gitIgnoreRuleCache.size > MAX_GITIGNORE_CACHE_ENTRIES) {
+        gitIgnoreRuleCache.delete(gitIgnoreRuleCache.keys().next().value);
+    }
+    return rules;
+}
+async function readConfiguredIgnoreRules(rootPath) {
+    const rules = [];
+    for (const path of rootPath.ignoreFiles ?? []) {
+        const absolutePath = isAbsolute(path)
+            ? path
+            : resolve(rootPath.absolutePath, path);
+        const content = await readFile(absolutePath, "utf8");
+        rules.push(...parseGitIgnoreRules(content, ""));
+    }
+    return rules;
+}
+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) ||
+        segmentMatches(ignoredSegment, segment));
+}
+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) {
+    if (!isHiddenName(name) || rootPath.hidden) {
+        return false;
+    }
+    return !hasIncludeDescendant(relativePath, rootPath.include);
+}
+function shouldSkipHiddenFile(name, relativePath, rootPath) {
+    return (isHiddenName(name) &&
+        !rootPath.hidden &&
+        !hasExplicitHiddenFileInclude(relativePath, rootPath.include));
+}
+async function isNestedGitRepositoryDirectory(absolutePath) {
+    const marker = await stat(join(absolutePath, ".git")).catch(() => null);
+    return marker !== null && (marker.isFile() || marker.isDirectory());
+}
+function nestedGitRepositoryExplicitlyIncluded(relativePath, rootPath) {
+    if (!rootPath.include || rootPath.include.length === 0) {
+        return false;
+    }
+    const normalizedRelativePath = normalizePathPattern(relativePath);
+    return rootPath.include.some((pattern) => {
+        const normalizedPattern = normalizePathPattern(pattern);
+        return (pathPatternMatches(normalizedPattern, normalizedRelativePath) ||
+            normalizedPattern.startsWith(`${normalizedRelativePath}/`));
+    });
+}
+function hasIncludeDescendant(relativePath, includePatterns) {
+    if (!includePatterns || includePatterns.length === 0) {
+        return false;
+    }
+    return includePatterns.some((pattern) => includePatternDeclaresHiddenDirectory(pattern, relativePath) &&
+        pathPatternMightMatchDescendant(pattern, relativePath));
+}
+function hasExplicitHiddenFileInclude(relativePath, includePatterns) {
+    if (!includePatterns || includePatterns.length === 0) {
+        return false;
+    }
+    return includePatterns.some((pattern) => includePatternDeclaresHiddenDirectory(pattern, relativePath) &&
+        pathPatternMatches(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(workspaceIndexId, rootPath, absolutePath, diagnostics, knownFiles = new Map()) {
+    const info = await stat(absolutePath).catch(() => null);
+    if (!info || !info.isFile()) {
+        return null;
+    }
+    const relativePath = toDisplayPath(relative(rootPath.absolutePath, absolutePath)) ||
+        basename(absolutePath);
+    if (info.size === 0) {
+        recordSkippedFile(diagnostics, {
+            absolutePath,
+            relativePath,
+            reason: "empty",
+            sizeBytes: 0,
+        });
+        return null;
+    }
+    const detected = detectFileType(absolutePath);
+    if (!detected) {
+        recordSkippedFile(diagnostics, {
+            absolutePath,
+            relativePath,
+            reason: "unsupported",
+            sizeBytes: info.size,
+        });
+        return null;
+    }
+    const maxFileSize = resolveMaxFileSizeBytes(detected.kind, rootPath.maxFileSizeBytes);
+    if (info.size > maxFileSize) {
+        recordSkippedFile(diagnostics, {
+            absolutePath,
+            relativePath,
+            reason: "too_large",
+            sizeBytes: info.size,
+            limitBytes: maxFileSize,
+        });
+        return null;
+    }
+    const lastModifiedTime = Math.trunc(info.mtimeMs);
+    const known = knownFiles.get(normalizePath(absolutePath));
+    if (known?.contentHash &&
+        known.sizeBytes === info.size &&
+        known.lastModifiedTime === lastModifiedTime) {
+        return {
+            id: makeFileId(workspaceIndexId, absolutePath),
+            absolutePath,
+            relativePath,
+            rootPath: rootPath.absolutePath,
+            sizeBytes: info.size,
+            lastModifiedTime,
+            kind: detected.kind,
+            format: detected.format,
+        };
+    }
+    if (detected.kind !== "image" && (await isLikelyBinaryFile(absolutePath))) {
+        recordSkippedFile(diagnostics, {
+            absolutePath,
+            relativePath,
+            reason: "binary",
+            sizeBytes: info.size,
+        });
+        return null;
+    }
+    return {
+        id: makeFileId(workspaceIndexId, absolutePath),
+        absolutePath,
+        relativePath,
+        rootPath: rootPath.absolutePath,
+        sizeBytes: info.size,
+        lastModifiedTime,
+        kind: detected.kind,
+        format: detected.format,
+    };
+}
+const MAX_SKIPPED_FILE_SAMPLES = 20;
+export function createScanDiagnostics() {
+    return {
+        skippedFiles: 0,
+        skippedByReason: {
+            empty: 0,
+            too_large: 0,
+            unsupported: 0,
+            binary: 0,
+        },
+        skippedSamples: [],
+    };
+}
+function recordSkippedFile(diagnostics, skipped) {
+    diagnostics.skippedFiles++;
+    diagnostics.skippedByReason[skipped.reason]++;
+    if (diagnostics.skippedSamples.length < MAX_SKIPPED_FILE_SAMPLES) {
+        diagnostics.skippedSamples.push(skipped);
+    }
+}
+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 makeFileId(workspaceIndexId, absolutePath) {
+    return sha256Text(`${workspaceIndexId}\0${normalizePath(absolutePath)}`);
+}
+//# sourceMappingURL=index.js.map