@shvmgyl15/tsgraph 0.1.0

package/src/nextjs/router.ts

@@ -0,0 +1,102 @@
+import path from "node:path";
+import type { AppRouterNode, Graph } from "../graph/types.js";
+import type { ScannedFile } from "../scanner/index.js";
+
+const APP_ROUTER_FILES = new Set([
+  "page", "layout", "loading", "error", "not-found",
+  "route", "template", "default",
+]);
+
+type FileMap = Record<string, string>;
+
+function classifyFile(fileName: string): string | undefined {
+  const base = path.basename(fileName, path.extname(fileName));
+  if (APP_ROUTER_FILES.has(base)) return base;
+  return undefined;
+}
+
+function buildRouterTree(
+  appDir: string,
+  files: ScannedFile[],
+): AppRouterNode | undefined {
+  const dirMap = new Map<string, FileMap>();
+
+  for (const sf of files) {
+    const rel = sf.relativePath;
+    if (!rel.startsWith("app/") && !rel.startsWith("app\\")) continue;
+    const afterApp = rel.replace(/^app[/\\]/, "");
+    const dir = path.dirname(afterApp);
+    const fileName = path.basename(afterApp);
+    const kind = classifyFile(fileName);
+    if (!kind) continue;
+
+    let entry = dirMap.get(dir);
+    if (!entry) {
+      entry = {};
+      dirMap.set(dir, entry);
+    }
+    entry[kind] = rel;
+  }
+
+  if (dirMap.size === 0) return undefined;
+
+  const segments = [...dirMap.keys()].filter((d) => d !== ".");
+
+  function nodeForDir(dirParts: string[]): AppRouterNode {
+    const dirPath = dirParts.join("/");
+    const files = dirMap.get(dirPath) ?? {};
+    const childDirs = segments.filter((s) => {
+      const parts = s.split("/");
+      if (parts.length !== dirParts.length + 1) return false;
+      return parts.slice(0, -1).join("/") === dirPath;
+    });
+
+    return {
+      path: "/" + dirParts.map((p) => p.replace(/^\(|\)$/g, "")).join("/"),
+      dir: dirPath === "." ? "app" : path.join("app", dirPath),
+      files: {
+        page: files.page,
+        layout: files.layout,
+        loading: files.loading,
+        error: files.error,
+        notFound: files["not-found"],
+        route: files.route,
+        template: files.template,
+        default: files.default,
+      },
+      children: childDirs.map((s) => {
+        const parts = s.split("/");
+        return nodeForDir(parts);
+      }),
+    };
+  }
+
+  const rootChildren = segments
+    .filter((s) => !s.includes("/"))
+    .map((s) => nodeForDir(s === "." ? [] : [s]));
+
+  const rootFiles = dirMap.get(".") ?? {};
+  return {
+    path: "/",
+    dir: "app",
+    files: {
+      page: rootFiles.page,
+      layout: rootFiles.layout,
+      loading: rootFiles.loading,
+      error: rootFiles.error,
+      notFound: rootFiles["not-found"],
+      route: rootFiles.route,
+      template: rootFiles.template,
+      default: rootFiles.default,
+    },
+    children: rootChildren,
+  };
+}
+
+export function extractAppRouter(
+  graph: Graph,
+  scanned: ScannedFile[],
+): Graph {
+  const tree = buildRouterTree(graph.root, scanned);
+  return { ...graph, appRouter: tree ?? undefined };
+}

package/src/nextjs/routes.ts

@@ -0,0 +1,69 @@
+import path from "node:path";
+import { Project } from "ts-morph";
+import type { Graph, HTTPRoute } from "../graph/types.js";
+import type { ScannedFile } from "../scanner/index.js";
+
+const HTTP_METHODS = new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
+
+function appRouteToHttpPath(relativePath: string): string {
+  let p = relativePath
+    .replace(/^app[/\\]/, "")
+    .replace(/\/route\.[jt]sx?$/, "")
+    .replace(/\[\.\.\.(.+?)\]/g, "*$1")
+    .replace(/\[(.+?)\]/g, ":$1")
+    .replace(/^\(.+?\)\//, "")
+    .replace(/\/(\(.+?\))/g, "");
+
+  if (!p.startsWith("/")) p = "/" + p;
+  return p === "/" ? "/" : p.replace(/\/$/, "");
+}
+
+export function extractAPIRoutes(
+  graph: Graph,
+  scanned: ScannedFile[],
+  rootDir: string,
+): Graph {
+  const routeFiles = scanned.filter((sf) => {
+    const base = path.basename(sf.path, path.extname(sf.path));
+    return base === "route" && sf.relativePath.startsWith("app/");
+  });
+
+  if (routeFiles.length === 0) return graph;
+
+  const project = new Project({ compilerOptions: { noEmit: true } });
+  const newRoutes: HTTPRoute[] = [...graph.routes];
+
+  for (const rf of routeFiles) {
+    try {
+      const sourceFile = project.addSourceFileAtPath(rf.path);
+    } catch {
+      continue;
+    }
+  }
+
+  for (const rf of routeFiles) {
+    try {
+      const sourceFile = project.getSourceFile(rf.path);
+      if (!sourceFile) continue;
+
+      const httpPath = appRouteToHttpPath(rf.relativePath);
+
+      for (const func of sourceFile.getFunctions()) {
+        const name = func.getName();
+        if (!name || !HTTP_METHODS.has(name.toUpperCase())) continue;
+
+        newRoutes.push({
+          method: name.toUpperCase(),
+          path: httpPath,
+          handler: rf.relativePath,
+          file: rf.relativePath,
+          line: func.getStartLineNumber(),
+        });
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return { ...graph, routes: newRoutes };
+}

package/src/opencode/index.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect } from "vitest";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import { addOpencodePlugin } from "./index.js";
+
+let tmpDir: string;
+
+function setup() {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "tsgraph-opencode-"));
+}
+
+function teardown() {
+  fs.rmSync(tmpDir, { recursive: true });
+}
+
+function readJson(filePath: string): Record<string, unknown> {
+  return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+
+describe("addOpencodePlugin", () => {
+  it("creates opencode.json when it does not exist", () => {
+    setup();
+    const result = addOpencodePlugin(tmpDir);
+    expect(result.opencodeJsonUpdated).toBe(true);
+    expect(result.errors).toHaveLength(0);
+
+    const configPath = path.join(tmpDir, "opencode.json");
+    expect(fs.existsSync(configPath)).toBe(true);
+
+    const config = readJson(configPath);
+    expect(config["mcpServers"]).toEqual({
+      tsgraph: { command: "npx", args: ["tsgraph", "mcp"] },
+    });
+    teardown();
+  });
+
+  it("updates existing opencode.json preserving other fields", () => {
+    setup();
+    const configPath = path.join(tmpDir, "opencode.json");
+    fs.writeFileSync(
+      configPath,
+      JSON.stringify({ existingKey: "keep-me", mcpServers: { other: { command: "other" } } }, null, 2) + "\n",
+    );
+
+    const result = addOpencodePlugin(tmpDir);
+    expect(result.opencodeJsonUpdated).toBe(true);
+    expect(result.errors).toHaveLength(0);
+
+    const config = readJson(configPath);
+    expect(config["existingKey"]).toBe("keep-me");
+    expect((config["mcpServers"] as Record<string, unknown>)["other"]).toEqual({ command: "other" });
+    expect((config["mcpServers"] as Record<string, unknown>)["tsgraph"]).toEqual({
+      command: "npx",
+      args: ["tsgraph", "mcp"],
+    });
+    teardown();
+  });
+
+  it("creates .opencode/agents/tsgraph.json", () => {
+    setup();
+    const result = addOpencodePlugin(tmpDir);
+    expect(result.agentCreated).toBe(true);
+    expect(result.errors).toHaveLength(0);
+
+    const agentPath = path.join(tmpDir, ".opencode", "agents", "tsgraph.json");
+    expect(fs.existsSync(agentPath)).toBe(true);
+
+    const agent = readJson(agentPath);
+    expect(agent["name"]).toBe("tsgraph");
+    expect(agent["description"]).toBe(
+      "Query the tsgraph codebase index for symbols, imports, dependencies, and analysis",
+    );
+    expect(agent["tools"]).toContain("tsgraph_query");
+    expect(agent["tools"]).toContain("tsgraph_plan");
+    teardown();
+  });
+
+  it("handles invalid existing opencode.json gracefully", () => {
+    setup();
+    const configPath = path.join(tmpDir, "opencode.json");
+    fs.writeFileSync(configPath, "not valid json");
+
+    const result = addOpencodePlugin(tmpDir);
+    expect(result.opencodeJsonUpdated).toBe(false);
+    expect(result.errors.length).toBeGreaterThan(0);
+    expect(result.errors[0]).toContain("Failed to update opencode.json");
+    teardown();
+  });
+});

package/src/opencode/index.ts

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const MCP_SERVER_CONFIG = {
+  command: "npx",
+  args: ["@shvmgyl15/tsgraph", "mcp"],
+};
+
+const AGENT_CONFIG = {
+  name: "tsgraph",
+  description: "Query the tsgraph codebase index for symbols, imports, dependencies, and analysis",
+  tools: [
+    "tsgraph_callers",
+    "tsgraph_callees",
+    "tsgraph_node",
+    "tsgraph_source",
+    "tsgraph_query",
+    "tsgraph_imports",
+    "tsgraph_public",
+    "tsgraph_focus",
+    "tsgraph_context",
+    "tsgraph_complexity",
+    "tsgraph_hotspot",
+    "tsgraph_coupling",
+    "tsgraph_deps",
+    "tsgraph_impact",
+    "tsgraph_path",
+    "tsgraph_orphans",
+    "tsgraph_trace",
+    "tsgraph_boundaries",
+    "tsgraph_changes",
+    "tsgraph_stale",
+    "tsgraph_plan",
+    "tsgraph_review",
+  ],
+};
+
+export interface AddPluginResult {
+  opencodeJsonUpdated: boolean;
+  agentCreated: boolean;
+  errors: string[];
+}
+
+export function addOpencodePlugin(rootDir: string): AddPluginResult {
+  const errors: string[] = [];
+  let opencodeJsonUpdated = false;
+  let agentCreated = false;
+
+  const opencodeJsonPath = path.join(rootDir, "opencode.json");
+
+  try {
+    let config: Record<string, unknown>;
+    if (fs.existsSync(opencodeJsonPath)) {
+      const raw = fs.readFileSync(opencodeJsonPath, "utf-8");
+      config = JSON.parse(raw);
+    } else {
+      config = {};
+    }
+
+    config["mcpServers"] = {
+      ...((config["mcpServers"] as Record<string, unknown>) || {}),
+      tsgraph: MCP_SERVER_CONFIG,
+    };
+
+    fs.writeFileSync(opencodeJsonPath, JSON.stringify(config, null, 2) + "\n");
+    opencodeJsonUpdated = true;
+  } catch (e) {
+    errors.push(`Failed to update opencode.json: ${String(e)}`);
+  }
+
+  try {
+    const agentsDir = path.join(rootDir, ".opencode", "agents");
+    fs.mkdirSync(agentsDir, { recursive: true });
+
+    const agentPath = path.join(agentsDir, "tsgraph.json");
+    fs.writeFileSync(agentPath, JSON.stringify(AGENT_CONFIG, null, 2) + "\n");
+    agentCreated = true;
+  } catch (e) {
+    errors.push(`Failed to create tsgraph agent: ${String(e)}`);
+  }
+
+  return { opencodeJsonUpdated, agentCreated, errors };
+}

package/src/parser/index.ts

@@ -0,0 +1,339 @@
+import path from "node:path";
+import fs from "node:fs";
+import {
+  Project,
+  Node,
+  SyntaxKind,
+  type SourceFile,
+} from "ts-morph";
+import type {
+  Graph,
+  SymbolNode,
+  CallEdge,
+  ImportEdge,
+  Dependency,
+  FileNode,
+  PackageNode,
+} from "../graph/types.js";
+import { GRAPH_VERSION } from "../graph/types.js";
+import type { ScannedFile } from "../scanner/index.js";
+import { extractNextJs } from "../nextjs/index.js";
+
+function symbolId(file: string, name: string): string {
+  return `${file}::${name}`;
+}
+
+function countLines(filePath: string): number {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return content.split("\n").length;
+  } catch {
+    return 0;
+  }
+}
+
+function extractFileNodes(
+  rootDir: string,
+  scanned: ScannedFile[],
+  pkg: string,
+): FileNode[] {
+  return scanned.map((sf) => ({
+    id: sf.relativePath,
+    path: sf.relativePath,
+    packageName: pkg,
+    lines: countLines(sf.path),
+    generated: sf.isGenerated,
+  }));
+}
+
+function extractSymbols(
+  sourceFile: SourceFile,
+  filePath: string,
+  pkgName: string,
+): SymbolNode[] {
+  const symbols: SymbolNode[] = [];
+
+  for (const func of sourceFile.getFunctions()) {
+    const name = func.getName();
+    if (!name) continue;
+    symbols.push({
+      id: symbolId(filePath, name),
+      kind: "function",
+      name,
+      packageName: pkgName,
+      file: filePath,
+      line: func.getStartLineNumber(),
+      endLine: func.getEndLineNumber(),
+      isExported: func.isExported(),
+      arity: func.getParameters().length,
+    });
+  }
+
+  for (const cls of sourceFile.getClasses()) {
+    const name = cls.getName();
+    if (!name) continue;
+    symbols.push({
+      id: symbolId(filePath, name),
+      kind: "class",
+      name,
+      packageName: pkgName,
+      file: filePath,
+      line: cls.getStartLineNumber(),
+      endLine: cls.getEndLineNumber(),
+      isExported: cls.isExported(),
+    });
+
+    for (const method of cls.getMethods()) {
+      const mName = method.getName();
+      if (!mName) continue;
+      symbols.push({
+        id: symbolId(filePath, `${name}.${mName}`),
+        kind: "method",
+        name: mName,
+        receiver: name,
+        packageName: pkgName,
+        file: filePath,
+        line: method.getStartLineNumber(),
+        endLine: method.getEndLineNumber(),
+        isExported: true,
+        arity: method.getParameters().length,
+      });
+    }
+  }
+
+  for (const iface of sourceFile.getInterfaces()) {
+    const name = iface.getName();
+    symbols.push({
+      id: symbolId(filePath, name),
+      kind: "interface",
+      name,
+      packageName: pkgName,
+      file: filePath,
+      line: iface.getStartLineNumber(),
+      endLine: iface.getEndLineNumber(),
+      isExported: iface.isExported(),
+    });
+  }
+
+  for (const alias of sourceFile.getTypeAliases()) {
+    const name = alias.getName();
+    symbols.push({
+      id: symbolId(filePath, name),
+      kind: "type_alias",
+      name,
+      packageName: pkgName,
+      file: filePath,
+      line: alias.getStartLineNumber(),
+      endLine: alias.getEndLineNumber(),
+      isExported: alias.isExported(),
+    });
+  }
+
+  for (const enm of sourceFile.getEnums()) {
+    const name = enm.getName();
+    symbols.push({
+      id: symbolId(filePath, name),
+      kind: "enum",
+      name,
+      packageName: pkgName,
+      file: filePath,
+      line: enm.getStartLineNumber(),
+      endLine: enm.getEndLineNumber(),
+      isExported: enm.isExported(),
+    });
+  }
+
+  for (const vs of sourceFile.getVariableStatements()) {
+    const isExported = vs.isExported();
+    const isConst =
+      vs
+        .getDeclarationList()
+        .getFirstChildByKind(SyntaxKind.ConstKeyword) !== undefined;
+    const varKind = isConst ? "const" : "var";
+    for (const decl of vs.getDeclarations()) {
+      const name = decl.getName();
+      symbols.push({
+        id: symbolId(filePath, name),
+        kind: varKind,
+        name,
+        packageName: pkgName,
+        file: filePath,
+        line: decl.getStartLineNumber(),
+        endLine: decl.getEndLineNumber(),
+        isExported,
+      });
+    }
+  }
+
+  return symbols;
+}
+
+function extractCalls(
+  sourceFile: SourceFile,
+  filePath: string,
+): CallEdge[] {
+  const calls: CallEdge[] = [];
+
+  for (const func of sourceFile.getFunctions()) {
+    const name = func.getName();
+    if (!name) continue;
+    const funcId = symbolId(filePath, name);
+    func.forEachDescendant((node) => {
+      if (Node.isCallExpression(node)) {
+        const calleeRaw = node.getExpression().getText();
+        calls.push({
+          callerSymbolId: funcId,
+          callerName: name,
+          calleeRaw,
+          file: filePath,
+          line: node.getStartLineNumber(),
+        });
+      }
+      return false;
+    });
+  }
+
+  for (const cls of sourceFile.getClasses()) {
+    const clsName = cls.getName();
+    if (!clsName) continue;
+    for (const method of cls.getMethods()) {
+      const mName = method.getName();
+      if (!mName) continue;
+      const methodId = symbolId(filePath, `${clsName}.${mName}`);
+      method.forEachDescendant((node) => {
+        if (Node.isCallExpression(node)) {
+          const calleeRaw = node.getExpression().getText();
+          calls.push({
+            callerSymbolId: methodId,
+            callerName: mName,
+            calleeRaw,
+            file: filePath,
+            line: node.getStartLineNumber(),
+          });
+        }
+        return false;
+      });
+    }
+  }
+
+  return calls;
+}
+
+function extractImports(
+  sourceFile: SourceFile,
+  filePath: string,
+  pkgName: string,
+): ImportEdge[] {
+  const imports: ImportEdge[] = [];
+
+  for (const imp of sourceFile.getImportDeclarations()) {
+    const importPath = imp.getModuleSpecifierValue();
+
+    const defaultImport = imp.getDefaultImport();
+    if (defaultImport) {
+      imports.push({
+        fromFile: filePath,
+        fromPackage: pkgName,
+        importPath,
+        alias: defaultImport.getText(),
+        isDefault: true,
+      });
+    }
+
+    for (const named of imp.getNamedImports()) {
+      imports.push({
+        fromFile: filePath,
+        fromPackage: pkgName,
+        importPath,
+        alias: named.getName(),
+        isDefault: false,
+      });
+    }
+  }
+
+  return imports;
+}
+
+function readDependencies(rootDir: string): Dependency[] {
+  const pkgPath = path.join(rootDir, "package.json");
+  try {
+    const raw = fs.readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    const deps: Dependency[] = [];
+    const allDeps: Record<string, string> = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies,
+    };
+    for (const [module, version] of Object.entries(allDeps)) {
+      deps.push({ module, version: String(version) });
+    }
+    return deps;
+  } catch {
+    return [];
+  }
+}
+
+function computePackageName(rootDir: string): string {
+  try {
+    const pkgPath = path.join(rootDir, "package.json");
+    const raw = fs.readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    return pkg.name ?? path.basename(rootDir);
+  } catch {
+    return path.basename(rootDir);
+  }
+}
+
+export function parseProject(rootDir: string, scanned: ScannedFile[]): Graph {
+  const pkgName = computePackageName(rootDir);
+  const fileNodes = extractFileNodes(rootDir, scanned, pkgName);
+
+  const rootPackage: PackageNode = {
+    id: pkgName,
+    name: pkgName,
+    importPathBestEffort: pkgName,
+    dir: rootDir,
+    files: scanned.map((sf) => sf.relativePath),
+  };
+
+  const project = new Project({
+    compilerOptions: {
+      allowJs: true,
+      noEmit: true,
+    },
+  });
+
+  const parsable = scanned.filter(
+    (sf) =>
+      sf.kind === "ts" || sf.kind === "tsx" || sf.kind === "js" || sf.kind === "jsx",
+  );
+
+  for (const sf of parsable) {
+    try {
+      project.addSourceFileAtPath(sf.path);
+    } catch {
+      // skip files that fail to parse
+    }
+  }
+
+  const allSymbols: SymbolNode[] = [];
+  const allCalls: CallEdge[] = [];
+  const allImports: ImportEdge[] = [];
+
+  for (const sourceFile of project.getSourceFiles()) {
+    const relPath = path.relative(rootDir, sourceFile.getFilePath());
+    const symbols = extractSymbols(sourceFile, relPath, pkgName);
+    const calls = extractCalls(sourceFile, relPath);
+    const imports = extractImports(sourceFile, relPath, pkgName);
+
+    allSymbols.push(...symbols);
+    allCalls.push(...calls);
+    allImports.push(...imports);
+  }
+
+  const dependencies = readDependencies(rootDir);
+
+  const baseGraph = { version: GRAPH_VERSION, generatedAt: new Date().toISOString(), root: rootDir, packages: [rootPackage], files: fileNodes, symbols: allSymbols, imports: allImports, calls: allCalls, envReads: [], dependencies, routes: [], concurrency: [], testEdges: [], implements: [], mutations: [], errors: [] };
+
+  return extractNextJs(baseGraph, rootDir, scanned);
+}