@linghun/tui 0.1.2 → 0.1.4

package/dist/{chunk-X7E34LKV.js → chunk-KI7NO6IF.js}

@@ -5,14 +5,14 @@ import {
   isPotentiallyMutatingMcpTool,
   runMcpStdioToolCall,
   runMcpStdioToolList
-} from "./chunk-DIDRFIIW.js";
+} from "./chunk-OMWSM2DA.js";
 import {
   buildIndexStatusPanel,
   buildMcpStatusPanel,
   formatIndexRefreshSummary,
   formatIndexStatus,
   formatMcpStatus
-} from "./chunk-O2U4XQVM.js";
+} from "./chunk-UYU4QN3P.js";
 import {
   runMcpSseToolCall
 } from "./chunk-BNC4F63N.js";
@@ -26,14 +26,14 @@ import {
 } from "./chunk-6CHUZ2NF.js";
 import {
   showCommandPanel
-} from "./chunk-PPUOHBAK.js";
+} from "./chunk-2JZBPXHF.js";
 import {
   writeDiagnosticLine
-} from "./chunk-HPIHFENG.js";
+} from "./chunk-HMGGPN4J.js";
 import {
   redactedPath,
   runCommandCapture
-} from "./chunk-HZ5XNKWS.js";
+} from "./chunk-HMGYFENJ.js";
 import {
   findDeferredTool,
   getCodebaseMemoryToolRisk,
@@ -44,7 +44,7 @@ import {
   searchDeferredTools,
   summarizeDeferredToolMatch,
   validateCodebaseMemoryToolExecution
-} from "./chunk-6DBBXNEG.js";
+} from "./chunk-7VGFNZPN.js";
 import {
   findCurrentIndexProject,
   readLocalIndexArtifactState
@@ -65,6 +65,7 @@ import {
 } from "./chunk-UGYFQF6M.js";
 
 // src/mcp-index-runtime.ts
+import { spawn } from "child_process";
 import { randomUUID } from "crypto";
 import { readFile } from "fs/promises";
 import { delimiter, dirname, join, resolve } from "path";
@@ -79,6 +80,7 @@ var CODEBASE_MEMORY_COMMAND = "codebase-memory-mcp";
 var CODEBASE_MEMORY_ENV = "LINGHUN_CODEBASE_MEMORY_MCP";
 var CLI_BUNDLED_ROOT_ENV = "LINGHUN_CLI_BUNDLED_ROOT";
 var CODEBASE_MEMORY_BUNDLED_ENV = "LINGHUN_CODEBASE_MEMORY_BUNDLED_DIR";
+var PRE_ENGINE_BUNDLED_ENV = "LINGHUN_PRE_ENGINE_BUNDLED_DIR";
 var CODEBASE_MEMORY_BUNDLED_PLATFORM_ARCHES = /* @__PURE__ */ new Set([
   "win32-x64",
   "linux-x64",
@@ -422,6 +424,153 @@ function getCodebaseMemoryPlatformArch() {
   }
   return `${process.platform}-${process.arch}`;
 }
+var PRE_ENGINE_COMMAND = "linghun-pre-engine";
+var PreEngineDaemon = class {
+  constructor(binary, cwd) {
+    this.binary = binary;
+    this.cwd = cwd;
+  }
+  binary;
+  cwd;
+  proc = null;
+  queue = Promise.resolve();
+  idleTimer = null;
+  msgId = 1;
+  call(toolName, args) {
+    return new Promise((resolve2, reject) => {
+      this.queue = this.queue.then(() => this._doCall(toolName, args).then(resolve2, reject)).catch(() => {
+      });
+    });
+  }
+  _ensureProc() {
+    if (this.proc) return Promise.resolve(this.proc);
+    const proc = spawn(this.binary, [], { cwd: this.cwd, stdio: ["pipe", "pipe", "pipe"] });
+    this.proc = proc;
+    proc.on("exit", () => {
+      if (this.proc === proc) this.proc = null;
+    });
+    return new Promise((resolve2) => {
+      let buf = "";
+      const onData = (chunk) => {
+        buf += chunk.toString();
+        const lines = buf.split("\n");
+        buf = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const msg = JSON.parse(line);
+            if (msg.id === 0) {
+              proc.stdout.off("data", onData);
+              proc.stdin.write(
+                JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized", params: {} }) + "\n"
+              );
+              resolve2(proc);
+            }
+          } catch {
+          }
+        }
+      };
+      proc.stdout.on("data", onData);
+      proc.stdin.write(
+        JSON.stringify({ jsonrpc: "2.0", id: 0, method: "initialize", params: { rootUri: this.cwd } }) + "\n"
+      );
+    });
+  }
+  _doCall(toolName, args) {
+    this._resetIdle();
+    return this._ensureProc().then(
+      (proc) => new Promise((resolve2) => {
+        const id = this.msgId++;
+        let buf = "";
+        const cleanup = () => {
+          proc.stdout.off("data", onData);
+          proc.off("exit", onExit);
+        };
+        const onExit = () => {
+          cleanup();
+          resolve2({ ok: false, summary: "pre-engine process exited unexpectedly" });
+        };
+        const onData = (chunk) => {
+          buf += chunk.toString();
+          const lines = buf.split("\n");
+          buf = lines.pop() ?? "";
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+              const msg = JSON.parse(line);
+              if (msg.id === id) {
+                cleanup();
+                if (msg.error) {
+                  resolve2({ ok: false, summary: msg.error.message ?? String(msg.error) });
+                } else {
+                  const content = msg.result?.content;
+                  const text = Array.isArray(content) ? content.map((c) => c.text ?? "").join("") : "";
+                  resolve2({ ok: true, summary: text, data: msg.result });
+                }
+              }
+            } catch {
+            }
+          }
+        };
+        proc.stdout.on("data", onData);
+        proc.on("exit", onExit);
+        proc.stdin.write(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id,
+            method: "tools/call",
+            params: { name: toolName, arguments: args }
+          }) + "\n"
+        );
+      })
+    );
+  }
+  _resetIdle() {
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.idleTimer = setTimeout(() => {
+      this.proc?.kill();
+      this.proc = null;
+    }, 3e4);
+  }
+};
+var _preEngineDaemons = /* @__PURE__ */ new Map();
+function getOrCreatePreEngineDaemon(binary, cwd) {
+  const key = `${binary}\0${cwd}`;
+  let d = _preEngineDaemons.get(key);
+  if (!d) {
+    d = new PreEngineDaemon(binary, cwd);
+    _preEngineDaemons.set(key, d);
+  }
+  return d;
+}
+async function resolvePreEngineBinary() {
+  const platformArch = `${process.platform}-${process.arch}`;
+  const fileName = platformArch.startsWith("win32") ? `${PRE_ENGINE_COMMAND}.exe` : PRE_ENGINE_COMMAND;
+  const roots = [];
+  if (process.env[PRE_ENGINE_BUNDLED_ENV]) {
+    roots.push(process.env[PRE_ENGINE_BUNDLED_ENV]);
+  }
+  if (process.env[CLI_BUNDLED_ROOT_ENV]) {
+    roots.push(join(process.env[CLI_BUNDLED_ROOT_ENV], "pre-engine"));
+  }
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  roots.push(join(moduleDir, "..", "bundled", "pre-engine"));
+  roots.push(join(moduleDir, "bundled", "pre-engine"));
+  for (const root of roots) {
+    const candidate = join(root, platformArch, fileName);
+    if (await pathExists(candidate)) {
+      return candidate;
+    }
+  }
+  const pathDirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+  for (const dir of pathDirs) {
+    const candidate = join(dir, fileName);
+    if (await pathExists(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
 async function findPathCodebaseMemoryBinary() {
   const pathDirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
   const candidates = pathDirs.map((dir) => join(dir, CODEBASE_MEMORY_COMMAND));
@@ -1034,15 +1183,54 @@ async function runCodebaseMemoryCli(context, tool, input, cwd, timeoutMs = 3e4)
 function executeSearchExtraTools(query, context) {
   const all = listDeferredTools(context);
   const filtered = searchDeferredTools(query, all);
+  const recommendedNext = recommendDeferredToolCall(query, context, filtered);
   for (const tool of filtered) {
     context.discoveredDeferredToolNames.add(tool.name);
   }
+  const recommendationText = recommendedNext ? ` Recommended next: ExecuteExtraTool(${recommendedNext.tool_name}, ${JSON.stringify({
+    params: recommendedNext.params
+  })}) because ${recommendedNext.reason}.` : "";
   return {
     ok: true,
-    text: `SearchExtraTools matched ${filtered.length}/${all.length} deferred tools (query=${JSON.stringify(query)}).`,
-    data: { matches: filtered.map(summarizeDeferredToolMatch), total: filtered.length }
+    text: `SearchExtraTools matched ${filtered.length}/${all.length} deferred tools (query=${JSON.stringify(query)}).${recommendationText}`,
+    data: { matches: filtered.map(summarizeDeferredToolMatch), total: filtered.length, recommendedNext }
   };
 }
+function recommendDeferredToolCall(query, context, matches) {
+  const has = (name) => matches.some((tool) => tool.name === name && tool.executable);
+  const task = query.trim();
+  if (context.index.status === "ready" && context.index.projectName) {
+    if (has("get_architecture")) {
+      return {
+        tool_name: "get_architecture",
+        params: { project: context.index.projectName },
+        reason: "codebase-memory index is ready, so index-backed architecture is the broad repository discovery step"
+      };
+    }
+    if (task && has("search_code")) {
+      return {
+        tool_name: "search_code",
+        params: { project: context.index.projectName, pattern: task },
+        reason: "codebase-memory index is ready, so indexed search should narrow the repository scope before AST precision"
+      };
+    }
+    if (task && has("search_graph")) {
+      return {
+        tool_name: "search_graph",
+        params: { project: context.index.projectName, query: task },
+        reason: "codebase-memory index is ready, so graph search should narrow related symbols before AST precision"
+      };
+    }
+  }
+  if (task && has("pre_plan")) {
+    return {
+      tool_name: "pre_plan",
+      params: { task },
+      reason: "the codebase index is not ready, so pre-engine should provide the first structured repository-analysis pass"
+    };
+  }
+  return void 0;
+}
 async function executeExtraTool(args, context) {
   if (typeof args.tool_name !== "string" || args.tool_name.trim() === "") {
     return {
@@ -1102,6 +1290,28 @@ async function executeExtraTool(args, context) {
       data: cliResult.data
     };
   }
+  if (target.kind === "pre-engine") {
+    const binary = await resolvePreEngineBinary();
+    if (!binary) {
+      return {
+        ok: false,
+        text: `ExecuteExtraTool(pre-engine:${target.name}) \u5931\u8D25\uFF1A\u627E\u4E0D\u5230 linghun-pre-engine \u4E8C\u8FDB\u5236\u6587\u4EF6\uFF08bundled \u6216 PATH \u5747\u672A\u547D\u4E2D\uFF09\u3002`
+      };
+    }
+    const daemon = getOrCreatePreEngineDaemon(binary, context.projectPath);
+    const result = await daemon.call(target.name, params);
+    if (!result.ok) {
+      return {
+        ok: false,
+        text: `ExecuteExtraTool(pre-engine:${target.name}) \u5931\u8D25\uFF1A${result.summary}`
+      };
+    }
+    return {
+      ok: true,
+      text: `ExecuteExtraTool(pre-engine:${target.name}) \u5B8C\u6210\u3002`,
+      data: result.data
+    };
+  }
   if (target.kind === "mcp") {
     const parsed = parseMcpDeferredToolName(target.name);
     if (!parsed) {
@@ -1169,6 +1379,7 @@ export {
   findBundledCodebaseMemoryBinary,
   getBundledCodebaseMemoryRoots,
   getCodebaseMemoryPlatformArch,
+  resolvePreEngineBinary,
   findPathCodebaseMemoryBinary,
   findCodebaseMemoryBinaryCandidate,
   probeCodebaseMemoryBinary,

package/dist/{chunk-UIKN3CDF.js → chunk-NMOVU75L.js}

@@ -1,6 +1,6 @@
 import {
   formatApprovedRunnerSpecLine
-} from "./chunk-YDTJ7UBG.js";
+} from "./chunk-JMUAQUQQ.js";
 import {
   formatJobNextAction,
   formatJobRunnerInline,

package/dist/{chunk-ZJDPYOTK.js → chunk-NR3MFRPO.js}

@@ -27,11 +27,11 @@ import {
 } from "./chunk-CFXB5SE5.js";
 import {
   showCommandPanel
-} from "./chunk-PPUOHBAK.js";
+} from "./chunk-2JZBPXHF.js";
 import {
   redactRemoteSummary,
   remoteTranscriptSummary
-} from "./chunk-42ZZUF7P.js";
+} from "./chunk-6C32YAB5.js";
 import {
   applyRemoteSessionDisables,
   createRemoteState

package/dist/{chunk-WXTHKLNH.js → chunk-OI5TZ37D.js}

@@ -2,6 +2,8 @@
 var TODO_OUTPUT_ITEM_LIMIT = 8;
 var BASH_TAIL_LINE_LIMIT = 0;
 var PRIMARY_PREVIEW_LINE_CAP = 5;
+var DIAGNOSTICS_SUMMARY_LIMIT = 3;
+var DIAGNOSTICS_EVIDENCE_LIMIT = 120;
 var RAW_TOOL_USE_PATTERNS = [
   /<tool_use(?:_error)?\b[\s\S]*?<\/tool_use(?:_error)?>/giu,
   /<tool_use(?:_error)?\b[^>]*\/>/giu,
@@ -62,12 +64,36 @@ function formatToolOutput(name, output, language, evidenceId) {
   if (layered.preview) {
     lines.push(layered.preview);
   }
+  const diagnostics = formatToolDiagnosticsSummary(output);
+  if (diagnostics) {
+    lines.push(diagnostics);
+  }
   const bashEnd = formatBashEndSummary(name, output, language);
   if (bashEnd) {
     lines.push(bashEnd);
   }
   return lines.join("\n");
 }
+function formatToolDiagnosticsSummary(output) {
+  const metadata = output.data && typeof output.data === "object" ? output.data : void 0;
+  const diagnostics = Array.isArray(metadata?.diagnostics) ? metadata.diagnostics : [];
+  const lines = diagnostics.map(formatCompactDiagnosticLine).filter((line) => Boolean(line)).slice(0, DIAGNOSTICS_SUMMARY_LIMIT);
+  if (lines.length === 0) return void 0;
+  return ["Linghun diagnostics:", ...lines].join("\n");
+}
+function formatCompactDiagnosticLine(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  const type = typeof record.type === "string" ? record.type.trim() : "";
+  const evidence = typeof record.evidence === "string" ? record.evidence.trim() : "";
+  if (!type || !evidence) return void 0;
+  return `- ${type}: ${compactDiagnosticEvidence(evidence)}`;
+}
+function compactDiagnosticEvidence(value) {
+  const singleLine = value.replace(/\s+/gu, " ").trim();
+  if (singleLine.length <= DIAGNOSTICS_EVIDENCE_LIMIT) return singleLine;
+  return `${singleLine.slice(0, DIAGNOSTICS_EVIDENCE_LIMIT - 3)}...`;
+}
 function formatPrimaryToolLead(name, output, layered, language) {
   const metadata = output.data && typeof output.data === "object" ? output.data : void 0;
   const count = readNumber(metadata, "count");
@@ -589,6 +615,7 @@ function looksLikeMojibake(text) {
 export {
   createLayeredToolOutput,
   formatToolOutput,
+  formatToolDiagnosticsSummary,
   formatToolStart,
   sanitizeAssistantPrimaryText,
   sanitizeAssistantPrimaryTextWithMetadata,

package/dist/{chunk-DIDRFIIW.js → chunk-OMWSM2DA.js}

@@ -1,6 +1,6 @@
 import {
   createProcessGuard
-} from "./chunk-J6CYFWSW.js";
+} from "./chunk-VDQTNA4W.js";
 import {
   sanitizeDiagnosticText
 } from "./chunk-UGYFQF6M.js";

package/dist/{chunk-HGCTHBUY.js → chunk-PHPEPZAA.js}

@@ -4,7 +4,7 @@ import {
   formatPermissionSummary,
   getHardDenyReason,
   isPlanAllowedTool
-} from "./chunk-42ZZUF7P.js";
+} from "./chunk-6C32YAB5.js";
 import {
   classifyToolRequest
 } from "./chunk-LHHKPGLX.js";

package/dist/{chunk-EKYXI6C7.js → chunk-R7BB45CP.js}

@@ -27,7 +27,7 @@ import {
 } from "./chunk-VIJ7GDKI.js";
 import {
   sanitizeMainScreenLeakage
-} from "./chunk-YLOJWSHB.js";
+} from "./chunk-WRVHCSM2.js";
 import {
   SLASH_COMMAND_REGISTRY
 } from "./chunk-PGNALDEH.js";