@lzehrung/codegraph-core 2.3.2 → 2.3.4

package/dist/util/projectFiles.js

@@ -11,7 +11,7 @@ export { isRelativePathInside, matchesDiscoveryGlob } from "./discoveryPath.js";
 import { PROJECT_FILE_DEFINITIONS, } from "./projectFiles/definitions.js";
 import { trimToNull } from "./projectFiles/parsers.js";
 import { mapLimitSemaphore } from "./concurrency.js";
-import { isGitProjectRootIgnored, isGitRepo, listGitExcludeFiles, listGitSubmoduleDirectories, listTrackedFiles, listUntrackedFiles, } from "./git.js";
+import { getGitRepositoryRoot, isGitProjectRootIgnored, isGitRepo, listGitExcludeFiles, listGitSubmoduleDirectories, listTrackedFiles, listUntrackedFiles, } from "./git.js";
 export const DEFAULT_PROJECT_FILE_IGNORES = [
     "**/node_modules/**",
     "**/.git/**",
@@ -99,6 +99,15 @@ export const DEFAULT_PROJECT_PATTERNS = [
     ...DEFAULT_PROJECT_MANIFESTS.map((name) => `**/${name}`),
 ];
 const REALPATH_FILTER_CONCURRENCY = 64;
+function createPathCheckProgressReporter(total, onProgress) {
+    onProgress?.(0, total);
+    let completed = 0;
+    return () => {
+        completed += 1;
+        if (completed === total || completed % 100 === 0)
+            onProgress?.(completed, total);
+    };
+}
 function isPresent(value) {
     return value !== undefined;
 }
@@ -188,7 +197,12 @@ function parseGitignoreRule(baseDir, rawLine) {
         matches,
     };
 }
-const EMPTY_GITIGNORE_INDEX = { hasRules: false, byBaseDir: new Map() };
+const EMPTY_GITIGNORE_INDEX = {
+    hasRules: false,
+    repositoryRoots: [],
+    repositoryAliases: [],
+    byBaseDir: new Map(),
+};
 /**
  * Parse `.gitignore` rules from an already-discovered set of `.gitignore` files.
  *
@@ -198,22 +212,36 @@ const EMPTY_GITIGNORE_INDEX = { hasRules: false, byBaseDir: new Map() };
  * child negation could re-include files. Depth-first ordering also keeps the "last match
  * wins" order deeper files depend on, and drops the locale sensitivity of `localeCompare`.
  */
-async function buildGitignoreIndex(sources) {
+async function buildGitignoreIndex(sources, repositoryRoots = [], repositoryAliases = []) {
     const sorted = [...sources]
-        .map(({ file, baseDir }) => ({ file: normalizePath(file), baseDir: normalizePath(baseDir) }))
+        .map(({ file, baseDir, repositoryRoot, priority }) => ({
+        file: normalizePath(file),
+        baseDir: normalizePath(baseDir),
+        priority: priority ?? 2,
+        ...(repositoryRoot === undefined ? {} : { repositoryRoot: normalizePath(repositoryRoot) }),
+    }))
         .sort((left, right) => {
-        const leftFile = left.file;
-        const rightFile = right.file;
-        const depthDelta = leftFile.split("/").length - rightFile.split("/").length;
-        if (depthDelta !== 0)
-            return depthDelta;
-        if (leftFile < rightFile)
+        const baseDepthDelta = left.baseDir.split("/").length - right.baseDir.split("/").length;
+        if (baseDepthDelta !== 0)
+            return baseDepthDelta;
+        const priorityDelta = left.priority - right.priority;
+        if (priorityDelta !== 0)
+            return priorityDelta;
+        if (left.file < right.file)
             return -1;
-        return leftFile > rightFile ? 1 : 0;
+        return left.file > right.file ? 1 : 0;
     });
-    const gitignoreIndex = { hasRules: false, byBaseDir: new Map() };
-    for (const { file, baseDir } of sorted) {
-        if (isIgnoredByGitignore(file, gitignoreIndex)) {
+    const gitignoreIndex = {
+        hasRules: false,
+        repositoryRoots: Array.from(new Set(repositoryRoots.map(normalizePath))).sort((left, right) => right.length - left.length),
+        repositoryAliases: Array.from(new Map(repositoryAliases.map(({ path: aliasPath, repositoryRoot }) => [
+            fileIdentityKey(aliasPath),
+            { path: normalizePath(aliasPath), repositoryRoot: normalizePath(repositoryRoot) },
+        ])).values()).sort((left, right) => right.path.length - left.path.length),
+        byBaseDir: new Map(),
+    };
+    for (const { file, baseDir, repositoryRoot } of sorted) {
+        if (isIgnoredByGitignore(path.dirname(file), gitignoreIndex, true)) {
             continue;
         }
         let raw;
@@ -232,7 +260,7 @@ async function buildGitignoreIndex(sources) {
             if (existing)
                 existing.rules.push(rule);
             else
-                gitignoreIndex.byBaseDir.set(baseKey, { baseDir, rules: [rule] });
+                gitignoreIndex.byBaseDir.set(baseKey, { baseDir, repositoryRoot, rules: [rule] });
             gitignoreIndex.hasRules = true;
         }
     }
@@ -277,9 +305,12 @@ async function loadGitignoreIndexForRootAliases(projectRoot) {
  * `path.relative` and normalization work; on the same project that repetition was the
  * dominant remaining cost, at 2.6s of a 3.8s discovery.
  */
-function isIgnoredByGitignore(absolutePath, gitignoreIndex) {
+function isIgnoredByGitignore(absolutePath, gitignoreIndex, isDirectory = false) {
     if (!gitignoreIndex.hasRules)
         return false;
+    const owningRepositoryRoot = gitignoreIndex.repositoryRoots.find((root) => isFilePathWithinRoot(root, absolutePath)) ??
+        gitignoreIndex.repositoryAliases.find(({ path: aliasPath }) => isFilePathWithinRoot(aliasPath, absolutePath))
+            ?.repositoryRoot;
     const chain = [];
     let current = normalizePath(path.dirname(absolutePath));
     for (;;) {
@@ -294,6 +325,11 @@ function isIgnoredByGitignore(absolutePath, gitignoreIndex) {
     let ignored = false;
     for (let depth = chain.length - 1; depth >= 0; depth -= 1) {
         const group = chain[depth];
+        if (group.repositoryRoot !== undefined &&
+            owningRepositoryRoot !== undefined &&
+            fileIdentityKey(group.repositoryRoot) !== fileIdentityKey(owningRepositoryRoot)) {
+            continue;
+        }
         const relativePath = path.relative(group.baseDir, absolutePath);
         if (!isRelativePathInside(relativePath)) {
             continue;
@@ -301,10 +337,11 @@ function isIgnoredByGitignore(absolutePath, gitignoreIndex) {
         const normalizedRelativePath = normalizePath(relativePath);
         const hasSeparator = normalizedRelativePath.includes("/");
         for (const rule of group.rules) {
-            if (rule.dirOnly && !hasSeparator) {
+            if (rule.dirOnly && !hasSeparator && !isDirectory) {
                 continue;
             }
-            if (rule.matches(normalizedRelativePath)) {
+            const matchesDirectory = isDirectory && rule.dirOnly && rule.matches(`${normalizedRelativePath}/.directory`);
+            if (rule.matches(normalizedRelativePath) || matchesDirectory) {
                 ignored = !rule.negated;
             }
         }
@@ -350,65 +387,91 @@ function collectCandidateAncestorDirectories(root, files) {
     }
     return directories;
 }
-/**
- * Locate the `.gitignore` files that can affect `files`, plus Git's other ignore sources.
- *
- * Filtering the candidate listing for `.gitignore` would miss a `.gitignore` that is
- * itself ignored; Git still reads those, and tracked files matching their rules must
- * still be excluded. Probing the candidates' ancestor directories finds them without
- * reintroducing a full-tree walk. `.git/info/exclude` and `core.excludesFile` are
- * included so the index is authoritative for every source Git consults: paths that do
- * not come from Git, such as entries behind a directory symlink, are then filtered by
- * the same rules Git applied to the candidate listing.
- */
-async function findGitIgnoreSources(root, files) {
-    const directories = collectCandidateAncestorDirectories(root, files);
-    const present = await mapLimitSemaphore(directories, REALPATH_FILTER_CONCURRENCY, async (directory) => {
-        const candidate = normalizePath(path.join(directory, ".gitignore"));
-        try {
-            return (await fsp.stat(candidate)).isFile() ? { file: candidate, baseDir: directory } : null;
-        }
-        catch {
-            return null;
-        }
-    });
-    const sources = present.filter((entry) => entry !== null);
-    sources.push(...(await listGitExcludeFiles(root)));
+async function findGitIgnoreSources(sourceRoots, files) {
+    const roots = Array.from(new Map(sourceRoots.map(({ path: sourceRoot, repositoryRoot }) => [
+        fileIdentityKey(sourceRoot),
+        { path: normalizePath(sourceRoot), repositoryRoot: normalizePath(repositoryRoot) },
+    ])).values());
+    const sources = [];
+    for (const { path: sourceRoot, repositoryRoot } of roots) {
+        const directories = collectCandidateAncestorDirectories(sourceRoot, files.filter((file) => isFilePathWithinRoot(sourceRoot, file)));
+        const present = await mapLimitSemaphore(directories, REALPATH_FILTER_CONCURRENCY, async (directory) => {
+            const candidate = normalizePath(path.join(directory, ".gitignore"));
+            try {
+                return (await fsp.stat(candidate)).isFile()
+                    ? { file: candidate, baseDir: directory, repositoryRoot, priority: 2 }
+                    : null;
+            }
+            catch {
+                return null;
+            }
+        });
+        sources.push(...present.filter((entry) => entry !== null));
+        sources.push(...(await listGitExcludeFiles(sourceRoot)).map((source) => ({
+            ...source,
+            repositoryRoot: source.baseDir,
+        })));
+    }
     return sources;
 }
 /**
  * Enumerate candidate project files through Git, or `null` when Git cannot answer.
  *
- * Tracked plus untracked-but-not-ignored files are exactly the working-tree files Git
- * treats as part of the project. Any Git failure returns `null` and discovery falls back
- * to scanning the filesystem.
- *
- * Submodules need explicit handling or their contents vanish from the index: the
- * superproject records only a gitlink. Tracked files come from `--recurse-submodules`,
- * which cannot combine with `--others`, so untracked files are listed per submodule
- * directory, including submodules nested inside submodules.
- *
- * A root that Git itself ignores falls back to scanning. Enumerating it through Git
- * would return only tracked files and silently drop the rest, which would make a
- * directory the caller named explicitly look nearly empty.
+ * Tracked plus untracked-but-not-ignored files are Git candidates. Submodule files retain
+ * their own repository boundary, and source roots cover logical and physical aliases.
  */
 async function listGitCandidateFiles(root, logLevel) {
     try {
-        if (!(await isGitRepo(root)))
+        const realRoot = normalizePath(await fsp.realpath(root));
+        const gitRoot = (await isGitRepo(root)) ? root : realRoot;
+        if (!(await isGitRepo(gitRoot)))
             return null;
-        if (await isGitProjectRootIgnored(root))
+        if (await isGitProjectRootIgnored(realRoot))
+            return null;
+        const gitRepositoryRoot = await getGitRepositoryRoot(gitRoot);
+        if (!gitRepositoryRoot)
             return null;
         const [tracked, untracked, submoduleDirectories] = await Promise.all([
-            listTrackedFiles(root, { recurseSubmodules: true, ...(logLevel === undefined ? {} : { logLevel }) }),
-            listUntrackedFiles(root, { respectGitignore: true }),
-            listGitSubmoduleDirectories(root, { recurse: true }),
+            listTrackedFiles(gitRoot, { recurseSubmodules: true, ...(logLevel === undefined ? {} : { logLevel }) }),
+            listUntrackedFiles(gitRoot, { respectGitignore: true }),
+            listGitSubmoduleDirectories(gitRoot, { recurse: true }),
         ]);
-        const submoduleUntracked = await Promise.all(submoduleDirectories.map(async (directory) => await listUntrackedFiles(directory, { respectGitignore: true })));
-        // Sorted so discovery order is reproducible rather than an artifact of how three
-        // separate Git listings happened to be concatenated. Callers that surface results
-        // in discovery order then behave the same way on every machine.
-        const files = Array.from(new Set([...tracked, ...untracked, ...submoduleUntracked.flat()])).sort();
-        return { files, gitignoreFiles: await findGitIgnoreSources(root, files) };
+        const submoduleRoots = await Promise.all(submoduleDirectories.map(async (logicalPath) => ({
+            logicalPath: normalizePath(logicalPath),
+            physicalPath: normalizePath(await fsp.realpath(logicalPath).catch(() => logicalPath)),
+        })));
+        const submoduleUntracked = await Promise.all(submoduleRoots.map(async ({ physicalPath }) => await listUntrackedFiles(physicalPath, { respectGitignore: true })));
+        const rawFiles = Array.from(new Set([...tracked, ...untracked, ...submoduleUntracked.flat()])).sort();
+        const needsLogicalRemap = normalizePath(gitRoot) !== normalizePath(root);
+        const files = Array.from(new Set(rawFiles.map((file) => needsLogicalRemap && isFilePathWithinRoot(realRoot, file)
+            ? normalizePath(path.resolve(root, path.relative(realRoot, file)))
+            : normalizePath(file)))).sort();
+        const physicalFiles = normalizePath(root) === realRoot
+            ? []
+            : (await mapLimitSemaphore(files, REALPATH_FILTER_CONCURRENCY, async (file) => {
+                try {
+                    return normalizePath(await fsp.realpath(file));
+                }
+                catch {
+                    return null;
+                }
+            })).filter((file) => file !== null);
+        const gitignoreRoots = [gitRepositoryRoot, ...submoduleRoots.map(({ physicalPath }) => physicalPath)].map(normalizePath);
+        const sourceRoots = [
+            { path: root, repositoryRoot: gitRepositoryRoot },
+            { path: realRoot, repositoryRoot: gitRepositoryRoot },
+            { path: gitRepositoryRoot, repositoryRoot: gitRepositoryRoot },
+            ...submoduleRoots.flatMap(({ logicalPath, physicalPath }) => [
+                { path: logicalPath, repositoryRoot: physicalPath },
+                { path: physicalPath, repositoryRoot: physicalPath },
+            ]),
+        ];
+        return {
+            files,
+            gitignoreFiles: await findGitIgnoreSources(sourceRoots, [...rawFiles, ...files, ...physicalFiles]),
+            gitignoreRoots,
+            gitignoreAliases: sourceRoots,
+        };
     }
     catch (error) {
         logWithLevel(logLevel, "debug", `Git discovery unavailable for ${root}: ${stringifyUnknown(error)}`);
@@ -416,6 +479,12 @@ async function listGitCandidateFiles(root, logLevel) {
     }
 }
 export async function listProjectFiles(projectRoot, patterns = DEFAULT_PROJECT_PATTERNS, options) {
+    return await listProjectFilesInternal(projectRoot, patterns, options);
+}
+export async function listProjectFilesWithGitCandidates(projectRoot, patterns = DEFAULT_PROJECT_PATTERNS, options) {
+    return await listProjectFilesInternal(projectRoot, patterns, options);
+}
+async function listProjectFilesInternal(projectRoot, patterns = DEFAULT_PROJECT_PATTERNS, options) {
     const root = await ensureDirectoryReadable(projectRoot, "Project root");
     const globRoot = options?.globRoot ? await ensureDirectoryReadable(options.globRoot, "Glob root") : root;
     const includeGlobs = (options?.includeGlobs ?? []).map(normalizeGlobPattern).filter(Boolean);
@@ -448,12 +517,17 @@ export async function listProjectFiles(projectRoot, patterns = DEFAULT_PROJECT_P
         // `Intermediate/` tree, and discovery took 26.1s. Git lists 4,010 in about 111ms.
         // An aliased root or a gitignore-root override means Git's notion of the project is
         // not this call's, so those fall back to the scan.
-        const gitCandidates = useGitignore && options?.gitignoreRoot === undefined && normalizePath(realRoot) === normalizePath(root)
-            ? await listGitCandidateFiles(root, options?.logLevel)
-            : null;
+        const attemptedGitCandidates = useGitignore && options?.gitignoreRoot === undefined && normalizePath(realRoot) === normalizePath(root);
+        const gitCandidates = attemptedGitCandidates ? await listGitCandidateFiles(root, options?.logLevel) : null;
+        // Report only when this call actually asked Git, including a null result. Callers that
+        // already enumerated candidates (build-index) can hand the same set to metadata discovery
+        // and skip a second Git spawn; omitting the callback keeps prior caller behavior.
+        if (attemptedGitCandidates) {
+            options?.onGitCandidatesDiscovered?.(gitCandidates);
+        }
         let gitignoreIndex = EMPTY_GITIGNORE_INDEX;
         if (useGitignore && gitCandidates) {
-            gitignoreIndex = await buildGitignoreIndex(gitCandidates.gitignoreFiles);
+            gitignoreIndex = await buildGitignoreIndex(gitCandidates.gitignoreFiles, gitCandidates.gitignoreRoots, gitCandidates.gitignoreAliases);
         }
         else if (useGitignore) {
             const gitignoreRoot = options?.gitignoreRoot
@@ -489,6 +563,12 @@ export async function listProjectFiles(projectRoot, patterns = DEFAULT_PROJECT_P
                 ignore: translatedUserIgnoreGlobs,
             })
             : [];
+        const reportSourceSymlinkChecks = options?.onDiscoveryProgress
+            ? (current, total) => options.onDiscoveryProgress?.({ activity: "Checking source symlinks", current, total })
+            : undefined;
+        const reportSourcePathChecks = options?.onDiscoveryProgress
+            ? (current, total) => options.onDiscoveryProgress?.({ activity: "Checking source file paths", current, total })
+            : undefined;
         const symlinkOptions = {
             globRoot,
             ...(gitCandidates ? { candidatePaths: gitCandidates.files } : {}),
@@ -498,6 +578,7 @@ export async function listProjectFiles(projectRoot, patterns = DEFAULT_PROJECT_P
             ...(options?.onSymlinkDirectoriesDiscovered
                 ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered }
                 : {}),
+            ...(reportSourceSymlinkChecks ? { onPathCheckProgress: reportSourceSymlinkChecks } : {}),
         };
         const safeSymlinkDirectories = await resolveSafeSymlinkDirectories(root, realRoot, symlinkProbeIgnoreGlobs, symlinkOptions);
         const linkedFiles = await listEntriesFromSafeSymlinkDirectories(root, realRoot, patterns, fastGlobIgnoreGlobs, {
@@ -512,7 +593,7 @@ export async function listProjectFiles(projectRoot, patterns = DEFAULT_PROJECT_P
                 filterIgnoreGlobs: userIgnoreGlobs,
                 resolvedSafeSymlinkDirectories: safeSymlinkDirectories,
             });
-        const rootSafeFiles = await filterRealPathsWithinRootEntries([...files, ...includedOverrideFiles, ...linkedFiles, ...linkedOverrideFiles], realRoot);
+        const rootSafeFiles = await filterRealPathsWithinRootEntries([...files, ...includedOverrideFiles, ...linkedFiles, ...linkedOverrideFiles], realRoot, reportSourcePathChecks);
         const seen = new Set();
         return rootSafeFiles
             .map(({ path: filePath, realPath }) => ({ filePath: normalizePath(filePath), realPath }))
@@ -612,6 +693,18 @@ async function isSafeSymlinkDirectory(root, linkPath, realRoot) {
         return false;
     }
 }
+async function verifySafeSymlinkDirectories(root, realRoot, paths, onPathCheckProgress) {
+    const reportPathCheck = createPathCheckProgressReporter(paths.length, onPathCheckProgress);
+    const verified = await mapLimitSemaphore(Array.from(paths), REALPATH_FILTER_CONCURRENCY, async (linkPath) => {
+        try {
+            return (await isSafeSymlinkDirectory(root, linkPath, realRoot)) ? linkPath : null;
+        }
+        finally {
+            reportPathCheck();
+        }
+    });
+    return verified.filter((entry) => entry !== null);
+}
 /**
  * Resolve the symlinked directories under `root` that are safe to crawl.
  *
@@ -624,8 +717,7 @@ async function isSafeSymlinkDirectory(root, linkPath, realRoot) {
  */
 async function resolveSafeSymlinkDirectories(root, realRoot, ignore, options) {
     if (options.knownSymlinkDirectories !== undefined) {
-        const verified = await mapLimitSemaphore(Array.from(new Set(options.knownSymlinkDirectories)), REALPATH_FILTER_CONCURRENCY, async (linkPath) => ((await isSafeSymlinkDirectory(root, linkPath, realRoot)) ? linkPath : null));
-        const resolved = verified.filter((entry) => entry !== null);
+        const resolved = await verifySafeSymlinkDirectories(root, realRoot, Array.from(new Set(options.knownSymlinkDirectories)), options.onPathCheckProgress);
         options.onSymlinkDirectoriesDiscovered?.(resolved, "known");
         return resolved;
     }
@@ -640,8 +732,7 @@ async function resolveSafeSymlinkDirectories(root, realRoot, ignore, options) {
                 return false;
             return !ignoreMatchers.some((matcher) => matcher(relativePath));
         });
-        const verified = await mapLimitSemaphore(candidatePaths, REALPATH_FILTER_CONCURRENCY, async (linkPath) => (await isSafeSymlinkDirectory(root, linkPath, realRoot)) ? linkPath : null);
-        const discovered = verified.filter((entry) => entry !== null);
+        const discovered = await verifySafeSymlinkDirectories(root, realRoot, candidatePaths, options.onPathCheckProgress);
         options.onSymlinkDirectoriesDiscovered?.(discovered, "git-candidates");
         return discovered;
     }
@@ -654,8 +745,7 @@ async function resolveSafeSymlinkDirectories(root, realRoot, ignore, options) {
         objectMode: true,
         ignore,
     }));
-    const candidates = await mapLimitSemaphore(entries.filter((entry) => entry.dirent.isSymbolicLink()).map((entry) => entry.path), REALPATH_FILTER_CONCURRENCY, async (linkPath) => ((await isSafeSymlinkDirectory(root, linkPath, realRoot)) ? linkPath : null));
-    const discovered = candidates.filter((entry) => entry !== null);
+    const discovered = await verifySafeSymlinkDirectories(root, realRoot, entries.filter((entry) => entry.dirent.isSymbolicLink()).map((entry) => entry.path), options.onPathCheckProgress);
     options.onSymlinkDirectoriesDiscovered?.(discovered, "filesystem");
     return discovered;
 }
@@ -690,7 +780,8 @@ async function listEntriesFromSafeSymlinkDirectories(root, realRoot, patterns, i
     }
     return [...filesByPath.values()];
 }
-async function filterRealPathsWithinRootEntries(paths, realRoot) {
+async function filterRealPathsWithinRootEntries(paths, realRoot, onPathCheckProgress) {
+    const reportPathCheck = createPathCheckProgressReporter(paths.length, onPathCheckProgress);
     const filtered = await mapLimitSemaphore(paths, REALPATH_FILTER_CONCURRENCY, async (filePath) => {
         try {
             const realPath = await fsp.realpath(filePath);
@@ -699,11 +790,14 @@ async function filterRealPathsWithinRootEntries(paths, realRoot) {
         catch {
             return null;
         }
+        finally {
+            reportPathCheck();
+        }
     });
     return filtered.filter((entry) => entry !== null);
 }
-export async function filterRealPathsWithinRoot(paths, realRoot) {
-    const entries = await filterRealPathsWithinRootEntries(paths, realRoot);
+export async function filterRealPathsWithinRoot(paths, realRoot, onPathCheckProgress) {
+    const entries = await filterRealPathsWithinRootEntries(paths, realRoot, onPathCheckProgress);
     return entries.map((entry) => entry.path);
 }
 function toProjectGlob(pattern) {
@@ -740,33 +834,115 @@ async function buildProjectFileInfo(def, filePath) {
     };
 }
 export async function discoverProjectFiles(projectRoot, options) {
+    return await discoverProjectFilesInternal(projectRoot, options);
+}
+export async function discoverProjectFilesWithGitCandidates(projectRoot, options) {
+    return await discoverProjectFilesInternal(projectRoot, options);
+}
+async function discoverProjectFilesInternal(projectRoot, options) {
     const root = await ensureDirectoryReadable(projectRoot, "Project root");
     try {
         const realRoot = await fsp.realpath(root);
-        const allPatterns = PROJECT_FILE_DEFINITIONS.flatMap((def) => def.patterns.map(toProjectGlob));
-        const matches = await fg(allPatterns, {
-            cwd: root,
-            absolute: true,
-            dot: true,
-            followSymbolicLinks: false,
-            ignore: DEFAULT_PROJECT_FILE_IGNORES,
-            markDirectories: true,
-            onlyFiles: false,
-        });
-        const linkedMatches = await listEntriesFromSafeSymlinkDirectories(root, realRoot, allPatterns, DEFAULT_PROJECT_FILE_IGNORES, {
-            markDirectories: true,
-            onlyFiles: false,
-            ...(options?.knownSymlinkDirectories !== undefined
-                ? { knownSymlinkDirectories: options.knownSymlinkDirectories }
-                : {}),
-            ...(options?.onSymlinkDirectoriesDiscovered
-                ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered }
-                : {}),
-        });
-        const rootSafeMatches = await filterRealPathsWithinRoot([...matches, ...linkedMatches].map((match) => (match.endsWith("/") ? match.slice(0, -1) : match)), realRoot);
         const projectFileDefinitionMatchers = PROJECT_FILE_DEFINITIONS.map((definition) => definition.patterns.map((pattern) => pattern.includes("*") || pattern.includes("?")
             ? new RegExp("^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$")
             : undefined));
+        const matchesDefinition = (fileName, definitionIndex) => {
+            const definition = PROJECT_FILE_DEFINITIONS[definitionIndex];
+            return definition.patterns.some((pattern, patternIndex) => {
+                const matcher = projectFileDefinitionMatchers[definitionIndex][patternIndex];
+                return matcher ? matcher.test(fileName) : pattern === fileName;
+            });
+        };
+        let gitCandidates;
+        if (options?.knownGitCandidates !== undefined) {
+            gitCandidates = options.knownGitCandidates;
+        }
+        else {
+            gitCandidates = await listGitCandidateFiles(root, options?.logLevel);
+        }
+        options?.onGitCandidatesDiscovered?.(gitCandidates);
+        const reportMetadataSymlinkChecks = options?.onDiscoveryProgress
+            ? (current, total) => options.onDiscoveryProgress?.({ activity: "Checking project metadata symlinks", current, total })
+            : undefined;
+        const reportMetadataFileChecks = options?.onDiscoveryProgress
+            ? (current, total) => options.onDiscoveryProgress?.({ activity: "Checking project metadata files", current, total })
+            : undefined;
+        const reportMetadataDirectoryChecks = options?.onDiscoveryProgress
+            ? (current, total) => options.onDiscoveryProgress?.({ activity: "Checking project metadata directories", current, total })
+            : undefined;
+        let rootSafeMatches;
+        if (gitCandidates) {
+            const gitignoreIndex = await buildGitignoreIndex(gitCandidates.gitignoreFiles, gitCandidates.gitignoreRoots, gitCandidates.gitignoreAliases);
+            const defaultIgnoreMatchers = DEFAULT_PROJECT_FILE_IGNORES.map((globPattern) => picomatch(globPattern, { dot: true }));
+            const filterGitIgnoredEntries = (entries, directoryKeys = new Set()) => entries
+                .map(({ path: filePath, realPath }) => ({ filePath: normalizePath(filePath), realPath }))
+                .filter(({ filePath, realPath }) => {
+                const isDirectory = directoryKeys.has(fileIdentityKey(filePath));
+                const rootRelative = normalizePath(path.relative(root, filePath));
+                if (!isRelativePathInside(rootRelative))
+                    return false;
+                if (defaultIgnoreMatchers.some((matcher) => matcher(rootRelative)))
+                    return false;
+                if (isIgnoredByGitignore(filePath, gitignoreIndex, isDirectory))
+                    return false;
+                return normalizePath(realPath) === filePath || !isIgnoredByGitignore(realPath, gitignoreIndex, isDirectory);
+            })
+                .map(({ filePath }) => filePath);
+            const symlinkOptions = {
+                candidatePaths: gitCandidates.files,
+                ...(options?.knownSymlinkDirectories !== undefined
+                    ? { knownSymlinkDirectories: options.knownSymlinkDirectories }
+                    : {}),
+                ...(options?.onSymlinkDirectoriesDiscovered
+                    ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered }
+                    : {}),
+                ...(reportMetadataSymlinkChecks ? { onPathCheckProgress: reportMetadataSymlinkChecks } : {}),
+            };
+            const safeSymlinkDirectories = await resolveSafeSymlinkDirectories(root, realRoot, DEFAULT_PROJECT_FILE_IGNORES, symlinkOptions);
+            const allPatterns = PROJECT_FILE_DEFINITIONS.flatMap((definition) => definition.patterns.map(toProjectGlob));
+            const linkedMatches = await listEntriesFromSafeSymlinkDirectories(root, realRoot, allPatterns, DEFAULT_PROJECT_FILE_IGNORES, {
+                markDirectories: true,
+                onlyFiles: false,
+                resolvedSafeSymlinkDirectories: safeSymlinkDirectories,
+            });
+            const rootSafeCandidateEntries = await filterRealPathsWithinRootEntries(gitCandidates.files, realRoot, reportMetadataFileChecks);
+            const filteredFiles = filterGitIgnoredEntries(rootSafeCandidateEntries);
+            const fileMatches = filteredFiles.filter((file) => PROJECT_FILE_DEFINITIONS.some((definition, definitionIndex) => definition.kind === "file" && matchesDefinition(path.basename(file), definitionIndex)));
+            const rawCandidateDirectories = collectCandidateAncestorDirectories(root, rootSafeCandidateEntries.map(({ path: filePath }) => filePath));
+            const candidateDirectoryKeys = new Set(rawCandidateDirectories.map(fileIdentityKey));
+            const safeSymlinkDirectoryKeys = new Set(safeSymlinkDirectories.map(fileIdentityKey));
+            const directoryMatches = [
+                ...filterGitIgnoredEntries(await filterRealPathsWithinRootEntries(rawCandidateDirectories, realRoot, reportMetadataDirectoryChecks), candidateDirectoryKeys),
+                ...filterGitIgnoredEntries(await filterRealPathsWithinRootEntries(safeSymlinkDirectories, realRoot, reportMetadataDirectoryChecks), safeSymlinkDirectoryKeys),
+            ].filter((directory) => PROJECT_FILE_DEFINITIONS.some((definition, definitionIndex) => definition.kind === "dir" && matchesDefinition(path.basename(directory), definitionIndex)));
+            const linkedDirectoryKeys = new Set(linkedMatches.filter((match) => match.endsWith("/")).map((match) => fileIdentityKey(match.slice(0, -1))));
+            const rootSafeLinked = filterGitIgnoredEntries(await filterRealPathsWithinRootEntries(linkedMatches.map((match) => (match.endsWith("/") ? match.slice(0, -1) : match)), realRoot, reportMetadataFileChecks), linkedDirectoryKeys);
+            rootSafeMatches = [...fileMatches, ...directoryMatches, ...rootSafeLinked];
+        }
+        else {
+            const allPatterns = PROJECT_FILE_DEFINITIONS.flatMap((definition) => definition.patterns.map(toProjectGlob));
+            const matches = await fg(allPatterns, {
+                cwd: root,
+                absolute: true,
+                dot: true,
+                followSymbolicLinks: false,
+                ignore: DEFAULT_PROJECT_FILE_IGNORES,
+                markDirectories: true,
+                onlyFiles: false,
+            });
+            const linkedMatches = await listEntriesFromSafeSymlinkDirectories(root, realRoot, allPatterns, DEFAULT_PROJECT_FILE_IGNORES, {
+                markDirectories: true,
+                onlyFiles: false,
+                ...(options?.knownSymlinkDirectories !== undefined
+                    ? { knownSymlinkDirectories: options.knownSymlinkDirectories }
+                    : {}),
+                ...(options?.onSymlinkDirectoriesDiscovered
+                    ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered }
+                    : {}),
+                ...(reportMetadataSymlinkChecks ? { onPathCheckProgress: reportMetadataSymlinkChecks } : {}),
+            });
+            rootSafeMatches = await filterRealPathsWithinRoot([...matches, ...linkedMatches].map((match) => (match.endsWith("/") ? match.slice(0, -1) : match)), realRoot, reportMetadataFileChecks);
+        }
         const entries = [];
         const matchTasks = rootSafeMatches.map(async (cleanMatch) => {
             const stats = await fsp.stat(cleanMatch);
@@ -778,10 +954,7 @@ export async function discoverProjectFiles(projectRoot, options) {
                     continue;
                 if (!isDir && def.kind !== "file")
                     continue;
-                const matchesPattern = def.patterns.some((pattern, patternIndex) => {
-                    const matcher = projectFileDefinitionMatchers[definitionIndex][patternIndex];
-                    return matcher ? matcher.test(fileName) : pattern === fileName;
-                });
+                const matchesPattern = matchesDefinition(fileName, definitionIndex);
                 if (matchesPattern) {
                     entries.push(await buildProjectFileInfo(def, cleanMatch));
                 }