@shvmgyl15/tsgraph 0.1.0

package/src/graph/types.ts

@@ -0,0 +1,353 @@
+export const GRAPH_VERSION = "1";
+
+export type SymbolKind =
+  | "function"
+  | "method"
+  | "class"
+  | "interface"
+  | "type_alias"
+  | "enum"
+  | "var"
+  | "const";
+
+export type ConcurrencyKind =
+  | "promise_all"
+  | "promise_settled"
+  | "set_timeout"
+  | "set_interval"
+  | "abort_signal"
+  | "async_function";
+
+export interface StructField {
+  name: string;
+  type: string;
+  tag?: string;
+}
+
+export interface SymbolNode {
+  id: string;
+  kind: SymbolKind;
+  name: string;
+  receiver?: string;
+  packageName: string;
+  file: string;
+  line: number;
+  endLine: number;
+  doc?: string;
+  signature?: string;
+  methodSignature?: string;
+  interfaceMethods?: Record<string, string>;
+  structFields?: StructField[];
+  embeddedTypes?: string[];
+  arity?: number;
+  isExported: boolean;
+  isClientComponent?: boolean;
+  isServerComponent?: boolean;
+}
+
+export interface PackageNode {
+  id: string;
+  name: string;
+  importPathBestEffort: string;
+  dir: string;
+  files: string[];
+}
+
+export interface FileNode {
+  id: string;
+  path: string;
+  packageName: string;
+  lines: number;
+  generated: boolean;
+}
+
+export interface CallEdge {
+  callerSymbolId: string;
+  callerName: string;
+  calleeRaw: string;
+  file: string;
+  line: number;
+}
+
+export interface ImportEdge {
+  fromFile: string;
+  fromPackage: string;
+  importPath: string;
+  alias?: string;
+  isDefault: boolean;
+}
+
+export interface Dependency {
+  module: string;
+  version: string;
+}
+
+export interface HTTPRoute {
+  method: string;
+  path: string;
+  handler: string;
+  file: string;
+  line: number;
+}
+
+export interface EnvRead {
+  key: string;
+  accessor: string;
+  file: string;
+  line: number;
+  functionName?: string;
+}
+
+export interface ConcurrencyNode {
+  kind: ConcurrencyKind;
+  functionName: string;
+  file: string;
+  line: number;
+  detail?: string;
+}
+
+export interface TestEdge {
+  testFunc: string;
+  target: string;
+  file: string;
+  line: number;
+}
+
+export interface ImplementsEdge {
+  interface: string;
+  concrete: string;
+}
+
+export interface MutationEdge {
+  field: string;
+  functionName: string;
+  file: string;
+  line: number;
+}
+
+export interface ErrorEdge {
+  message: string;
+  functionName: string;
+  file: string;
+  line: number;
+}
+
+export interface AppRouterNode {
+  path: string;
+  dir: string;
+  files: {
+    page?: string;
+    layout?: string;
+    loading?: string;
+    error?: string;
+    notFound?: string;
+    route?: string;
+    template?: string;
+    default?: string;
+  };
+  children: AppRouterNode[];
+}
+
+export interface Graph {
+  version: string;
+  generatedAt: string;
+  root: string;
+  packages: PackageNode[];
+  files: FileNode[];
+  symbols: SymbolNode[];
+  imports: ImportEdge[];
+  calls: CallEdge[];
+  envReads: EnvRead[];
+  dependencies: Dependency[];
+  routes: HTTPRoute[];
+  concurrency: ConcurrencyNode[];
+  testEdges: TestEdge[];
+  implements: ImplementsEdge[];
+  mutations: MutationEdge[];
+  errors: ErrorEdge[];
+  appRouter?: AppRouterNode;
+}
+
+let _nextId = 0;
+function nextId(): string {
+  return `gen_${++_nextId}`;
+}
+
+export function makeStructField(overrides?: Partial<StructField>): StructField {
+  return { name: "", type: "", ...overrides };
+}
+
+export function makeSymbolNode(overrides?: Partial<SymbolNode>): SymbolNode {
+  return {
+    id: nextId(),
+    kind: "function",
+    name: "",
+    packageName: "",
+    file: "",
+    line: 0,
+    endLine: 0,
+    isExported: false,
+    ...overrides,
+  };
+}
+
+export function makePackageNode(overrides?: Partial<PackageNode>): PackageNode {
+  return {
+    id: nextId(),
+    name: "",
+    importPathBestEffort: "",
+    dir: "",
+    files: [],
+    ...overrides,
+  };
+}
+
+export function makeFileNode(overrides?: Partial<FileNode>): FileNode {
+  return {
+    id: nextId(),
+    path: "",
+    packageName: "",
+    lines: 0,
+    generated: false,
+    ...overrides,
+  };
+}
+
+export function makeCallEdge(overrides?: Partial<CallEdge>): CallEdge {
+  return {
+    callerSymbolId: "",
+    callerName: "",
+    calleeRaw: "",
+    file: "",
+    line: 0,
+    ...overrides,
+  };
+}
+
+export function makeImportEdge(overrides?: Partial<ImportEdge>): ImportEdge {
+  return {
+    fromFile: "",
+    fromPackage: "",
+    importPath: "",
+    isDefault: false,
+    ...overrides,
+  };
+}
+
+export function makeDependency(overrides?: Partial<Dependency>): Dependency {
+  return { module: "", version: "", ...overrides };
+}
+
+export function makeHTTPRoute(overrides?: Partial<HTTPRoute>): HTTPRoute {
+  return { method: "", path: "", handler: "", file: "", line: 0, ...overrides };
+}
+
+export function makeEnvRead(overrides?: Partial<EnvRead>): EnvRead {
+  return { key: "", accessor: "", file: "", line: 0, ...overrides };
+}
+
+export function makeConcurrencyNode(overrides?: Partial<ConcurrencyNode>): ConcurrencyNode {
+  return {
+    kind: "async_function",
+    functionName: "",
+    file: "",
+    line: 0,
+    ...overrides,
+  };
+}
+
+export function makeTestEdge(overrides?: Partial<TestEdge>): TestEdge {
+  return { testFunc: "", target: "", file: "", line: 0, ...overrides };
+}
+
+export function makeImplementsEdge(overrides?: Partial<ImplementsEdge>): ImplementsEdge {
+  return { interface: "", concrete: "", ...overrides };
+}
+
+export function makeMutationEdge(overrides?: Partial<MutationEdge>): MutationEdge {
+  return { field: "", functionName: "", file: "", line: 0, ...overrides };
+}
+
+export function makeErrorEdge(overrides?: Partial<ErrorEdge>): ErrorEdge {
+  return { message: "", functionName: "", file: "", line: 0, ...overrides };
+}
+
+export function makeAppRouterNode(overrides?: Partial<AppRouterNode>): AppRouterNode {
+  return {
+    path: "",
+    dir: "",
+    files: {},
+    children: [],
+    ...overrides,
+  };
+}
+
+export function makeGraph(overrides?: Partial<Graph>): Graph {
+  return {
+    version: GRAPH_VERSION,
+    generatedAt: new Date().toISOString(),
+    root: "",
+    packages: [],
+    files: [],
+    symbols: [],
+    imports: [],
+    calls: [],
+    envReads: [],
+    dependencies: [],
+    routes: [],
+    concurrency: [],
+    testEdges: [],
+    implements: [],
+    mutations: [],
+    errors: [],
+    ...overrides,
+  };
+}
+
+const ARRAY_KEYS: (keyof Graph)[] = [
+  "packages", "files", "symbols", "imports", "calls",
+  "envReads", "dependencies", "routes", "concurrency",
+  "testEdges", "implements", "mutations", "errors",
+];
+
+function isGraph(value: unknown): value is Graph {
+  if (value === null || value === undefined) return false;
+  if (typeof value !== "object") return false;
+  const obj = value as Record<string, unknown>;
+  if (typeof obj.version !== "string") return false;
+  if (typeof obj.generatedAt !== "string") return false;
+  if (typeof obj.root !== "string") return false;
+  for (const key of ARRAY_KEYS) {
+    if (!Array.isArray(obj[key])) return false;
+  }
+  return true;
+}
+
+export function serialize(graph: Graph): string {
+  if (graph.version !== GRAPH_VERSION) {
+    throw new Error(
+      `Graph version mismatch: expected ${GRAPH_VERSION}, got ${graph.version}`,
+    );
+  }
+  return JSON.stringify(graph, null, 2);
+}
+
+export function deserialize(json: string): Graph {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(json);
+  } catch (e) {
+    throw new Error(`Invalid JSON: ${(e as Error).message}`);
+  }
+  if (!isGraph(parsed)) {
+    throw new Error(
+      "Invalid graph structure: missing or invalid required fields",
+    );
+  }
+  if (parsed.version !== GRAPH_VERSION) {
+    throw new Error(
+      `Graph version mismatch: expected ${GRAPH_VERSION}, got ${parsed.version}`,
+    );
+  }
+  return parsed;
+}

package/src/mcp/mcp.test.ts

@@ -0,0 +1,176 @@
+import { describe, it, expect, afterEach } from "vitest";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+import { spawn, type ChildProcess } from "node:child_process";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, "../..");
+const cliEntry = path.join(projectRoot, "src/cli/index.ts");
+
+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");
+}
+
+let server: ChildProcess | null = null;
+let requestId = 0;
+let stderrBuf = "";
+
+function sendRequest(proc: ChildProcess, method: string, params?: unknown): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    const id = ++requestId;
+    const msg = JSON.stringify({ jsonrpc: "2.0", id, method, params: params ?? {} }) + "\n";
+
+    const responses: string[] = [];
+
+    const onData = (chunk: Buffer) => {
+      const text = chunk.toString("utf-8");
+      responses.push(text);
+      const full = responses.join("");
+      const lines = full.split("\n").filter(Boolean);
+      // Keep incomplete last chunk
+      if (!full.endsWith("\n")) {
+        responses.length = 0;
+        responses.push(lines.pop() ?? "");
+      }
+      for (const line of lines) {
+        try {
+          const resp = JSON.parse(line);
+          if (resp.id === id) {
+            proc.stdout?.off("data", onData);
+            resolve(resp);
+          }
+        } catch {
+          // partial or notification, keep waiting
+        }
+      }
+    };
+
+    const onStderr = (chunk: Buffer) => {
+      stderrBuf += chunk.toString("utf-8");
+    };
+
+    proc.stdout?.on("data", onData);
+    proc.stderr?.on("data", onStderr);
+    proc.stdin?.write(msg);
+
+    setTimeout(() => {
+      proc.stdout?.off("data", onData);
+      reject(new Error(`Timeout. stderr: ${stderrBuf.slice(-500)}`));
+    }, 10000);
+  });
+}
+
+async function mcpHandshake(proc: ChildProcess): Promise<void> {
+  const initResp = await sendRequest(proc, "initialize", {
+    protocolVersion: "2024-11-05",
+    capabilities: {},
+    clientInfo: { name: "tsgraph-test", version: "1.0.0" },
+  }) as Record<string, unknown>;
+  expect((initResp as { result?: Record<string, unknown> }).result?.protocolVersion).toBeTruthy();
+  // Send initialized notification
+  proc.stdin?.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\n");
+}
+
+describe("MCP server", () => {
+  afterEach(() => {
+    if (server && !server.killed) {
+      server.kill();
+      server = null;
+    }
+  });
+
+  it("lists all registered tools", async () => {
+    const dir = createTempDir();
+    writeFile(dir, "package.json", JSON.stringify({ name: "test" }));
+    writeFile(dir, "index.ts", "export function foo() { return 1; }");
+    fs.mkdirSync(path.join(dir, ".tsgraph"), { recursive: true });
+
+    // Build graph first
+    const { scanFiles } = await import("../scanner/index.js");
+    const { parseProject } = await import("../parser/index.js");
+    const { serialize } = await import("../graph/types.js");
+    const scanned = scanFiles(dir);
+    const graph = parseProject(dir, scanned.files);
+    fs.writeFileSync(path.join(dir, ".tsgraph", "graph.json"), serialize(graph), "utf-8");
+
+    server = spawn("npx", ["tsx", cliEntry, "mcp"], {
+      cwd: dir,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    await new Promise((r) => setTimeout(r, 500));
+
+    await mcpHandshake(server);
+
+    const resp = await sendRequest(server, "tools/list") as Record<string, unknown>;
+    expect(resp).toBeTruthy();
+    expect((resp as { result?: { tools?: unknown[] } }).result?.tools).toBeTruthy();
+    const tools = (resp as { result: { tools: { name: string }[] } }).result.tools;
+    const toolNames = tools.map((t) => t.name).sort();
+    expect(toolNames).toContain("callers");
+    expect(toolNames).toContain("callees");
+    expect(toolNames).toContain("node");
+    expect(toolNames).toContain("query");
+    expect(toolNames).toContain("context");
+    expect(toolNames).toContain("imports");
+    expect(toolNames).toContain("public");
+    expect(toolNames).toContain("impact");
+    expect(toolNames).toContain("path");
+    expect(toolNames).toContain("orphans");
+    expect(toolNames).toContain("trace");
+    expect(toolNames).toContain("complexity");
+    expect(toolNames).toContain("hotspot");
+    expect(toolNames).toContain("coupling");
+    expect(toolNames).toHaveLength(14);
+
+    server.kill();
+    fs.rmSync(dir, { recursive: true });
+  }, 30000);
+
+  it("calls orphans tool and returns results", async () => {
+    const dir = createTempDir();
+    writeFile(dir, "package.json", JSON.stringify({ name: "test" }));
+    writeFile(dir, "index.ts", "export function foo() { return 1; }");
+    fs.mkdirSync(path.join(dir, ".tsgraph"), { recursive: true });
+
+    const { scanFiles } = await import("../scanner/index.js");
+    const { parseProject } = await import("../parser/index.js");
+    const { serialize } = await import("../graph/types.js");
+    const scanned = scanFiles(dir);
+    const graph = parseProject(dir, scanned.files);
+    fs.writeFileSync(path.join(dir, ".tsgraph", "graph.json"), serialize(graph), "utf-8");
+
+    server = spawn("npx", ["tsx", cliEntry, "mcp"], {
+      cwd: dir,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    await new Promise((r) => setTimeout(r, 500));
+
+    await mcpHandshake(server);
+
+    const resp = await sendRequest(server, "tools/call", {
+      name: "orphans",
+      arguments: {},
+    }) as Record<string, unknown>;
+
+    expect(resp).toBeTruthy();
+    const result = (resp as { result?: { content?: { text?: string }[] } }).result;
+    expect(result).toBeTruthy();
+    const textContent = result?.content?.[0]?.text;
+    expect(textContent).toBeTruthy();
+    const parsed = JSON.parse(textContent!);
+    expect(Array.isArray(parsed)).toBe(true);
+
+    server.kill();
+    fs.rmSync(dir, { recursive: true });
+  }, 30000);
+});