@ttsc/graph 0.16.4 → 0.16.6

package/src/structures/index.ts

@@ -0,0 +1,22 @@
+// The canonical graph data model and tool I/O types: the wire contract
+// `ttscgraph dump` emits and the MCP server loads, plus the schemas typia
+// derives the tool surface from. Pure types so typia can build validators and
+// tool schemas at build time, and so the Go `dump.go` writer has one TypeScript
+// source of truth to mirror.
+
+export * from "./ITtscGraphApplication";
+export * from "./ITtscGraphDecorator";
+export * from "./ITtscGraphDiagnostic";
+export * from "./ITtscGraphDump";
+export * from "./ITtscGraphEdge";
+export * from "./ITtscGraphEvidence";
+export * from "./ITtscGraphEscape";
+export * from "./ITtscGraphDetails";
+export * from "./ITtscGraphEntrypoints";
+export * from "./ITtscGraphNode";
+export * from "./ITtscGraphOverview";
+export * from "./ITtscGraphLookup";
+export * from "./ITtscGraphTrace";
+export * from "./TtscGraphEdgeKind";
+export * from "./TtscGraphNodeKind";
+export * from "./TtscGraphNodeModifier";

package/src/view.ts

@@ -0,0 +1,155 @@
+import { spawn, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import http from "node:http";
+import path from "node:path";
+
+import { type RawDump, reduce } from "./reduce";
+import { resolveGraphBinary } from "./resolveGraphBinary";
+
+interface ViewOptions {
+  cwd: string;
+  tsconfig: string;
+  port: number;
+  open: boolean;
+  maxNodes: number;
+}
+
+function parseViewArgs(argv: readonly string[]): ViewOptions {
+  const opts: ViewOptions = {
+    cwd: process.cwd(),
+    tsconfig: "tsconfig.json",
+    port: 0,
+    open: true,
+    maxNodes: 1200,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]!;
+    if (arg === "--cwd") opts.cwd = argv[++i] ?? opts.cwd;
+    else if (arg.startsWith("--cwd=")) opts.cwd = arg.slice("--cwd=".length);
+    else if (arg === "--tsconfig" || arg === "-p")
+      opts.tsconfig = argv[++i] ?? opts.tsconfig;
+    else if (arg.startsWith("--tsconfig="))
+      opts.tsconfig = arg.slice("--tsconfig=".length);
+    else if (arg === "--port") opts.port = Number(argv[++i]);
+    else if (arg.startsWith("--port="))
+      opts.port = Number(arg.slice("--port=".length));
+    else if (arg === "--no-open") opts.open = false;
+    else if (arg === "--max-nodes") opts.maxNodes = Number(argv[++i]);
+    else if (arg.startsWith("--max-nodes="))
+      opts.maxNodes = Number(arg.slice("--max-nodes=".length));
+  }
+  return opts;
+}
+
+/**
+ * `ttsc-graph view`: build the project's code graph, reduce it, and serve a
+ * self-contained 3D viewer on a localhost port, opening the browser. The native
+ * binary produces the graph (the same `dump` the docs document); everything
+ * else is local and offline. The process stays alive serving until Ctrl+C.
+ */
+export function runView(argv: readonly string[]): number | void {
+  const opts = parseViewArgs(argv);
+
+  const binary = resolveGraphBinary();
+  if (binary === null) {
+    process.stderr.write(
+      "@ttsc/graph: could not resolve the ttscgraph binary. " +
+        "Install `ttsc` so its platform package is present, " +
+        "or set TTSC_GRAPH_BINARY to an absolute path.\n",
+    );
+    return 1;
+  }
+
+  process.stderr.write(
+    `@ttsc/graph: building the graph for ${opts.cwd} (${opts.tsconfig})...\n`,
+  );
+  const dump = spawnSync(
+    binary,
+    ["dump", "--cwd", opts.cwd, "--tsconfig", opts.tsconfig],
+    { encoding: "utf8", maxBuffer: 1024 * 1024 * 1024 },
+  );
+  if (dump.error) {
+    process.stderr.write(`@ttsc/graph: ${dump.error.message}\n`);
+    return 1;
+  }
+  if (dump.status !== 0) {
+    process.stderr.write(dump.stderr || "@ttsc/graph: dump failed\n");
+    return dump.status ?? 1;
+  }
+
+  let raw: RawDump;
+  try {
+    raw = JSON.parse(dump.stdout) as RawDump;
+  } catch (err) {
+    process.stderr.write(
+      `@ttsc/graph: could not parse the graph dump: ${String(err)}\n`,
+    );
+    return 1;
+  }
+
+  const payload = reduce(raw, { maxNodes: opts.maxNodes });
+  payload.project = path.basename(path.resolve(opts.cwd));
+  const graphJson = JSON.stringify(payload);
+
+  const viewerDir = path.join(__dirname, "viewer");
+  let indexHtml: Buffer;
+  let viewerJs: Buffer;
+  try {
+    indexHtml = fs.readFileSync(path.join(viewerDir, "index.html"));
+    viewerJs = fs.readFileSync(path.join(viewerDir, "viewer.js"));
+  } catch (err) {
+    process.stderr.write(
+      `@ttsc/graph: the bundled viewer is missing (${String(err)}). ` +
+        "Reinstall @ttsc/graph.\n",
+    );
+    return 1;
+  }
+
+  const server = http.createServer((req, res) => {
+    const url = (req.url ?? "/").split("?")[0];
+    if (url === "/graph.json") {
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(graphJson);
+    } else if (url === "/viewer.js") {
+      res.writeHead(200, {
+        "content-type": "application/javascript; charset=utf-8",
+      });
+      res.end(viewerJs);
+    } else {
+      res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      res.end(indexHtml);
+    }
+  });
+
+  server.listen(opts.port, "127.0.0.1", () => {
+    const address = server.address();
+    const port =
+      typeof address === "object" && address ? address.port : opts.port;
+    const url = `http://127.0.0.1:${port}/`;
+    const counts = payload.counts;
+    process.stderr.write(
+      `@ttsc/graph: ${counts.nodes.toLocaleString()} nodes / ${counts.links.toLocaleString()} edges` +
+        ` (from ${counts.rawNodes.toLocaleString()} / ${counts.rawEdges.toLocaleString()})\n`,
+    );
+    process.stderr.write(`@ttsc/graph: serving the 3D viewer at ${url}\n`);
+    process.stderr.write("@ttsc/graph: press Ctrl+C to stop.\n");
+    if (opts.open) openBrowser(url);
+  });
+  // No return: the listening server keeps the process alive until Ctrl+C.
+}
+
+/** Best-effort open the URL in the default browser; the URL is printed anyway. */
+function openBrowser(url: string): void {
+  try {
+    if (process.platform === "win32")
+      spawn("cmd", ["/c", "start", "", url], {
+        stdio: "ignore",
+        detached: true,
+      }).unref();
+    else if (process.platform === "darwin")
+      spawn("open", [url], { stdio: "ignore", detached: true }).unref();
+    else spawn("xdg-open", [url], { stdio: "ignore", detached: true }).unref();
+  } catch {
+    /* the URL is printed; opening is a convenience */
+  }
+}

package/src/viewer/index.html

@@ -0,0 +1,123 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>ttsc · code graph</title>
+    <style>
+      :root {
+        color-scheme: dark;
+      }
+      * {
+        box-sizing: border-box;
+      }
+      html,
+      body {
+        margin: 0;
+        height: 100%;
+        background: #0a0c10;
+        color: #e6edf3;
+        font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+        overflow: hidden;
+      }
+      #app {
+        display: flex;
+        flex-direction: column;
+        height: 100vh;
+      }
+      header {
+        display: flex;
+        flex-wrap: wrap;
+        align-items: baseline;
+        gap: 0 14px;
+        padding: 10px 16px;
+        border-bottom: 1px solid #222834;
+        background: linear-gradient(to bottom, #13171f, #0e1116);
+      }
+      header .brand {
+        font-size: 13px;
+        font-weight: 600;
+        color: #f5f5f5;
+      }
+      header .brand b {
+        color: #36e2ee;
+      }
+      header #project {
+        font-size: 12px;
+        color: #9ca3af;
+      }
+      header #counts {
+        margin-left: auto;
+        font-size: 11px;
+        color: #6b7280;
+      }
+      #graph {
+        position: relative;
+        flex: 1;
+        min-height: 0;
+      }
+      #graph .tooltip {
+        position: absolute;
+        display: none;
+        pointer-events: none;
+        z-index: 10;
+        max-width: 24rem;
+        padding: 4px 7px;
+        border-radius: 6px;
+        background: rgba(12, 14, 19, 0.93);
+        border: 1px solid #2a313e;
+        font-size: 11px;
+        line-height: 1.4;
+      }
+      #graph .tooltip .muted {
+        color: #8b97a8;
+      }
+      footer {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 6px 16px;
+        padding: 8px 16px;
+        border-top: 1px solid #222834;
+        font-size: 10px;
+        color: #6b7280;
+      }
+      footer .dot {
+        display: inline-flex;
+        align-items: center;
+        gap: 6px;
+      }
+      footer .swatch {
+        display: inline-block;
+        width: 16px;
+        height: 2px;
+        border-radius: 2px;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="app">
+      <header>
+        <span class="brand"><b>ttsc</b> · code graph</span>
+        <span id="project"></span>
+        <span id="counts"></span>
+      </header>
+      <div id="graph"></div>
+      <footer>
+        <span class="dot"
+          ><span class="swatch" style="background: #3fb950"></span
+          >value-call</span
+        >
+        <span class="dot"
+          ><span class="swatch" style="background: #f5b042"></span
+          >type-ref</span
+        >
+        <span class="dot"
+          ><span class="swatch" style="background: #6ea8ff"></span
+          >heritage</span
+        >
+        <span>node size = connection count · color = declaration kind</span>
+      </footer>
+    </div>
+    <script src="viewer.js"></script>
+  </body>
+</html>

package/src/viewer/main.ts

@@ -0,0 +1,209 @@
+// Vanilla 3D code-graph viewer bundled into @ttsc/graph by esbuild and served by
+// `ttsc-graph view`. Mirrors website/src/components/graph/GraphViewer3D.tsx, but
+// standalone (no React): fetch the reduced graph the CLI serves, render it on
+// three.js + three-forcegraph, and let the user orbit it.
+import * as THREE from "three";
+import ThreeForceGraph from "three-forcegraph";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
+
+interface GNode {
+  id: string;
+  name: string;
+  kind: string;
+  file: string;
+  degree: number;
+}
+
+interface GLink {
+  source: string;
+  target: string;
+  kind: string;
+}
+
+interface Payload {
+  project: string;
+  counts: { nodes: number; links: number };
+  nodes: GNode[];
+  links: GLink[];
+}
+
+const NODE_COLORS: Record<string, string> = {
+  class: "#36e2ee",
+  interface: "#6ea8ff",
+  function: "#3fb950",
+  method: "#2bb673",
+  type: "#f5b042",
+  enum: "#c792ea",
+  variable: "#8b97a8",
+};
+
+const LINK_COLORS: Record<string, string> = {
+  "value-call": "#3fb950",
+  "type-ref": "#f5b042",
+  heritage: "#6ea8ff",
+};
+
+function escapeHtml(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
+function setText(id: string, text: string): void {
+  const el = document.getElementById(id);
+  if (el) el.textContent = text;
+}
+
+async function main(): Promise<void> {
+  const container = document.getElementById("graph");
+  if (!container) return;
+
+  let data: Payload;
+  try {
+    const res = await fetch("graph.json");
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    data = (await res.json()) as Payload;
+  } catch (err) {
+    container.textContent = `could not load the graph (${String(err)})`;
+    return;
+  }
+
+  if (data.project) setText("project", data.project);
+  setText(
+    "counts",
+    `${data.nodes.length.toLocaleString()} nodes · ${data.links.length.toLocaleString()} edges`,
+  );
+
+  const width = container.clientWidth || 800;
+  const height = container.clientHeight || 600;
+
+  const scene = new THREE.Scene();
+  scene.background = new THREE.Color(0x0a0c10);
+  scene.add(new THREE.AmbientLight(0xffffff, 2));
+  const keyLight = new THREE.DirectionalLight(0xffffff, 0.8);
+  keyLight.position.set(1, 1, 1);
+  scene.add(keyLight);
+
+  const camera = new THREE.PerspectiveCamera(50, width / height, 0.1, 1e6);
+  camera.position.set(0, 0, 320);
+
+  const renderer = new THREE.WebGLRenderer({ antialias: true });
+  renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+  renderer.setSize(width, height);
+  container.appendChild(renderer.domElement);
+
+  const controls = new OrbitControls(camera, renderer.domElement);
+  controls.enableDamping = true;
+  controls.dampingFactor = 0.18;
+
+  const graph = new ThreeForceGraph<GNode, GLink>()
+    .nodeId("id")
+    .nodeRelSize(4)
+    .nodeResolution(12)
+    .nodeOpacity(0.95)
+    .nodeVal((node) => 1 + Math.sqrt(node.degree))
+    .nodeColor((node) => NODE_COLORS[node.kind] ?? "#8b97a8")
+    .linkColor((link) => LINK_COLORS[link.kind] ?? "#ffffff55")
+    .linkOpacity(0.4)
+    .linkWidth(0)
+    .warmupTicks(20)
+    .cooldownTicks(160);
+  scene.add(graph);
+
+  const fit = (): void => {
+    const b = graph.getGraphBbox();
+    if (!b) return;
+    const cx = (b.x[0] + b.x[1]) / 2;
+    const cy = (b.y[0] + b.y[1]) / 2;
+    const cz = (b.z[0] + b.z[1]) / 2;
+    const radius = Math.max(
+      (b.x[1] - b.x[0]) / 2,
+      (b.y[1] - b.y[0]) / 2,
+      (b.z[1] - b.z[0]) / 2,
+      10,
+    );
+    const dist = radius * 2.6;
+    camera.position.set(cx + dist * 0.5, cy + dist * 0.32, cz + dist * 0.8);
+    camera.near = Math.max(0.1, dist / 200);
+    camera.far = dist * 20;
+    camera.updateProjectionMatrix();
+    controls.target.set(cx, cy, cz);
+    controls.update();
+  };
+  // `?static` settles the layout, frames it, then stops the render loop, for a
+  // low-CPU snapshot (and headless screenshots). Default mode keeps animating.
+  const staticMode = new URLSearchParams(window.location.search).has("static");
+  let stopAtFrame = -1;
+  let frame = 0;
+  graph.onEngineStop(() => {
+    fit();
+    if (staticMode && stopAtFrame < 0) stopAtFrame = frame + 4;
+  });
+
+  // Hover tooltip via raycasting the node objects (each carries __data).
+  const tooltip = document.createElement("div");
+  tooltip.className = "tooltip";
+  container.appendChild(tooltip);
+  const raycaster = new THREE.Raycaster();
+  const pointer = new THREE.Vector2();
+  renderer.domElement.addEventListener("pointermove", (event) => {
+    const rect = renderer.domElement.getBoundingClientRect();
+    pointer.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;
+    pointer.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+    raycaster.setFromCamera(pointer, camera);
+    const hits = raycaster.intersectObjects(graph.children, true);
+    let node: GNode | null = null;
+    for (const hit of hits) {
+      let obj: THREE.Object3D | null = hit.object;
+      while (obj) {
+        const meta = obj as { __graphObjType?: string; __data?: unknown };
+        if (meta.__graphObjType === "node" && meta.__data) {
+          node = meta.__data as GNode;
+          break;
+        }
+        obj = obj.parent;
+      }
+      if (node) break;
+    }
+    if (!node) {
+      tooltip.style.display = "none";
+      return;
+    }
+    tooltip.style.display = "block";
+    tooltip.style.left = `${event.clientX - rect.left + 12}px`;
+    tooltip.style.top = `${event.clientY - rect.top + 12}px`;
+    tooltip.innerHTML =
+      `${escapeHtml(node.name)}<br/>` +
+      `<span class="muted">${escapeHtml(node.kind)} · ${escapeHtml(node.file)}</span>`;
+  });
+  renderer.domElement.addEventListener("pointerleave", () => {
+    tooltip.style.display = "none";
+  });
+
+  const animate = (): void => {
+    if (stopAtFrame >= 0 && frame > stopAtFrame) {
+      renderer.render(scene, camera);
+      return;
+    }
+    requestAnimationFrame(animate);
+    graph.tickFrame();
+    controls.update();
+    renderer.render(scene, camera);
+    frame++;
+  };
+  animate();
+
+  window.addEventListener("resize", () => {
+    const w = container.clientWidth || width;
+    const h = container.clientHeight || height;
+    camera.aspect = w / h;
+    camera.updateProjectionMatrix();
+    renderer.setSize(w, h);
+  });
+
+  graph.graphData({ nodes: data.nodes, links: data.links });
+  window.setTimeout(fit, 700);
+}
+
+void main();

package/lib/bin.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/lib/diagnostics.d.ts

@@ -1,23 +0,0 @@
-/**
- * Background worker that computes the project's plugin diagnostics and writes
- * them where the ttscgraph server reads them.
- *
- * The graph binary runs only the TypeScript semantic pass. Everything a plugin
- * adds — `@ttsc/lint` rule violations and transform-plugin (typia, nestia, …)
- * findings — comes from `ttsc`'s own check, which runs whatever plugins the
- * project configured. This worker invokes that check through the public
- * `TtscCompiler`, so nothing here is specific to any plugin: it forwards
- * whatever diagnostics ttsc produces.
- *
- * A native plugin reports its findings with a string `code` (tsc uses numeric
- * codes), so the string-coded diagnostics are exactly the plugin/lint set the
- * graph does not already have. They are serialized with code 0 and the rule
- * folded into the message, the shape ttscgraph's injected-diagnostics provider
- * consumes.
- *
- * Every failure is swallowed: a missing `ttsc`, a go toolchain that cannot
- * build a plugin, a project that does not compile — any of these simply leaves
- * no file, and the graph shows its tsc diagnostics alone. The worker must never
- * be able to break the server it feeds.
- */
-export declare function runDiagnosticsWorker(argv?: readonly string[]): void;

package/lib/diagnostics.js

@@ -1,84 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runDiagnosticsWorker = runDiagnosticsWorker;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_module_1 = require("node:module");
-/**
- * Background worker that computes the project's plugin diagnostics and writes
- * them where the ttscgraph server reads them.
- *
- * The graph binary runs only the TypeScript semantic pass. Everything a plugin
- * adds — `@ttsc/lint` rule violations and transform-plugin (typia, nestia, …)
- * findings — comes from `ttsc`'s own check, which runs whatever plugins the
- * project configured. This worker invokes that check through the public
- * `TtscCompiler`, so nothing here is specific to any plugin: it forwards
- * whatever diagnostics ttsc produces.
- *
- * A native plugin reports its findings with a string `code` (tsc uses numeric
- * codes), so the string-coded diagnostics are exactly the plugin/lint set the
- * graph does not already have. They are serialized with code 0 and the rule
- * folded into the message, the shape ttscgraph's injected-diagnostics provider
- * consumes.
- *
- * Every failure is swallowed: a missing `ttsc`, a go toolchain that cannot
- * build a plugin, a project that does not compile — any of these simply leaves
- * no file, and the graph shows its tsc diagnostics alone. The worker must never
- * be able to break the server it feeds.
- */
-function runDiagnosticsWorker(argv = process.argv.slice(2)) {
-    const [cwd, tsconfig, outPath] = argv;
-    if (!cwd || !outPath) {
-        return;
-    }
-    try {
-        const ttscPackageJson = require.resolve("ttsc/package.json", {
-            paths: [cwd],
-        });
-        const fromProject = (0, node_module_1.createRequire)(ttscPackageJson);
-        const { TtscCompiler } = fromProject("ttsc");
-        const result = new TtscCompiler({
-            cwd,
-            tsconfig: tsconfig || undefined,
-        }).compile();
-        const raw = result &&
-            typeof result === "object" &&
-            Array.isArray(result.diagnostics)
-            ? (result.diagnostics)
-            : [];
-        const out = raw
-            .filter((d) => typeof d.file === "string" &&
-            (typeof d.line === "number" || typeof d.start === "number"))
-            .map((d) => ({
-            file: d.file,
-            // A byte offset when the structured lane gives one; otherwise null and
-            // the server attributes by line. @ttsc/lint and transform plugins reach
-            // the result through ttsc's text banner, which carries a line but no
-            // offset.
-            start: typeof d.start === "number" ? d.start : null,
-            line: typeof d.line === "number" ? d.line : 1,
-            column: typeof d.character === "number" ? d.character : 1,
-            // tsc diagnostics use numeric codes; @ttsc/lint and native plugins hash
-            // their rule to a code >= 9000. A rare string id is marked non-tsc (the
-            // server then drops the "TS" prefix); the rule name travels in the
-            // message regardless.
-            code: typeof d.code === "number" ? d.code : 9000,
-            message: String(d.messageText ?? ""),
-        }));
-        // Atomic publish: write to a sibling temp file and rename, so the server
-        // never reads a half-written file (a partial read would drop every finding
-        // for that query).
-        const tmp = `${outPath}.${process.pid}.tmp`;
-        node_fs_1.default.writeFileSync(tmp, JSON.stringify(out));
-        node_fs_1.default.renameSync(tmp, outPath);
-    }
-    catch {
-        // Resilient by contract: no file means the graph shows tsc-only diagnostics.
-    }
-}
-if (require.main === module) {
-    runDiagnosticsWorker();
-}
-//# sourceMappingURL=diagnostics.js.map

package/lib/diagnostics.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"diagnostics.js","sourceRoot":"","sources":["../src/diagnostics.ts"],"names":[],"mappings":";;;;;;AAAA,sDAAyB;AACzB,6CAA4C;AAE5C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8BACE,IAAI,GAAsB,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAE/C,MAAM,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACtC,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QACrB,OAAO;IACT,CAAC;IACD,IAAI,CAAC;QACH,MAAM,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,mBAAmB,EAAE;YAC3D,KAAK,EAAE,CAAC,GAAG,CAAC;SACb,CAAC,CAAC;QACH,MAAM,WAAW,GAAG,IAAA,2BAAa,EAAC,eAAe,CAAC,CAAC;QACnD,MAAM,EAAE,YAAY,EAAE,GAAG,WAAW,CAAC,MAAM,CAK1C,CAAC;QAEF,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC;YAC9B,GAAG;YACH,QAAQ,EAAE,QAAQ,IAAI,SAAS;SAChC,CAAC,CAAC,OAAO,EAAE,CAAC;QAEb,MAAM,GAAG,GACP,MAAM;YACN,OAAO,MAAM,KAAK,QAAQ;YAC1B,KAAK,CAAC,OAAO,CAAE,MAAoC,CAAC,WAAW,CAAC;YAC9D,CAAC,CAAC,CAAE,MAAqD,CAAC,WAAW,CAAC;YACtE,CAAC,CAAC,EAAE,CAAC;QAET,MAAM,GAAG,GAAG,GAAG;aACZ,MAAM,CACL,CAAC,CAAC,EAAE,EAAE,CACJ,OAAO,CAAC,CAAC,IAAI,KAAK,QAAQ;YAC1B,CAAC,OAAO,CAAC,CAAC,IAAI,KAAK,QAAQ,IAAI,OAAO,CAAC,CAAC,KAAK,KAAK,QAAQ,CAAC,CAC9D;aACA,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACX,IAAI,EAAE,CAAC,CAAC,IAAc;YACtB,uEAAuE;YACvE,wEAAwE;YACxE,qEAAqE;YACrE,UAAU;YACV,KAAK,EAAE,OAAO,CAAC,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAE,CAAC,CAAC,KAAgB,CAAC,CAAC,CAAC,IAAI;YAC/D,IAAI,EAAE,OAAO,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAE,CAAC,CAAC,IAAe,CAAC,CAAC,CAAC,CAAC;YACzD,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAE,CAAC,CAAC,SAAoB,CAAC,CAAC,CAAC,CAAC;YACrE,wEAAwE;YACxE,wEAAwE;YACxE,mEAAmE;YACnE,sBAAsB;YACtB,IAAI,EAAE,OAAO,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAE,CAAC,CAAC,IAAe,CAAC,CAAC,CAAC,IAAI;YAC5D,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,WAAW,IAAI,EAAE,CAAC;SACrC,CAAC,CAAC,CAAC;QAEN,yEAAyE;QACzE,2EAA2E;QAC3E,mBAAmB;QACnB,MAAM,GAAG,GAAG,GAAG,OAAO,IAAI,OAAO,CAAC,GAAG,MAAM,CAAC;QAC5C,iBAAE,CAAC,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3C,iBAAE,CAAC,UAAU,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAC9B,CAAC;IAAC,MAAM,CAAC;QACP,6EAA6E;IAC/E,CAAC;AACH,CAAC;AAED,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;IAC5B,oBAAoB,EAAE,CAAC;AACzB,CAAC"}

package/lib/index.d.ts

@@ -1,29 +0,0 @@
-/**
- * Resolve the per-platform `ttscgraph` MCP server binary, or `null` when it
- * cannot be located.
- *
- * `ttsc` is a peer the user installs alongside `@ttsc/graph` (not a dependency
- * of this launcher), so resolution starts from the user's project, not from
- * this package's own tree.
- *
- * Resolution order:
- *
- * 1. `TTSC_GRAPH_BINARY` env var, when set to an absolute path.
- * 2. The per-platform npm package `@ttsc/<platform>-<arch>/bin/ttscgraph[.exe]`.
- *    That package carries `ttsc`, `ttscserver`, and `ttscgraph` together and is
- *    an `optionalDependency` of `ttsc`, so it is resolved from `ttsc`'s
- *    location — found from `process.cwd()` (the project where the agent ran the
- *    server).
- */
-export declare function resolveGraphBinary(env?: NodeJS.ProcessEnv, cwd?: string): string | null;
-/**
- * Spawn the resident MCP server, inheriting stdio so the agent's MCP client
- * speaks JSON-RPC to it directly over this process's stdin/stdout. Returns the
- * child's exit code.
- *
- * Before spawning, it kicks off the background diagnostics worker (except in
- * `--connect` proxy mode) and points the server at its output file, so a
- * plugin-using project's lint and transform-plugin diagnostics fuse onto the
- * graph without blocking startup.
- */
-export declare function runGraph(argv?: readonly string[]): number;