openlore 2.0.2 → 2.0.4

package/dist/core/analyzer/call-graph.js

@@ -16,6 +16,8 @@ import Parser from 'tree-sitter';
 import { FunctionRegistryTrie } from './function-registry-trie.js';
 import { inferTypesFromSource, resolveViaTypeInference } from './type-inference-engine.js';
 import { extractAllHttpEdges } from './http-route-parser.js';
+import { buildProjectedIac } from './iac/index.js';
+import { logger } from '../../utils/logger.js';
 // ============================================================================
 // CONSTANTS
 // ============================================================================
@@ -1167,6 +1169,494 @@ async function extractSwiftGraph(filePath, content) {
     return { nodes, rawEdges };
 }
 // ============================================================================
+// ADDITIONAL GENERAL-PURPOSE LANGUAGES (spec-08)
+// ============================================================================
+//
+// C#, Kotlin, PHP, C, Scala, Dart, Lua, Elixir, Bash. Each follows the existing
+// extractor pattern (lazy soft-loaded grammar + FN/CALL queries + dispatch).
+// Grammars are native modules; loaders fail SOFT (graceful degradation): a
+// missing/ABI-incompatible grammar logs one warning and skips graphing for that
+// language without aborting analyze or any other language.
+const _warnedUnavailable = new Set();
+const _grammarHandleCache = new Map();
+function warnUnavailable(language, err) {
+    if (!_warnedUnavailable.has(language)) {
+        _warnedUnavailable.add(language);
+        logger.warning(`language ${language} grammar unavailable — files will be indexed for search but not graphed (${err.message})`);
+    }
+    return null;
+}
+/** Native tree-sitter loader. Returns a uniform handle, or null when unavailable. */
+async function loadGrammarSoft(language, importer, pick) {
+    if (_grammarHandleCache.has(language))
+        return _grammarHandleCache.get(language);
+    try {
+        const mod = (await importer());
+        const lang = pick(mod);
+        if (!lang)
+            throw new Error('grammar export resolved to undefined');
+        const parser = new Parser();
+        parser.setLanguage(lang);
+        const handle = {
+            withTree: (content, fn) => {
+                const tree = parser.parse(content);
+                const root = tree.rootNode;
+                const runQuery = (src) => {
+                    try {
+                        const q = new Parser.Query(lang, src);
+                        return q.matches(tree.rootNode);
+                    }
+                    catch {
+                        return [];
+                    }
+                };
+                return fn(root, runQuery);
+            },
+        };
+        _grammarHandleCache.set(language, handle);
+        return handle;
+    }
+    catch (err) {
+        _grammarHandleCache.set(language, warnUnavailable(language, err));
+        return null;
+    }
+}
+/**
+ * WASM grammar loader via web-tree-sitter (ABI-agnostic, portable). Used for
+ * grammars with no host-ABI-compatible native build (Dart, Lua). Soft-fails.
+ */
+async function loadWasmGrammarSoft(language, wasmSpecifier) {
+    const cacheKey = `wasm:${language}`;
+    if (_grammarHandleCache.has(cacheKey))
+        return _grammarHandleCache.get(cacheKey);
+    try {
+        const { createRequire } = await import('node:module');
+        const { readFile } = await import('node:fs/promises');
+        const req = createRequire(import.meta.url);
+        const wasmPath = req.resolve(wasmSpecifier);
+        // Load the wasm bytes ourselves and hand web-tree-sitter a Uint8Array, so it
+        // never does its own `require("fs/promises")` (which breaks under ESM/vitest).
+        const wasmBytes = new Uint8Array(await readFile(wasmPath));
+        // CRITICAL: each WASM grammar gets its OWN web-tree-sitter module instance.
+        // web-tree-sitter is a singleton emscripten module with a shared heap; loading
+        // two different grammars into one instance corrupts parsing (a Dart parse
+        // silently breaks subsequent Lua parses). Busting the require cache before each
+        // grammar yields an isolated runtime + heap per grammar, so they never interfere.
+        for (const k of Object.keys(req.cache)) {
+            if (k.includes('web-tree-sitter'))
+                delete req.cache[k];
+        }
+        const TS = req('web-tree-sitter');
+        const ParserCtor = (TS.default ?? TS.Parser ?? TS);
+        if (typeof ParserCtor.init === 'function')
+            await ParserCtor.init();
+        const LanguageNs = (TS.Language ?? ParserCtor.Language);
+        const lang = await LanguageNs.load(wasmBytes);
+        const handle = {
+            withTree: (content, fn) => {
+                // Fresh parser + explicit tree/query disposal: web-tree-sitter holds the
+                // parse tree in WASM heap, which corrupts the next parse if not freed.
+                const p = new ParserCtor();
+                p.setLanguage(lang);
+                const tree = p.parse(content);
+                const queries = [];
+                const runQuery = (src) => {
+                    try {
+                        const q = lang.query(src);
+                        queries.push(q);
+                        return q.matches(tree.rootNode);
+                    }
+                    catch {
+                        return [];
+                    }
+                };
+                try {
+                    return fn(tree.rootNode, runQuery);
+                }
+                finally {
+                    for (const q of queries)
+                        q.delete?.();
+                    tree.delete?.();
+                    p.delete?.();
+                }
+            },
+        };
+        _grammarHandleCache.set(cacheKey, handle);
+        return handle;
+    }
+    catch (err) {
+        _grammarHandleCache.set(cacheKey, warnUnavailable(language, err));
+        return null;
+    }
+}
+/** Reset loader caches — test-only hook for the graceful-degradation test. */
+export function __resetGrammarCacheForTests() {
+    _grammarHandleCache.clear();
+    _warnedUnavailable.clear();
+}
+const NAME_CHILD_TYPES = new Set(['identifier', 'name', 'type_identifier', 'simple_identifier', 'word']);
+/** Walk up from a node to the nearest grouping construct; return its declared name. */
+function enclosingGroupName(node, classTypes) {
+    let cursor = node.parent;
+    while (cursor) {
+        if (classTypes.has(cursor.type)) {
+            const nameNode = cursor.namedChildren.find(c => NAME_CHILD_TYPES.has(c.type))
+                ?? cursor.childForFieldName('name') ?? undefined;
+            if (nameNode)
+                return nameNode.text;
+        }
+        cursor = cursor.parent;
+    }
+    return undefined;
+}
+/**
+ * Generic query-driven extractor shared by the structurally-similar languages.
+ * Mirrors the Java extractor's shape; per-language differences are expressed
+ * via the QueryLangSpec rather than copy-pasted bodies.
+ */
+async function extractByQueries(spec, filePath, content) {
+    const handle = await spec.loader();
+    if (!handle)
+        return { nodes: [], rawEdges: [] };
+    return handle.withTree(content, (_root, runQuery) => {
+        const nodes = [];
+        for (const match of runQuery(spec.fnQuery)) {
+            const nameCapture = match.captures.find(c => c.name === 'fn.name');
+            const nodeCapture = match.captures.find(c => c.name === 'fn.node');
+            if (!nameCapture || !nodeCapture)
+                continue;
+            const name = nameCapture.node.text;
+            const fnNode = nodeCapture.node;
+            const className = (spec.classTypes.size ? enclosingGroupName(fnNode, spec.classTypes) : undefined)
+                ?? spec.extraClassName?.(fnNode);
+            const id = className ? `${filePath}::${className}.${name}` : `${filePath}::${name}`;
+            if (nodes.some(n => n.id === id))
+                continue; // collapse multi-clause/overloads to one node
+            nodes.push({
+                id, name, filePath, className,
+                isAsync: false,
+                language: spec.language,
+                startIndex: fnNode.startIndex,
+                endIndex: fnNode.endIndex,
+                fanIn: 0, fanOut: 0,
+                signature: extractDeclaration(content, fnNode.startIndex, fnNode.endIndex, spec.language),
+            });
+        }
+        const definedNames = new Set(nodes.map(n => n.name));
+        const rawEdges = [];
+        const seen = new Set();
+        for (const match of runQuery(spec.callQuery)) {
+            const nameCapture = match.captures.find(c => c.name === 'call.name');
+            const nodeCapture = match.captures.find(c => c.name === 'call.node');
+            const objectCapture = match.captures.find(c => c.name === 'call.object');
+            if (!nameCapture || !nodeCapture)
+                continue;
+            const calleeName = nameCapture.node.text;
+            if (isIgnoredCallee(calleeName))
+                continue;
+            if (spec.callFilter && !spec.callFilter(calleeName, definedNames))
+                continue;
+            const caller = findEnclosingFunction(nodes, nodeCapture.node.startIndex);
+            if (!caller)
+                continue;
+            const calleeObject = objectCapture?.node.text;
+            const key = `${caller.id}\0${calleeName}\0${calleeObject ?? ''}\0${nodeCapture.node.startIndex}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            rawEdges.push({ callerId: caller.id, calleeName, line: nodeCapture.node.startPosition.row + 1, calleeObject });
+        }
+        return { nodes, rawEdges };
+    });
+}
+// ── C# ──────────────────────────────────────────────────────────────────────
+const CSHARP_SPEC = {
+    language: 'C#',
+    loader: () => loadGrammarSoft('C#', () => import('tree-sitter-c-sharp'), m => m.default),
+    classTypes: new Set(['class_declaration', 'struct_declaration', 'record_declaration', 'interface_declaration', 'enum_declaration']),
+    fnQuery: `
+    (method_declaration name: (identifier) @fn.name) @fn.node
+    (constructor_declaration name: (identifier) @fn.name) @fn.node
+    (local_function_statement name: (identifier) @fn.name) @fn.node
+  `,
+    // Name-based resolution (matches the codebase's best-effort approach): capture
+    // the callee name only — the object isn't used for resolution in these langs.
+    callQuery: `
+    (invocation_expression function: (member_access_expression name: (identifier) @call.name)) @call.node
+    (invocation_expression function: (identifier) @call.name) @call.node
+  `,
+};
+// ── Kotlin ──────────────────────────────────────────────────────────────────
+const KOTLIN_SPEC = {
+    language: 'Kotlin',
+    loader: () => loadGrammarSoft('Kotlin', () => import('tree-sitter-kotlin'), m => m.default),
+    classTypes: new Set(['class_declaration', 'object_declaration', 'interface_declaration', 'companion_object']),
+    // Extension functions: `fun Foo.bar()` — receiver user_type becomes the className.
+    extraClassName: (fnNode) => {
+        const receiver = fnNode.namedChildren.find(c => c.type === 'user_type');
+        return receiver?.text;
+    },
+    fnQuery: `
+    (function_declaration (simple_identifier) @fn.name) @fn.node
+  `,
+    callQuery: `
+    (call_expression (simple_identifier) @call.name) @call.node
+    (call_expression (navigation_expression (navigation_suffix (simple_identifier) @call.name))) @call.node
+  `,
+};
+// ── PHP ─────────────────────────────────────────────────────────────────────
+const PHP_SPEC = {
+    language: 'PHP',
+    loader: () => loadGrammarSoft('PHP', () => import('tree-sitter-php'), m => m.default.php),
+    classTypes: new Set(['class_declaration', 'trait_declaration', 'interface_declaration', 'enum_declaration']),
+    fnQuery: `
+    (function_definition name: (name) @fn.name) @fn.node
+    (method_declaration name: (name) @fn.name) @fn.node
+  `,
+    callQuery: `
+    (function_call_expression function: (name) @call.name) @call.node
+    (member_call_expression name: (name) @call.name) @call.node
+    (scoped_call_expression name: (name) @call.name) @call.node
+  `,
+};
+// ── C ───────────────────────────────────────────────────────────────────────
+const C_SPEC = {
+    language: 'C',
+    loader: () => loadGrammarSoft('C', () => import('tree-sitter-c'), m => m.default),
+    classTypes: new Set(), // C has no classes — file scope is the implicit grouping
+    fnQuery: `
+    (function_definition declarator: (function_declarator declarator: (identifier) @fn.name)) @fn.node
+  `,
+    callQuery: `
+    (call_expression function: (identifier) @call.name) @call.node
+  `,
+};
+// ── Scala ───────────────────────────────────────────────────────────────────
+const SCALA_SPEC = {
+    language: 'Scala',
+    loader: () => loadGrammarSoft('Scala', () => import('tree-sitter-scala'), m => m.default),
+    classTypes: new Set(['object_definition', 'class_definition', 'trait_definition']),
+    fnQuery: `
+    (function_definition name: (identifier) @fn.name) @fn.node
+  `,
+    callQuery: `
+    (call_expression function: (identifier) @call.name) @call.node
+    (call_expression function: (field_expression field: (identifier) @call.name)) @call.node
+  `,
+};
+// ── Lua (via bundled WASM — no ABI-compatible native build for the host) ─────
+const LUA_SPEC = {
+    language: 'Lua',
+    loader: () => loadWasmGrammarSoft('Lua', 'tree-sitter-wasms/out/tree-sitter-lua.wasm'),
+    classTypes: new Set(),
+    // `function t.f()` / `function t:m()` record the table name in className.
+    extraClassName: (fnNode) => {
+        const nameVar = fnNode.childForFieldName('name');
+        if (nameVar?.type === 'variable')
+            return nameVar.childForFieldName('table')?.text;
+        return undefined;
+    },
+    fnQuery: `
+    (local_function_definition_statement name: (identifier) @fn.name) @fn.node
+    (function_definition_statement name: (identifier) @fn.name) @fn.node
+    (function_definition_statement name: (variable field: (identifier) @fn.name)) @fn.node
+    (function_definition_statement name: (variable method: (identifier) @fn.name)) @fn.node
+  `,
+    callQuery: `
+    (call function: (variable name: (identifier) @call.name)) @call.node
+    (call function: (variable field: (identifier) @call.name)) @call.node
+    (call function: (variable method: (identifier) @call.name)) @call.node
+  `,
+};
+// ── Bash ────────────────────────────────────────────────────────────────────
+const BASH_SPEC = {
+    language: 'Bash',
+    loader: () => loadGrammarSoft('Bash', () => import('tree-sitter-bash'), m => m.default),
+    classTypes: new Set(),
+    // Only edge to project-defined functions, never external binaries (grep/ls/…).
+    callFilter: (calleeName, definedNames) => definedNames.has(calleeName),
+    fnQuery: `
+    (function_definition name: (word) @fn.name) @fn.node
+  `,
+    callQuery: `
+    (command name: (command_name (word) @call.name)) @call.node
+  `,
+};
+const QUERY_LANG_SPECS = {
+    'C#': CSHARP_SPEC, 'Kotlin': KOTLIN_SPEC, 'PHP': PHP_SPEC, 'C': C_SPEC,
+    'Scala': SCALA_SPEC, 'Lua': LUA_SPEC, 'Bash': BASH_SPEC,
+};
+// ── Dart (via portable WASM + web-tree-sitter) ───────────────────────────────
+//
+// No ABI-compatible native Dart grammar exists for the pinned host binding, so
+// Dart loads the portable `tree-sitter-wasms` WASM through web-tree-sitter
+// (ABI-agnostic, pure JS/WASM, builds on every platform) — each WASM grammar in
+// its own module instance (see loadWasmGrammarSoft). Dart's grammar places the
+// `function_body` as a SIBLING of `function_signature` (not a child), so a
+// generic query extractor would attribute no calls — hence a custom walk that
+// spans signature+body.
+const DART_CLASS_TYPES = new Set(['class_definition', 'mixin_declaration', 'extension_declaration', 'enum_declaration']);
+async function extractDartGraph(filePath, content) {
+    const handle = await loadWasmGrammarSoft('Dart', 'tree-sitter-wasms/out/tree-sitter-dart.wasm');
+    if (!handle)
+        return { nodes: [], rawEdges: [] };
+    return handle.withTree(content, (root) => {
+        const enclosingClass = (node) => {
+            let c = node.parent;
+            while (c) {
+                if (DART_CLASS_TYPES.has(c.type))
+                    return c.childForFieldName('name')?.text;
+                c = c.parent;
+            }
+            return undefined;
+        };
+        const nodes = [];
+        const collectFns = (n) => {
+            if (n.type === 'function_signature') {
+                const nameNode = n.childForFieldName('name');
+                if (nameNode) {
+                    // Body is a sibling of the signature (or of its method_signature parent).
+                    const unit = n.parent && n.parent.type === 'method_signature' ? n.parent : n;
+                    const sib = unit.nextNamedSibling;
+                    const endIndex = sib && sib.type === 'function_body' ? sib.endIndex : n.endIndex;
+                    const className = enclosingClass(n);
+                    const id = className ? `${filePath}::${className}.${nameNode.text}` : `${filePath}::${nameNode.text}`;
+                    if (!nodes.some(x => x.id === id)) {
+                        nodes.push({
+                            id, name: nameNode.text, filePath, className, isAsync: false, language: 'Dart',
+                            startIndex: n.startIndex, endIndex, fanIn: 0, fanOut: 0,
+                            signature: extractDeclaration(content, n.startIndex, n.endIndex, 'Dart'),
+                        });
+                    }
+                }
+            }
+            for (const c of n.namedChildren)
+                collectFns(c);
+        };
+        collectFns(root);
+        const rawEdges = [];
+        const seen = new Set();
+        const collectCalls = (n) => {
+            if (n.type === 'selector' && n.namedChildren.some(c => c.type === 'argument_part')) {
+                const prev = n.previousNamedSibling;
+                let name;
+                if (prev?.type === 'identifier')
+                    name = prev.text;
+                else if (prev?.type === 'selector') {
+                    const uas = prev.namedChildren.find(c => c.type === 'unconditional_assignable_selector');
+                    name = uas?.namedChildren.find(c => c.type === 'identifier')?.text;
+                }
+                if (name && !isIgnoredCallee(name)) {
+                    const caller = findEnclosingFunction(nodes, n.startIndex);
+                    if (caller) {
+                        const key = `${caller.id}\0${name}\0${n.startIndex}`;
+                        if (!seen.has(key)) {
+                            seen.add(key);
+                            rawEdges.push({ callerId: caller.id, calleeName: name, line: n.startPosition.row + 1 });
+                        }
+                    }
+                }
+            }
+            for (const c of n.namedChildren)
+                collectCalls(c);
+        };
+        collectCalls(root);
+        return { nodes, rawEdges };
+    });
+}
+// ── Elixir (custom walk — everything is a `call` node) ───────────────────────
+const ELIXIR_DEF_KEYWORDS = new Set(['def', 'defp', 'defmacro', 'defmacrop']);
+async function extractElixirGraph(filePath, content) {
+    const loaded = await loadGrammarSoft('Elixir', () => import('tree-sitter-elixir'), m => m.default);
+    if (!loaded)
+        return { nodes: [], rawEdges: [] };
+    return loaded.withTree(content, (root) => {
+        const nodes = [];
+        const calls = [];
+        const targetIdent = (call) => {
+            const t = call.childForFieldName('target');
+            return t ?? call.namedChildren[0];
+        };
+        const walk = (node, moduleName) => {
+            if (node.type === 'call') {
+                const target = targetIdent(node);
+                const kw = target?.type === 'identifier' ? target.text : undefined;
+                const args = node.childForFieldName('arguments') ?? node.namedChildren.find(c => c.type === 'arguments');
+                if (kw === 'defmodule') {
+                    const aliasNode = args?.namedChildren.find(c => c.type === 'alias');
+                    const newModule = aliasNode?.text ?? moduleName;
+                    for (const child of node.namedChildren)
+                        walk(child, newModule);
+                    return;
+                }
+                if (kw && ELIXIR_DEF_KEYWORDS.has(kw)) {
+                    // First argument is the function head: an identifier (no args) or a call (with args).
+                    const head = args?.namedChildren[0];
+                    let fnName;
+                    let arity = 0;
+                    if (head?.type === 'identifier') {
+                        fnName = head.text;
+                    }
+                    else if (head?.type === 'call') {
+                        const ht = head.childForFieldName('target') ?? head.namedChildren[0];
+                        fnName = ht?.text;
+                        const hargs = head.childForFieldName('arguments') ?? head.namedChildren.find(c => c.type === 'arguments');
+                        arity = hargs?.namedChildren.length ?? 0;
+                    }
+                    if (fnName) {
+                        const id = moduleName ? `${filePath}::${moduleName}.${fnName}` : `${filePath}::${fnName}`;
+                        const existing = nodes.find(n => n.id === id);
+                        if (existing) {
+                            existing.signature = `${existing.signature} (+clause)`;
+                        }
+                        else {
+                            nodes.push({
+                                id, name: fnName, filePath, className: moduleName, isAsync: false,
+                                language: 'Elixir', startIndex: node.startIndex, endIndex: node.endIndex,
+                                fanIn: 0, fanOut: 0, signature: `${kw} ${fnName}/${arity}`,
+                            });
+                        }
+                    }
+                    // Recurse into the body for nested calls.
+                    for (const child of node.namedChildren)
+                        walk(child, moduleName);
+                    return;
+                }
+                // Otherwise it's a call site: local `fun(...)` or remote `Mod.fun(...)`.
+                if (target?.type === 'identifier' && !ELIXIR_DEF_KEYWORDS.has(target.text)) {
+                    calls.push({ name: target.text, pos: node.startIndex, row: node.startPosition.row });
+                }
+                else if (target?.type === 'dot') {
+                    // Remote `Mod.fun(...)`: emit the function name only (no receiver), so
+                    // name-based resolution can match an in-project function (matching how
+                    // the other spec-08 languages resolve member/static calls).
+                    const right = target.childForFieldName('right') ?? target.namedChildren[target.namedChildren.length - 1];
+                    if (right)
+                        calls.push({ name: right.text, pos: node.startIndex, row: node.startPosition.row });
+                }
+            }
+            for (const child of node.namedChildren)
+                walk(child, moduleName);
+        };
+        walk(root, undefined);
+        const rawEdges = [];
+        const seen = new Set();
+        for (const c of calls) {
+            if (isIgnoredCallee(c.name))
+                continue;
+            const caller = findEnclosingFunction(nodes, c.pos);
+            if (!caller)
+                continue;
+            const key = `${caller.id}\0${c.name}\0${c.object ?? ''}\0${c.pos}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            rawEdges.push({ callerId: caller.id, calleeName: c.name, line: c.row + 1, calleeObject: c.object });
+        }
+        return { nodes, rawEdges };
+    });
+}
+// ============================================================================
 // CLASS HIERARCHY EXTRACTION
 // ============================================================================
 /**
@@ -1537,8 +2027,13 @@ export class CallGraphBuilder {
      * @param files       Source files with path, content, and language
      * @param layers      Optional layer map { layerName: [path prefix, ...] }
      * @param importMap   Optional per-file import map (from ImportResolverBridge)
+     * @param resolutionNodes  Optional pre-existing nodes used only to seed the
+     *   call-resolution trie (not added to the returned nodes/edges). An
+     *   incremental subset rebuild passes the full set of known nodes so calls
+     *   into files outside the re-parsed subset resolve to their real node
+     *   instead of degrading to a synthetic `external::` leaf.
      */
-    async build(files, layers, importMap) {
+    async build(files, layers, importMap, resolutionNodes) {
         const allNodes = new Map();
         const allRawEdges = [];
         // Pass 1: Extract nodes and raw edges from each file
@@ -1569,6 +2064,16 @@ export class CallGraphBuilder {
                 else if (file.language === 'Swift') {
                     result = await extractSwiftGraph(file.path, file.content);
                 }
+                else if (file.language === 'Elixir') {
+                    result = await extractElixirGraph(file.path, file.content);
+                }
+                else if (file.language === 'Dart') {
+                    result = await extractDartGraph(file.path, file.content);
+                }
+                else if (QUERY_LANG_SPECS[file.language]) {
+                    // spec-08 additional languages (C#, Kotlin, PHP, C, Scala, Dart, Lua, Bash).
+                    result = await extractByQueries(QUERY_LANG_SPECS[file.language], file.path, file.content);
+                }
                 else {
                     continue;
                 }
@@ -1607,6 +2112,15 @@ export class CallGraphBuilder {
         const trie = new FunctionRegistryTrie();
         for (const node of allNodes.values())
             trie.insert(node);
+        // Seed resolution with pre-existing nodes (incremental subset rebuilds) so
+        // cross-file calls outside the re-parsed subset still resolve internally.
+        // These are NOT added to allNodes, so they never appear in the output.
+        if (resolutionNodes) {
+            for (const node of resolutionNodes) {
+                if (!allNodes.has(node.id) && !node.isExternal)
+                    trie.insert(node);
+            }
+        }
         // Build per-function-body content slices for type inference (keyed by functionId)
         const fileContents = new Map();
         for (const file of files)
@@ -1750,6 +2264,20 @@ export class CallGraphBuilder {
         catch {
             // HTTP edge extraction is best-effort; don't fail the whole build
         }
+        // Pass 2c: Infrastructure-as-Code projection (spec-07).
+        // IaC resources/references project onto the existing node/edge primitives.
+        let iacClasses = [];
+        try {
+            const iac = buildProjectedIac(files);
+            for (const n of iac.nodes)
+                if (!allNodes.has(n.id))
+                    allNodes.set(n.id, n);
+            edges.push(...iac.edges);
+            iacClasses = iac.classes;
+        }
+        catch {
+            // IaC extraction is best-effort; never fail the whole build
+        }
         // Pass 3: Calculate fanIn / fanOut (count unique caller→callee pairs, not call sites)
         const seenPairs = new Set();
         for (const edge of edges) {
@@ -1968,6 +2496,11 @@ export class CallGraphBuilder {
         // Pass 7: Build class hierarchy (inheritance + grouping)
         const relationships = await extractClassRelationships(files);
         const { classes, inheritanceEdges } = buildClassNodes(allNodes, relationships);
+        // Merge IaC module groupings (deduped by id) into the class set.
+        const classIds = new Set(classes.map(c => c.id));
+        for (const c of iacClasses)
+            if (!classIds.has(c.id))
+                classes.push(c);
         return {
             nodes: allNodes,
             edges,