@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.19-dev.10.1

package/dist/node-runtime/summary-review-YSMXKITO.js

@@ -0,0 +1,228 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  loadEnabledModelPatterns,
+  modelMatchesEnabledPatterns
+} from "./chunk-4ZWGEEAS.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/summary-review.js
+import { complete } from "@ashx-j/lunr-ai/compat";
+var PREFERRED_SUMMARY_MODELS = [
+  { provider: "anthropic", id: "claude-haiku-4-5" },
+  { provider: "openai-codex", id: "gpt-5.3-codex-spark" }
+];
+function estimateTokens(text) {
+  let trimmed = text.trim();
+  return trimmed.length === 0 ? 0 : Math.max(1, Math.ceil(trimmed.length / 4));
+}
+function summarizeQueryResult(result) {
+  if (result.error)
+    return `Query: ${result.query}
+Status: Error
+Error: ${result.error}`;
+  let lines = [
+    `Query: ${result.query}`,
+    `Provider: ${result.provider ?? "unknown"}`,
+    `Answer: ${result.answer || "(no answer text returned)"}`
+  ];
+  if (result.results.length === 0)
+    return lines.push("Sources: none"), lines.join(`
+`);
+  lines.push("Sources:");
+  for (let i = 0; i < result.results.length; i++) {
+    let source = result.results[i];
+    lines.push(`${i + 1}. ${source.title} \u2014 ${source.url}`);
+  }
+  return lines.join(`
+`);
+}
+function buildSummaryPrompt(results, feedback) {
+  let sections = [
+    "You are writing the final web search summary for a coding assistant.",
+    "Write a concise, factual summary using only the provided search results.",
+    "Requirements:",
+    "- Keep it readable and skimmable.",
+    "- Include key findings and caveats.",
+    "- Do not invent sources or claims.",
+    "- If evidence is weak or conflicting, say so explicitly.",
+    '- End with a short "Sources" section listing the most relevant URLs.'
+  ];
+  feedback && sections.push("- Incorporate the user feedback provided below into the summary."), sections.push(""), sections.push("<search_results>");
+  for (let i = 0; i < results.length; i++)
+    sections.push(`
+[Result ${i + 1}]`), sections.push(summarizeQueryResult(results[i]));
+  return sections.push(`
+</search_results>`), feedback && (sections.push(""), sections.push("<user_feedback>"), sections.push(feedback), sections.push("</user_feedback>")), sections.join(`
+`);
+}
+function buildDeterministicAnswerPreview(answer) {
+  let text = answer.replace(/\s+/g, " ").trim();
+  if (text.length === 0)
+    return "";
+  let sourceMarker = text.search(/\bSources?\s*:/i);
+  return sourceMarker >= 0 && (text = text.slice(0, sourceMarker).trim()), text.length === 0 ? "" : text.length > 240 ? `${text.slice(0, 237)}...` : text;
+}
+function buildDeterministicSummaryLines(results) {
+  if (results.length === 0)
+    return [
+      "No completed search results were available when the curator session finished.",
+      "",
+      "Sources",
+      "- None"
+    ];
+  let lines = [
+    "Summary based on the currently selected search results.",
+    ""
+  ], sourceUrls = [], successful = 0, failed = 0;
+  for (let result of results) {
+    if (result.error) {
+      failed += 1, lines.push(`- ${result.query}: failed (${result.error})`);
+      continue;
+    }
+    successful += 1;
+    let preview = buildDeterministicAnswerPreview(result.answer);
+    preview.length > 0 ? lines.push(`- ${result.query}: ${preview}`) : lines.push(`- ${result.query}: returned ${result.results.length} source${result.results.length === 1 ? "" : "s"} without answer text.`);
+    for (let source of result.results)
+      sourceUrls.includes(source.url) || sourceUrls.push(source.url);
+  }
+  if (lines.push(""), lines.push(`Completed queries: ${results.length}`), lines.push(`Successful: ${successful}`), lines.push(`Failed: ${failed}`), lines.push(""), lines.push("Sources"), sourceUrls.length === 0)
+    lines.push("- None");
+  else {
+    for (let url of sourceUrls.slice(0, 12))
+      lines.push(`- ${url}`);
+    sourceUrls.length > 12 && lines.push(`- ... and ${sourceUrls.length - 12} more`);
+  }
+  return lines;
+}
+function buildDeterministicSummary(results) {
+  let summary = buildDeterministicSummaryLines(results).join(`
+`).trim(), nonEmptySummary = summary.length > 0 ? summary : `No completed search results were available when the curator session finished.
+
+Sources
+- None`;
+  return {
+    summary: nonEmptySummary,
+    meta: {
+      model: null,
+      durationMs: 0,
+      tokenEstimate: estimateTokens(nonEmptySummary),
+      fallbackUsed: !0,
+      fallbackReason: "deterministic-submit-fallback",
+      edited: !1
+    }
+  };
+}
+function parseModelSelector(value) {
+  let slashIndex = value.indexOf("/");
+  if (slashIndex <= 0 || slashIndex >= value.length - 1)
+    throw new Error(`Invalid summary model: ${value}. Use provider/model-id.`);
+  return {
+    provider: value.slice(0, slashIndex),
+    id: value.slice(slashIndex + 1)
+  };
+}
+async function resolveSummaryModelCandidates(ctx, modelOverride) {
+  let enabledModelPatterns = loadEnabledModelPatterns(ctx), specs = [], normalizedOverride = typeof modelOverride == "string" ? modelOverride.trim() : "";
+  normalizedOverride.length > 0 && specs.push(parseModelSelector(normalizedOverride)), specs.push(...PREFERRED_SUMMARY_MODELS);
+  let candidates = [], errors = [], seen = /* @__PURE__ */ new Set();
+  for (let spec of specs) {
+    let value = `${spec.provider}/${spec.id}`;
+    if (seen.has(value))
+      continue;
+    seen.add(value);
+    let model = ctx.modelRegistry.find(spec.provider, spec.id);
+    if (!model) {
+      errors.push(`Summary model not found: ${value}`);
+      continue;
+    }
+    if (!modelMatchesEnabledPatterns(model, enabledModelPatterns)) {
+      errors.push(`Summary model is not enabled: ${value}`);
+      continue;
+    }
+    let auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+    if (!auth.ok || !auth.apiKey) {
+      errors.push(`No API key available for summary model ${value}`);
+      continue;
+    }
+    candidates.push({ model, apiKey: auth.apiKey, headers: auth.headers });
+  }
+  return { candidates, errors };
+}
+function buildFallbackSummary(results, fallbackReason) {
+  let deterministic = buildDeterministicSummary(results);
+  return {
+    summary: deterministic.summary,
+    meta: {
+      ...deterministic.meta,
+      fallbackReason
+    }
+  };
+}
+function isAbortError(err) {
+  if (!err || typeof err != "object")
+    return !1;
+  let name = err.name, message = err.message;
+  return name === "AbortError" || typeof message == "string" && message.toLowerCase().includes("abort");
+}
+function getTextFromContentPart(part) {
+  if (!part || typeof part != "object")
+    return "";
+  let value = part;
+  return typeof value.text == "string" ? value.text : typeof value.refusal == "string" ? value.refusal : "";
+}
+function getContentPartType(part) {
+  if (!part || typeof part != "object")
+    return "unknown";
+  let value = part;
+  return typeof value.type == "string" ? value.type : "unknown";
+}
+async function generateSummaryDraft(results, ctx, signal, modelOverride, feedback) {
+  if (!ctx || !ctx.modelRegistry)
+    throw new Error("Summary generation context unavailable");
+  let prompt = buildSummaryPrompt(results, feedback), resolved;
+  try {
+    resolved = await resolveSummaryModelCandidates(ctx, modelOverride);
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    return buildFallbackSummary(results, `summary-model-settings-error: ${message}`);
+  }
+  let lastError = resolved.errors.at(-1);
+  for (let { model, apiKey, headers } of resolved.candidates) {
+    let startedAt = Date.now();
+    try {
+      let userMessage = {
+        role: "user",
+        content: [{ type: "text", text: prompt }],
+        timestamp: Date.now()
+      }, response = await complete(model, { messages: [userMessage] }, { apiKey, headers, signal });
+      if (response.stopReason === "aborted")
+        throw new Error("Aborted");
+      let contentParts = Array.isArray(response.content) ? response.content : [], summary = contentParts.map((part) => getTextFromContentPart(part)).filter((text) => text.trim().length > 0).join(`
+`).trim();
+      if (summary.length === 0) {
+        let partTypes = contentParts.map((part) => getContentPartType(part)), typesLabel = partTypes.length > 0 ? partTypes.join(", ") : "none";
+        throw new Error(`Summary model returned empty response (content parts: ${typesLabel})`);
+      }
+      return {
+        summary,
+        meta: {
+          model: `${model.provider}/${model.id}`,
+          durationMs: Math.max(0, Date.now() - startedAt),
+          tokenEstimate: estimateTokens(summary),
+          fallbackUsed: !1,
+          edited: !1
+        }
+      };
+    } catch (err) {
+      if (isAbortError(err))
+        throw err;
+      lastError = err instanceof Error ? err.message : String(err);
+    }
+  }
+  return buildFallbackSummary(results, lastError ? `summary-model-unavailable: ${lastError}` : "summary-model-unavailable");
+}
+export {
+  buildDeterministicSummary,
+  buildSummaryPrompt,
+  generateSummaryDraft
+};

package/dist/node-runtime/tavily-WEZFVFP7.js

@@ -0,0 +1,154 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  activityMonitor
+} from "./chunk-DAPBPCBP.js";
+import {
+  getWebSearchConfigPath
+} from "./chunk-VRB2IYGG.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/tavily.js
+import { existsSync, readFileSync } from "node:fs";
+var TAVILY_API_URL = "https://api.tavily.com/search", CONFIG_PATH = getWebSearchConfigPath(), SEARCH_TIMEOUT_MS = 6e4, cachedConfig = null;
+function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  if (!existsSync(CONFIG_PATH))
+    return cachedConfig = {}, cachedConfig;
+  let raw = readFileSync(CONFIG_PATH, "utf-8");
+  try {
+    return cachedConfig = JSON.parse(raw), cachedConfig;
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+}
+function normalizeApiKey(value) {
+  if (typeof value != "string")
+    return null;
+  let normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function getApiKey() {
+  return normalizeApiKey(process.env.TAVILY_API_KEY) ?? normalizeApiKey(loadConfig().tavilyApiKey);
+}
+function requireApiKey() {
+  let apiKey = getApiKey();
+  if (!apiKey)
+    throw new Error(`Tavily API key not found. Either:
+  1. Create ${CONFIG_PATH} with { "tavilyApiKey": "your-key" }
+  2. Set TAVILY_API_KEY environment variable
+Get a key at https://app.tavily.com/`);
+  return apiKey;
+}
+function normalizeCount(value) {
+  return typeof value != "number" || !Number.isFinite(value) ? 5 : Math.max(1, Math.min(Math.floor(value), 20));
+}
+function normalizeDomain(value) {
+  let input = value.trim().toLowerCase();
+  if (!input || (input.startsWith("-") && (input = input.slice(1).trim()), !input))
+    return null;
+  try {
+    input = (input.includes("://") ? new URL(input) : new URL(`https://${input}`)).hostname;
+  } catch {
+    input = input.split("/")[0]?.split(":")[0] ?? "";
+  }
+  return input = input.replace(/^\.+|\.+$/g, ""), /^[a-z0-9][a-z0-9.-]*\.[a-z]{2,}$/i.test(input) ? input : null;
+}
+function mapDomainFilter(domainFilter) {
+  if (!domainFilter?.length)
+    return {};
+  let include_domains = [], exclude_domains = [];
+  for (let raw of domainFilter) {
+    let domain = normalizeDomain(raw);
+    if (!domain)
+      continue;
+    let target = raw.trim().startsWith("-") ? exclude_domains : include_domains;
+    target.includes(domain) || target.push(domain);
+  }
+  return {
+    ...include_domains.length > 0 ? { include_domains } : {},
+    ...exclude_domains.length > 0 ? { exclude_domains } : {}
+  };
+}
+function requestSignal(signal) {
+  let timeout = AbortSignal.timeout(SEARCH_TIMEOUT_MS);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function mapResults(results, numResults) {
+  if (!Array.isArray(results))
+    return [];
+  let mapped = [];
+  for (let item of results)
+    if (item?.url && (mapped.push({
+      title: item.title || `Source ${mapped.length + 1}`,
+      url: item.url,
+      snippet: typeof item.content == "string" ? item.content.replace(/\s+/g, " ").trim() : ""
+    }), mapped.length >= numResults))
+      break;
+  return mapped;
+}
+function mapInlineContent(results) {
+  return Array.isArray(results) ? results.flatMap((item) => !item?.url || typeof item.raw_content != "string" || item.raw_content.trim().length === 0 ? [] : [{
+    url: item.url,
+    title: item.title || "",
+    content: item.raw_content,
+    error: null
+  }]) : [];
+}
+function isTavilyAvailable() {
+  return !!getApiKey();
+}
+async function searchWithTavily(query, options = {}) {
+  let numResults = normalizeCount(options.numResults), body = {
+    query,
+    search_depth: "basic",
+    max_results: numResults,
+    include_answer: "basic",
+    include_raw_content: options.includeContent ? "markdown" : !1,
+    ...options.recencyFilter ? { time_range: options.recencyFilter } : {},
+    ...mapDomainFilter(options.domainFilter)
+  }, activityId = activityMonitor.logStart({ type: "api", query }), response;
+  try {
+    response = await fetch(TAVILY_API_URL, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${requireApiKey()}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: requestSignal(options.signal)
+    });
+  } catch (err) {
+    let message = errorMessage(err);
+    throw message.toLowerCase().includes("abort") ? activityMonitor.logComplete(activityId, 0) : activityMonitor.logError(activityId, message), err;
+  }
+  if (!response.ok) {
+    activityMonitor.logComplete(activityId, response.status);
+    let errorText = await response.text();
+    throw new Error(`Tavily API error ${response.status}: ${errorText.slice(0, 300)}`);
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch (err) {
+    throw activityMonitor.logComplete(activityId, response.status), new Error(`Tavily API returned invalid JSON: ${errorMessage(err)}`);
+  }
+  activityMonitor.logComplete(activityId, response.status);
+  let result = {
+    answer: typeof data.answer == "string" ? data.answer : "",
+    results: mapResults(data.results, numResults)
+  };
+  if (options.includeContent) {
+    let inlineContent = mapInlineContent(data.results);
+    inlineContent.length > 0 && (result.inlineContent = inlineContent);
+  }
+  return result;
+}
+export {
+  isTavilyAvailable,
+  searchWithTavily
+};

package/dist/node-runtime/timings-UAD5BEAS.js

@@ -0,0 +1,16 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  measureStartup,
+  noteImportMain,
+  printTimings,
+  resetTimings,
+  time
+} from "./chunk-PVCDKGR6.js";
+import "./chunk-BRJX2PRC.js";
+export {
+  measureStartup,
+  noteImportMain,
+  printTimings,
+  resetTimings,
+  time
+};

package/dist/node-runtime/tool-renderer-MV5O452K.js

@@ -0,0 +1,204 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/core/export-html/ansi-to-html.js
+var ANSI_COLORS = [
+  "#000000",
+  // 0: black
+  "#800000",
+  // 1: red
+  "#008000",
+  // 2: green
+  "#808000",
+  // 3: yellow
+  "#000080",
+  // 4: blue
+  "#800080",
+  // 5: magenta
+  "#008080",
+  // 6: cyan
+  "#c0c0c0",
+  // 7: white
+  "#808080",
+  // 8: bright black
+  "#ff0000",
+  // 9: bright red
+  "#00ff00",
+  // 10: bright green
+  "#ffff00",
+  // 11: bright yellow
+  "#0000ff",
+  // 12: bright blue
+  "#ff00ff",
+  // 13: bright magenta
+  "#00ffff",
+  // 14: bright cyan
+  "#ffffff"
+  // 15: bright white
+];
+function color256ToHex(index) {
+  if (index < 16)
+    return ANSI_COLORS[index];
+  if (index < 232) {
+    let cubeIndex = index - 16, r = Math.floor(cubeIndex / 36), g = Math.floor(cubeIndex % 36 / 6), b = cubeIndex % 6, toComponent = (n) => n === 0 ? 0 : 55 + n * 40, toHex = (n) => toComponent(n).toString(16).padStart(2, "0");
+    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+  }
+  let grayHex = (8 + (index - 232) * 10).toString(16).padStart(2, "0");
+  return `#${grayHex}${grayHex}${grayHex}`;
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function createEmptyStyle() {
+  return {
+    fg: null,
+    bg: null,
+    bold: !1,
+    dim: !1,
+    italic: !1,
+    underline: !1
+  };
+}
+function styleToInlineCSS(style) {
+  let parts = [];
+  return style.fg && parts.push(`color:${style.fg}`), style.bg && parts.push(`background-color:${style.bg}`), style.bold && parts.push("font-weight:bold"), style.dim && parts.push("opacity:0.6"), style.italic && parts.push("font-style:italic"), style.underline && parts.push("text-decoration:underline"), parts.join(";");
+}
+function hasStyle(style) {
+  return style.fg !== null || style.bg !== null || style.bold || style.dim || style.italic || style.underline;
+}
+function applySgrCode(params, style) {
+  let i = 0;
+  for (; i < params.length; ) {
+    let code = params[i];
+    if (code === 0)
+      style.fg = null, style.bg = null, style.bold = !1, style.dim = !1, style.italic = !1, style.underline = !1;
+    else if (code === 1)
+      style.bold = !0;
+    else if (code === 2)
+      style.dim = !0;
+    else if (code === 3)
+      style.italic = !0;
+    else if (code === 4)
+      style.underline = !0;
+    else if (code === 22)
+      style.bold = !1, style.dim = !1;
+    else if (code === 23)
+      style.italic = !1;
+    else if (code === 24)
+      style.underline = !1;
+    else if (code >= 30 && code <= 37)
+      style.fg = ANSI_COLORS[code - 30];
+    else if (code === 38) {
+      if (params[i + 1] === 5 && params.length > i + 2)
+        style.fg = color256ToHex(params[i + 2]), i += 2;
+      else if (params[i + 1] === 2 && params.length > i + 4) {
+        let r = params[i + 2], g = params[i + 3], b = params[i + 4];
+        style.fg = `rgb(${r},${g},${b})`, i += 4;
+      }
+    } else if (code === 39)
+      style.fg = null;
+    else if (code >= 40 && code <= 47)
+      style.bg = ANSI_COLORS[code - 40];
+    else if (code === 48) {
+      if (params[i + 1] === 5 && params.length > i + 2)
+        style.bg = color256ToHex(params[i + 2]), i += 2;
+      else if (params[i + 1] === 2 && params.length > i + 4) {
+        let r = params[i + 2], g = params[i + 3], b = params[i + 4];
+        style.bg = `rgb(${r},${g},${b})`, i += 4;
+      }
+    } else code === 49 ? style.bg = null : code >= 90 && code <= 97 ? style.fg = ANSI_COLORS[code - 90 + 8] : code >= 100 && code <= 107 && (style.bg = ANSI_COLORS[code - 100 + 8]);
+    i++;
+  }
+}
+var ANSI_REGEX = /\x1b\[([\d;]*)m/g;
+function ansiToHtml(text) {
+  let style = createEmptyStyle(), result = "", lastIndex = 0, inSpan = !1;
+  ANSI_REGEX.lastIndex = 0;
+  let match = ANSI_REGEX.exec(text);
+  for (; match !== null; ) {
+    let beforeText = text.slice(lastIndex, match.index);
+    beforeText && (result += escapeHtml(beforeText));
+    let paramStr = match[1], params = paramStr ? paramStr.split(";").map((p) => parseInt(p, 10) || 0) : [0];
+    inSpan && (result += "</span>", inSpan = !1), applySgrCode(params, style), hasStyle(style) && (result += `<span style="${styleToInlineCSS(style)}">`, inSpan = !0), lastIndex = match.index + match[0].length, match = ANSI_REGEX.exec(text);
+  }
+  let remainingText = text.slice(lastIndex);
+  return remainingText && (result += escapeHtml(remainingText)), inSpan && (result += "</span>"), result;
+}
+function ansiLinesToHtml(lines) {
+  return lines.map((line) => `<div class="ansi-line">${ansiToHtml(line) || "&nbsp;"}</div>`).join("");
+}
+
+// packages/coding-agent/dist/core/export-html/tool-renderer.js
+var ANSI_ESCAPE_REGEX = /\x1b\[[\d;]*m/g;
+function isBlankRenderedLine(line) {
+  return line.replace(ANSI_ESCAPE_REGEX, "").trim().length === 0;
+}
+function trimRenderedResultLines(lines) {
+  let start = 0, end = lines.length;
+  for (; start < end && isBlankRenderedLine(lines[start]); )
+    start++;
+  for (; end > start && isBlankRenderedLine(lines[end - 1]); )
+    end--;
+  return lines.slice(start, end);
+}
+function createToolHtmlRenderer(deps) {
+  let { getToolDefinition, theme, cwd, width = 100 } = deps, renderedCallComponents = /* @__PURE__ */ new Map(), renderedResultComponents = /* @__PURE__ */ new Map(), renderedStates = /* @__PURE__ */ new Map(), renderedArgs = /* @__PURE__ */ new Map(), getState = (toolCallId) => {
+    let state = renderedStates.get(toolCallId);
+    return state || (state = {}, renderedStates.set(toolCallId, state)), state;
+  }, createRenderContext = (toolCallId, lastComponent, expanded, isPartial, isError) => ({
+    args: renderedArgs.get(toolCallId),
+    toolCallId,
+    invalidate: () => {
+    },
+    lastComponent,
+    state: getState(toolCallId),
+    cwd,
+    executionStarted: !0,
+    argsComplete: !0,
+    isPartial,
+    expanded,
+    showImages: !1,
+    isError
+  });
+  return {
+    renderCall(toolCallId, toolName, args) {
+      try {
+        renderedArgs.set(toolCallId, args);
+        let toolDef = getToolDefinition(toolName);
+        if (!toolDef?.renderCall)
+          return;
+        let component = toolDef.renderCall(args, theme, createRenderContext(toolCallId, renderedCallComponents.get(toolCallId), !1, !0, !1));
+        renderedCallComponents.set(toolCallId, component);
+        let lines = component.render(width);
+        return ansiLinesToHtml(lines);
+      } catch {
+        return;
+      }
+    },
+    renderResult(toolCallId, toolName, result, details, isError) {
+      try {
+        let toolDef = getToolDefinition(toolName);
+        if (!toolDef?.renderResult)
+          return;
+        let agentToolResult = {
+          content: result,
+          details,
+          isError
+        }, collapsedComponent = toolDef.renderResult(agentToolResult, { expanded: !1, isPartial: !1 }, theme, createRenderContext(toolCallId, renderedResultComponents.get(toolCallId), !1, !1, isError));
+        renderedResultComponents.set(toolCallId, collapsedComponent);
+        let collapsed = ansiLinesToHtml(trimRenderedResultLines(collapsedComponent.render(width))), expandedComponent = toolDef.renderResult(agentToolResult, { expanded: !0, isPartial: !1 }, theme, createRenderContext(toolCallId, renderedResultComponents.get(toolCallId), !0, !1, isError));
+        renderedResultComponents.set(toolCallId, expandedComponent);
+        let expanded = ansiLinesToHtml(trimRenderedResultLines(expandedComponent.render(width)));
+        return {
+          ...collapsed && collapsed !== expanded ? { collapsed } : {},
+          expanded
+        };
+      } catch {
+        return;
+      }
+    }
+  };
+}
+export {
+  createToolHtmlRenderer
+};

package/dist/node-runtime/update-cli-I6OVDRPL.js

@@ -0,0 +1,75 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  checkForUpdate,
+  isPublishedInstall
+} from "./chunk-BR7YDUKA.js";
+import "./chunk-DVGWF6A2.js";
+import {
+  SettingsManager
+} from "./chunk-5NWQCSKR.js";
+import "./chunk-URD2SLIT.js";
+import "./chunk-5OLJGVCB.js";
+import "./chunk-AY6CAJSL.js";
+import {
+  APP_NAME,
+  NPM_CLI_PACKAGE,
+  PACKAGE_NAME,
+  VERSION,
+  getAgentDir,
+  getPackageDir,
+  spawnProcess,
+  waitForChildProcess
+} from "./chunk-PCIGF2XK.js";
+import "./chunk-Q4Q6D4IY.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/cli/update-cli.js
+import chalk from "chalk";
+function printUpdateHelp() {
+  console.log(`${chalk.bold("Usage:")}
+  ${APP_NAME} update [--self]
+
+Reinstall the global ${NPM_CLI_PACKAGE} package from npm.
+
+Options:
+  --self    Same as \`${APP_NAME} update\` (kept for muscle memory)
+  -h, --help
+
+This does not refresh model catalogs (/refresh) or extension packages (${APP_NAME} install).
+`);
+}
+async function handleUpdateCli(args, deps = {}) {
+  if (args[0] !== "update")
+    return !1;
+  let rest = args.slice(1).filter((a) => a !== "--self");
+  if (rest.includes("-h") || rest.includes("--help"))
+    return printUpdateHelp(), process.exitCode = 0, !0;
+  if (rest.length > 0)
+    return (deps.error ?? console.error)(`Unknown argument: ${rest[0]}`), printUpdateHelp(), process.exitCode = 2, !0;
+  let npmPackage = deps.npmPackage ?? NPM_CLI_PACKAGE, appName = deps.appName ?? APP_NAME;
+  if (!(deps.published ?? isPublishedInstall(PACKAGE_NAME, npmPackage)))
+    return (deps.error ?? console.error)(`This tree is ${PACKAGE_NAME}, not a global ${NPM_CLI_PACKAGE} install. Use \`npm i -g ${NPM_CLI_PACKAGE}\` to update the published CLI; workspace \`npx ${APP_NAME}\` is not self-updated.`), process.exitCode = 1, !0;
+  let log = deps.log ?? console.log, error = deps.error ?? console.error, result = await (deps.check ?? checkForUpdate)({
+    currentVersion: deps.currentVersion ?? VERSION,
+    agentDir: getAgentDir(),
+    published: !0,
+    packageName: npmPackage,
+    appName,
+    offline: process.env.PI_OFFLINE === "1",
+    force: !0
+  });
+  if (!result)
+    return error("Could not reach the npm registry to check for updates."), process.exitCode = 1, !0;
+  if (!result.newer)
+    return log(`${appName} ${result.current} is up to date.`), process.exitCode = 0, !0;
+  let cwd = process.cwd(), npmArgv = SettingsManager.create(cwd, getAgentDir(), { projectTrusted: !1 }).getNpmCommand() ?? ["npm"], installArgv = [...npmArgv.slice(1), "install", "-g", `${npmPackage}@${result.latest}`], command = npmArgv[0] ?? "npm", packageDir = deps.packageDir ?? getPackageDir();
+  (deps.warn ?? console.warn)(`Installing ${npmPackage}@${result.latest}. If this process is the global install (${packageDir}), Windows may fail to overwrite files until ${appName} exits.`);
+  let code = await (deps.spawn ?? (async (cmd, argv) => {
+    let child = spawnProcess(cmd, argv, { stdio: "inherit" });
+    return waitForChildProcess(child);
+  }))(command, installArgv);
+  return process.exitCode = code === 0 || code === null ? 0 : code, (process.exitCode ?? 0) === 0 && log(`Updated ${appName} ${result.current} \u2192 ${result.latest}.`), !0;
+}
+export {
+  handleUpdateCli
+};