@ttsc/graph 0.16.4 → 0.16.5

package/lib/server/createServer.js

@@ -0,0 +1,1227 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = createServer;
+const _a = __importStar(require("typia/lib/internal/_llmApplicationFinalize"));
+const _b = __importStar(require("typia/lib/internal/_validateReport"));
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const typia_1 = __importDefault(require("typia"));
+const TtscGraphApplication_1 = require("../TtscGraphApplication");
+const instructions_1 = require("./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.
+ *
+ * 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.
+ */
+function createServer(graph, version) {
+    const controller = {
+        "protocol": "class",
+        "name": "graph",
+        "execute": new TtscGraphApplication_1.TtscGraphApplication(graph),
+        "application": _a._llmApplicationFinalize({
+            functions: [
+                {
+                    description: "The first source-free index for a code question: ranked symbols, exact code\nhandles mentioned in the query, declaration signatures, and direct\ndependency context. Use this before reading source.",
+                    name: "graph_index",
+                    output: {
+                        type: "object",
+                        properties: {
+                            hits: {
+                                type: "array",
+                                items: {
+                                    $ref: "#/$defs/ITtscGraphIndex.IHit"
+                                },
+                                description: "Ranked symbols relevant to the query."
+                            },
+                            mentions: {
+                                type: "array",
+                                items: {
+                                    $ref: "#/$defs/ITtscGraphIndex.IMention"
+                                },
+                                description: "Code handles written directly in the query, resolved when possible."
+                            },
+                            neighborhood: {
+                                type: "array",
+                                items: {
+                                    $ref: "#/$defs/ITtscGraphIndex.INeighborhood"
+                                },
+                                description: "Direct dependency context for the resolved mentions and highest hits."
+                            },
+                            next: {
+                                $ref: "#/$defs/ITtscGraphIndex.INext",
+                                description: "Follow-up handles for deeper graph calls."
+                            },
+                            query: {
+                                type: "string",
+                                description: "The original query the index was built for."
+                            },
+                            truncated: {
+                                type: "boolean",
+                                description: "True when result caps hid additional seeds or references."
+                            }
+                        },
+                        required: [
+                            "query",
+                            "hits",
+                            "mentions",
+                            "neighborhood",
+                            "next"
+                        ],
+                        additionalProperties: false,
+                        $defs: {
+                            "ITtscGraphIndex.IHit": {
+                                type: "object",
+                                properties: {
+                                    file: {
+                                        type: "string"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    score: {
+                                        type: "number",
+                                        description: "Relative relevance; higher is a better match."
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "Declaration head, included only for indexed symbols."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file",
+                                    "score"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphIndex.IMention": {
+                                type: "object",
+                                properties: {
+                                    candidates: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphIndex.INode"
+                                        }
+                                    },
+                                    handle: {
+                                        type: "string"
+                                    },
+                                    node: {
+                                        $ref: "#/$defs/ITtscGraphIndex.INode"
+                                    }
+                                },
+                                required: [
+                                    "handle"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphIndex.INeighborhood": {
+                                type: "object",
+                                properties: {
+                                    dependedOnBy: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphIndex.IReference"
+                                        }
+                                    },
+                                    dependsOn: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphIndex.IReference"
+                                        }
+                                    },
+                                    file: {
+                                        type: "string"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "Declaration head, included only for indexed symbols."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file",
+                                    "dependsOn",
+                                    "dependedOnBy"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphIndex.INext": {
+                                type: "object",
+                                properties: {
+                                    expand: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Pass these ids to `graph_expand`, with `source: true` only when needed."
+                                    },
+                                    traceFrom: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Pass these ids to `graph_trace` when following dependency flow."
+                                    }
+                                },
+                                required: [
+                                    "expand",
+                                    "traceFrom"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphIndex.INode": {
+                                type: "object",
+                                properties: {
+                                    file: {
+                                        type: "string"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "Declaration head, included only for indexed symbols."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphIndex.IReference": {
+                                type: "object",
+                                properties: {
+                                    file: {
+                                        type: "string"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    relation: {
+                                        type: "string"
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file",
+                                    "relation"
+                                ],
+                                additionalProperties: false
+                            }
+                        }
+                    },
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            limit: {
+                                type: "number",
+                                description: "Maximum ranked hits to return."
+                            },
+                            neighbors: {
+                                type: "number",
+                                description: "Maximum direct dependencies and dependents to return per indexed symbol."
+                            },
+                            query: {
+                                type: "string",
+                                description: "A natural code question or search phrase. Mix prose with code handles,\nfor example `how Repository.find loads relations` or\n`SelectQueryBuilder.setFindOptions join aliases`."
+                            }
+                        },
+                        required: [
+                            "query"
+                        ],
+                        additionalProperties: false,
+                        $defs: {}
+                    },
+                    validate: (() => {
+                        const _io0 = input => "string" === typeof input.query && (undefined === input.limit || "number" === typeof input.limit) && (undefined === input.neighbors || "number" === typeof input.neighbors);
+                        const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.query || _report(_exceptionable, {
+                                path: _path + ".query",
+                                expected: "string",
+                                value: input.query
+                            }), undefined === input.limit || "number" === typeof input.limit || _report(_exceptionable, {
+                                path: _path + ".limit",
+                                expected: "(number | undefined)",
+                                value: input.limit
+                            }), undefined === input.neighbors || "number" === typeof input.neighbors || _report(_exceptionable, {
+                                path: _path + ".neighbors",
+                                expected: "(number | undefined)",
+                                value: input.neighbors
+                            })].every(flag => flag);
+                        const __is = input => "object" === typeof input && null !== input && _io0(input);
+                        let errors;
+                        let _report;
+                        return input => {
+                            if (false === __is(input)) {
+                                errors = [];
+                                _report = _b._validateReport(errors);
+                                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                    path: _path + "",
+                                    expected: "ITtscGraphIndex.IProps",
+                                    value: input
+                                })) && _vo0(input, _path + "", true) || _report(true, {
+                                    path: _path + "",
+                                    expected: "ITtscGraphIndex.IProps",
+                                    value: input
+                                }))(input, "$input", true);
+                                const success = 0 === errors.length;
+                                return success ? {
+                                    success,
+                                    data: input
+                                } : {
+                                    success,
+                                    errors,
+                                    data: input
+                                };
+                            }
+                            return {
+                                success: true,
+                                data: input
+                            };
+                        };
+                    })()
+                },
+                {
+                    description: "The project's architecture \u2014 folder layers, dependency hotspots, and the\npublic API. Call first to orient on an unfamiliar codebase.",
+                    name: "graph_overview",
+                    output: {
+                        type: "object",
+                        properties: {
+                            counts: {
+                                $ref: "#/$defs/ITtscGraphOverview.ICounts",
+                                description: "Size of the graph."
+                            },
+                            hotspots: {
+                                type: "array",
+                                items: {
+                                    $ref: "#/$defs/ITtscGraphOverview.IHotspot"
+                                },
+                                description: "Highest-dependency symbols, busiest first."
+                            },
+                            layers: {
+                                type: "array",
+                                items: {
+                                    $ref: "#/$defs/ITtscGraphOverview.ILayer"
+                                },
+                                description: "Folder layering, largest first."
+                            },
+                            project: {
+                                type: "string",
+                                description: "Absolute project root."
+                            },
+                            publicApi: {
+                                type: "array",
+                                items: {
+                                    $ref: "#/$defs/ITtscGraphOverview.IPublicApi"
+                                },
+                                description: "Exported API symbols, most-depended-on first."
+                            }
+                        },
+                        required: [
+                            "project",
+                            "counts"
+                        ],
+                        additionalProperties: false,
+                        $defs: {
+                            "ITtscGraphOverview.ICounts": {
+                                type: "object",
+                                properties: {
+                                    byKind: {
+                                        $ref: "#/$defs/Recordstringnumber",
+                                        description: "Node count per kind."
+                                    },
+                                    edges: {
+                                        type: "number"
+                                    },
+                                    files: {
+                                        type: "number"
+                                    },
+                                    nodes: {
+                                        type: "number"
+                                    }
+                                },
+                                required: [
+                                    "files",
+                                    "nodes",
+                                    "edges",
+                                    "byKind"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphOverview.IHotspot": {
+                                type: "object",
+                                properties: {
+                                    fanIn: {
+                                        type: "number",
+                                        description: "Non-structural edges pointing at this symbol."
+                                    },
+                                    fanOut: {
+                                        type: "number",
+                                        description: "Non-structural edges leaving this symbol."
+                                    },
+                                    file: {
+                                        type: "string"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    name: {
+                                        type: "string"
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file",
+                                    "fanIn",
+                                    "fanOut"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphOverview.ILayer": {
+                                type: "object",
+                                properties: {
+                                    dir: {
+                                        type: "string",
+                                        description: "Directory, project-relative."
+                                    },
+                                    exported: {
+                                        type: "number",
+                                        description: "Exported symbols declared under it."
+                                    },
+                                    files: {
+                                        type: "number",
+                                        description: "Distinct source files under it."
+                                    }
+                                },
+                                required: [
+                                    "dir",
+                                    "files",
+                                    "exported"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphOverview.IPublicApi": {
+                                type: "object",
+                                properties: {
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the file that declares it."
+                                    },
+                                    kind: {
+                                        type: "string",
+                                        description: "Its declaration kind (`class`, `interface`, `function`, \u2026)."
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "The exported symbol's name."
+                                    }
+                                },
+                                required: [
+                                    "name",
+                                    "kind",
+                                    "file"
+                                ],
+                                additionalProperties: false
+                            },
+                            Recordstringnumber: {
+                                type: "object",
+                                properties: {},
+                                required: [],
+                                additionalProperties: {
+                                    type: "number"
+                                }
+                            }
+                        }
+                    },
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            aspect: {
+                                type: "string",
+                                "enum": [
+                                    "all",
+                                    "hotspots",
+                                    "layers",
+                                    "publicApi"
+                                ],
+                                description: "The facet to project, or `all` for every facet. `layers` is the folder\nlayering, `hotspots` the highest-dependency symbols, `publicApi` the\nexported API symbols ranked by how depended-on they are."
+                            }
+                        },
+                        required: [],
+                        additionalProperties: false,
+                        $defs: {}
+                    },
+                    validate: (() => {
+                        const _io0 = input => undefined === input.aspect || "all" === input.aspect || "hotspots" === input.aspect || "layers" === input.aspect || "publicApi" === input.aspect;
+                        const _vo0 = (input, _path, _exceptionable = true) => [undefined === input.aspect || "all" === input.aspect || "hotspots" === input.aspect || "layers" === input.aspect || "publicApi" === input.aspect || _report(_exceptionable, {
+                                path: _path + ".aspect",
+                                expected: "(\"all\" | \"hotspots\" | \"layers\" | \"publicApi\" | undefined)",
+                                value: input.aspect
+                            })].every(flag => flag);
+                        const __is = input => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input);
+                        let errors;
+                        let _report;
+                        return input => {
+                            if (false === __is(input)) {
+                                errors = [];
+                                _report = _b._validateReport(errors);
+                                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input && false === Array.isArray(input) || _report(true, {
+                                    path: _path + "",
+                                    expected: "ITtscGraphOverview.IProps",
+                                    value: input
+                                })) && _vo0(input, _path + "", true) || _report(true, {
+                                    path: _path + "",
+                                    expected: "ITtscGraphOverview.IProps",
+                                    value: input
+                                }))(input, "$input", true);
+                                const success = 0 === errors.length;
+                                return success ? {
+                                    success,
+                                    data: input
+                                } : {
+                                    success,
+                                    errors,
+                                    data: input
+                                };
+                            }
+                            return {
+                                success: true,
+                                data: input
+                            };
+                        };
+                    })()
+                },
+                {
+                    description: "The declared shape of the given symbols: each one's signature, and for a\nclass/interface/namespace its members. Handles may be ids or dotted symbol\nnames. Set `source: true` to also read a specific body, `neighbors: true`\nto list what it uses and what uses it.",
+                    name: "graph_expand",
+                    output: {
+                        type: "object",
+                        properties: {
+                            nodes: {
+                                type: "array",
+                                items: {
+                                    $ref: "#/$defs/ITtscGraphExpand.INode"
+                                }
+                            },
+                            unknown: {
+                                type: "array",
+                                items: {
+                                    type: "string"
+                                },
+                                description: "Handles that resolved to no node, or that were ambiguous."
+                            }
+                        },
+                        required: [
+                            "nodes",
+                            "unknown"
+                        ],
+                        additionalProperties: false,
+                        $defs: {
+                            "ITtscGraphExpand.IMember": {
+                                type: "object",
+                                properties: {
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "The member's declaration signature."
+                                    }
+                                },
+                                required: [
+                                    "name",
+                                    "kind"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphExpand.INode": {
+                                type: "object",
+                                properties: {
+                                    dependedOnBy: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphExpand.IReference"
+                                        },
+                                        description: "Symbols that use this node (incoming dependency edges)."
+                                    },
+                                    dependsOn: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphExpand.IReference"
+                                        },
+                                        description: "Symbols this node uses (outgoing dependency edges)."
+                                    },
+                                    file: {
+                                        type: "string"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    members: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphExpand.IMember"
+                                        },
+                                        description: "For a class, interface, namespace, module, enum, or file: the symbols it\ncontains, each with its own signature \u2014 the member outline a consumer\nreaches for, without the bodies."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "The declaration signature \u2014 its first line(s) up to the body."
+                                    },
+                                    source: {
+                                        type: "string",
+                                        description: "The full declaration source \u2014 only when `source` was requested."
+                                    },
+                                    truncated: {
+                                        type: "boolean",
+                                        description: "True when `source` was cut at the line cap."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphExpand.IReference": {
+                                type: "object",
+                                properties: {
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    relation: {
+                                        type: "string",
+                                        description: "The edge kind connecting the two (`calls`, `type_ref`, \u2026)."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "relation"
+                                ],
+                                additionalProperties: false
+                            }
+                        }
+                    },
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            handles: {
+                                type: "array",
+                                items: {
+                                    type: "string"
+                                },
+                                description: "Node ids from another tool, or dotted symbol handles such as\n`OrderService.create`. Pass every handle you need in one call."
+                            },
+                            neighbors: {
+                                type: "boolean",
+                                description: "Also list each node's direct dependencies and dependents (the symbols it\nuses and the symbols that use it)."
+                            },
+                            source: {
+                                type: "boolean",
+                                description: "Return the full declaration source body too. Off by default: expand\nreturns the declared shape \u2014 a symbol's signature, and a class/interface/\nnamespace's member outline \u2014 which is what you usually need and a\nfraction of the tokens. Turn this on only for the few leaf functions or\nmethods whose actual control-flow logic you must read."
+                            }
+                        },
+                        required: [
+                            "handles"
+                        ],
+                        additionalProperties: false,
+                        $defs: {}
+                    },
+                    validate: (() => {
+                        const _io0 = input => Array.isArray(input.handles) && input.handles.every(elem => "string" === typeof elem) && (undefined === input.neighbors || "boolean" === typeof input.neighbors) && (undefined === input.source || "boolean" === typeof input.source);
+                        const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.handles) || _report(_exceptionable, {
+                                path: _path + ".handles",
+                                expected: "Array<string>",
+                                value: input.handles
+                            })) && input.handles.map((elem, _index2) => "string" === typeof elem || _report(_exceptionable, {
+                                path: _path + ".handles[" + _index2 + "]",
+                                expected: "string",
+                                value: elem
+                            })).every(flag => flag) || _report(_exceptionable, {
+                                path: _path + ".handles",
+                                expected: "Array<string>",
+                                value: input.handles
+                            }), undefined === input.neighbors || "boolean" === typeof input.neighbors || _report(_exceptionable, {
+                                path: _path + ".neighbors",
+                                expected: "(boolean | undefined)",
+                                value: input.neighbors
+                            }), undefined === input.source || "boolean" === typeof input.source || _report(_exceptionable, {
+                                path: _path + ".source",
+                                expected: "(boolean | undefined)",
+                                value: input.source
+                            })].every(flag => flag);
+                        const __is = input => "object" === typeof input && null !== input && _io0(input);
+                        let errors;
+                        let _report;
+                        return input => {
+                            if (false === __is(input)) {
+                                errors = [];
+                                _report = _b._validateReport(errors);
+                                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                    path: _path + "",
+                                    expected: "ITtscGraphExpand.IProps",
+                                    value: input
+                                })) && _vo0(input, _path + "", true) || _report(true, {
+                                    path: _path + "",
+                                    expected: "ITtscGraphExpand.IProps",
+                                    value: input
+                                }))(input, "$input", true);
+                                const success = 0 === errors.length;
+                                return success ? {
+                                    success,
+                                    data: input
+                                } : {
+                                    success,
+                                    errors,
+                                    data: input
+                                };
+                            }
+                            return {
+                                success: true,
+                                data: input
+                            };
+                        };
+                    })()
+                },
+                {
+                    description: "Find any symbol \u2014 class, function, method, or field \u2014 by name or\ndescription. Each hit comes with its signature, so the query alone often\nanswers the question, and `next.expand` gives handles for source\nfollow-up.",
+                    name: "graph_query",
+                    output: {
+                        type: "object",
+                        properties: {
+                            hits: {
+                                type: "array",
+                                items: {
+                                    $ref: "#/$defs/ITtscGraphQuery.IHit"
+                                }
+                            },
+                            next: {
+                                $ref: "#/$defs/ITtscGraphQuery.INext",
+                                description: "Follow-up handles for source or member details."
+                            }
+                        },
+                        required: [
+                            "hits",
+                            "next"
+                        ],
+                        additionalProperties: false,
+                        $defs: {
+                            "ITtscGraphQuery.IHit": {
+                                type: "object",
+                                properties: {
+                                    file: {
+                                        type: "string"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    score: {
+                                        type: "number",
+                                        description: "Relative relevance; higher is a better match."
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "The hit's declaration signature, so you can often answer without\nexpanding."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file",
+                                    "score"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphQuery.INext": {
+                                type: "object",
+                                properties: {
+                                    expand: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Pass these ids to `graph_expand`, with `source: true` only when needed."
+                                    }
+                                },
+                                required: [
+                                    "expand"
+                                ],
+                                additionalProperties: false
+                            }
+                        }
+                    },
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            limit: {
+                                type: "number",
+                                description: "Maximum hits to return."
+                            },
+                            query: {
+                                type: "string",
+                                description: "What to find, in natural language and code vocabulary mixed freely \u2014 a\nsymbol name, a dotted member (`OrderService.create`), or a phrase\n(`shopping order create`, `repository find relations`). Exact names are\nnot required; subword and CamelCase matches rank too."
+                            }
+                        },
+                        required: [
+                            "query"
+                        ],
+                        additionalProperties: false,
+                        $defs: {}
+                    },
+                    validate: (() => {
+                        const _io0 = input => "string" === typeof input.query && (undefined === input.limit || "number" === typeof input.limit);
+                        const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.query || _report(_exceptionable, {
+                                path: _path + ".query",
+                                expected: "string",
+                                value: input.query
+                            }), undefined === input.limit || "number" === typeof input.limit || _report(_exceptionable, {
+                                path: _path + ".limit",
+                                expected: "(number | undefined)",
+                                value: input.limit
+                            })].every(flag => flag);
+                        const __is = input => "object" === typeof input && null !== input && _io0(input);
+                        let errors;
+                        let _report;
+                        return input => {
+                            if (false === __is(input)) {
+                                errors = [];
+                                _report = _b._validateReport(errors);
+                                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                    path: _path + "",
+                                    expected: "ITtscGraphQuery.IProps",
+                                    value: input
+                                })) && _vo0(input, _path + "", true) || _report(true, {
+                                    path: _path + "",
+                                    expected: "ITtscGraphQuery.IProps",
+                                    value: input
+                                }))(input, "$input", true);
+                                const success = 0 === errors.length;
+                                return success ? {
+                                    success,
+                                    data: input
+                                } : {
+                                    success,
+                                    errors,
+                                    data: input
+                                };
+                            }
+                            return {
+                                success: true,
+                                data: input
+                            };
+                        };
+                    })()
+                },
+                {
+                    description: "Follow dependency flow from a symbol: `forward` to what it uses, `reverse`\nto what uses it, or `impact` to the public API and tests a change reaches.\nGive `from`/`to` as ids or dotted names to get the path between two symbols\nin one call \u2014 how A reaches B.",
+                    name: "graph_trace",
+                    output: {
+                        type: "object",
+                        properties: {
+                            candidates: {
+                                type: "array",
+                                items: {
+                                    $ref: "#/$defs/ITtscGraphTrace.INode"
+                                },
+                                description: "When `from` was an ambiguous name, the matches to disambiguate with."
+                            },
+                            direction: {
+                                type: "string"
+                            },
+                            hops: {
+                                type: "array",
+                                items: {
+                                    $ref: "#/$defs/ITtscGraphTrace.IHop"
+                                },
+                                description: "Edges traversed, in breadth-first order."
+                            },
+                            path: {
+                                type: "array",
+                                items: {
+                                    $ref: "#/$defs/ITtscGraphTrace.INode"
+                                },
+                                description: "When `to` was given: the ordered dependency path from `from` to `to`\n(`from` first, `to` last), or empty when `to` is not reachable from\n`from`."
+                            },
+                            reached: {
+                                type: "array",
+                                items: {
+                                    $ref: "#/$defs/ITtscGraphTrace.INode"
+                                },
+                                description: "Unique nodes reached (excluding the start), each with its depth and roles."
+                            },
+                            start: {
+                                $ref: "#/$defs/ITtscGraphTrace.INode",
+                                description: "The resolved start node, or undefined when `from` matched nothing."
+                            },
+                            target: {
+                                $ref: "#/$defs/ITtscGraphTrace.INode",
+                                description: "The resolved `to` target, when a path was requested."
+                            },
+                            truncated: {
+                                type: "boolean",
+                                description: "True when the trace hit maxNodes or maxDepth and more flow exists."
+                            }
+                        },
+                        required: [
+                            "direction",
+                            "hops",
+                            "reached",
+                            "truncated"
+                        ],
+                        additionalProperties: false,
+                        $defs: {
+                            "ITtscGraphTrace.IHop": {
+                                type: "object",
+                                properties: {
+                                    depth: {
+                                        type: "number",
+                                        description: "Hops from the start (1 = direct)."
+                                    },
+                                    from: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    to: {
+                                        type: "string"
+                                    }
+                                },
+                                required: [
+                                    "from",
+                                    "to",
+                                    "kind",
+                                    "depth"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphTrace.INode": {
+                                type: "object",
+                                properties: {
+                                    depth: {
+                                        type: "number",
+                                        description: "Hops from the start, on a reached node."
+                                    },
+                                    file: {
+                                        type: "string"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    roles: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Why this node matters to an impact trace: `exported`, `test`."
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "The node's signature \u2014 carried on path nodes so the path explains itself."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file"
+                                ],
+                                additionalProperties: false
+                            }
+                        }
+                    },
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            direction: {
+                                type: "string",
+                                "enum": [
+                                    "forward",
+                                    "impact",
+                                    "reverse"
+                                ],
+                                description: "`forward` follows what the start uses (callees, instantiations, renders);\n`reverse` follows what uses the start (callers); `impact` is a reverse\ntrace that flags the public API and tests a change would reach."
+                            },
+                            from: {
+                                type: "string",
+                                description: "Where to start: a node id from another tool, a simple symbol name, or a\ndotted member name such as `OrderService.create`. An ambiguous name\nreturns its candidates instead of a trace."
+                            },
+                            maxDepth: {
+                                type: "number",
+                                description: "How many hops deep to follow."
+                            },
+                            maxNodes: {
+                                type: "number",
+                                description: "Cap on reached nodes; the trace stops and marks itself truncated past it."
+                            },
+                            to: {
+                                type: "string",
+                                description: "A target symbol: node id, simple symbol name, or dotted member name. When\ngiven, the tool returns the dependency path from `from` to this target \u2014\nthe one-call answer for \"how does A reach B\" \u2014 instead of an open-ended\ntrace."
+                            }
+                        },
+                        required: [
+                            "from"
+                        ],
+                        additionalProperties: false,
+                        $defs: {}
+                    },
+                    validate: (() => {
+                        const _io0 = input => "string" === typeof input.from && (undefined === input.to || "string" === typeof input.to) && (undefined === input.direction || "forward" === input.direction || "impact" === input.direction || "reverse" === input.direction) && (undefined === input.maxDepth || "number" === typeof input.maxDepth) && (undefined === input.maxNodes || "number" === typeof input.maxNodes);
+                        const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.from || _report(_exceptionable, {
+                                path: _path + ".from",
+                                expected: "string",
+                                value: input.from
+                            }), undefined === input.to || "string" === typeof input.to || _report(_exceptionable, {
+                                path: _path + ".to",
+                                expected: "(string | undefined)",
+                                value: input.to
+                            }), undefined === input.direction || "forward" === input.direction || "impact" === input.direction || "reverse" === input.direction || _report(_exceptionable, {
+                                path: _path + ".direction",
+                                expected: "(\"forward\" | \"impact\" | \"reverse\" | undefined)",
+                                value: input.direction
+                            }), undefined === input.maxDepth || "number" === typeof input.maxDepth || _report(_exceptionable, {
+                                path: _path + ".maxDepth",
+                                expected: "(number | undefined)",
+                                value: input.maxDepth
+                            }), undefined === input.maxNodes || "number" === typeof input.maxNodes || _report(_exceptionable, {
+                                path: _path + ".maxNodes",
+                                expected: "(number | undefined)",
+                                value: input.maxNodes
+                            })].every(flag => flag);
+                        const __is = input => "object" === typeof input && null !== input && _io0(input);
+                        let errors;
+                        let _report;
+                        return input => {
+                            if (false === __is(input)) {
+                                errors = [];
+                                _report = _b._validateReport(errors);
+                                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                    path: _path + "",
+                                    expected: "ITtscGraphTrace.IProps",
+                                    value: input
+                                })) && _vo0(input, _path + "", true) || _report(true, {
+                                    path: _path + "",
+                                    expected: "ITtscGraphTrace.IProps",
+                                    value: input
+                                }))(input, "$input", true);
+                                const success = 0 === errors.length;
+                                return success ? {
+                                    success,
+                                    data: input
+                                } : {
+                                    success,
+                                    errors,
+                                    data: input
+                                };
+                            }
+                            return {
+                                success: true,
+                                data: input
+                            };
+                        };
+                    })()
+                }
+            ]
+        })
+    };
+    const functions = controller.application.functions;
+    const execute = controller.execute;
+    const server = new mcp_js_1.McpServer({ name: "ttsc-graph", version }, { capabilities: { tools: {} }, instructions: instructions_1.instructions });
+    const raw = server.server;
+    raw.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+        tools: functions.map((func) => ({
+            name: func.name,
+            description: func.description,
+            inputSchema: {
+                type: "object",
+                properties: func.parameters.properties,
+                required: func.parameters.required,
+                additionalProperties: false,
+                $defs: func.parameters.$defs,
+            },
+        })),
+    }));
+    raw.setRequestHandler(types_js_1.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}`);
+        }
+        // A client may omit `arguments` for an all-optional tool (e.g. graph_overview);
+        // validate an empty object so that call succeeds instead of failing on "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",
+                        text: result === undefined
+                            ? "Success"
+                            : JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (exception) {
+            return error(exception instanceof Error
+                ? `${exception.name}: ${exception.message}`
+                : String(exception));
+        }
+    });
+    return server;
+}
+function error(text) {
+    return { isError: true, content: [{ type: "text", text }] };
+}
+//# sourceMappingURL=createServer.js.map