icopilot 2.2.0

package/dist/commands/diagram-cmd.js

@@ -0,0 +1,658 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import ts from 'typescript';
+import { theme } from '../ui/theme.js';
+const MAX_NODES = 20;
+const OMITTED_NODE_KEY = '__omitted__';
+const SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mts', '.cts', '.mjs', '.cjs']);
+const SKIP_DIRS = new Set([
+    '.git',
+    '.next',
+    '.turbo',
+    'build',
+    'coverage',
+    'dist',
+    'node_modules',
+    'out',
+]);
+const FLOW_ENTRY_NAMES = new Set([
+    'main',
+    'run',
+    'start',
+    'bootstrap',
+    'createProgram',
+    'handleSlash',
+]);
+export function diagramCommand(args, cwd) {
+    const [subcommand, ...rest] = args;
+    const scope = rest.join(' ').trim() || undefined;
+    if (!subcommand) {
+        return generateDiagram(cwd, { type: 'architecture' });
+    }
+    switch (subcommand.toLowerCase()) {
+        case 'architecture':
+            return generateDiagram(cwd, { type: 'architecture', scope });
+        case 'deps':
+            return generateDiagram(cwd, { type: 'deps', scope });
+        case 'classes':
+            return generateDiagram(cwd, { type: 'classes', scope });
+        case 'flow':
+            return generateDiagram(cwd, { type: 'flow', scope });
+        default:
+            return `${theme.warn('usage: /diagram [deps|classes [file]|flow [function]]')}\n`;
+    }
+}
+export function generateDiagram(rootDir, opts) {
+    const cwd = path.resolve(rootDir);
+    const scopeTarget = resolveScopeTarget(cwd, opts.scope);
+    const files = opts.type === 'flow'
+        ? collectSourceFiles(cwd)
+        : collectSourceFiles(cwd, scopeTarget ?? undefined);
+    const parsedFiles = parseProjectFiles(cwd, files);
+    switch (opts.type) {
+        case 'architecture':
+            return buildArchitectureDiagram(cwd, parsedFiles);
+        case 'deps':
+            return buildDependencyDiagram(parsedFiles);
+        case 'classes':
+            return buildClassDiagram(parsedFiles);
+        case 'flow':
+            return buildFlowDiagram(cwd, parsedFiles, opts.scope);
+    }
+}
+function buildArchitectureDiagram(rootDir, parsedFiles) {
+    const entryFiles = new Set(detectEntryFiles(rootDir, parsedFiles));
+    const nodes = new Map();
+    const edges = new Map();
+    for (const parsed of parsedFiles) {
+        const fromModule = detectModuleBoundary(parsed.relative);
+        upsertNode(nodes, fromModule, entryFiles.has(parsed.file) ? `${fromModule}<br/>entry` : fromModule, 1);
+        if (entryFiles.has(parsed.file)) {
+            incrementNode(nodes, fromModule, 3);
+        }
+        for (const imported of parsed.imports) {
+            const toModule = detectModuleBoundary(relativePath(rootDir, imported));
+            upsertNode(nodes, toModule, entryFiles.has(imported) ? `${toModule}<br/>entry` : toModule, 1);
+            incrementNode(nodes, fromModule, 1);
+            incrementNode(nodes, toModule, 1);
+            if (fromModule !== toModule) {
+                upsertEdge(edges, fromModule, toModule);
+            }
+        }
+    }
+    return renderDirectedGraph('graph TD', nodes, edges, {
+        emptyMessage: 'No module relationships found.',
+        omittedLabel: 'other modules',
+    });
+}
+function buildDependencyDiagram(parsedFiles) {
+    const nodes = new Map();
+    const edges = new Map();
+    for (const parsed of parsedFiles) {
+        upsertNode(nodes, parsed.relative, parsed.relative, 1);
+        for (const imported of parsed.imports) {
+            const relativeImport = toPosixPath(parsedFiles.find((item) => item.file === imported)?.relative ?? '');
+            if (!relativeImport)
+                continue;
+            upsertNode(nodes, relativeImport, relativeImport, 1);
+            incrementNode(nodes, parsed.relative, 1);
+            incrementNode(nodes, relativeImport, 1);
+            upsertEdge(edges, parsed.relative, relativeImport);
+        }
+    }
+    return renderDirectedGraph('graph LR', nodes, edges, {
+        emptyMessage: 'No file dependencies found.',
+        omittedLabel: 'other files',
+    });
+}
+function buildClassDiagram(parsedFiles) {
+    const nodes = new Map();
+    const edges = new Map();
+    const classByName = new Map();
+    for (const parsed of parsedFiles) {
+        for (const classInfo of parsed.classes) {
+            classByName.set(classInfo.name, classInfo);
+            upsertNode(nodes, classInfo.id, classInfo.name, 1);
+        }
+    }
+    for (const parsed of parsedFiles) {
+        for (const classInfo of parsed.classes) {
+            if (!classInfo.extends)
+                continue;
+            const base = classByName.get(classInfo.extends);
+            const baseKey = base?.id ?? `external:${classInfo.extends}`;
+            const baseLabel = base?.name ?? `${classInfo.extends} (external)`;
+            upsertNode(nodes, baseKey, baseLabel, base ? 1 : 0);
+            incrementNode(nodes, classInfo.id, 1);
+            incrementNode(nodes, baseKey, 1);
+            upsertEdge(edges, baseKey, classInfo.id);
+        }
+    }
+    return renderClassGraph(nodes, edges);
+}
+function buildFlowDiagram(rootDir, parsedFiles, scope) {
+    const entryFiles = new Set(detectEntryFiles(rootDir, parsedFiles));
+    const allFunctions = parsedFiles.flatMap((parsed) => parsed.functions);
+    const functionById = new Map(allFunctions.map((fn) => [fn.id, fn]));
+    const functionIdsBySimpleName = new Map();
+    const functionIdsByFullName = new Map();
+    for (const fn of allFunctions) {
+        functionIdsByFullName.set(fn.fullName, fn.id);
+        const ids = functionIdsBySimpleName.get(fn.simpleName) ?? [];
+        ids.push(fn.id);
+        functionIdsBySimpleName.set(fn.simpleName, ids);
+    }
+    const edges = new Map();
+    const incoming = new Map();
+    for (const fn of allFunctions) {
+        for (const call of fn.calls) {
+            const targetId = resolveFunctionCall(fn, call, functionIdsBySimpleName, functionIdsByFullName);
+            if (!targetId || targetId === fn.id || !functionById.has(targetId))
+                continue;
+            upsertEdge(edges, fn.id, targetId);
+            incoming.set(targetId, (incoming.get(targetId) ?? 0) + 1);
+        }
+    }
+    const rootIds = selectFlowRoots(allFunctions, scope, entryFiles, functionIdsBySimpleName, functionIdsByFullName, incoming);
+    const reachableIds = collectReachableNodes(rootIds, edges);
+    const activeIds = reachableIds.size > 0 ? reachableIds : new Set(allFunctions.map((fn) => fn.id));
+    const nodes = new Map();
+    const filteredEdges = new Map();
+    for (const fn of allFunctions) {
+        if (!activeIds.has(fn.id))
+            continue;
+        const label = rootIds.has(fn.id) ? `${fn.fullName}<br/>entry` : fn.fullName;
+        upsertNode(nodes, fn.id, label, 1 + (incoming.get(fn.id) ?? 0) + fn.calls.length);
+        if (rootIds.has(fn.id)) {
+            incrementNode(nodes, fn.id, 3);
+        }
+    }
+    for (const edge of edges.values()) {
+        if (!activeIds.has(edge.from) || !activeIds.has(edge.to))
+            continue;
+        filteredEdges.set(`${edge.from}→${edge.to}`, edge);
+    }
+    return renderDirectedGraph('flowchart TD', nodes, filteredEdges, {
+        emptyMessage: scope ? `No function flow found for "${scope}".` : 'No function flow found.',
+        omittedLabel: 'other functions',
+    });
+}
+function parseProjectFiles(rootDir, files) {
+    const fileSet = new Set(files.map((file) => path.resolve(file)));
+    return files
+        .map((file) => parseSourceFile(rootDir, file, fileSet))
+        .sort((left, right) => left.relative.localeCompare(right.relative));
+}
+function parseSourceFile(rootDir, file, fileSet) {
+    const content = fs.readFileSync(file, 'utf8');
+    const sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true, scriptKindForFile(file));
+    const imports = new Set();
+    const classes = [];
+    const functions = [];
+    const visit = (node, currentClass) => {
+        if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
+            node.moduleSpecifier &&
+            ts.isStringLiteral(node.moduleSpecifier)) {
+            const resolved = resolveImportTarget(file, node.moduleSpecifier.text, fileSet);
+            if (resolved)
+                imports.add(resolved);
+        }
+        if (ts.isCallExpression(node)) {
+            const moduleSpecifier = extractCallImport(node);
+            if (moduleSpecifier) {
+                const resolved = resolveImportTarget(file, moduleSpecifier, fileSet);
+                if (resolved)
+                    imports.add(resolved);
+            }
+        }
+        if (ts.isClassDeclaration(node) && node.name) {
+            const className = node.name.text;
+            const heritage = node.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword);
+            const extendsName = heritage?.types[0]?.expression.getText(sourceFile).trim();
+            classes.push({
+                id: `${relativePath(rootDir, file)}#${className}`,
+                name: className,
+                file,
+                extends: extendsName,
+            });
+            ts.forEachChild(node, (child) => visit(child, className));
+            return;
+        }
+        if (ts.isFunctionDeclaration(node) && node.name && node.body) {
+            functions.push(createFunctionInfo(rootDir, file, node.name.text, node.body, sourceFile, undefined, isNodeExported(node)));
+            return;
+        }
+        if (currentClass && ts.isMethodDeclaration(node) && node.body) {
+            const methodName = getNodeName(node.name);
+            if (methodName) {
+                functions.push(createFunctionInfo(rootDir, file, methodName, node.body, sourceFile, currentClass, isNodeExported(node)));
+            }
+            return;
+        }
+        if (ts.isVariableDeclaration(node) && node.initializer && ts.isIdentifier(node.name)) {
+            if (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer)) {
+                const body = ts.isBlock(node.initializer.body)
+                    ? node.initializer.body
+                    : ts.factory.createBlock([ts.factory.createReturnStatement(node.initializer.body)], true);
+                functions.push(createFunctionInfo(rootDir, file, node.name.text, body, sourceFile, currentClass, isNodeExported(node.parent?.parent)));
+                return;
+            }
+        }
+        ts.forEachChild(node, (child) => visit(child, currentClass));
+    };
+    visit(sourceFile);
+    return {
+        file,
+        relative: relativePath(rootDir, file),
+        imports: Array.from(imports).sort((left, right) => left.localeCompare(right)),
+        classes,
+        functions,
+    };
+}
+function createFunctionInfo(rootDir, file, simpleName, body, sourceFile, className, exported = false) {
+    const fullName = className ? `${className}.${simpleName}` : simpleName;
+    return {
+        id: `${relativePath(rootDir, file)}#${fullName}`,
+        simpleName,
+        fullName,
+        file,
+        className,
+        exported,
+        calls: collectCallNames(body, sourceFile, className),
+    };
+}
+function collectCallNames(body, sourceFile, className) {
+    const calls = new Set();
+    const visit = (node) => {
+        if (node !== body && (ts.isFunctionLike(node) || ts.isClassLike(node))) {
+            return;
+        }
+        if (ts.isCallExpression(node)) {
+            const callName = getCallName(node, sourceFile, className);
+            if (callName)
+                calls.add(callName);
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(body, visit);
+    return Array.from(calls);
+}
+function getCallName(node, sourceFile, className) {
+    if (ts.isIdentifier(node.expression)) {
+        return node.expression.text;
+    }
+    if (ts.isPropertyAccessExpression(node.expression)) {
+        if (node.expression.expression.kind === ts.SyntaxKind.ThisKeyword && className) {
+            return `${className}.${node.expression.name.text}`;
+        }
+        return node.expression.name.text;
+    }
+    if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+        const firstArg = node.arguments[0];
+        if (firstArg && ts.isStringLiteral(firstArg)) {
+            return `import:${firstArg.text}`;
+        }
+    }
+    return node.expression.getText(sourceFile).trim() || null;
+}
+function resolveFunctionCall(source, call, functionIdsBySimpleName, functionIdsByFullName) {
+    if (call.startsWith('import:'))
+        return null;
+    if (functionIdsByFullName.has(call))
+        return functionIdsByFullName.get(call) ?? null;
+    if (source.className) {
+        const classQualified = `${source.className}.${call}`;
+        if (functionIdsByFullName.has(classQualified)) {
+            return functionIdsByFullName.get(classQualified) ?? null;
+        }
+    }
+    const bySimple = functionIdsBySimpleName.get(call) ?? [];
+    if (bySimple.length === 1) {
+        return bySimple[0] ?? null;
+    }
+    return null;
+}
+function selectFlowRoots(functions, scope, entryFiles, functionIdsBySimpleName, functionIdsByFullName, incoming) {
+    if (scope) {
+        const trimmedScope = scope.trim();
+        const exact = new Set();
+        const exactFull = functionIdsByFullName.get(trimmedScope);
+        if (exactFull)
+            exact.add(exactFull);
+        for (const [simpleName, ids] of functionIdsBySimpleName) {
+            if (simpleName === trimmedScope)
+                ids.forEach((id) => exact.add(id));
+        }
+        if (exact.size > 0)
+            return exact;
+        const fuzzy = new Set(functions
+            .filter((fn) => fn.fullName.toLowerCase().includes(trimmedScope.toLowerCase()) ||
+            fn.simpleName.toLowerCase().includes(trimmedScope.toLowerCase()))
+            .map((fn) => fn.id));
+        if (fuzzy.size > 0)
+            return fuzzy;
+    }
+    const preferred = functions
+        .filter((fn) => entryFiles.has(fn.file) || fn.exported || FLOW_ENTRY_NAMES.has(fn.simpleName))
+        .sort((left, right) => left.fullName.localeCompare(right.fullName))
+        .slice(0, 3)
+        .map((fn) => fn.id);
+    if (preferred.length > 0)
+        return new Set(preferred);
+    const byIncoming = functions
+        .filter((fn) => (incoming.get(fn.id) ?? 0) === 0)
+        .sort((left, right) => left.fullName.localeCompare(right.fullName))
+        .slice(0, 3)
+        .map((fn) => fn.id);
+    if (byIncoming.length > 0)
+        return new Set(byIncoming);
+    return new Set(functions.slice(0, 3).map((fn) => fn.id));
+}
+function collectReachableNodes(rootIds, edges) {
+    const adjacency = new Map();
+    for (const edge of edges.values()) {
+        const list = adjacency.get(edge.from) ?? [];
+        list.push(edge.to);
+        adjacency.set(edge.from, list);
+    }
+    const visited = new Set();
+    const queue = Array.from(rootIds);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current || visited.has(current))
+            continue;
+        visited.add(current);
+        for (const next of adjacency.get(current) ?? []) {
+            if (!visited.has(next))
+                queue.push(next);
+        }
+    }
+    return visited;
+}
+function renderDirectedGraph(header, nodes, edges, options) {
+    const limited = limitGraph(nodes, edges);
+    const lines = ['```mermaid', header];
+    if (limited.nodes.length === 0) {
+        lines.push(`  empty["${escapeMermaidLabel(options.emptyMessage)}"]`);
+        lines.push('```');
+        return `${lines.join('\n')}\n`;
+    }
+    for (const node of limited.nodes) {
+        lines.push(`  ${mermaidId(node.key)}["${escapeMermaidLabel(node.label)}"]`);
+    }
+    if (limited.omittedCount > 0) {
+        lines.push(`  ${mermaidId(OMITTED_NODE_KEY)}["${escapeMermaidLabel(`${limited.omittedCount} ${options.omittedLabel}`)}"]`);
+        lines.push(`  %% ${limited.omittedCount} ${options.omittedLabel} omitted for readability`);
+    }
+    for (const edge of limited.edges) {
+        const label = edge.count > 1 ? `|${edge.count}| ` : '';
+        lines.push(`  ${mermaidId(edge.from)} --> ${label}${mermaidId(edge.to)}`);
+    }
+    lines.push('```');
+    return `${lines.join('\n')}\n`;
+}
+function renderClassGraph(nodes, edges) {
+    const limited = limitGraph(nodes, edges);
+    const lines = ['```mermaid', 'classDiagram'];
+    if (limited.nodes.length === 0) {
+        lines.push('  class EmptyDiagram {');
+        lines.push('    No classes found');
+        lines.push('  }');
+        lines.push('```');
+        return `${lines.join('\n')}\n`;
+    }
+    for (const node of limited.nodes) {
+        lines.push(`  class ${mermaidId(node.key)}["${escapeMermaidLabel(node.label)}"]`);
+    }
+    if (limited.omittedCount > 0) {
+        lines.push(`  class ${mermaidId(OMITTED_NODE_KEY)} {`);
+        lines.push(`    +${limited.omittedCount} more classes omitted`);
+        lines.push('  }');
+    }
+    for (const edge of limited.edges) {
+        lines.push(`  ${mermaidId(edge.from)} <|-- ${mermaidId(edge.to)}`);
+    }
+    lines.push('```');
+    return `${lines.join('\n')}\n`;
+}
+function limitGraph(nodes, edges) {
+    const sortedNodes = Array.from(nodes.values()).sort((left, right) => right.weight - left.weight || left.label.localeCompare(right.label));
+    if (sortedNodes.length <= MAX_NODES) {
+        return { nodes: sortedNodes, edges: Array.from(edges.values()), omittedCount: 0 };
+    }
+    const keptNodes = sortedNodes.slice(0, MAX_NODES - 1);
+    const keptKeys = new Set(keptNodes.map((node) => node.key));
+    const omittedCount = sortedNodes.length - keptNodes.length;
+    const limitedEdges = new Map();
+    for (const edge of edges.values()) {
+        const from = keptKeys.has(edge.from) ? edge.from : OMITTED_NODE_KEY;
+        const to = keptKeys.has(edge.to) ? edge.to : OMITTED_NODE_KEY;
+        if (from === to && from === OMITTED_NODE_KEY)
+            continue;
+        const key = `${from}→${to}`;
+        const current = limitedEdges.get(key);
+        if (current) {
+            current.count += edge.count;
+        }
+        else {
+            limitedEdges.set(key, { from, to, count: edge.count });
+        }
+    }
+    return {
+        nodes: keptNodes,
+        edges: Array.from(limitedEdges.values()),
+        omittedCount,
+    };
+}
+function upsertNode(nodes, key, label, weight) {
+    const current = nodes.get(key);
+    if (current) {
+        current.weight += weight;
+        if (label.includes('<br/>entry'))
+            current.label = label;
+        return;
+    }
+    nodes.set(key, { key, label, weight });
+}
+function incrementNode(nodes, key, weight) {
+    const current = nodes.get(key);
+    if (current)
+        current.weight += weight;
+}
+function upsertEdge(edges, from, to) {
+    const key = `${from}→${to}`;
+    const current = edges.get(key);
+    if (current) {
+        current.count += 1;
+        return;
+    }
+    edges.set(key, { from, to, count: 1 });
+}
+function collectSourceFiles(rootDir, scopeTarget) {
+    const start = scopeTarget ?? rootDir;
+    if (!fs.existsSync(start))
+        return [];
+    const stat = fs.statSync(start);
+    if (stat.isFile()) {
+        return isIncludedSourceFile(start, rootDir, true) ? [path.resolve(start)] : [];
+    }
+    const files = [];
+    const walk = (currentDir) => {
+        for (const entry of fs.readdirSync(currentDir, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                if (SKIP_DIRS.has(entry.name))
+                    continue;
+                walk(path.join(currentDir, entry.name));
+                continue;
+            }
+            const file = path.join(currentDir, entry.name);
+            if (isIncludedSourceFile(file, rootDir, currentDir === start && Boolean(scopeTarget))) {
+                files.push(path.resolve(file));
+            }
+        }
+    };
+    walk(start);
+    return files.sort((left, right) => left.localeCompare(right));
+}
+function isIncludedSourceFile(file, rootDir, explicitScope) {
+    const extension = path.extname(file).toLowerCase();
+    if (!SOURCE_EXTENSIONS.has(extension))
+        return false;
+    if (file.endsWith('.d.ts'))
+        return false;
+    if (explicitScope)
+        return true;
+    const normalized = toPosixPath(relativePath(rootDir, file));
+    return !(normalized.includes('/tests/') ||
+        normalized.includes('/__tests__/') ||
+        /\.test\.[cm]?[jt]sx?$/u.test(normalized) ||
+        /\.spec\.[cm]?[jt]sx?$/u.test(normalized));
+}
+function resolveScopeTarget(rootDir, scope) {
+    if (!scope)
+        return null;
+    const resolved = path.resolve(rootDir, scope);
+    if (fs.existsSync(resolved))
+        return resolved;
+    const normalizedScope = toPosixPath(scope).replace(/^\.\//u, '');
+    const candidates = collectSourceFiles(rootDir).filter((file) => {
+        const relative = toPosixPath(relativePath(rootDir, file));
+        return relative === normalizedScope || relative.endsWith(`/${normalizedScope}`);
+    });
+    return candidates[0] ?? null;
+}
+function detectEntryFiles(rootDir, parsedFiles) {
+    const byRelative = new Map(parsedFiles.map((parsed) => [toPosixPath(parsed.relative), parsed.file]));
+    const candidates = new Set();
+    const packageJsonPath = path.join(rootDir, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            for (const value of extractPackageEntryValues(pkg)) {
+                const resolved = resolveEntryCandidate(value, byRelative);
+                if (resolved)
+                    candidates.add(resolved);
+            }
+        }
+        catch {
+            // ignore invalid package.json
+        }
+    }
+    for (const candidate of ['src/index.ts', 'src/main.ts', 'src/cli.ts', 'index.ts', 'main.ts']) {
+        const resolved = resolveEntryCandidate(candidate, byRelative);
+        if (resolved)
+            candidates.add(resolved);
+    }
+    return Array.from(candidates);
+}
+function extractPackageEntryValues(pkg) {
+    const values = [];
+    if (pkg.main)
+        values.push(pkg.main);
+    if (typeof pkg.bin === 'string') {
+        values.push(pkg.bin);
+    }
+    else if (pkg.bin) {
+        values.push(...Object.values(pkg.bin));
+    }
+    return values;
+}
+function resolveEntryCandidate(candidate, byRelative) {
+    const relative = toPosixPath(candidate).replace(/^\.\/+/u, '');
+    const direct = byRelative.get(relative);
+    if (direct)
+        return direct;
+    const asTs = relative.replace(/\.js$/u, '.ts');
+    if (byRelative.has(asTs))
+        return byRelative.get(asTs) ?? null;
+    const withoutBinPrefix = relative.replace(/^bin\//u, 'src/');
+    if (byRelative.has(withoutBinPrefix))
+        return byRelative.get(withoutBinPrefix) ?? null;
+    return null;
+}
+function detectModuleBoundary(relativeFile) {
+    const normalized = toPosixPath(relativeFile);
+    const parts = normalized.split('/').filter(Boolean);
+    if (parts.length === 0)
+        return normalized;
+    if (parts[0] === 'src' && parts.length >= 3) {
+        return `src/${parts[1]}`;
+    }
+    if (parts[0] === 'src') {
+        return normalized;
+    }
+    if (parts.length >= 2) {
+        return parts[0];
+    }
+    return normalized;
+}
+function resolveImportTarget(fromFile, moduleSpecifier, fileSet) {
+    if (!moduleSpecifier.startsWith('.'))
+        return null;
+    const base = path.resolve(path.dirname(fromFile), moduleSpecifier);
+    const candidates = [
+        base,
+        ...Array.from(SOURCE_EXTENSIONS, (extension) => `${base}${extension}`),
+        ...Array.from(SOURCE_EXTENSIONS, (extension) => path.join(base, `index${extension}`)),
+    ];
+    if (/\.[cm]?[jt]sx?$/u.test(moduleSpecifier)) {
+        const extless = base.replace(/\.[^.]+$/u, '');
+        candidates.push(...Array.from(SOURCE_EXTENSIONS, (extension) => `${extless}${extension}`));
+    }
+    for (const candidate of candidates) {
+        const resolved = path.resolve(candidate);
+        if (fileSet.has(resolved))
+            return resolved;
+    }
+    return null;
+}
+function extractCallImport(node) {
+    const firstArg = node.arguments[0];
+    if (!firstArg || !ts.isStringLiteral(firstArg))
+        return null;
+    if (ts.isIdentifier(node.expression) && node.expression.text === 'require') {
+        return firstArg.text;
+    }
+    if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+        return firstArg.text;
+    }
+    return null;
+}
+function isNodeExported(node) {
+    if (!node)
+        return false;
+    return Boolean(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export);
+}
+function getNodeName(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return null;
+}
+function scriptKindForFile(file) {
+    const extension = path.extname(file).toLowerCase();
+    switch (extension) {
+        case '.tsx':
+            return ts.ScriptKind.TSX;
+        case '.jsx':
+            return ts.ScriptKind.JSX;
+        case '.js':
+        case '.mjs':
+        case '.cjs':
+            return ts.ScriptKind.JS;
+        default:
+            return ts.ScriptKind.TS;
+    }
+}
+function relativePath(rootDir, file) {
+    return toPosixPath(path.relative(rootDir, file) || path.basename(file));
+}
+function toPosixPath(value) {
+    return value.replace(/\\/gu, '/');
+}
+function mermaidId(key) {
+    return key.replace(/[^A-Za-z0-9_]/gu, '_');
+}
+function escapeMermaidLabel(value) {
+    return value.replace(/"/gu, '&quot;');
+}