@zuvia-software-solutions/code-mapper 1.4.0

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

@@ -0,0 +1,357 @@
+// code-mapper/src/core/ingestion/process-processor.ts
+/** @file process-processor.ts @description Detects execution flows (Processes) by finding entry points, tracing forward via confidence-gated beam search, deduplicating similar paths, and labeling with heuristic names */
+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: 20,
+    maxProcesses: 120,
+    minSteps: 2,
+    minEdgeConfidence: 0.5,
+    minPathConfidence: 0.1,
+    maxBeamSize: 5000,
+};
+/** Detect processes (execution flows) in the knowledge graph, runs after community detection */
+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, cfg.minEdgeConfidence);
+    const reverseCallsEdges = buildReverseCallsGraph(knowledgeGraph, cfg.minEdgeConfidence);
+    const nodeMap = new Map();
+    for (const n of knowledgeGraph.iterNodes())
+        nodeMap.set(n.id, n);
+    // 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);
+    // 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);
+    // Deduplicate similar traces (subset removal)
+    const uniqueTraces = deduplicateTraces(allTraces);
+    // Deduplicate by entry+terminal pair (keep longest path per pair)
+    const endpointDeduped = deduplicateByEndpoints(uniqueTraces);
+    // D4: Merge traces that share ≥ 80% of their steps (near-duplicate paths)
+    // Two flows like [A,B,C,D,E] and [A,B,C,D,F] share 4/5 = 80% — keep the longer one
+    const prefixMerged = mergeSimilarTraces(endpointDeduped);
+    onProgress?.(`Deduped ${uniqueTraces.length} → ${prefixMerged.length} unique flows`, 70);
+    // Limit to max processes (prioritize longer traces)
+    const limitedTraces = prefixMerged
+        .sort((a, b) => b.length - a.length)
+        .slice(0, cfg.maxProcesses);
+    onProgress?.(`Creating ${limitedTraces.length} process nodes...`, 80);
+    // Create process nodes
+    const processes = [];
+    const steps = [];
+    // Build communityId -> heuristicLabel map from Community nodes in the graph
+    const communityLabels = new Map();
+    for (const n of knowledgeGraph.iterNodes()) {
+        if (n.label === 'Community') {
+            communityLabels.set(n.id, n.properties.heuristicLabel || n.properties.name || 'Unknown');
+        }
+    }
+    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 with module context from entry point's community
+        const entryNode = nodeMap.get(entryPointId);
+        const terminalNode = nodeMap.get(terminalId);
+        const entryName = entryNode?.properties.name || 'Unknown';
+        const terminalName = terminalNode?.properties.name || 'Unknown';
+        // Find the community for the entry point
+        const entryMembership = memberships.find(m => m.nodeId === entryPointId);
+        const entryModule = entryMembership ? communityLabels.get(entryMembership.communityId) : undefined;
+        const modulePrefix = entryModule && entryModule !== 'Unknown' ? `${entryModule}: ` : '';
+        const heuristicLabel = `${modulePrefix}${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,
+            });
+        });
+    });
+    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,
+        },
+    };
+};
+const buildCallsGraph = (graph, minEdgeConfidence) => {
+    const adj = new Map();
+    for (const rel of graph.iterRelationships()) {
+        if (rel.type === 'CALLS' && rel.confidence >= minEdgeConfidence) {
+            if (!adj.has(rel.sourceId)) {
+                adj.set(rel.sourceId, []);
+            }
+            adj.get(rel.sourceId).push({ targetId: rel.targetId, confidence: rel.confidence });
+        }
+    }
+    // Sort each caller's callees by confidence descending — beam search explores
+    // highest-confidence edges first within each expansion
+    for (const [, edges] of adj) {
+        edges.sort((a, b) => b.confidence - a.confidence);
+    }
+    return adj;
+};
+const buildReverseCallsGraph = (graph, minEdgeConfidence) => {
+    const adj = new Map();
+    for (const rel of graph.iterRelationships()) {
+        if (rel.type === 'CALLS' && rel.confidence >= minEdgeConfidence) {
+            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
+ *
+ * Scored by call ratio, export status, and name patterns; test files excluded
+ */
+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 calleeEdges = callsEdges.get(node.id) || [];
+        // Must have at least 1 outgoing call to trace forward
+        if (calleeEdges.length === 0)
+            continue;
+        // Calculate entry point score
+        const { score: baseScore, reasons } = calculateEntryPointScore(node.properties.name, node.properties.language ?? SupportedLanguages.JavaScript, node.properties.isExported ?? false, callers.length, calleeEdges.length, filePath);
+        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);
+    if (sorted.length > 0 && isDev) {
+        console.log(`[Process] Top 10 entry point candidates:`);
+        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.map(c => c.id);
+};
+/**
+ * Trace forward from an entry point using confidence-gated beam search.
+ *
+ * Instead of a static per-node branching limit, this follows ALL callees whose
+ * edge confidence meets the threshold, then prunes paths whose cumulative
+ * confidence (product of edge confidences along the path) drops below a floor.
+ *
+ * A global beam size caps the number of active paths in memory, ensuring bounded
+ * resource usage regardless of graph fan-out. Paths are explored in order of
+ * cumulative confidence (highest first), so well-resolved execution flows are
+ * discovered before speculative ones.
+ */
+const traceFromEntryPoint = (entryId, callsEdges, config) => {
+    const traces = [];
+    // Priority queue sorted by cumulative confidence descending
+    const beam = [{
+            cumulativeConf: 1.0,
+            currentId: entryId,
+            path: [entryId],
+            pathSet: new Set([entryId]),
+        }];
+    while (beam.length > 0) {
+        // Pop highest cumulative confidence
+        const entry = beam.shift();
+        const edges = callsEdges.get(entry.currentId) || [];
+        // Filter edges by per-edge confidence gate
+        const viable = edges.filter(e => e.confidence >= config.minEdgeConfidence);
+        if (viable.length === 0 || entry.path.length >= config.maxTraceDepth) {
+            // Terminal — record if long enough
+            if (entry.path.length >= config.minSteps) {
+                traces.push(entry.path);
+            }
+            continue;
+        }
+        let addedBranch = false;
+        for (const edge of viable) {
+            // O(1) cycle detection
+            if (entry.pathSet.has(edge.targetId))
+                continue;
+            const childConf = entry.cumulativeConf * edge.confidence;
+            // Prune paths whose cumulative confidence is too low
+            if (childConf < config.minPathConfidence)
+                continue;
+            const newPath = [...entry.path, edge.targetId];
+            const newSet = new Set(entry.pathSet);
+            newSet.add(edge.targetId);
+            const child = {
+                cumulativeConf: childConf,
+                currentId: edge.targetId,
+                path: newPath,
+                pathSet: newSet,
+            };
+            // Binary search for sorted insert (descending by cumulativeConf)
+            let lo = 0;
+            let hi = beam.length;
+            while (lo < hi) {
+                const mid = (lo + hi) >>> 1;
+                if (beam[mid].cumulativeConf > childConf)
+                    lo = mid + 1;
+                else
+                    hi = mid;
+            }
+            beam.splice(lo, 0, child);
+            addedBranch = true;
+        }
+        // Trim beam if it exceeds max size (drop lowest-confidence tails)
+        if (beam.length > config.maxBeamSize) {
+            beam.length = config.maxBeamSize;
+        }
+        if (!addedBranch && entry.path.length >= config.minSteps) {
+            traces.push(entry.path);
+        }
+    }
+    return traces;
+};
+/** Merge traces that are subsets of other traces, keeping longer ones */
+const deduplicateTraces = (traces) => {
+    if (traces.length === 0)
+        return [];
+    const sorted = [...traces].sort((a, b) => b.length - a.length);
+    const unique = [];
+    for (const trace of sorted) {
+        // Check if this trace is an ordered subsequence of any already-added trace.
+        // Fixed: previous string .includes() had false positives (e.g. "A->B" inside "A->B->D").
+        const isSubset = unique.some(existing => isOrderedSubsequence(trace, existing));
+        if (!isSubset) {
+            unique.push(trace);
+        }
+    }
+    return unique;
+};
+/** Check if every element of shorter appears in longer in the same order */
+function isOrderedSubsequence(shorter, longer) {
+    if (shorter.length >= longer.length)
+        return false;
+    let j = 0;
+    for (let i = 0; i < longer.length && j < shorter.length; i++) {
+        if (longer[i] === shorter[j])
+            j++;
+    }
+    return j === shorter.length;
+}
+/** Keep only the longest trace per unique entry->terminal pair */
+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());
+};
+/** D4: Merge traces that share ≥ 80% of steps — keeps the longer one.
+ *  Reduces near-duplicate flows like [A,B,C,D,E] and [A,B,C,D,F] to just the longer. */
+const mergeSimilarTraces = (traces) => {
+    if (traces.length <= 1)
+        return traces;
+    const sorted = [...traces].sort((a, b) => b.length - a.length);
+    const kept = [];
+    const removed = new Set();
+    for (let i = 0; i < sorted.length; i++) {
+        if (removed.has(i))
+            continue;
+        kept.push(sorted[i]);
+        // Check remaining traces for high overlap with this one
+        for (let j = i + 1; j < sorted.length; j++) {
+            if (removed.has(j))
+                continue;
+            const shorter = sorted[j];
+            const longer = sorted[i];
+            // Count shared steps
+            const longerSet = new Set(longer);
+            let shared = 0;
+            for (const step of shorter) {
+                if (longerSet.has(step))
+                    shared++;
+            }
+            // If ≥ 80% of the shorter trace's steps are in the longer trace, merge (remove shorter)
+            if (shared >= shorter.length * 0.8) {
+                removed.add(j);
+            }
+        }
+    }
+    return kept;
+};
+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,40 @@
+/**
+ * @file resolution-context.ts
+ * @description Single implementation of tiered name resolution
+ *
+ * Resolution tiers (highest confidence first):
+ *   1  Same file (lookupExactFull — authoritative)
+ *   2a 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';
+export type ResolutionTier = 'same-file' | 'import-scoped' | 'global';
+export interface TieredCandidates {
+    readonly candidates: readonly SymbolDefinition[];
+    readonly tier: ResolutionTier;
+}
+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 {
+    /** Resolve a name from a file, returning candidates at the winning tier */
+    resolve(name: string, fromFile: string): TieredCandidates | null;
+    readonly symbols: SymbolTable;
+    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,171 @@
+// code-mapper/src/core/ingestion/resolution-context.ts
+/**
+ * @file resolution-context.ts
+ * @description Single implementation of tiered name resolution
+ *
+ * Resolution tiers (highest confidence first):
+ *   1  Same file (lookupExactFull — authoritative)
+ *   2a 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
+        const chainResult = walkBindingChain(name, fromFile, symbols, namedImportMap, allDefs);
+        if (chainResult && chainResult.length > 0) {
+            return { candidates: chainResult, tier: 'import-scoped' };
+        }
+        if (allDefs.length === 0) {
+            // Don't exit early — still check import map. The symbol may be imported from another file.
+            // First try lookupExactFull with the exact imported file path
+            const importedFiles = importMap.get(fromFile);
+            if (importedFiles) {
+                for (const importedFile of importedFiles) {
+                    const imported = symbols.lookupExactFull(importedFile, name);
+                    if (imported)
+                        return { candidates: [imported], tier: 'import-scoped' };
+                }
+            }
+            // Fallback: try fuzzy lookup — the symbol may exist globally but path normalization differs
+            const fuzzyDefs = symbols.lookupFuzzy(name);
+            if (fuzzyDefs.length > 0) {
+                if (importedFiles) {
+                    const stripExt = (p) => p.replace(/\.[^.]+$/, '').replace(/\\/g, '/');
+                    const importedArr = Array.from(importedFiles).map(stripExt);
+                    const importedDefs = fuzzyDefs.filter(def => {
+                        const defStripped = stripExt(def.filePath);
+                        return importedArr.some(imp => defStripped.endsWith(imp) || imp.endsWith(defStripped)
+                            || defStripped.includes(imp) || imp.includes(defStripped));
+                    });
+                    if (importedDefs.length > 0) {
+                        return { candidates: importedDefs, tier: 'import-scoped' };
+                    }
+                }
+                // Last resort: if there's exactly one global definition and it's a Function, use it
+                // This handles cross-file calls where the import map fails but the symbol is unique
+                if (fuzzyDefs.length === 1 && (fuzzyDefs[0].type === 'Function' || fuzzyDefs[0].type === 'Method')) {
+                    return { candidates: fuzzyDefs, tier: 'global' };
+                }
+            }
+            return null;
+        }
+        // Tier 2a: Import-scoped — definition in a file imported by fromFile
+        const importedFiles = importMap.get(fromFile);
+        if (importedFiles) {
+            // First try exact match
+            let importedDefs = allDefs.filter(def => importedFiles.has(def.filePath));
+            // Fallback: suffix matching for path normalization + extension differences (.ts vs .js)
+            if (importedDefs.length === 0) {
+                const stripExt = (p) => p.replace(/\.[^.]+$/, '').replace(/\\/g, '/');
+                const importedArr = Array.from(importedFiles).map(stripExt);
+                importedDefs = allDefs.filter(def => {
+                    const defStripped = stripExt(def.filePath);
+                    return importedArr.some(imp => defStripped.endsWith(imp) || imp.endsWith(defStripped)
+                        || defStripped.includes(imp) || imp.includes(defStripped));
+                });
+            }
+            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 — consumers must check candidate count for ambiguity
+        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 to reduce GC pressure
+        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,10 @@
+/** @file C# namespace import resolution via .csproj root namespace stripping */
+import type { SuffixIndex } from './utils.js';
+export interface CSharpProjectConfig {
+    rootNamespace: string;
+    projectDir: string;
+}
+/** Resolve a C# using-directive to matching .cs files (single-file or directory match) */
+export declare function resolveCSharpImport(importPath: string, csharpConfigs: CSharpProjectConfig[], normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string[];
+/** Compute the directory suffix for a C# namespace import (e.g., "/ProjectDir/Models/") */
+export declare function resolveCSharpNamespaceDir(importPath: string, csharpConfigs: CSharpProjectConfig[]): string | null;

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

@@ -0,0 +1,101 @@
+// code-mapper/src/core/ingestion/resolvers/csharp.ts
+/** @file C# namespace import resolution via .csproj root namespace stripping */
+import { suffixResolve } from './utils.js';
+/** Resolve a C# using-directive to matching .cs files (single-file or directory match) */
+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) {
+            // 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 (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 direct .cs children (namespace import)
+        if (index) {
+            const dirFiles = index.getFilesInDir(dirPrefix, '.cs');
+            for (const f of dirFiles) {
+                const normalized = f.replace(/\\/g, '/');
+                // Ensure file is a direct child (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
+    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 (e.g., "/ProjectDir/Models/") */
+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;
+}