@ttsc/graph 0.16.4 → 0.16.5

package/lib/model/loadGraph.js

@@ -0,0 +1,418 @@
+"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.loadGraph = loadGraph;
+const _a = __importStar(require("typia/lib/internal/_assertGuard"));
+const node_child_process_1 = require("node:child_process");
+const typia_1 = __importDefault(require("typia"));
+const resolveGraphBinary_1 = require("../resolveGraphBinary");
+const TtscGraphMemory_1 = require("./TtscGraphMemory");
+// A full-project dump is the whole fact graph as one JSON document; a large
+// monorepo runs to many megabytes, well past spawnSync's 1 MiB default, so the
+// buffer is raised to a ceiling no real graph reaches.
+const MAX_DUMP_BYTES = 1024 * 1024 * 1024;
+/**
+ * Build the resident {@link TtscGraphMemory} for a project by running `ttscgraph
+ * dump` once and loading its JSON. This is the cold path behind the MCP tool
+ * calls: one type-check in Go produces the checker-resolved fact graph, then
+ * every later tool call is answered from the in-memory model.
+ *
+ * Throws when the binary cannot be resolved, the dump command fails, or its
+ * output is not a readable graph — the server surfaces the failure rather than
+ * answering from an empty graph.
+ */
+function loadGraph(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const tsconfig = options.tsconfig ?? "tsconfig.json";
+    const binary = options.binary ?? (0, resolveGraphBinary_1.resolveGraphBinary)();
+    if (binary === null) {
+        throw new Error("@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.");
+    }
+    const result = (0, node_child_process_1.spawnSync)(binary, ["dump", "--cwd", cwd, "--tsconfig", tsconfig], { encoding: "utf8", maxBuffer: MAX_DUMP_BYTES, windowsHide: true });
+    if (result.error) {
+        throw new Error(`@ttsc/graph: ttscgraph dump failed: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        throw new Error(`@ttsc/graph: ttscgraph dump exited with ${result.status}: ${(result.stderr ?? "").trim()}`);
+    }
+    return TtscGraphMemory_1.TtscGraphMemory.from(parseDump(result.stdout));
+}
+/**
+ * Parse and validate `ttscgraph dump` output. typia asserts the full
+ * {@link ITtscGraphDump} shape so a malformed or stale dump fails loudly here
+ * rather than producing wrong answers downstream, and the schema version is
+ * checked so an incompatible producer is refused.
+ */
+function parseDump(json) {
+    let value;
+    try {
+        value = JSON.parse(json);
+    }
+    catch (error) {
+        throw new Error(`@ttsc/graph: dump output is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return (() => {
+        const _iv4 = new Set(["class", "enum", "external_symbol", "file", "function", "interface", "method", "module", "namespace", "package", "parameter", "property", "type", "variable"]);
+        const _iv6 = new Set(["abstract", "async", "const", "declare", "default", "export", "optional", "private", "protected", "public", "readonly", "static"]);
+        const _iv9 = new Set(["accesses", "calls", "contains", "decorates", "exports", "extends", "implements", "imports", "instantiates", "overrides", "renders", "tests", "type_ref"]);
+        const _av13 = new Set(["class", "enum", "external_symbol", "file", "function", "interface", "method", "module", "namespace", "package", "parameter", "property", "type", "variable"]);
+        const _av15 = new Set(["abstract", "async", "const", "declare", "default", "export", "optional", "private", "protected", "public", "readonly", "static"]);
+        const _av18 = new Set(["accesses", "calls", "contains", "decorates", "exports", "extends", "implements", "imports", "instantiates", "overrides", "renders", "tests", "type_ref"]);
+        const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.project || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".project",
+            expected: "string",
+            value: input.project
+        }, _errorFactory)) && ("string" === typeof input.tsconfig || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".tsconfig",
+            expected: "string",
+            value: input.tsconfig
+        }, _errorFactory)) && ((Array.isArray(input.nodes) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".nodes",
+            expected: "Array<ITtscGraphNode>",
+            value: input.nodes
+        }, _errorFactory)) && input.nodes.every((elem, _index10) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".nodes[" + _index10 + "]",
+            expected: "ITtscGraphNode",
+            value: elem
+        }, _errorFactory)) && _ao1(elem, _path + ".nodes[" + _index10 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".nodes[" + _index10 + "]",
+            expected: "ITtscGraphNode",
+            value: elem
+        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".nodes",
+            expected: "Array<ITtscGraphNode>",
+            value: input.nodes
+        }, _errorFactory)) && ((Array.isArray(input.edges) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".edges",
+            expected: "Array<ITtscGraphEdge>",
+            value: input.edges
+        }, _errorFactory)) && input.edges.every((elem, _index11) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".edges[" + _index11 + "]",
+            expected: "ITtscGraphEdge",
+            value: elem
+        }, _errorFactory)) && _ao5(elem, _path + ".edges[" + _index11 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".edges[" + _index11 + "]",
+            expected: "ITtscGraphEdge",
+            value: elem
+        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".edges",
+            expected: "Array<ITtscGraphEdge>",
+            value: input.edges
+        }, _errorFactory)) && (undefined === input.diagnostics || (Array.isArray(input.diagnostics) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".diagnostics",
+            expected: "(Array<ITtscGraphDiagnostic> | undefined)",
+            value: input.diagnostics
+        }, _errorFactory)) && input.diagnostics.every((elem, _index12) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".diagnostics[" + _index12 + "]",
+            expected: "ITtscGraphDiagnostic",
+            value: elem
+        }, _errorFactory)) && _ao6(elem, _path + ".diagnostics[" + _index12 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".diagnostics[" + _index12 + "]",
+            expected: "ITtscGraphDiagnostic",
+            value: elem
+        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".diagnostics",
+            expected: "(Array<ITtscGraphDiagnostic> | undefined)",
+            value: input.diagnostics
+        }, _errorFactory));
+        const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".id",
+            expected: "string",
+            value: input.id
+        }, _errorFactory)) && (true === _av13.has(input.kind) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".kind",
+            expected: "(\"class\" | \"enum\" | \"external_symbol\" | \"file\" | \"function\" | \"interface\" | \"method\" | \"module\" | \"namespace\" | \"package\" | \"parameter\" | \"property\" | \"type\" | \"variable\")",
+            value: input.kind
+        }, _errorFactory)) && ("string" === typeof input.name || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".name",
+            expected: "string",
+            value: input.name
+        }, _errorFactory)) && (undefined === input.qualifiedName || "string" === typeof input.qualifiedName || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".qualifiedName",
+            expected: "(string | undefined)",
+            value: input.qualifiedName
+        }, _errorFactory)) && ("string" === typeof input.file || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".file",
+            expected: "string",
+            value: input.file
+        }, _errorFactory)) && ("boolean" === typeof input.external || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".external",
+            expected: "boolean",
+            value: input.external
+        }, _errorFactory)) && (undefined === input.ignored || "boolean" === typeof input.ignored || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".ignored",
+            expected: "(boolean | undefined)",
+            value: input.ignored
+        }, _errorFactory)) && (undefined === input.exported || "boolean" === typeof input.exported || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".exported",
+            expected: "(boolean | undefined)",
+            value: input.exported
+        }, _errorFactory)) && (undefined === input.modifiers || (Array.isArray(input.modifiers) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".modifiers",
+            expected: "(Array<TtscGraphNodeModifier> | undefined)",
+            value: input.modifiers
+        }, _errorFactory)) && input.modifiers.every((elem, _index14) => true === _av15.has(elem) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".modifiers[" + _index14 + "]",
+            expected: "(\"abstract\" | \"async\" | \"const\" | \"declare\" | \"default\" | \"export\" | \"optional\" | \"private\" | \"protected\" | \"public\" | \"readonly\" | \"static\")",
+            value: elem
+        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".modifiers",
+            expected: "(Array<TtscGraphNodeModifier> | undefined)",
+            value: input.modifiers
+        }, _errorFactory)) && (undefined === input.decorators || (Array.isArray(input.decorators) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".decorators",
+            expected: "(Array<ITtscGraphDecorator> | undefined)",
+            value: input.decorators
+        }, _errorFactory)) && input.decorators.every((elem, _index16) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".decorators[" + _index16 + "]",
+            expected: "ITtscGraphDecorator",
+            value: elem
+        }, _errorFactory)) && _ao2(elem, _path + ".decorators[" + _index16 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".decorators[" + _index16 + "]",
+            expected: "ITtscGraphDecorator",
+            value: elem
+        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".decorators",
+            expected: "(Array<ITtscGraphDecorator> | undefined)",
+            value: input.decorators
+        }, _errorFactory)) && (undefined === input.evidence || ("object" === typeof input.evidence && null !== input.evidence || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".evidence",
+            expected: "(ITtscGraphEvidence | undefined)",
+            value: input.evidence
+        }, _errorFactory)) && _ao4(input.evidence, _path + ".evidence", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".evidence",
+            expected: "(ITtscGraphEvidence | undefined)",
+            value: input.evidence
+        }, _errorFactory));
+        const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.name || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".name",
+            expected: "string",
+            value: input.name
+        }, _errorFactory)) && ((Array.isArray(input.arguments) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".arguments",
+            expected: "Array<ITtscGraphDecorator.IArgument>",
+            value: input.arguments
+        }, _errorFactory)) && input.arguments.every((elem, _index17) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".arguments[" + _index17 + "]",
+            expected: "ITtscGraphDecorator.IArgument",
+            value: elem
+        }, _errorFactory)) && _ao3(elem, _path + ".arguments[" + _index17 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".arguments[" + _index17 + "]",
+            expected: "ITtscGraphDecorator.IArgument",
+            value: elem
+        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".arguments",
+            expected: "Array<ITtscGraphDecorator.IArgument>",
+            value: input.arguments
+        }, _errorFactory));
+        const _ao3 = (input, _path, _exceptionable = true) => ("string" === typeof input.text || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".text",
+            expected: "string",
+            value: input.text
+        }, _errorFactory)) && (undefined === input.literal || "string" === typeof input.literal || "number" === typeof input.literal || "boolean" === typeof input.literal || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".literal",
+            expected: "(boolean | number | string | undefined)",
+            value: input.literal
+        }, _errorFactory));
+        const _ao4 = (input, _path, _exceptionable = true) => ("string" === typeof input.file || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".file",
+            expected: "string",
+            value: input.file
+        }, _errorFactory)) && ("number" === typeof input.startLine || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".startLine",
+            expected: "number",
+            value: input.startLine
+        }, _errorFactory)) && (undefined === input.startCol || "number" === typeof input.startCol || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".startCol",
+            expected: "(number | undefined)",
+            value: input.startCol
+        }, _errorFactory)) && (undefined === input.endLine || "number" === typeof input.endLine || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".endLine",
+            expected: "(number | undefined)",
+            value: input.endLine
+        }, _errorFactory)) && (undefined === input.endCol || "number" === typeof input.endCol || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".endCol",
+            expected: "(number | undefined)",
+            value: input.endCol
+        }, _errorFactory)) && (undefined === input.text || "string" === typeof input.text || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".text",
+            expected: "(string | undefined)",
+            value: input.text
+        }, _errorFactory));
+        const _ao5 = (input, _path, _exceptionable = true) => ("string" === typeof input.from || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".from",
+            expected: "string",
+            value: input.from
+        }, _errorFactory)) && ("string" === typeof input.to || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".to",
+            expected: "string",
+            value: input.to
+        }, _errorFactory)) && (true === _av18.has(input.kind) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".kind",
+            expected: "(\"accesses\" | \"calls\" | \"contains\" | \"decorates\" | \"exports\" | \"extends\" | \"implements\" | \"imports\" | \"instantiates\" | \"overrides\" | \"renders\" | \"tests\" | \"type_ref\")",
+            value: input.kind
+        }, _errorFactory)) && (undefined === input.evidence || ("object" === typeof input.evidence && null !== input.evidence || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".evidence",
+            expected: "(ITtscGraphEvidence | undefined)",
+            value: input.evidence
+        }, _errorFactory)) && _ao4(input.evidence, _path + ".evidence", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".evidence",
+            expected: "(ITtscGraphEvidence | undefined)",
+            value: input.evidence
+        }, _errorFactory));
+        const _ao6 = (input, _path, _exceptionable = true) => ("string" === typeof input.file || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".file",
+            expected: "string",
+            value: input.file
+        }, _errorFactory)) && ("number" === typeof input.line || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".line",
+            expected: "number",
+            value: input.line
+        }, _errorFactory)) && (undefined === input.column || "number" === typeof input.column || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".column",
+            expected: "(number | undefined)",
+            value: input.column
+        }, _errorFactory)) && ("string" === typeof input.code || "number" === typeof input.code || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".code",
+            expected: "(number | string)",
+            value: input.code
+        }, _errorFactory)) && ("string" === typeof input.message || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".message",
+            expected: "string",
+            value: input.message
+        }, _errorFactory)) && (undefined === input.severity || "error" === input.severity || "hint" === input.severity || "info" === input.severity || "warning" === input.severity || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".severity",
+            expected: "(\"error\" | \"hint\" | \"info\" | \"warning\" | undefined)",
+            value: input.severity
+        }, _errorFactory)) && (undefined === input.origin || "lint" === input.origin || "plugin" === input.origin || "tsc" === input.origin || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".origin",
+            expected: "(\"lint\" | \"plugin\" | \"tsc\" | undefined)",
+            value: input.origin
+        }, _errorFactory)) && (undefined === input.node || "string" === typeof input.node || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".node",
+            expected: "(string | undefined)",
+            value: input.node
+        }, _errorFactory));
+        const _io0 = input => "string" === typeof input.project && "string" === typeof input.tsconfig && (Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _io1(elem))) && (Array.isArray(input.edges) && input.edges.every(elem => "object" === typeof elem && null !== elem && _io5(elem))) && (undefined === input.diagnostics || Array.isArray(input.diagnostics) && input.diagnostics.every(elem => "object" === typeof elem && null !== elem && _io6(elem)));
+        const _io1 = input => "string" === typeof input.id && true === _iv4.has(input.kind) && "string" === typeof input.name && (undefined === input.qualifiedName || "string" === typeof input.qualifiedName) && "string" === typeof input.file && "boolean" === typeof input.external && (undefined === input.ignored || "boolean" === typeof input.ignored) && (undefined === input.exported || "boolean" === typeof input.exported) && (undefined === input.modifiers || Array.isArray(input.modifiers) && input.modifiers.every(elem => true === _iv6.has(elem))) && (undefined === input.decorators || Array.isArray(input.decorators) && input.decorators.every(elem => "object" === typeof elem && null !== elem && _io2(elem))) && (undefined === input.evidence || "object" === typeof input.evidence && null !== input.evidence && _io4(input.evidence));
+        const _io2 = input => "string" === typeof input.name && (Array.isArray(input.arguments) && input.arguments.every(elem => "object" === typeof elem && null !== elem && _io3(elem)));
+        const _io3 = input => "string" === typeof input.text && (undefined === input.literal || "string" === typeof input.literal || "number" === typeof input.literal || "boolean" === typeof input.literal);
+        const _io4 = input => "string" === typeof input.file && "number" === typeof input.startLine && (undefined === input.startCol || "number" === typeof input.startCol) && (undefined === input.endLine || "number" === typeof input.endLine) && (undefined === input.endCol || "number" === typeof input.endCol) && (undefined === input.text || "string" === typeof input.text);
+        const _io5 = input => "string" === typeof input.from && "string" === typeof input.to && true === _iv9.has(input.kind) && (undefined === input.evidence || "object" === typeof input.evidence && null !== input.evidence && _io4(input.evidence));
+        const _io6 = input => "string" === typeof input.file && "number" === typeof input.line && (undefined === input.column || "number" === typeof input.column) && ("string" === typeof input.code || "number" === typeof input.code) && "string" === typeof input.message && (undefined === input.severity || "error" === input.severity || "hint" === input.severity || "info" === input.severity || "warning" === input.severity) && (undefined === input.origin || "lint" === input.origin || "plugin" === input.origin || "tsc" === input.origin) && (undefined === input.node || "string" === typeof input.node);
+        const __is = input => "object" === typeof input && null !== input && _io0(input);
+        let _errorFactory;
+        return (input, errorFactory) => {
+            if (false === __is(input)) {
+                _errorFactory = errorFactory;
+                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _a._assertGuard(true, {
+                    method: "typia.assert",
+                    path: _path + "",
+                    expected: "ITtscGraphDump",
+                    value: input
+                }, _errorFactory)) && _ao0(input, _path + "", true) || _a._assertGuard(true, {
+                    method: "typia.assert",
+                    path: _path + "",
+                    expected: "ITtscGraphDump",
+                    value: input
+                }, _errorFactory))(input, "$input", true);
+            }
+            return input;
+        };
+    })()(value);
+}
+//# sourceMappingURL=loadGraph.js.map

package/lib/model/loadGraph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadGraph.js","sourceRoot":"","sources":["../../src/model/loadGraph.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2DAA+C;AAC/C,kDAA0B;AAE1B,8DAA2D;AAE3D,uDAAoD;AAEpD,4EAA4E;AAC5E,+EAA+E;AAC/E,uDAAuD;AACvD,MAAM,cAAc,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAE1C;;;;;;;;;GASG;AACH,mBACE,OAAO,GAWH,EAAE;IAEN,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IACzC,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,eAAe,CAAC;IACrD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,IAAA,uCAAkB,GAAE,CAAC;IACtD,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CACb,uDAAuD;YACrD,qDAAqD;YACrD,+CAA+C,CAClD,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAG,IAAA,8BAAS,EACtB,MAAM,EACN,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,QAAQ,CAAC,EAC9C,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,WAAW,EAAE,IAAI,EAAE,CACnE,CAAC;IACF,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CACb,uCAAuC,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,CAC9D,CAAC;IACJ,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CACb,2CAA2C,MAAM,CAAC,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAC5F,CAAC;IACJ,CAAC;IAED,OAAO,iCAAe,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;AACxD,CAAC;AAED;;;;;GAKG;AACH,SAAS,SAAS,CAAC,IAAY;IAC7B,IAAI,KAAc,CAAC;IACnB,IAAI,CAAC;QACH,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,+CACE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CACvD,EAAE,CACH,CAAC;IACJ,CAAC;IACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAAoC,KAAK,EAAE;AAC7C,CAAC"}

package/lib/reduce.js

@@ -0,0 +1,101 @@
+"use strict";
+// Reduce a raw `ttscgraph dump` to the payload the bundled 3D viewer renders.
+// This mirrors website/src/components/graph/graphReduce.ts (the same pure
+// transform); keep the two in sync. The CLI reduces in Node before serving, so
+// the browser viewer only ever renders a ready `{ nodes, links }`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduce = reduce;
+function posix(p) {
+    return p.replace(/\\/g, "/");
+}
+function commonRoot(files) {
+    if (files.length === 0)
+        return "";
+    let parts = posix(files[0]).split("/");
+    for (const file of files.slice(1)) {
+        const other = posix(file).split("/");
+        let i = 0;
+        while (i < parts.length && i < other.length && parts[i] === other[i])
+            i++;
+        parts = parts.slice(0, i);
+        if (parts.length === 0)
+            break;
+    }
+    return parts.join("/");
+}
+function relativize(abs, root) {
+    const a = posix(abs);
+    const r = posix(root).replace(/\/+$/, "");
+    if (r && (a === r || a.startsWith(r + "/")))
+        return a.slice(r.length).replace(/^\/+/, "");
+    const nm = a.lastIndexOf("node_modules/");
+    if (nm >= 0)
+        return a.slice(nm);
+    const slash = a.lastIndexOf("/");
+    return slash >= 0 ? a.slice(slash + 1) : a;
+}
+function rewriteId(id, root) {
+    const hash = id.indexOf("#");
+    if (hash < 0)
+        return id;
+    return relativize(id.slice(0, hash), root) + id.slice(hash);
+}
+function degreeOf(nodes, edges) {
+    const degree = new Map(nodes.map((n) => [n.id, 0]));
+    for (const e of edges) {
+        if (degree.has(e.from))
+            degree.set(e.from, degree.get(e.from) + 1);
+        if (degree.has(e.to))
+            degree.set(e.to, degree.get(e.to) + 1);
+    }
+    return degree;
+}
+function reduce(raw, { maxNodes = 1200, keepExternal = false, } = {}) {
+    const keptByExternal = raw.nodes.filter((n) => keepExternal || !n.external);
+    const root = commonRoot(raw.nodes.filter((n) => !n.external).map((n) => n.file));
+    const liveIds = new Set(keptByExternal.map((n) => n.id));
+    const liveEdges = raw.edges.filter((e) => liveIds.has(e.from) && liveIds.has(e.to));
+    const degree = degreeOf(keptByExternal, liveEdges);
+    let kept = keptByExternal;
+    let droppedByCap = 0;
+    if (kept.length > maxNodes) {
+        kept = [...kept]
+            .sort((a, b) => (degree.get(b.id) ?? 0) - (degree.get(a.id) ?? 0))
+            .slice(0, maxNodes);
+        droppedByCap = keptByExternal.length - kept.length;
+    }
+    const keptIds = new Set(kept.map((n) => n.id));
+    const edges = liveEdges.filter((e) => keptIds.has(e.from) && keptIds.has(e.to));
+    const finalDegree = degreeOf(kept, edges);
+    const nodes = kept
+        .filter((n) => (finalDegree.get(n.id) ?? 0) > 0)
+        .map((n) => ({
+        id: rewriteId(n.id, root),
+        name: n.name,
+        kind: n.kind,
+        file: relativize(n.file, root),
+        degree: finalDegree.get(n.id) ?? 0,
+    }));
+    const nodeIds = new Set(nodes.map((n) => n.id));
+    const links = edges
+        .map((e) => ({
+        source: rewriteId(e.from, root),
+        target: rewriteId(e.to, root),
+        kind: e.kind,
+    }))
+        .filter((e) => nodeIds.has(e.source) && nodeIds.has(e.target));
+    return {
+        project: raw.project ?? "",
+        counts: {
+            rawNodes: raw.nodes.length,
+            rawEdges: raw.edges.length,
+            nodes: nodes.length,
+            links: links.length,
+            droppedExternal: raw.nodes.length - keptByExternal.length,
+            droppedByCap,
+        },
+        nodes,
+        links,
+    };
+}
+//# sourceMappingURL=reduce.js.map

package/lib/reduce.js.map

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

package/lib/resolveGraphBinary.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGraphBinary = resolveGraphBinary;
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Resolve the per-platform `ttscgraph` 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).
+ */
+function resolveGraphBinary(env = process.env, cwd = process.cwd()) {
+    if (env.TTSC_GRAPH_BINARY && node_path_1.default.isAbsolute(env.TTSC_GRAPH_BINARY)) {
+        return env.TTSC_GRAPH_BINARY;
+    }
+    const exe = process.platform === "win32" ? "ttscgraph.exe" : "ttscgraph";
+    try {
+        const ttscPackageJson = require.resolve("ttsc/package.json", {
+            paths: [cwd],
+        });
+        const fromTtsc = (0, node_module_1.createRequire)(ttscPackageJson);
+        return fromTtsc.resolve(`@ttsc/${process.platform}-${process.arch}/bin/${exe}`);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=resolveGraphBinary.js.map

package/lib/resolveGraphBinary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveGraphBinary.js","sourceRoot":"","sources":["../src/resolveGraphBinary.ts"],"names":[],"mappings":";;;;;;AAAA,6CAA4C;AAC5C,0DAA6B;AAE7B;;;;;;;;;;;;;;;;GAgBG;AACH,4BACE,GAAG,GAAsB,OAAO,CAAC,GAAG,EACpC,GAAG,GAAW,OAAO,CAAC,GAAG,EAAE;IAE3B,IAAI,GAAG,CAAC,iBAAiB,IAAI,mBAAI,CAAC,UAAU,CAAC,GAAG,CAAC,iBAAiB,CAAC,EAAE,CAAC;QACpE,OAAO,GAAG,CAAC,iBAAiB,CAAC;IAC/B,CAAC;IACD,MAAM,GAAG,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,WAAW,CAAC;IACzE,IAAI,CAAC;QACH,MAAM,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,mBAAmB,EAAE;YAC3D,KAAK,EAAE,CAAC,GAAG,CAAC;SACb,CAAC,CAAC;QACH,MAAM,QAAQ,GAAG,IAAA,2BAAa,EAAC,eAAe,CAAC,CAAC;QAChD,OAAO,QAAQ,CAAC,OAAO,CACrB,SAAS,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,IAAI,QAAQ,GAAG,EAAE,CACvD,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC"}