gitnexus 1.6.10-rc.79 → 1.6.10-rc.80

package/README.md

@@ -511,9 +511,19 @@ For very large repositories:
 # Increase Node.js heap size
 NODE_OPTIONS="--max-old-space-size=16384" npx gitnexus analyze
 
-# Exclude large directories
+# Exclude large directories (this repo only)
 echo "vendor/" >> .gitnexusignore
 echo "dist/" >> .gitnexusignore
+
+# Exclude a directory across every repo you index, without touching each
+# repo's own .gitnexusignore or needing push/commit access to it. GitNexus
+# reads the same sources `git` itself does: core.excludesFile (all repos)
+# and $GIT_DIR/info/exclude (this repo only, untracked). A repo's own
+# .gitignore/.gitnexusignore can still override either with a `!pattern`
+# negation. Skip both entirely with GITNEXUS_NO_GLOBAL_IGNORE=1.
+git config --global core.excludesFile ~/.gitignore_global   # applies to every repo
+echo "docs/" >> ~/.gitignore_global
+echo "build/" >> .git/info/exclude                          # this repo only, untracked
 ```
 
 ### Large files are being skipped

package/dist/config/ignore-service.d.ts

@@ -10,6 +10,8 @@ export declare const isHardcodedIgnoredDirectory: (name: string) => boolean;
 export interface IgnoreOptions {
     /** Skip .gitignore parsing, only read .gitnexusignore. Defaults to GITNEXUS_NO_GITIGNORE env var. */
     noGitignore?: boolean;
+    /** Skip core.excludesFile and $GIT_COMMON_DIR/info/exclude. Defaults to GITNEXUS_NO_GLOBAL_IGNORE env var. */
+    noGlobalIgnore?: boolean;
 }
 export declare const loadIgnoreRules: (repoPath: string, options?: IgnoreOptions) => Promise<Ignore | null>;
 /**

package/dist/config/ignore-service.js

@@ -2,6 +2,7 @@ import ignore from 'ignore';
 import fs from 'fs/promises';
 import nodePath from 'path';
 import { logger } from '../core/logger.js';
+import { getCoreExcludesFilePath, getGitInfoExcludePath } from '../storage/git.js';
 const DEFAULT_IGNORE_LIST = new Set([
     // Version Control
     '.git',
@@ -312,6 +313,32 @@ export const isHardcodedIgnoredDirectory = (name) => {
 export const loadIgnoreRules = async (repoPath, options) => {
     const ig = ignore();
     let hasRules = false;
+    // Mirror git's own precedence for ignore sources (gitignore(5)): patterns
+    // from core.excludesFile are consulted first (lowest precedence — git's
+    // real global, all-repos file), then $GIT_COMMON_DIR/info/exclude
+    // (per-repo, untracked — no write access to the repo needed), then
+    // .gitignore/.gitnexusignore below. Later ig.add() calls win on
+    // conflicting patterns, matching git's own last-match-wins semantics (#2606).
+    const skipGlobalIgnore = options?.noGlobalIgnore ?? !!process.env.GITNEXUS_NO_GLOBAL_IGNORE;
+    if (!skipGlobalIgnore) {
+        const globalSources = [
+            getCoreExcludesFilePath(repoPath),
+            getGitInfoExcludePath(repoPath),
+        ].filter((candidate) => candidate !== null);
+        for (const sourcePath of globalSources) {
+            try {
+                const content = await fs.readFile(sourcePath, 'utf-8');
+                ig.add(content);
+                hasRules = true;
+            }
+            catch (err) {
+                const code = err.code;
+                if (code !== 'ENOENT') {
+                    logger.warn(`  Warning: could not read ${sourcePath}: ${err.message}`);
+                }
+            }
+        }
+    }
     // Allow users to bypass .gitignore parsing (e.g. when .gitignore accidentally excludes source files)
     const skipGitignore = options?.noGitignore ?? !!process.env.GITNEXUS_NO_GITIGNORE;
     const filenames = skipGitignore ? ['.gitnexusignore'] : ['.gitignore', '.gitnexusignore'];

package/dist/storage/git.d.ts

@@ -65,6 +65,28 @@ export declare const getGitRoot: (fromPath: string) => string | null;
  * path if the caller later resolved it from a different directory.
  */
 export declare const getCanonicalRepoRoot: (fromPath: string) => string | null;
+/**
+ * Path to the repo's `$GIT_COMMON_DIR/info/exclude` file — git's own
+ * per-repo, untracked exclude list (same tier as `.gitignore` in
+ * precedence, but never committed, so it works even when the caller has
+ * no write access to the repo's tracked content). Shared across every
+ * linked worktree of a repo, matching git's own resolution (#2606).
+ *
+ * Returns `null` when `fromPath` is not inside a git repository or `git`
+ * is unavailable; callers should treat that the same as "no file".
+ */
+export declare const getGitInfoExcludePath: (fromPath: string) => string | null;
+/**
+ * Path to git's own global, all-repos ignore file: the value of
+ * `core.excludesFile` (any config scope — system/global/local, resolved
+ * the same way `git` itself would from `fromPath`), or git's documented
+ * default of `$XDG_CONFIG_HOME/git/ignore` when unset (gitignore(5)).
+ * Lowest-precedence source, mirroring git's own behavior (#2606).
+ *
+ * Never throws: an unset key or unavailable `git` falls through to the
+ * default path, which is always computable without `git`.
+ */
+export declare const getCoreExcludesFilePath: (fromPath: string) => string;
 /**
  * Resolve `fromPath` to the directory whose basename should drive the
  * registry name (#1259) — the *identity root*. Three outcomes:

package/dist/storage/git.js

@@ -1,6 +1,7 @@
 import { execFileSync, execSync } from 'child_process';
 import { statSync } from 'fs';
 import path from 'path';
+import os from 'os';
 // Git utilities for repository detection, commit tracking, and diff analysis
 const chompGitOutput = (value) => value.toString().replace(/\r?\n$/, '');
 /**
@@ -198,6 +199,80 @@ export const getCanonicalRepoRoot = (fromPath) => {
         return null;
     }
 };
+// getGitInfoExcludePath/getCoreExcludesFilePath are called once per repo
+// PER language/contract extractor during group sync (#2606) — an N-repo
+// group fans out to 6+ extractors each calling these, so an uncached
+// execSync per call turns into O(extractors × repos) blocking subprocess
+// spawns. Both resolve to the same value for the same fromPath for the
+// life of the process (git config/exclude files don't change mid-run), so
+// memoize by fromPath. ponytail: process-lifetime cache, never invalidated
+// — fine for one-shot CLI runs; the long-lived MCP server would need a
+// TTL or explicit invalidation if a user edits core.excludesFile mid-session.
+const gitInfoExcludePathCache = new Map();
+const coreExcludesFilePathCache = new Map();
+/**
+ * Path to the repo's `$GIT_COMMON_DIR/info/exclude` file — git's own
+ * per-repo, untracked exclude list (same tier as `.gitignore` in
+ * precedence, but never committed, so it works even when the caller has
+ * no write access to the repo's tracked content). Shared across every
+ * linked worktree of a repo, matching git's own resolution (#2606).
+ *
+ * Returns `null` when `fromPath` is not inside a git repository or `git`
+ * is unavailable; callers should treat that the same as "no file".
+ */
+export const getGitInfoExcludePath = (fromPath) => {
+    const cached = gitInfoExcludePathCache.get(fromPath);
+    if (cached !== undefined)
+        return cached;
+    let result;
+    try {
+        const commonDir = chompGitOutput(execSync('git rev-parse --path-format=absolute --git-common-dir', {
+            cwd: fromPath,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        }));
+        result = commonDir ? path.join(path.resolve(commonDir), 'info', 'exclude') : null;
+    }
+    catch {
+        result = null;
+    }
+    gitInfoExcludePathCache.set(fromPath, result);
+    return result;
+};
+/**
+ * Path to git's own global, all-repos ignore file: the value of
+ * `core.excludesFile` (any config scope — system/global/local, resolved
+ * the same way `git` itself would from `fromPath`), or git's documented
+ * default of `$XDG_CONFIG_HOME/git/ignore` when unset (gitignore(5)).
+ * Lowest-precedence source, mirroring git's own behavior (#2606).
+ *
+ * Never throws: an unset key or unavailable `git` falls through to the
+ * default path, which is always computable without `git`.
+ */
+export const getCoreExcludesFilePath = (fromPath) => {
+    const cached = coreExcludesFilePathCache.get(fromPath);
+    if (cached !== undefined)
+        return cached;
+    let result;
+    try {
+        const configured = chompGitOutput(execSync('git config --get --type=path core.excludesFile', {
+            cwd: fromPath,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        }));
+        if (configured)
+            result = configured;
+    }
+    catch {
+        // Unset, or git unavailable — fall through to git's documented default.
+    }
+    if (!result) {
+        const xdgConfigHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+        result = path.join(xdgConfigHome, 'git', 'ignore');
+    }
+    coreExcludesFilePathCache.set(fromPath, result);
+    return result;
+};
 /**
  * Resolve `fromPath` to the directory whose basename should drive the
  * registry name (#1259) — the *identity root*. Three outcomes:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.10-rc.79",
+  "version": "1.6.10-rc.80",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",