gitnexus 1.4.5 → 1.4.6

package/dist/cli/eval-server.js

@@ -24,6 +24,7 @@
  *   POST /shutdown     — Graceful shutdown.
  */
 import http from 'http';
+import { writeSync } from 'node:fs';
 import { LocalBackend } from '../mcp/local/local-backend.js';
 // ─── Text Formatters ──────────────────────────────────────────────────
 // Convert structured JSON results into compact, LLM-friendly text.
@@ -121,8 +122,10 @@ export function formatContextResult(result) {
     return lines.join('\n').trim();
 }
 export function formatImpactResult(result) {
-    if (result.error)
-        return `Error: ${result.error}`;
+    if (result.error) {
+        const suggestion = result.suggestion ? `\nSuggestion: ${result.suggestion}` : '';
+        return `Error: ${result.error}${suggestion}`;
+    }
     const target = result.target;
     const direction = result.direction;
     const byDepth = result.byDepth || {};
@@ -132,7 +135,11 @@ export function formatImpactResult(result) {
     }
     const lines = [];
     const dirLabel = direction === 'upstream' ? 'depends on this (will break if changed)' : 'this depends on';
-    lines.push(`Blast radius for ${target?.kind || ''} ${target?.name} (${direction}): ${total} symbol(s) ${dirLabel}\n`);
+    lines.push(`Blast radius for ${target?.kind || ''} ${target?.name} (${direction}): ${total} symbol(s) ${dirLabel}`);
+    if (result.partial) {
+        lines.push('⚠️  Partial results — graph traversal was interrupted. Deeper impacts may exist.');
+    }
+    lines.push('');
     const depthLabels = {
         1: 'WILL BREAK (direct)',
         2: 'LIKELY AFFECTED (indirect)',
@@ -346,10 +353,11 @@ export async function evalServerCommand(options) {
             console.error(`  Auto-shutdown after ${idleTimeoutSec}s idle`);
         }
         try {
-            process.stdout.write(`GITNEXUS_EVAL_SERVER_READY:${port}\n`);
+            // Use fd 1 directly — LadybugDB captures process.stdout (#324)
+            writeSync(1, `GITNEXUS_EVAL_SERVER_READY:${port}\n`);
         }
         catch {
-            // stdout may not be available
+            // stdout may not be available (e.g., broken pipe)
         }
     });
     resetIdleTimer();

package/dist/cli/tool.d.ts

@@ -10,8 +10,9 @@
  *   gitnexus impact --target "AuthService" --direction upstream
  *   gitnexus cypher "MATCH (n:Function) RETURN n.name LIMIT 10"
  *
- * Note: Output goes to stderr because LadybugDB's native module captures stdout
- * at the OS level during init. This is consistent with augment.ts.
+ * Note: Output goes to stdout via fs.writeSync(fd 1), bypassing LadybugDB's
+ * native module which captures the Node.js process.stdout stream during init.
+ * See the output() function for details (#324).
  */
 export declare function queryCommand(queryText: string, options?: {
     repo?: string;

package/dist/cli/tool.js

@@ -10,9 +10,11 @@
  *   gitnexus impact --target "AuthService" --direction upstream
  *   gitnexus cypher "MATCH (n:Function) RETURN n.name LIMIT 10"
  *
- * Note: Output goes to stderr because LadybugDB's native module captures stdout
- * at the OS level during init. This is consistent with augment.ts.
+ * Note: Output goes to stdout via fs.writeSync(fd 1), bypassing LadybugDB's
+ * native module which captures the Node.js process.stdout stream during init.
+ * See the output() function for details (#324).
  */
+import { writeSync } from 'node:fs';
 import { LocalBackend } from '../mcp/local/local-backend.js';
 let _backend = null;
 async function getBackend() {
@@ -26,10 +28,30 @@ async function getBackend() {
     }
     return _backend;
 }
+/**
+ * Write tool output to stdout using low-level fd write.
+ *
+ * LadybugDB's native module captures Node.js process.stdout during init,
+ * but the underlying OS file descriptor 1 (stdout) remains intact.
+ * By using fs.writeSync(1, ...) we bypass the Node.js stream layer
+ * and write directly to the real stdout fd (#324).
+ *
+ * Falls back to stderr if the fd write fails (e.g., broken pipe).
+ */
 function output(data) {
     const text = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
-    // stderr because LadybugDB captures stdout at OS level
-    process.stderr.write(text + '\n');
+    try {
+        writeSync(1, text + '\n');
+    }
+    catch (err) {
+        if (err?.code === 'EPIPE') {
+            // Consumer closed the pipe (e.g., `gitnexus cypher ... | head -1`)
+            // Exit cleanly per Unix convention
+            process.exit(0);
+        }
+        // Fallback: stderr (previous behavior, works on all platforms)
+        process.stderr.write(text + '\n');
+    }
 }
 export async function queryCommand(queryText, options) {
     if (!queryText?.trim()) {
@@ -67,15 +89,28 @@ export async function impactCommand(target, options) {
         console.error('Usage: gitnexus impact <symbol_name> [--direction upstream|downstream]');
         process.exit(1);
     }
-    const backend = await getBackend();
-    const result = await backend.callTool('impact', {
-        target,
-        direction: options?.direction || 'upstream',
-        maxDepth: options?.depth ? parseInt(options.depth) : undefined,
-        includeTests: options?.includeTests ?? false,
-        repo: options?.repo,
-    });
-    output(result);
+    try {
+        const backend = await getBackend();
+        const result = await backend.callTool('impact', {
+            target,
+            direction: options?.direction || 'upstream',
+            maxDepth: options?.depth ? parseInt(options.depth, 10) : undefined,
+            includeTests: options?.includeTests ?? false,
+            repo: options?.repo,
+        });
+        output(result);
+    }
+    catch (err) {
+        // Belt-and-suspenders: catch infrastructure failures (getBackend, callTool transport)
+        // The backend's impact() already returns structured errors for graph query failures
+        output({
+            error: (err instanceof Error ? err.message : String(err)) || 'Impact analysis failed unexpectedly',
+            target: { name: target },
+            direction: options?.direction || 'upstream',
+            suggestion: 'Try reducing --depth or using gitnexus context <symbol> as a fallback',
+        });
+        process.exit(1);
+    }
 }
 export async function cypherCommand(query, options) {
     if (!query?.trim()) {

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

@@ -6,7 +6,6 @@ export declare const processCalls: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;
 }[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<ExtractedHeritage[]>;
-export declare const extractReturnTypeName: (raw: string, depth?: number) => string | undefined;
 /**
  * Fast path: resolve pre-extracted call sites from workers.
  * No AST parsing — workers already extracted calledName + sourceId.

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

@@ -7,6 +7,7 @@ import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop, F
 import { buildTypeEnv } from './type-env.js';
 import { getTreeSitterBufferSize } from './constants.js';
 import { callRouters } from './call-routing.js';
+import { extractReturnTypeName } from './type-extractors/shared.js';
 /**
  * Walk up the AST from a node to find the enclosing function/method.
  * Returns null if the call is at module/file level (top-level code).
@@ -386,138 +387,6 @@ const resolveCallTarget = (call, currentFile, ctx) => {
         return null;
     return toResolveResult(filteredCandidates[0], tiered.tier);
 };
-// ── Return type text helpers ─────────────────────────────────────────────
-// extractSimpleTypeName works on AST nodes; this operates on raw return-type
-// text already stored in SymbolDefinition (e.g. "User", "Promise<User>",
-// "User | null", "*User").  Extracts the base user-defined type name.
-/** Primitive / built-in types that should NOT produce a receiver binding. */
-const PRIMITIVE_TYPES = new Set([
-    'string', 'number', 'boolean', 'void', 'int', 'float', 'double', 'long',
-    'short', 'byte', 'char', 'bool', 'str', 'i8', 'i16', 'i32', 'i64',
-    'u8', 'u16', 'u32', 'u64', 'f32', 'f64', 'usize', 'isize',
-    'undefined', 'null', 'None', 'nil',
-]);
-/**
- * Extract a simple type name from raw return-type text.
- * Handles common patterns:
- *   "User"                → "User"
- *   "Promise<User>"       → "User"   (unwrap wrapper generics)
- *   "Option<User>"        → "User"
- *   "Result<User, Error>" → "User"   (first type arg)
- *   "User | null"         → "User"   (strip nullable union)
- *   "User?"               → "User"   (strip nullable suffix)
- *   "*User"               → "User"   (Go pointer)
- *   "&User"               → "User"   (Rust reference)
- * Returns undefined for complex types or primitives.
- */
-const WRAPPER_GENERICS = new Set([
-    'Promise', 'Observable', 'Future', 'CompletableFuture', 'Task', 'ValueTask', // async wrappers
-    'Option', 'Some', 'Optional', 'Maybe', // nullable wrappers
-    'Result', 'Either', // result wrappers
-    // Rust smart pointers (Deref to inner type)
-    'Rc', 'Arc', 'Weak', // pointer types
-    'MutexGuard', 'RwLockReadGuard', 'RwLockWriteGuard', // guard types
-    'Ref', 'RefMut', // RefCell guards
-    'Cow', // copy-on-write
-    // Containers (List, Array, Vec, Set, etc.) are intentionally excluded —
-    // methods are called on the container, not the element type.
-    // Non-wrapper generics return the base type (e.g., List) via the else branch.
-]);
-/**
- * Extracts the first type argument from a comma-separated generic argument string,
- * respecting nested angle brackets. For example:
- *   "Result<User, Error>"  → "Result<User, Error>"  (no top-level comma)
- *   "User, Error"          → "User"
- *   "Map<K, V>, string"    → "Map<K, V>"
- */
-function extractFirstGenericArg(args) {
-    let depth = 0;
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === '<')
-            depth++;
-        else if (args[i] === '>')
-            depth--;
-        else if (args[i] === ',' && depth === 0)
-            return args.slice(0, i).trim();
-    }
-    return args.trim();
-}
-/**
- * Extract the first non-lifetime type argument from a generic argument string.
- * Skips Rust lifetime parameters (e.g., `'a`, `'_`) to find the actual type.
- *   "'_, User"       → "User"
- *   "'a, User"       → "User"
- *   "User, Error"    → "User"  (no lifetime — delegates to extractFirstGenericArg)
- */
-function extractFirstTypeArg(args) {
-    let remaining = args;
-    while (remaining) {
-        const first = extractFirstGenericArg(remaining);
-        if (!first.startsWith("'"))
-            return first;
-        // Skip past this lifetime arg + the comma separator
-        const commaIdx = remaining.indexOf(',', first.length);
-        if (commaIdx < 0)
-            return first; // only lifetimes — fall through
-        remaining = remaining.slice(commaIdx + 1).trim();
-    }
-    return args.trim();
-}
-const MAX_RETURN_TYPE_INPUT_LENGTH = 2048;
-const MAX_RETURN_TYPE_LENGTH = 512;
-export const extractReturnTypeName = (raw, depth = 0) => {
-    if (depth > 10)
-        return undefined;
-    if (raw.length > MAX_RETURN_TYPE_INPUT_LENGTH)
-        return undefined;
-    let text = raw.trim();
-    if (!text)
-        return undefined;
-    // Strip pointer/reference prefixes: *User, &User, &mut User
-    text = text.replace(/^[&*]+\s*(mut\s+)?/, '');
-    // Strip nullable suffix: User?
-    text = text.replace(/\?$/, '');
-    // Handle union types: "User | null" → "User"
-    if (text.includes('|')) {
-        const parts = text.split('|').map(p => p.trim()).filter(p => p !== 'null' && p !== 'undefined' && p !== 'void' && p !== 'None' && p !== 'nil');
-        if (parts.length === 1)
-            text = parts[0];
-        else
-            return undefined; // genuine union — too complex
-    }
-    // Handle generics: Promise<User> → unwrap if wrapper, else take base
-    const genericMatch = text.match(/^(\w+)\s*<(.+)>$/);
-    if (genericMatch) {
-        const [, base, args] = genericMatch;
-        if (WRAPPER_GENERICS.has(base)) {
-            // Take the first non-lifetime type argument, using bracket-balanced splitting
-            // so that nested generics like Result<User, Error> are not split at the inner
-            // comma. Lifetime parameters (Rust 'a, '_) are skipped.
-            const firstArg = extractFirstTypeArg(args);
-            return extractReturnTypeName(firstArg, depth + 1);
-        }
-        // Non-wrapper generic: return the base type (e.g., Map<K,V> → Map)
-        return PRIMITIVE_TYPES.has(base.toLowerCase()) ? undefined : base;
-    }
-    // Bare wrapper type without generic argument (e.g. Task, Promise, Option)
-    // should not produce a binding — these are meaningless without a type parameter
-    if (WRAPPER_GENERICS.has(text))
-        return undefined;
-    // Handle qualified names: models.User → User, Models::User → User, \App\Models\User → User
-    if (text.includes('::') || text.includes('.') || text.includes('\\')) {
-        text = text.split(/::|[.\\]/).pop();
-    }
-    // Final check: skip primitives
-    if (PRIMITIVE_TYPES.has(text) || PRIMITIVE_TYPES.has(text.toLowerCase()))
-        return undefined;
-    // Must start with uppercase (class/type convention) or be a valid identifier
-    if (!/^[A-Z_]\w*$/.test(text))
-        return undefined;
-    // If the final extracted type name is too long, reject it
-    if (text.length > MAX_RETURN_TYPE_LENGTH)
-        return undefined;
-    return text;
-};
 // ── Scope key helpers ────────────────────────────────────────────────────
 // Scope keys use the format "funcName@startIndex" (produced by type-env.ts).
 // Source IDs use "Label:filepath:funcName" (produced by parse-worker.ts).

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

@@ -201,10 +201,13 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                 ? extractMethodSignature(definitionNode)
                 : undefined;
             // Language-specific return type fallback (e.g. Ruby YARD @return [Type])
-            if (methodSig && !methodSig.returnType && definitionNode) {
+            // Also upgrades uninformative AST types like PHP `array` with PHPDoc `@return User[]`
+            if (methodSig && (!methodSig.returnType || methodSig.returnType === 'array' || methodSig.returnType === 'iterable') && definitionNode) {
                 const tc = typeConfigs[language];
                 if (tc?.extractReturnType) {
-                    methodSig.returnType = tc.extractReturnType(definitionNode);
+                    const docReturn = tc.extractReturnType(definitionNode);
+                    if (docReturn)
+                        methodSig.returnType = docReturn;
                 }
             }
             const node = {

package/dist/core/ingestion/symbol-table.d.ts

@@ -32,6 +32,12 @@ export interface SymbolTable {
      * Used when imports are missing or for framework magic
      */
     lookupFuzzy: (name: string) => SymbolDefinition[];
+    /**
+     * Low Confidence: Look for callable symbols (Function/Method/Constructor) by name.
+     * Faster than `lookupFuzzy` + filter — backed by a lazy callable-only index.
+     * Used by ReturnTypeLookup to resolve callee → return type.
+     */
+    lookupFuzzyCallable: (name: string) => SymbolDefinition[];
     /**
      * Debugging: See how many symbols are tracked
      */

package/dist/core/ingestion/symbol-table.js

@@ -5,6 +5,11 @@ export const createSymbolTable = () => {
     // 2. Global Reverse Index (The "Backup")
     // Structure: SymbolName -> [List of Definitions]
     const globalIndex = new Map();
+    // 3. Lazy Callable Index — populated on first lookupFuzzyCallable call.
+    // Structure: SymbolName -> [Callable Definitions]
+    // Only Function, Method, Constructor symbols are indexed.
+    let callableIndex = null;
+    const CALLABLE_TYPES = new Set(['Function', 'Method', 'Constructor']);
     const add = (filePath, name, nodeId, type, metadata) => {
         const def = {
             nodeId,
@@ -24,6 +29,8 @@ export const createSymbolTable = () => {
             globalIndex.set(name, []);
         }
         globalIndex.get(name).push(def);
+        // Invalidate the lazy callable index — it will be rebuilt on next use
+        callableIndex = null;
     };
     const lookupExact = (filePath, name) => {
         return fileIndex.get(filePath)?.get(name)?.nodeId;
@@ -34,6 +41,18 @@ export const createSymbolTable = () => {
     const lookupFuzzy = (name) => {
         return globalIndex.get(name) || [];
     };
+    const lookupFuzzyCallable = (name) => {
+        if (!callableIndex) {
+            // Build the callable index lazily on first use
+            callableIndex = new Map();
+            for (const [symName, defs] of globalIndex) {
+                const callables = defs.filter(d => CALLABLE_TYPES.has(d.type));
+                if (callables.length > 0)
+                    callableIndex.set(symName, callables);
+            }
+        }
+        return callableIndex.get(name) ?? [];
+    };
     const getStats = () => ({
         fileCount: fileIndex.size,
         globalSymbolCount: globalIndex.size
@@ -41,6 +60,7 @@ export const createSymbolTable = () => {
     const clear = () => {
         fileIndex.clear();
         globalIndex.clear();
+        callableIndex = null;
     };
-    return { add, lookupExact, lookupExactFull, lookupFuzzy, getStats, clear };
+    return { add, lookupExact, lookupExactFull, lookupFuzzy, lookupFuzzyCallable, getStats, clear };
 };

package/dist/core/ingestion/type-env.js

@@ -1,6 +1,6 @@
-import { FUNCTION_NODE_TYPES, extractFunctionName, CLASS_CONTAINER_TYPES } from './utils.js';
+import { FUNCTION_NODE_TYPES, extractFunctionName, CLASS_CONTAINER_TYPES, isBuiltInOrNoise } from './utils.js';
 import { typeConfigs, TYPED_PARAMETER_TYPES } from './type-extractors/index.js';
-import { extractSimpleTypeName, extractVarName, stripNullable } from './type-extractors/shared.js';
+import { extractSimpleTypeName, extractVarName, stripNullable, extractReturnTypeName } from './type-extractors/shared.js';
 /** File-level scope key */
 const FILE_SCOPE = '';
 /** Fallback for languages where class names aren't in a 'name' field (e.g. Kotlin uses type_identifier). */
@@ -303,13 +303,45 @@ export const buildTypeEnv = (tree, language, symbolTable) => {
     const classNames = createClassNameLookup(localClassNames, symbolTable);
     const config = typeConfigs[language];
     const bindings = [];
+    // Build ReturnTypeLookup from optional SymbolTable.
+    // Conservative: returns undefined when callee is ambiguous (0 or 2+ matches).
+    const returnTypeLookup = {
+        lookupReturnType(callee) {
+            if (!symbolTable)
+                return undefined;
+            if (isBuiltInOrNoise(callee))
+                return undefined;
+            const callables = symbolTable.lookupFuzzyCallable(callee);
+            if (callables.length !== 1)
+                return undefined;
+            const rawReturn = callables[0].returnType;
+            if (!rawReturn)
+                return undefined;
+            return extractReturnTypeName(rawReturn);
+        },
+        lookupRawReturnType(callee) {
+            if (!symbolTable)
+                return undefined;
+            if (isBuiltInOrNoise(callee))
+                return undefined;
+            const callables = symbolTable.lookupFuzzyCallable(callee);
+            if (callables.length !== 1)
+                return undefined;
+            return callables[0].returnType;
+        }
+    };
     // Pre-compute combined set of node types that need extractTypeBinding.
     // Single Set.has() replaces 3 separate checks per node in walk().
     const interestingNodeTypes = new Set();
     TYPED_PARAMETER_TYPES.forEach(t => interestingNodeTypes.add(t));
     config.declarationNodeTypes.forEach(t => interestingNodeTypes.add(t));
     config.forLoopNodeTypes?.forEach(t => interestingNodeTypes.add(t));
-    const pendingAssignments = [];
+    // Tier 2: copy-propagation (`const b = a`) and call-result propagation (`const b = foo()`)
+    const pendingCopies = [];
+    // NOTE: Infrastructure-ready — no language extractor currently returns { kind: 'callResult' }
+    // from extractPendingAssignment. When one does, this array will bind variables to their
+    // function return types at TypeEnv build time. See PendingAssignment in types.ts.
+    const pendingCallResults = [];
     // Maps `scope\0varName` → the type annotation AST node from the original declaration.
     // Allows pattern extractors to navigate back to the declaration's generic type arguments
     // (e.g., to extract T from Result<T, E> for `if let Ok(x) = res`).
@@ -376,7 +408,10 @@ export const buildTypeEnv = (tree, language, symbolTable) => {
         // For-each loop variable bindings (Java/C#/Kotlin): explicit element types in the AST.
         // Checked before declarationNodeTypes — loop variables are not declarations.
         if (config.forLoopNodeTypes?.has(node.type)) {
-            config.extractForLoopBinding?.(node, scopeEnv, declarationTypeNodes, scope);
+            if (config.extractForLoopBinding) {
+                const forLoopCtx = { scopeEnv, declarationTypeNodes, scope, returnTypeLookup };
+                config.extractForLoopBinding(node, forLoopCtx);
+            }
             return;
         }
         if (config.declarationNodeTypes.has(node.type)) {
@@ -514,7 +549,12 @@ export const buildTypeEnv = (tree, language, symbolTable) => {
             if (scopeEnv) {
                 const pending = config.extractPendingAssignment(node, scopeEnv);
                 if (pending) {
-                    pendingAssignments.push({ scope, ...pending });
+                    if (pending.kind === 'copy') {
+                        pendingCopies.push({ scope, lhs: pending.lhs, rhs: pending.rhs });
+                    }
+                    else {
+                        pendingCallResults.push({ scope, lhs: pending.lhs, callee: pending.callee });
+                    }
                 }
             }
         }
@@ -537,19 +577,31 @@ export const buildTypeEnv = (tree, language, symbolTable) => {
         }
     };
     walk(tree.rootNode, FILE_SCOPE);
-    // Tier 2: single-pass assignment chain propagation in source order.
-    // Resolves `const b = a` where `a` has a known type from Tier 0/1.
+    // Tier 2a: copy-propagation — `const b = a` where `a` has a known type from Tier 0/1.
     // Multi-hop chains resolve when forward-declared (a→b→c in source order);
     // reverse-order assignments are depth-1 only. No fixpoint iteration —
     // this covers 95%+ of real-world patterns.
-    for (const { scope, lhs, rhs } of pendingAssignments) {
+    for (const { scope, lhs, rhs } of pendingCopies) {
         const scopeEnv = env.get(scope);
         if (!scopeEnv || scopeEnv.has(lhs))
             continue;
         const rhsType = scopeEnv.get(rhs) ?? env.get(FILE_SCOPE)?.get(rhs);
-        if (rhsType) {
+        if (rhsType)
             scopeEnv.set(lhs, rhsType);
-        }
+    }
+    // Tier 2b: call-result propagation — `const b = foo()` where `foo` has a declared return type.
+    // Uses ReturnTypeLookup which is backed by SymbolTable.lookupFuzzyCallable.
+    // Conservative: only binds when exactly one callable matches (avoids overload ambiguity).
+    // NOTE: Currently dormant — no extractPendingAssignment implementation emits 'callResult' yet.
+    // The loop is structurally complete and will activate when any language extractor starts
+    // returning { kind: 'callResult', lhs, callee } from extractPendingAssignment.
+    for (const { scope, lhs, callee } of pendingCallResults) {
+        const scopeEnv = env.get(scope);
+        if (!scopeEnv || scopeEnv.has(lhs))
+            continue;
+        const typeName = returnTypeLookup.lookupReturnType(callee);
+        if (typeName)
+            scopeEnv.set(lhs, typeName);
     }
     return {
         lookup: (varName, callNode) => lookupInEnv(env, varName, callNode, patternOverrides),

package/dist/core/ingestion/type-extractors/c-cpp.js

@@ -198,7 +198,7 @@ const extractPendingAssignment = (node, scopeEnv) => {
     const lhs = extractVarName(finalName);
     if (!lhs || scopeEnv.has(lhs))
         return undefined;
-    return { lhs, rhs: value.text };
+    return { kind: 'copy', lhs, rhs: value.text };
 };
 // --- For-loop Tier 1c ---
 const FOR_LOOP_NODE_TYPES = new Set(['for_range_loop']);
@@ -291,7 +291,7 @@ const findCppParamElementType = (iterableName, startNode, pos = 'last') => {
 /** C++: for (auto& user : users) — extract loop variable binding.
  *  Handles explicit types (for (User& user : users)) and auto (for (auto& user : users)).
  *  For auto, resolves element type from the iterable's container type. */
-const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
+const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope }) => {
     if (node.type !== 'for_range_loop')
         return;
     const typeNode = node.childForFieldName('type');

package/dist/core/ingestion/type-extractors/csharp.js

@@ -1,4 +1,4 @@
-import { extractSimpleTypeName, extractVarName, findChildByType, unwrapAwait, resolveIterableElementType, methodToTypeArgPosition } from './shared.js';
+import { extractSimpleTypeName, extractVarName, findChildByType, unwrapAwait, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString } from './shared.js';
 /** Known container property accessors that operate on the container itself (e.g., dict.Keys, dict.Values) */
 const KNOWN_CONTAINER_PROPS = new Set(['Keys', 'Values']);
 const DECLARATION_NODE_TYPES = new Set([
@@ -214,7 +214,7 @@ const findCSharpParamElementType = (iterableName, startNode, pos = 'last') => {
 };
 /** C#: foreach (User user in users) — extract loop variable binding.
  *  Tier 1c: for `foreach (var user in users)`, resolves element type from iterable. */
-const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
+const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope, returnTypeLookup }) => {
     const typeNode = node.childForFieldName('type');
     const nameNode = node.childForFieldName('left');
     if (!typeNode || !nameNode)
@@ -233,6 +233,7 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
     const rightNode = node.childForFieldName('right');
     let iterableName;
     let methodName;
+    let callExprElementType;
     if (rightNode?.type === 'identifier') {
         iterableName = rightNode.text;
     }
@@ -261,6 +262,7 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
     }
     else if (rightNode?.type === 'invocation_expression') {
         // C# method call: data.Select(...) → invocation_expression > member_access_expression
+        // Direct function call: GetUsers() → invocation_expression > identifier
         const fn = rightNode.firstNamedChild;
         if (fn?.type === 'member_access_expression') {
             const obj = fn.childForFieldName('expression');
@@ -270,12 +272,24 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
             if (prop?.type === 'identifier')
                 methodName = prop.text;
         }
+        else if (fn?.type === 'identifier') {
+            // Direct function call: foreach (var u in GetUsers())
+            const rawReturn = returnTypeLookup.lookupRawReturnType(fn.text);
+            if (rawReturn)
+                callExprElementType = extractElementTypeFromString(rawReturn);
+        }
     }
-    if (!iterableName)
+    if (!iterableName && !callExprElementType)
         return;
-    const containerTypeName = scopeEnv.get(iterableName);
-    const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName);
-    const elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractCSharpElementTypeFromTypeNode, findCSharpParamElementType, typeArgPos);
+    let elementType;
+    if (callExprElementType) {
+        elementType = callExprElementType;
+    }
+    else {
+        const containerTypeName = scopeEnv.get(iterableName);
+        const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName);
+        elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractCSharpElementTypeFromTypeNode, findCSharpParamElementType, typeArgPos);
+    }
     if (elementType)
         scopeEnv.set(varName, elementType);
 };
@@ -351,7 +365,7 @@ const extractPendingAssignment = (node, scopeEnv) => {
         }
         const valueNode = evc?.firstNamedChild ?? child.namedChild(child.namedChildCount - 1);
         if (valueNode && valueNode !== nameNode && (valueNode.type === 'identifier' || valueNode.type === 'simple_identifier')) {
-            return { lhs, rhs: valueNode.text };
+            return { kind: 'copy', lhs, rhs: valueNode.text };
         }
     }
     return undefined;