@vpxa/kb 0.1.1

package/packages/analyzers/dist/symbol-analyzer.d.ts

@@ -0,0 +1,10 @@
+import type { AnalysisResult, IAnalyzer, SymbolAnalyzerOptions } from './types.js';
+export declare class SymbolAnalyzer implements IAnalyzer<SymbolAnalyzerOptions> {
+    readonly name = "symbols";
+    analyze(rootPath: string, options?: SymbolAnalyzerOptions): Promise<AnalysisResult>;
+    private collectFiles;
+    private extractSymbols;
+    private groupByKind;
+    private formatMarkdown;
+}
+//# sourceMappingURL=symbol-analyzer.d.ts.map

package/packages/analyzers/dist/symbol-analyzer.js

@@ -0,0 +1,442 @@
+import { readdir, readFile } from "node:fs/promises";
+import { extname, join, relative } from "node:path";
+const CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".java",
+  ".py",
+  ".go",
+  ".cs",
+  ".rb",
+  ".kt",
+  ".scala",
+  ".rs",
+  ".php",
+  ".swift"
+]);
+const DEFAULT_EXCLUDES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  ".turbo",
+  ".cache",
+  "cdk.out",
+  "__pycache__",
+  ".venv",
+  "target",
+  "bin",
+  "obj",
+  ".gradle",
+  "venv",
+  "env"
+]);
+const TS_PATTERNS = {
+  exported: [
+    { pattern: /^export\s+(?:async\s+)?function\s+(\w+)/gm, kind: "function" },
+    { pattern: /^export\s+(?:default\s+)?class\s+(\w+)/gm, kind: "class" },
+    { pattern: /^export\s+interface\s+(\w+)/gm, kind: "interface" },
+    { pattern: /^export\s+type\s+(\w+)/gm, kind: "type" },
+    { pattern: /^export\s+(?:const|let)\s+(\w+)/gm, kind: "const" },
+    { pattern: /^export\s+enum\s+(\w+)/gm, kind: "enum" }
+  ],
+  local: [
+    { pattern: /^(?:async\s+)?function\s+(\w+)/gm, kind: "function" },
+    { pattern: /^class\s+(\w+)/gm, kind: "class" },
+    { pattern: /^interface\s+(\w+)/gm, kind: "interface" },
+    { pattern: /^type\s+(\w+)/gm, kind: "type" },
+    { pattern: /^(?:const|let)\s+(\w+)\s*=/gm, kind: "const" },
+    { pattern: /^enum\s+(\w+)/gm, kind: "enum" }
+  ]
+};
+const JAVA_PATTERNS = {
+  exported: [
+    {
+      pattern: /^[ \t]*public\s+(?:static\s+)?(?:abstract\s+)?class\s+(\w+)/gm,
+      kind: "class"
+    },
+    {
+      pattern: /^[ \t]*public\s+(?:static\s+)?interface\s+(\w+)/gm,
+      kind: "interface"
+    },
+    {
+      pattern: /^[ \t]*public\s+(?:static\s+)?enum\s+(\w+)/gm,
+      kind: "enum"
+    },
+    {
+      pattern: /^[ \t]*public\s+(?:static\s+)?(?:synchronized\s+)?(?:final\s+)?(?:abstract\s+)?(?:\w+(?:<[^>]*>)?(?:\[\])*)\s+(\w+)\s*\(/gm,
+      kind: "function"
+    }
+  ],
+  local: [
+    {
+      pattern: /^[ \t]*(?:private|protected)\s+(?:static\s+)?(?:abstract\s+)?class\s+(\w+)/gm,
+      kind: "class"
+    },
+    {
+      pattern: /^[ \t]*(?:private|protected)\s+(?:static\s+)?(?:synchronized\s+)?(?:final\s+)?(?:\w+(?:<[^>]*>)?(?:\[\])*)\s+(\w+)\s*\(/gm,
+      kind: "function"
+    },
+    {
+      pattern: /^[ \t]*(?:private|protected)\s+(?:static\s+)?(?:final\s+)?(?:\w+(?:<[^>]*>)?)\s+(\w+)\s*[;=]/gm,
+      kind: "variable"
+    }
+  ],
+  skipIndentFilter: true
+};
+const PYTHON_PATTERNS = {
+  exported: [
+    // Top-level functions (no leading whitespace = module-level = "exported")
+    { pattern: /^def\s+(\w+)\s*\(/gm, kind: "function" },
+    { pattern: /^async\s+def\s+(\w+)\s*\(/gm, kind: "function" },
+    { pattern: /^class\s+(\w+)/gm, kind: "class" }
+  ],
+  local: [
+    // Indented methods inside classes
+    { pattern: /^[ \t]+def\s+(\w+)\s*\(/gm, kind: "function" },
+    { pattern: /^[ \t]+async\s+def\s+(\w+)\s*\(/gm, kind: "function" }
+  ],
+  skipIndentFilter: true
+};
+const GO_PATTERNS = {
+  exported: [
+    // Exported = starts with uppercase
+    { pattern: /^func\s+([A-Z]\w*)\s*\(/gm, kind: "function" },
+    // Method with receiver
+    { pattern: /^func\s+\([^)]+\)\s+([A-Z]\w*)\s*\(/gm, kind: "function" },
+    { pattern: /^type\s+([A-Z]\w*)\s+struct\b/gm, kind: "class" },
+    { pattern: /^type\s+([A-Z]\w*)\s+interface\b/gm, kind: "interface" },
+    { pattern: /^type\s+([A-Z]\w*)\s+/gm, kind: "type" }
+  ],
+  local: [
+    { pattern: /^func\s+([a-z]\w*)\s*\(/gm, kind: "function" },
+    { pattern: /^func\s+\([^)]+\)\s+([a-z]\w*)\s*\(/gm, kind: "function" },
+    { pattern: /^type\s+([a-z]\w*)\s+struct\b/gm, kind: "class" },
+    { pattern: /^type\s+([a-z]\w*)\s+/gm, kind: "type" }
+  ],
+  skipIndentFilter: true
+};
+const CSHARP_PATTERNS = {
+  exported: [
+    {
+      pattern: /^[ \t]*public\s+(?:static\s+)?(?:partial\s+)?(?:abstract\s+)?class\s+(\w+)/gm,
+      kind: "class"
+    },
+    {
+      pattern: /^[ \t]*public\s+(?:static\s+)?interface\s+(\w+)/gm,
+      kind: "interface"
+    },
+    {
+      pattern: /^[ \t]*public\s+(?:static\s+)?enum\s+(\w+)/gm,
+      kind: "enum"
+    },
+    {
+      pattern: /^[ \t]*public\s+(?:static\s+)?(?:virtual\s+)?(?:override\s+)?(?:async\s+)?(?:\w+(?:<[^>]*>)?(?:\[\])?)\s+(\w+)\s*\(/gm,
+      kind: "function"
+    }
+  ],
+  local: [
+    {
+      pattern: /^[ \t]*(?:private|protected|internal)\s+(?:static\s+)?(?:abstract\s+)?class\s+(\w+)/gm,
+      kind: "class"
+    },
+    {
+      pattern: /^[ \t]*(?:private|protected|internal)\s+(?:static\s+)?(?:async\s+)?(?:\w+(?:<[^>]*>)?)\s+(\w+)\s*\(/gm,
+      kind: "function"
+    }
+  ],
+  skipIndentFilter: true
+};
+const KOTLIN_PATTERNS = {
+  exported: [
+    { pattern: /^(?:open\s+|data\s+|sealed\s+)?class\s+(\w+)/gm, kind: "class" },
+    { pattern: /^(?:fun|suspend\s+fun)\s+(\w+)\s*[(<]/gm, kind: "function" },
+    { pattern: /^interface\s+(\w+)/gm, kind: "interface" },
+    { pattern: /^object\s+(\w+)/gm, kind: "class" },
+    { pattern: /^enum\s+class\s+(\w+)/gm, kind: "enum" }
+  ],
+  local: [
+    { pattern: /^[ \t]+(?:private|internal)\s+(?:fun|suspend\s+fun)\s+(\w+)/gm, kind: "function" },
+    { pattern: /^[ \t]+(?:private|internal)\s+(?:val|var)\s+(\w+)/gm, kind: "variable" }
+  ],
+  skipIndentFilter: true
+};
+const RUBY_PATTERNS = {
+  exported: [
+    { pattern: /^class\s+(\w+)/gm, kind: "class" },
+    { pattern: /^module\s+(\w+)/gm, kind: "class" },
+    { pattern: /^[ \t]+def\s+self\.(\w+)/gm, kind: "function" }
+  ],
+  local: [{ pattern: /^[ \t]+def\s+(\w+)/gm, kind: "function" }],
+  skipIndentFilter: true
+};
+const RUST_PATTERNS = {
+  exported: [
+    { pattern: /^pub\s+(?:async\s+)?fn\s+(\w+)/gm, kind: "function" },
+    { pattern: /^pub\s+struct\s+(\w+)/gm, kind: "class" },
+    { pattern: /^pub\s+trait\s+(\w+)/gm, kind: "interface" },
+    { pattern: /^pub\s+enum\s+(\w+)/gm, kind: "enum" },
+    { pattern: /^pub\s+type\s+(\w+)/gm, kind: "type" }
+  ],
+  local: [
+    { pattern: /^(?:async\s+)?fn\s+(\w+)/gm, kind: "function" },
+    { pattern: /^struct\s+(\w+)/gm, kind: "class" },
+    { pattern: /^trait\s+(\w+)/gm, kind: "interface" },
+    { pattern: /^enum\s+(\w+)/gm, kind: "enum" }
+  ],
+  skipIndentFilter: true
+};
+const PHP_PATTERNS = {
+  exported: [
+    { pattern: /^[ \t]*(?:abstract\s+)?class\s+(\w+)/gm, kind: "class" },
+    { pattern: /^[ \t]*interface\s+(\w+)/gm, kind: "interface" },
+    { pattern: /^[ \t]*public\s+(?:static\s+)?function\s+(\w+)/gm, kind: "function" },
+    { pattern: /^function\s+(\w+)\s*\(/gm, kind: "function" }
+  ],
+  local: [
+    {
+      pattern: /^[ \t]*(?:private|protected)\s+(?:static\s+)?function\s+(\w+)/gm,
+      kind: "function"
+    }
+  ],
+  skipIndentFilter: true
+};
+const SWIFT_PATTERNS = {
+  exported: [
+    { pattern: /^[ \t]*(?:open|public)\s+class\s+(\w+)/gm, kind: "class" },
+    { pattern: /^[ \t]*(?:open|public)\s+struct\s+(\w+)/gm, kind: "class" },
+    { pattern: /^[ \t]*(?:open|public)\s+protocol\s+(\w+)/gm, kind: "interface" },
+    { pattern: /^[ \t]*(?:open|public)\s+enum\s+(\w+)/gm, kind: "enum" },
+    { pattern: /^[ \t]*(?:open|public)\s+func\s+(\w+)/gm, kind: "function" }
+  ],
+  local: [
+    { pattern: /^[ \t]*(?:private|fileprivate|internal)\s+func\s+(\w+)/gm, kind: "function" },
+    { pattern: /^[ \t]*(?:private|fileprivate|internal)\s+class\s+(\w+)/gm, kind: "class" }
+  ],
+  skipIndentFilter: true
+};
+const SCALA_PATTERNS = {
+  exported: [
+    { pattern: /^[ \t]*(?:case\s+)?class\s+(\w+)/gm, kind: "class" },
+    { pattern: /^[ \t]*object\s+(\w+)/gm, kind: "class" },
+    { pattern: /^[ \t]*trait\s+(\w+)/gm, kind: "interface" },
+    { pattern: /^[ \t]*def\s+(\w+)/gm, kind: "function" }
+  ],
+  local: [],
+  skipIndentFilter: true
+};
+function getLangPatterns(ext) {
+  switch (ext) {
+    case ".ts":
+    case ".tsx":
+    case ".js":
+    case ".jsx":
+      return TS_PATTERNS;
+    case ".java":
+      return JAVA_PATTERNS;
+    case ".py":
+      return PYTHON_PATTERNS;
+    case ".go":
+      return GO_PATTERNS;
+    case ".cs":
+      return CSHARP_PATTERNS;
+    case ".kt":
+      return KOTLIN_PATTERNS;
+    case ".rb":
+      return RUBY_PATTERNS;
+    case ".rs":
+      return RUST_PATTERNS;
+    case ".php":
+      return PHP_PATTERNS;
+    case ".swift":
+      return SWIFT_PATTERNS;
+    case ".scala":
+      return SCALA_PATTERNS;
+    default:
+      return TS_PATTERNS;
+  }
+}
+function extractSignature(lines, startLine) {
+  let sig = "";
+  let parenDepth = 0;
+  let foundOpen = false;
+  for (let i = startLine; i < Math.min(startLine + 5, lines.length); i++) {
+    const line = lines[i].trim();
+    sig += (sig ? " " : "") + line;
+    for (const ch of line) {
+      if (ch === "(") {
+        parenDepth++;
+        foundOpen = true;
+      }
+      if (ch === ")") parenDepth--;
+    }
+    if (foundOpen && parenDepth <= 0) {
+      return sig.replace(/\s*\{.*$/, "").replace(/\s*:\s*$/, "").trim();
+    }
+  }
+  return sig.trim() || void 0;
+}
+class SymbolAnalyzer {
+  name = "symbols";
+  async analyze(rootPath, options = {}) {
+    const { format = "markdown", filter } = options;
+    const startTime = Date.now();
+    const files = await this.collectFiles(rootPath);
+    let symbols = [];
+    for (const filePath of files) {
+      const content = await readFile(filePath, "utf-8");
+      const fileSymbols = this.extractSymbols(
+        content,
+        relative(rootPath, filePath).replace(/\\/g, "/")
+      );
+      symbols.push(...fileSymbols);
+    }
+    if (filter) {
+      const filterLower = filter.toLowerCase();
+      symbols = symbols.filter((s) => s.name.toLowerCase().includes(filterLower));
+    }
+    const output = format === "json" ? JSON.stringify(symbols, null, 2) : this.formatMarkdown(symbols, rootPath);
+    return {
+      output,
+      data: {
+        symbols,
+        byKind: this.groupByKind(symbols),
+        exportedCount: symbols.filter((s) => s.exported).length,
+        totalCount: symbols.length
+      },
+      meta: {
+        analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        scope: rootPath,
+        fileCount: files.length,
+        durationMs: Date.now() - startTime
+      }
+    };
+  }
+  async collectFiles(dirPath) {
+    const files = [];
+    const walk = async (dir) => {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (DEFAULT_EXCLUDES.has(entry.name)) continue;
+        if (entry.name.startsWith(".")) continue;
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          await walk(fullPath);
+        } else if (CODE_EXTENSIONS.has(extname(entry.name))) {
+          files.push(fullPath);
+        }
+      }
+    };
+    await walk(dirPath);
+    return files;
+  }
+  extractSymbols(content, filePath) {
+    const symbols = [];
+    const lines = content.split("\n");
+    const exportedNames = /* @__PURE__ */ new Set();
+    const ext = extname(filePath);
+    const lang = getLangPatterns(ext);
+    for (const { pattern, kind } of lang.exported) {
+      const regex = new RegExp(pattern.source, pattern.flags);
+      let match;
+      while ((match = regex.exec(content)) !== null) {
+        const name = match[1];
+        exportedNames.add(name);
+        const line = content.slice(0, match.index).split("\n").length;
+        const signature = kind === "function" || kind === "method" ? extractSignature(lines, line - 1) : void 0;
+        symbols.push({ name, kind, exported: true, filePath, line, signature });
+      }
+    }
+    for (const { pattern, kind } of lang.local) {
+      const regex = new RegExp(pattern.source, pattern.flags);
+      let match;
+      while ((match = regex.exec(content)) !== null) {
+        const name = match[1];
+        if (exportedNames.has(name)) continue;
+        if (!lang.skipIndentFilter) {
+          const lineIdx = content.slice(0, match.index).split("\n").length - 1;
+          const lineContent = lines[lineIdx] ?? "";
+          if (lineContent.startsWith(" ") || lineContent.startsWith("	")) continue;
+        }
+        const line = content.slice(0, match.index).split("\n").length;
+        const signature = kind === "function" || kind === "method" ? extractSignature(lines, line - 1) : void 0;
+        symbols.push({ name, kind, exported: false, filePath, line, signature });
+      }
+    }
+    return symbols;
+  }
+  groupByKind(symbols) {
+    const groups = {};
+    for (const s of symbols) {
+      groups[s.kind] = (groups[s.kind] ?? 0) + 1;
+    }
+    return groups;
+  }
+  formatMarkdown(symbols, rootPath) {
+    const lines = [];
+    const exported = symbols.filter((s) => s.exported).length;
+    lines.push(`## Symbols: ${rootPath}
+`);
+    lines.push(`**${symbols.length} symbols** (${exported} exported)
+`);
+    const kindCounts = {};
+    for (const s of symbols) {
+      kindCounts[s.kind] = (kindCounts[s.kind] ?? 0) + 1;
+    }
+    const kindSummary = Object.entries(kindCounts).sort((a, b) => b[1] - a[1]).map(([kind, count]) => {
+      const plural = kind === "class" ? "classes" : `${kind}s`;
+      return `${count} ${plural}`;
+    }).join(", ");
+    lines.push(`**Breakdown**: ${kindSummary}
+`);
+    const byFile = {};
+    for (const s of symbols) {
+      if (!byFile[s.filePath]) byFile[s.filePath] = [];
+      byFile[s.filePath].push(s);
+    }
+    lines.push(`**${Object.keys(byFile).length} files** with symbols
+`);
+    let totalOutputBytes = 0;
+    const MAX_OUTPUT_BYTES = 80 * 1024;
+    const sortedFiles = Object.entries(byFile).sort((a, b) => {
+      const aExports = a[1].filter((s) => s.exported).length;
+      const bExports = b[1].filter((s) => s.exported).length;
+      return bExports - aExports;
+    });
+    for (const [file, fileSymbols] of sortedFiles) {
+      const exportedSyms = fileSymbols.filter((s) => s.exported);
+      if (exportedSyms.length === 0) continue;
+      const fileSection = [`### ${file}
+`];
+      for (const s of exportedSyms) {
+        const sig = s.signature ? ` \u2014 \`${s.signature}\`` : "";
+        fileSection.push(`- \u{1F4E4} \`${s.kind}\` **${s.name}** (line ${s.line})${sig}`);
+      }
+      const internalCount = fileSymbols.length - exportedSyms.length;
+      if (internalCount > 0) {
+        fileSection.push(
+          `- _${internalCount} internal ${internalCount === 1 ? "symbol" : "symbols"}_`
+        );
+      }
+      fileSection.push("");
+      const sectionText = fileSection.join("\n");
+      totalOutputBytes += sectionText.length;
+      if (totalOutputBytes > MAX_OUTPUT_BYTES) {
+        lines.push(
+          `
+_Output truncated at 80KB. ${Object.keys(byFile).length - lines.filter((l) => l.startsWith("### ")).length} files omitted._`
+        );
+        break;
+      }
+      lines.push(sectionText);
+    }
+    return lines.join("\n");
+  }
+}
+export {
+  SymbolAnalyzer
+};
+//# sourceMappingURL=symbol-analyzer.js.map

package/packages/analyzers/dist/ts-call-graph.d.ts

@@ -0,0 +1,27 @@
+/**
+ * TypeScript Compiler API-based call graph extractor.
+ *
+ * Uses ts.createProgram to build a real type-checked program, then walks
+ * the AST to find function call sites and resolve them to their declaration files.
+ * Produces module-level call edges: which modules call functions in which other modules.
+ */
+export interface ModuleCallEdge {
+    /** Caller module (relative path) */
+    from: string;
+    /** Callee module (relative path) */
+    to: string;
+    /** Function/symbol names called across this edge */
+    symbols: string[];
+}
+export interface CallGraphResult {
+    edges: ModuleCallEdge[];
+    fileCount: number;
+    edgeCount: number;
+    durationMs: number;
+}
+/**
+ * Extract module-level call graph from a TypeScript/JavaScript project.
+ * Returns null if TypeScript compiler is unavailable or no TS files found.
+ */
+export declare function extractTsCallGraph(rootPath: string): Promise<CallGraphResult | null>;
+//# sourceMappingURL=ts-call-graph.d.ts.map

package/packages/analyzers/dist/ts-call-graph.js

@@ -0,0 +1,160 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { extname, join, relative } from "node:path";
+const SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  ".turbo",
+  ".cache",
+  "cdk.out"
+]);
+async function extractTsCallGraph(rootPath) {
+  const startTime = Date.now();
+  if (!hasTsConfig(rootPath)) return null;
+  let ts;
+  try {
+    ts = await import("typescript");
+  } catch {
+    return null;
+  }
+  const sourceFiles = collectTsFiles(rootPath);
+  if (sourceFiles.length === 0) return null;
+  const cappedFiles = sourceFiles.slice(0, 800);
+  const compilerOptions = loadCompilerOptions(ts, rootPath);
+  const program = ts.createProgram(cappedFiles, {
+    ...compilerOptions,
+    noEmit: true,
+    skipLibCheck: true,
+    allowJs: true,
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler
+  });
+  const checker = program.getTypeChecker();
+  const edgeMap = /* @__PURE__ */ new Map();
+  for (const sourceFile of program.getSourceFiles()) {
+    const fileName = sourceFile.fileName;
+    if (sourceFile.isDeclarationFile) continue;
+    if (fileName.includes("node_modules")) continue;
+    const callerRel = relative(rootPath, fileName).replace(/\\/g, "/");
+    if (callerRel.startsWith("..")) continue;
+    visitNode(ts, sourceFile, sourceFile, checker, rootPath, callerRel, edgeMap);
+  }
+  const edges = [];
+  for (const [key, syms] of edgeMap) {
+    const [from, to] = key.split("|");
+    edges.push({ from, to, symbols: [...syms].sort().slice(0, 10) });
+  }
+  edges.sort((a, b) => b.symbols.length - a.symbols.length);
+  return {
+    edges,
+    fileCount: cappedFiles.length,
+    edgeCount: edges.length,
+    durationMs: Date.now() - startTime
+  };
+}
+function hasTsConfig(rootPath) {
+  if (existsSync(join(rootPath, "tsconfig.json"))) return true;
+  if (existsSync(join(rootPath, "tsconfig.build.json"))) return true;
+  try {
+    for (const entry of readdirSync(rootPath, { withFileTypes: true })) {
+      if (entry.isDirectory() && !SKIP_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
+        if (existsSync(join(rootPath, entry.name, "tsconfig.json"))) return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+function loadCompilerOptions(ts, rootPath) {
+  const tsconfigPath = join(rootPath, "tsconfig.json");
+  if (!existsSync(tsconfigPath)) return {};
+  try {
+    const configFile = ts.readConfigFile(tsconfigPath, (p) => readFileSync(p, "utf-8"));
+    if (configFile.error) return {};
+    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, rootPath);
+    return parsed.options;
+  } catch {
+    return {};
+  }
+}
+function collectTsFiles(rootPath) {
+  const files = [];
+  const tsExts = /* @__PURE__ */ new Set([".ts", ".tsx"]);
+  const walk = (dir, depth) => {
+    if (depth > 10) return;
+    try {
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          walk(fullPath, depth + 1);
+        } else if (tsExts.has(extname(entry.name))) {
+          if (entry.name.endsWith(".d.ts")) continue;
+          if (/\.(test|spec)\.[jt]sx?$/.test(entry.name)) continue;
+          const relDir = relative(rootPath, dir).replace(/\\/g, "/");
+          if (relDir.split("/").some((s) => s === "test" || s === "tests" || s === "__tests__" || s === "spec"))
+            continue;
+          files.push(fullPath);
+        }
+      }
+    } catch {
+    }
+  };
+  walk(rootPath, 0);
+  return files;
+}
+function visitNode(ts, node, sourceFile, checker, rootPath, callerRel, edgeMap) {
+  if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
+    const expr = node.expression;
+    resolveCallTarget(ts, expr, checker, rootPath, callerRel, edgeMap);
+  }
+  ts.forEachChild(node, (child) => {
+    visitNode(ts, child, sourceFile, checker, rootPath, callerRel, edgeMap);
+  });
+}
+function remapDistToSource(rel) {
+  const distMatch = rel.match(/^(.+?)\/dist\/(.+)$/);
+  if (!distMatch) return rel;
+  const [, prefix, rest] = distMatch;
+  const srcFile = rest.replace(/\.d\.(m?ts|cts)$/, ".ts");
+  return `${prefix}/src/${srcFile}`;
+}
+function resolveCallTarget(ts, expr, checker, rootPath, callerRel, edgeMap) {
+  try {
+    let symbol;
+    let symbolName;
+    if (ts.isIdentifier(expr)) {
+      symbol = checker.getSymbolAtLocation(expr);
+      symbolName = expr.text;
+    } else if (ts.isPropertyAccessExpression(expr)) {
+      symbol = checker.getSymbolAtLocation(expr.name);
+      symbolName = expr.name.text;
+    }
+    if (!symbol || !symbolName) return;
+    if (symbol.flags & ts.SymbolFlags.Alias) {
+      symbol = checker.getAliasedSymbol(symbol);
+    }
+    const declarations = symbol.getDeclarations();
+    if (!declarations || declarations.length === 0) return;
+    const declFile = declarations[0].getSourceFile().fileName;
+    if (declFile.includes("node_modules")) return;
+    let calleeRel = relative(rootPath, declFile).replace(/\\/g, "/");
+    calleeRel = remapDistToSource(calleeRel);
+    if (calleeRel === callerRel || calleeRel.startsWith("..")) return;
+    const key = `${callerRel}|${calleeRel}`;
+    const existing = edgeMap.get(key);
+    if (existing) {
+      existing.add(symbolName);
+    } else {
+      edgeMap.set(key, /* @__PURE__ */ new Set([symbolName]));
+    }
+  } catch {
+  }
+}
+export {
+  extractTsCallGraph
+};
+//# sourceMappingURL=ts-call-graph.js.map