gitnexus 1.4.0 → 1.4.5

package/README.md

@@ -96,7 +96,7 @@ GitNexus builds a complete knowledge graph of your codebase through a multi-phas
 5. **Processes** — Traces execution flows from entry points through call chains
 6. **Search** — Builds hybrid search indexes for fast retrieval
 
-The result is a **KuzuDB graph database** stored locally in `.gitnexus/` with full-text search and semantic embeddings.
+The result is a **LadybugDB graph database** stored locally in `.gitnexus/` with full-text search and semantic embeddings.
 
 ## MCP Tools
 
@@ -157,26 +157,27 @@ GitNexus supports indexing multiple repositories. Each `gitnexus analyze` regist
 
 ## Supported Languages
 
-TypeScript, JavaScript, Python, Java, C, C++, C#, Go, Rust, PHP, Kotlin, Swift
+TypeScript, JavaScript, Python, Java, C, C++, C#, Go, Rust, PHP, Kotlin, Swift, Ruby
 
 ### Language Feature Matrix
 
-| Language | Imports | Types | Exports | Named Bindings | Config | Frameworks | Entry Points | Heritage |
-|----------|---------|-------|---------|----------------|--------|------------|-------------|----------|
-| TypeScript | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
-| JavaScript | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
-| Python | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
-| C# | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
-| Java | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ |
-| Kotlin | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ |
-| Go | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ | ✓ |
-| Rust | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ |
-| PHP | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — |
-| Swift | — | ✓ | ✓ | — | ✓ | ✓ | ✓ | ✓ |
-| C | — | ✓ | ✓ | — | — | ✓ | ✓ | ✓ |
-| C++ | — | ✓ | ✓ | — | — | ✓ | ✓ | ✓ |
-
-**Imports** — cross-file import resolution · **Types** — type annotation extraction · **Exports** — public/exported symbol detection · **Named Bindings** — `import { X }` tracking · **Config** — language toolchain config parsing (tsconfig, go.mod, etc.) · **Frameworks** — AST-based framework pattern detection · **Entry Points** — entry point scoring heuristics · **Heritage** — class inheritance / interface implementation
+| Language | Imports | Named Bindings | Exports | Heritage | Type Annotations | Constructor Inference | Config | Frameworks | Entry Points |
+|----------|---------|----------------|---------|----------|-----------------|---------------------|--------|------------|-------------|
+| TypeScript | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+| JavaScript | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ | ✓ |
+| Python | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+| Java | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
+| Kotlin | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
+| C# | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+| Go | ✓ | — | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+| Rust | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
+| PHP | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ | ✓ | ✓ |
+| Ruby | ✓ | — | ✓ | ✓ | — | ✓ | — | ✓ | ✓ |
+| Swift | — | — | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+| C | — | — | ✓ | — | ✓ | ✓ | — | ✓ | ✓ |
+| C++ | — | — | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
+
+**Imports** — cross-file import resolution · **Named Bindings** — `import { X as Y }` / re-export tracking · **Exports** — public/exported symbol detection · **Heritage** — class inheritance, interfaces, mixins · **Type Annotations** — explicit type extraction for receiver resolution · **Constructor Inference** — infer receiver type from constructor calls (`self`/`this` resolution included for all languages) · **Config** — language toolchain config parsing (tsconfig, go.mod, etc.) · **Frameworks** — AST-based framework pattern detection · **Entry Points** — entry point scoring heuristics
 
 ## Agent Skills
 

package/dist/cli/analyze.js

@@ -8,12 +8,12 @@ import { execFileSync } from 'child_process';
 import v8 from 'v8';
 import cliProgress from 'cli-progress';
 import { runPipelineFromRepo } from '../core/ingestion/pipeline.js';
-import { initKuzu, loadGraphToKuzu, getKuzuStats, executeQuery, executeWithReusedStatement, closeKuzu, createFTSIndex, loadCachedEmbeddings } from '../core/kuzu/kuzu-adapter.js';
+import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, createFTSIndex, loadCachedEmbeddings } from '../core/lbug/lbug-adapter.js';
 // Embedding imports are lazy (dynamic import) so onnxruntime-node is never
 // loaded when embeddings are not requested. This avoids crashes on Node
 // versions whose ABI is not yet supported by the native binary (#89).
 // disposeEmbedder intentionally not called — ONNX Runtime segfaults on cleanup (see #38)
-import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, getGlobalRegistryPath } from '../storage/repo-manager.js';
+import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, getGlobalRegistryPath, cleanupOldKuzuFiles } from '../storage/repo-manager.js';
 import { getCurrentCommit, isGitRepo, getGitRoot } from '../storage/git.js';
 import { generateAIContextFiles } from './ai-context.js';
 import { generateSkillFiles } from './skill-gen.js';
@@ -51,7 +51,7 @@ const PHASE_LABELS = {
     communities: 'Detecting communities',
     processes: 'Detecting processes',
     complete: 'Pipeline complete',
-    kuzu: 'Loading into KuzuDB',
+    lbug: 'Loading into LadybugDB',
     fts: 'Creating search indexes',
     embeddings: 'Generating embeddings',
     done: 'Done',
@@ -81,13 +81,22 @@ export const analyzeCommand = async (inputPath, options) => {
         process.exitCode = 1;
         return;
     }
-    const { storagePath, kuzuPath } = getStoragePaths(repoPath);
+    const { storagePath, lbugPath } = getStoragePaths(repoPath);
+    // Clean up stale KuzuDB files from before the LadybugDB migration.
+    // If kuzu existed but lbug doesn't, we're doing a migration re-index — say so.
+    const kuzuResult = await cleanupOldKuzuFiles(storagePath);
+    if (kuzuResult.found && kuzuResult.needsReindex) {
+        console.log('  Migrating from KuzuDB to LadybugDB — rebuilding index...\n');
+    }
     const currentCommit = getCurrentCommit(repoPath);
     const existingMeta = await loadMeta(storagePath);
     if (existingMeta && !options?.force && !options?.skills && existingMeta.lastCommit === currentCommit) {
         console.log('  Already up to date\n');
         return;
     }
+    if (process.env.GITNEXUS_NO_GITIGNORE) {
+        console.log('  GITNEXUS_NO_GITIGNORE is set — skipping .gitignore (still reading .gitnexusignore)\n');
+    }
     // Single progress bar for entire pipeline
     const bar = new cliProgress.SingleBar({
         format: '  {bar} {percentage}% | {phase}',
@@ -108,7 +117,7 @@ export const analyzeCommand = async (inputPath, options) => {
         aborted = true;
         bar.stop();
         console.log('\n  Interrupted — cleaning up...');
-        closeKuzu().catch(() => { }).finally(() => process.exit(130));
+        closeLbug().catch(() => { }).finally(() => process.exit(130));
     };
     process.on('SIGINT', sigintHandler);
     // Route all console output through bar.log() so the bar doesn't stamp itself
@@ -154,15 +163,15 @@ export const analyzeCommand = async (inputPath, options) => {
     if (options?.embeddings && existingMeta && !options?.force) {
         try {
             updateBar(0, 'Caching embeddings...');
-            await initKuzu(kuzuPath);
+            await initLbug(lbugPath);
             const cached = await loadCachedEmbeddings();
             cachedEmbeddingNodeIds = cached.embeddingNodeIds;
             cachedEmbeddings = cached.embeddings;
-            await closeKuzu();
+            await closeLbug();
         }
         catch {
             try {
-                await closeKuzu();
+                await closeLbug();
             }
             catch { }
         }
@@ -173,26 +182,26 @@ export const analyzeCommand = async (inputPath, options) => {
         const scaled = Math.round(progress.percent * 0.6);
         updateBar(scaled, phaseLabel);
     });
-    // ── Phase 2: KuzuDB (60–85%) ──────────────────────────────────────
-    updateBar(60, 'Loading into KuzuDB...');
-    await closeKuzu();
-    const kuzuFiles = [kuzuPath, `${kuzuPath}.wal`, `${kuzuPath}.lock`];
-    for (const f of kuzuFiles) {
+    // ── Phase 2: LadybugDB (60–85%) ──────────────────────────────────────
+    updateBar(60, 'Loading into LadybugDB...');
+    await closeLbug();
+    const lbugFiles = [lbugPath, `${lbugPath}.wal`, `${lbugPath}.lock`];
+    for (const f of lbugFiles) {
         try {
             await fs.rm(f, { recursive: true, force: true });
         }
         catch { }
     }
-    const t0Kuzu = Date.now();
-    await initKuzu(kuzuPath);
-    let kuzuMsgCount = 0;
-    const kuzuResult = await loadGraphToKuzu(pipelineResult.graph, pipelineResult.repoPath, storagePath, (msg) => {
-        kuzuMsgCount++;
-        const progress = Math.min(84, 60 + Math.round((kuzuMsgCount / (kuzuMsgCount + 10)) * 24));
+    const t0Lbug = Date.now();
+    await initLbug(lbugPath);
+    let lbugMsgCount = 0;
+    const lbugResult = await loadGraphToLbug(pipelineResult.graph, pipelineResult.repoPath, storagePath, (msg) => {
+        lbugMsgCount++;
+        const progress = Math.min(84, 60 + Math.round((lbugMsgCount / (lbugMsgCount + 10)) * 24));
         updateBar(progress, msg);
     });
-    const kuzuTime = ((Date.now() - t0Kuzu) / 1000).toFixed(1);
-    const kuzuWarnings = kuzuResult.warnings;
+    const lbugTime = ((Date.now() - t0Lbug) / 1000).toFixed(1);
+    const lbugWarnings = lbugResult.warnings;
     // ── Phase 3: FTS (85–90%) ─────────────────────────────────────────
     updateBar(85, 'Creating search indexes...');
     const t0Fts = Date.now();
@@ -221,7 +230,7 @@ export const analyzeCommand = async (inputPath, options) => {
         }
     }
     // ── Phase 4: Embeddings (90–98%) ──────────────────────────────────
-    const stats = await getKuzuStats();
+    const stats = await getLbugStats();
     let embeddingTime = '0.0';
     let embeddingSkipped = true;
     let embeddingSkipReason = 'off (use --embeddings to enable)';
@@ -293,7 +302,7 @@ export const analyzeCommand = async (inputPath, options) => {
         clusters: aggregatedClusterCount,
         processes: pipelineResult.processResult?.stats.totalProcesses,
     }, generatedSkills);
-    await closeKuzu();
+    await closeLbug();
     // Note: we intentionally do NOT call disposeEmbedder() here.
     // ONNX Runtime's native cleanup segfaults on macOS and some Linux configs.
     // Since the process exits immediately after, Node.js reclaims everything.
@@ -309,18 +318,18 @@ export const analyzeCommand = async (inputPath, options) => {
     const embeddingsCached = cachedEmbeddings.length > 0;
     console.log(`\n  Repository indexed successfully (${totalTime}s)${embeddingsCached ? ` [${cachedEmbeddings.length} embeddings cached]` : ''}\n`);
     console.log(`  ${stats.nodes.toLocaleString()} nodes | ${stats.edges.toLocaleString()} edges | ${pipelineResult.communityResult?.stats.totalCommunities || 0} clusters | ${pipelineResult.processResult?.stats.totalProcesses || 0} flows`);
-    console.log(`  KuzuDB ${kuzuTime}s | FTS ${ftsTime}s | Embeddings ${embeddingSkipped ? embeddingSkipReason : embeddingTime + 's'}`);
+    console.log(`  LadybugDB ${lbugTime}s | FTS ${ftsTime}s | Embeddings ${embeddingSkipped ? embeddingSkipReason : embeddingTime + 's'}`);
     console.log(`  ${repoPath}`);
     if (aiContext.files.length > 0) {
         console.log(`  Context: ${aiContext.files.join(', ')}`);
     }
     // Show a quiet summary if some edge types needed fallback insertion
-    if (kuzuWarnings.length > 0) {
-        const totalFallback = kuzuWarnings.reduce((sum, w) => {
+    if (lbugWarnings.length > 0) {
+        const totalFallback = lbugWarnings.reduce((sum, w) => {
             const m = w.match(/\((\d+) edges\)/);
             return sum + (m ? parseInt(m[1]) : 0);
         }, 0);
-        console.log(`  Note: ${totalFallback} edges across ${kuzuWarnings.length} types inserted via fallback (schema will be updated in next release)`);
+        console.log(`  Note: ${totalFallback} edges across ${lbugWarnings.length} types inserted via fallback (schema will be updated in next release)`);
     }
     try {
         await fs.access(getGlobalRegistryPath());
@@ -329,7 +338,7 @@ export const analyzeCommand = async (inputPath, options) => {
         console.log('\n  Tip: Run `gitnexus setup` to configure MCP for your editor.');
     }
     console.log('');
-    // KuzuDB's native module holds open handles that prevent Node from exiting.
+    // LadybugDB's native module holds open handles that prevent Node from exiting.
     // ONNX Runtime also registers native atexit hooks that segfault on some
     // platforms (#38, #40). Force-exit to ensure clean termination.
     process.exit(0);

package/dist/cli/augment.js

@@ -19,7 +19,7 @@ export async function augmentCommand(pattern) {
         const result = await augment(pattern, process.cwd());
         if (result) {
             // IMPORTANT: Write to stderr, NOT stdout.
-            // KuzuDB's native module captures stdout fd at OS level during init,
+            // LadybugDB's native module captures stdout fd at OS level during init,
             // which makes stdout permanently broken in subprocess contexts.
             // stderr is never captured, so it works reliably everywhere.
             // The hook reads from the subprocess's stderr.

package/dist/cli/eval-server.d.ts

@@ -1,7 +1,7 @@
 /**
  * Eval Server — Lightweight HTTP server for SWE-bench evaluation
  *
- * Keeps KuzuDB warm in memory so tool calls from the agent are near-instant.
+ * Keeps LadybugDB warm in memory so tool calls from the agent are near-instant.
  * Designed to run inside Docker containers during SWE-bench evaluation.
  *
  * KEY DESIGN: Returns LLM-friendly text, not raw JSON.

package/dist/cli/eval-server.js

@@ -1,7 +1,7 @@
 /**
  * Eval Server — Lightweight HTTP server for SWE-bench evaluation
  *
- * Keeps KuzuDB warm in memory so tool calls from the agent are near-instant.
+ * Keeps LadybugDB warm in memory so tool calls from the agent are near-instant.
  * Designed to run inside Docker containers during SWE-bench evaluation.
  *
  * KEY DESIGN: Returns LLM-friendly text, not raw JSON.

package/dist/cli/index.js

@@ -22,6 +22,7 @@ program
     .option('--embeddings', 'Enable embedding generation for semantic search (off by default)')
     .option('--skills', 'Generate repo-specific skill files from detected communities')
     .option('-v, --verbose', 'Enable verbose ingestion warnings (default: false)')
+    .addHelpText('after', '\nEnvironment variables:\n  GITNEXUS_NO_GITIGNORE=1  Skip .gitignore parsing (still reads .gitnexusignore)')
     .action(createLazyAction(() => import('./analyze.js'), 'analyzeCommand'));
 program
     .command('serve')

package/dist/cli/mcp.js

@@ -9,7 +9,7 @@ import { startMCPServer } from '../mcp/server.js';
 import { LocalBackend } from '../mcp/local/local-backend.js';
 export const mcpCommand = async () => {
     // Prevent unhandled errors from crashing the MCP server process.
-    // KuzuDB lock conflicts and transient errors should degrade gracefully.
+    // LadybugDB lock conflicts and transient errors should degrade gracefully.
     process.on('uncaughtException', (err) => {
         console.error(`GitNexus MCP: uncaught exception — ${err.message}`);
         // Process is in an undefined state after uncaughtException — exit after flushing

package/dist/cli/setup.js

@@ -9,6 +9,7 @@ import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
 import { fileURLToPath } from 'url';
+import { glob } from 'glob';
 import { getGlobalDir } from '../storage/repo-manager.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -201,7 +202,6 @@ async function setupOpenCode(result) {
     }
 }
 // ─── Skill Installation ───────────────────────────────────────────
-const SKILL_NAMES = ['gitnexus-exploring', 'gitnexus-debugging', 'gitnexus-impact-analysis', 'gitnexus-refactoring', 'gitnexus-guide', 'gitnexus-cli'];
 /**
  * Install GitNexus skills to a target directory.
  * Each skill is installed as {targetDir}/gitnexus-{skillName}/SKILL.md
@@ -214,24 +214,36 @@ const SKILL_NAMES = ['gitnexus-exploring', 'gitnexus-debugging', 'gitnexus-impac
 async function installSkillsTo(targetDir) {
     const installed = [];
     const skillsRoot = path.join(__dirname, '..', '..', 'skills');
-    for (const skillName of SKILL_NAMES) {
+    let flatFiles = [];
+    let dirSkillFiles = [];
+    try {
+        [flatFiles, dirSkillFiles] = await Promise.all([
+            glob('*.md', { cwd: skillsRoot }),
+            glob('*/SKILL.md', { cwd: skillsRoot }),
+        ]);
+    }
+    catch {
+        return [];
+    }
+    const skillSources = new Map();
+    for (const relPath of dirSkillFiles) {
+        skillSources.set(path.dirname(relPath), { isDirectory: true });
+    }
+    for (const relPath of flatFiles) {
+        const skillName = path.basename(relPath, '.md');
+        if (!skillSources.has(skillName)) {
+            skillSources.set(skillName, { isDirectory: false });
+        }
+    }
+    for (const [skillName, source] of skillSources) {
         const skillDir = path.join(targetDir, skillName);
         try {
-            // Try directory-based skill first (skills/{name}/SKILL.md)
-            const dirSource = path.join(skillsRoot, skillName);
-            const dirSkillFile = path.join(dirSource, 'SKILL.md');
-            let isDirectory = false;
-            try {
-                const stat = await fs.stat(dirSource);
-                isDirectory = stat.isDirectory();
-            }
-            catch { /* not a directory */ }
-            if (isDirectory) {
+            if (source.isDirectory) {
+                const dirSource = path.join(skillsRoot, skillName);
                 await copyDirRecursive(dirSource, skillDir);
                 installed.push(skillName);
             }
             else {
-                // Fall back to flat file (skills/{name}.md)
                 const flatSource = path.join(skillsRoot, `${skillName}.md`);
                 const content = await fs.readFile(flatSource, 'utf-8');
                 await fs.mkdir(skillDir, { recursive: true });

package/dist/cli/status.js

@@ -3,8 +3,8 @@
  *
  * Shows the indexing status of the current repository.
  */
-import { findRepo } from '../storage/repo-manager.js';
-import { getCurrentCommit, isGitRepo } from '../storage/git.js';
+import { findRepo, getStoragePaths, hasKuzuIndex } from '../storage/repo-manager.js';
+import { getCurrentCommit, isGitRepo, getGitRoot } from '../storage/git.js';
 export const statusCommand = async () => {
     const cwd = process.cwd();
     if (!isGitRepo(cwd)) {
@@ -13,8 +13,17 @@ export const statusCommand = async () => {
     }
     const repo = await findRepo(cwd);
     if (!repo) {
-        console.log('Repository not indexed.');
-        console.log('Run: gitnexus analyze');
+        // Check if there's a stale KuzuDB index that needs migration
+        const repoRoot = getGitRoot(cwd) ?? cwd;
+        const { storagePath } = getStoragePaths(repoRoot);
+        if (await hasKuzuIndex(storagePath)) {
+            console.log('Repository has a stale KuzuDB index from a previous version.');
+            console.log('Run: gitnexus analyze   (rebuilds the index with LadybugDB)');
+        }
+        else {
+            console.log('Repository not indexed.');
+            console.log('Run: gitnexus analyze');
+        }
         return;
     }
     const currentCommit = getCurrentCommit(repo.repoPath);

package/dist/cli/tool.d.ts

@@ -10,7 +10,7 @@
  *   gitnexus impact --target "AuthService" --direction upstream
  *   gitnexus cypher "MATCH (n:Function) RETURN n.name LIMIT 10"
  *
- * Note: Output goes to stderr because KuzuDB's native module captures stdout
+ * Note: Output goes to stderr because LadybugDB's native module captures stdout
  * at the OS level during init. This is consistent with augment.ts.
  */
 export declare function queryCommand(queryText: string, options?: {

package/dist/cli/tool.js

@@ -10,7 +10,7 @@
  *   gitnexus impact --target "AuthService" --direction upstream
  *   gitnexus cypher "MATCH (n:Function) RETURN n.name LIMIT 10"
  *
- * Note: Output goes to stderr because KuzuDB's native module captures stdout
+ * Note: Output goes to stderr because LadybugDB's native module captures stdout
  * at the OS level during init. This is consistent with augment.ts.
  */
 import { LocalBackend } from '../mcp/local/local-backend.js';
@@ -28,7 +28,7 @@ async function getBackend() {
 }
 function output(data) {
     const text = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
-    // stderr because KuzuDB captures stdout at OS level
+    // stderr because LadybugDB captures stdout at OS level
     process.stderr.write(text + '\n');
 }
 export async function queryCommand(queryText, options) {

package/dist/cli/wiki.js

@@ -86,7 +86,7 @@ export const wikiCommand = async (inputPath, options) => {
         return;
     }
     // ── Check for existing index ────────────────────────────────────────
-    const { storagePath, kuzuPath } = getStoragePaths(repoPath);
+    const { storagePath, lbugPath } = getStoragePaths(repoPath);
     const meta = await loadMeta(storagePath);
     if (!meta) {
         console.log('  Error: No GitNexus index found.');
@@ -217,7 +217,7 @@ export const wikiCommand = async (inputPath, options) => {
         baseUrl: options?.baseUrl,
         concurrency: options?.concurrency ? parseInt(options.concurrency, 10) : undefined,
     };
-    const generator = new WikiGenerator(repoPath, storagePath, kuzuPath, llmConfig, wikiOptions, (phase, percent, detail) => {
+    const generator = new WikiGenerator(repoPath, storagePath, lbugPath, llmConfig, wikiOptions, (phase, percent, detail) => {
         const label = detail || phase;
         if (label !== lastPhase) {
             lastPhase = label;

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

@@ -1 +1,26 @@
+import { type Ignore } from 'ignore';
+import type { Path } from 'path-scurry';
 export declare const shouldIgnorePath: (filePath: string) => boolean;
+/** Check if a directory name is in the hardcoded ignore list */
+export declare const isHardcodedIgnoredDirectory: (name: string) => boolean;
+/**
+ * Load .gitignore and .gitnexusignore rules from the repo root.
+ * Returns an `ignore` instance with all patterns, or null if no files found.
+ */
+export interface IgnoreOptions {
+    /** Skip .gitignore parsing, only read .gitnexusignore. Defaults to GITNEXUS_NO_GITIGNORE env var. */
+    noGitignore?: boolean;
+}
+export declare const loadIgnoreRules: (repoPath: string, options?: IgnoreOptions) => Promise<Ignore | null>;
+/**
+ * Create a glob-compatible ignore filter combining:
+ * - .gitignore / .gitnexusignore patterns (via `ignore` package)
+ * - Hardcoded DEFAULT_IGNORE_LIST, IGNORED_EXTENSIONS, IGNORED_FILES
+ *
+ * Returns an IgnoreLike object for glob's `ignore` option,
+ * enabling directory-level pruning during traversal.
+ */
+export declare const createIgnoreFilter: (repoPath: string, options?: IgnoreOptions) => Promise<{
+    ignored(p: Path): boolean;
+    childrenIgnored(p: Path): boolean;
+}>;

package/dist/config/ignore-service.js

@@ -1,3 +1,6 @@
+import ignore from 'ignore';
+import fs from 'fs/promises';
+import nodePath from 'path';
 const DEFAULT_IGNORE_LIST = new Set([
     // Version Control
     '.git',
@@ -161,6 +164,10 @@ const IGNORED_FILES = new Set([
     '.env.test',
     '.env.example',
 ]);
+// NOTE: Negation patterns in .gitnexusignore (e.g. `!vendor/`) cannot override
+// entries in DEFAULT_IGNORE_LIST — this is intentional. The hardcoded list protects
+// against indexing directories that are almost never source code (node_modules, .git, etc.).
+// Users who need to include such directories should remove them from the hardcoded list.
 export const shouldIgnorePath = (filePath) => {
     const normalizedPath = filePath.replace(/\\/g, '/');
     const parts = normalizedPath.split('/');
@@ -206,3 +213,72 @@ export const shouldIgnorePath = (filePath) => {
     }
     return false;
 };
+/** Check if a directory name is in the hardcoded ignore list */
+export const isHardcodedIgnoredDirectory = (name) => {
+    return DEFAULT_IGNORE_LIST.has(name);
+};
+export const loadIgnoreRules = async (repoPath, options) => {
+    const ig = ignore();
+    let hasRules = false;
+    // 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'];
+    for (const filename of filenames) {
+        try {
+            const content = await fs.readFile(nodePath.join(repoPath, filename), 'utf-8');
+            ig.add(content);
+            hasRules = true;
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== 'ENOENT') {
+                console.warn(`  Warning: could not read ${filename}: ${err.message}`);
+            }
+        }
+    }
+    return hasRules ? ig : null;
+};
+/**
+ * Create a glob-compatible ignore filter combining:
+ * - .gitignore / .gitnexusignore patterns (via `ignore` package)
+ * - Hardcoded DEFAULT_IGNORE_LIST, IGNORED_EXTENSIONS, IGNORED_FILES
+ *
+ * Returns an IgnoreLike object for glob's `ignore` option,
+ * enabling directory-level pruning during traversal.
+ */
+export const createIgnoreFilter = async (repoPath, options) => {
+    const ig = await loadIgnoreRules(repoPath, options);
+    return {
+        ignored(p) {
+            // path-scurry's Path.relative() returns POSIX paths on all platforms,
+            // which is what the `ignore` package expects. No explicit normalization needed.
+            const rel = p.relative();
+            if (!rel)
+                return false;
+            // Check .gitignore / .gitnexusignore patterns
+            if (ig && ig.ignores(rel))
+                return true;
+            // Fall back to hardcoded rules
+            return shouldIgnorePath(rel);
+        },
+        childrenIgnored(p) {
+            // Fast path: check directory name against hardcoded list.
+            // Note: dot-directories (.git, .vscode, etc.) are primarily excluded by
+            // glob's `dot: false` option in filesystem-walker.ts. This check is
+            // defense-in-depth — do not remove `dot: false` assuming this covers it.
+            if (DEFAULT_IGNORE_LIST.has(p.name))
+                return true;
+            // Check against .gitignore / .gitnexusignore patterns.
+            // Test both bare path and path with trailing slash to handle
+            // bare-name patterns (e.g. `local`) and dir-only patterns (e.g. `local/`).
+            if (ig) {
+                const rel = p.relative();
+                if (rel && (ig.ignores(rel) || ig.ignores(rel + '/')))
+                    return true;
+            }
+            return false;
+        },
+    };
+};

package/dist/config/supported-languages.d.ts

@@ -7,6 +7,7 @@ export declare enum SupportedLanguages {
     CPlusPlus = "cpp",
     CSharp = "csharp",
     Go = "go",
+    Ruby = "ruby",
     Rust = "rust",
     PHP = "php",
     Kotlin = "kotlin",

package/dist/config/supported-languages.js

@@ -8,9 +8,9 @@ export var SupportedLanguages;
     SupportedLanguages["CPlusPlus"] = "cpp";
     SupportedLanguages["CSharp"] = "csharp";
     SupportedLanguages["Go"] = "go";
+    SupportedLanguages["Ruby"] = "ruby";
     SupportedLanguages["Rust"] = "rust";
     SupportedLanguages["PHP"] = "php";
     SupportedLanguages["Kotlin"] = "kotlin";
-    // Ruby = 'ruby',
     SupportedLanguages["Swift"] = "swift";
 })(SupportedLanguages || (SupportedLanguages = {}));