gitnexus 1.6.4-rc.38 → 1.6.4-rc.39

package/dist/cli/index-repo.js

@@ -10,7 +10,7 @@
  */
 import path from 'path';
 import fs from 'fs/promises';
-import { getStoragePaths, loadMeta, addToGitignore, registerRepo, } from '../storage/repo-manager.js';
+import { getStoragePaths, loadMeta, ensureGitNexusIgnored, registerRepo, } from '../storage/repo-manager.js';
 import { getGitRoot, getRemoteUrl, isGitRepo } from '../storage/git.js';
 export const indexCommand = async (inputPathParts, options) => {
     console.log('\n  GitNexus Index\n');
@@ -96,7 +96,7 @@ export const indexCommand = async (inputPathParts, options) => {
         meta.remoteUrl = getRemoteUrl(repoPath);
     }
     await registerRepo(repoPath, meta);
-    await addToGitignore(repoPath);
+    await ensureGitNexusIgnored(repoPath);
     const projectName = path.basename(repoPath);
     const { stats } = meta;
     console.log(`  Repository registered: ${projectName}`);

package/dist/core/group/extractors/grpc-extractor.js

@@ -1,6 +1,7 @@
 import * as path from 'node:path';
 import { glob } from 'glob';
 import Parser from 'tree-sitter';
+import { createIgnoreFilter } from '../../../config/ignore-service.js';
 import { readSafe } from './fs-utils.js';
 import { GRPC_SCAN_GLOB, getPluginForFile, hasProtoPlugin, } from './grpc-patterns/index.js';
 /**
@@ -185,11 +186,16 @@ function longestSharedSegmentRun(aPath, bPath) {
 }
 async function buildProtoContext(repoPath) {
     const servicesByName = new Map();
+    // `.gitnexusignore` / `.gitignore` honoured via the shared IgnoreService —
+    // see `filesystem-walker.ts` for the canonical pattern. Replaces a
+    // hardcoded `[node_modules, .git, vendor]` array; those names plus the
+    // rest of `DEFAULT_IGNORE_LIST` are still excluded by default (#1185).
+    const protoIgnoreFilter = await createIgnoreFilter(repoPath);
     const protoFiles = await glob('**/*.proto', {
         cwd: repoPath,
         absolute: false,
         nodir: true,
-        ignore: ['**/node_modules/**', '**/.git/**', '**/vendor/**'],
+        ignore: protoIgnoreFilter,
     });
     const contents = new Map();
     for (const rel of protoFiles) {
@@ -324,9 +330,14 @@ export class GrpcExtractor {
             }
         }
         // ─── Source files (+ .proto when plugin available) ────────────
+        // Honour `.gitnexusignore` / `.gitignore` via the shared IgnoreService —
+        // mirrors `filesystem-walker.ts`. Replaces a hardcoded
+        // `[node_modules, .git, vendor, dist, build]` array; those names are all
+        // in `DEFAULT_IGNORE_LIST`, so default behaviour is preserved (#1185).
+        const sourceIgnoreFilter = await createIgnoreFilter(repoPath);
         const sourceFiles = await glob(GRPC_SCAN_GLOB, {
             cwd: repoPath,
-            ignore: ['**/node_modules/**', '**/.git/**', '**/vendor/**', '**/dist/**', '**/build/**'],
+            ignore: sourceIgnoreFilter,
             nodir: true,
         });
         const parser = new Parser();

package/dist/core/group/extractors/http-route-extractor.js

@@ -1,6 +1,7 @@
 import * as path from 'node:path';
 import { glob } from 'glob';
 import Parser from 'tree-sitter';
+import { createIgnoreFilter } from '../../../config/ignore-service.js';
 import { readSafe } from './fs-utils.js';
 import { getPluginForFile, HTTP_SCAN_GLOB } from './http-patterns/index.js';
 /**
@@ -183,9 +184,16 @@ export class HttpRouteExtractor {
         return [...providers, ...consumers];
     }
     async scanFiles(repoPath) {
+        // Honour `.gitnexusignore` and `.gitignore` via the shared IgnoreService
+        // so contract extraction respects the same exclusion rules as the rest of
+        // the ingestion pipeline. Mirrors `filesystem-walker.ts` which uses the
+        // same shape. Replaces a hardcoded `[node_modules, .git, dist, build,
+        // vendor]` array — those names are still in `DEFAULT_IGNORE_LIST`, so
+        // default behaviour is preserved (#1185).
+        const ignoreFilter = await createIgnoreFilter(repoPath);
         return glob(HTTP_SCAN_GLOB, {
             cwd: repoPath,
-            ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**', '**/vendor/**'],
+            ignore: ignoreFilter,
             nodir: true,
         });
     }

package/dist/core/group/extractors/topic-extractor.js

@@ -1,5 +1,6 @@
 import { glob } from 'glob';
 import Parser from 'tree-sitter';
+import { createIgnoreFilter } from '../../../config/ignore-service.js';
 import { readSafe } from './fs-utils.js';
 import { scanFile, unquoteLiteral } from './tree-sitter-scanner.js';
 import { TOPIC_SCAN_GLOB, getProviderForFile, } from './topic-patterns/index.js';
@@ -40,22 +41,21 @@ export class TopicExtractor {
         return true;
     }
     async extract(_dbExecutor, repoPath, _repo) {
+        // Honour `.gitnexusignore` / `.gitignore` via the shared IgnoreService —
+        // mirrors `filesystem-walker.ts`. The 5-name hardcoded list
+        // (`node_modules, .git, vendor, dist, build`) is preserved because every
+        // entry is in `DEFAULT_IGNORE_LIST`, so default behaviour is unchanged
+        // (#1185). The Go-specific `**/*_test.go` filter is layered on top via a
+        // small wrapper so glob-level pruning is preserved (we never read those
+        // files); the wrapper short-circuits before calling the base filter.
+        const baseFilter = await createIgnoreFilter(repoPath);
+        const ignoreFilter = {
+            ignored: (p) => p.relative().endsWith('_test.go') || baseFilter.ignored(p),
+            childrenIgnored: (p) => baseFilter.childrenIgnored(p),
+        };
         const files = await glob(TOPIC_SCAN_GLOB, {
             cwd: repoPath,
-            ignore: [
-                '**/node_modules/**',
-                '**/.git/**',
-                '**/vendor/**',
-                '**/dist/**',
-                '**/build/**',
-                // Language-level test file conventions. Go test files
-                // `*_test.go` live next to source; other languages either use
-                // separate test directories (Python's `tests/`, Java's
-                // `src/test/`) or are already covered by the dist/build ignores.
-                // Pushed to the glob level so the orchestrator stays
-                // language-agnostic.
-                '**/*_test.go',
-            ],
+            ignore: ignoreFilter,
             nodir: true,
         });
         // One parser reused across files; the scanner calls `setLanguage` per

package/dist/core/run-analyze.js

@@ -13,7 +13,7 @@ import fs from 'fs/promises';
 import { runPipelineFromRepo } from './ingestion/pipeline.js';
 import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, loadCachedEmbeddings, } from './lbug/lbug-adapter.js';
 import { createSearchFTSIndexes } from './search/fts-indexes.js';
-import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, cleanupOldKuzuFiles, } from '../storage/repo-manager.js';
+import { getStoragePaths, saveMeta, loadMeta, ensureGitNexusIgnored, registerRepo, cleanupOldKuzuFiles, } from '../storage/repo-manager.js';
 import { getCurrentCommit, getRemoteUrl, hasGitDir, getInferredRepoName } from '../storage/git.js';
 import { generateAIContextFiles } from '../cli/ai-context.js';
 import { EMBEDDING_TABLE_NAME } from './lbug/schema.js';
@@ -69,6 +69,7 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
     if (existingMeta && !options.force && existingMeta.lastCommit === currentCommit) {
         // Non-git folders have currentCommit = '' — always rebuild since we can't detect changes
         if (currentCommit !== '') {
+            await ensureGitNexusIgnored(repoPath);
             return {
                 repoName: options.registryName ?? getInferredRepoName(repoPath) ?? path.basename(repoPath),
                 repoPath,
@@ -302,10 +303,8 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
             name: options.registryName,
             allowDuplicateName: options.allowDuplicateName,
         });
-        // Only attempt to update .gitignore when a .git directory is present.
-        if (hasGitDir(repoPath)) {
-            await addToGitignore(repoPath);
-        }
+        // Keep generated .gitnexus contents ignored without editing the user's root .gitignore.
+        await ensureGitNexusIgnored(repoPath);
         // ── Generate AI context files (best-effort) ───────────────────────
         let aggregatedClusterCount = 0;
         if (pipelineResult.communityResult?.communities) {

package/dist/storage/repo-manager.d.ts

@@ -128,9 +128,9 @@ export declare const loadRepo: (repoPath: string) => Promise<IndexedRepo | null>
  */
 export declare const findRepo: (startPath: string) => Promise<IndexedRepo | null>;
 /**
- * Add .gitnexus to .gitignore if not already present
+ * Keep generated index files ignored without modifying the user's root .gitignore.
  */
-export declare const addToGitignore: (repoPath: string) => Promise<void>;
+export declare const ensureGitNexusIgnored: (repoPath: string) => Promise<void>;
 /**
  * Get the path to the global GitNexus directory
  */

package/dist/storage/repo-manager.js

@@ -50,6 +50,7 @@ export const canonicalizePath = (p) => {
     }
 };
 const GITNEXUS_DIR = '.gitnexus';
+const GITNEXUS_EXCLUDE_ENTRY = `${GITNEXUS_DIR}/`;
 // ─── Local Storage Helpers ─────────────────────────────────────────────
 /**
  * Get the .gitnexus storage path for a repository
@@ -185,23 +186,42 @@ export const findRepo = async (startPath) => {
     return null;
 };
 /**
- * Add .gitnexus to .gitignore if not already present
+ * Keep generated index files ignored without modifying the user's root .gitignore.
  */
-export const addToGitignore = async (repoPath) => {
-    const gitignorePath = path.join(repoPath, '.gitignore');
+export const ensureGitNexusIgnored = async (repoPath) => {
+    const gitignorePath = path.join(getStoragePath(repoPath), '.gitignore');
+    await fs.mkdir(path.dirname(gitignorePath), { recursive: true });
+    await fs.writeFile(gitignorePath, '*\n', 'utf-8');
+    await ensureGitInfoExclude(repoPath);
+};
+const ensureGitInfoExclude = async (repoPath) => {
+    const gitDirPath = path.join(path.resolve(repoPath), '.git');
+    const excludePath = path.join(gitDirPath, 'info', 'exclude');
     try {
-        const content = await fs.readFile(gitignorePath, 'utf-8');
-        if (content.includes(GITNEXUS_DIR))
+        const gitDir = await fs.stat(gitDirPath);
+        if (!gitDir.isDirectory())
             return;
-        const newContent = content.endsWith('\n')
-            ? `${content}${GITNEXUS_DIR}\n`
-            : `${content}\n${GITNEXUS_DIR}\n`;
-        await fs.writeFile(gitignorePath, newContent, 'utf-8');
     }
     catch {
-        // .gitignore doesn't exist, create it
-        await fs.writeFile(gitignorePath, `${GITNEXUS_DIR}\n`, 'utf-8');
+        return;
     }
+    await fs.mkdir(path.dirname(excludePath), { recursive: true });
+    let content = '';
+    try {
+        content = await fs.readFile(excludePath, 'utf-8');
+    }
+    catch (err) {
+        if (err?.code !== 'ENOENT')
+            throw err;
+    }
+    const excludes = content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('#'));
+    if (excludes.includes(GITNEXUS_DIR) || excludes.includes(GITNEXUS_EXCLUDE_ENTRY))
+        return;
+    const separator = content.length === 0 || content.endsWith('\n') ? '' : '\n';
+    await fs.writeFile(excludePath, `${content}${separator}${GITNEXUS_EXCLUDE_ENTRY}\n`, 'utf-8');
 };
 // ─── Global Registry (~/.gitnexus/registry.json) ───────────────────────
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.4-rc.38",
+  "version": "1.6.4-rc.39",
   "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",