@shvmgyl15/tsgraph 0.1.0

package/src/git/index.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import { execSync } from "node:child_process";
+import {
+  isGitRepo,
+  getCurrentBranch,
+  getDiffFiles,
+  getStaleFiles,
+  getCommitHistory,
+} from "./index.js";
+
+let tmpDir: string;
+
+function run(cmd: string) {
+  execSync(cmd, { cwd: tmpDir, stdio: "pipe" });
+}
+
+function writeFile(relativePath: string, content: string) {
+  const fullPath = path.join(tmpDir, relativePath);
+  fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+  fs.writeFileSync(fullPath, content, "utf-8");
+}
+
+beforeAll(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "tsgraph-git-test-"));
+  run("git init");
+  run('git config user.email "test@test.com"');
+  run('git config user.name "Test"');
+  writeFile(".gitkeep", "");
+  run("git add . && git commit -m 'initial'");
+});
+
+afterAll(() => {
+  fs.rmSync(tmpDir, { recursive: true });
+});
+
+describe("isGitRepo", () => {
+  it("returns true inside a git repo", () => {
+    expect(isGitRepo(tmpDir)).toBe(true);
+  });
+
+  it("returns false outside a git repo", () => {
+    const nonRepo = fs.mkdtempSync(path.join(os.tmpdir(), "tsgraph-non-git-"));
+    expect(isGitRepo(nonRepo)).toBe(false);
+    fs.rmSync(nonRepo, { recursive: true });
+  });
+});
+
+describe("getCurrentBranch", () => {
+  it("returns current branch name", () => {
+    const branch = getCurrentBranch(tmpDir);
+    expect(branch).toBeTruthy();
+  });
+});
+
+describe("getDiffFiles", () => {
+  it("returns changed files vs base branch", () => {
+    writeFile("file1.ts", "content");
+    run("git add . && git commit -m 'initial'");
+    run("git checkout -b feature");
+    writeFile("file2.ts", "content");
+    run("git add . && git commit -m 'add file2'");
+    writeFile("file3.ts", "content");
+    run("git add . && git commit -m 'add file3'");
+    const results = getDiffFiles(tmpDir, "main");
+    expect(results.length).toBeGreaterThanOrEqual(2);
+    const paths = results.map((r) => r.path);
+    expect(paths).toContain("file2.ts");
+    expect(paths).toContain("file3.ts");
+    run("git checkout main");
+  });
+});
+
+describe("getCommitHistory", () => {
+  it("returns recent commit history", () => {
+    const history = getCommitHistory(tmpDir, 5);
+    expect(history.length).toBeGreaterThan(0);
+    expect(history[0]).toHaveProperty("hash");
+    expect(history[0]).toHaveProperty("message");
+  });
+});
+
+describe("getStaleFiles", () => {
+  it("does not return recently committed files", () => {
+    writeFile("fresh.ts", "fresh content");
+    run("git add . && git commit -m 'add fresh'");
+    const stale = getStaleFiles(tmpDir, 0);
+    expect(stale).not.toContain("fresh.ts");
+  });
+});

package/src/git/index.ts

@@ -0,0 +1,86 @@
+import { execSync } from "node:child_process";
+
+export interface ChangedFile {
+  path: string;
+  status: "added" | "modified" | "deleted" | "renamed";
+}
+
+export interface CommitInfo {
+  hash: string;
+  date: string;
+  message: string;
+  author: string;
+}
+
+export function isGitRepo(root: string): boolean {
+  try {
+    execSync("git rev-parse --git-dir", { cwd: root, stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getCurrentBranch(root: string): string {
+  return execSync("git rev-parse --abbrev-ref HEAD", {
+    cwd: root,
+    encoding: "utf-8",
+  }).trim();
+}
+
+export function getDiffFiles(root: string, base: string = "main"): ChangedFile[] {
+  const output = execSync(`git diff --name-status ${base}...HEAD`, {
+    cwd: root,
+    encoding: "utf-8",
+  }).trim();
+  if (!output) return [];
+  return output.split("\n").map((line) => {
+    const parts = line.split(/\s+/);
+    const status = parts[0];
+    let fileStatus: ChangedFile["status"];
+    let filePath = parts[1] ?? "";
+    if (status === "A") fileStatus = "added";
+    else if (status === "D") fileStatus = "deleted";
+    else if (status === "R" || status.startsWith("R")) fileStatus = "renamed";
+    else fileStatus = "modified";
+    if (fileStatus === "renamed" && parts[2]) filePath = parts[2];
+    return { path: filePath, status: fileStatus };
+  });
+}
+
+export function getStaleFiles(root: string, thresholdDays: number = 90): string[] {
+  const cutoff = new Date();
+  cutoff.setDate(cutoff.getDate() - thresholdDays);
+  const cutoffStr = cutoff.toISOString().split("T")[0];
+  try {
+    const output = execSync(
+      `git log --pretty=format: --name-only --diff-filter=AM --since=${cutoffStr}`,
+      { cwd: root, encoding: "utf-8" },
+    ).trim();
+    const recentFiles = new Set(output.split("\n").filter(Boolean));
+    const allFiles = execSync("git ls-files", {
+      cwd: root,
+      encoding: "utf-8",
+    })
+      .trim()
+      .split("\n")
+      .filter(Boolean);
+    return allFiles.filter((f) => !recentFiles.has(f));
+  } catch {
+    return [];
+  }
+}
+
+export function getCommitHistory(root: string, count: number = 10): CommitInfo[] {
+  const output = execSync(
+    `git log --max-count=${count} --format="%H|%ad|%s|%an" --date=short`,
+    { cwd: root, encoding: "utf-8" },
+  ).trim();
+  if (!output) return [];
+  return output.split("\n").map((line) => {
+    const [hash, date, ...msgParts] = line.split("|");
+    const message = msgParts.slice(0, -1).join("|");
+    const author = msgParts[msgParts.length - 1] ?? "";
+    return { hash, date, message, author };
+  });
+}

package/src/graph/types.test.ts

@@ -0,0 +1,383 @@
+import { describe, it, expect } from "vitest";
+import {
+  GRAPH_VERSION,
+  makeGraph,
+  makePackageNode,
+  makeFileNode,
+  makeSymbolNode,
+  makeCallEdge,
+  makeImportEdge,
+  makeDependency,
+  makeHTTPRoute,
+  makeEnvRead,
+  makeConcurrencyNode,
+  makeTestEdge,
+  makeImplementsEdge,
+  makeMutationEdge,
+  makeErrorEdge,
+  makeAppRouterNode,
+  makeStructField,
+  serialize,
+  deserialize,
+} from "./types.js";
+
+describe("GRAPH_VERSION", () => {
+  it("is 1", () => {
+    expect(GRAPH_VERSION).toBe("1");
+  });
+});
+
+describe("factory functions", () => {
+  describe("makeGraph", () => {
+    it("returns a graph with defaults", () => {
+      const g = makeGraph();
+      expect(g.version).toBe(GRAPH_VERSION);
+      expect(g.generatedAt).toBeTruthy();
+      expect(g.root).toBe("");
+      expect(g.packages).toEqual([]);
+      expect(g.files).toEqual([]);
+      expect(g.symbols).toEqual([]);
+      expect(g.imports).toEqual([]);
+      expect(g.calls).toEqual([]);
+      expect(g.envReads).toEqual([]);
+      expect(g.dependencies).toEqual([]);
+      expect(g.routes).toEqual([]);
+      expect(g.concurrency).toEqual([]);
+      expect(g.testEdges).toEqual([]);
+      expect(g.implements).toEqual([]);
+      expect(g.mutations).toEqual([]);
+      expect(g.errors).toEqual([]);
+      expect(g.appRouter).toBeUndefined();
+    });
+
+    it("merges overrides", () => {
+      const g = makeGraph({ root: "/project", version: "2" });
+      expect(g.root).toBe("/project");
+      expect(g.version).toBe("2");
+    });
+
+    it("generates an ISO timestamp", () => {
+      const g = makeGraph();
+      expect(() => new Date(g.generatedAt)).not.toThrow();
+      expect(new Date(g.generatedAt).toISOString()).toBe(g.generatedAt);
+    });
+  });
+
+  describe("makePackageNode", () => {
+    it("returns a package node with defaults", () => {
+      const p = makePackageNode();
+      expect(p.id).toBeTruthy();
+      expect(p.name).toBe("");
+      expect(p.importPathBestEffort).toBe("");
+      expect(p.dir).toBe("");
+      expect(p.files).toEqual([]);
+    });
+
+    it("merges overrides", () => {
+      const p = makePackageNode({ name: "utils", dir: "./utils" });
+      expect(p.name).toBe("utils");
+      expect(p.dir).toBe("./utils");
+      expect(p.files).toEqual([]);
+    });
+  });
+
+  describe("makeFileNode", () => {
+    it("returns a file node with defaults", () => {
+      const f = makeFileNode();
+      expect(f.id).toBeTruthy();
+      expect(f.path).toBe("");
+      expect(f.packageName).toBe("");
+      expect(f.lines).toBe(0);
+      expect(f.generated).toBe(false);
+    });
+
+    it("merges overrides", () => {
+      const f = makeFileNode({ path: "src/index.ts", generated: true, lines: 42 });
+      expect(f.path).toBe("src/index.ts");
+      expect(f.generated).toBe(true);
+      expect(f.lines).toBe(42);
+    });
+  });
+
+  describe("makeSymbolNode", () => {
+    it("returns a symbol node with defaults", () => {
+      const s = makeSymbolNode();
+      expect(s.id).toBeTruthy();
+      expect(s.kind).toBe("function");
+      expect(s.name).toBe("");
+      expect(s.packageName).toBe("");
+      expect(s.file).toBe("");
+      expect(s.line).toBe(0);
+      expect(s.endLine).toBe(0);
+      expect(s.isExported).toBe(false);
+    });
+
+    it("merges overrides", () => {
+      const s = makeSymbolNode({ name: "Foo", kind: "class", isExported: true, line: 10, endLine: 30 });
+      expect(s.name).toBe("Foo");
+      expect(s.kind).toBe("class");
+      expect(s.isExported).toBe(true);
+      expect(s.line).toBe(10);
+      expect(s.endLine).toBe(30);
+    });
+
+    it("preserves optional fields", () => {
+      const s = makeSymbolNode({
+        doc: "does foo",
+        signature: "Foo() => void",
+        structFields: [{ name: "bar", type: "string" }],
+        embeddedTypes: ["Mixin"],
+        arity: 2,
+        isClientComponent: true,
+        isServerComponent: false,
+      });
+      expect(s.doc).toBe("does foo");
+      expect(s.signature).toBe("Foo() => void");
+      expect(s.structFields).toHaveLength(1);
+      expect(s.structFields![0].name).toBe("bar");
+      expect(s.embeddedTypes).toEqual(["Mixin"]);
+      expect(s.arity).toBe(2);
+      expect(s.isClientComponent).toBe(true);
+      expect(s.isServerComponent).toBe(false);
+    });
+  });
+
+  describe("makeCallEdge", () => {
+    it("returns defaults", () => {
+      const e = makeCallEdge();
+      expect(e.callerSymbolId).toBe("");
+      expect(e.callerName).toBe("");
+      expect(e.calleeRaw).toBe("");
+      expect(e.file).toBe("");
+      expect(e.line).toBe(0);
+    });
+  });
+
+  describe("makeImportEdge", () => {
+    it("returns defaults", () => {
+      const e = makeImportEdge();
+      expect(e.fromFile).toBe("");
+      expect(e.fromPackage).toBe("");
+      expect(e.importPath).toBe("");
+      expect(e.isDefault).toBe(false);
+    });
+
+    it("sets isDefault", () => {
+      const e = makeImportEdge({ isDefault: true });
+      expect(e.isDefault).toBe(true);
+    });
+  });
+
+  describe("makeDependency", () => {
+    it("returns defaults", () => {
+      const d = makeDependency();
+      expect(d.module).toBe("");
+      expect(d.version).toBe("");
+    });
+  });
+
+  describe("makeHTTPRoute", () => {
+    it("returns defaults", () => {
+      const r = makeHTTPRoute();
+      expect(r.method).toBe("");
+      expect(r.path).toBe("");
+      expect(r.handler).toBe("");
+      expect(r.file).toBe("");
+      expect(r.line).toBe(0);
+    });
+  });
+
+  describe("makeEnvRead", () => {
+    it("returns defaults", () => {
+      const e = makeEnvRead();
+      expect(e.key).toBe("");
+      expect(e.accessor).toBe("");
+      expect(e.file).toBe("");
+      expect(e.line).toBe(0);
+    });
+  });
+
+  describe("makeConcurrencyNode", () => {
+    it("returns defaults", () => {
+      const c = makeConcurrencyNode();
+      expect(c.kind).toBe("async_function");
+      expect(c.functionName).toBe("");
+      expect(c.file).toBe("");
+      expect(c.line).toBe(0);
+    });
+  });
+
+  describe("makeTestEdge", () => {
+    it("returns defaults", () => {
+      const t = makeTestEdge();
+      expect(t.testFunc).toBe("");
+      expect(t.target).toBe("");
+      expect(t.file).toBe("");
+      expect(t.line).toBe(0);
+    });
+  });
+
+  describe("makeImplementsEdge", () => {
+    it("returns defaults", () => {
+      const e = makeImplementsEdge();
+      expect(e.interface).toBe("");
+      expect(e.concrete).toBe("");
+    });
+  });
+
+  describe("makeMutationEdge", () => {
+    it("returns defaults", () => {
+      const m = makeMutationEdge();
+      expect(m.field).toBe("");
+      expect(m.functionName).toBe("");
+      expect(m.file).toBe("");
+      expect(m.line).toBe(0);
+    });
+  });
+
+  describe("makeErrorEdge", () => {
+    it("returns defaults", () => {
+      const e = makeErrorEdge();
+      expect(e.message).toBe("");
+      expect(e.functionName).toBe("");
+      expect(e.file).toBe("");
+      expect(e.line).toBe(0);
+    });
+  });
+
+  describe("makeAppRouterNode", () => {
+    it("returns defaults", () => {
+      const n = makeAppRouterNode();
+      expect(n.path).toBe("");
+      expect(n.dir).toBe("");
+      expect(n.files).toEqual({});
+      expect(n.children).toEqual([]);
+    });
+
+    it("supports nested children", () => {
+      const child = makeAppRouterNode({ path: "/child" });
+      const parent = makeAppRouterNode({ path: "/", children: [child] });
+      expect(parent.children).toHaveLength(1);
+      expect(parent.children[0].path).toBe("/child");
+    });
+  });
+
+  describe("makeStructField", () => {
+    it("returns defaults", () => {
+      const f = makeStructField();
+      expect(f.name).toBe("");
+      expect(f.type).toBe("");
+    });
+
+    it("merges overrides", () => {
+      const f = makeStructField({ name: "id", type: "string", tag: "json:\"id\"" });
+      expect(f.name).toBe("id");
+      expect(f.type).toBe("string");
+      expect(f.tag).toBe("json:\"id\"");
+    });
+  });
+});
+
+describe("serialize / deserialize", () => {
+  describe("serialize", () => {
+    it("produces valid JSON with 2-space indentation", () => {
+      const g = makeGraph();
+      const json = serialize(g);
+      expect(json).toBeTruthy();
+      expect(json.startsWith("{")).toBe(true);
+      const parsed = JSON.parse(json);
+      expect(parsed.version).toBe(GRAPH_VERSION);
+    });
+
+    it("throws on version mismatch", () => {
+      const g = makeGraph({ version: "999" });
+      expect(() => serialize(g)).toThrow("version mismatch");
+    });
+  });
+
+  describe("deserialize", () => {
+    it("round-trips a graph with all fields", () => {
+      const original = makeGraph({
+        root: "/test",
+        packages: [makePackageNode({ name: "main", dir: "." })],
+        files: [makeFileNode({ path: "index.ts", packageName: "main" })],
+        symbols: [makeSymbolNode({ name: "run", kind: "function", file: "index.ts", line: 1, endLine: 5 })],
+        calls: [makeCallEdge({ callerSymbolId: "s1", callerName: "run", calleeRaw: "log", file: "index.ts", line: 2 })],
+        imports: [makeImportEdge({ fromFile: "index.ts", importPath: "fs" })],
+        dependencies: [makeDependency({ module: "react", version: "^18" })],
+        routes: [makeHTTPRoute({ method: "GET", path: "/api", handler: "getHandler", file: "route.ts", line: 3 })],
+        envReads: [makeEnvRead({ key: "PORT", accessor: "process.env.PORT", file: "config.ts", line: 5 })],
+        concurrency: [makeConcurrencyNode({ kind: "promise_all", functionName: "fetchAll", file: "fetch.ts", line: 10 })],
+        testEdges: [makeTestEdge({ testFunc: "TestRun", target: "run", file: "index_test.ts", line: 1 })],
+        implements: [makeImplementsEdge({ interface: "Runner", concrete: "FastRunner" })],
+        mutations: [makeMutationEdge({ field: "User.name", functionName: "rename", file: "user.ts", line: 8 })],
+        errors: [makeErrorEdge({ message: "not found", functionName: "findUser", file: "user.ts", line: 12 })],
+        appRouter: makeAppRouterNode({
+          path: "/",
+          dir: "app",
+          files: { page: "page.tsx", layout: "layout.tsx" },
+          children: [makeAppRouterNode({ path: "/about", dir: "about", files: { page: "page.tsx" } })],
+        }),
+      });
+
+      const json = serialize(original);
+      const restored = deserialize(json);
+
+      expect(restored.version).toBe(original.version);
+      expect(restored.root).toBe(original.root);
+      expect(restored.packages).toHaveLength(1);
+      expect(restored.files).toHaveLength(1);
+      expect(restored.symbols).toHaveLength(1);
+      expect(restored.calls).toHaveLength(1);
+      expect(restored.imports).toHaveLength(1);
+      expect(restored.dependencies).toHaveLength(1);
+      expect(restored.routes).toHaveLength(1);
+      expect(restored.envReads).toHaveLength(1);
+      expect(restored.concurrency).toHaveLength(1);
+      expect(restored.testEdges).toHaveLength(1);
+      expect(restored.implements).toHaveLength(1);
+      expect(restored.mutations).toHaveLength(1);
+      expect(restored.errors).toHaveLength(1);
+      expect(restored.appRouter).toBeTruthy();
+      expect(restored.appRouter!.children).toHaveLength(1);
+    });
+
+    it("round-trips an empty graph", () => {
+      const original = makeGraph({ root: "/empty" });
+      const json = serialize(original);
+      const restored = deserialize(json);
+      expect(restored.root).toBe("/empty");
+      expect(restored.packages).toEqual([]);
+    });
+
+    it("rejects malformed JSON", () => {
+      expect(() => deserialize("not json")).toThrow("Invalid JSON");
+    });
+
+    it("rejects null", () => {
+      expect(() => deserialize("null")).toThrow("Invalid graph structure");
+    });
+
+    it("rejects missing version", () => {
+      const json = JSON.stringify({ root: "/x", generatedAt: "", packages: [], files: [], symbols: [], imports: [], calls: [], envReads: [], dependencies: [], routes: [], concurrency: [], testEdges: [], implements: [], mutations: [], errors: [] });
+      expect(() => deserialize(json)).toThrow("Invalid graph structure");
+    });
+
+    it("rejects version mismatch", () => {
+      const g = makeGraph({ version: "2" });
+      expect(() => deserialize(serialize(g))).toThrow("version mismatch");
+    });
+
+    it("rejects missing array fields", () => {
+      const json = JSON.stringify({ version: GRAPH_VERSION, generatedAt: "", root: "" });
+      expect(() => deserialize(json)).toThrow("Invalid graph structure");
+    });
+
+    it("accepts extra unknown fields (forward compat)", () => {
+      const g = makeGraph({ root: "/future" });
+      const json = JSON.stringify({ ...JSON.parse(serialize(g)), futureField: "hello" });
+      const restored = deserialize(json);
+      expect(restored.root).toBe("/future");
+    });
+  });
+});