@ttsc/graph 0.16.7 → 0.16.9

package/lib/server/createServer.js.map

@@ -1 +1 @@
-{"version":3,"file":"createServer.js","sourceRoot":"","sources":["../../src/server/createServer.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"createServer.js","sourceRoot":"","sources":["../../src/server/createServer.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/graph",
-  "version": "0.16.7",
+  "version": "0.16.9",
   "description": "Checker-resolved architecture graph over MCP for coding agents, backed by ttsc's in-process TypeScript-Go compiler.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -14,14 +14,10 @@
     },
     "./package.json": "./package.json"
   },
-  "ttsc": {
-    "plugin": {
-      "transform": "typia/lib/transform"
-    }
-  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
-    "typia": "13.0.0-dev.20260605.1"
+    "@typia/mcp": "13.0.0-rc.1",
+    "typia": "13.0.0-rc.1"
   },
   "keywords": [
     "ttsc",
@@ -43,7 +39,7 @@
     "three": "^0.184.0",
     "three-forcegraph": "^1.43.4",
     "typescript": "7.0.1-rc",
-    "ttsc": "0.16.7"
+    "ttsc": "0.16.9"
   },
   "repository": {
     "type": "git",

package/src/TtscGraphApplication.ts

@@ -15,10 +15,11 @@ export type TtscGraphSource = TtscGraphMemory | (() => TtscGraphMemory);
  * The MCP tool surface as a plain class over the resident
  * {@link TtscGraphMemory}.
  *
- * Its public method is the MCP tool: `typia.llm.controller` reflects
+ * Its public method is the MCP tool: `typia.llm.application` reflects
  * {@link ITtscGraphApplication} to generate the tool's JSON schema and argument
- * validator from the signature and JSDoc, with no hand-written schema. The
- * method delegates to the pure graph functions in `./server`, which are
+ * validator from the signature and JSDoc, with no hand-written schema, and
+ * `@typia/mcp`'s `createMcpServer` registers it (see `./server/createServer`).
+ * The method delegates to the pure graph functions in `./server`, which are
  * unit-testable without a transport; this class only binds them to the graph.
  *
  * Every method answers from the resident graph; none recompiles. Output is kept
@@ -70,6 +71,7 @@ export class TtscGraphApplication implements ITtscGraphApplication {
           result: runTour(this.graph(), props.request),
         };
       default:
+        props.request satisfies never;
         throw new Error("Unknown graph request type");
     }
   }

package/src/reduce.ts

@@ -55,6 +55,11 @@ function posix(p: string): string {
   return p.replace(/\\/g, "/");
 }
 
+/** An absolute path (POSIX or Windows drive); relative dumps skip rerooting. */
+function isAbsolute(p: string): boolean {
+  return /^(?:[A-Za-z]:)?\//.test(posix(p));
+}
+
 function commonRoot(files: string[]): string {
   if (files.length === 0) return "";
   let parts = posix(files[0]!).split("/");
@@ -68,10 +73,13 @@ function commonRoot(files: string[]): string {
   return parts.join("/");
 }
 
+// An empty root means the dump's paths are already project-relative (the
+// current `ttscgraph dump` contract); they pass through structure-intact.
 function relativize(abs: string, root: string): string {
   const a = posix(abs);
   const r = posix(root).replace(/\/+$/, "");
-  if (r && (a === r || a.startsWith(r + "/")))
+  if (!r) return a;
+  if (a === r || a.startsWith(r + "/"))
     return a.slice(r.length).replace(/^\/+/, "");
   const nm = a.lastIndexOf("node_modules/");
   if (nm >= 0) return a.slice(nm);
@@ -97,6 +105,26 @@ function degreeOf(
   return degree;
 }
 
+/**
+ * Collapse the fine-grained wire kinds `ttscgraph dump` emits (calls,
+ * instantiates, renders, accesses, type_ref, extends, implements) into the
+ * three display families the viewer colors and its legend name. An unknown kind
+ * passes through and renders with the fallback color.
+ */
+const DISPLAY_KIND: Record<string, string> = {
+  calls: "value-call",
+  instantiates: "value-call",
+  renders: "value-call",
+  accesses: "value-call",
+  type_ref: "type-ref",
+  extends: "heritage",
+  implements: "heritage",
+};
+
+function displayKind(kind: string): string {
+  return DISPLAY_KIND[kind] ?? kind;
+}
+
 export function reduce(
   raw: RawDump,
   {
@@ -105,9 +133,13 @@ export function reduce(
   }: { maxNodes?: number; keepExternal?: boolean } = {},
 ): ViewerPayload {
   const keptByExternal = raw.nodes.filter((n) => keepExternal || !n.external);
-  const root = commonRoot(
-    raw.nodes.filter((n) => !n.external).map((n) => n.file),
-  );
+  // Reroot only absolute paths (the legacy dump contract); a current dump's
+  // paths are already project-relative and keep their structure as-is.
+  const projectFiles = raw.nodes.filter((n) => !n.external).map((n) => n.file);
+  const root =
+    projectFiles.length > 0 && isAbsolute(projectFiles[0]!)
+      ? commonRoot(projectFiles)
+      : "";
 
   const liveIds = new Set(keptByExternal.map((n) => n.id));
   const liveEdges = raw.edges.filter(
@@ -145,7 +177,7 @@ export function reduce(
     .map((e) => ({
       source: rewriteId(e.from, root),
       target: rewriteId(e.to, root),
-      kind: e.kind,
+      kind: displayKind(e.kind),
     }))
     .filter((e) => nodeIds.has(e.source) && nodeIds.has(e.target));
 

package/src/server/createServer.ts

@@ -1,101 +1,31 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-import typia from "typia";
+import { createMcpServer } from "@typia/mcp";
+import typia, { type ILlmController } from "typia";
 
 import { TtscGraphApplication, TtscGraphSource } from "../TtscGraphApplication";
-import { TtscGraphMemory } from "../model/TtscGraphMemory";
 import { ITtscGraphApplication } from "../structures/ITtscGraphApplication";
-import { instructions } from "./instructions";
 
 /**
- * Build the MCP server for a graph. `typia.llm.controller` reflects
- * {@link ITtscGraphApplication} into a validated tool application. Every tool's
- * JSON schema and argument validator is generated from the method's TypeScript
- * types and JSDoc, so there is no hand-written schema. The list/call handlers
- * below are the minimal standalone registration: list the generated functions,
- * and on a call validate the arguments (returning typia's errors for the model
- * to self-correct) before invoking the method.
+ * Build the MCP server for a graph. `typia.llm.application` reflects
+ * {@link ITtscGraphApplication} into the tool schema and validator (no
+ * hand-written schema), and `createMcpServer` from `@typia/mcp` handles the
+ * list/call registration, argument validation, and structured output.
  *
- * Registration is inlined rather than pulled from `@typia/mcp` to keep the
- * dependency surface to `typia` plus the MCP SDK and avoid version-pinning the
- * wider typia ecosystem; the shape it relies on is `typia.llm.controller`'s
- * public output.
+ * We assemble the `ILlmController` (`{ protocol, name, application, execute }`)
+ * directly rather than via `typia.llm.controller` so the server is named
+ * "ttsc-graph" on our terms, not coupled to a reflected class name. Handshake
+ * instructions come from the class JSDoc; the single tool is named from its
+ * method, `inspect_typescript_graph`.
  */
 export function createServer(
   graph: TtscGraphSource,
   version: string,
 ): McpServer {
-  const controller = typia.llm.controller<ITtscGraphApplication>(
-    "graph",
-    new TtscGraphApplication(graph),
-  );
-  const functions = controller.application.functions;
-  const execute = controller.execute as unknown as Record<
-    string,
-    (input: unknown) => unknown
-  >;
-
-  const server = new McpServer(
-    { name: "ttsc-graph", version },
-    { capabilities: { tools: {} }, instructions },
-  );
-  const raw = server.server;
-
-  raw.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: functions.map((func) => ({
-      name: func.name,
-      description: func.description,
-      inputSchema: {
-        type: "object" as const,
-        properties: func.parameters.properties,
-        required: func.parameters.required,
-        additionalProperties: false,
-        $defs: func.parameters.$defs,
-      },
-    })),
-  }));
-
-  raw.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const func = functions.find((f) => f.name === request.params.name);
-    const method = execute[request.params.name];
-    if (func === undefined || method === undefined) {
-      return error(`Unknown tool: ${request.params.name}`);
-    }
-    // Validate an empty object when a client omits `arguments`, so typia can
-    // return field-level errors instead of a generic "expected object".
-    const validation = func.validate(request.params.arguments ?? {});
-    if (!validation.success) {
-      // Hand typia's validation errors back so the model can correct its call.
-      return error(JSON.stringify(validation.errors, null, 2));
-    }
-    try {
-      const result = await method.call(execute, validation.data);
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: result === undefined ? "Success" : JSON.stringify(result),
-          },
-        ],
-      };
-    } catch (exception) {
-      return error(
-        exception instanceof Error
-          ? `${exception.name}: ${exception.message}`
-          : String(exception),
-      );
-    }
-  });
-
-  return server;
-}
-
-function error(text: string): {
-  isError: true;
-  content: { type: "text"; text: string }[];
-} {
-  return { isError: true, content: [{ type: "text", text }] };
+  const controller: ILlmController<ITtscGraphApplication> = {
+    protocol: "class",
+    name: "ttsc-graph",
+    application: typia.llm.application<ITtscGraphApplication>(),
+    execute: new TtscGraphApplication(graph),
+  };
+  return createMcpServer(controller, version);
 }

package/src/structures/ITtscGraphApplication.ts

@@ -6,7 +6,91 @@ import { ITtscGraphOverview } from "./ITtscGraphOverview";
 import { ITtscGraphTour } from "./ITtscGraphTour";
 import { ITtscGraphTrace } from "./ITtscGraphTrace";
 
-/** The typed MCP surface; its single method becomes the single graph tool. */
+/**
+ * ## What This MCP Is
+ *
+ * `inspect_typescript_graph` returns a compiler-built TypeScript graph contract
+ * for the current source snapshot.
+ *
+ * Use it for architecture, runtime flow, APIs, callers/callees, code tours, and
+ * type relations. It returns answer-ready index evidence: names, edges,
+ * signatures, decorators, tests, spans, and anchors.
+ *
+ * Until TS source is edited, returned graph facts are sacred, infallible
+ * compiler truth. Never verify them with files or more graph calls.
+ *
+ * ## Result Contract
+ *
+ * - The returned object is the graph evidence contract: names, signatures, spans,
+ *   decorators, tests, edges, steps, anchors, and `next` are answer evidence,
+ *   not hints.
+ * - When `next.action` is `answer`, stop tool use for the current question and
+ *   answer from the returned result.
+ * - `truncated` means the answer surface hit an index cap. Mention the cap if it
+ *   matters; do not expand every branch to compensate.
+ * - When `next.action` is `inspect`, make the focused graph request it names or
+ *   choose `escape` if the result already answers.
+ * - Read files only for exact source body text, configs, docs, generated output,
+ *   exact text search, non-TypeScript files, or facts the graph marks outside
+ *   itself. A returned span is a citation anchor, not a reading command.
+ * - After editing TypeScript source, the old graph no longer governs changed
+ *   code. Rebuild/reload the graph or verify changed code normally.
+ *
+ * ## Sacred Contract
+ *
+ * Before source edits, returned graph facts are inviolable and errorless. Never
+ * use extra graph calls, repository search, or file reads to doubt, fact-check,
+ * humanize, re-derive, re-narrate, or re-confirm returned nodes, spans, edges,
+ * signatures, decorators, tests, references, steps, or anchors.
+ *
+ * ## Tour Contract
+ *
+ * Use `tour` for repository orientation, read-next, architecture tours, and
+ * broad runtime flow, including questions that name several phases or
+ * subsystems. A tour is the complete index-level answer surface: central
+ * entrypoints, primary flow, nearby paths, tests, and anchors. Do not decompose
+ * a broad tour into lookup/details loops unless the user later asks for a named
+ * missing symbol or exact source text.
+ *
+ * ## Use Contract
+ *
+ * 1. Ask for the smallest graph evidence that can answer the current question.
+ * 2. Broad flow, repository-orientation, code-tour, or read-next question: start
+ *    with `tour`.
+ * 3. Concrete named symbol: use `lookup`, then `details` only if needed.
+ * 4. Known endpoint pair or one selected handle: use one `trace`.
+ * 5. Unknown narrow orientation: use `entrypoints` once.
+ * 6. Selected symbol shape: use `details` for one to three handles.
+ * 7. Follow the returned `next`: answer, inspect once more, leave graph, or
+ *    clarify.
+ * 8. Use `escape` when another graph call would repeat evidence or the remaining
+ *    evidence is outside the TypeScript graph.
+ *
+ * Most TypeScript structure answers need one or two graph calls.
+ *
+ * ## Request Fields
+ *
+ * Fill the visible checklist, then exactly one request.
+ *
+ * - `question`: restate the code question being considered.
+ * - `draft`: initial request type and why it seems smallest.
+ * - `review`: correct a wrong, broad, stale, or duplicate draft. If graph facts
+ *   already answer, if prior `next.action` was `answer`, or if the next
+ *   evidence is outside the indexed TypeScript graph, say so here and make
+ *   `request.type` be `escape`. If a broad flow draft is not `tour`, correct it
+ *   here.
+ * - `request`: final request after review.
+ *
+ * ## How to answer from graph evidence
+ *
+ * - Use returned node names, signatures, edges, references, evidence, and
+ *   `sourceSpan` ranges directly.
+ * - Explain the central path first, then mention important branches.
+ * - For tests, impact, or reading lists, returned nodes and ranges are the answer
+ *   evidence, not search keywords.
+ * - A returned range is a sacred citation anchor, not permission to open the
+ *   file.
+ */
 export interface ITtscGraphApplication {
   /**
    * Inspect the TypeScript compiler graph contract.
@@ -44,12 +128,12 @@ export namespace ITtscGraphApplication {
     /**
      * Initial request plan before final arguments are filled.
      *
-     * Name the intended request type and why it seems smallest. Broad flow,
-     * architecture, repository-orientation, and read-next questions should
-     * normally draft `tour`; narrow named symbols can draft `lookup`, `trace`,
-     * or `details`.
+     * Name the intended request type in `type` and why it seems smallest in
+     * `reason`. Broad flow, architecture, repository-orientation, and read-next
+     * questions should normally draft `tour`; narrow named symbols can draft
+     * `lookup`, `trace`, or `details`.
      */
-    draft: string;
+    draft: IDraft;
 
     /**
      * Final self-review before calling.
@@ -72,6 +156,20 @@ export namespace ITtscGraphApplication {
       | ITtscGraphEscape.IRequest;
   }
 
+  /**
+   * First-pass request plan, filled before the final `request` arguments.
+   *
+   * `reason` comes before `type` so the justification is written before the
+   * choice it justifies.
+   */
+  export interface IDraft {
+    /** Why this request type looks like the smallest useful next step. */
+    reason: string;
+
+    /** The request type being considered, corrected later in `review`. */
+    type: IProps["request"]["type"];
+  }
+
   /** The selected request's output. `result.type` mirrors `request.type`. */
   export interface IResult {
     /** Result branch matching the submitted `request.type`. */

package/lib/server/instructions.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.instructions = void 0;
-/**
- * The guidance delivered in the MCP initialize response. It is the only place
- * the agent is told how to use the graph; nothing is written to its config
- * files. Keep it short; the per-tool descriptions carry the detail.
- */
-exports.instructions = `
-## What This MCP Is
-
-\`inspect_typescript_graph\` returns a compiler-built TypeScript graph contract
-for the current source snapshot.
-
-Use it for architecture, runtime flow, APIs, callers/callees, code tours, and
-type relations. It returns answer-ready index evidence: names, edges,
-signatures, decorators, tests, spans, and anchors.
-
-Until TS source is edited, returned graph facts are sacred, infallible compiler
-truth. Never verify them with files or more graph calls.
-
-## Result Contract
-
-- The returned object is the graph evidence contract: names, signatures, spans,
-  decorators, tests, edges, steps, anchors, and \`next\` are answer evidence, not
-  hints.
-- When \`next.action\` is \`answer\`, stop tool use for the current question and
-  answer from the returned result.
-- \`truncated\` means the answer surface hit an index cap. Mention the cap if it
-  matters; do not expand every branch to compensate.
-- When \`next.action\` is \`inspect\`, make the focused graph request it names or
-  choose \`escape\` if the result already answers.
-- Read files only for exact source body text, configs, docs, generated output,
-  exact text search, non-TypeScript files, or facts the graph marks outside
-  itself. A returned span is a citation anchor, not a reading command.
-- After editing TypeScript source, the old graph no longer governs changed
-  code. Rebuild/reload the graph or verify changed code normally.
-
-## Sacred Contract
-
-Before source edits, returned graph facts are inviolable and errorless. Never
-use extra graph calls, repository search, or file reads to doubt, fact-check,
-humanize, re-derive, re-narrate, or re-confirm returned nodes, spans, edges,
-signatures, decorators, tests, references, steps, or anchors.
-
-## Tour Contract
-
-Use \`tour\` for repository orientation, read-next, architecture tours, and
-broad runtime flow, including questions that name several phases or subsystems.
-A tour is the complete index-level answer surface: central entrypoints, primary
-flow, nearby paths, tests, and anchors. Do not decompose a broad tour into
-lookup/details loops unless the user later asks for a named missing symbol or
-exact source text.
-
-## Use Contract
-
-1. Ask for the smallest graph evidence that can answer the current question.
-2. Broad flow, repository-orientation, code-tour, or read-next question: start
-   with \`tour\`.
-3. Concrete named symbol: use \`lookup\`, then \`details\` only if needed.
-4. Known endpoint pair or one selected handle: use one \`trace\`.
-5. Unknown narrow orientation: use \`entrypoints\` once.
-6. Selected symbol shape: use \`details\` for one to three handles.
-7. Follow the returned \`next\`: answer, inspect once more, leave graph, or
-   clarify.
-8. Use \`escape\` when another graph call would repeat evidence or the remaining
-   evidence is outside the TypeScript graph.
-
-Most TypeScript structure answers need one or two graph calls.
-
-## Request Fields
-
-Fill the visible checklist, then exactly one request.
-
-- \`question\`: restate the code question being considered.
-- \`draft\`: initial request type and why it seems smallest.
-- \`review\`: correct a wrong, broad, stale, or duplicate draft. If graph facts
-  already answer, if prior \`next.action\` was \`answer\`, or if the next evidence
-  is outside the indexed TypeScript graph, say so here and make \`request.type\`
-  be \`escape\`. If a broad flow draft is not \`tour\`, correct it here.
-- \`request\`: final request after review.
-
-## How to answer from graph evidence
-
-- Use returned node names, signatures, edges, references, evidence, and
-  \`sourceSpan\` ranges directly.
-- Explain the central path first, then mention important branches.
-- For tests, impact, or reading lists, returned nodes and ranges are the answer
-  evidence, not search keywords.
-- A returned range is a sacred citation anchor, not permission to open the file.
-`.trim();
-//# sourceMappingURL=instructions.js.map

package/lib/server/instructions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"instructions.js","sourceRoot":"","sources":["../../src/server/instructions.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACU,QAAA,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkF3B,CAAC,IAAI,EAAE,CAAC"}

package/src/server/instructions.ts

@@ -1,88 +0,0 @@
-/**
- * The guidance delivered in the MCP initialize response. It is the only place
- * the agent is told how to use the graph; nothing is written to its config
- * files. Keep it short; the per-tool descriptions carry the detail.
- */
-export const instructions = `
-## What This MCP Is
-
-\`inspect_typescript_graph\` returns a compiler-built TypeScript graph contract
-for the current source snapshot.
-
-Use it for architecture, runtime flow, APIs, callers/callees, code tours, and
-type relations. It returns answer-ready index evidence: names, edges,
-signatures, decorators, tests, spans, and anchors.
-
-Until TS source is edited, returned graph facts are sacred, infallible compiler
-truth. Never verify them with files or more graph calls.
-
-## Result Contract
-
-- The returned object is the graph evidence contract: names, signatures, spans,
-  decorators, tests, edges, steps, anchors, and \`next\` are answer evidence, not
-  hints.
-- When \`next.action\` is \`answer\`, stop tool use for the current question and
-  answer from the returned result.
-- \`truncated\` means the answer surface hit an index cap. Mention the cap if it
-  matters; do not expand every branch to compensate.
-- When \`next.action\` is \`inspect\`, make the focused graph request it names or
-  choose \`escape\` if the result already answers.
-- Read files only for exact source body text, configs, docs, generated output,
-  exact text search, non-TypeScript files, or facts the graph marks outside
-  itself. A returned span is a citation anchor, not a reading command.
-- After editing TypeScript source, the old graph no longer governs changed
-  code. Rebuild/reload the graph or verify changed code normally.
-
-## Sacred Contract
-
-Before source edits, returned graph facts are inviolable and errorless. Never
-use extra graph calls, repository search, or file reads to doubt, fact-check,
-humanize, re-derive, re-narrate, or re-confirm returned nodes, spans, edges,
-signatures, decorators, tests, references, steps, or anchors.
-
-## Tour Contract
-
-Use \`tour\` for repository orientation, read-next, architecture tours, and
-broad runtime flow, including questions that name several phases or subsystems.
-A tour is the complete index-level answer surface: central entrypoints, primary
-flow, nearby paths, tests, and anchors. Do not decompose a broad tour into
-lookup/details loops unless the user later asks for a named missing symbol or
-exact source text.
-
-## Use Contract
-
-1. Ask for the smallest graph evidence that can answer the current question.
-2. Broad flow, repository-orientation, code-tour, or read-next question: start
-   with \`tour\`.
-3. Concrete named symbol: use \`lookup\`, then \`details\` only if needed.
-4. Known endpoint pair or one selected handle: use one \`trace\`.
-5. Unknown narrow orientation: use \`entrypoints\` once.
-6. Selected symbol shape: use \`details\` for one to three handles.
-7. Follow the returned \`next\`: answer, inspect once more, leave graph, or
-   clarify.
-8. Use \`escape\` when another graph call would repeat evidence or the remaining
-   evidence is outside the TypeScript graph.
-
-Most TypeScript structure answers need one or two graph calls.
-
-## Request Fields
-
-Fill the visible checklist, then exactly one request.
-
-- \`question\`: restate the code question being considered.
-- \`draft\`: initial request type and why it seems smallest.
-- \`review\`: correct a wrong, broad, stale, or duplicate draft. If graph facts
-  already answer, if prior \`next.action\` was \`answer\`, or if the next evidence
-  is outside the indexed TypeScript graph, say so here and make \`request.type\`
-  be \`escape\`. If a broad flow draft is not \`tour\`, correct it here.
-- \`request\`: final request after review.
-
-## How to answer from graph evidence
-
-- Use returned node names, signatures, edges, references, evidence, and
-  \`sourceSpan\` ranges directly.
-- Explain the central path first, then mention important branches.
-- For tests, impact, or reading lists, returned nodes and ranges are the answer
-  evidence, not search keywords.
-- A returned range is a sacred citation anchor, not permission to open the file.
-`.trim();