@triedotdev/mcp 1.0.169 → 1.0.171

package/dist/chunk-2YXOBNKW.js

@@ -0,0 +1,619 @@
+import {
+  cloudClient,
+  fetchDocuments,
+  fetchGraph,
+  fetchLedger,
+  fetchSignals,
+  sessionCache
+} from "./chunk-QR64Y5TI.js";
+
+// src/server/mcp-server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/utils/ai-tool-detector.ts
+function detectAITool() {
+  if (process.env.CLAUDE_CODE_VERSION || process.env.CLAUDE_CODE) {
+    return {
+      name: "Claude Code",
+      preferredOutputFormat: "markdown",
+      supportsDiffs: true,
+      supportsInlineActions: true
+    };
+  }
+  if (process.env.CURSOR_IDE || process.env.CURSOR_TRACE_ID) {
+    return {
+      name: "Cursor",
+      preferredOutputFormat: "rich-text",
+      supportsDiffs: true,
+      supportsInlineActions: false
+    };
+  }
+  if (process.env.OPENCODE_INSTANCE) {
+    return {
+      name: "OpenCode",
+      preferredOutputFormat: "plain-text",
+      supportsDiffs: false,
+      supportsInlineActions: false
+    };
+  }
+  if (process.env.VSCODE_PID || process.env.VSCODE_IPC_HOOK) {
+    return {
+      name: "VS Code",
+      preferredOutputFormat: "markdown",
+      supportsDiffs: true,
+      supportsInlineActions: false
+    };
+  }
+  const parentProcess = process.env.PARENT_PROCESS_NAME || process.env._ || "";
+  if (parentProcess.toLowerCase().includes("claude")) {
+    return {
+      name: "Claude Code",
+      preferredOutputFormat: "markdown",
+      supportsDiffs: true,
+      supportsInlineActions: true
+    };
+  }
+  if (parentProcess.toLowerCase().includes("cursor")) {
+    return {
+      name: "Cursor",
+      preferredOutputFormat: "rich-text",
+      supportsDiffs: true,
+      supportsInlineActions: false
+    };
+  }
+  if (process.env.npm_execpath || process.argv[1]?.includes("npx")) {
+    return {
+      name: "MCP Client",
+      preferredOutputFormat: "markdown",
+      supportsDiffs: true,
+      supportsInlineActions: false
+    };
+  }
+  return {
+    name: "MCP Client",
+    preferredOutputFormat: "markdown",
+    supportsDiffs: true,
+    supportsInlineActions: false
+  };
+}
+
+// src/config/defaults.ts
+var DEFAULT_API_BASE_URL = process.env.TRIE_API_BASE_URL || "https://trie-api.vercel.app";
+var DEFAULT_CACHE_TTL_MS = {
+  context: 6e4,
+  graph: 5 * 6e4,
+  ledger: 5 * 6e4,
+  signals: 2 * 6e4,
+  documents: 5 * 6e4
+};
+
+// src/tools/common.ts
+function asText(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof data === "string" ? data : JSON.stringify(data, null, 2)
+      }
+    ],
+    data
+  };
+}
+
+// src/tools/context.ts
+var TrieContextTool = class {
+  async execute() {
+    const data = await sessionCache.get("context", DEFAULT_CACHE_TTL_MS.context, async () => {
+      const [graph, signals, documents] = await Promise.all([
+        fetchGraph({ view: "weekly", types: ["signal", "insight", "decision", "shipped"] }),
+        fetchSignals(20),
+        fetchDocuments()
+      ]);
+      const hotZones = graph.nodes.filter((n) => typeof n.path === "string").slice(0, 5).map((n) => ({
+        path: n.path || "",
+        risk: n.severity || "medium",
+        reason: "Related incidents and signals in cloud graph"
+      }));
+      return {
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        graphSummary: {
+          nodes: graph.nodes.length,
+          edges: graph.edges.length
+        },
+        hot_zones: hotZones,
+        recentSignals: signals.slice(0, 10),
+        recentDocuments: documents.slice(0, 10)
+      };
+    });
+    return asText(data);
+  }
+};
+
+// src/tools/check-file.ts
+function severityScore(sev) {
+  if (sev === "high") return 3;
+  if (sev === "medium") return 2;
+  return 1;
+}
+function getRiskLevel(warnings) {
+  const max = Math.max(0, ...warnings.map((w) => severityScore(w.severity)));
+  if (max >= 3) return "high";
+  if (max >= 2) return "medium";
+  return "low";
+}
+var TrieCheckFileTool = class {
+  async execute(input = {}) {
+    const file = input.file?.trim();
+    if (!file) throw new Error("`file` is required.");
+    const [ledger, graph, signals] = await Promise.all([
+      fetchLedger(input.project),
+      fetchGraph({ types: ["insight", "decision", "signal", "shipped"] }),
+      fetchSignals(50)
+    ]);
+    const warnings = [];
+    const ledgerBlob = JSON.stringify(ledger).toLowerCase();
+    if (ledgerBlob.includes(file.toLowerCase())) {
+      warnings.push({
+        type: "incident_history",
+        severity: "high",
+        message: "This file appears in prior incidents/ledger events."
+      });
+    }
+    const relatedNodes = graph.nodes.filter((n) => (n.path || "").includes(file));
+    if (relatedNodes.length > 0) {
+      warnings.push({
+        type: "architectural_decision",
+        severity: "medium",
+        message: `${relatedNodes.length} graph node(s) relate to this file.`,
+        details: relatedNodes.slice(0, 3).map((n) => n.label || n.id)
+      });
+    }
+    const relatedSignals = signals.filter(
+      (s) => JSON.stringify(s).toLowerCase().includes(file.toLowerCase())
+    );
+    if (relatedSignals.length > 0) {
+      warnings.push({
+        type: "active_alerts",
+        severity: "high",
+        message: `${relatedSignals.length} signal(s) mention this file.`
+      });
+    }
+    if (warnings.length === 0) {
+      warnings.push({
+        type: "no_known_risks",
+        severity: "info",
+        message: "No known cloud risks found for this file."
+      });
+    }
+    const result = {
+      file,
+      risk_level: getRiskLevel(warnings),
+      warnings,
+      recommendation: warnings.some((w) => w.severity === "high") ? "High-risk area detected. Proceed carefully and verify with tests." : "No high-risk alerts; proceed with normal caution."
+    };
+    return asText(result);
+  }
+};
+
+// src/tools/graph.ts
+var TrieGraphTool = class {
+  async execute(input = {}) {
+    const key = `graph:${JSON.stringify(input)}`;
+    const data = await sessionCache.get(key, DEFAULT_CACHE_TTL_MS.graph, () => fetchGraph(input));
+    return asText(data);
+  }
+};
+
+// src/tools/signals.ts
+import { z } from "zod";
+var SignalsInputSchema = z.object({
+  limit: z.number().int().min(1).max(100).optional()
+}).strict();
+var TrieSignalsTool = class {
+  async execute(input = {}) {
+    const parsedInput = SignalsInputSchema.parse(input);
+    const limit = parsedInput.limit || 20;
+    const key = `signals:${limit}`;
+    const data = await sessionCache.get(key, DEFAULT_CACHE_TTL_MS.signals, () => fetchSignals(limit));
+    return asText(data);
+  }
+};
+
+// src/tools/documents.ts
+var TrieDocumentsTool = class {
+  async execute() {
+    const data = await sessionCache.get("documents", DEFAULT_CACHE_TTL_MS.documents, fetchDocuments);
+    return asText(data);
+  }
+};
+
+// src/tools/ledger.ts
+var TrieLedgerTool = class {
+  async execute(input = {}) {
+    const key = `ledger:${input.project || "default"}`;
+    const data = await sessionCache.get(key, DEFAULT_CACHE_TTL_MS.ledger, () => fetchLedger(input.project));
+    return asText(data);
+  }
+};
+
+// src/cloud/chat.ts
+async function searchContext(query) {
+  return cloudClient.request("/api/cloud/chat", {
+    method: "POST",
+    body: JSON.stringify({
+      messages: [{ role: "user", content: query }]
+    })
+  });
+}
+
+// src/tools/search.ts
+import { z as z2 } from "zod";
+var SearchInputSchema = z2.object({
+  query: z2.string().trim().min(1).max(2e3)
+}).strict();
+var TrieSearchTool = class {
+  async execute(input = {}) {
+    const parsedInput = SearchInputSchema.parse(input);
+    const data = await searchContext(parsedInput.query);
+    return asText(data);
+  }
+};
+
+// src/server/tool-registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  definitions = [];
+  constructor() {
+    this.initializeTools();
+    this.defineToolSchemas();
+  }
+  initializeTools() {
+    this.tools.set("context", new TrieContextTool());
+    this.tools.set("check_file", new TrieCheckFileTool());
+    this.tools.set("graph", new TrieGraphTool());
+    this.tools.set("signals", new TrieSignalsTool());
+    this.tools.set("documents", new TrieDocumentsTool());
+    this.tools.set("ledger", new TrieLedgerTool());
+    this.tools.set("search", new TrieSearchTool());
+  }
+  defineToolSchemas() {
+    this.definitions = [
+      {
+        name: "trie_context",
+        description: "Get consolidated Trie cloud context (hot zones, graph summary, recent signals/documents).",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "trie_check_file",
+        description: "Proactively assess risk for a file: incidents, alerts, brittleness, and decisions.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            file: {
+              type: "string"
+            },
+            project: {
+              type: "string"
+            }
+          },
+          required: ["file"]
+        }
+      },
+      {
+        name: "trie_graph",
+        description: "Read ANT graph from Trie cloud.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            view: { type: "string" },
+            types: { type: "array", items: { type: "string" } },
+            since: { type: "string" },
+            until: { type: "string" }
+          }
+        }
+      },
+      {
+        name: "trie_signals",
+        description: "Read cloud signals feed.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            limit: { type: "number" }
+          }
+        }
+      },
+      {
+        name: "trie_documents",
+        description: "Read cloud documents.",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "trie_ledger",
+        description: "Read cloud ledger entries.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string" }
+          }
+        }
+      },
+      {
+        name: "trie_search",
+        description: "Search cloud context via natural language.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string" }
+          },
+          required: ["query"]
+        }
+      }
+    ];
+  }
+  getTool(name) {
+    return this.tools.get(name);
+  }
+  getAllTools() {
+    return this.definitions;
+  }
+  getToolNames() {
+    return Array.from(this.tools.keys());
+  }
+  hasTool(name) {
+    return this.tools.has(name);
+  }
+};
+
+// src/server/resource-manager.ts
+var ResourceManager = class {
+  /**
+   * Get all available resources dynamically
+   */
+  async getAvailableResources() {
+    const resources = [];
+    resources.push(
+      {
+        uri: "trie://context",
+        name: "Trie Cloud Context",
+        description: "Consolidated cloud context with hot zones and active signals.",
+        mimeType: "application/json"
+      },
+      {
+        uri: "trie://graph",
+        name: "Trie ANT Graph",
+        description: "Raw ANT graph from cloud.",
+        mimeType: "application/json"
+      }
+    );
+    return resources;
+  }
+  /**
+   * Read content for a specific resource
+   */
+  async readResourceContent(uri) {
+    if (uri === "trie://context") {
+      return await this.getContextResource(uri);
+    }
+    if (uri === "trie://graph") {
+      return await this.getGraphResource(uri);
+    }
+    throw new Error(`Unknown resource: ${uri}`);
+  }
+  async getContextResource(uri) {
+    const data = await sessionCache.get("context-resource", DEFAULT_CACHE_TTL_MS.context, async () => {
+      const [graph, signals, documents] = await Promise.all([
+        fetchGraph({ view: "weekly", types: ["signal", "insight", "decision", "shipped"] }),
+        fetchSignals(20),
+        fetchDocuments()
+      ]);
+      const hotZones = graph.nodes.filter((n) => typeof n.path === "string").slice(0, 10).map((n) => ({
+        path: n.path,
+        risk: n.severity || "medium",
+        reason: "Graph-linked incidents/signals"
+      }));
+      return {
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        graph: { nodes: graph.nodes.length, edges: graph.edges.length },
+        hot_zones: hotZones,
+        signals: signals.slice(0, 10),
+        documents: documents.slice(0, 10)
+      };
+    });
+    return {
+      contents: [{
+        uri,
+        mimeType: "application/json",
+        text: JSON.stringify(data, null, 2)
+      }]
+    };
+  }
+  async getGraphResource(uri) {
+    const graph = await sessionCache.get(
+      "graph-resource",
+      DEFAULT_CACHE_TTL_MS.graph,
+      () => fetchGraph({ view: "weekly" })
+    );
+    return {
+      contents: [{
+        uri,
+        mimeType: "application/json",
+        text: JSON.stringify(graph, null, 2)
+      }]
+    };
+  }
+};
+
+// src/server/request-handlers.ts
+var RequestHandlers = class {
+  constructor(toolRegistry, resourceManager) {
+    this.toolRegistry = toolRegistry;
+    this.resourceManager = resourceManager;
+  }
+  /**
+   * Handle tool execution requests
+   */
+  async handleToolCall(name, args) {
+    const normalizedName = this.normalizeName(name);
+    try {
+      const tool = this.toolRegistry.getTool(normalizedName);
+      if (!tool) {
+        throw new Error(`Unknown tool: ${name}`);
+      }
+      return await tool.execute(this.sanitizeArgs(args));
+    } catch (error) {
+      return {
+        content: [{
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }]
+      };
+    }
+  }
+  /**
+   * Handle resource listing requests
+   */
+  async handleListResources() {
+    const resources = await this.resourceManager.getAvailableResources();
+    return { resources };
+  }
+  /**
+   * Handle resource reading requests
+   */
+  async handleReadResource(uri) {
+    return await this.resourceManager.readResourceContent(uri);
+  }
+  normalizeName(name) {
+    const stripNamespace = (n) => {
+      const trimmed = n.trim().replace(/\s*\([^)]*\)\s*$/, "").trim();
+      const withoutSlash = trimmed.startsWith("/") ? trimmed.slice(1) : trimmed;
+      const parts = withoutSlash.split(":");
+      const base = (parts[0] || withoutSlash).trim();
+      const slashParts = base.split("/");
+      return (slashParts[slashParts.length - 1] || base).trim();
+    };
+    const rawName = stripNamespace(name);
+    return rawName.startsWith("trie_") ? rawName.slice("trie_".length) : rawName;
+  }
+  sanitizeArgs(args) {
+    if (args == null) return {};
+    if (typeof args !== "object" || Array.isArray(args)) {
+      throw new Error("Tool args must be a JSON object.");
+    }
+    const serialized = JSON.stringify(args);
+    if (serialized.length > 32 * 1024) {
+      throw new Error("Tool args exceed 32KB limit.");
+    }
+    return args;
+  }
+};
+
+// src/server/mcp-server.ts
+var MCPServer = class {
+  server;
+  toolRegistry;
+  resourceManager;
+  requestHandlers;
+  constructor() {
+    this.server = new Server(
+      {
+        name: "trie",
+        version: "1.0.0",
+        description: "Trie Cloud context bridge for Cursor and Claude Code. Read trie://context first and call trie_check_file before editing high-risk files."
+      },
+      {
+        capabilities: {
+          tools: {},
+          resources: {}
+        }
+      }
+    );
+    this.toolRegistry = new ToolRegistry();
+    this.resourceManager = new ResourceManager();
+    this.requestHandlers = new RequestHandlers(this.toolRegistry, this.resourceManager);
+    this.setupRequestHandlers();
+  }
+  setupRequestHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: this.toolRegistry.getAllTools()
+      };
+    });
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      return await this.requestHandlers.handleToolCall(name, args);
+    });
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+      return await this.requestHandlers.handleListResources();
+    });
+    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      const { uri } = request.params;
+      return await this.requestHandlers.handleReadResource(uri);
+    });
+  }
+  /**
+   * Show startup banner
+   */
+  showStartupBanner(toolCount, aiTool) {
+    console.error(`
+ \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
+ \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D
+    \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557
+    \u2588\u2588\u2551   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D
+    \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
+    \u255A\u2550\u255D   \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+  Your central registry for Trie tools
+
+  by Louis Kishfy
+
+  Download the Trie workspace: https://www.trie.dev
+  Follow me on X: https://x.com/louiskishfy
+
+  ${toolCount} tools ready | ${aiTool}
+
+  Quick Start:
+    \u2022 "Scan this code" - Run Trie analysis
+    \u2022 "Use trie" - Open the Trie menu
+    \u2022 "Use trie_fix" - Apply high-confidence fixes
+
+  Ready.
+`);
+  }
+  /**
+   * Initialize and start the server
+   */
+  async start() {
+    try {
+      const aiTool = detectAITool();
+      const toolCount = this.toolRegistry.getAllTools().length;
+      this.showStartupBanner(toolCount, aiTool.name);
+      const transport = new StdioServerTransport();
+      await this.server.connect(transport);
+    } catch (error) {
+      console.error("Fatal error starting MCP server:", error);
+      process.exit(1);
+    }
+  }
+};
+async function startServer() {
+  const server = new MCPServer();
+  await server.start();
+}
+
+export {
+  MCPServer,
+  startServer
+};
+//# sourceMappingURL=chunk-2YXOBNKW.js.map