@shvmgyl15/tsgraph 0.1.0

package/src/parser/parser.test.ts

@@ -0,0 +1,282 @@
+import { describe, it, expect } from "vitest";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import { scanFiles } from "../scanner/index.js";
+import { parseProject } from "./index.js";
+
+function createTempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "tsgraph-test-"));
+}
+
+function writeFile(dir: string, relativePath: string, content: string) {
+  const fullPath = path.join(dir, relativePath);
+  fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+  fs.writeFileSync(fullPath, content, "utf-8");
+}
+
+describe("parseProject", () => {
+  it("extracts functions from a TypeScript file", () => {
+    const dir = createTempDir();
+    writeFile(dir, "index.ts", `
+export function greet(name: string): string {
+  return "Hello " + name;
+}
+
+function helper() {
+  return 42;
+}
+`);
+
+    const { files } = scanFiles(dir);
+    const graph = parseProject(dir, files);
+
+    expect(graph.symbols).toHaveLength(2);
+
+    const greet = graph.symbols.find((s) => s.name === "greet");
+    expect(greet).toBeTruthy();
+    expect(greet!.kind).toBe("function");
+    expect(greet!.isExported).toBe(true);
+    expect(greet!.file).toBe("index.ts");
+
+    const helper = graph.symbols.find((s) => s.name === "helper");
+    expect(helper).toBeTruthy();
+    expect(helper!.kind).toBe("function");
+    expect(helper!.isExported).toBe(false);
+    fs.rmSync(dir, { recursive: true });
+  });
+
+  it("extracts classes with methods", () => {
+    const dir = createTempDir();
+    writeFile(dir, "user.ts", `
+export class User {
+  name: string;
+
+  constructor(name: string) {
+    this.name = name;
+  }
+
+  greet(): string {
+    return "Hi " + this.name;
+  }
+}
+`);
+
+    const { files } = scanFiles(dir);
+    const graph = parseProject(dir, files);
+
+    const cls = graph.symbols.find((s) => s.name === "User");
+    expect(cls).toBeTruthy();
+    expect(cls!.kind).toBe("class");
+    expect(cls!.isExported).toBe(true);
+
+    const greet = graph.symbols.find((s) => s.name === "greet");
+    expect(greet).toBeTruthy();
+    expect(greet!.kind).toBe("method");
+    expect(greet!.receiver).toBe("User");
+
+    fs.rmSync(dir, { recursive: true });
+  });
+
+  it("extracts interfaces and type aliases", () => {
+    const dir = createTempDir();
+    writeFile(dir, "types.ts", `
+export interface Props {
+  name: string;
+  age?: number;
+}
+
+export type Status = "active" | "inactive";
+
+type Internal = number;
+`);
+
+    const { files } = scanFiles(dir);
+    const graph = parseProject(dir, files);
+
+    expect(graph.symbols).toHaveLength(3);
+
+    const props = graph.symbols.find((s) => s.name === "Props");
+    expect(props).toBeTruthy();
+    expect(props!.kind).toBe("interface");
+    expect(props!.isExported).toBe(true);
+
+    const status = graph.symbols.find((s) => s.name === "Status");
+    expect(status).toBeTruthy();
+    expect(status!.kind).toBe("type_alias");
+    expect(status!.isExported).toBe(true);
+
+    const internal = graph.symbols.find((s) => s.name === "Internal");
+    expect(internal).toBeTruthy();
+    expect(internal!.kind).toBe("type_alias");
+    expect(internal!.isExported).toBe(false);
+
+    fs.rmSync(dir, { recursive: true });
+  });
+
+  it("extracts enums", () => {
+    const dir = createTempDir();
+    writeFile(dir, "enums.ts", `
+export enum Color {
+  Red,
+  Green,
+  Blue,
+}
+`);
+
+    const { files } = scanFiles(dir);
+    const graph = parseProject(dir, files);
+
+    const color = graph.symbols.find((s) => s.name === "Color");
+    expect(color).toBeTruthy();
+    expect(color!.kind).toBe("enum");
+    expect(color!.isExported).toBe(true);
+
+    fs.rmSync(dir, { recursive: true });
+  });
+
+  it("extracts const and var declarations", () => {
+    const dir = createTempDir();
+    writeFile(dir, "vars.ts", `
+export const MAX = 100;
+const TIMEOUT = 5000;
+var name = "test";
+`);
+
+    const { files } = scanFiles(dir);
+    const graph = parseProject(dir, files);
+
+    const max = graph.symbols.find((s) => s.name === "MAX");
+    expect(max).toBeTruthy();
+    expect(max!.kind).toBe("const");
+    expect(max!.isExported).toBe(true);
+
+    const timeout = graph.symbols.find((s) => s.name === "TIMEOUT");
+    expect(timeout).toBeTruthy();
+    expect(timeout!.kind).toBe("const");
+    expect(timeout!.isExported).toBe(false);
+
+    const n = graph.symbols.find((s) => s.name === "name");
+    expect(n).toBeTruthy();
+    expect(n!.kind).toBe("var");
+
+    fs.rmSync(dir, { recursive: true });
+  });
+
+  it("extracts call expressions within function bodies", () => {
+    const dir = createTempDir();
+    writeFile(dir, "lib.ts", `
+export function log(msg: string) {
+  console.log(msg);
+}
+
+export function process() {
+  log("starting");
+  Math.random();
+}
+`);
+
+    const { files } = scanFiles(dir);
+    const graph = parseProject(dir, files);
+
+    // process calls log and Math.random
+    const processCalls = graph.calls.filter((c) => c.callerName === "process");
+    expect(processCalls.length).toBeGreaterThanOrEqual(2);
+    expect(processCalls.some((c) => c.calleeRaw === "log")).toBe(true);
+    expect(processCalls.some((c) => c.calleeRaw === "Math.random")).toBe(true);
+
+    fs.rmSync(dir, { recursive: true });
+  });
+
+  it("extracts imports", () => {
+    const dir = createTempDir();
+    writeFile(dir, "main.ts", `
+import React, { useState } from "react";
+import { z } from "zod";
+import fs from "node:fs";
+`);
+    writeFile(dir, "package.json", JSON.stringify({
+      name: "test-project",
+      dependencies: { react: "^18", zod: "^3" },
+    }));
+
+    const { files } = scanFiles(dir);
+    const graph = parseProject(dir, files);
+
+    expect(graph.imports.length).toBeGreaterThanOrEqual(3);
+
+    const reactDefault = graph.imports.find(
+      (i) => i.importPath === "react" && i.alias === "React",
+    );
+    expect(reactDefault).toBeTruthy();
+    expect(reactDefault!.isDefault).toBe(true);
+
+    const useState = graph.imports.find(
+      (i) => i.importPath === "react" && i.alias === "useState",
+    );
+    expect(useState).toBeTruthy();
+    expect(useState!.isDefault).toBe(false);
+
+    const zodImport = graph.imports.find(
+      (i) => i.importPath === "zod" && i.alias === "z",
+    );
+    expect(zodImport).toBeTruthy();
+
+    fs.rmSync(dir, { recursive: true });
+  });
+
+  it("reads dependencies from package.json", () => {
+    const dir = createTempDir();
+    writeFile(dir, "index.ts", `export const x = 1;`);
+    writeFile(dir, "package.json", JSON.stringify({
+      name: "my-app",
+      dependencies: { react: "^18" },
+      devDependencies: { vitest: "^1" },
+    }));
+
+    const { files } = scanFiles(dir);
+    const graph = parseProject(dir, files);
+
+    expect(graph.dependencies).toHaveLength(2);
+    expect(graph.dependencies.some((d) => d.module === "react")).toBe(true);
+    expect(graph.dependencies.some((d) => d.module === "vitest")).toBe(true);
+
+    fs.rmSync(dir, { recursive: true });
+  });
+
+  it("creates file nodes for all scanned files", () => {
+    const dir = createTempDir();
+    writeFile(dir, "src/index.ts", "");
+    writeFile(dir, "src/util.ts", "");
+    writeFile(dir, "data.json", "{}");
+    writeFile(dir, "style.css", "body{}");
+
+    const { files } = scanFiles(dir);
+    const graph = parseProject(dir, files);
+
+    expect(graph.files).toHaveLength(4);
+    const paths = graph.files.map((f) => f.path).sort();
+    expect(paths).toContain("data.json");
+    expect(paths).toContain("style.css");
+    expect(paths).toContain("src/index.ts");
+    expect(paths).toContain("src/util.ts");
+
+    fs.rmSync(dir, { recursive: true });
+  });
+
+  it("handles empty project with no .ts files", () => {
+    const dir = createTempDir();
+    writeFile(dir, "README.md", "# Hello");
+
+    const { files } = scanFiles(dir);
+    const graph = parseProject(dir, files);
+
+    expect(graph.symbols).toHaveLength(0);
+    expect(graph.calls).toHaveLength(0);
+    expect(graph.imports).toHaveLength(0);
+    expect(graph.files).toHaveLength(1);
+    expect(graph.packages).toHaveLength(1);
+
+    fs.rmSync(dir, { recursive: true });
+  });
+});

package/src/plan/index.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect } from "vitest";
+import {
+  makeGraph,
+  makeSymbolNode,
+  makeFileNode,
+  makeCallEdge,
+  makeImportEdge,
+  makePackageNode,
+} from "../graph/types.js";
+import { generatePlan, generateReview } from "./index.js";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import { execSync } from "node:child_process";
+
+function createGitRepo(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "tsgraph-plan-"));
+  execSync("git init", { cwd: dir, stdio: "pipe" });
+  execSync('git config user.email "test@test.com"', { cwd: dir, stdio: "pipe" });
+  execSync('git config user.name "Test"', { cwd: dir, stdio: "pipe" });
+  return dir;
+}
+
+function writeFile(root: string, relPath: string, content: string) {
+  const fullPath = path.join(root, relPath);
+  fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+  fs.writeFileSync(fullPath, content, "utf-8");
+}
+
+describe("generatePlan", () => {
+  it("returns summary for given files and symbols", () => {
+    const graph = makeGraph({
+      files: [
+        makeFileNode({ path: "src/util.ts", packageName: "app" }),
+        makeFileNode({ path: "src/index.ts", packageName: "app" }),
+      ],
+      symbols: [
+        makeSymbolNode({
+          id: "src/util.ts::helper",
+          name: "helper",
+          kind: "function",
+          file: "src/util.ts",
+          packageName: "app",
+          line: 1,
+          endLine: 5,
+          isExported: true,
+        }),
+        makeSymbolNode({
+          id: "src/index.ts::main",
+          name: "main",
+          kind: "function",
+          file: "src/index.ts",
+          packageName: "app",
+          line: 10,
+          endLine: 15,
+          isExported: true,
+        }),
+      ],
+      calls: [
+        makeCallEdge({
+          callerSymbolId: "src/index.ts::main",
+          callerName: "main",
+          calleeRaw: "helper",
+          file: "src/index.ts",
+          line: 11,
+        }),
+      ],
+      imports: [],
+    });
+
+    const result = generatePlan(graph, ["src/util.ts"], []);
+    expect(result.changes.files).toContain("src/util.ts");
+    expect(result.affectedFiles).toContain("src/util.ts");
+    expect(result.affectedFiles).toContain("src/index.ts");
+    expect(result.summary).toContain("1 symbol(s) changed");
+  });
+
+  it("handles explicit symbols", () => {
+    const graph = makeGraph({
+      files: [makeFileNode({ path: "src/lib.ts", packageName: "app" })],
+      symbols: [
+        makeSymbolNode({
+          id: "src/lib.ts::foo",
+          name: "foo",
+          kind: "function",
+          file: "src/lib.ts",
+          packageName: "app",
+          line: 1,
+          endLine: 3,
+          isExported: true,
+        }),
+      ],
+      calls: [],
+      imports: [],
+    });
+
+    const result = generatePlan(graph, [], ["foo"]);
+    expect(result.changes.symbols).toContain("foo");
+    expect(result.summary).toContain("1 symbol(s) changed");
+  });
+});
+
+describe("generateReview", () => {
+  it("returns empty result if not a git repo", () => {
+    const graph = makeGraph({ files: [], symbols: [], imports: [] });
+    const result = generateReview(graph, "/tmp/nonexistent");
+    expect(result.totalChanges).toBe(0);
+    expect(result.summary).toContain("Not a git repository");
+  });
+
+  it("finds findings for changed files", () => {
+    const dir = createGitRepo();
+    writeFile(dir, "src/index.ts", 'export const x = 1;\n');
+    execSync("git add . && git commit -m 'initial'", { cwd: dir, stdio: "pipe" });
+    writeFile(dir, "src/new.ts", 'export const y = 2;\n');
+    execSync("git add . && git commit -m 'add new'", { cwd: dir, stdio: "pipe" });
+
+    const graph = makeGraph({
+      files: [
+        makeFileNode({ path: "src/index.ts", packageName: "app" }),
+        makeFileNode({ path: "src/new.ts", packageName: "app" }),
+      ],
+      symbols: [
+        makeSymbolNode({
+          id: "src/index.ts::x",
+          name: "x",
+          kind: "const",
+          file: "src/index.ts",
+          packageName: "app",
+          line: 1,
+          endLine: 1,
+          isExported: true,
+        }),
+        makeSymbolNode({
+          id: "src/new.ts::y",
+          name: "y",
+          kind: "const",
+          file: "src/new.ts",
+          packageName: "app",
+          line: 1,
+          endLine: 1,
+          isExported: true,
+        }),
+      ],
+      calls: [],
+      imports: [],
+    });
+
+    const result = generateReview(graph, dir, "HEAD~1");
+    expect(result.totalChanges).toBeGreaterThanOrEqual(1);
+    expect(result.findings.length).toBeGreaterThanOrEqual(1);
+    const orphan = result.findings.find((f) => f.type === "orphan");
+    expect(orphan).toBeTruthy();
+    expect(orphan!.detail).toContain("y");
+
+    const changedExport = result.findings.find(
+      (f) => f.type === "changed_export",
+    );
+    expect(changedExport).toBeTruthy();
+    fs.rmSync(dir, { recursive: true });
+  });
+});

package/src/plan/index.ts

@@ -0,0 +1,161 @@
+import type { Graph, SymbolNode } from "../graph/types.js";
+import { findCallers } from "../search/index.js";
+import { getDiffFiles, isGitRepo } from "../git/index.js";
+import type { ChangedFile } from "../git/index.js";
+import { checkBoundaries, loadBoundariesConfig } from "../boundaries/index.js";
+
+export interface PlannedChange {
+  files: string[];
+  symbols: string[];
+}
+
+export interface PlanResult {
+  changes: PlannedChange;
+  affectedCallers: { symbol: SymbolNode; callerCount: number }[];
+  affectedFiles: string[];
+  summary: string;
+}
+
+export interface ReviewFinding {
+  type: "orphan" | "boundary" | "changed_export";
+  detail: string;
+}
+
+export interface ReviewResult {
+  changes: { path: string; status: ChangedFile["status"] }[];
+  findings: ReviewFinding[];
+  totalChanges: number;
+  totalFindings: number;
+  summary: string;
+}
+
+function symbolsInFile(graph: Graph, filePath: string): SymbolNode[] {
+  return graph.symbols.filter((s) => s.file === filePath);
+}
+
+export function generatePlan(
+  graph: Graph,
+  files: string[],
+  symbols: string[] = [],
+): PlanResult {
+  const allSymbolNames = new Set(symbols);
+
+  for (const f of files) {
+    for (const sym of symbolsInFile(graph, f)) {
+      allSymbolNames.add(sym.name);
+    }
+  }
+
+  const callersMap = new Map<string, { symbol: SymbolNode; callerCount: number }>();
+
+  for (const symName of allSymbolNames) {
+    const sym = graph.symbols.find((s) => s.name === symName);
+    if (!sym) continue;
+    const callers = findCallers(graph, sym.name);
+    callersMap.set(symName, {
+      symbol: sym,
+      callerCount: callers.length,
+    });
+  }
+
+  const affectedFiles = new Set<string>();
+  for (const [_, info] of callersMap) {
+    affectedFiles.add(info.symbol.file);
+    const callers = findCallers(graph, info.symbol.name);
+    for (const c of callers) {
+      affectedFiles.add(c.callerSymbol.file);
+    }
+  }
+  for (const f of files) {
+    affectedFiles.add(f);
+  }
+
+  const totalAffected = callersMap.size;
+  const totalCallers = [...callersMap.values()].reduce(
+    (sum, c) => sum + c.callerCount,
+    0,
+  );
+
+  const summary =
+    `Plan: ${files.length} file(s), ${allSymbolNames.size} symbol(s) changed. ` +
+    `Affects ${totalAffected} symbol(s) with ${totalCallers} total caller(s) across ${affectedFiles.size} file(s).`;
+
+  return {
+    changes: { files, symbols: [...allSymbolNames] },
+    affectedCallers: [...callersMap.values()],
+    affectedFiles: [...affectedFiles],
+    summary,
+  };
+}
+
+export function generateReview(
+  graph: Graph,
+  rootDir: string,
+  base: string = "main",
+): ReviewResult {
+  const findings: ReviewFinding[] = [];
+
+  if (!isGitRepo(rootDir)) {
+    return {
+      changes: [],
+      findings: [],
+      totalChanges: 0,
+      totalFindings: 0,
+      summary: "Not a git repository — cannot review.",
+    };
+  }
+
+  const diffFiles = getDiffFiles(rootDir, base);
+  const changedPaths = new Set(diffFiles.map((d) => d.path));
+
+  for (const f of diffFiles) {
+    const fileSyms = symbolsInFile(graph, f.path);
+    for (const sym of fileSyms) {
+      if (f.status === "added") {
+        const callers = findCallers(graph, sym.id);
+        if (callers.length === 0 && !sym.name.startsWith("_")) {
+          findings.push({
+            type: "orphan",
+            detail: `${sym.kind} ${sym.name} in ${sym.file}:${sym.line} — new symbol has no callers`,
+          });
+        }
+      }
+      if (f.status === "modified" || f.status === "added") {
+        if (sym.isExported) {
+          findings.push({
+            type: "changed_export",
+            detail: `${sym.isExported ? "exported " : ""}${sym.kind} ${sym.name} in ${sym.file}:${sym.line} — public API change`,
+          });
+        }
+      }
+    }
+  }
+
+  const boundariesConfig = loadBoundariesConfig(rootDir);
+  if (boundariesConfig) {
+    const result = checkBoundaries(graph, boundariesConfig);
+    for (const v of result.violations) {
+      if (changedPaths.has(v.fromFile) || changedPaths.has(v.toFile)) {
+        findings.push({
+          type: "boundary",
+          detail: `${v.fromFile} → ${v.toFile}: ${v.rule}`,
+        });
+      }
+    }
+  }
+
+  const summary =
+    `Review: ${diffFiles.length} file(s) changed vs "${base}". ` +
+    `${findings.length} finding(s): ` +
+    `${findings.filter((f) => f.type === "orphan").length} orphan(s), ` +
+    `${findings.filter((f) => f.type === "changed_export").length} changed export(s), ` +
+    `${findings.filter((f) => f.type === "boundary").length} boundary violation(s).`;
+
+  return {
+    changes: diffFiles,
+    findings,
+    totalChanges: diffFiles.length,
+    totalFindings: findings.length,
+    summary,
+  };
+}