@shvmgyl15/tsgraph 0.1.0

package/src/analysis/analysis.test.ts

@@ -0,0 +1,405 @@
+import { describe, it, expect } from "vitest";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import {
+  makeGraph,
+  makeSymbolNode,
+  makeCallEdge,
+  makeImportEdge,
+  makePackageNode,
+  makeFileNode,
+} from "../graph/types.js";
+import { cyclomaticComplexity, analyzeComplexity } from "./complexity.js";
+import { findHotspots } from "./hotspot.js";
+import { analyzeCoupling, dependencyTree } from "./coupling.js";
+
+function createTempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "tsgraph-test-"));
+}
+
+describe("cyclomaticComplexity", () => {
+  it("returns 1 for a function with no branches", () => {
+    const code = `function greet() { return "hello"; }`;
+    expect(cyclomaticComplexity(code)).toBe(1);
+  });
+
+  it("counts if statements", () => {
+    const code = `function f() {
+      if (a) return 1;
+      if (b) return 2;
+    }`;
+    expect(cyclomaticComplexity(code)).toBe(3);
+  });
+
+  it("counts if-else as single branch point", () => {
+    const code = `function f() {
+      if (a) { return 1; }
+      else { return 2; }
+    }`;
+    expect(cyclomaticComplexity(code)).toBe(2);
+  });
+
+  it("counts else-if as additional branch", () => {
+    const code = `function f() {
+      if (a) { return 1; }
+      else if (b) { return 2; }
+      else { return 3; }
+    }`;
+    expect(cyclomaticComplexity(code)).toBe(3);
+  });
+
+  it("counts for loops", () => {
+    const code = `function f() {
+      for (let i = 0; i < 10; i++) {}
+    }`;
+    expect(cyclomaticComplexity(code)).toBe(2);
+  });
+
+  it("counts while loops", () => {
+    const code = `function f() {
+      while (true) { break; }
+    }`;
+    expect(cyclomaticComplexity(code)).toBe(2);
+  });
+
+  it("counts case labels", () => {
+    const code = `function f(x: number) {
+      switch (x) {
+        case 1: return "a";
+        case 2: return "b";
+        case 3: return "c";
+      }
+    }`;
+    expect(cyclomaticComplexity(code)).toBe(4);
+  });
+
+  it("counts catch clauses", () => {
+    const code = `function f() {
+      try { doStuff(); }
+      catch (e) { handle(); }
+    }`;
+    expect(cyclomaticComplexity(code)).toBe(2);
+  });
+
+  it("counts ternary operators", () => {
+    const code = `function f() {
+      return a ? b : c;
+    }`;
+    expect(cyclomaticComplexity(code)).toBe(2);
+  });
+
+  it("counts logical && and ||", () => {
+    const code = `function f() {
+      if (a && b || c) return 1;
+    }`;
+    expect(cyclomaticComplexity(code)).toBe(4);
+  });
+
+  it("avoids counting string literals", () => {
+    const code = `function f() {
+      const s = "if (true) { for(;;) {} }";
+      return s;
+    }`;
+    expect(cyclomaticComplexity(code)).toBe(1);
+  });
+
+  it("ignores comments", () => {
+    const code = `function f() {
+      // if (true) { return 1; }
+      /* for(;;) {} */
+      return 0;
+    }`;
+    expect(cyclomaticComplexity(code)).toBe(1);
+  });
+});
+
+describe("analyzeComplexity", () => {
+  it("returns complexity for all functions in a project", () => {
+    const dir = createTempDir();
+    const filePath = path.join(dir, "src/lib.ts");
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(
+      filePath,
+      [
+        "export function simple() { return 1; }",
+        "export function complex() {",
+        "  if (a) { for(;;) {} }",
+        "  return 0;",
+        "}",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const graph = makeGraph({
+      root: dir,
+      files: [makeFileNode({ path: "src/lib.ts", lines: 5 })],
+      symbols: [
+        makeSymbolNode({
+          id: "simple",
+          name: "simple",
+          kind: "function",
+          file: "src/lib.ts",
+          line: 1,
+          endLine: 1,
+          packageName: "app",
+          isExported: true,
+        }),
+        makeSymbolNode({
+          id: "complex",
+          name: "complex",
+          kind: "function",
+          file: "src/lib.ts",
+          line: 2,
+          endLine: 5,
+          packageName: "app",
+          isExported: true,
+        }),
+      ],
+    });
+
+    const results = analyzeComplexity(graph);
+    expect(results).toHaveLength(2);
+    const simple = results.find((r) => r.symbol.name === "simple");
+    const complex = results.find((r) => r.symbol.name === "complex");
+    expect(simple!.complexity).toBe(1);
+    expect(complex!.complexity).toBeGreaterThanOrEqual(2);
+
+    fs.rmSync(dir, { recursive: true });
+  });
+
+  it("filters by file when specified", () => {
+    const dir = createTempDir();
+    const filePath = path.join(dir, "src/a.ts");
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, "export function foo() {}", "utf-8");
+
+    const graph = makeGraph({
+      root: dir,
+      symbols: [
+        makeSymbolNode({
+          id: "foo",
+          name: "foo",
+          kind: "function",
+          file: "src/a.ts",
+          line: 1,
+          endLine: 1,
+        }),
+        makeSymbolNode({
+          id: "bar",
+          name: "bar",
+          kind: "function",
+          file: "src/b.ts",
+          line: 1,
+          endLine: 1,
+        }),
+      ],
+    });
+
+    const results = analyzeComplexity(graph, "a.ts");
+    expect(results).toHaveLength(1);
+    expect(results[0].symbol.name).toBe("foo");
+
+    fs.rmSync(dir, { recursive: true });
+  });
+});
+
+describe("findHotspots", () => {
+  it("returns top hotspots sorted by score", () => {
+    const dir = createTempDir();
+    const filePath = path.join(dir, "src/hot.ts");
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(
+      filePath,
+      [
+        "export function a() {",
+        "  if (x) { for(;;) {} }",
+        "  if (y) { while(z) {} }",
+        "  return 0;",
+        "}",
+        "export function b() { return 1; }",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const graph = makeGraph({
+      root: dir,
+      files: [makeFileNode({ path: "src/hot.ts", lines: 6 })],
+      symbols: [
+        makeSymbolNode({
+          id: "a",
+          name: "a",
+          kind: "function",
+          file: "src/hot.ts",
+          line: 1,
+          endLine: 5,
+          packageName: "app",
+        }),
+        makeSymbolNode({
+          id: "b",
+          name: "b",
+          kind: "function",
+          file: "src/hot.ts",
+          line: 6,
+          endLine: 6,
+          packageName: "app",
+        }),
+      ],
+    });
+
+    const hotspots = findHotspots(graph, 5);
+    expect(hotspots.length).toBeGreaterThanOrEqual(1);
+    expect(hotspots[0].file).toBe("src/hot.ts");
+
+    fs.rmSync(dir, { recursive: true });
+  });
+});
+
+describe("analyzeCoupling", () => {
+  it("finds packages importing from other modules", () => {
+    const graph = makeGraph({
+      files: [
+        makeFileNode({ path: "src/orders.ts", packageName: "orders" }),
+        makeFileNode({ path: "src/payment.ts", packageName: "payment" }),
+        makeFileNode({ path: "src/notify.ts", packageName: "notify" }),
+      ],
+      imports: [
+        makeImportEdge({
+          fromFile: "src/orders.ts",
+          fromPackage: "orders",
+          importPath: "payment",
+          alias: "payment",
+          isDefault: true,
+        }),
+        makeImportEdge({
+          fromFile: "src/orders.ts",
+          fromPackage: "orders",
+          importPath: "notify",
+          alias: "notify",
+          isDefault: true,
+        }),
+        makeImportEdge({
+          fromFile: "src/orders.ts",
+          fromPackage: "orders",
+          importPath: "payment",
+          alias: "processPayment",
+          isDefault: false,
+        }),
+      ],
+    });
+
+    const results = analyzeCoupling(graph);
+    expect(results).toHaveLength(2);
+    const paymentCoupling = results.find((r) => r.coupledTo === "payment");
+    expect(paymentCoupling).toBeTruthy();
+    expect(paymentCoupling!.importCount).toBe(2);
+    expect(paymentCoupling!.packageName).toBe("orders");
+  });
+});
+
+describe("dependencyTree", () => {
+  it("builds a tree from call edges", () => {
+    const graph = makeGraph({
+      symbols: [
+        makeSymbolNode({
+          id: "src/main.ts::serve",
+          name: "serve",
+          kind: "function",
+          file: "src/main.ts",
+          line: 1,
+          endLine: 5,
+          packageName: "app",
+        }),
+        makeSymbolNode({
+          id: "src/main.ts::greet",
+          name: "greet",
+          kind: "function",
+          file: "src/main.ts",
+          line: 6,
+          endLine: 8,
+          packageName: "app",
+        }),
+        makeSymbolNode({
+          id: "src/main.ts::log",
+          name: "log",
+          kind: "function",
+          file: "src/main.ts",
+          line: 9,
+          endLine: 11,
+          packageName: "app",
+        }),
+      ],
+      calls: [
+        makeCallEdge({
+          callerSymbolId: "src/main.ts::serve",
+          callerName: "serve",
+          calleeRaw: "greet",
+          file: "src/main.ts",
+          line: 3,
+        }),
+        makeCallEdge({
+          callerSymbolId: "src/main.ts::serve",
+          callerName: "serve",
+          calleeRaw: "log",
+          file: "src/main.ts",
+          line: 4,
+        }),
+      ],
+    });
+
+    const tree = dependencyTree(graph, "serve");
+    expect(tree).toBeTruthy();
+    expect(tree!.name).toBe("serve");
+    expect(tree!.children).toHaveLength(2);
+    const childNames = tree!.children.map((c) => c.name).sort();
+    expect(childNames).toEqual(["greet", "log"]);
+  });
+
+  it("returns undefined for unknown symbol", () => {
+    const graph = makeGraph();
+    const tree = dependencyTree(graph, "noop");
+    expect(tree).toBeUndefined();
+  });
+
+  it("respects max depth", () => {
+    const graph = makeGraph({
+      symbols: [
+        makeSymbolNode({
+          id: "a",
+          name: "a",
+          kind: "function",
+          file: "a.ts",
+          line: 1,
+          endLine: 1,
+          packageName: "app",
+        }),
+        makeSymbolNode({
+          id: "b",
+          name: "b",
+          kind: "function",
+          file: "b.ts",
+          line: 1,
+          endLine: 1,
+          packageName: "app",
+        }),
+        makeSymbolNode({
+          id: "c",
+          name: "c",
+          kind: "function",
+          file: "c.ts",
+          line: 1,
+          endLine: 1,
+          packageName: "app",
+        }),
+      ],
+      calls: [
+        makeCallEdge({ callerSymbolId: "a", callerName: "a", calleeRaw: "b", file: "a.ts", line: 1 }),
+        makeCallEdge({ callerSymbolId: "b", callerName: "b", calleeRaw: "c", file: "b.ts", line: 1 }),
+      ],
+    });
+
+    const tree = dependencyTree(graph, "a", 1);
+    expect(tree!.children).toHaveLength(1);
+    expect(tree!.children[0].children).toHaveLength(0);
+  });
+});

package/src/analysis/complexity.ts

@@ -0,0 +1,107 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { Graph, SymbolNode } from "../graph/types.js";
+
+interface DecisionPattern {
+  regex: RegExp;
+  label: string;
+}
+
+const DECISION_PATTERNS: DecisionPattern[] = [
+  { regex: /\bif\s*\(/g, label: "if" },
+  { regex: /\belse\s+if\s*\(/g, label: "elseif" },
+  { regex: /\bfor\s*\(/g, label: "for" },
+  { regex: /\bwhile\s*\(/g, label: "while" },
+  { regex: /\bdo\s*\{/g, label: "do" },
+  { regex: /\bcatch\s*\(/g, label: "catch" },
+  { regex: /\bcase\s+/g, label: "case" },
+  { regex: /\|\|/g, label: "or" },
+  { regex: /&&/g, label: "and" },
+];
+
+function stripComments(code: string): string {
+  return code
+    .replace(/\/\/.*$/gm, "")
+    .replace(/\/\*[\s\S]*?\*\//g, "");
+}
+
+function stripStrings(code: string): string {
+  const inString = (s: string) => {
+    let result = "";
+    let i = 0;
+    while (i < s.length) {
+      if (s[i] === '"' || s[i] === "'" || s[i] === "`") {
+        const quote = s[i];
+        i++;
+        while (i < s.length && s[i] !== quote) {
+          if (s[i] === "\\") i++;
+          i++;
+        }
+      } else {
+        result += s[i];
+      }
+      i++;
+    }
+    return result;
+  };
+  return inString(code);
+}
+
+export function cyclomaticComplexity(sourceCode: string): number {
+  const cleaned = stripStrings(stripComments(sourceCode));
+  let decisions = 0;
+
+  for (const dp of DECISION_PATTERNS) {
+    const matches = cleaned.match(dp.regex);
+    if (matches) decisions += matches.length;
+  }
+
+  const elseIfCount = (cleaned.match(/\belse\s+if\s*\(/g) || []).length;
+  decisions -= elseIfCount;
+
+  const ternaryMatches = cleaned.match(/\?/g);
+  if (ternaryMatches) {
+    for (const m of ternaryMatches) {
+      const idx = cleaned.indexOf(m);
+      const before = cleaned[idx - 1];
+      if (before !== "?" && before !== "!" && before !== "=") {
+        decisions++;
+      }
+    }
+  }
+
+  return Math.max(1, 1 + decisions);
+}
+
+export interface ComplexityResult {
+  symbol: SymbolNode;
+  complexity: number;
+}
+
+export function analyzeComplexity(
+  graph: Graph,
+  fileFilter?: string,
+): ComplexityResult[] {
+  const results: ComplexityResult[] = [];
+  const root = graph.root;
+
+  for (const sym of graph.symbols) {
+    if (fileFilter && !sym.file.includes(fileFilter)) continue;
+    if (sym.kind !== "function" && sym.kind !== "method") continue;
+
+    const filePath = path.join(root, sym.file);
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      const lines = content.split("\n");
+      const start = Math.max(0, sym.line - 1);
+      const end = Math.min(lines.length, sym.endLine);
+      const snippet = lines.slice(start, end).join("\n");
+      const complexity = cyclomaticComplexity(snippet);
+      results.push({ symbol: sym, complexity });
+    } catch {
+      continue;
+    }
+  }
+
+  return results;
+}

package/src/analysis/coupling.ts

@@ -0,0 +1,106 @@
+import type { Graph, ImportEdge, SymbolNode } from "../graph/types.js";
+
+export interface CouplingResult {
+  packageName: string;
+  coupledTo: string;
+  importCount: number;
+  fileCount: number;
+}
+
+export interface DepsNode {
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  children: DepsNode[];
+}
+
+export function analyzeCoupling(graph: Graph): CouplingResult[] {
+  const pkgFiles = new Map<string, Set<string>>();
+  for (const f of graph.files) {
+    const files = pkgFiles.get(f.packageName) ?? new Set();
+    files.add(f.path);
+    pkgFiles.set(f.packageName, files);
+  }
+
+  const pkgImportTargets = new Map<string, Map<string, { files: Set<string>; count: number }>>();
+  for (const imp of graph.imports) {
+    const target = imp.importPath.split("/")[0];
+    const byPkg = pkgImportTargets.get(imp.fromPackage) ?? new Map();
+    const entry = byPkg.get(target) ?? { files: new Set<string>(), count: 0 };
+    entry.files.add(imp.fromFile);
+    entry.count++;
+    byPkg.set(target, entry);
+    pkgImportTargets.set(imp.fromPackage, byPkg);
+  }
+
+  const results: CouplingResult[] = [];
+  for (const [pkg, targets] of pkgImportTargets) {
+    for (const [target, entry] of targets) {
+      if (pkg === target) continue;
+      results.push({
+        packageName: pkg,
+        coupledTo: target,
+        importCount: entry.count,
+        fileCount: entry.files.size,
+      });
+    }
+  }
+
+  results.sort((a, b) => b.importCount - a.importCount);
+  return results;
+}
+
+export function dependencyTree(
+  graph: Graph,
+  symbolName: string,
+  maxDepth: number = 3,
+): DepsNode | undefined {
+  const sym = graph.symbols.find((s) => s.name === symbolName);
+  if (!sym) return undefined;
+
+  function buildTree(
+    current: SymbolNode,
+    depth: number,
+    visited: Set<string>,
+  ): DepsNode {
+    const node: DepsNode = {
+      name: current.name,
+      kind: current.kind,
+      file: current.file,
+      line: current.line,
+      children: [],
+    };
+
+    if (depth >= maxDepth) return node;
+
+    const calleeEdges = graph.calls.filter(
+      (c) => c.callerSymbolId === current.id,
+    );
+
+    for (const edge of calleeEdges) {
+      if (visited.has(edge.calleeRaw)) continue;
+      visited.add(edge.calleeRaw);
+
+      const calleeSym = graph.symbols.find(
+        (s) => s.name === edge.calleeRaw && s.file === edge.file,
+      );
+
+      if (calleeSym) {
+        node.children.push(buildTree(calleeSym, depth + 1, visited));
+      } else {
+        node.children.push({
+          name: edge.calleeRaw,
+          kind: "unknown",
+          file: edge.file,
+          line: edge.line,
+          children: [],
+        });
+      }
+    }
+
+    return node;
+  }
+
+  return buildTree(sym, 0, new Set([symbolName]));
+}

package/src/analysis/hotspot.ts

@@ -0,0 +1,52 @@
+import type { Graph } from "../graph/types.js";
+import { analyzeComplexity } from "./complexity.js";
+
+export interface HotspotResult {
+  file: string;
+  score: number;
+  symbolCount: number;
+  totalComplexity: number;
+  lines: number;
+}
+
+export function findHotspots(
+  graph: Graph,
+  topN: number = 10,
+): HotspotResult[] {
+  const fileNodes = new Map(graph.files.map((f) => [f.path, f]));
+  const complexityResults = analyzeComplexity(graph);
+  const fileScores = new Map<
+    string,
+    { totalComplexity: number; symbolCount: number; lines: number }
+  >();
+
+  for (const r of complexityResults) {
+    const entry = fileScores.get(r.symbol.file) ?? {
+      totalComplexity: 0,
+      symbolCount: 0,
+      lines: 1,
+    };
+    entry.totalComplexity += r.complexity;
+    entry.symbolCount++;
+    fileScores.set(r.symbol.file, entry);
+  }
+
+  for (const [filePath, entry] of fileScores) {
+    const fn = fileNodes.get(filePath);
+    entry.lines = fn?.lines ?? 1;
+  }
+
+  const results: HotspotResult[] = [];
+  for (const [file, data] of fileScores) {
+    results.push({
+      file,
+      score: data.totalComplexity * data.lines,
+      symbolCount: data.symbolCount,
+      totalComplexity: data.totalComplexity,
+      lines: data.lines,
+    });
+  }
+
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, topN);
+}

package/src/analysis/index.ts

@@ -0,0 +1,17 @@
+import type { Graph } from "../graph/types.js";
+import { analyzeComplexity, cyclomaticComplexity } from "./complexity.js";
+import type { ComplexityResult } from "./complexity.js";
+import { findHotspots } from "./hotspot.js";
+import type { HotspotResult } from "./hotspot.js";
+import { analyzeCoupling, dependencyTree } from "./coupling.js";
+import type { CouplingResult, DepsNode } from "./coupling.js";
+
+export {
+  analyzeComplexity,
+  cyclomaticComplexity,
+  findHotspots,
+  analyzeCoupling,
+  dependencyTree,
+};
+
+export type { ComplexityResult, HotspotResult, CouplingResult, DepsNode };