@linghun/tui 0.1.0

package/dist/chunk-OEYW3JE3.js

@@ -0,0 +1,262 @@
+import {
+  createProcessGuard
+} from "./chunk-JHGWGH2C.js";
+import {
+  sanitizeDiagnosticText
+} from "./chunk-OMZYPQVA.js";
+
+// src/mcp-stdio-runtime.ts
+import { spawn } from "child_process";
+var MUTATING_MCP_TOOL_KEYWORDS = [
+  "write",
+  "delete",
+  "update",
+  "create",
+  "remove",
+  "index_repository",
+  "detect_changes",
+  "ingest",
+  "manage_adr"
+];
+function isPotentiallyMutatingMcpTool(toolName) {
+  const lower = toolName.toLowerCase();
+  return MUTATING_MCP_TOOL_KEYWORDS.some((keyword) => lower.includes(keyword));
+}
+var MCP_STDIO_CALL_TIMEOUT_MS = 15e3;
+var MCP_STDIO_PROTOCOL_VERSION = "2025-06-18";
+var McpStdioStructuredError = class extends Error {
+  constructor(message, errorCode) {
+    super(message);
+    this.errorCode = errorCode;
+  }
+  errorCode;
+};
+async function createMcpStdioRunner(options) {
+  return new Promise((resolvePromise) => {
+    let child;
+    const guard = createProcessGuard();
+    try {
+      child = spawn(options.server.command, options.server.args ?? [], {
+        cwd: options.cwd,
+        shell: false,
+        windowsHide: true,
+        env: options.server.env ? { ...process.env, ...options.server.env } : process.env,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      guard.track(child, { label: options.label });
+    } catch (error) {
+      const nodeError = error;
+      resolvePromise({
+        ok: false,
+        summary: `spawn failed: ${sanitizeDiagnosticText(nodeError.message)}`,
+        errorCode: nodeError.code
+      });
+      return;
+    }
+    let settled = false;
+    let timer;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      try {
+        guard.requestStop(false);
+      } catch {
+      }
+      resolvePromise(result);
+    };
+    const stderrChunks = [];
+    let stdoutBuffer = "";
+    const stdin = child.stdin;
+    const stdout = child.stdout;
+    const stderr = child.stderr;
+    if (!stdin || !stdout || !stderr) {
+      settle({ ok: false, summary: "MCP stdio streams unavailable" });
+      return;
+    }
+    timer = setTimeout(() => {
+      settle({
+        ok: false,
+        summary: options.timeoutSummary,
+        errorCode: "ETIMEDOUT"
+      });
+    }, options.timeoutMs);
+    const pending = /* @__PURE__ */ new Map();
+    let nextId = 1;
+    const sendRequest = (method, params2) => {
+      return new Promise((resolveReq, rejectReq) => {
+        const id = nextId++;
+        pending.set(id, { resolve: resolveReq, reject: rejectReq });
+        const message = JSON.stringify({ jsonrpc: "2.0", id, method, params: params2 });
+        try {
+          stdin.write(`${message}
+`);
+        } catch (error) {
+          pending.delete(id);
+          rejectReq(error);
+        }
+      });
+    };
+    stdout.setEncoding("utf8");
+    stdout.on("data", (chunk) => {
+      stdoutBuffer += chunk;
+      let newlineIdx = stdoutBuffer.indexOf("\n");
+      while (newlineIdx >= 0) {
+        const line = stdoutBuffer.slice(0, newlineIdx).trim();
+        stdoutBuffer = stdoutBuffer.slice(newlineIdx + 1);
+        if (line !== "") {
+          let frame;
+          try {
+            frame = JSON.parse(line);
+          } catch (error) {
+            process.stderr.write(
+              `[linghun] mcp_stdio_non_json_frame line=${sanitizeDiagnosticText(line.slice(0, 240))} reason=${sanitizeDiagnosticText(error instanceof Error ? error.message : String(error))}
+`
+            );
+            newlineIdx = stdoutBuffer.indexOf("\n");
+            continue;
+          }
+          const obj = frame;
+          if (typeof obj.id === "number") {
+            const handler = pending.get(obj.id);
+            if (handler) {
+              pending.delete(obj.id);
+              if (obj.error) {
+                handler.reject(
+                  new Error(
+                    `MCP error id=${obj.id}: ${sanitizeDiagnosticText(obj.error.message ?? "unknown")}`
+                  )
+                );
+              } else {
+                handler.resolve(obj.result);
+              }
+            }
+          }
+        }
+        newlineIdx = stdoutBuffer.indexOf("\n");
+      }
+    });
+    stderr.on("data", (chunk) => {
+      if (options.captureStderr) {
+        stderrChunks.push(chunk);
+      }
+    });
+    child.on("error", (error) => {
+      const nodeError = error;
+      settle({
+        ok: false,
+        summary: `MCP stdio error: ${sanitizeDiagnosticText(nodeError.message)}`,
+        errorCode: nodeError.code
+      });
+    });
+    child.on("exit", (code, signal) => {
+      if (!settled) {
+        const stderrText = sanitizeDiagnosticText(
+          Buffer.concat(stderrChunks).toString("utf8").slice(0, 400)
+        );
+        settle({
+          ok: false,
+          summary: `MCP stdio child exited prematurely (code=${code ?? "?"} signal=${signal ?? "-"})${stderrText ? `: ${stderrText}` : ""}`
+        });
+      }
+    });
+    (async () => {
+      try {
+        const result = await options.run(sendRequest);
+        settle({ ok: true, value: result });
+      } catch (error) {
+        if (error instanceof McpStdioStructuredError) {
+          settle({
+            ok: false,
+            summary: sanitizeDiagnosticText(error.message),
+            errorCode: error.errorCode
+          });
+          return;
+        }
+        settle({
+          ok: false,
+          summary: sanitizeDiagnosticText(error.message)
+        });
+      }
+    })();
+  });
+}
+async function runMcpStdioToolCall(server, toolName, params, cwd, timeoutMs = MCP_STDIO_CALL_TIMEOUT_MS) {
+  const result = await createMcpStdioRunner({
+    server,
+    cwd,
+    timeoutMs,
+    label: `mcp-stdio:${server.command}`,
+    timeoutSummary: `MCP stdio timeout after ${timeoutMs}ms (no result for tools/call ${toolName})`,
+    captureStderr: true,
+    run: async (sendRequest) => {
+      await sendRequest("initialize", {
+        protocolVersion: MCP_STDIO_PROTOCOL_VERSION,
+        capabilities: {},
+        clientInfo: { name: "linghun-tui", version: "0.0.0" }
+      });
+      const listResult = await sendRequest("tools/list", {});
+      const toolNames = extractMcpToolNames(listResult);
+      if (!toolNames.includes(toolName)) {
+        throw new McpStdioStructuredError(
+          `tools/list does not contain ${toolName} (server published ${toolNames.length} tools); refusing tools/call`,
+          "MCP_TOOL_NOT_FOUND"
+        );
+      }
+      return await sendRequest("tools/call", {
+        name: toolName,
+        arguments: params
+      });
+    }
+  });
+  if (!result.ok) {
+    return { ok: false, summary: result.summary, errorCode: result.errorCode };
+  }
+  return { ok: true, summary: `tools/call ${toolName} ok`, data: result.value };
+}
+function extractMcpToolNames(listResult) {
+  if (!listResult || typeof listResult !== "object") return [];
+  const tools = listResult.tools;
+  if (!Array.isArray(tools)) return [];
+  const names = [];
+  for (const tool of tools) {
+    if (tool && typeof tool === "object") {
+      const name = tool.name;
+      if (typeof name === "string" && name.length > 0) names.push(name);
+    }
+  }
+  return names;
+}
+async function runMcpStdioToolList(server, cwd, timeoutMs = 5e3) {
+  const result = await createMcpStdioRunner({
+    server,
+    cwd,
+    timeoutMs,
+    label: `mcp-stdio-list:${server.command}`,
+    timeoutSummary: `MCP stdio tools/list timeout after ${timeoutMs}ms`,
+    captureStderr: false,
+    run: async (sendRequest) => {
+      await sendRequest("initialize", {
+        protocolVersion: MCP_STDIO_PROTOCOL_VERSION,
+        capabilities: {},
+        clientInfo: { name: "linghun-tui", version: "0.0.0" }
+      });
+      return extractMcpToolNames(await sendRequest("tools/list", {}));
+    }
+  });
+  if (!result.ok) {
+    return { ok: false, toolNames: [], summary: result.summary, errorCode: result.errorCode };
+  }
+  return {
+    ok: true,
+    toolNames: result.value,
+    summary: `tools/list ok (${result.value.length} tools)`
+  };
+}
+
+export {
+  isPotentiallyMutatingMcpTool,
+  createMcpStdioRunner,
+  runMcpStdioToolCall,
+  runMcpStdioToolList
+};

package/dist/chunk-OF3K3CU5.js

@@ -0,0 +1,159 @@
+import {
+  redactedPath
+} from "./chunk-RVY34HK4.js";
+import {
+  truncateDisplay
+} from "./chunk-OMZYPQVA.js";
+
+// src/mcp-index-command-runtime.ts
+import { basename } from "path";
+var CODEBASE_MEMORY_ENV = "LINGHUN_CODEBASE_MEMORY_MCP";
+function buildMcpStatusPanel(context) {
+  const isEn = context.language === "en-US";
+  const enabled = context.mcp.enabled;
+  const serverCount = context.mcp.servers.length;
+  const toolCount = context.mcp.tools.length;
+  const needsDoctor = !context.mcp.lastDoctor;
+  const summary = [
+    isEn ? `MCP ${enabled ? "enabled" : "disabled"} \xB7 ${serverCount} server${serverCount === 1 ? "" : "s"} \xB7 ${toolCount} tool${toolCount === 1 ? "" : "s"}` : `MCP ${enabled ? "\u5DF2\u542F\u7528" : "\u672A\u542F\u7528"} \xB7 \u670D\u52A1\u5668 ${serverCount} \xB7 \u5DE5\u5177 ${toolCount}`
+  ];
+  if (needsDoctor) {
+    summary.push(
+      isEn ? "Not yet diagnosed \u2014 run /mcp doctor to check." : "\u5C1A\u672A\u8BCA\u65AD \u2014 \u8FD0\u884C /mcp doctor \u68C0\u6D4B\u3002"
+    );
+  }
+  const failingServers = context.mcp.servers.filter(
+    (s) => s.status === "error" || s.status === "missing"
+  );
+  const sections = [];
+  if (serverCount > 0) {
+    sections.push({
+      title: isEn ? "Servers" : "\u670D\u52A1\u5668",
+      rows: context.mcp.servers.slice(0, 8).map((s) => `${s.name} \xB7 ${s.status}`)
+    });
+  }
+  const actions = ["/mcp doctor", "/mcp tools"];
+  if (failingServers.length > 0) actions.push("/mcp validate");
+  return {
+    title: "/mcp",
+    tone: failingServers.length > 0 ? "warning" : "neutral",
+    summary,
+    sections,
+    actions,
+    detailsText: formatMcpStatus(context)
+  };
+}
+function formatMcpStatus(context) {
+  const isEn = context.language === "en-US";
+  const notRunHint = isEn ? "not detected \u2014 run /mcp doctor to check" : "\u672A\u68C0\u6D4B\uFF0C\u8FD0\u884C /mcp doctor \u68C0\u6D4B";
+  const servers = context.mcp.servers.map((server) => {
+    const suffix = server.error ? ` (${truncateDisplay(server.error, 80)})` : "";
+    return `- ${server.name}: ${server.status}; command ${redactedPath(server.command)}${suffix}`;
+  });
+  const lastDoctor = context.mcp.lastDoctor ?? notRunHint;
+  const memorySource = context.index.binarySource ?? notRunHint;
+  const memoryBinary = context.index.binaryStatus ?? notRunHint;
+  const memoryVersion = context.index.binaryVersion ?? "-";
+  const runtime = context.index.runtime ?? (isEn ? "Linghun-managed codebase-memory or external fallback" : "Linghun \u5185\u7F6E codebase-memory \u6216\u5916\u90E8 fallback");
+  return [
+    "MCP status",
+    `- enabled: ${context.mcp.enabled ? "yes" : "no"}`,
+    `- servers: ${context.mcp.servers.length}`,
+    `- tools(stable): ${context.mcp.tools.length}`,
+    `- lastDoctor: ${lastDoctor}`,
+    ...servers,
+    `- codebase-memory source ${memorySource}`,
+    `- codebase-memory binary ${memoryBinary}; version ${memoryVersion}`,
+    `- runtime: ${runtime}`,
+    "- guard: codebase-memory deferred tools currently require Linghun static registry + required args before CLI execution; unknown or incomplete tool calls are rejected.",
+    "- guard: extension-contributed MCP/skill/plugin tools must pass discovery + trust + schemaLoaded + compatible runtime before execution.",
+    "- license/NOTICE: Linghun-managed codebase-memory must be shipped with license/NOTICE metadata; external fallback is reported as external, not bundled.",
+    isEn ? "- next: run /mcp doctor for diagnostics, /mcp tools to list registered tools, /index status for codebase-memory state." : "- \u4E0B\u4E00\u6B65\uFF1A\u8FD0\u884C /mcp doctor \u505A\u8BCA\u65AD\u3001/mcp tools \u67E5\u770B\u5DF2\u767B\u8BB0\u5DE5\u5177\u3001/index status \u67E5\u770B codebase-memory \u72B6\u6001\u3002"
+  ].join("\n");
+}
+function buildIndexStatusPanel(context) {
+  const isEn = context.language === "en-US";
+  const status = context.index.status;
+  const enabled = context.index.enabled;
+  const isError = status === "error" || status === "missing";
+  const summary = [
+    isEn ? `Index ${enabled ? "enabled" : "disabled"} \xB7 status: ${status}` : `\u7D22\u5F15 ${enabled ? "\u5DF2\u542F\u7528" : "\u672A\u542F\u7528"} \xB7 \u72B6\u6001\uFF1A${status}`
+  ];
+  const actions = [];
+  if (status === "missing") {
+    summary.push(
+      isEn ? "Not built yet \u2014 run /index init fast." : "\u5C1A\u672A\u5EFA\u7ACB \u2014 \u8FD0\u884C /index init fast\u3002"
+    );
+    actions.push("/index init fast");
+  } else if (status === "stale") {
+    summary.push(
+      isEn ? "Stale \u2014 /index refresh recommended." : "\u5DF2\u8FC7\u671F \u2014 \u5EFA\u8BAE\u8FD0\u884C /index refresh\u3002"
+    );
+    actions.push("/index refresh");
+  } else if (status === "refresh_completed_but_unverified") {
+    summary.push(
+      isEn ? "Refresh completed; status read-back is unverified \u2014 run /index status --fresh." : "\u5237\u65B0\u5DF2\u5B8C\u6210\uFF1B\u72B6\u6001\u8BFB\u56DE\u5C1A\u672A\u9A8C\u8BC1 \u2014 \u8FD0\u884C /index status --fresh\u3002"
+    );
+    actions.push("/index status --fresh");
+  } else if (status === "error") {
+    summary.push(isEn ? "Error \u2014 run /index doctor." : "\u51FA\u9519 \u2014 \u8FD0\u884C /index doctor\u3002");
+    actions.push("/index doctor");
+  } else if (status === "ready") {
+    actions.push("/index search", "/index architecture");
+  }
+  return {
+    title: "/index",
+    tone: isError ? "error" : status === "stale" ? "warning" : "neutral",
+    summary,
+    actions,
+    detailsText: formatIndexStatus(context)
+  };
+}
+function formatIndexStatus(context) {
+  const suggestion = context.index.binaryStatus && context.index.binaryStatus !== "ready" ? `\u5EFA\u8BAE\uFF1A\u914D\u7F6E ${CODEBASE_MEMORY_ENV}\uFF0C\u6216\u5B89\u88C5/\u4FEE\u590D Linghun-managed codebase-memory\uFF1B\u666E\u901A\u804A\u5929\u4E0D\u53D7\u5F71\u54CD\u3002` : context.index.status === "missing" ? context.index.error ? "\u5EFA\u8BAE\uFF1A\u786E\u8BA4 codebase-memory artifact \u662F\u5426\u5B58\u5728\uFF1B\u53EF\u663E\u5F0F\u8FD0\u884C /index init fast\u3002\u666E\u901A\u804A\u5929\u4E0D\u53D7\u5F71\u54CD\u3002" : "\u5EFA\u8BAE\uFF1A\u8FD0\u884C /index init fast \u5EFA\u7ACB\u7D22\u5F15\uFF1B\u4ED3\u5E93\u5F88\u5927\u65F6\u4F1A\u81EA\u52A8\u8DF3\u8FC7\u9AD8\u98CE\u9669\u5927\u6587\u4EF6/\u751F\u6210\u7269\u3002" : context.index.status === "stale" ? "\u5EFA\u8BAE\uFF1A\u6309\u9700\u5237\u65B0\u7D22\u5F15\uFF1B\u5927\u6587\u4EF6/\u751F\u6210\u7269\u4F1A\u5728\u9ED8\u8BA4\u5237\u65B0\u4E2D\u4E34\u65F6\u8DF3\u8FC7\u3002" : context.index.status === "refresh_completed_but_unverified" ? "\u5EFA\u8BAE\uFF1A\u7D22\u5F15\u5237\u65B0\u547D\u4EE4\u5DF2\u5B8C\u6210\uFF0C\u4F46\u8BFB\u56DE/\u65B0\u9C9C\u5EA6\u5C1A\u672A\u9A8C\u8BC1\uFF1B\u8FD0\u884C /index status --fresh \u786E\u8BA4\u3002" : context.index.status === "error" ? "\u5EFA\u8BAE\uFF1A\u4FEE\u590D codebase-memory runtime/artifact \u540E\u91CD\u8BD5 /index doctor \u6216 /index status\u3002" : "\u5EFA\u8BAE\uFF1A\u53EF\u7528 /index search <query> \u6216 /index architecture \u83B7\u53D6\u77ED\u7ED3\u679C\uFF1B\u65B0\u9C9C\u5EA6\u68C0\u67E5\u7528 /index status --fresh \u6216 /index check\u3002";
+  return [
+    "Index status",
+    `- enabled: ${context.index.enabled ? "yes" : "no"}`,
+    `- project: ${context.index.projectName ?? basename(context.projectPath)}`,
+    `- project selection: ${context.index.projectSelectionSource ?? (context.index.projectName ? "root_path" : "missing")}`,
+    `- status: ${context.index.status}`,
+    `- source: ${context.index.binarySource ?? "unknown"}`,
+    `- binary status: ${context.index.binaryStatus ?? "unknown"}`,
+    `- binary command: ${context.index.binaryCommand ?? "-"}`,
+    `- version: ${context.index.binaryVersion ?? "-"}`,
+    `- artifact status: ${context.index.artifactStatus ?? "unknown"}`,
+    `- artifact path (details): ${redactedPath(context.index.artifactPath)}`,
+    `- runtime: ${context.index.runtime ?? "Linghun-managed codebase-memory or external fallback"}`,
+    `- graph: ${context.index.nodes ?? "-"} nodes, ${context.index.edges ?? "-"} edges`,
+    `- changed files: ${context.index.changedFiles ?? "-"}`,
+    `- stale hint: ${context.index.staleHint ? truncateDisplay(context.index.staleHint, 160) : "-"}`,
+    `- safety: ${context.index.safetyRiskyFiles?.length ? `pending risky files ${context.index.safetyRiskyFiles.length}` : "-"}`,
+    `- error: ${context.index.error ? truncateDisplay(context.index.error, 120) : "-"}`,
+    `- lastQuery: ${context.index.lastQuery ?? "-"}`,
+    `- next action: ${suggestion}`
+  ].join("\n");
+}
+function formatIndexRefreshSummary(context, actionLabel = "refresh") {
+  const title = actionLabel === "refresh" ? "Index refresh completed" : "Index init completed";
+  const titleZh = actionLabel === "refresh" ? "\u7D22\u5F15\u5237\u65B0\u5B8C\u6210" : "\u7D22\u5F15\u521D\u59CB\u5316\u5B8C\u6210";
+  if (context.language === "en-US") {
+    return [
+      title,
+      `- status: ${context.index.status}`,
+      "- details: run /index status for the full index status view."
+    ].join("\n");
+  }
+  return [
+    titleZh,
+    `- \u72B6\u6001\uFF1A${context.index.status}`,
+    "- \u8BE6\u60C5\uFF1A\u8F93\u5165 /index status \u67E5\u770B\u5B8C\u6574\u7D22\u5F15\u72B6\u6001\u3002"
+  ].join("\n");
+}
+
+export {
+  buildMcpStatusPanel,
+  formatMcpStatus,
+  buildIndexStatusPanel,
+  formatIndexStatus,
+  formatIndexRefreshSummary
+};