@shvmgyl15/tsgraph 0.1.0 → 0.2.0

package/src/analysis/coupling.ts

@@ -1,106 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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 };

package/src/boundaries/index.test.ts

@@ -1,335 +0,0 @@
-import { describe, it, expect } from "vitest";
-import path from "node:path";
-import fs from "node:fs";
-import os from "node:os";
-import {
-  makeGraph,
-  makeImportEdge,
-  makeFileNode,
-  makePackageNode,
-} from "../graph/types.js";
-import {
-  loadBoundariesConfig,
-  checkBoundaries,
-} from "./index.js";
-import type { BoundariesConfig, LayerConfig } from "./index.js";
-
-function createTempDir(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), "tsgraph-boundaries-"));
-}
-
-function makeConfig(layers: LayerConfig[]): BoundariesConfig {
-  return { layers };
-}
-
-const uiLayer: LayerConfig = {
-  name: "ui",
-  path: "src/components",
-  dependsOn: ["shared"],
-};
-
-const sharedLayer: LayerConfig = {
-  name: "shared",
-  path: "src/shared",
-  dependsOn: ["lib"],
-};
-
-const libLayer: LayerConfig = {
-  name: "lib",
-  path: "src/lib",
-  dependsOn: [],
-};
-
-const defaultConfig = makeConfig([uiLayer, sharedLayer, libLayer]);
-
-describe("loadBoundariesConfig", () => {
-  it("reads and parses valid config", () => {
-    const dir = createTempDir();
-    const configDir = path.join(dir, ".tsgraph");
-    fs.mkdirSync(configDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(configDir, "boundaries.json"),
-      JSON.stringify(defaultConfig),
-      "utf-8",
-    );
-    const loaded = loadBoundariesConfig(dir);
-    expect(loaded).not.toBeNull();
-    expect(loaded!.layers).toHaveLength(3);
-    expect(loaded!.layers[0].name).toBe("ui");
-    expect(loaded!.layers[0].dependsOn).toEqual(["shared"]);
-    fs.rmSync(dir, { recursive: true });
-  });
-
-  it("returns null when file does not exist", () => {
-    const dir = createTempDir();
-    const loaded = loadBoundariesConfig(dir);
-    expect(loaded).toBeNull();
-    fs.rmSync(dir, { recursive: true });
-  });
-
-  it("returns null for invalid JSON", () => {
-    const dir = createTempDir();
-    const configDir = path.join(dir, ".tsgraph");
-    fs.mkdirSync(configDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(configDir, "boundaries.json"),
-      "not json",
-      "utf-8",
-    );
-    const loaded = loadBoundariesConfig(dir);
-    expect(loaded).toBeNull();
-    fs.rmSync(dir, { recursive: true });
-  });
-
-  it("returns null for invalid schema", () => {
-    const dir = createTempDir();
-    const configDir = path.join(dir, ".tsgraph");
-    fs.mkdirSync(configDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(configDir, "boundaries.json"),
-      JSON.stringify({ layers: [{ name: "ui" }] }),
-      "utf-8",
-    );
-    const loaded = loadBoundariesConfig(dir);
-    expect(loaded).toBeNull();
-    fs.rmSync(dir, { recursive: true });
-  });
-});
-
-describe("checkBoundaries", () => {
-  it("allows legal import within same layer", () => {
-    const graph = makeGraph({
-      files: [
-        makeFileNode({ path: "src/components/Button.tsx", packageName: "app" }),
-        makeFileNode({ path: "src/components/Panel.tsx", packageName: "app" }),
-      ],
-      imports: [
-        makeImportEdge({
-          fromFile: "src/components/Button.tsx",
-          fromPackage: "app",
-          importPath: "./Panel",
-        }),
-      ],
-    });
-    const result = checkBoundaries(graph, defaultConfig);
-    expect(result.violations).toHaveLength(0);
-    expect(result.allowed).toBe(1);
-  });
-
-  it("allows legal import to a depended-on layer", () => {
-    const graph = makeGraph({
-      files: [
-        makeFileNode({ path: "src/components/Page.tsx", packageName: "app" }),
-        makeFileNode({ path: "src/shared/helper.ts", packageName: "shared" }),
-      ],
-      imports: [
-        makeImportEdge({
-          fromFile: "src/components/Page.tsx",
-          fromPackage: "app",
-          importPath: "../shared/helper",
-        }),
-      ],
-    });
-    const result = checkBoundaries(graph, defaultConfig);
-    expect(result.violations).toHaveLength(0);
-    expect(result.allowed).toBe(1);
-  });
-
-  it("flags violation for import to a non-depended layer", () => {
-    const graph = makeGraph({
-      files: [
-        makeFileNode({ path: "src/components/Page.tsx", packageName: "app" }),
-        makeFileNode({ path: "src/lib/util.ts", packageName: "lib" }),
-      ],
-      imports: [
-        makeImportEdge({
-          fromFile: "src/components/Page.tsx",
-          fromPackage: "app",
-          importPath: "../lib/util",
-        }),
-      ],
-    });
-    const result = checkBoundaries(graph, defaultConfig);
-    expect(result.violations).toHaveLength(1);
-    expect(result.allowed).toBe(0);
-    expect(result.violations[0].fromLayer).toBe("ui");
-    expect(result.violations[0].toLayer).toBe("lib");
-    expect(result.violations[0].fromFile).toBe("src/components/Page.tsx");
-    expect(result.violations[0].toFile).toBe("src/lib/util.ts");
-    expect(result.violations[0].toPackage).toBe("lib");
-    expect(result.violations[0].rule).toBe("ui → lib not allowed");
-  });
-
-  it("allows legal import through transitive dependency chain", () => {
-    const graph = makeGraph({
-      files: [
-        makeFileNode({ path: "src/shared/util.ts", packageName: "shared" }),
-        makeFileNode({ path: "src/lib/helper.ts", packageName: "lib" }),
-      ],
-      imports: [
-        makeImportEdge({
-          fromFile: "src/shared/util.ts",
-          fromPackage: "shared",
-          importPath: "../lib/helper",
-        }),
-      ],
-    });
-    const result = checkBoundaries(graph, defaultConfig);
-    expect(result.violations).toHaveLength(0);
-    expect(result.allowed).toBe(1);
-  });
-
-  it("treats bare module imports as allowed (unresolved)", () => {
-    const graph = makeGraph({
-      files: [
-        makeFileNode({ path: "src/components/Page.tsx", packageName: "app" }),
-      ],
-      imports: [
-        makeImportEdge({
-          fromFile: "src/components/Page.tsx",
-          fromPackage: "app",
-          importPath: "react",
-        }),
-      ],
-    });
-    const result = checkBoundaries(graph, defaultConfig);
-    expect(result.violations).toHaveLength(0);
-    expect(result.allowed).toBe(1);
-  });
-
-  it("treats imports to files outside known layers as allowed", () => {
-    const graph = makeGraph({
-      files: [
-        makeFileNode({ path: "src/components/Page.tsx", packageName: "app" }),
-        makeFileNode({ path: "src/generated/api.ts", packageName: "api" }),
-      ],
-      imports: [
-        makeImportEdge({
-          fromFile: "src/components/Page.tsx",
-          fromPackage: "app",
-          importPath: "../generated/api",
-        }),
-      ],
-    });
-    const result = checkBoundaries(graph, defaultConfig);
-    expect(result.violations).toHaveLength(0);
-    expect(result.allowed).toBe(1);
-  });
-
-  it("treats files outside any layer as allowed", () => {
-    const graph = makeGraph({
-      files: [
-        makeFileNode({ path: "src/generated/api.ts", packageName: "api" }),
-        makeFileNode({ path: "src/lib/util.ts", packageName: "lib" }),
-      ],
-      imports: [
-        makeImportEdge({
-          fromFile: "src/generated/api.ts",
-          fromPackage: "api",
-          importPath: "../lib/util",
-        }),
-      ],
-    });
-    const result = checkBoundaries(graph, defaultConfig);
-    expect(result.violations).toHaveLength(0);
-    expect(result.allowed).toBe(1);
-  });
-
-  it("handles mixed allowed and violating imports", () => {
-    const graph = makeGraph({
-      files: [
-        makeFileNode({ path: "src/components/Page.tsx", packageName: "app" }),
-        makeFileNode({ path: "src/shared/helper.ts", packageName: "shared" }),
-        makeFileNode({ path: "src/lib/util.ts", packageName: "lib" }),
-      ],
-      imports: [
-        makeImportEdge({
-          fromFile: "src/components/Page.tsx",
-          fromPackage: "app",
-          importPath: "../shared/helper",
-        }),
-        makeImportEdge({
-          fromFile: "src/components/Page.tsx",
-          fromPackage: "app",
-          importPath: "../lib/util",
-        }),
-        makeImportEdge({
-          fromFile: "src/components/Page.tsx",
-          fromPackage: "app",
-          importPath: "react",
-        }),
-      ],
-    });
-    const result = checkBoundaries(graph, defaultConfig);
-    expect(result.violations).toHaveLength(1);
-    expect(result.allowed).toBe(2);
-    expect(result.violations[0].toLayer).toBe("lib");
-  });
-
-  it("resolves imports with .tsx extension", () => {
-    const graph = makeGraph({
-      files: [
-        makeFileNode({ path: "src/components/Page.tsx", packageName: "app" }),
-        makeFileNode({ path: "src/shared/helper.tsx", packageName: "shared" }),
-      ],
-      imports: [
-        makeImportEdge({
-          fromFile: "src/components/Page.tsx",
-          fromPackage: "app",
-          importPath: "../shared/helper",
-        }),
-      ],
-    });
-    const result = checkBoundaries(graph, defaultConfig);
-    expect(result.violations).toHaveLength(0);
-    expect(result.allowed).toBe(1);
-  });
-
-  it("resolves imports with index.ts pattern", () => {
-    const graph = makeGraph({
-      files: [
-        makeFileNode({ path: "src/components/Page.tsx", packageName: "app" }),
-        makeFileNode({ path: "src/shared/index.ts", packageName: "shared" }),
-      ],
-      imports: [
-        makeImportEdge({
-          fromFile: "src/components/Page.tsx",
-          fromPackage: "app",
-          importPath: "../shared",
-        }),
-      ],
-    });
-    const result = checkBoundaries(graph, defaultConfig);
-    expect(result.violations).toHaveLength(0);
-    expect(result.allowed).toBe(1);
-  });
-
-  it("populates toPackage from graph file nodes", () => {
-    const graph = makeGraph({
-      files: [
-        makeFileNode({ path: "src/components/Page.tsx", packageName: "app" }),
-        makeFileNode({ path: "src/lib/util.ts", packageName: "lib-pkg" }),
-      ],
-      imports: [
-        makeImportEdge({
-          fromFile: "src/components/Page.tsx",
-          fromPackage: "app",
-          importPath: "../lib/util",
-        }),
-      ],
-    });
-    const result = checkBoundaries(graph, defaultConfig);
-    expect(result.violations).toHaveLength(1);
-    expect(result.violations[0].toPackage).toBe("lib-pkg");
-  });
-
-  it("returns config in result", () => {
-    const graph = makeGraph({
-      files: [],
-      imports: [],
-    });
-    const result = checkBoundaries(graph, defaultConfig);
-    expect(result.config).toBe(defaultConfig);
-    expect(result.config.layers).toHaveLength(3);
-  });
-});

package/src/boundaries/index.ts

@@ -1,137 +0,0 @@
-import type { Graph } from "../graph/types.js";
-import path from "node:path";
-import fs from "node:fs";
-import { z } from "zod/v4";
-
-export interface LayerConfig {
-  name: string;
-  path: string;
-  dependsOn: string[];
-}
-
-export interface BoundariesConfig {
-  layers: LayerConfig[];
-}
-
-export interface BoundaryViolation {
-  fromFile: string;
-  fromLayer: string;
-  toFile: string;
-  toLayer: string;
-  toPackage: string;
-  rule: string;
-}
-
-export interface BoundaryResult {
-  violations: BoundaryViolation[];
-  allowed: number;
-  config: BoundariesConfig;
-}
-
-const layerConfigSchema = z.object({
-  name: z.string(),
-  path: z.string(),
-  dependsOn: z.array(z.string()),
-});
-
-const boundariesConfigSchema = z.object({
-  layers: z.array(layerConfigSchema),
-});
-
-export function loadBoundariesConfig(rootDir: string): BoundariesConfig | null {
-  const configPath = path.join(rootDir, ".tsgraph", "boundaries.json");
-  try {
-    const raw = fs.readFileSync(configPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    const result = boundariesConfigSchema.safeParse(parsed);
-    if (!result.success) return null;
-    return result.data;
-  } catch {
-    return null;
-  }
-}
-
-const EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
-const INDEX_PATTERNS = ["/index", ""];
-
-function findLayerByPath(filePath: string, config: BoundariesConfig): LayerConfig | undefined {
-  return config.layers.find((layer) => filePath.startsWith(layer.path));
-}
-
-function resolveTargetPath(fromFile: string, importPath: string): string | undefined {
-  if (importPath.startsWith(".")) {
-    const dir = path.posix.dirname(fromFile);
-    return path.posix.normalize(path.posix.join(dir, importPath));
-  }
-  if (importPath.startsWith("/")) {
-    return path.posix.normalize(importPath);
-  }
-  return undefined;
-}
-
-function matchFile(resolved: string, files: { path: string }[]): string | undefined {
-  for (const file of files) {
-    if (file.path === resolved) return file.path;
-    for (const ext of EXTENSIONS) {
-      if (file.path === resolved + ext) return file.path;
-    }
-    for (const ext of EXTENSIONS) {
-      for (const idx of INDEX_PATTERNS) {
-        if (file.path === resolved + idx + ext) return file.path;
-      }
-    }
-  }
-  return undefined;
-}
-
-export function checkBoundaries(graph: Graph, config: BoundariesConfig): BoundaryResult {
-  const violations: BoundaryViolation[] = [];
-  let allowed = 0;
-
-  for (const imp of graph.imports) {
-    const fromLayer = findLayerByPath(imp.fromFile, config);
-    if (!fromLayer) {
-      allowed++;
-      continue;
-    }
-
-    const resolved = resolveTargetPath(imp.fromFile, imp.importPath);
-    if (!resolved) {
-      allowed++;
-      continue;
-    }
-
-    const matchedFile = matchFile(resolved, graph.files);
-    if (!matchedFile) {
-      allowed++;
-      continue;
-    }
-
-    const toLayer = findLayerByPath(matchedFile, config);
-    if (!toLayer) {
-      allowed++;
-      continue;
-    }
-
-    if (fromLayer.name === toLayer.name) {
-      allowed++;
-      continue;
-    }
-
-    if (!fromLayer.dependsOn.includes(toLayer.name)) {
-      const targetFile = graph.files.find((f) => f.path === matchedFile);
-      violations.push({
-        fromFile: imp.fromFile,
-        fromLayer: fromLayer.name,
-        toFile: matchedFile,
-        toLayer: toLayer.name,
-        toPackage: targetFile?.packageName ?? toLayer.name,
-        rule: `${fromLayer.name} → ${toLayer.name} not allowed`,
-      });
-    } else {
-      allowed++;
-    }
-  }
-
-  return { violations, allowed, config };
-}