@duytransipher/gitnexus 1.4.6-sipher.0

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

@@ -0,0 +1,315 @@
+/**
+ * Process Detection Processor
+ *
+ * Detects execution flows (Processes) in the code graph by:
+ * 1. Finding entry points (functions with no internal callers)
+ * 2. Tracing forward via CALLS edges (BFS)
+ * 3. Grouping and deduplicating similar paths
+ * 4. Labeling with heuristic names
+ *
+ * Processes help agents understand how features work through the codebase.
+ */
+import { calculateEntryPointScore, isTestFile } from './entry-point-scoring.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
+const isDev = process.env.NODE_ENV === 'development';
+const DEFAULT_CONFIG = {
+    maxTraceDepth: 10,
+    maxBranching: 4,
+    maxProcesses: 75,
+    minSteps: 3, // 3+ steps = genuine multi-hop flow (2-step is just "A calls B")
+};
+// ============================================================================
+// MAIN PROCESSOR
+// ============================================================================
+/**
+ * Detect processes (execution flows) in the knowledge graph
+ *
+ * This runs AFTER community detection, using CALLS edges to trace flows.
+ */
+export const processProcesses = async (knowledgeGraph, memberships, onProgress, config = {}) => {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    onProgress?.('Finding entry points...', 0);
+    // Build lookup maps
+    const membershipMap = new Map();
+    memberships.forEach(m => membershipMap.set(m.nodeId, m.communityId));
+    const callsEdges = buildCallsGraph(knowledgeGraph);
+    const reverseCallsEdges = buildReverseCallsGraph(knowledgeGraph);
+    const nodeMap = new Map();
+    for (const n of knowledgeGraph.iterNodes())
+        nodeMap.set(n.id, n);
+    // Step 1: Find entry points (functions that call others but have few callers)
+    const entryPoints = findEntryPoints(knowledgeGraph, reverseCallsEdges, callsEdges);
+    onProgress?.(`Found ${entryPoints.length} entry points, tracing flows...`, 20);
+    onProgress?.(`Found ${entryPoints.length} entry points, tracing flows...`, 20);
+    // Step 2: Trace processes from each entry point
+    const allTraces = [];
+    for (let i = 0; i < entryPoints.length && allTraces.length < cfg.maxProcesses * 2; i++) {
+        const entryId = entryPoints[i];
+        const traces = traceFromEntryPoint(entryId, callsEdges, cfg);
+        // Filter out traces that are too short
+        traces.filter(t => t.length >= cfg.minSteps).forEach(t => allTraces.push(t));
+        if (i % 10 === 0) {
+            onProgress?.(`Tracing entry point ${i + 1}/${entryPoints.length}...`, 20 + (i / entryPoints.length) * 40);
+        }
+    }
+    onProgress?.(`Found ${allTraces.length} traces, deduplicating...`, 60);
+    // Step 3: Deduplicate similar traces (subset removal)
+    const uniqueTraces = deduplicateTraces(allTraces);
+    // Step 3b: Deduplicate by entry+terminal pair (keep longest path per pair)
+    const endpointDeduped = deduplicateByEndpoints(uniqueTraces);
+    onProgress?.(`Deduped ${uniqueTraces.length} → ${endpointDeduped.length} unique endpoint pairs`, 70);
+    // Step 4: Limit to max processes (prioritize longer traces)
+    const limitedTraces = endpointDeduped
+        .sort((a, b) => b.length - a.length)
+        .slice(0, cfg.maxProcesses);
+    onProgress?.(`Creating ${limitedTraces.length} process nodes...`, 80);
+    // Step 5: Create process nodes
+    const processes = [];
+    const steps = [];
+    limitedTraces.forEach((trace, idx) => {
+        const entryPointId = trace[0];
+        const terminalId = trace[trace.length - 1];
+        // Get communities touched
+        const communitiesSet = new Set();
+        trace.forEach(nodeId => {
+            const comm = membershipMap.get(nodeId);
+            if (comm)
+                communitiesSet.add(comm);
+        });
+        const communities = Array.from(communitiesSet);
+        // Determine process type
+        const processType = communities.length > 1 ? 'cross_community' : 'intra_community';
+        // Generate label
+        const entryNode = nodeMap.get(entryPointId);
+        const terminalNode = nodeMap.get(terminalId);
+        const entryName = entryNode?.properties.name || 'Unknown';
+        const terminalName = terminalNode?.properties.name || 'Unknown';
+        const heuristicLabel = `${capitalize(entryName)} → ${capitalize(terminalName)}`;
+        const processId = `proc_${idx}_${sanitizeId(entryName)}`;
+        processes.push({
+            id: processId,
+            label: heuristicLabel,
+            heuristicLabel,
+            processType,
+            stepCount: trace.length,
+            communities,
+            entryPointId,
+            terminalId,
+            trace,
+        });
+        // Create step relationships
+        trace.forEach((nodeId, stepIdx) => {
+            steps.push({
+                nodeId,
+                processId,
+                step: stepIdx + 1, // 1-indexed
+            });
+        });
+    });
+    onProgress?.('Process detection complete!', 100);
+    // Calculate stats
+    const crossCommunityCount = processes.filter(p => p.processType === 'cross_community').length;
+    const avgStepCount = processes.length > 0
+        ? processes.reduce((sum, p) => sum + p.stepCount, 0) / processes.length
+        : 0;
+    return {
+        processes,
+        steps,
+        stats: {
+            totalProcesses: processes.length,
+            crossCommunityCount,
+            avgStepCount: Math.round(avgStepCount * 10) / 10,
+            entryPointsFound: entryPoints.length,
+        },
+    };
+};
+/**
+ * Minimum edge confidence for process tracing.
+ * Filters out ambiguous fuzzy-global matches (0.3) that cause
+ * traces to jump across unrelated code areas.
+ */
+const MIN_TRACE_CONFIDENCE = 0.5;
+const buildCallsGraph = (graph) => {
+    const adj = new Map();
+    for (const rel of graph.iterRelationships()) {
+        if (rel.type === 'CALLS' && rel.confidence >= MIN_TRACE_CONFIDENCE) {
+            if (!adj.has(rel.sourceId)) {
+                adj.set(rel.sourceId, []);
+            }
+            adj.get(rel.sourceId).push(rel.targetId);
+        }
+    }
+    return adj;
+};
+const buildReverseCallsGraph = (graph) => {
+    const adj = new Map();
+    for (const rel of graph.iterRelationships()) {
+        if (rel.type === 'CALLS' && rel.confidence >= MIN_TRACE_CONFIDENCE) {
+            if (!adj.has(rel.targetId)) {
+                adj.set(rel.targetId, []);
+            }
+            adj.get(rel.targetId).push(rel.sourceId);
+        }
+    }
+    return adj;
+};
+/**
+ * Find functions/methods that are good entry points for tracing.
+ *
+ * Entry points are scored based on:
+ * 1. Call ratio (calls many, called by few)
+ * 2. Export status (exported/public functions rank higher)
+ * 3. Name patterns (handle*, on*, *Controller, etc.)
+ *
+ * Test files are excluded entirely.
+ */
+const findEntryPoints = (graph, reverseCallsEdges, callsEdges) => {
+    const symbolTypes = new Set(['Function', 'Method']);
+    const entryPointCandidates = [];
+    for (const node of graph.iterNodes()) {
+        if (!symbolTypes.has(node.label))
+            continue;
+        const filePath = node.properties.filePath || '';
+        // Skip test files entirely
+        if (isTestFile(filePath))
+            continue;
+        const callers = reverseCallsEdges.get(node.id) || [];
+        const callees = callsEdges.get(node.id) || [];
+        // Must have at least 1 outgoing call to trace forward
+        if (callees.length === 0)
+            continue;
+        // Calculate entry point score using new scoring system
+        const { score: baseScore, reasons } = calculateEntryPointScore(node.properties.name, node.properties.language ?? SupportedLanguages.JavaScript, node.properties.isExported ?? false, callers.length, callees.length, filePath // Pass filePath for framework detection
+        );
+        let score = baseScore;
+        const astFrameworkMultiplier = node.properties.astFrameworkMultiplier ?? 1.0;
+        if (astFrameworkMultiplier > 1.0) {
+            score *= astFrameworkMultiplier;
+            reasons.push(`framework-ast:${node.properties.astFrameworkReason || 'decorator'}`);
+        }
+        if (score > 0) {
+            entryPointCandidates.push({ id: node.id, score, reasons });
+        }
+    }
+    // Sort by score descending and return top candidates
+    const sorted = entryPointCandidates.sort((a, b) => b.score - a.score);
+    // DEBUG: Log top candidates with new scoring details
+    if (sorted.length > 0 && isDev) {
+        console.log(`[Process] Top 10 entry point candidates (new scoring):`);
+        sorted.slice(0, 10).forEach((c, i) => {
+            const node = graph.getNode(c.id);
+            const exported = node?.properties.isExported ? '✓' : '✗';
+            const shortPath = node?.properties.filePath?.split('/').slice(-2).join('/') || '';
+            console.log(`  ${i + 1}. ${node?.properties.name} [exported:${exported}] (${shortPath})`);
+            console.log(`     score: ${c.score.toFixed(2)} = [${c.reasons.join(' × ')}]`);
+        });
+    }
+    return sorted
+        .slice(0, 200) // Limit to prevent explosion
+        .map(c => c.id);
+};
+// ============================================================================
+// HELPER: Trace from entry point (BFS)
+// ============================================================================
+/**
+ * Trace forward from an entry point using BFS.
+ * Returns all distinct paths up to maxDepth.
+ */
+const traceFromEntryPoint = (entryId, callsEdges, config) => {
+    const traces = [];
+    // BFS with path tracking
+    // Each queue item: [currentNodeId, pathSoFar]
+    const queue = [[entryId, [entryId]]];
+    while (queue.length > 0 && traces.length < config.maxBranching * 3) {
+        const [currentId, path] = queue.shift();
+        // Get outgoing calls
+        const callees = callsEdges.get(currentId) || [];
+        if (callees.length === 0) {
+            // Terminal node - this is a complete trace
+            if (path.length >= config.minSteps) {
+                traces.push([...path]);
+            }
+        }
+        else if (path.length >= config.maxTraceDepth) {
+            // Max depth reached - save what we have
+            if (path.length >= config.minSteps) {
+                traces.push([...path]);
+            }
+        }
+        else {
+            // Continue tracing - limit branching
+            const limitedCallees = callees.slice(0, config.maxBranching);
+            let addedBranch = false;
+            for (const calleeId of limitedCallees) {
+                // Avoid cycles
+                if (!path.includes(calleeId)) {
+                    queue.push([calleeId, [...path, calleeId]]);
+                    addedBranch = true;
+                }
+            }
+            // If all branches were cycles, save current path as terminal
+            if (!addedBranch && path.length >= config.minSteps) {
+                traces.push([...path]);
+            }
+        }
+    }
+    return traces;
+};
+// ============================================================================
+// HELPER: Deduplicate traces
+// ============================================================================
+/**
+ * Merge traces that are subsets of other traces.
+ * Keep longer traces, remove redundant shorter ones.
+ */
+const deduplicateTraces = (traces) => {
+    if (traces.length === 0)
+        return [];
+    // Sort by length descending
+    const sorted = [...traces].sort((a, b) => b.length - a.length);
+    const unique = [];
+    for (const trace of sorted) {
+        // Check if this trace is a subset of any already-added trace
+        const traceKey = trace.join('->');
+        const isSubset = unique.some(existing => {
+            const existingKey = existing.join('->');
+            return existingKey.includes(traceKey);
+        });
+        if (!isSubset) {
+            unique.push(trace);
+        }
+    }
+    return unique;
+};
+// ============================================================================
+// HELPER: Deduplicate by entry+terminal endpoints
+// ============================================================================
+/**
+ * Keep only the longest trace per unique entry→terminal pair.
+ * Multiple paths between the same two endpoints are redundant for agents.
+ */
+const deduplicateByEndpoints = (traces) => {
+    if (traces.length === 0)
+        return [];
+    const byEndpoints = new Map();
+    // Sort longest first so the first seen per key is the longest
+    const sorted = [...traces].sort((a, b) => b.length - a.length);
+    for (const trace of sorted) {
+        const key = `${trace[0]}::${trace[trace.length - 1]}`;
+        if (!byEndpoints.has(key)) {
+            byEndpoints.set(key, trace);
+        }
+    }
+    return Array.from(byEndpoints.values());
+};
+// ============================================================================
+// HELPER: String utilities
+// ============================================================================
+const capitalize = (s) => {
+    if (!s)
+        return s;
+    return s.charAt(0).toUpperCase() + s.slice(1);
+};
+const sanitizeId = (s) => {
+    return s.replace(/[^a-zA-Z0-9]/g, '_').substring(0, 20).toLowerCase();
+};

package/dist/core/ingestion/resolution-context.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Resolution Context
+ *
+ * Single implementation of tiered name resolution. Replaces the duplicated
+ * tier-selection logic previously split between symbol-resolver.ts and
+ * call-processor.ts.
+ *
+ * Resolution tiers (highest confidence first):
+ * 1. Same file (lookupExactFull — authoritative)
+ * 2a-named. Named binding chain (walkBindingChain via NamedImportMap)
+ * 2a. Import-scoped (lookupFuzzy filtered by ImportMap)
+ * 2b. Package-scoped (lookupFuzzy filtered by PackageMap)
+ * 3. Global (all candidates — consumers must check candidate count)
+ */
+import type { SymbolTable, SymbolDefinition } from './symbol-table.js';
+import type { NamedImportBinding } from './import-processor.js';
+/** Resolution tier for tracking, logging, and test assertions. */
+export type ResolutionTier = 'same-file' | 'import-scoped' | 'global';
+/** Tier-selected candidates with metadata. */
+export interface TieredCandidates {
+    readonly candidates: readonly SymbolDefinition[];
+    readonly tier: ResolutionTier;
+}
+/** Confidence scores per resolution tier. */
+export declare const TIER_CONFIDENCE: Record<ResolutionTier, number>;
+export type ImportMap = Map<string, Set<string>>;
+export type PackageMap = Map<string, Set<string>>;
+export type NamedImportMap = Map<string, Map<string, NamedImportBinding>>;
+export interface ResolutionContext {
+    /**
+     * The only resolution API. Returns all candidates at the winning tier.
+     *
+     * Tier 3 ('global') returns ALL candidates regardless of count —
+     * consumers must check candidates.length and refuse ambiguous matches.
+     */
+    resolve(name: string, fromFile: string): TieredCandidates | null;
+    /** Symbol table — used by parsing-processor to populate symbols. */
+    readonly symbols: SymbolTable;
+    /** Raw maps — used by import-processor to populate import data. */
+    readonly importMap: ImportMap;
+    readonly packageMap: PackageMap;
+    readonly namedImportMap: NamedImportMap;
+    enableCache(filePath: string): void;
+    clearCache(): void;
+    getStats(): {
+        fileCount: number;
+        globalSymbolCount: number;
+        cacheHits: number;
+        cacheMisses: number;
+    };
+    clear(): void;
+}
+export declare const createResolutionContext: () => ResolutionContext;

package/dist/core/ingestion/resolution-context.js

@@ -0,0 +1,132 @@
+/**
+ * Resolution Context
+ *
+ * Single implementation of tiered name resolution. Replaces the duplicated
+ * tier-selection logic previously split between symbol-resolver.ts and
+ * call-processor.ts.
+ *
+ * Resolution tiers (highest confidence first):
+ * 1. Same file (lookupExactFull — authoritative)
+ * 2a-named. Named binding chain (walkBindingChain via NamedImportMap)
+ * 2a. Import-scoped (lookupFuzzy filtered by ImportMap)
+ * 2b. Package-scoped (lookupFuzzy filtered by PackageMap)
+ * 3. Global (all candidates — consumers must check candidate count)
+ */
+import { createSymbolTable } from './symbol-table.js';
+import { isFileInPackageDir } from './import-processor.js';
+import { walkBindingChain } from './named-binding-extraction.js';
+/** Confidence scores per resolution tier. */
+export const TIER_CONFIDENCE = {
+    'same-file': 0.95,
+    'import-scoped': 0.9,
+    'global': 0.5,
+};
+export const createResolutionContext = () => {
+    const symbols = createSymbolTable();
+    const importMap = new Map();
+    const packageMap = new Map();
+    const namedImportMap = new Map();
+    // Per-file cache state
+    let cacheFile = null;
+    let cache = null;
+    let cacheHits = 0;
+    let cacheMisses = 0;
+    // --- Core resolution (single implementation of tier logic) ---
+    const resolveUncached = (name, fromFile) => {
+        // Tier 1: Same file — authoritative match
+        const localDef = symbols.lookupExactFull(fromFile, name);
+        if (localDef) {
+            return { candidates: [localDef], tier: 'same-file' };
+        }
+        // Get all global definitions for subsequent tiers
+        const allDefs = symbols.lookupFuzzy(name);
+        // Tier 2a-named: Check named bindings BEFORE empty-allDefs early return
+        // because aliased imports mean lookupFuzzy('U') returns empty but we
+        // can resolve via the exported name.
+        const chainResult = walkBindingChain(name, fromFile, symbols, namedImportMap, allDefs);
+        if (chainResult && chainResult.length > 0) {
+            return { candidates: chainResult, tier: 'import-scoped' };
+        }
+        if (allDefs.length === 0)
+            return null;
+        // Tier 2a: Import-scoped — definition in a file imported by fromFile
+        const importedFiles = importMap.get(fromFile);
+        if (importedFiles) {
+            const importedDefs = allDefs.filter(def => importedFiles.has(def.filePath));
+            if (importedDefs.length > 0) {
+                return { candidates: importedDefs, tier: 'import-scoped' };
+            }
+        }
+        // Tier 2b: Package-scoped — definition in a package dir imported by fromFile
+        const importedPackages = packageMap.get(fromFile);
+        if (importedPackages) {
+            const packageDefs = allDefs.filter(def => {
+                for (const dirSuffix of importedPackages) {
+                    if (isFileInPackageDir(def.filePath, dirSuffix))
+                        return true;
+                }
+                return false;
+            });
+            if (packageDefs.length > 0) {
+                return { candidates: packageDefs, tier: 'import-scoped' };
+            }
+        }
+        // Tier 3: Global — pass all candidates through.
+        // Consumers must check candidate count and refuse ambiguous matches.
+        return { candidates: allDefs, tier: 'global' };
+    };
+    const resolve = (name, fromFile) => {
+        // Check cache (only when enabled AND fromFile matches cached file)
+        if (cache && cacheFile === fromFile) {
+            if (cache.has(name)) {
+                cacheHits++;
+                return cache.get(name);
+            }
+            cacheMisses++;
+        }
+        const result = resolveUncached(name, fromFile);
+        // Store in cache if active and file matches
+        if (cache && cacheFile === fromFile) {
+            cache.set(name, result);
+        }
+        return result;
+    };
+    // --- Cache lifecycle ---
+    const enableCache = (filePath) => {
+        cacheFile = filePath;
+        if (!cache)
+            cache = new Map();
+        else
+            cache.clear();
+    };
+    const clearCache = () => {
+        cacheFile = null;
+        // Reuse the Map instance — just clear entries to reduce GC pressure at scale.
+        cache?.clear();
+    };
+    const getStats = () => ({
+        ...symbols.getStats(),
+        cacheHits,
+        cacheMisses,
+    });
+    const clear = () => {
+        symbols.clear();
+        importMap.clear();
+        packageMap.clear();
+        namedImportMap.clear();
+        clearCache();
+        cacheHits = 0;
+        cacheMisses = 0;
+    };
+    return {
+        resolve,
+        symbols,
+        importMap,
+        packageMap,
+        namedImportMap,
+        enableCache,
+        clearCache,
+        getStats,
+        clear,
+    };
+};

package/dist/core/ingestion/resolvers/csharp.d.ts

@@ -0,0 +1,22 @@
+/**
+ * C# namespace import resolution.
+ * Handles using-directive resolution via .csproj root namespace stripping.
+ */
+import type { SuffixIndex } from './utils.js';
+/** C# project config parsed from .csproj files */
+export interface CSharpProjectConfig {
+    /** Root namespace from <RootNamespace> or assembly name (default: project directory name) */
+    rootNamespace: string;
+    /** Directory containing the .csproj file */
+    projectDir: string;
+}
+/**
+ * Resolve a C# using-directive import path to matching .cs files.
+ * Tries single-file match first, then directory match for namespace imports.
+ */
+export declare function resolveCSharpImport(importPath: string, csharpConfigs: CSharpProjectConfig[], normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string[];
+/**
+ * Compute the directory suffix for a C# namespace import (for PackageMap).
+ * Returns a suffix like "/ProjectDir/Models/" or null if no config matches.
+ */
+export declare function resolveCSharpNamespaceDir(importPath: string, csharpConfigs: CSharpProjectConfig[]): string | null;

package/dist/core/ingestion/resolvers/csharp.js

@@ -0,0 +1,109 @@
+/**
+ * C# namespace import resolution.
+ * Handles using-directive resolution via .csproj root namespace stripping.
+ */
+import { suffixResolve } from './utils.js';
+/**
+ * Resolve a C# using-directive import path to matching .cs files.
+ * Tries single-file match first, then directory match for namespace imports.
+ */
+export function resolveCSharpImport(importPath, csharpConfigs, normalizedFileList, allFileList, index) {
+    const namespacePath = importPath.replace(/\./g, '/');
+    const results = [];
+    for (const config of csharpConfigs) {
+        const nsPath = config.rootNamespace.replace(/\./g, '/');
+        let relative;
+        if (namespacePath.startsWith(nsPath + '/')) {
+            relative = namespacePath.slice(nsPath.length + 1);
+        }
+        else if (namespacePath === nsPath) {
+            // The import IS the root namespace — resolve to all .cs files in project root
+            relative = '';
+        }
+        else {
+            continue;
+        }
+        const dirPrefix = config.projectDir
+            ? (relative ? config.projectDir + '/' + relative : config.projectDir)
+            : relative;
+        // 1. Try as single file: relative.cs (e.g., "Models/DlqMessage.cs")
+        if (relative) {
+            const candidate = dirPrefix + '.cs';
+            if (index) {
+                const result = index.get(candidate) || index.getInsensitive(candidate);
+                if (result)
+                    return [result];
+            }
+            // Also try suffix match
+            const suffixResult = index?.get(relative + '.cs') || index?.getInsensitive(relative + '.cs');
+            if (suffixResult)
+                return [suffixResult];
+        }
+        // 2. Try as directory: all .cs files directly inside (namespace import)
+        if (index) {
+            const dirFiles = index.getFilesInDir(dirPrefix, '.cs');
+            for (const f of dirFiles) {
+                const normalized = f.replace(/\\/g, '/');
+                // Check it's a direct child by finding the dirPrefix and ensuring no deeper slashes
+                const prefixIdx = normalized.indexOf(dirPrefix + '/');
+                if (prefixIdx < 0)
+                    continue;
+                const afterDir = normalized.substring(prefixIdx + dirPrefix.length + 1);
+                if (!afterDir.includes('/')) {
+                    results.push(f);
+                }
+            }
+            if (results.length > 0)
+                return results;
+        }
+        // 3. Linear scan fallback for directory matching
+        if (results.length === 0) {
+            const dirTrail = dirPrefix + '/';
+            for (let i = 0; i < normalizedFileList.length; i++) {
+                const normalized = normalizedFileList[i];
+                if (!normalized.endsWith('.cs'))
+                    continue;
+                const prefixIdx = normalized.indexOf(dirTrail);
+                if (prefixIdx < 0)
+                    continue;
+                const afterDir = normalized.substring(prefixIdx + dirTrail.length);
+                if (!afterDir.includes('/')) {
+                    results.push(allFileList[i]);
+                }
+            }
+            if (results.length > 0)
+                return results;
+        }
+    }
+    // Fallback: suffix matching without namespace stripping (single file)
+    const pathParts = namespacePath.split('/').filter(Boolean);
+    const fallback = suffixResolve(pathParts, normalizedFileList, allFileList, index);
+    return fallback ? [fallback] : [];
+}
+/**
+ * Compute the directory suffix for a C# namespace import (for PackageMap).
+ * Returns a suffix like "/ProjectDir/Models/" or null if no config matches.
+ */
+export function resolveCSharpNamespaceDir(importPath, csharpConfigs) {
+    const namespacePath = importPath.replace(/\./g, '/');
+    for (const config of csharpConfigs) {
+        const nsPath = config.rootNamespace.replace(/\./g, '/');
+        let relative;
+        if (namespacePath.startsWith(nsPath + '/')) {
+            relative = namespacePath.slice(nsPath.length + 1);
+        }
+        else if (namespacePath === nsPath) {
+            relative = '';
+        }
+        else {
+            continue;
+        }
+        const dirPrefix = config.projectDir
+            ? (relative ? config.projectDir + '/' + relative : config.projectDir)
+            : relative;
+        if (!dirPrefix)
+            continue;
+        return '/' + dirPrefix + '/';
+    }
+    return null;
+}

package/dist/core/ingestion/resolvers/go.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Go package import resolution.
+ * Handles Go module path-based package imports.
+ */
+/** Go module config parsed from go.mod */
+export interface GoModuleConfig {
+    /** Module path (e.g., "github.com/user/repo") */
+    modulePath: string;
+}
+/**
+ * Extract the package directory suffix from a Go import path.
+ * Returns the suffix string (e.g., "/internal/auth/") or null if invalid.
+ */
+export declare function resolveGoPackageDir(importPath: string, goModule: GoModuleConfig): string | null;
+/**
+ * Resolve a Go internal package import to all .go files in the package directory.
+ * Returns an array of file paths.
+ */
+export declare function resolveGoPackage(importPath: string, goModule: GoModuleConfig, normalizedFileList: string[], allFileList: string[]): string[];