@shvmgyl15/tsgraph 0.1.0 → 0.1.1

package/src/graph/types.ts

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

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