@linghun/tui 0.1.0

package/dist/chunk-HQIJGQYU.js

@@ -0,0 +1,172 @@
+// src/agent-workflow-registry.ts
+import { readFile, readdir } from "fs/promises";
+import { extname, join } from "path";
+import { builtInTools } from "@linghun/tools";
+async function loadAgentRegistry(projectPath) {
+  return loadRegistryDir(join(projectPath, ".linghun", "agents"), parseAgentDefinition);
+}
+async function loadWorkflowRegistry(projectPath) {
+  return loadRegistryDir(join(projectPath, ".linghun", "workflows"), parseWorkflowDefinition);
+}
+function registryAgentToWorkflowTemplate(agent) {
+  return {
+    id: `agent:${agent.id}`,
+    purpose: agent.description,
+    risk: "medium",
+    writesFiles: (agent.allowedTools ?? []).some(
+      (tool) => ["Write", "Edit", "MultiEdit", "Bash"].includes(tool)
+    ),
+    recommendedValidation: [],
+    steps: [`agent ${agent.id}: ${agent.prompt}`]
+  };
+}
+function registryWorkflowToTemplate(workflow) {
+  return {
+    id: workflow.id,
+    purpose: workflow.description,
+    risk: workflow.steps.some((step) => step.action === "bash" || step.action === "write") ? "high" : "medium",
+    writesFiles: workflow.steps.some((step) => step.action === "write"),
+    recommendedValidation: workflow.steps.filter((step) => step.action === "verification" && step.level).map((step) => step.level),
+    steps: workflow.steps.map((step) => `${step.action}:${step.id}`)
+  };
+}
+async function loadRegistryDir(dir, parse) {
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return { ok: true, items: [], errors: [] };
+  }
+  const items = [];
+  const errors = [];
+  for (const name of entries.filter((entry) => [".json", ".md"].includes(extname(entry))).sort()) {
+    const path = join(dir, name);
+    try {
+      items.push(parse(await readFile(path, "utf8"), path));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push(`${name}: ${message}`);
+    }
+  }
+  return { ok: errors.length === 0, items, errors };
+}
+function parseAgentDefinition(content, path) {
+  const value = parseRegistryContent(content, path);
+  const obj = asRecord(value, "agent definition");
+  const id = readRequiredString(obj, "id");
+  const name = readRequiredString(obj, "name");
+  const description = readRequiredString(obj, "description");
+  const prompt = readRequiredString(obj, "prompt");
+  const allowedTools = Array.isArray(obj.allowedTools) ? obj.allowedTools.map((item) => readAgentToolName(item, "allowedTools")) : void 0;
+  return {
+    id: assertSafeId(id, "id"),
+    name,
+    description,
+    prompt,
+    ...typeof obj.model === "string" && obj.model.trim() ? { model: obj.model.trim() } : {},
+    ...allowedTools ? { allowedTools } : {},
+    ...typeof obj.maxTurns === "number" && Number.isInteger(obj.maxTurns) && obj.maxTurns > 0 ? { maxTurns: obj.maxTurns } : {},
+    path
+  };
+}
+function parseWorkflowDefinition(content, path) {
+  const value = parseRegistryContent(content, path);
+  const obj = asRecord(value, "workflow definition");
+  const id = assertSafeId(readRequiredString(obj, "id"), "id");
+  const name = readRequiredString(obj, "name");
+  const description = readRequiredString(obj, "description");
+  if (!Array.isArray(obj.steps) || obj.steps.length === 0) {
+    throw new Error("steps must be a non-empty array");
+  }
+  return {
+    id,
+    name,
+    description,
+    steps: obj.steps.map((step, index) => parseWorkflowStep(step, index)),
+    ...asOptionalRecord(obj.inputs) ? { inputs: obj.inputs } : {},
+    ...typeof obj.runInBackground === "boolean" ? { runInBackground: obj.runInBackground } : {},
+    path
+  };
+}
+function parseWorkflowStep(value, index) {
+  const obj = asRecord(value, `steps[${index}]`);
+  const action = obj.action;
+  if (action !== "agent" && action !== "verification" && action !== "index" && action !== "details" && action !== "bash" && action !== "write") {
+    throw new Error(`steps[${index}].action is invalid`);
+  }
+  const step = {
+    id: assertSafeId(
+      typeof obj.id === "string" && obj.id.trim() ? obj.id.trim() : `step-${index + 1}`,
+      `steps[${index}].id`
+    ),
+    action
+  };
+  if (typeof obj.role === "string") {
+    if (!isAgentTypeValue(obj.role)) throw new Error(`steps[${index}].role is invalid`);
+    step.role = obj.role;
+  }
+  if (typeof obj.task === "string") step.task = obj.task.trim();
+  if (typeof obj.level === "string") {
+    if (!["smoke", "focused", "typecheck", "test", "build", "lint"].includes(obj.level)) {
+      throw new Error(`steps[${index}].level is invalid`);
+    }
+    step.level = obj.level;
+  }
+  if (typeof obj.command === "string") step.command = obj.command.trim();
+  if (typeof obj.path === "string") step.path = obj.path.trim();
+  if (typeof obj.content === "string") step.content = obj.content.trim();
+  return step;
+}
+function parseRegistryContent(content, path) {
+  if (extname(path) === ".json") return JSON.parse(content);
+  const match = /^---\r?\n(?<frontmatter>[\s\S]*?)\r?\n---/.exec(content);
+  if (!match?.groups?.frontmatter) {
+    throw new Error("markdown registry files require JSON frontmatter between --- markers");
+  }
+  return JSON.parse(match.groups.frontmatter);
+}
+function asRecord(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function asOptionalRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function readRequiredString(obj, key) {
+  const value = obj[key];
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${key} must be a non-empty string`);
+  }
+  return value.trim();
+}
+function readArrayString(value, key) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${key} entries must be non-empty strings`);
+  }
+  return value.trim();
+}
+function readAgentToolName(value, key) {
+  const name = readArrayString(value, key);
+  if (!Object.prototype.hasOwnProperty.call(builtInTools, name)) {
+    throw new Error(`${key} contains invalid tool: ${name}`);
+  }
+  return name;
+}
+function assertSafeId(value, key) {
+  if (!/^[a-zA-Z0-9._-]{1,80}$/u.test(value)) {
+    throw new Error(`${key} must contain only letters, digits, dot, underscore, or dash`);
+  }
+  return value;
+}
+function isAgentTypeValue(value) {
+  return value === "explorer" || value === "planner" || value === "worker" || value === "verifier";
+}
+
+export {
+  loadAgentRegistry,
+  loadWorkflowRegistry,
+  registryAgentToWorkflowTemplate,
+  registryWorkflowToTemplate
+};

package/dist/chunk-HW2TBXVK.js

@@ -0,0 +1,34 @@
+import {
+  fitText
+} from "./chunk-APJIC2O5.js";
+
+// src/shell/components/SlashSuggestions.tsx
+import { Box, Text } from "@linghun/ink-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
+function SlashSuggestions({
+  candidates,
+  selectedIndex,
+  theme,
+  language,
+  width,
+  hint
+}) {
+  if (candidates.length === 0) return null;
+  const safeIndex = Math.max(0, Math.min(selectedIndex, candidates.length - 1));
+  const widest = candidates.reduce((acc, item) => Math.max(acc, item.slash.length), 0);
+  const colWidth = Math.min(Math.max(widest + 2, 12), 14);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width, children: [
+    candidates.map((item, index) => {
+      const title = language === "en-US" ? item.titleEn : item.titleZh;
+      const isSelected = index === safeIndex;
+      const marker = isSelected ? "\u203A" : " ";
+      const line = `${marker} ${item.slash.padEnd(colWidth, " ")}${title}`;
+      return /* @__PURE__ */ jsx(Text, { color: isSelected ? theme.accent : theme.muted, bold: isSelected, children: fitText(line, Math.max(20, width - 2)) }, item.slash);
+    }),
+    hint ? /* @__PURE__ */ jsx(Text, { color: theme.muted, children: fitText(hint, Math.max(20, width - 2)) }) : null
+  ] });
+}
+
+export {
+  SlashSuggestions
+};

package/dist/chunk-HWD22O6F.js

@@ -0,0 +1,94 @@
+// src/shell/clipboard.ts
+import { spawn } from "child_process";
+async function writeTextToClipboard(text, options = {}) {
+  return writeTextToClipboardWithDeps(text, clipboardCandidates(), pipeToCommand, options.stdout);
+}
+async function writeTextToClipboardWithDeps(text, candidates, pipe, stdout) {
+  const normalized = text.replace(/\r\n/g, "\n");
+  if (!normalized) return { ok: false, error: "empty selection" };
+  const osc52Written = writeOsc52(stdout, normalized);
+  const errors = [];
+  for (const candidate of candidates) {
+    const input = clipboardInputForCandidate(candidate, normalized);
+    const result = await pipe(candidate.command, candidate.args, input.text, input.encoding);
+    if (result.ok) return { ok: true, method: candidate.label };
+    if (result.error) errors.push(`${candidate.label}: ${result.error}`);
+  }
+  if (osc52Written && candidates.length === 0) return { ok: true, method: "osc52-best-effort" };
+  return {
+    ok: false,
+    error: errors.length > 0 ? `no supported clipboard command succeeded (${errors.join("; ")})${osc52Written ? "; OSC52 was attempted but cannot be acknowledged" : ""}` : osc52Written ? "OSC52 was attempted but cannot be acknowledged; no native clipboard command found" : "no supported clipboard command found"
+  };
+}
+function clipboardCandidates() {
+  if (process.platform === "win32") return [{ command: "clip", args: [], label: "clip" }];
+  if (process.platform === "darwin") return [{ command: "pbcopy", args: [], label: "pbcopy" }];
+  return [
+    { command: "wl-copy", args: [], label: "wl-copy" },
+    { command: "xclip", args: ["-selection", "clipboard"], label: "xclip" },
+    { command: "xsel", args: ["--clipboard", "--input"], label: "xsel" }
+  ];
+}
+function pipeToCommand(command, args, text, encoding) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let stderr = "";
+    let child;
+    try {
+      child = spawn(command, args, {
+        stdio: ["pipe", "ignore", "pipe"],
+        windowsHide: true
+      });
+    } catch (error) {
+      resolve({ ok: false, error: error instanceof Error ? error.message : String(error) });
+      return;
+    }
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+    child.once("error", (error) => finish({ ok: false, error: error.message }));
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.once("close", (code) => {
+      if (code === 0) {
+        finish({ ok: true });
+        return;
+      }
+      finish({ ok: false, error: stderr.trim() || `exit ${code ?? "unknown"}` });
+    });
+    child.stdin?.end(Buffer.from(text, encoding));
+  });
+}
+function clipboardInputForCandidate(candidate, text) {
+  if (process.platform === "win32" && candidate.command.toLowerCase() === "clip") {
+    return { text: `${text.replace(/\n/g, "\r\n")}\r
+`, encoding: "utf16le" };
+  }
+  return { text, encoding: "utf8" };
+}
+function writeOsc52(stdout, text) {
+  if (!stdout || typeof stdout.write !== "function") return false;
+  try {
+    const payload = Buffer.from(text, "utf8").toString("base64");
+    const osc = `\x1B]52;c;${payload}\x07`;
+    const sequence = isTmux() ? wrapTmuxDcs(osc) : osc;
+    return stdout.write(sequence) !== false;
+  } catch {
+    return false;
+  }
+}
+function isTmux() {
+  return Boolean(process.env.TMUX);
+}
+function wrapTmuxDcs(osc) {
+  const escaped = osc.replace(/\x1B/g, "\x1B\x1B");
+  return `\x1BPtmux;${escaped}\x1B\\`;
+}
+
+export {
+  writeTextToClipboard,
+  writeTextToClipboardWithDeps
+};

package/dist/chunk-I3NTAIMF.js

@@ -0,0 +1,280 @@
+import {
+  codebaseMemoryRequiredArgs
+} from "./chunk-QLRTQHTR.js";
+import {
+  truncateDisplay
+} from "./chunk-OMZYPQVA.js";
+
+// src/deferred-tools-catalog.ts
+function codebaseMemoryRiskClass() {
+  return {
+    list_projects: "readonly",
+    index_status: "readonly",
+    search_code: "readonly",
+    get_architecture: "readonly",
+    get_code_snippet: "readonly",
+    query_graph: "readonly",
+    trace_path: "readonly",
+    search_graph: "readonly",
+    index_repository: "mutating",
+    detect_changes: "mutating"
+  };
+}
+function getCodebaseMemoryToolRisk(tool) {
+  return codebaseMemoryRiskClass()[tool] ?? "unknown";
+}
+function validateCodebaseMemoryToolExecution(tool, input) {
+  const requiredArgs = codebaseMemoryRequiredArgs();
+  if (!(tool in requiredArgs)) {
+    return {
+      ok: false,
+      summary: `MCP deferred tool guard: ${tool} \u5C1A\u672A\u7ECF\u8FC7 discovery/schema/trust/runtime \u767B\u8BB0\uFF0C\u5DF2\u62D2\u7EDD\u6267\u884C\u3002\u8BF7\u5148\u8FD0\u884C /mcp doctor \u6216\u4F7F\u7528\u5DF2\u53D1\u73B0\u4E14\u53EF\u4FE1\u7684\u5DE5\u5177\u5165\u53E3\u3002`
+    };
+  }
+  const missing = requiredArgs[tool]?.filter(
+    (key) => input[key] === void 0 || input[key] === null || input[key] === ""
+  );
+  if (missing && missing.length > 0) {
+    return {
+      ok: false,
+      summary: `MCP deferred tool guard: ${tool} \u7F3A\u5C11 required args\uFF1A${missing.join(", ")}\u3002\u5DF2\u62D2\u7EDD\u76F2\u6267\u884C\u3002`
+    };
+  }
+  const schemaProblem = validateCodebaseMemoryToolSchema(tool, input);
+  if (schemaProblem) {
+    return { ok: false, summary: schemaProblem };
+  }
+  return { ok: true };
+}
+function validateCodebaseMemoryToolSchema(tool, input) {
+  const stringArgs = /* @__PURE__ */ new Set(["project", "projectName", "query", "path", "symbol", "from", "to", "repo_path"]);
+  const booleanArgs = /* @__PURE__ */ new Set(["force"]);
+  const numberArgs = /* @__PURE__ */ new Set(["limit", "max_depth"]);
+  for (const [key, value] of Object.entries(input)) {
+    if (stringArgs.has(key) && typeof value !== "string") {
+      return `MCP deferred tool guard: ${tool}.${key} \u5FC5\u987B\u662F string\uFF0C\u5DF2\u62D2\u7EDD\u6267\u884C\u3002`;
+    }
+    if (booleanArgs.has(key) && typeof value !== "boolean") {
+      return `MCP deferred tool guard: ${tool}.${key} \u5FC5\u987B\u662F boolean\uFF0C\u5DF2\u62D2\u7EDD\u6267\u884C\u3002`;
+    }
+    if (numberArgs.has(key) && typeof value !== "number") {
+      return `MCP deferred tool guard: ${tool}.${key} \u5FC5\u987B\u662F number\uFF0C\u5DF2\u62D2\u7EDD\u6267\u884C\u3002`;
+    }
+  }
+  return void 0;
+}
+var CODEBASE_MEMORY_DESCRIPTIONS = {
+  list_projects: "List indexed projects in codebase-memory.",
+  index_status: "Get current index status (nodes/edges/status) for a project.",
+  detect_changes: "Detect uncovered file changes for a project's index.",
+  index_repository: "Build or refresh the codebase-memory index for a repo path.",
+  search_code: "Pattern search across an indexed project.",
+  get_architecture: "Project architecture summary (modules, entry points).",
+  get_code_snippet: "Read a code snippet by qualified name in an indexed project.",
+  query_graph: "Run a graph query (CALLS / IMPORTS) on an indexed project.",
+  trace_path: "Trace a function call chain from -> to in an indexed project.",
+  search_graph: "Find similar implementations / SIMILAR_TO entries in a project."
+};
+function listCodebaseMemoryDeferredTools() {
+  const required = codebaseMemoryRequiredArgs();
+  return Object.keys(required).sort((a, b) => a.localeCompare(b)).map((name) => ({
+    name,
+    kind: "codebase-memory",
+    description: CODEBASE_MEMORY_DESCRIPTIONS[name] ?? `codebase-memory tool: ${name}`,
+    requiredArgs: [...required[name]],
+    executable: true,
+    reason: "codebase-memory static whitelist; required args validated before execution."
+  }));
+}
+function listMcpDeferredTools(context) {
+  if (!context.mcp.enabled) return [];
+  const enabledServers = new Set(
+    context.mcp.servers.filter((server) => server.status !== "disabled" && server.status !== "missing").map((server) => server.name)
+  );
+  return context.mcp.tools.filter((tool) => enabledServers.has(tool.server)).filter((tool) => tool.discovery === "discovered").filter((tool) => tool.schemaLoaded === true).filter((tool) => tool.trusted === true).map((tool) => {
+    const serverConfig = context.config.mcp.servers[tool.server];
+    const localStdio = isLocalStdioMcpServer(serverConfig);
+    const sse = serverConfig?.transport === "sse" && typeof serverConfig.url === "string" && serverConfig.url.trim();
+    return {
+      name: `mcp:${tool.server}:${tool.name}`,
+      kind: "mcp",
+      // truncate is already enforced by stabilizeMcpToolList; do not echo raw schema
+      description: tool.description || `MCP tool ${tool.server}:${tool.name}`,
+      requiredArgs: [],
+      executable: Boolean(localStdio || sse),
+      reason: localStdio ? "MCP server tool discovered (local stdio); JSON-RPC tools/call adapter available. Mutating use needs session permission." : sse ? "MCP server tool discovered (SSE/HTTP endpoint); JSON-RPC tools/list and tools/call adapter available. Mutating use needs session permission." : "MCP server tool discovered with schema and trusted, but server is not local stdio or SSE."
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}
+function isLocalStdioMcpServer(server) {
+  if (!server) return false;
+  if (server.disabled === true) return false;
+  if (typeof server.command !== "string") return false;
+  if (server.command.trim() === "") return false;
+  return true;
+}
+function listSkillDeferredTools(context) {
+  if (!context.skills.enabled) return [];
+  const disabled = new Set(context.skills.disabledIds);
+  const trusted = new Set(context.skills.trustedIds);
+  return context.skills.skills.filter((skill) => !disabled.has(skill.id)).filter((skill) => trusted.has(skill.id)).map((skill) => ({
+    name: `skill:${skill.id}`,
+    kind: "skill",
+    description: truncateDisplay(
+      (skill.description ?? skill.name ?? skill.id).replace(/\s+/g, " "),
+      160
+    ),
+    requiredArgs: [],
+    executable: false,
+    reason: skillManifestHasContribution(skill) ? "Skill manifest contributes commands/tools (enabled+trusted), but Linghun has no safe Skill executor adapter yet; review manifest manually or run /skills status." : "Skill manifest is metadata-only (no command/tool contribution); not executable. Run /skills status for details."
+  })).sort((a, b) => a.name.localeCompare(b.name));
+}
+function skillManifestHasContribution(skill) {
+  const triggers = skill.triggers ?? [];
+  if (Array.isArray(triggers) && triggers.length > 0) return true;
+  const raw = skill;
+  if (Array.isArray(raw.commands) && raw.commands.length > 0) return true;
+  if (Array.isArray(raw.tools) && raw.tools.length > 0) return true;
+  return false;
+}
+function listPluginDeferredTools(context) {
+  if (!context.plugins.enabled) return [];
+  const disabled = new Set(context.plugins.disabledIds);
+  const trusted = new Set(context.plugins.trustedIds);
+  return context.plugins.plugins.filter((plugin) => !disabled.has(plugin.id)).filter((plugin) => trusted.has(plugin.id)).map((plugin) => ({
+    name: `plugin:${plugin.id}`,
+    kind: "plugin",
+    description: truncateDisplay(
+      (plugin.description ?? plugin.name ?? plugin.id).replace(/\s+/g, " "),
+      160
+    ),
+    requiredArgs: [],
+    executable: false,
+    reason: pluginManifestHasContribution(plugin) ? "Plugin manifest contributes commands/tools (enabled+trusted), but Linghun has no safe Plugin executor adapter yet; review contributions manually or run /plugins doctor." : "Plugin manifest is metadata-only (no command/tool contribution); not executable. Run /plugins doctor for details."
+  })).sort((a, b) => a.name.localeCompare(b.name));
+}
+function pluginManifestHasContribution(plugin) {
+  const c = plugin.contributions;
+  if (!c) return false;
+  return (c.commands?.length ?? 0) > 0 || (c.mcpServers?.length ?? 0) > 0 || (c.providers?.length ?? 0) > 0 || (c.hooks?.length ?? 0) > 0 || (c.workflows?.length ?? 0) > 0 || (c.skills?.length ?? 0) > 0;
+}
+function listDeferredTools(context) {
+  return [
+    ...listCodebaseMemoryDeferredTools(),
+    ...listMcpDeferredTools(context),
+    ...listSkillDeferredTools(context),
+    ...listPluginDeferredTools(context)
+  ];
+}
+function snapshotDeferredTools(context) {
+  const tools = listDeferredTools(context);
+  const byKind = {
+    "codebase-memory": 0,
+    mcp: 0,
+    skill: 0,
+    plugin: 0
+  };
+  let executableCount = 0;
+  for (const tool of tools) {
+    byKind[tool.kind] += 1;
+    if (tool.executable) executableCount += 1;
+  }
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    total: tools.length,
+    byKind,
+    executableCount,
+    tools
+  };
+}
+function snapshotDeferredToolsSummary(context) {
+  const snapshot = snapshotDeferredTools(context);
+  return {
+    total: snapshot.total,
+    byKind: snapshot.byKind,
+    executableCount: snapshot.executableCount
+  };
+}
+var DISCOVERED_NAME_MAX_LEN = 80;
+var DISCOVERED_NAMES_MAX_COUNT = 32;
+function sanitizeDiscoveredDeferredToolName(name) {
+  const cleaned = name.replace(/[^A-Za-z0-9_:.\-]/g, "_");
+  if (cleaned.length <= DISCOVERED_NAME_MAX_LEN) return cleaned;
+  return `${cleaned.slice(0, DISCOVERED_NAME_MAX_LEN)}\u2026`;
+}
+function snapshotDiscoveredDeferredToolsSummary(context) {
+  const sorted = Array.from(context.discoveredDeferredToolNames).sort();
+  const sanitized = sorted.map(sanitizeDiscoveredDeferredToolName);
+  if (sanitized.length <= DISCOVERED_NAMES_MAX_COUNT) {
+    return { total: sanitized.length, names: sanitized, truncated: false };
+  }
+  return {
+    total: sanitized.length,
+    names: sanitized.slice(0, DISCOVERED_NAMES_MAX_COUNT),
+    truncated: true
+  };
+}
+function searchDeferredTools(query, tools) {
+  const trimmed = query.trim().toLowerCase();
+  if (trimmed === "") return tools;
+  return tools.filter((tool) => {
+    const haystack = `${tool.name} ${tool.description} ${tool.kind}`.toLowerCase();
+    return haystack.includes(trimmed);
+  });
+}
+function findDeferredTool(toolName, tools) {
+  return tools.find((tool) => tool.name === toolName);
+}
+function deferredToolListHashInput(tools) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    kind: tool.kind,
+    executable: tool.executable,
+    requiredArgs: [...tool.requiredArgs].sort((a, b) => a.localeCompare(b))
+  })).sort((a, b) => a.name.localeCompare(b.name));
+}
+function formatDeferredToolsSystemReminder(language, snapshot) {
+  if (snapshot.total === 0) return void 0;
+  return language === "en-US" ? "Additional tools must be discovered via SearchExtraTools, then invoked via ExecuteExtraTool. Built-in tools (Read/Edit/Write/Bash/Grep/Glob/Todo) are still called directly." : "Additional tools must be discovered via SearchExtraTools, then invoked via ExecuteExtraTool.";
+}
+function isCodebaseMemoryToolName(name) {
+  return name in codebaseMemoryRequiredArgs();
+}
+function summarizeDeferredToolMatch(tool) {
+  return {
+    name: tool.name,
+    kind: tool.kind,
+    description: tool.description,
+    requiredArgs: tool.requiredArgs,
+    executable: tool.executable,
+    reason: tool.reason
+  };
+}
+function parseMcpDeferredToolName(name) {
+  if (!name.startsWith("mcp:")) return void 0;
+  const rest = name.slice(4);
+  const idx = rest.indexOf(":");
+  if (idx <= 0) return void 0;
+  const server = rest.slice(0, idx);
+  const tool = rest.slice(idx + 1);
+  if (server.trim() === "" || tool.trim() === "") return void 0;
+  return { server, tool };
+}
+
+export {
+  getCodebaseMemoryToolRisk,
+  validateCodebaseMemoryToolExecution,
+  isLocalStdioMcpServer,
+  listDeferredTools,
+  snapshotDeferredTools,
+  snapshotDeferredToolsSummary,
+  sanitizeDiscoveredDeferredToolName,
+  snapshotDiscoveredDeferredToolsSummary,
+  searchDeferredTools,
+  findDeferredTool,
+  deferredToolListHashInput,
+  formatDeferredToolsSystemReminder,
+  isCodebaseMemoryToolName,
+  summarizeDeferredToolMatch,
+  parseMcpDeferredToolName
+};