@ai-matrx/chat 0.1.77 → 0.2.1

package/dist/tool-call-visualization/renderers/search/parseSearch.js

@@ -0,0 +1,271 @@
+function getDomain(url) {
+  try {
+    return new URL(url).hostname.replace(/^www\./, "");
+  } catch {
+    const stripped = url.replace(/^https?:\/\//, "").replace(/^www\./, "");
+    const slash = stripped.indexOf("/");
+    return slash === -1 ? stripped : stripped.slice(0, slash);
+  }
+}
+function getFaviconUrl(url, size = 32) {
+  const domain = getDomain(url);
+  if (!domain) return "";
+  return `https://www.google.com/s2/favicons?domain=${domain}&sz=${size}`;
+}
+function getSiteName(url) {
+  const domain = getDomain(url);
+  if (!domain) return "";
+  const labels = domain.split(".").filter(Boolean);
+  const TWO_PART_TLD = /* @__PURE__ */ new Set(["co", "com", "org", "net", "gov", "edu", "ac"]);
+  let mainIdx = labels.length - 2;
+  if (labels.length >= 3 && TWO_PART_TLD.has(labels[labels.length - 2]) && labels[labels.length - 1].length <= 3) {
+    mainIdx = labels.length - 3;
+  }
+  const main = labels[mainIdx] ?? domain;
+  const titled = main.split(/[-_]/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+  return titled || domain;
+}
+function getBreadcrumbParts(url) {
+  try {
+    const u = new URL(url);
+    const origin = `${u.protocol}//${u.host}`;
+    const segments = u.pathname.replace(/\/+$/, "").split("/").filter(Boolean).slice(0, 3).map((s) => {
+      try {
+        return decodeURIComponent(s);
+      } catch {
+        return s;
+      }
+    });
+    return { origin, segments };
+  } catch {
+    return { origin: url, segments: [] };
+  }
+}
+function baseUrlKey(url) {
+  if (!url) return "";
+  try {
+    const u = new URL(url);
+    const host = u.hostname.replace(/^www\./, "");
+    const path = u.pathname.replace(/\/+$/, "");
+    return `${host}${path}`.toLowerCase();
+  } catch {
+    return url.trim().replace(/[?#].*$/, "").replace(/\/+$/, "").toLowerCase();
+  }
+}
+function dedupeByBaseUrl(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const item of items) {
+    const key = baseUrlKey(item.url);
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    out.push(item);
+  }
+  return out;
+}
+function formatDate(value) {
+  if (!value) return void 0;
+  const parsed = Date.parse(value);
+  if (Number.isNaN(parsed)) return value;
+  return new Date(parsed).toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+}
+const READ_BLOCK_RE = /<read_result>([\s\S]*?)<\/read_result>/g;
+function extractReads(raw) {
+  const reads = [];
+  let match;
+  READ_BLOCK_RE.lastIndex = 0;
+  while ((match = READ_BLOCK_RE.exec(raw)) !== null) {
+    const body = match[1];
+    const url = body.match(/^\s*url\s*:\s*(.+)$/im)?.[1]?.trim() ?? body.match(/^\s*URL\s*:\s*(.+)$/m)?.[1]?.trim() ?? "";
+    const title = body.match(/^\s*title\s*:\s*(.+)$/im)?.[1]?.trim() ?? void 0;
+    let text = body.replace(/^\s*url\s*:\s*.+$/im, "").replace(/^\s*title\s*:\s*.+$/im, "").trim();
+    text = text.replace(/^\s*(?:text|content)\s*:\s*/i, "").trim();
+    if (url || text) {
+      reads.push({ url, title, text });
+    }
+  }
+  const rest = raw.replace(READ_BLOCK_RE, "").trim();
+  return { reads, rest };
+}
+function parseSearchedLine(raw) {
+  const line = raw.match(/^Searched:\s*(.+)$/m)?.[1];
+  if (!line) return [];
+  const out = [];
+  const re = /"([^"]+)"\s*\((\d+)\)/g;
+  let m;
+  while ((m = re.exec(line)) !== null) out.push(m[1]);
+  return out;
+}
+function parseResultEntry(block) {
+  const titleLine = block.match(/^\s*Title:\s*(.+)$/m)?.[1]?.trim();
+  const url = block.match(/^\s*URL:\s*(.+)$/im)?.[1]?.trim();
+  if (!titleLine && !url) return null;
+  const dateMatch = titleLine?.match(/\(([^)]+)\)\s*$/);
+  const date = dateMatch?.[1]?.trim();
+  const title = (titleLine ?? url ?? "").replace(/\s*\([^)]+\)\s*$/, "").trim();
+  const description = block.match(/^\s*Description:\s*(.+)$/m)?.[1]?.trim();
+  const extra = block.match(/^\s*Extra Snippets:\s*(.+)$/m)?.[1]?.trim();
+  let snippet = [description, extra].filter(Boolean).join(" \u2014 ");
+  if (!snippet && url) {
+    const lines = block.split("\n").map((l) => l.trim());
+    const urlIdx = lines.findIndex((l) => /^URL:/i.test(l));
+    if (urlIdx !== -1) {
+      const tail = lines.slice(urlIdx + 1).filter(
+        (l) => l.length > 0 && !/^(Title|URL|Description|Extra Snippets):/i.test(l)
+      );
+      snippet = tail.join(" ").trim();
+    }
+  }
+  return {
+    title: title || url || "Untitled",
+    url: url ?? "",
+    date,
+    snippet: snippet || void 0
+  };
+}
+function parseGroups(raw) {
+  const groups = [];
+  const headerRe = /^##\s+"([^"]+)"\s*\((\d+)(?:\s+results?)?\)\s*$/gim;
+  const headers = [];
+  let hm;
+  while ((hm = headerRe.exec(raw)) !== null) {
+    headers.push({
+      query: hm[1],
+      count: parseInt(hm[2], 10) || 0,
+      index: hm.index,
+      headerLen: hm[0].length
+    });
+  }
+  for (let i = 0; i < headers.length; i++) {
+    const h = headers[i];
+    const bodyStart = h.index + h.headerLen;
+    const bodyEnd = i + 1 < headers.length ? headers[i + 1].index : raw.length;
+    let body = raw.slice(bodyStart, bodyEnd);
+    body = body.replace(/\n#+\s+[\s\S]*$/, "").replace(/\n---\s*\n\s*##[\s\S]*$/, "").trim();
+    const entries = body.split(/\n\s*\n(?=\s*Title:)/i);
+    const results = [];
+    for (const entry of entries) {
+      if (!/Title:/i.test(entry) && !/URL:/i.test(entry)) continue;
+      const parsed = parseResultEntry(entry);
+      if (parsed) results.push(parsed);
+    }
+    groups.push({
+      query: h.query,
+      count: h.count || results.length,
+      results: dedupeByBaseUrl(results)
+    });
+  }
+  return groups;
+}
+function extractReport(raw) {
+  const CURATED = "# Curated Research Results";
+  const NEXT_STEPS = "\n## Next steps:";
+  const start = raw.indexOf(CURATED);
+  if (start === -1) return null;
+  const after = raw.slice(start + CURATED.length);
+  const nsIdx = after.indexOf(NEXT_STEPS);
+  const reportRaw = (nsIdx !== -1 ? after.slice(0, nsIdx) : after).trim();
+  const report = reportRaw.replace(/^The following is the result of[^\n]*\n+/i, "").trim();
+  return report.length > 0 ? report : null;
+}
+const EMPTY_PARSED = {
+  queries: [],
+  groups: [],
+  reads: [],
+  sources: [],
+  domains: [],
+  totalReported: 0,
+  report: null
+};
+function parseSearch(raw) {
+  if (!raw || typeof raw !== "string") return EMPTY_PARSED;
+  const { reads, rest } = extractReads(raw);
+  const groups = parseGroups(rest);
+  const report = extractReport(raw);
+  const searchedQueries = parseSearchedLine(rest);
+  const groupQueries = groups.map((g) => g.query);
+  const queries = searchedQueries.length > 0 ? searchedQueries : groupQueries;
+  for (const q of groupQueries) {
+    if (!queries.includes(q)) queries.push(q);
+  }
+  const flat = [];
+  for (const group of groups) {
+    for (const r of group.results) {
+      if (!r.url) continue;
+      flat.push({
+        title: r.title,
+        url: r.url,
+        domain: getDomain(r.url),
+        date: r.date,
+        snippet: r.snippet
+      });
+    }
+  }
+  for (const rd of reads) {
+    if (!rd.url) continue;
+    flat.push({
+      title: rd.title ?? getDomain(rd.url),
+      url: rd.url,
+      domain: getDomain(rd.url),
+      snippet: rd.text ? rd.text.slice(0, 240) : void 0
+    });
+  }
+  const sources = dedupeByBaseUrl(flat);
+  const domainCounts = /* @__PURE__ */ new Map();
+  for (const s of sources) {
+    if (!s.domain) continue;
+    domainCounts.set(s.domain, (domainCounts.get(s.domain) ?? 0) + 1);
+  }
+  const domains = Array.from(domainCounts.entries()).map(([domain, count]) => ({ domain, count })).sort((a, b) => b.count - a.count || a.domain.localeCompare(b.domain));
+  const totalReported = groups.reduce(
+    (acc, g) => acc + (g.count || g.results.length),
+    0
+  );
+  return { queries, groups, reads, sources, domains, totalReported, report };
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function sourceName(value) {
+  if (typeof value === "string") return value || void 0;
+  if (value && typeof value === "object") {
+    const name = value.name;
+    return asString(name);
+  }
+  return void 0;
+}
+function parseHeadlines(result) {
+  if (!result) return { articles: [], totalResults: 0 };
+  const rawArticles = Array.isArray(result.articles) ? result.articles : [];
+  const articles = [];
+  for (const a of rawArticles) {
+    const title = asString(a.title);
+    const url = asString(a.url);
+    if (!title && !url) continue;
+    articles.push({
+      title: title ?? url ?? "Untitled",
+      url: url ?? "",
+      source: sourceName(a.source),
+      publishedAt: asString(a.publishedAt) ?? asString(a.published_at),
+      description: asString(a.description),
+      imageUrl: asString(a.urlToImage) ?? asString(a.url_to_image)
+    });
+  }
+  const totalResults = typeof result.total_results === "number" ? result.total_results : typeof result.totalResults === "number" ? result.totalResults : articles.length;
+  return { articles, totalResults };
+}
+export {
+  baseUrlKey,
+  dedupeByBaseUrl,
+  formatDate,
+  getBreadcrumbParts,
+  getDomain,
+  getFaviconUrl,
+  getSiteName,
+  parseHeadlines,
+  parseSearch
+};

package/dist/tool-call-visualization/renderers/search/useGraduatedReveal.d.ts

@@ -0,0 +1,26 @@
+export interface GraduatedRevealOptions {
+    /** While true, the count grows on a timer. While false → reveal everything. */
+    active: boolean;
+    /** How many items are visible at t=0 of a reveal. Default 4. */
+    initial?: number;
+    /** How many more items appear on each tick. Default 2. */
+    step?: number;
+    /** Milliseconds between ticks. Default 450. */
+    intervalMs?: number;
+    /**
+     * Bump to restart the reveal from `initial` (e.g. a simulator Play/Replay
+     * key, or the callId so a fresh tool call restarts paced reveal).
+     */
+    replayKey?: string | number;
+}
+export interface GraduatedReveal<T> {
+    /** The items currently visible — `items` sliced to `visibleCount`. */
+    visible: T[];
+    /** How many items are visible right now. */
+    visibleCount: number;
+    /** Total items available (`items.length`). */
+    total: number;
+    /** True while still revealing (active AND more remain). */
+    isRevealing: boolean;
+}
+export declare function useGraduatedReveal<T>(items: T[], opts: GraduatedRevealOptions): GraduatedReveal<T>;

package/dist/tool-call-visualization/renderers/search/useGraduatedReveal.js

@@ -0,0 +1,34 @@
+"use client";
+import { useEffect, useRef, useState } from "react";
+function useGraduatedReveal(items, opts) {
+  const { active, initial = 4, step = 2, intervalMs = 450, replayKey } = opts;
+  const [count, setCount] = useState(initial);
+  const timerRef = useRef(null);
+  useEffect(() => {
+    setCount(initial);
+  }, [replayKey, initial]);
+  useEffect(() => {
+    if (timerRef.current) {
+      clearInterval(timerRef.current);
+      timerRef.current = null;
+    }
+    if (!active) return void 0;
+    timerRef.current = setInterval(() => {
+      setCount((c) => c + step);
+    }, intervalMs);
+    return () => {
+      if (timerRef.current) {
+        clearInterval(timerRef.current);
+        timerRef.current = null;
+      }
+    };
+  }, [active, step, intervalMs, replayKey]);
+  const total = items.length;
+  const visibleCount = active ? Math.min(count, total) : total;
+  const visible = active ? items.slice(0, visibleCount) : items;
+  const isRevealing = active && visibleCount < total;
+  return { visible, visibleCount, total, isRevealing };
+}
+export {
+  useGraduatedReveal
+};

package/dist/tool-call-visualization/renderers/shell/ShellInline.d.ts

@@ -0,0 +1,60 @@
+/**
+ * ShellInline — the human renderer for the process-execution tools
+ * (`shell_execute`, `shell_python`, `code_execute_python`).
+ *
+ * Until now these fell to `GenericRenderer`, which dumps `stdout` /
+ * `stderr` / `exit_code` / `backend` / `cwd` / `log_path` as six equal-weight
+ * key/value rows — so the reader of a chat had to hunt a key/value table to
+ * learn whether the command they just watched an agent run actually worked.
+ * This is the `fs_*` "OUCH" fix applied to the one family that still had it.
+ *
+ * THE READER'S QUESTION: *what ran, where, and did it work?*
+ *   • The command IS the headline, monospace, at a terminal's weight.
+ *   • Exit code is a chip, and a nonzero one is red — a failed run is a
+ *     RESULT (the backend returns the payload with success=false), so it must
+ *     never read like a success.
+ *   • Output is a bounded terminal block: the last `TAIL_LINES` lines by
+ *     default with a "Show all N lines" control, because the tail is where a
+ *     command's verdict lives. stderr is tinted, never hidden.
+ *   • The BACKEND is always named. `sandbox` = the bound container;
+ *     `host` = aidream's scoped workspace; `durable_vfs` = the in-process
+ *     coreutils emulator — which is NOT the user's sandbox. A routing defect
+ *     has silently sent a sandbox-bound conversation to the emulator before,
+ *     and neither the agent nor the operator could tell. That case gets a
+ *     loud red badge saying so, with the remedy, rather than a quiet word.
+ *
+ * Shapes are read DEFENSIVELY: an unrecognised payload falls through to
+ * <GenericRenderer> — never a wrong guess.
+ */
+import React from "react";
+import type { ToolRendererProps } from "../../types.js";
+/** How much output the collapsed view shows before offering the rest. */
+export declare const TAIL_LINES = 12;
+/**
+ * The wording for a result that ran somewhere other than the box the user
+ * believes is bound. Exported so the guard asserts the exact sentence a
+ * reader sees, not a paraphrase of it.
+ */
+export declare const DURABLE_VFS_BADGE_TEXT = "not your sandbox \u2014 binding was lost";
+interface ProcessResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+    backend: string | null;
+    cwd: string | null;
+    truncated: boolean;
+}
+/**
+ * Narrow the `shell_execution` payload. Returns null when the result carries
+ * none of the process fields — that is a shape we do not understand, and the
+ * generic floor is the honest answer for it.
+ */
+export declare function asProcessResult(result: Record<string, unknown> | null): ProcessResult | null;
+/**
+ * The loud badge for a command that ran in the durable-VFS emulator rather
+ * than the bound container. Never quiet: the whole point is that the silent
+ * version of this cost an operator an afternoon.
+ */
+export declare const DurableVfsWarning: React.FC;
+export declare const ShellInline: React.FC<ToolRendererProps>;
+export default ShellInline;

package/dist/tool-call-visualization/renderers/shell/ShellInline.js

@@ -0,0 +1,158 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import React from "react";
+import { AlertTriangle, SquareTerminal } from "lucide-react";
+import { cn } from "@ai-matrx/design-system";
+import { getArg, isTerminal, resultAsObject } from "../_shared.js";
+import { GenericRenderer } from "../../registry/GenericRenderer.js";
+import { ToolErrorCard } from "../../result-fields/ToolErrorCard.js";
+import { ToolResultCard } from "../_shared-entity/ToolResultCard.js";
+import { ErrorAlchemyMenu } from "../../../host/ui-slots.js";
+import { Tile } from "@ai-matrx/design-system/controls";
+const TAIL_LINES = 12;
+const DURABLE_VFS_BADGE_TEXT = "not your sandbox \u2014 binding was lost";
+const SHELL_ICON_TINT = "text-slate-600 dark:text-slate-300";
+function str(value) {
+  return typeof value === "string" ? value : "";
+}
+function asProcessResult(result) {
+  if (!result) return null;
+  const hasProcessShape = "stdout" in result || "stderr" in result || "exit_code" in result;
+  if (!hasProcessShape) return null;
+  return {
+    stdout: str(result.stdout),
+    stderr: str(result.stderr),
+    exitCode: typeof result.exit_code === "number" && Number.isFinite(result.exit_code) ? result.exit_code : null,
+    backend: typeof result.backend === "string" ? result.backend : null,
+    cwd: typeof result.cwd === "string" ? result.cwd : null,
+    truncated: result.stdout_truncated === true || result.stderr_truncated === true
+  };
+}
+const Chip = ({
+  children,
+  tone
+}) => /* @__PURE__ */ jsx(
+  "span",
+  {
+    className: cn(
+      "text-xs tabular-nums",
+      tone === "bad" ? "font-medium text-red-600 dark:text-red-400" : "text-muted-foreground"
+    ),
+    children
+  }
+);
+const DurableVfsWarning = () => /* @__PURE__ */ jsxs(
+  "div",
+  {
+    role: "alert",
+    "data-testid": "shell-durable-vfs-warning",
+    className: "flex items-start gap-2 border-t border-red-500/30 bg-red-50 px-4 py-2 text-xs text-red-700 dark:bg-red-950/40 dark:text-red-300",
+    children: [
+      /* @__PURE__ */ jsx(AlertTriangle, { className: "mt-0.5 size-3.5 shrink-0" }),
+      /* @__PURE__ */ jsxs("span", { children: [
+        /* @__PURE__ */ jsxs("span", { className: "font-semibold", children: [
+          "Ran in the durable file store \u2014 ",
+          DURABLE_VFS_BADGE_TEXT,
+          "."
+        ] }),
+        " ",
+        "This emulator has no git, no loops and no shell redirection, so results can differ from the container. Re-attach a running sandbox from the chat input's sandbox control and run the command again."
+      ] }),
+      /* @__PURE__ */ jsx(ErrorAlchemyMenu, {})
+    ]
+  }
+);
+const OutputBlock = ({ text, stream }) => {
+  const [showAll, setShowAll] = React.useState(false);
+  const lines = text.replace(/\n+$/, "").split("\n");
+  const hidden = Math.max(0, lines.length - TAIL_LINES);
+  const shown = showAll || hidden === 0 ? lines : lines.slice(-TAIL_LINES);
+  return /* @__PURE__ */ jsxs("div", { className: "border-t border-border/30", children: [
+    hidden > 0 && /* @__PURE__ */ jsx(Tile, { variant: "quiet", title: showAll ? `Show last ${TAIL_LINES} lines` : `Show all ${lines.length} lines`, onClick: (ev) => {
+      ev.stopPropagation();
+      setShowAll((v) => !v);
+    } }),
+    /* @__PURE__ */ jsx(
+      "pre",
+      {
+        className: cn(
+          // `overflow-x-auto` on the block itself: a long line scrolls HERE
+          // and never widens the transcript (the 390px rule).
+          "max-h-80 overflow-auto whitespace-pre px-4 py-2 font-mono text-xs leading-relaxed",
+          stream === "stderr" ? "text-amber-700 dark:text-amber-400" : "text-foreground"
+        ),
+        children: shown.join("\n")
+      }
+    )
+  ] });
+};
+const ShellResultCard = ({ command, result, ...shell }) => {
+  const failed = result.exitCode !== null && result.exitCode !== 0;
+  const sub = [
+    result.exitCode !== null ? `exit ${result.exitCode}` : null,
+    result.backend ? `ran in ${result.backend}` : null,
+    result.cwd,
+    result.truncated ? "output truncated" : null
+  ].filter(Boolean).join(" \xB7 ");
+  return /* @__PURE__ */ jsx(
+    ToolResultCard,
+    {
+      icon: SquareTerminal,
+      iconClassName: SHELL_ICON_TINT,
+      title: command || "Command",
+      sub: sub || null,
+      headerAction: result.exitCode !== null ? /* @__PURE__ */ jsx(Chip, { tone: failed ? "bad" : void 0, children: failed ? `exit ${result.exitCode}` : "exit 0" }) : void 0,
+      ...shell,
+      children: /* @__PURE__ */ jsxs("div", { children: [
+        result.backend === "durable_vfs" && /* @__PURE__ */ jsx(DurableVfsWarning, {}),
+        result.stdout.trim() !== "" && /* @__PURE__ */ jsx(OutputBlock, { text: result.stdout, stream: "stdout" }),
+        result.stderr.trim() !== "" && /* @__PURE__ */ jsx(OutputBlock, { text: result.stderr, stream: "stderr" }),
+        result.stdout.trim() === "" && result.stderr.trim() === "" && /* @__PURE__ */ jsx("p", { className: "border-t border-border/30 px-4 py-2 text-xs text-muted-foreground", children: "No output." })
+      ] })
+    }
+  );
+};
+const ShellInline = (props) => {
+  const {
+    entry,
+    onOpenOverlay,
+    onOpenWindowPanel,
+    toolGroupId,
+    expanded,
+    onToggleExpanded
+  } = props;
+  if (entry.status === "error") {
+    return /* @__PURE__ */ jsx(
+      ToolErrorCard,
+      {
+        entry,
+        onOpenOverlay,
+        toolGroupId
+      }
+    );
+  }
+  if (!isTerminal(entry)) return null;
+  const result = asProcessResult(resultAsObject(entry));
+  if (!result) return /* @__PURE__ */ jsx(GenericRenderer, { ...props });
+  const command = getArg(entry, "command") || getArg(entry, "code") || getArg(entry, "script") || "";
+  return /* @__PURE__ */ jsx(
+    ShellResultCard,
+    {
+      command,
+      result,
+      expanded,
+      onToggleExpanded,
+      onOpenWindowPanel: onOpenWindowPanel ? () => onOpenWindowPanel() : void 0,
+      onOpenOverlay: onOpenOverlay ? () => onOpenOverlay() : void 0
+    }
+  );
+};
+var ShellInline_default = ShellInline;
+export {
+  DURABLE_VFS_BADGE_TEXT,
+  DurableVfsWarning,
+  ShellInline,
+  TAIL_LINES,
+  asProcessResult,
+  ShellInline_default as default
+};

package/dist/tool-call-visualization/renderers/skill/SkillInline.d.ts

@@ -0,0 +1,22 @@
+/**
+ * SkillInline — the renderer for the `skill` tool (and legacy `skill_search` /
+ * `skill_list`). Registered with `chrome: "card"`, so the shell renders THIS
+ * card directly — no folded glyph line above it, no duplicate icon/label.
+ *
+ * Built ON the canonical `ToolResultCard` (owner rule: one template, never
+ * reinvented): full-width header (icon · title · sub), click-anywhere toggle,
+ * bordered "Open" dropdown with the canonical Window Panel · Tool Admin pair.
+ *
+ * Density follows intent (owner-specified, 2026-07-15):
+ *   • SEARCH is a keyword lookup — show WHAT WAS FOUND, nice and small: one
+ *     line per hit (label · humanized type). No descriptions, no ids.
+ *   • GET is the agent adopting a skill — now the detail matters: full
+ *     description, category chips, trigger patterns. The huge markdown `body`
+ *     stays in Tool Admin / Raw.
+ *
+ * Shapes read defensively; anything unrecognized falls to <GenericRenderer>.
+ */
+import React from "react";
+import type { ToolRendererProps } from "../../types.js";
+export declare const SkillInline: React.FC<ToolRendererProps>;
+export default SkillInline;

package/dist/tool-call-visualization/renderers/skill/SkillInline.js

@@ -0,0 +1,113 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { LibraryBig } from "lucide-react";
+import { cn } from "@ai-matrx/design-system";
+import { getArg, isTerminal, resultAsObject } from "../_shared.js";
+import { GenericRenderer } from "../../registry/GenericRenderer.js";
+import { ToolErrorCard } from "../../result-fields/ToolErrorCard.js";
+import { humanizeEnumValue } from "../../result-fields/shape.js";
+import { ToolResultCard } from "../_shared-entity/ToolResultCard.js";
+import { catalogProseText } from "../../../utils/content-ir/surfaces/kind-one-line.js";
+const SKILL_ICON_TINT = "text-violet-600 dark:text-violet-400";
+function humanType(raw) {
+  if (typeof raw !== "string" || !raw) return null;
+  return humanizeEnumValue(raw) ?? raw;
+}
+function asHint(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const o = raw;
+  const label = typeof o.label === "string" && o.label || typeof o.skill_id === "string" && o.skill_id || null;
+  if (!label) return null;
+  return { label, type: humanType(o.skill_type) };
+}
+function stringArray(raw) {
+  return Array.isArray(raw) ? raw.filter((v) => typeof v === "string") : [];
+}
+const SkillInline = (props) => {
+  const { entry, onOpenOverlay, onOpenWindowPanel, toolGroupId, expanded, onToggleExpanded } = props;
+  if (entry.status === "error") {
+    return /* @__PURE__ */ jsx(ToolErrorCard, { entry, onOpenOverlay, toolGroupId });
+  }
+  if (!isTerminal(entry)) return null;
+  const result = resultAsObject(entry);
+  const cardShellProps = {
+    icon: LibraryBig,
+    iconClassName: SKILL_ICON_TINT,
+    expanded,
+    onToggleExpanded,
+    onOpenWindowPanel: onOpenWindowPanel ? () => onOpenWindowPanel() : void 0,
+    onOpenOverlay: onOpenOverlay ? () => onOpenOverlay() : void 0
+  };
+  const hintArray = result && (Array.isArray(result.hints) ? result.hints : Array.isArray(result.skills) ? result.skills : null);
+  if (hintArray) {
+    const hints = hintArray.map(asHint).filter((h) => h !== null);
+    if (hints.length > 0 || hintArray.length === 0) {
+      const query = typeof result?.query === "string" && result.query || getArg(entry, "query") || null;
+      return /* @__PURE__ */ jsx(
+        ToolResultCard,
+        {
+          ...cardShellProps,
+          title: `Found ${hints.length} ${hints.length === 1 ? "skill" : "skills"}`,
+          sub: query ? `\u201C${query}\u201D` : null,
+          children: hints.length > 0 ? /* @__PURE__ */ jsx("div", { children: hints.map((h, i) => /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: cn(
+                "flex items-baseline gap-2 px-4 py-1.5",
+                i > 0 && "border-t border-border/30"
+              ),
+              children: [
+                /* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1 truncate text-[13px] text-foreground", children: h.label }),
+                h.type && /* @__PURE__ */ jsx("span", { className: "shrink-0 text-xs text-muted-foreground", children: h.type })
+              ]
+            },
+            `${h.label}-${i}`
+          )) }) : void 0
+        }
+      );
+    }
+  }
+  if (result && (typeof result.skill_id === "string" || typeof result.label === "string")) {
+    const label = typeof result.label === "string" && result.label || result.skill_id || "Skill";
+    const type = humanType(result.skill_type);
+    const version = typeof result.version === "number" ? `v${result.version}` : null;
+    const description = typeof result.description === "string" ? catalogProseText(result.description.trim()) : "";
+    const categories = stringArray(result.category_path);
+    const triggers = stringArray(result.trigger_patterns);
+    return /* @__PURE__ */ jsx(
+      ToolResultCard,
+      {
+        ...cardShellProps,
+        title: label,
+        sub: ["Skill", type, version].filter(Boolean).join(" \xB7 "),
+        children: (description || categories.length > 0 || triggers.length > 0) && /* @__PURE__ */ jsxs("div", { className: "space-y-2.5 px-4 py-3", children: [
+          description && /* @__PURE__ */ jsx("p", { className: "whitespace-pre-line text-[13px] leading-relaxed text-foreground", children: description }),
+          (categories.length > 0 || triggers.length > 0) && /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-1.5", children: [
+            categories.map((c) => /* @__PURE__ */ jsx(
+              "span",
+              {
+                className: "rounded-md bg-muted px-1.5 py-0.5 text-xs font-medium text-muted-foreground",
+                children: c
+              },
+              `c-${c}`
+            )),
+            triggers.map((t) => /* @__PURE__ */ jsx(
+              "span",
+              {
+                className: "rounded-md border border-border/50 px-1.5 py-0.5 text-xs text-muted-foreground",
+                children: t
+              },
+              `t-${t}`
+            ))
+          ] })
+        ] })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(GenericRenderer, { ...props });
+};
+var SkillInline_default = SkillInline;
+export {
+  SkillInline,
+  SkillInline_default as default
+};