@shvmgyl15/tsgraph 0.1.0 → 0.2.0

package/src/parser/parser.test.ts

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

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

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