@tangle-network/ui 11.10.0 → 11.11.1

package/dist/chunk-ND3ZFXQK.js

@@ -1,179 +0,0 @@
-// src/utils/tool-display.ts
-var TOOL_NAME_PREFIX = "tool:";
-function normalizeToolName(tool) {
-  const n = tool?.toLowerCase() ?? "";
-  return n.startsWith(TOOL_NAME_PREFIX) ? n.slice(TOOL_NAME_PREFIX.length) : n;
-}
-function extractString(obj, key) {
-  if (typeof obj === "object" && obj !== null && key in obj) {
-    const val = obj[key];
-    if (typeof val === "string") return val;
-  }
-  return void 0;
-}
-function extractCommand(input) {
-  if (typeof input === "string") return input;
-  return extractString(input, "command") ?? extractString(input, "cmd");
-}
-function extractFilePath(input) {
-  return extractString(input, "file_path") ?? extractString(input, "path") ?? extractString(input, "filePath") ?? extractString(input, "file");
-}
-var TOOL_CATEGORY_ICONS = {
-  command: "terminal",
-  write: "file-plus",
-  read: "file-text",
-  search: "search",
-  edit: "file-edit",
-  task: "cpu",
-  web: "globe",
-  todo: "check-square",
-  other: "box"
-};
-function getToolCategory(toolName) {
-  const name = normalizeToolName(toolName);
-  switch (name) {
-    case "bash":
-    case "shell":
-    case "command":
-    case "execute":
-      return "command";
-    case "write":
-    case "write_file":
-    case "create_file":
-      return "write";
-    case "read":
-    case "read_file":
-    case "cat":
-      return "read";
-    case "grep":
-    case "search":
-    case "rg":
-      return "search";
-    case "edit":
-    case "patch":
-    case "sed":
-      return "edit";
-    case "glob":
-    case "find":
-    case "ls":
-      return "search";
-    case "web_search":
-    case "web_fetch":
-    case "fetch":
-      return "web";
-    case "task":
-    case "agent":
-    case "spawn":
-      return "task";
-    case "todo":
-    case "todo_write":
-      return "todo";
-    default:
-      return "other";
-  }
-}
-function getToolDisplayMetadata(part) {
-  const name = normalizeToolName(part.tool);
-  const input = part.state.status !== "pending" ? part.state.input : void 0;
-  const filePath = extractFilePath(input);
-  const command = extractCommand(input);
-  switch (name) {
-    case "bash":
-    case "shell":
-    case "command":
-    case "execute":
-      return {
-        title: "Shell",
-        description: command ? truncateCommand(command) : void 0,
-        displayVariant: "command",
-        commandSnippet: command
-      };
-    case "write":
-    case "write_file":
-    case "create_file":
-      return {
-        title: "Write",
-        description: filePath,
-        displayVariant: "write-file",
-        targetPath: filePath
-      };
-    case "edit":
-    case "patch":
-      return {
-        title: "Edit",
-        description: filePath,
-        hasDiffOutput: true,
-        diffFilePath: filePath,
-        displayVariant: "diff",
-        targetPath: filePath
-      };
-    case "read":
-    case "read_file":
-    case "cat":
-      return {
-        title: "Read",
-        description: filePath,
-        displayVariant: "read-file",
-        targetPath: filePath
-      };
-    case "grep":
-    case "search":
-    case "rg": {
-      const pattern = extractString(input, "pattern");
-      return {
-        title: "Search",
-        description: pattern,
-        displayVariant: "grep"
-      };
-    }
-    case "glob":
-    case "find":
-    case "ls": {
-      const pattern = extractString(input, "pattern");
-      return {
-        title: "Find",
-        description: pattern,
-        displayVariant: "glob"
-      };
-    }
-    case "web_search":
-    case "web_fetch":
-    case "fetch": {
-      const query = extractString(input, "query") ?? extractString(input, "url");
-      return {
-        title: name === "web_search" ? "Web search" : "Fetch",
-        description: query ? truncateCommand(query) : void 0,
-        displayVariant: "web-search"
-      };
-    }
-    case "task":
-    case "agent":
-    case "spawn": {
-      const desc = extractString(input, "description") ?? extractString(input, "prompt");
-      return {
-        title: "Task",
-        description: desc ? truncateCommand(desc) : void 0
-      };
-    }
-    default:
-      return {
-        title: part.tool || "Tool",
-        description: command ?? filePath ?? extractString(input, "pattern") ?? extractString(input, "query")
-      };
-  }
-}
-function truncateCommand(cmd) {
-  const first = cmd.split("\n")[0];
-  return first.length > 60 ? first.slice(0, 57) + "..." : first;
-}
-function getToolErrorText(part, fallback) {
-  if (part.state.status !== "error") return void 0;
-  return part.state.error || fallback;
-}
-
-export {
-  TOOL_CATEGORY_ICONS,
-  getToolCategory,
-  getToolDisplayMetadata,
-  getToolErrorText
-};

package/dist/chunk-OEX7NZE3.js

@@ -1,321 +0,0 @@
-// src/stores/active-sessions-store.ts
-import { useStore } from "@nanostores/react";
-import { atom } from "nanostores";
-import { useMemo } from "react";
-var INITIAL_STATE = {
-  sessions: {},
-  lastUpdatedAt: 0
-};
-var STATUS_PRIORITY = {
-  running: 0,
-  error: 1,
-  "attention-needed": 2,
-  idle: 3
-};
-var DEFAULT_RECORD = {
-  status: "idle",
-  isRunning: false,
-  isForeground: false,
-  needsAttention: false,
-  connectionState: "disconnected",
-  reconnectState: "idle",
-  transportMode: null,
-  lastError: null,
-  lastEventAt: null
-};
-var activeSessionsAtom = atom(INITIAL_STATE);
-var foregroundSessionId = null;
-function createRecord(options, now) {
-  return {
-    sessionId: options.sessionId,
-    projectId: options.projectId ?? null,
-    projectLabel: options.projectLabel,
-    title: options.title,
-    href: options.href,
-    registeredAt: now,
-    lastActivityAt: now,
-    metadata: options.metadata,
-    ...DEFAULT_RECORD,
-    isForeground: options.sessionId === foregroundSessionId
-  };
-}
-function resolveStatus(session) {
-  if (session.isRunning) return "running";
-  if (session.lastError || session.reconnectState === "failed") return "error";
-  if (session.needsAttention) return "attention-needed";
-  return "idle";
-}
-function normalizeSession(session) {
-  return {
-    ...session,
-    status: resolveStatus(session)
-  };
-}
-function updateSession(sessionId, updater) {
-  const current = activeSessionsAtom.get();
-  const existing = current.sessions[sessionId];
-  if (!existing) return;
-  const now = Date.now();
-  activeSessionsAtom.set({
-    sessions: {
-      ...current.sessions,
-      [sessionId]: normalizeSession(updater(existing, now))
-    },
-    lastUpdatedAt: now
-  });
-}
-function registerActiveSession(options) {
-  const now = Date.now();
-  const current = activeSessionsAtom.get();
-  const existing = current.sessions[options.sessionId];
-  activeSessionsAtom.set({
-    sessions: {
-      ...current.sessions,
-      [options.sessionId]: normalizeSession(
-        existing ? {
-          ...existing,
-          projectId: existing.projectId ?? options.projectId ?? null,
-          projectLabel: options.projectLabel ?? existing.projectLabel,
-          title: options.title ?? existing.title,
-          href: options.href ?? existing.href,
-          metadata: options.metadata ?? existing.metadata,
-          lastActivityAt: now,
-          isForeground: options.sessionId === foregroundSessionId || existing.isForeground
-        } : createRecord(options, now)
-      )
-    },
-    lastUpdatedAt: now
-  });
-}
-function unregisterActiveSession(sessionId) {
-  const current = activeSessionsAtom.get();
-  if (!current.sessions[sessionId]) return;
-  const { [sessionId]: _removed, ...remaining } = current.sessions;
-  if (foregroundSessionId === sessionId) {
-    foregroundSessionId = null;
-  }
-  activeSessionsAtom.set({
-    sessions: remaining,
-    lastUpdatedAt: Date.now()
-  });
-}
-function setForegroundActiveSession(sessionId) {
-  foregroundSessionId = sessionId;
-  const current = activeSessionsAtom.get();
-  const now = Date.now();
-  let changed = false;
-  const sessions = Object.fromEntries(
-    Object.entries(current.sessions).map(([id, session]) => {
-      const isForeground = id === sessionId;
-      if (session.isForeground !== isForeground) {
-        changed = true;
-      }
-      return [
-        id,
-        {
-          ...session,
-          isForeground,
-          lastActivityAt: isForeground ? now : session.lastActivityAt
-        }
-      ];
-    })
-  );
-  if (!changed) return;
-  activeSessionsAtom.set({
-    sessions,
-    lastUpdatedAt: now
-  });
-}
-function updateActiveSessionMeta(sessionId, meta) {
-  updateSession(sessionId, (session, now) => ({
-    ...session,
-    ...meta,
-    lastActivityAt: now
-  }));
-}
-function setActiveSessionConnection(sessionId, options) {
-  updateSession(sessionId, (session, now) => ({
-    ...session,
-    connectionState: options.connectionState,
-    reconnectState: options.reconnectState ?? session.reconnectState,
-    transportMode: options.transportMode ?? session.transportMode,
-    lastError: options.lastError === void 0 ? session.lastError : options.lastError,
-    lastEventAt: options.lastEventAt ?? session.lastEventAt,
-    lastActivityAt: now
-  }));
-}
-function setActiveSessionRunning(sessionId, isRunning, options) {
-  updateSession(sessionId, (session, now) => ({
-    ...session,
-    isRunning,
-    needsAttention: isRunning ? false : session.needsAttention,
-    lastError: isRunning ? null : session.lastError,
-    lastEventAt: options?.lastEventAt ?? session.lastEventAt,
-    lastActivityAt: now
-  }));
-}
-function setActiveSessionAttention(sessionId, needsAttention, options) {
-  updateSession(sessionId, (session, now) => ({
-    ...session,
-    needsAttention,
-    isRunning: needsAttention ? false : session.isRunning,
-    lastEventAt: options?.lastEventAt ?? session.lastEventAt,
-    lastActivityAt: now
-  }));
-}
-function setActiveSessionError(sessionId, error) {
-  updateSession(sessionId, (session, now) => ({
-    ...session,
-    isRunning: false,
-    needsAttention: false,
-    lastError: error,
-    reconnectState: error ? "failed" : "idle",
-    connectionState: error ? "error" : session.connectionState,
-    lastEventAt: now,
-    lastActivityAt: now
-  }));
-}
-function bumpActiveSessionActivity(sessionId, options) {
-  updateSession(sessionId, (session, now) => ({
-    ...session,
-    lastEventAt: options?.lastEventAt ?? session.lastEventAt ?? now,
-    lastActivityAt: now
-  }));
-}
-function resetActiveSessions() {
-  foregroundSessionId = null;
-  activeSessionsAtom.set(INITIAL_STATE);
-}
-function getAllActiveSessions(state) {
-  return Object.values(state.sessions);
-}
-function getActiveSession(state, sessionId) {
-  return state.sessions[sessionId] ?? null;
-}
-function getSessionsForProject(state, projectId) {
-  return Object.values(state.sessions).filter((session) => session.projectId === projectId);
-}
-function getSessionsForNavbar(state, projectId) {
-  const sessions = projectId == null ? Object.values(state.sessions) : getSessionsForProject(state, projectId);
-  return [...sessions].sort((left, right) => {
-    if (left.isForeground !== right.isForeground) {
-      return Number(right.isForeground) - Number(left.isForeground);
-    }
-    const statusDiff = STATUS_PRIORITY[left.status] - STATUS_PRIORITY[right.status];
-    if (statusDiff !== 0) {
-      return statusDiff;
-    }
-    return right.lastActivityAt - left.lastActivityAt;
-  });
-}
-function getSessionsByActivity(state) {
-  return [...Object.values(state.sessions)].sort(
-    (left, right) => right.lastActivityAt - left.lastActivityAt
-  );
-}
-function getTotalRunningSessionCount(state) {
-  return Object.values(state.sessions).filter((session) => session.isRunning).length;
-}
-function hasBackgroundRunningSessions(state) {
-  return Object.values(state.sessions).some(
-    (session) => session.isRunning && !session.isForeground
-  );
-}
-function getAllProjectActivity(state) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const session of Object.values(state.sessions)) {
-    if (session.projectId == null) continue;
-    const existing = grouped.get(session.projectId);
-    if (existing) {
-      existing.activeSessionCount += 1;
-      existing.lastActivityAt = Math.max(existing.lastActivityAt, session.lastActivityAt);
-      if (session.isRunning) {
-        existing.runningSessionIds.push(session.sessionId);
-      }
-      if (!existing.projectLabel && session.projectLabel) {
-        existing.projectLabel = session.projectLabel;
-      }
-      continue;
-    }
-    grouped.set(session.projectId, {
-      projectId: session.projectId,
-      projectLabel: session.projectLabel,
-      activeSessionCount: 1,
-      runningSessionIds: session.isRunning ? [session.sessionId] : [],
-      lastActivityAt: session.lastActivityAt
-    });
-  }
-  return [...grouped.values()].sort((left, right) => right.lastActivityAt - left.lastActivityAt);
-}
-function useActiveSessionsState() {
-  return useStore(activeSessionsAtom);
-}
-function useActiveSessions() {
-  const state = useStore(activeSessionsAtom);
-  return useMemo(() => getAllActiveSessions(state), [state]);
-}
-function useActiveSession(sessionId) {
-  const state = useStore(activeSessionsAtom);
-  return useMemo(
-    () => sessionId ? getActiveSession(state, sessionId) : null,
-    [sessionId, state]
-  );
-}
-function useProjectSessions(projectId) {
-  const state = useStore(activeSessionsAtom);
-  return useMemo(
-    () => projectId == null ? [] : getSessionsForProject(state, projectId),
-    [projectId, state]
-  );
-}
-function useNavbarSessions(projectId) {
-  const state = useStore(activeSessionsAtom);
-  return useMemo(() => getSessionsForNavbar(state, projectId), [projectId, state]);
-}
-function useSessionsByActivity() {
-  const state = useStore(activeSessionsAtom);
-  return useMemo(() => getSessionsByActivity(state), [state]);
-}
-function useProjectActivity() {
-  const state = useStore(activeSessionsAtom);
-  return useMemo(() => getAllProjectActivity(state), [state]);
-}
-function useTotalRunningSessions() {
-  const state = useStore(activeSessionsAtom);
-  return useMemo(() => getTotalRunningSessionCount(state), [state]);
-}
-function useHasBackgroundRunningSessions() {
-  const state = useStore(activeSessionsAtom);
-  return useMemo(() => hasBackgroundRunningSessions(state), [state]);
-}
-
-export {
-  activeSessionsAtom,
-  registerActiveSession,
-  unregisterActiveSession,
-  setForegroundActiveSession,
-  updateActiveSessionMeta,
-  setActiveSessionConnection,
-  setActiveSessionRunning,
-  setActiveSessionAttention,
-  setActiveSessionError,
-  bumpActiveSessionActivity,
-  resetActiveSessions,
-  getAllActiveSessions,
-  getActiveSession,
-  getSessionsForProject,
-  getSessionsForNavbar,
-  getSessionsByActivity,
-  getTotalRunningSessionCount,
-  hasBackgroundRunningSessions,
-  getAllProjectActivity,
-  useActiveSessionsState,
-  useActiveSessions,
-  useActiveSession,
-  useProjectSessions,
-  useNavbarSessions,
-  useSessionsByActivity,
-  useProjectActivity,
-  useTotalRunningSessions,
-  useHasBackgroundRunningSessions
-};

package/dist/chunk-OL5GYLHV.js

@@ -1,60 +0,0 @@
-import {
-  CodeBlock,
-  CopyButton
-} from "./chunk-3XXBZL53.js";
-import {
-  cn
-} from "./chunk-RQHJBTEU.js";
-
-// src/markdown/markdown.tsx
-import { memo } from "react";
-import ReactMarkdown from "react-markdown";
-import remarkGfm from "remark-gfm";
-import rehypeSanitize from "rehype-sanitize";
-import { Fragment, jsx } from "react/jsx-runtime";
-var Markdown = memo(({ children, className, urlTransform }) => {
-  return /* @__PURE__ */ jsx(
-    "div",
-    {
-      className: cn("tangle-prose max-w-none text-sm", className),
-      children: /* @__PURE__ */ jsx(
-        ReactMarkdown,
-        {
-          remarkPlugins: [remarkGfm],
-          rehypePlugins: [rehypeSanitize],
-          urlTransform,
-          components: {
-            pre({ children: preChildren }) {
-              return /* @__PURE__ */ jsx(Fragment, { children: preChildren });
-            },
-            code({ className: codeClass, children: codeChildren, ...rest }) {
-              const match = /language-(\w+)/.exec(codeClass || "");
-              const language = match?.[1];
-              const code = String(codeChildren).replace(/\n$/, "");
-              if (!language && !code.includes("\n")) {
-                return /* @__PURE__ */ jsx(
-                  "code",
-                  {
-                    className: cn(
-                      "px-1.5 py-0.5 rounded border border-border bg-card text-[var(--code-keyword)] text-[0.85em] font-mono",
-                      codeClass
-                    ),
-                    ...rest,
-                    children: codeChildren
-                  }
-                );
-              }
-              return /* @__PURE__ */ jsx(CodeBlock, { code, language, children: /* @__PURE__ */ jsx(CopyButton, { text: code }) });
-            }
-          },
-          children
-        }
-      )
-    }
-  );
-});
-Markdown.displayName = "Markdown";
-
-export {
-  Markdown
-};

package/dist/chunk-QGFYBNSO.js

@@ -1,133 +0,0 @@
-import {
-  ToolCallGroup,
-  ToolCallStep
-} from "./chunk-R7B3UWPF.js";
-import {
-  Markdown
-} from "./chunk-OL5GYLHV.js";
-import {
-  cn
-} from "./chunk-RQHJBTEU.js";
-
-// src/run/tool-call-feed.tsx
-import { jsx } from "react/jsx-runtime";
-function ToolCallFeed({ segments, className }) {
-  if (segments.length === 0) return null;
-  return /* @__PURE__ */ jsx("div", { className: cn("space-y-1", className), children: segments.map((segment, i) => {
-    if (segment.kind === "text") {
-      return segment.content.trim() ? /* @__PURE__ */ jsx(Markdown, { children: segment.content }, i) : null;
-    }
-    if (segment.kind === "tool_call") {
-      return /* @__PURE__ */ jsx(
-        ToolCallStep,
-        {
-          type: segment.call.type,
-          label: segment.call.label,
-          status: segment.call.status,
-          detail: segment.call.detail,
-          output: segment.call.output,
-          duration: segment.call.duration
-        },
-        segment.call.id || i
-      );
-    }
-    if (segment.kind === "tool_group") {
-      return /* @__PURE__ */ jsx(ToolCallGroup, { title: segment.title, children: segment.calls.map((call) => /* @__PURE__ */ jsx(
-        ToolCallStep,
-        {
-          type: call.type,
-          label: call.label,
-          status: call.status,
-          detail: call.detail,
-          output: call.output,
-          duration: call.duration
-        },
-        call.id
-      )) }, i);
-    }
-    return null;
-  }) });
-}
-function parseToolEvent(event) {
-  const { type, data } = event;
-  if (type === "tool.invocation" || type === "tool_use") {
-    const toolName = data.name || data.tool || "unknown";
-    const input = data.input;
-    return {
-      id: data.id || data.toolUseId || createId(),
-      type: mapToolName(toolName),
-      label: formatToolLabel(toolName, input),
-      status: "running",
-      detail: input ? formatToolInput(toolName, input) : void 0
-    };
-  }
-  if (type === "tool.result" || type === "tool_result") {
-    return {
-      id: data.id || data.toolUseId || "",
-      type: mapToolName(data.name || data.tool || "unknown"),
-      label: formatToolLabel(data.name || data.tool || "unknown"),
-      status: data.error ? "error" : "success",
-      output: truncate(data.output || data.result || "", 500),
-      duration: data.duration
-    };
-  }
-  return null;
-}
-function createId() {
-  if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.randomUUID === "function") {
-    try {
-      return globalThis.crypto.randomUUID();
-    } catch {
-    }
-  }
-  return `tool_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
-}
-function mapToolName(name) {
-  const lower = name.toLowerCase();
-  if (lower.includes("bash") || lower.includes("terminal") || lower.includes("exec")) return "bash";
-  if (lower.includes("read") || lower.includes("cat")) return "read";
-  if (lower.includes("write") || lower.includes("create")) return "write";
-  if (lower.includes("edit") || lower.includes("replace")) return "edit";
-  if (lower.includes("glob") || lower.includes("find")) return "glob";
-  if (lower.includes("grep") || lower.includes("search")) return "grep";
-  if (lower.includes("list") || lower.includes("ls")) return "list";
-  if (lower.includes("inspect")) return "inspect";
-  if (lower.includes("audit")) return "audit";
-  return "unknown";
-}
-function formatToolLabel(toolName, input) {
-  const lower = toolName.toLowerCase();
-  if (lower.includes("bash") && input?.command) {
-    const cmd = String(input.command);
-    return cmd.length > 80 ? `${cmd.slice(0, 77)}...` : cmd;
-  }
-  if ((lower.includes("read") || lower.includes("cat")) && input?.path) {
-    return `Read ${input.path}`;
-  }
-  if (lower.includes("write") && input?.path) {
-    return `Write ${input.path}`;
-  }
-  if (lower.includes("edit") && input?.path) {
-    return `Edit ${input.path}`;
-  }
-  if (lower.includes("glob") && input?.pattern) {
-    return `Find ${input.pattern}`;
-  }
-  if (lower.includes("grep") && input?.pattern) {
-    return `Search for ${input.pattern}`;
-  }
-  return toolName;
-}
-function formatToolInput(toolName, input) {
-  if (input.command) return String(input.command);
-  if (input.path) return String(input.path);
-  return JSON.stringify(input, null, 2).slice(0, 300);
-}
-function truncate(text, max) {
-  return text.length > max ? text.slice(0, max - 3) + "..." : text;
-}
-
-export {
-  ToolCallFeed,
-  parseToolEvent
-};