gitnexus 1.6.13-rc.69 → 1.6.13-rc.70

package/dist/cli/skill-gen.js

@@ -65,18 +65,18 @@ export const generateSkillFiles = async (repoPath, projectName, pipelineResult)
             /* mirror root may not exist yet */
         }
     }
-    if (!communityResult || !communityResult.memberships.length) {
+    const memberships = communityResult?.rawMemberships ?? communityResult?.memberships ?? [];
+    if (!communityResult || !memberships.length) {
         console.log('\n  Skills: no communities detected, skipping skill generation');
         return { skills: [], outputPath: outputDir };
     }
     console.log('\n  Generating repo-specific skills...');
-    // Step 1: Build communities from memberships (not the filtered communities array).
-    // The community processor skips singletons from its communities array but memberships
-    // include ALL assignments. For repos with sparse CALLS edges, the communities array
-    // can be empty while memberships still has useful groupings.
+    // Step 1: Use raw assignments for the fallback when all communities were
+    // filtered as singletons. Same-folder aggregation can still produce skills
+    // for these sparse graphs without emitting dangling MEMBER_OF edges.
     const communities = communityResult.communities.length > 0
         ? communityResult.communities
-        : buildCommunitiesFromMemberships(communityResult.memberships, graph, repoPath);
+        : buildCommunitiesFromMemberships(memberships, graph, repoPath);
     const aggregated = aggregateCommunities(communities);
     // Step 2: Filter to significant communities
     // Keep communities with >= 3 symbols after aggregation.
@@ -89,8 +89,8 @@ export const generateSkillFiles = async (repoPath, projectName, pipelineResult)
         return { skills: [], outputPath: outputDir };
     }
     // Step 3: Build lookup maps
-    const membershipsByComm = buildMembershipMap(communityResult.memberships);
-    const nodeIdToCommunityLabel = buildNodeCommunityLabelMap(communityResult.memberships, communities);
+    const membershipsByComm = buildMembershipMap(memberships);
+    const nodeIdToCommunityLabel = buildNodeCommunityLabelMap(memberships, communities);
     // Step 4: Ensure the shared project-skill root exists. Never clear it: it
     // also contains user-authored and standard GitNexus skills.
     await fs.mkdir(outputDir, { recursive: true });
@@ -120,7 +120,7 @@ export const generateSkillFiles = async (repoPath, projectName, pipelineResult)
         // Gather entry points
         const entryPoints = gatherEntryPoints(members);
         // Gather execution flows
-        const flows = gatherFlows(community.rawIds, processResult?.processes || []);
+        const flows = gatherFlows(community.rawIds, members, processResult?.processes || []);
         // Gather cross-community connections
         const connections = gatherCrossConnections(community.rawIds, community.label, membershipsByComm, nodeIdToCommunityLabel, graph);
         // Generate kebab name
@@ -392,13 +392,18 @@ const gatherEntryPoints = (members) => {
 /**
  * @brief Gather execution flows touching this community
  * @param {string[]} rawIds - Raw community IDs for this aggregated community
+ * @param {MemberSymbol[]} members - Member symbols, including raw singleton assignments
  * @param {ProcessNode[]} processes - All detected processes
- * @returns {ProcessNode[]} Processes whose communities intersect rawIds, sorted by stepCount
+ * @returns {ProcessNode[]} Processes matching the community IDs or member symbols, sorted by stepCount
  */
-const gatherFlows = (rawIds, processes) => {
+const gatherFlows = (rawIds, members, processes) => {
     const rawIdSet = new Set(rawIds);
+    const memberIds = new Set(members.map((member) => member.id));
     return processes
-        .filter((proc) => proc.communities.some((cid) => rawIdSet.has(cid)))
+        .filter((proc) => proc.communities.some((cid) => rawIdSet.has(cid)) ||
+        // Filtered singleton communities are absent from process metadata,
+        // but their symbols still participate in detected execution traces.
+        proc.trace.some((nodeId) => memberIds.has(nodeId)))
         .sort((a, b) => b.stepCount - a.stepCount);
 };
 /**

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

@@ -30,6 +30,7 @@ export declare const createWatchIgnorePredicate: (repoPath: string, options?: Ig
 /**
  * Create a glob-compatible ignore filter combining:
  * - .gitignore / .gitnexusignore patterns (via `ignore` package)
+ * - nested .gitignore files, scoped to their own directory (#2675)
  * - Hardcoded DEFAULT_IGNORE_LIST, IGNORED_EXTENSIONS, IGNORED_FILES
  *
  * Returns an IgnoreLike object for glob's `ignore` option,

package/dist/config/ignore-service.js

@@ -1,5 +1,5 @@
 import ignore from 'ignore';
-import { existsSync } from 'fs';
+import { closeSync, constants as fsConstants, existsSync, fstatSync, lstatSync, openSync, readFileSync, } from 'fs';
 import fs from 'fs/promises';
 import nodePath from 'path';
 import { readRepoControlFile } from './repo-control-file.js';
@@ -472,9 +472,152 @@ const hasExplicitUnignore = (ig, rel) => {
     }
     return false;
 };
+/**
+ * Read a nested `.gitignore` only if it is a regular file, not a symlink.
+ *
+ * git does not follow a symlinked `.gitignore` in the working tree, and
+ * reading one could pull rules from outside the repository. Where the
+ * platform supports it, the file is opened with O_NOFOLLOW (a symlink fails
+ * with ELOOP). Windows has no O_NOFOLLOW, so there the path is lstat'ed after
+ * opening and must be the same regular file as the open descriptor. Either
+ * way the content is read through the descriptor that was checked, never by
+ * path, so the file cannot be swapped between the check and the read.
+ *
+ * The open also passes O_NONBLOCK where it exists. Opening a FIFO for reading
+ * blocks in open(2) until a writer appears, so a `.gitignore` that is a FIFO
+ * would hang the scan before the isFile() check could reject it (glob's
+ * ignore callback is synchronous). The flag makes that open return at once
+ * and changes nothing for a regular file. Same reasoning as readBoundedFile
+ * in src/core/ingestion/asyncapi/document.ts.
+ */
+const readNestedGitignore = (filePath) => {
+    const noFollow = fsConstants.O_NOFOLLOW;
+    const nonBlock = fsConstants.O_NONBLOCK;
+    const fd = openSync(filePath, fsConstants.O_RDONLY | (noFollow ?? 0) | (nonBlock ?? 0));
+    try {
+        const stat = fstatSync(fd);
+        if (!stat.isFile())
+            return null;
+        if (noFollow === undefined) {
+            const link = lstatSync(filePath);
+            if (!link.isFile() || link.ino !== stat.ino || link.dev !== stat.dev)
+                return null;
+        }
+        return readFileSync(fd, 'utf-8');
+    }
+    finally {
+        closeSync(fd);
+    }
+};
+/**
+ * Resolve `.gitignore` files below the repository root (#2675).
+ *
+ * `loadIgnoreRules` only reads the root `.gitignore`, so a monorepo package
+ * or checked-out submodule with its own `.gitignore` had its generated
+ * output indexed anyway. Each nested file is read lazily (glob's filter is
+ * synchronous) and cached per directory, and its patterns are matched
+ * against the path relative to that directory, like git does.
+ *
+ * Returns the effective decision when nested rules affect the path or an
+ * ancestor, and `undefined` otherwise. Root rules participate so a directory
+ * negation does not erase independent root exclusions for its children.
+ * The caller still gives `.gitnexusignore` its higher precedence.
+ */
+const createNestedGitignoreMatcher = (repoPath, rootRules) => {
+    const rulesFor = (dirRel) => {
+        let rules = null;
+        const filePath = nodePath.join(repoPath, dirRel, '.gitignore');
+        try {
+            const content = readNestedGitignore(filePath);
+            if (content !== null)
+                rules = ignore().add(content);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== 'ENOENT' && code !== 'ENOTDIR' && code !== 'ELOOP') {
+                logger.warn(`  Warning: could not read ${filePath}: ${err.message}`);
+            }
+        }
+        return rules;
+    };
+    const relativeTo = (base, rel) => base ? rel.slice(base.length + 1) : rel;
+    const match = (scopes, rel, isDirectory) => {
+        for (let i = scopes.length - 1; i >= 0; i--) {
+            const { base, rules } = scopes[i];
+            const sub = relativeTo(base, rel);
+            const result = rules.test(isDirectory ? `${sub}/` : sub);
+            if (result.ignored || result.unignored) {
+                return { ignored: result.ignored, nested: base !== '' };
+            }
+        }
+        return undefined;
+    };
+    const contexts = new Map([
+        [
+            '',
+            {
+                scopes: rootRules ? [{ base: '', rules: rootRules }] : [],
+                ignored: false,
+                nested: false,
+            },
+        ],
+    ]);
+    const contextFor = (dir) => {
+        const cached = contexts.get(dir);
+        if (cached)
+            return cached;
+        const parentDir = nodePath.posix.dirname(dir);
+        const parent = contextFor(parentDir === '.' ? '' : parentDir);
+        // A .gitignore inside an excluded directory cannot bring that directory
+        // back. Do not read rules below a parent that traversal would prune.
+        if (parent.ignored) {
+            contexts.set(dir, parent);
+            return parent;
+        }
+        const result = match(parent.scopes, dir, true);
+        const context = {
+            scopes: parent.scopes,
+            ignored: result?.ignored ?? false,
+            nested: parent.nested || (result?.nested ?? false),
+        };
+        if (!context.ignored) {
+            context.scopes = parent.scopes.map(({ base, rules }) => {
+                const sub = relativeTo(base, dir);
+                if (!rules.test(`${sub}/`).ignored)
+                    return { base, rules };
+                // A deeper rule let us enter this directory. Clear only its inherited
+                // exclusion in the shallower layer; child rules must still be tested.
+                // Keep patterns in their original scope, and escape this literal path.
+                const literal = sub.replace(/[\\*?\[\]]/g, '\\$&');
+                return {
+                    base,
+                    rules: ignore()
+                        .add(rules)
+                        .add({ pattern: `!/${literal}/` }),
+                };
+            });
+            const rules = rulesFor(dir);
+            if (rules)
+                context.scopes.push({ base: dir, rules });
+        }
+        contexts.set(dir, context);
+        return context;
+    };
+    return (rel, isDirectory) => {
+        const parentDir = nodePath.posix.dirname(rel);
+        const parent = contextFor(parentDir === '.' ? '' : parentDir);
+        if (parent.ignored)
+            return parent.nested ? true : undefined;
+        const result = match(parent.scopes, rel, isDirectory);
+        if (parent.nested || result?.nested)
+            return result?.ignored ?? false;
+        return undefined;
+    };
+};
 /**
  * Create a glob-compatible ignore filter combining:
  * - .gitignore / .gitnexusignore patterns (via `ignore` package)
+ * - nested .gitignore files, scoped to their own directory (#2675)
  * - Hardcoded DEFAULT_IGNORE_LIST, IGNORED_EXTENSIONS, IGNORED_FILES
  *
  * Returns an IgnoreLike object for glob's `ignore` option,
@@ -491,6 +634,13 @@ const hasExplicitUnignore = (ig, rel) => {
  */
 export const createIgnoreFilter = async (repoPath, options) => {
     const ig = await loadIgnoreRules(repoPath, options);
+    const skipGitignore = options?.noGitignore ?? !!process.env.GITNEXUS_NO_GITIGNORE;
+    const nestedIgnores = skipGitignore ? null : createNestedGitignoreMatcher(repoPath, ig);
+    // A nested negation outranks the root .gitignore, as in git, but not the
+    // user's .gitnexusignore, so keep a matcher for that file on its own.
+    const nexusIgnore = nestedIgnores
+        ? await loadIgnoreRules(repoPath, { ...options, noGitignore: true, noGlobalIgnore: true })
+        : null;
     return {
         ignored(p) {
             // The `ignore` package expects POSIX separators; path-scurry can surface
@@ -498,6 +648,27 @@ export const createIgnoreFilter = async (repoPath, options) => {
             const rel = p.relative().replace(/\\/g, '/');
             if (!rel)
                 return false;
+            // Nested .gitignore files below the root (#2675). .gitnexusignore
+            // comes first, then the deepest nested .gitignore, which outranks the
+            // root .gitignore as in git. The nested matcher preserves independent
+            // root exclusions; a nested negation never rescues a hardcoded default.
+            // With no nested opinion the original order below applies unchanged.
+            if (nestedIgnores) {
+                if (nexusIgnore) {
+                    if (hasExplicitUnignore(nexusIgnore, rel) && !ig?.ignores(rel))
+                        return false;
+                    if (nexusIgnore.ignores(rel))
+                        return true;
+                }
+                const nested = nestedIgnores(rel, false);
+                if (nested === true)
+                    return true;
+                if (nested === false) {
+                    if (ig && hasExplicitUnignore(ig, rel) && !ig.ignores(rel))
+                        return false;
+                    return shouldIgnorePath(rel);
+                }
+            }
             // User's .gitnexusignore negation takes precedence over hardcoded
             // rules (#771). If any ancestor or the path itself was explicitly
             // unignored AND no more-specific rule re-ignores this exact path,
@@ -519,6 +690,25 @@ export const createIgnoreFilter = async (repoPath, options) => {
             // list check below is defense-in-depth — do not remove `dot: false`
             // assuming this covers it.
             const rel = p.relative().replace(/\\/g, '/');
+            // Nested .gitignore files below the root (#2675), same precedence as in
+            // `ignored` above.
+            if (nestedIgnores && rel) {
+                if (nexusIgnore) {
+                    if (hasExplicitUnignore(nexusIgnore, rel) && !ig?.ignores(rel + '/')) {
+                        return false;
+                    }
+                    if (nexusIgnore.ignores(rel + '/'))
+                        return true;
+                }
+                const nested = nestedIgnores(rel, true);
+                if (nested === true)
+                    return true;
+                if (nested === false) {
+                    if (ig && hasExplicitUnignore(ig, rel) && !ig.ignores(rel + '/'))
+                        return false;
+                    return isHardcodedIgnoredDirectoryAtPath(repoPath, nodePath.join(repoPath, rel));
+                }
+            }
             // User's .gitnexusignore negation takes precedence (#771) — if the
             // user explicitly unignored this directory or any ancestor via a
             // !pattern rule, allow descent even if the directory name is in

package/dist/core/ingestion/community-processor.d.ts

@@ -62,7 +62,10 @@ export interface CommunityMembership {
 }
 export interface CommunityDetectionResult {
     communities: CommunityNode[];
+    /** Assignments to retained communities, safe to emit as MEMBER_OF edges. */
     memberships: CommunityMembership[];
+    /** All Leiden assignments, including filtered singletons. Optional for legacy producers. */
+    rawMemberships?: CommunityMembership[];
     stats: {
         totalCommunities: number;
         modularity: number;

package/dist/core/ingestion/community-processor.js

@@ -107,6 +107,7 @@ export const processCommunities = async (knowledgeGraph, onProgress, options = {
         return {
             communities: [],
             memberships: [],
+            rawMemberships: [],
             stats: {
                 totalCommunities: 0,
                 modularity: 0,
@@ -124,18 +125,23 @@ export const processCommunities = async (knowledgeGraph, onProgress, options = {
     // Step 3: Create community nodes with heuristic labels
     const communityNodes = createCommunityNodes(details.communities, details.count, graph, knowledgeGraph);
     onProgress?.('Creating membership edges...', 80);
-    // Step 4: Create membership mappings
+    // Step 4: Preserve all assignments for skill generation, but only emit
+    // memberships for retained communities with a corresponding graph node.
+    const retainedCommunityIds = new Set(communityNodes.map((community) => community.id));
     const memberships = [];
+    const rawMemberships = [];
     Object.entries(details.communities).forEach(([nodeId, communityNum]) => {
-        memberships.push({
-            nodeId,
-            communityId: `comm_${communityNum}`,
-        });
+        const communityId = `comm_${communityNum}`;
+        const membership = { nodeId, communityId };
+        rawMemberships.push(membership);
+        if (retainedCommunityIds.has(communityId))
+            memberships.push(membership);
     });
     onProgress?.('Community detection complete!', 100);
     return {
         communities: communityNodes,
         memberships,
+        rawMemberships,
         stats: {
             totalCommunities: details.count,
             modularity: details.modularity,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.13-rc.69",
+  "version": "1.6.13-rc.70",
   "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",