@dipertq/dsh-openviking-status 0.1.5

package/lib/client.js

@@ -0,0 +1,1431 @@
+// src/client/OpenVikingStatusChip.tsx
+import {
+  useState as useState2,
+  useEffect as useEffect2,
+  useCallback as useCallback2,
+  useRef as useRef2,
+  useMemo
+} from "react";
+
+// src/client/api.ts
+var DEFAULT_OPENVIKING_ENDPOINT = "http://127.0.0.1:1933";
+function resolveEndpoint(endpoint) {
+  if (endpoint && endpoint.trim().length > 0) {
+    return endpoint.trim().replace(/\/+$/, "");
+  }
+  if (typeof window !== "undefined") {
+    const win = window;
+    if (typeof win.__OPENVIKING_ENDPOINT__ === "string" && win.__OPENVIKING_ENDPOINT__.trim()) {
+      return win.__OPENVIKING_ENDPOINT__.trim().replace(/\/+$/, "");
+    }
+  }
+  if (typeof localStorage !== "undefined") {
+    try {
+      const stored = localStorage.getItem("openviking_endpoint") || localStorage.getItem("OPENVIKING_ENDPOINT");
+      if (stored && stored.trim()) {
+        return stored.trim().replace(/\/+$/, "");
+      }
+    } catch {
+    }
+  }
+  return DEFAULT_OPENVIKING_ENDPOINT;
+}
+function resolveApiKey(apiKey) {
+  if (apiKey && apiKey.trim().length > 0) {
+    return apiKey.trim();
+  }
+  if (typeof window !== "undefined") {
+    const win = window;
+    if (typeof win.__OPENVIKING_API_KEY__ === "string" && win.__OPENVIKING_API_KEY__.trim()) {
+      return win.__OPENVIKING_API_KEY__.trim();
+    }
+  }
+  if (typeof localStorage !== "undefined") {
+    try {
+      const stored = localStorage.getItem("openviking_api_key") || localStorage.getItem("OPENVIKING_API_KEY");
+      if (stored && stored.trim()) {
+        return stored.trim();
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+var OpenVikingClient = class {
+  endpoint;
+  apiKey;
+  resolvedSessionIds = /* @__PURE__ */ new Map();
+  constructor(endpoint, apiKey) {
+    this.endpoint = resolveEndpoint(endpoint);
+    this.apiKey = resolveApiKey(apiKey);
+  }
+  /**
+   * Формирование заголовков запроса, включая опциональный заголовок авторизации
+   */
+  getHeaders(customHeaders) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...customHeaders
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    return headers;
+  }
+  /**
+   * Генерация кандидатов ID сессии для fallback-разрешения:
+   * dsh-session-${id} <-> dsh-${id}
+   */
+  getCandidateSessionIds(sessionId) {
+    const raw = sessionId.trim();
+    const candidates = [];
+    const cached = this.resolvedSessionIds.get(raw);
+    if (cached) {
+      candidates.push(cached);
+    }
+    if (raw.startsWith("dsh-session-")) {
+      const suffix = raw.slice("dsh-session-".length);
+      candidates.push(raw, `dsh-${suffix}`);
+    } else if (raw.startsWith("dsh-")) {
+      const suffix = raw.slice("dsh-".length);
+      candidates.push(raw, `dsh-session-${suffix}`);
+    } else {
+      candidates.push(`dsh-session-${raw}`, `dsh-${raw}`, raw);
+    }
+    return Array.from(new Set(candidates));
+  }
+  /**
+   * Проверка доступности и состояния сервиса OpenViking
+   */
+  async checkHealth() {
+    try {
+      const res = await fetch(`${this.endpoint}/health`, {
+        method: "GET",
+        headers: this.getHeaders()
+      });
+      if (!res.ok) {
+        return {
+          ok: false,
+          error: `HTTP ${res.status}: ${res.statusText}`
+        };
+      }
+      const body = await res.json().catch(() => ({}));
+      const isOk = body.ok !== false && body.status !== "error" && (body.ok === true || body.status === "ok" || body.status === "healthy" || res.ok);
+      return {
+        ok: isOk,
+        version: typeof body.version === "string" ? body.version : void 0,
+        storage: typeof body.storage === "string" ? body.storage : void 0
+      };
+    } catch (err) {
+      return {
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /**
+   * Получение метаданных сессии по идентификатору с автоматическим разрешением префикса.
+   * При сетевых сбоях или ошибках авторизации возвращает null, не выбрасывая исключений.
+   */
+  async fetchSession(sessionId) {
+    if (!sessionId || !sessionId.trim()) {
+      return null;
+    }
+    const candidates = this.getCandidateSessionIds(sessionId);
+    for (const candidateId of candidates) {
+      try {
+        const res = await fetch(
+          `${this.endpoint}/api/v1/sessions/${encodeURIComponent(candidateId)}`,
+          {
+            method: "GET",
+            headers: this.getHeaders()
+          }
+        );
+        if (res.status === 404) {
+          continue;
+        }
+        if (!res.ok) {
+          return null;
+        }
+        const data = await res.json();
+        const raw = data?.result ?? data?.data ?? data;
+        if (!raw || typeof raw !== "object") {
+          return null;
+        }
+        this.resolvedSessionIds.set(sessionId.trim(), candidateId);
+        return {
+          session_id: typeof raw.session_id === "string" ? raw.session_id : candidateId,
+          peer_id: typeof raw.peer_id === "string" ? raw.peer_id : void 0,
+          pending_tokens: typeof raw.pending_tokens === "number" ? raw.pending_tokens : 0,
+          message_count: typeof raw.message_count === "number" ? raw.message_count : void 0,
+          commit_count: typeof raw.commit_count === "number" ? raw.commit_count : void 0,
+          last_commit_at: typeof raw.last_commit_at === "string" ? raw.last_commit_at : typeof raw.last_commit === "string" ? raw.last_commit : void 0,
+          created_at: typeof raw.created_at === "string" ? raw.created_at : void 0,
+          updated_at: typeof raw.updated_at === "string" ? raw.updated_at : void 0
+        };
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  /**
+   * Алиас для fetchSession
+   */
+  async getSession(sessionId) {
+    return this.fetchSession(sessionId);
+  }
+  /**
+   * Инициация фиксации (коммита) накопленных токенов сессии в долговременную память
+   */
+  async commitSession(sessionId, options) {
+    if (!sessionId || !sessionId.trim()) {
+      return { ok: false, error: "Missing sessionId" };
+    }
+    const candidates = this.getCandidateSessionIds(sessionId);
+    const bodyPayload = JSON.stringify(options ?? { keep_recent_count: 10 });
+    let lastError = "Session commit failed";
+    for (const candidateId of candidates) {
+      try {
+        const res = await fetch(
+          `${this.endpoint}/api/v1/sessions/${encodeURIComponent(candidateId)}/commit`,
+          {
+            method: "POST",
+            headers: this.getHeaders(),
+            body: bodyPayload
+          }
+        );
+        if (res.status === 404) {
+          lastError = `Session not found: ${candidateId}`;
+          continue;
+        }
+        if (!res.ok) {
+          const errBody = await res.json().catch(() => null);
+          const errorMsg = errBody?.error?.message || errBody?.message || errBody?.error || `HTTP ${res.status}: ${res.statusText}`;
+          return { ok: false, error: String(errorMsg) };
+        }
+        this.resolvedSessionIds.set(sessionId.trim(), candidateId);
+        return { ok: true };
+      } catch (err) {
+        return {
+          ok: false,
+          error: err instanceof Error ? err.message : String(err)
+        };
+      }
+    }
+    return { ok: false, error: lastError };
+  }
+};
+var defaultOpenVikingClient = new OpenVikingClient();
+function checkHealth(endpoint, apiKey) {
+  const client = endpoint || apiKey ? new OpenVikingClient(endpoint, apiKey) : defaultOpenVikingClient;
+  return client.checkHealth();
+}
+function fetchSession(sessionId, endpoint, apiKey) {
+  const client = endpoint || apiKey ? new OpenVikingClient(endpoint, apiKey) : defaultOpenVikingClient;
+  return client.fetchSession(sessionId);
+}
+function getSession(sessionId, endpoint, apiKey) {
+  return fetchSession(sessionId, endpoint, apiKey);
+}
+function commitSession(sessionId, options, endpoint, apiKey) {
+  const client = endpoint || apiKey ? new OpenVikingClient(endpoint, apiKey) : defaultOpenVikingClient;
+  return client.commitSession(sessionId, options);
+}
+
+// src/client/recallParser.ts
+var KNOWN_CATEGORIES = /* @__PURE__ */ new Set([
+  "preferences",
+  "entities",
+  "events",
+  "skills",
+  "resources",
+  "profile"
+]);
+function inferCategory(uri) {
+  if (!uri || typeof uri !== "string") return void 0;
+  const memoriesMatch = uri.match(/\/memories\/([^/#?]+)/i);
+  if (memoriesMatch && memoriesMatch[1]) {
+    return memoriesMatch[1].toLowerCase();
+  }
+  const cleanUri = uri.replace(/^viking:\/\/?/i, "");
+  const segments = cleanUri.split("/").filter(Boolean);
+  for (const seg of segments) {
+    const lower = seg.toLowerCase();
+    if (KNOWN_CATEGORIES.has(lower)) {
+      return lower;
+    }
+  }
+  if (segments[0]?.toLowerCase() === "user" && segments.length >= 3) {
+    return segments[2].toLowerCase();
+  }
+  if (segments.length >= 2) {
+    return segments[0].toLowerCase();
+  }
+  return void 0;
+}
+function extractAllText(input) {
+  if (input == null) return "";
+  if (typeof input === "string") return input;
+  if (typeof input === "number" || typeof input === "boolean")
+    return String(input);
+  if (Array.isArray(input)) {
+    return input.map(extractAllText).filter(Boolean).join("\n");
+  }
+  if (typeof input === "object") {
+    const obj = input;
+    const parts = [];
+    if ("content" in obj && obj.content != null) {
+      parts.push(extractAllText(obj.content));
+    }
+    if ("text" in obj && obj.text != null) {
+      parts.push(extractAllText(obj.text));
+    }
+    if ("message" in obj && obj.message != null) {
+      parts.push(extractAllText(obj.message));
+    }
+    if (parts.length > 0) {
+      return parts.join("\n");
+    }
+    try {
+      return Object.values(obj).map(extractAllText).filter(Boolean).join("\n");
+    } catch {
+      return "";
+    }
+  }
+  return "";
+}
+function findContextBlocks(text) {
+  const blocks = [];
+  const openTagRegex = /<openviking-context\b([^>]*)>/gi;
+  let match;
+  const tagPositions = [];
+  while ((match = openTagRegex.exec(text)) !== null) {
+    tagPositions.push({
+      index: match.index,
+      endIndex: match.index + match[0].length,
+      attrs: match[1] || ""
+    });
+  }
+  if (tagPositions.length === 0) {
+    if (/<available-memories\b/i.test(text)) {
+      blocks.push({
+        isProfile: true,
+        attributes: 'source="profile"',
+        content: text
+      });
+    } else if (/<memory\b/i.test(text)) {
+      blocks.push({
+        isProfile: false,
+        attributes: "",
+        content: text
+      });
+    }
+    return blocks;
+  }
+  for (let i = 0; i < tagPositions.length; i++) {
+    const current = tagPositions[i];
+    const nextStart = i + 1 < tagPositions.length ? tagPositions[i + 1].index : text.length;
+    const blockText = text.slice(current.endIndex, nextStart);
+    const closeIndex = blockText.search(/<\/openviking-context>/i);
+    const content = closeIndex !== -1 ? blockText.slice(0, closeIndex) : blockText;
+    const isProfile = /\bsource\s*=\s*["']profile["']/i.test(current.attrs);
+    blocks.push({
+      isProfile,
+      attributes: current.attrs,
+      content
+    });
+  }
+  return blocks;
+}
+function normalizeUri(uri) {
+  let clean = uri.trim();
+  if (clean.endsWith("/") && !clean.endsWith("://")) {
+    clean = clean.slice(0, -1);
+  }
+  return clean;
+}
+function parseProfileItems(blockContent) {
+  const items = [];
+  let memContent = blockContent;
+  const availMatch = blockContent.match(
+    /<available-memories\b[^>]*>([\s\S]*?)(?:<\/available-memories>|$)/i
+  );
+  if (availMatch && availMatch[1]) {
+    memContent = availMatch[1];
+  }
+  const lines = memContent.split(/\r?\n/);
+  let currentBaseUri = null;
+  for (const rawLine of lines) {
+    const trimmed = rawLine.trim();
+    if (!trimmed) continue;
+    const baseMatch = trimmed.match(
+      /^[-*•]?\s*(viking:\/\/[^\s<>"'`]+?\/)\s*$/i
+    );
+    if (baseMatch) {
+      currentBaseUri = baseMatch[1];
+      continue;
+    }
+    const bulletMatch = trimmed.match(/^[-*•]\s+([^\s<>"'`].*?)$/);
+    if (bulletMatch && currentBaseUri && !bulletMatch[1].startsWith("viking://")) {
+      let relPath = bulletMatch[1].trim();
+      relPath = relPath.replace(/^\[([^\]]+)\](?:\([^)]*\))?/, "$1");
+      relPath = relPath.replace(/[.,;:)\]]+$/, "").trim();
+      if (relPath) {
+        const cleanBase = currentBaseUri.endsWith("/") ? currentBaseUri : currentBaseUri + "/";
+        const fullUri = normalizeUri(cleanBase + relPath.replace(/^\/+/, ""));
+        items.push({
+          uri: fullUri,
+          category: inferCategory(fullUri),
+          source: "profile"
+        });
+        continue;
+      }
+    }
+    const fullBulletMatch = trimmed.match(
+      /^[-*•]\s+(viking:\/\/[^<>"'`\r\n]+)/i
+    );
+    if (fullBulletMatch) {
+      let uri = fullBulletMatch[1].trim().replace(/[.,;:)\]]+$/, "");
+      if (uri.endsWith("/")) {
+        currentBaseUri = uri;
+      } else {
+        uri = normalizeUri(uri);
+        items.push({
+          uri,
+          category: inferCategory(uri),
+          source: "profile"
+        });
+        continue;
+      }
+    }
+    const inlineMatches = trimmed.matchAll(/viking:\/\/[^\s<>"'`]+/gi);
+    for (const m of inlineMatches) {
+      let uri = m[0].replace(/[.,;:)\]]+$/, "");
+      if (uri.endsWith("/")) {
+        currentBaseUri = uri;
+      } else {
+        uri = normalizeUri(uri);
+        items.push({
+          uri,
+          category: inferCategory(uri),
+          source: "profile"
+        });
+      }
+    }
+  }
+  return items;
+}
+function parseRecallItems(blockContent) {
+  const items = [];
+  const memoryTagRegex = /<memory\b([^>]*?)(?:\/>|>([\s\S]*?)(?:<\/memory>|(?=<memory\b)|$))/gi;
+  let memMatch;
+  while ((memMatch = memoryTagRegex.exec(blockContent)) !== null) {
+    const attrsString = memMatch[1] || "";
+    const innerContent = memMatch[2] || "";
+    const uriMatch = attrsString.match(
+      /\buri\s*=\s*(?:["'](viking:\/\/[^"']+)["']|(viking:\/\/[^\s>]+))/i
+    );
+    if (!uriMatch) continue;
+    const rawUri = uriMatch[1] || uriMatch[2];
+    const uri = normalizeUri(rawUri);
+    const scoreMatch = attrsString.match(
+      /\bscore\s*=\s*(?:["']([^"']+)["']|([0-9.]+))/i
+    );
+    let score;
+    const scoreStr = scoreMatch ? scoreMatch[1] || scoreMatch[2] : void 0;
+    if (scoreStr) {
+      const parsed = parseFloat(scoreStr);
+      if (Number.isFinite(parsed)) {
+        score = parsed;
+      }
+    }
+    const typeMatch = attrsString.match(
+      /\b(?:type|category)\s*=\s*["']([^"']+)["']/i
+    );
+    const explicitCategory = typeMatch ? typeMatch[1].trim() : void 0;
+    const category = inferCategory(uri) || explicitCategory;
+    let abstractText;
+    const abstractAttrMatch = attrsString.match(
+      /\babstract\s*=\s*["']([^"']+)["']/i
+    );
+    if (abstractAttrMatch) {
+      abstractText = abstractAttrMatch[1].trim();
+    } else {
+      const trimmedContent = innerContent.trim();
+      if (trimmedContent) {
+        abstractText = trimmedContent;
+      }
+    }
+    items.push({
+      uri,
+      category,
+      source: "recall",
+      score,
+      abstract: abstractText
+    });
+  }
+  return items;
+}
+function parseRecalledMemories(input) {
+  if (input == null) {
+    return {
+      recalledCount: 0,
+      items: [],
+      profileItems: [],
+      recallItems: []
+    };
+  }
+  const text = extractAllText(input);
+  if (!text.trim()) {
+    return {
+      recalledCount: 0,
+      items: [],
+      profileItems: [],
+      recallItems: []
+    };
+  }
+  const blocks = findContextBlocks(text);
+  const rawProfileItems = [];
+  const rawRecallItems = [];
+  for (const block of blocks) {
+    if (block.isProfile) {
+      rawProfileItems.push(...parseProfileItems(block.content));
+    } else {
+      rawRecallItems.push(...parseRecallItems(block.content));
+    }
+  }
+  const recallMap = /* @__PURE__ */ new Map();
+  for (const item of rawRecallItems) {
+    const existing = recallMap.get(item.uri);
+    if (!existing) {
+      recallMap.set(item.uri, { ...item });
+    } else {
+      if (existing.score === void 0 && item.score !== void 0) {
+        existing.score = item.score;
+      } else if (existing.score !== void 0 && item.score !== void 0) {
+        existing.score = Math.max(existing.score, item.score);
+      }
+      if (!existing.abstract && item.abstract) {
+        existing.abstract = item.abstract;
+      }
+      if (!existing.category && item.category) {
+        existing.category = item.category;
+      }
+    }
+  }
+  const profileMap = /* @__PURE__ */ new Map();
+  for (const item of rawProfileItems) {
+    if (!profileMap.has(item.uri)) {
+      profileMap.set(item.uri, { ...item });
+    }
+  }
+  const itemsMap = /* @__PURE__ */ new Map();
+  for (const [uri, item] of profileMap.entries()) {
+    itemsMap.set(uri, item);
+  }
+  for (const [uri, item] of recallMap.entries()) {
+    itemsMap.set(uri, item);
+  }
+  const items = Array.from(itemsMap.values());
+  const profileItems = items.filter((it) => it.source === "profile");
+  const recallItems = items.filter((it) => it.source === "recall");
+  return {
+    recalledCount: items.length,
+    items,
+    profileItems,
+    recallItems
+  };
+}
+
+// src/client/OpenVikingStatusPopover.tsx
+import { useState, useEffect, useCallback, useRef } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function getProgressBarPercent(pendingTokens, threshold = COMMIT_THRESHOLD) {
+  if (!threshold || threshold <= 0) return 0;
+  const ratio = (pendingTokens || 0) / threshold;
+  return Math.min(100, Math.max(0, Math.round(ratio * 100)));
+}
+function getProgressBarColor(percent) {
+  if (percent >= 80) {
+    return "var(--dsw-status-warning, #fbbf24)";
+  }
+  return "var(--dsw-status-success, #34d399)";
+}
+function formatRelativeTime(isoOrTimestamp, now = Date.now()) {
+  if (!isoOrTimestamp) return void 0;
+  const date = new Date(isoOrTimestamp);
+  const time = date.getTime();
+  if (isNaN(time)) return String(isoOrTimestamp);
+  const diffMs = now - time;
+  if (diffMs < 0) return "just now";
+  const diffSec = Math.floor(diffMs / 1e3);
+  if (diffSec < 60) return "just now";
+  const diffMin = Math.floor(diffSec / 60);
+  if (diffMin < 60) return `${diffMin}m ago`;
+  const diffHour = Math.floor(diffMin / 60);
+  if (diffHour < 24) return `${diffHour}h ago`;
+  const diffDay = Math.floor(diffHour / 24);
+  return `${diffDay}d ago`;
+}
+function formatMemoryLeafName(uri) {
+  if (!uri) return "";
+  const clean = uri.replace(/^viking:\/\/?/i, "");
+  const memMatch = clean.match(/memories\/[^/]+\/(.+)$/i);
+  if (memMatch && memMatch[1]) {
+    return memMatch[1];
+  }
+  const segments = clean.split("/").filter(Boolean);
+  if (segments.length >= 2) {
+    return segments.slice(-2).join("/");
+  }
+  return segments[0] || clean;
+}
+function formatEndpoint(endpoint) {
+  if (!endpoint || !endpoint.trim()) {
+    return "127.0.0.1:1933";
+  }
+  return endpoint.trim().replace(/^https?:\/\//, "");
+}
+function truncateSessionId(id, maxLen = 16) {
+  if (!id) return "";
+  if (id.length <= maxLen) return id;
+  return `${id.slice(0, maxLen)}...`;
+}
+function getCategoryBadgeStyle(category) {
+  switch (category?.toLowerCase()) {
+    case "preferences":
+      return {
+        backgroundColor: "rgba(168, 85, 247, 0.15)",
+        color: "var(--dsw-status-purple, #c084fc)"
+      };
+    case "entities":
+      return {
+        backgroundColor: "rgba(59, 130, 246, 0.15)",
+        color: "var(--dsw-status-info, #60a5fa)"
+      };
+    case "skills":
+      return {
+        backgroundColor: "rgba(236, 72, 153, 0.15)",
+        color: "var(--dsw-status-pink, #f472b6)"
+      };
+    case "events":
+      return {
+        backgroundColor: "rgba(245, 158, 11, 0.15)",
+        color: "var(--dsw-status-warning, #fbbf24)"
+      };
+    case "resources":
+      return {
+        backgroundColor: "rgba(20, 184, 166, 0.15)",
+        color: "var(--dsw-status-teal, #2dd4bf)"
+      };
+    default:
+      return {
+        backgroundColor: "rgba(148, 163, 184, 0.15)",
+        color: "var(--dsw-text-muted, #94a3b8)"
+      };
+  }
+}
+function handleEscapeKey(event, onClose) {
+  if (event.key === "Escape") {
+    onClose?.();
+    return true;
+  }
+  return false;
+}
+function OpenVikingStatusPopover({
+  sessionId,
+  health,
+  sessionData,
+  recalledResult,
+  endpoint,
+  isCommitting = false,
+  commitError = null,
+  onCommitNow,
+  onClose,
+  className,
+  style
+}) {
+  const [copied, setCopied] = useState(false);
+  const copyTimeoutRef = useRef(null);
+  useEffect(() => {
+    return () => {
+      if (copyTimeoutRef.current) {
+        clearTimeout(copyTimeoutRef.current);
+      }
+    };
+  }, []);
+  const isOnline = health?.ok === true;
+  const statusColor = isOnline ? "var(--dsw-status-success, #34d399)" : "var(--dsw-status-error, #f87171)";
+  const displaySessionId = sessionData?.session_id || sessionId || "";
+  const pendingTokens = sessionData?.pending_tokens ?? 0;
+  const progressPercent = getProgressBarPercent(pendingTokens);
+  const progressBarColor = getProgressBarColor(progressPercent);
+  const memoryItems = recalledResult?.items || [];
+  const recalledCount = recalledResult?.recalledCount ?? memoryItems.length;
+  const handleCopySessionId = useCallback(() => {
+    if (!displaySessionId) return;
+    if (typeof navigator !== "undefined" && navigator.clipboard) {
+      navigator.clipboard.writeText(displaySessionId).catch(() => {
+      });
+      setCopied(true);
+      if (copyTimeoutRef.current) {
+        clearTimeout(copyTimeoutRef.current);
+      }
+      copyTimeoutRef.current = setTimeout(() => {
+        setCopied(false);
+        copyTimeoutRef.current = null;
+      }, 1500);
+    }
+  }, [displaySessionId]);
+  const isCommitDisabled = isCommitting || !isOnline || pendingTokens === 0;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      role: "dialog",
+      "aria-label": "OpenViking Memory Details",
+      className,
+      style: {
+        position: "absolute",
+        bottom: "calc(100% + 8px)",
+        right: 0,
+        width: "320px",
+        backgroundColor: "var(--dsw-surface-overlay, #1e293b)",
+        border: "1px solid var(--dsw-border-default, #334155)",
+        borderRadius: "8px",
+        padding: "12px",
+        boxShadow: "0 10px 25px -5px rgba(0, 0, 0, 0.5)",
+        zIndex: 1e3,
+        fontSize: "12px",
+        color: "var(--dsw-text-default, #f1f5f9)",
+        fontFamily: "var(--dsw-font-sans, system-ui, sans-serif)",
+        boxSizing: "border-box",
+        ...style
+      },
+      children: [
+        /* @__PURE__ */ jsx("style", { children: `@keyframes ov-spin { from { transform: rotate(0deg); } to { transform: rotate(360deg); } }` }),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              display: "flex",
+              justifyContent: "space-between",
+              alignItems: "flex-start",
+              marginBottom: "10px",
+              paddingBottom: "8px",
+              borderBottom: "1px solid var(--dsw-border-subtle, rgba(255, 255, 255, 0.08))"
+            },
+            children: [
+              /* @__PURE__ */ jsxs("div", { children: [
+                /* @__PURE__ */ jsx(
+                  "div",
+                  {
+                    style: {
+                      fontWeight: 600,
+                      fontSize: "13px",
+                      color: "var(--dsw-text-default, #f1f5f9)"
+                    },
+                    children: "OpenViking Memory"
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  "div",
+                  {
+                    "data-testid": "endpoint-label",
+                    style: {
+                      fontSize: "10px",
+                      color: "var(--dsw-text-muted, #94a3b8)",
+                      fontFamily: "var(--dsw-font-mono, monospace)",
+                      marginTop: "1px"
+                    },
+                    children: formatEndpoint(endpoint)
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  "data-testid": "status-badge",
+                  style: {
+                    display: "inline-flex",
+                    alignItems: "center",
+                    gap: "5px",
+                    fontSize: "10px",
+                    padding: "2px 7px",
+                    borderRadius: "4px",
+                    backgroundColor: isOnline ? "rgba(52, 211, 153, 0.15)" : "rgba(248, 113, 113, 0.15)",
+                    color: statusColor,
+                    fontWeight: 600
+                  },
+                  children: [
+                    /* @__PURE__ */ jsx(
+                      "span",
+                      {
+                        "data-testid": "status-badge-dot",
+                        style: {
+                          width: "6px",
+                          height: "6px",
+                          borderRadius: "50%",
+                          backgroundColor: statusColor,
+                          flexShrink: 0
+                        }
+                      }
+                    ),
+                    /* @__PURE__ */ jsx("span", { children: isOnline ? health?.version ? `ONLINE v${health.version}` : "ONLINE" : "OFFLINE" })
+                  ]
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              display: "flex",
+              flexDirection: "column",
+              gap: "6px",
+              marginBottom: "10px"
+            },
+            children: [
+              /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  style: {
+                    display: "flex",
+                    justifyContent: "space-between",
+                    alignItems: "center"
+                  },
+                  children: [
+                    /* @__PURE__ */ jsx("span", { style: { color: "var(--dsw-text-muted, #94a3b8)" }, children: "Session ID:" }),
+                    /* @__PURE__ */ jsxs(
+                      "div",
+                      {
+                        style: {
+                          display: "flex",
+                          alignItems: "center",
+                          gap: "4px"
+                        },
+                        children: [
+                          /* @__PURE__ */ jsx(
+                            "span",
+                            {
+                              "data-testid": "session-id-value",
+                              role: "button",
+                              tabIndex: 0,
+                              onKeyDown: (e) => {
+                                if (e.key === "Enter" || e.key === " ") {
+                                  e.preventDefault();
+                                  handleCopySessionId();
+                                }
+                              },
+                              "aria-label": "Click to copy Session ID",
+                              style: {
+                                fontFamily: "var(--dsw-font-mono, monospace)",
+                                cursor: "pointer"
+                              },
+                              title: displaySessionId,
+                              onClick: handleCopySessionId,
+                              children: truncateSessionId(displaySessionId)
+                            }
+                          ),
+                          /* @__PURE__ */ jsx(
+                            "button",
+                            {
+                              type: "button",
+                              "data-testid": "copy-session-btn",
+                              onClick: handleCopySessionId,
+                              title: copied ? "Copied!" : "Copy Session ID",
+                              "aria-label": copied ? "Copied!" : "Copy Session ID",
+                              style: {
+                                background: "none",
+                                border: "none",
+                                cursor: "pointer",
+                                padding: "2px 4px",
+                                fontSize: "10px",
+                                color: copied ? "var(--dsw-status-success, #34d399)" : "var(--dsw-text-muted, #94a3b8)",
+                                borderRadius: "3px"
+                              },
+                              children: copied ? "\u2713" : "\u{1F4CB}"
+                            }
+                          )
+                        ]
+                      }
+                    )
+                  ]
+                }
+              ),
+              sessionData?.peer_id && /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  style: {
+                    display: "flex",
+                    justifyContent: "space-between",
+                    alignItems: "center"
+                  },
+                  children: [
+                    /* @__PURE__ */ jsx("span", { style: { color: "var(--dsw-text-muted, #94a3b8)" }, children: "Peer ID:" }),
+                    /* @__PURE__ */ jsx(
+                      "span",
+                      {
+                        "data-testid": "peer-id-value",
+                        style: {
+                          maxWidth: "180px",
+                          overflow: "hidden",
+                          textOverflow: "ellipsis",
+                          whiteSpace: "nowrap",
+                          fontFamily: "var(--dsw-font-mono, monospace)"
+                        },
+                        title: sessionData.peer_id,
+                        children: sessionData.peer_id
+                      }
+                    )
+                  ]
+                }
+              ),
+              sessionData?.last_commit_at && /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  style: {
+                    display: "flex",
+                    justifyContent: "space-between",
+                    alignItems: "center"
+                  },
+                  children: [
+                    /* @__PURE__ */ jsx("span", { style: { color: "var(--dsw-text-muted, #94a3b8)" }, children: "Last Commit:" }),
+                    /* @__PURE__ */ jsx(
+                      "span",
+                      {
+                        "data-testid": "last-commit-value",
+                        title: sessionData.last_commit_at,
+                        style: { color: "var(--dsw-text-default, #e2e8f0)" },
+                        children: formatRelativeTime(sessionData.last_commit_at) || sessionData.last_commit_at
+                      }
+                    )
+                  ]
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { style: { marginBottom: "12px" }, children: [
+          /* @__PURE__ */ jsxs(
+            "div",
+            {
+              style: {
+                display: "flex",
+                justifyContent: "space-between",
+                marginBottom: "4px"
+              },
+              children: [
+                /* @__PURE__ */ jsx("span", { style: { color: "var(--dsw-text-muted, #94a3b8)" }, children: "Pending Tokens:" }),
+                /* @__PURE__ */ jsx("span", { "data-testid": "pending-tokens-label", style: { fontWeight: 500 }, children: `${pendingTokens.toLocaleString()} / ${COMMIT_THRESHOLD.toLocaleString()}` })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              "data-testid": "progress-bar-track",
+              style: {
+                width: "100%",
+                height: "6px",
+                borderRadius: "3px",
+                backgroundColor: "rgba(255, 255, 255, 0.1)",
+                overflow: "hidden"
+              },
+              children: /* @__PURE__ */ jsx(
+                "div",
+                {
+                  "data-testid": "progress-bar-fill",
+                  style: {
+                    width: `${progressPercent}%`,
+                    height: "100%",
+                    backgroundColor: progressBarColor,
+                    transition: "width 0.3s ease, background-color 0.3s ease"
+                  }
+                }
+              )
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { style: { marginBottom: "12px" }, children: [
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              style: {
+                display: "flex",
+                justifyContent: "space-between",
+                alignItems: "center",
+                marginBottom: "4px"
+              },
+              children: /* @__PURE__ */ jsx("span", { style: { fontWeight: 600, fontSize: "11px" }, children: `Recalled Memories (${recalledCount})` })
+            }
+          ),
+          memoryItems.length === 0 ? /* @__PURE__ */ jsx(
+            "div",
+            {
+              "data-testid": "empty-memories-message",
+              style: {
+                padding: "8px 0",
+                color: "var(--dsw-text-muted, #94a3b8)",
+                fontStyle: "italic",
+                fontSize: "11px",
+                textAlign: "center"
+              },
+              children: "No memories recalled in this session"
+            }
+          ) : /* @__PURE__ */ jsx(
+            "div",
+            {
+              "data-testid": "recalled-memories-list",
+              style: {
+                maxHeight: "140px",
+                overflowY: "auto",
+                display: "flex",
+                flexDirection: "column",
+                gap: "4px",
+                paddingRight: "2px"
+              },
+              children: memoryItems.map((item, idx) => /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  "data-testid": "recalled-memory-item",
+                  title: item.uri,
+                  style: {
+                    display: "flex",
+                    alignItems: "center",
+                    gap: "6px",
+                    padding: "4px 6px",
+                    borderRadius: "4px",
+                    backgroundColor: "rgba(255, 255, 255, 0.04)",
+                    border: "1px solid var(--dsw-border-subtle, rgba(255, 255, 255, 0.05))",
+                    fontSize: "11px"
+                  },
+                  children: [
+                    /* @__PURE__ */ jsx(
+                      "span",
+                      {
+                        "data-testid": "memory-category-badge",
+                        style: {
+                          fontSize: "9px",
+                          fontWeight: 600,
+                          padding: "1px 4px",
+                          borderRadius: "3px",
+                          textTransform: "uppercase",
+                          flexShrink: 0,
+                          ...getCategoryBadgeStyle(item.category)
+                        },
+                        children: item.category || "memory"
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(
+                      "span",
+                      {
+                        "data-testid": "memory-source-badge",
+                        style: {
+                          fontSize: "9px",
+                          fontWeight: 600,
+                          padding: "1px 4px",
+                          borderRadius: "3px",
+                          textTransform: "uppercase",
+                          flexShrink: 0,
+                          ...item.source === "profile" ? {
+                            backgroundColor: "rgba(99, 102, 241, 0.15)",
+                            color: "#818cf8"
+                          } : {
+                            backgroundColor: "rgba(16, 185, 129, 0.15)",
+                            color: "var(--dsw-status-success, #34d399)"
+                          }
+                        },
+                        children: item.source
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(
+                      "span",
+                      {
+                        "data-testid": "memory-leaf-name",
+                        style: {
+                          flex: 1,
+                          overflow: "hidden",
+                          textOverflow: "ellipsis",
+                          whiteSpace: "nowrap",
+                          fontFamily: "var(--dsw-font-mono, monospace)",
+                          color: "var(--dsw-text-default, #f1f5f9)"
+                        },
+                        children: formatMemoryLeafName(item.uri)
+                      }
+                    )
+                  ]
+                },
+                `${item.uri}-${idx}`
+              ))
+            }
+          )
+        ] }),
+        commitError && /* @__PURE__ */ jsx(
+          "div",
+          {
+            "data-testid": "commit-error-message",
+            style: {
+              marginBottom: "8px",
+              padding: "6px 8px",
+              borderRadius: "4px",
+              backgroundColor: "rgba(248, 113, 113, 0.1)",
+              border: "1px solid var(--dsw-status-error, #f87171)",
+              color: "var(--dsw-status-error, #f87171)",
+              fontSize: "11px",
+              wordBreak: "break-word"
+            },
+            children: commitError
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            "data-testid": "commit-now-btn",
+            onClick: () => onCommitNow?.(),
+            disabled: isCommitDisabled,
+            style: {
+              width: "100%",
+              padding: "7px 0",
+              borderRadius: "6px",
+              border: "1px solid var(--dsw-border-default, #475569)",
+              backgroundColor: isCommitting ? "var(--dsw-surface-active, #334155)" : isCommitDisabled ? "rgba(255, 255, 255, 0.03)" : "var(--dsw-surface-base, #1e293b)",
+              color: isCommitDisabled ? "var(--dsw-text-muted, #64748b)" : "var(--dsw-text-default, #f8fafc)",
+              cursor: isCommitDisabled ? "not-allowed" : "pointer",
+              fontWeight: 600,
+              fontSize: "12px",
+              transition: "all 0.15s ease",
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              gap: "6px"
+            },
+            children: isCommitting ? /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx(
+                "span",
+                {
+                  style: {
+                    display: "inline-block",
+                    width: "10px",
+                    height: "10px",
+                    borderRadius: "50%",
+                    border: "2px solid var(--dsw-status-warning, #fbbf24)",
+                    borderTopColor: "transparent",
+                    animation: "ov-spin 1s linear infinite"
+                  }
+                }
+              ),
+              /* @__PURE__ */ jsx("span", { children: "Committing..." })
+            ] }) : /* @__PURE__ */ jsx("span", { children: "Commit To Memory Now" })
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/client/OpenVikingStatusChip.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var COMMIT_THRESHOLD = 2e4;
+function formatPendingTokens(pendingTokens) {
+  const k = Math.round((pendingTokens || 0) / 1e3);
+  return `${k}k pend`;
+}
+function formatStatusLabel(isOnline, recalledCount, pendingTokens) {
+  if (!isOnline) {
+    return "OV offline";
+  }
+  return `OV: ${recalledCount} rec \xB7 ${formatPendingTokens(pendingTokens)}`;
+}
+function formatTooltipTitle({
+  isOnline,
+  isCommitting = false,
+  recalledCount,
+  pendingTokens
+}) {
+  if (!isOnline) {
+    return "OpenViking: Offline";
+  }
+  const countLabel = `${recalledCount} recalled`;
+  const tokenLabel = `${(pendingTokens || 0).toLocaleString()} pending tokens`;
+  if (isCommitting) {
+    return `OpenViking: Committing... (${countLabel}, ${tokenLabel})`;
+  }
+  return `OpenViking: Online (${countLabel}, ${tokenLabel})`;
+}
+function getStatusIndicatorColor(isOnline, isCommitting = false) {
+  if (!isOnline) {
+    return "var(--dsw-status-error, #f87171)";
+  }
+  if (isCommitting) {
+    return "var(--dsw-status-warning, #fbbf24)";
+  }
+  return "var(--dsw-status-success, #34d399)";
+}
+function getStatusGlow(isOnline, isCommitting = false) {
+  if (isOnline && !isCommitting) {
+    return "0 0 6px var(--dsw-status-success, #34d399)";
+  }
+  return "none";
+}
+function getFallbackSessionMessages(sessionId) {
+  if (!sessionId || typeof window === "undefined") {
+    return void 0;
+  }
+  const win = window;
+  if (win.__DSH_STORE__?.getState) {
+    const state = win.__DSH_STORE__.getState();
+    return state?.conversations?.[sessionId]?.messages || state?.sessions?.[sessionId]?.messages;
+  }
+  if (win.__DSH_SESSION_MESSAGES__?.[sessionId]) {
+    return win.__DSH_SESSION_MESSAGES__[sessionId];
+  }
+  return void 0;
+}
+function OpenVikingStatusChip({
+  sessionId,
+  messages,
+  contextText,
+  client,
+  onCommit,
+  className,
+  initialHealth,
+  initialSessionData,
+  initialOpen = false
+}) {
+  const [health, setHealth] = useState2(
+    initialHealth ?? null
+  );
+  const [sessionData, setSessionData] = useState2(
+    initialSessionData ?? null
+  );
+  const [isOpen, setIsOpen] = useState2(initialOpen);
+  const [isCommitting, setIsCommitting] = useState2(false);
+  const [commitError, setCommitError] = useState2(null);
+  const popoverRef = useRef2(null);
+  const apiClient = client ?? defaultOpenVikingClient;
+  const fallbackMessages = useMemo(() => {
+    if (messages || contextText) return void 0;
+    return getFallbackSessionMessages(sessionId);
+  }, [sessionId, messages, contextText]);
+  const inputForParser = useMemo(() => {
+    if (contextText && messages) {
+      return [contextText, ...messages];
+    }
+    return contextText ?? messages ?? fallbackMessages;
+  }, [contextText, messages, fallbackMessages]);
+  const recalledResult = useMemo(
+    () => parseRecalledMemories(inputForParser),
+    [inputForParser]
+  );
+  const fetchStatus = useCallback2(async () => {
+    try {
+      const healthRes = await apiClient.checkHealth();
+      setHealth(healthRes);
+      if (!healthRes.ok) {
+        return;
+      }
+      const session = await apiClient.fetchSession(sessionId);
+      setSessionData(session);
+    } catch {
+      setHealth({ ok: false });
+    }
+  }, [sessionId, apiClient]);
+  useEffect2(() => {
+    fetchStatus();
+    const timer = setInterval(fetchStatus, 15e3);
+    return () => clearInterval(timer);
+  }, [fetchStatus]);
+  useEffect2(() => {
+    function handleClickOutside(event) {
+      if (popoverRef.current && !popoverRef.current.contains(event.target)) {
+        setIsOpen(false);
+      }
+    }
+    function handleKeyDown(event) {
+      if (event.key === "Escape") {
+        setIsOpen(false);
+      }
+    }
+    if (isOpen) {
+      document.addEventListener("mousedown", handleClickOutside);
+      document.addEventListener("keydown", handleKeyDown);
+    }
+    return () => {
+      document.removeEventListener("mousedown", handleClickOutside);
+      document.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [isOpen]);
+  const handleCommitNow = async () => {
+    if (isCommitting) return;
+    setIsCommitting(true);
+    setCommitError(null);
+    try {
+      const res = await apiClient.commitSession(sessionId, {
+        keep_recent_count: 10
+      });
+      if (res.ok) {
+        await fetchStatus();
+        onCommit?.();
+      } else {
+        setCommitError(res.error || "Commit failed");
+      }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      setCommitError(msg || "Failed to commit session");
+      console.error("[dsh-openviking-status] Failed to commit session:", e);
+    } finally {
+      setIsCommitting(false);
+    }
+  };
+  const isOnline = health?.ok === true;
+  const pendingTokens = sessionData?.pending_tokens ?? 0;
+  const pendingTokensK = Math.round(pendingTokens / 1e3);
+  const recalledCount = recalledResult.recalledCount;
+  const statusColor = getStatusIndicatorColor(isOnline, isCommitting);
+  const statusGlow = getStatusGlow(isOnline, isCommitting);
+  const tooltipTitle = formatTooltipTitle({
+    isOnline,
+    isCommitting,
+    recalledCount,
+    pendingTokens
+  });
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      className,
+      style: {
+        position: "relative",
+        display: "inline-flex",
+        alignItems: "center"
+      },
+      ref: popoverRef,
+      children: [
+        /* @__PURE__ */ jsxs2(
+          "button",
+          {
+            type: "button",
+            onClick: () => setIsOpen(!isOpen),
+            "aria-expanded": isOpen,
+            "aria-haspopup": "dialog",
+            style: {
+              display: "inline-flex",
+              alignItems: "center",
+              gap: "6px",
+              height: "26px",
+              padding: "0 8px",
+              fontSize: "12px",
+              fontFamily: "var(--dsw-font-mono, monospace)",
+              borderRadius: "6px",
+              background: "var(--dsw-surface-base, rgba(255, 255, 255, 0.05))",
+              border: "1px solid var(--dsw-border-subtle, rgba(255, 255, 255, 0.1))",
+              color: "var(--dsw-text-muted, #94a3b8)",
+              cursor: "pointer",
+              transition: "all 0.15s ease",
+              userSelect: "none"
+            },
+            title: tooltipTitle,
+            "aria-label": tooltipTitle,
+            children: [
+              /* @__PURE__ */ jsx2(
+                "span",
+                {
+                  "data-testid": "status-dot",
+                  style: {
+                    width: "7px",
+                    height: "7px",
+                    borderRadius: "50%",
+                    backgroundColor: statusColor,
+                    boxShadow: statusGlow,
+                    flexShrink: 0
+                  }
+                }
+              ),
+              /* @__PURE__ */ jsx2(
+                "span",
+                {
+                  style: { fontWeight: 600, color: "var(--dsw-text-default, #e2e8f0)" },
+                  children: isOnline ? "OV:" : "OV"
+                }
+              ),
+              " ",
+              /* @__PURE__ */ jsx2("span", { children: isOnline ? `${recalledCount} rec \xB7 ${pendingTokensK}k pend` : "offline" })
+            ]
+          }
+        ),
+        isOpen && /* @__PURE__ */ jsx2(
+          OpenVikingStatusPopover,
+          {
+            sessionId,
+            health,
+            sessionData,
+            recalledResult,
+            endpoint: apiClient.endpoint,
+            isCommitting,
+            commitError,
+            onCommitNow: handleCommitNow,
+            onClose: () => setIsOpen(false)
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/client/index.tsx
+var name = "@dipertq/dsh-openviking-status";
+var inject = ["slots"];
+function apply(ctx) {
+  ctx.effect(
+    () => ctx.slots.inject(
+      "conversation.input.right",
+      () => ctx.slots.register(
+        {
+          name: "conversation.input.right",
+          id: "openviking-status",
+          order: 50,
+          label: "OpenViking"
+        },
+        OpenVikingStatusChip
+      )
+    ),
+    "openviking-status: composer chip"
+  );
+}
+export {
+  COMMIT_THRESHOLD,
+  DEFAULT_OPENVIKING_ENDPOINT,
+  OpenVikingClient,
+  OpenVikingStatusChip,
+  OpenVikingStatusPopover,
+  apply,
+  checkHealth,
+  commitSession,
+  defaultOpenVikingClient,
+  fetchSession,
+  formatEndpoint,
+  formatMemoryLeafName,
+  formatPendingTokens,
+  formatRelativeTime,
+  formatStatusLabel,
+  formatTooltipTitle,
+  getCategoryBadgeStyle,
+  getFallbackSessionMessages,
+  getProgressBarColor,
+  getProgressBarPercent,
+  getSession,
+  getStatusGlow,
+  getStatusIndicatorColor,
+  handleEscapeKey,
+  inferCategory,
+  inject,
+  name,
+  parseRecalledMemories,
+  resolveApiKey,
+  resolveEndpoint,
+  truncateSessionId
+};
+//# sourceMappingURL=client.js.map