@seqyuan/annodex 0.1.11 → 0.1.12

package/lib/widget-prompt.ts

@@ -0,0 +1,76 @@
+export const WIDGET_SYSTEM_PROMPT = `<widget-capability>
+You can create interactive visualizations using the \`show-widget\` code fence.
+
+Use \`show-widget\` by default when visual output is the primary answer. This includes charts, diagrams, flowcharts, dashboards, UI prototypes, mockups, SVG illustrations, icons, logos, infographics, timelines, hierarchies, comparison views, and visual explanations.
+
+For diagrams, flowcharts, architecture maps, sequence-style explanations, and Markdown-to-diagram requests, prefer \`show-widget\` with SVG/HTML over Mermaid. Widgets stream more reliably in this UI. Use Mermaid only when the user explicitly asks for Mermaid source, raw Mermaid, raw Markdown, or a saved Mermaid/Markdown file.
+
+Format:
+\`\`\`show-widget
+{"title":"Human-readable title","widget_code":"<raw HTML/SVG string>"}
+\`\`\`
+
+Detailed specs:
+When a \`<widget-guidelines>\` block is present, follow it. It contains the module-specific design rules for the current request.
+
+Required rules:
+1. \`widget_code\` is a JSON string: escape quotes and newlines. Always close the JSON object and fence.
+2. Do not include DOCTYPE, html, head, body, iframe, object, embed, form, link, base, or meta tags.
+3. Keep outer backgrounds transparent. The host supplies theme variables.
+4. Use a single concise widget per fence. For multiple widgets, interleave prose and use a separate \`show-widget\` fence for each widget.
+5. Streaming order: SVG puts \`<defs>\` before visible shapes; HTML uses \`<style>\`, then visible markup, then \`<script>\` last.
+6. Prefer responsive SVG for static visuals and small HTML widgets for controls.
+7. SVG widgets use \`<svg width="100%" viewBox="0 0 680 H">\` and keep all content inside the viewBox.
+8. Interactive controls must visibly update the output. For Chart.js, call \`chart.update()\` after changes.
+9. Clickable drill-down actions call \`window.__widgetSendMessage("short request")\`.
+10. Cross-widget filters publish with \`window.__widgetPublish("topic", { key: "value" })\`; other widgets listen for \`widget-filter\`.
+11. Allowed CDN hosts: \`cdnjs.cloudflare.com\`, \`cdn.jsdelivr.net\`, \`unpkg.com\`, \`esm.sh\`.
+12. CDN scripts must use an \`onload\` initializer plus an \`if (window.Lib) init();\` fallback.
+13. Use \`min-height\` instead of fixed outer \`height\` to prevent clipping.
+14. Title should be human-readable in the user's language.
+15. Put explanatory prose outside the code fence.
+16. Do not output raw \`\`\`svg, \`\`\`html, or plain Mermaid for visual answers unless the user explicitly asks for source code, raw Markdown, raw Mermaid, or a saved file.
+17. Do not convert Markdown outlines into Mermaid by default. Render them as a \`show-widget\` diagram unless Mermaid/source text is explicitly requested.
+</widget-capability>`;
+
+const WIDGET_BLOCK_PATTERN = /\n?\s*<widget-capability>[\s\S]*?<\/widget-capability>\s*/g;
+const HARNESS_BLOCK_PATTERN = /\n?\s*<visualization_harness>[\s\S]*?<\/visualization_harness>\s*/g;
+const GUIDELINES_BLOCK_PATTERN = /\n?\s*<widget-guidelines\b[^>]*>[\s\S]*?<\/widget-guidelines>\s*/g;
+
+export function isVisualizationHarness(content: string): boolean {
+  const normalized = content.toLowerCase();
+  return normalized.includes("show-widget")
+    && (normalized.includes("# visualization harness")
+      || normalized.includes("## when to visualize")
+      || normalized.includes("widget format"));
+}
+
+export function hasVisualizationIntent(message: string): boolean {
+  const normalized = message.toLowerCase();
+  return /\b(chart|plot|graph|visuali[sz]e|diagram|flowchart|timeline|dashboard|prototype|mockup|wireframe|heatmap|scatter|histogram|tree map|treemap|svg|icon|logo|infographic|comparison|hierarchy|interactive ui|generative ui)\b/.test(normalized)
+    || /图表|画图|绘图|可视化|流程图|架构图|时序图|原型图|交互式|仪表盘|看板|热图|散点图|折线图|柱状图|饼图|雷达图|网络图|桑基图|甘特图|图标|标志|logo|信息图|对比|层级|单细胞.*流程/.test(message);
+}
+
+export function stripWidgetPromptBlocks(systemPrompt: string): string {
+  return systemPrompt
+    .replace(WIDGET_BLOCK_PATTERN, "\n")
+    .replace(HARNESS_BLOCK_PATTERN, "\n")
+    .replace(GUIDELINES_BLOCK_PATTERN, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+export function withWidgetCapabilityPrompt(systemPrompt: string): string {
+  if (systemPrompt.includes("<widget-capability>")) return systemPrompt;
+  return systemPrompt.trim()
+    ? `${WIDGET_SYSTEM_PROMPT}\n\n${systemPrompt}`
+    : WIDGET_SYSTEM_PROMPT;
+}
+
+export function withVisualizationHarness(systemPrompt: string, harness: string): string {
+  const content = harness.trim();
+  if (!content || systemPrompt.includes("<visualization_harness>")) return systemPrompt;
+  return systemPrompt.trim()
+    ? `${systemPrompt.trimEnd()}\n\n<visualization_harness>\n${content}\n</visualization_harness>`
+    : `<visualization_harness>\n${content}\n</visualization_harness>`;
+}

package/lib/widget-utils.ts

@@ -0,0 +1,523 @@
+export interface TextSegment {
+  type: "text";
+  content: string;
+}
+
+export interface WidgetSegment {
+  type: "widget";
+  title?: string;
+  code: string;
+  partial?: boolean;
+  showOverlay?: boolean;
+}
+
+export type ContentSegment = TextSegment | WidgetSegment;
+
+/**
+ * Parse show-widget fences from markdown text. The parser is deliberately
+ * tolerant because streamed model output often contains incomplete fences or
+ * partial JSON while the widget is still being generated.
+ */
+export function parseShowWidgets(text: string): ContentSegment[] {
+  const segments: ContentSegment[] = [];
+  const markerRegex = /`{1,3}show-widget`{0,3}\s*(?:\n\s*`{3}(?:json|html)?\s*)?\n?/g;
+  let lastIndex = 0;
+  let match: RegExpExecArray | null;
+  let sawMarker = false;
+
+  while ((match = markerRegex.exec(text)) !== null) {
+    sawMarker = true;
+    const before = text.slice(lastIndex, match.index).trim();
+    if (before) segments.push({ type: "text", content: before });
+
+    const afterMarker = match.index + match[0].length;
+    const fenceClose = text.indexOf("```", afterMarker);
+    const jsonStart = text.indexOf("{", afterMarker);
+    const hasNearbyJson =
+      jsonStart !== -1 &&
+      jsonStart <= afterMarker + 200 &&
+      (fenceClose === -1 || jsonStart < fenceClose);
+
+    if (hasNearbyJson) {
+      const jsonEnd = findJsonEnd(text, jsonStart);
+      if (jsonEnd === -1) {
+        const partial = extractTruncatedWidget(text.slice(jsonStart));
+        if (partial) segments.push({ type: "widget", ...partial, partial: true });
+        lastIndex = text.length;
+        break;
+      }
+
+      const parsed = parseWidgetContent(text.slice(jsonStart, jsonEnd + 1).trim());
+      if (parsed) segments.push({ type: "widget", ...parsed });
+
+      let endPos = jsonEnd + 1;
+      const trailingFence = text.slice(endPos, endPos + 16).match(/^\s*\n?`{1,3}\s*/);
+      if (trailingFence) endPos += trailingFence[0].length;
+      lastIndex = endPos;
+      markerRegex.lastIndex = endPos;
+      continue;
+    }
+
+    if (fenceClose !== -1) {
+      const raw = text.slice(afterMarker, fenceClose).trim();
+      const parsed = parseWidgetContent(raw);
+      if (parsed) {
+        segments.push({ type: "widget", ...parsed });
+      } else if (raw) {
+        segments.push({ type: "text", content: raw });
+      }
+      lastIndex = fenceClose + 3;
+      markerRegex.lastIndex = lastIndex;
+    } else {
+      const raw = text.slice(afterMarker).trim();
+      const parsed = parseWidgetContent(raw);
+      if (parsed) {
+        const truncated = truncateUnclosedScript(parsed.code);
+        segments.push({
+          type: "widget",
+          title: parsed.title,
+          code: truncated.code,
+          partial: true,
+          showOverlay: truncated.truncated,
+        });
+      }
+      lastIndex = text.length;
+      break;
+    }
+  }
+
+  const after = text.slice(lastIndex).trim();
+  if (after) segments.push({ type: "text", content: after });
+
+  if (!sawMarker && segments.length === 0 && text.trim()) {
+    segments.push({ type: "text", content: text });
+  }
+
+  return segments;
+}
+
+function parseWidgetContent(raw: string): { title?: string; code: string } | null {
+  if (raw.startsWith("{")) {
+    if (!raw.endsWith("}")) return null;
+    try {
+      const obj = JSON.parse(raw) as { title?: string; widget_code?: string; code?: string };
+      const code = obj.widget_code ?? obj.code;
+      if (code) {
+        return { title: obj.title, code };
+      }
+    } catch {
+      return null;
+    }
+  }
+
+  if (/<(!DOCTYPE|html|svg|canvas|script|style|div)/i.test(raw)) {
+    return { code: raw };
+  }
+
+  return null;
+}
+
+function findJsonEnd(text: string, start: number): number {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (ch === "\"") {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === "{") depth++;
+    if (ch === "}") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+function extractTruncatedWidget(fenceBody: string): { title?: string; code: string; showOverlay?: boolean } | null {
+  try {
+    const parsed = parseWidgetContent(fenceBody);
+    if (parsed) return parsed;
+  } catch {
+    // Expected for partial JSON.
+  }
+
+  const keyIdx = fenceBody.indexOf("\"widget_code\"");
+  if (keyIdx === -1) return null;
+  const colonIdx = fenceBody.indexOf(":", keyIdx + 13);
+  if (colonIdx === -1) return null;
+  const quoteIdx = fenceBody.indexOf("\"", colonIdx + 1);
+  if (quoteIdx === -1) return null;
+
+  let raw = fenceBody.slice(quoteIdx + 1);
+  raw = raw.replace(/"\s*\}\s*$/, "");
+  if (raw.endsWith("\\")) raw = raw.slice(0, -1);
+
+  const title = fenceBody.match(/"title"\s*:\s*"([^"]*?)"/)?.[1];
+  const code = raw
+    .replace(/\\\\/g, "\x00BACKSLASH\x00")
+    .replace(/\\n/g, "\n")
+    .replace(/\\t/g, "\t")
+    .replace(/\\r/g, "\r")
+    .replace(/\\"/g, "\"")
+    .replace(/\\u([0-9a-fA-F]{4})/g, (_m, hex: string) => String.fromCharCode(parseInt(hex, 16)))
+    .replace(/\x00BACKSLASH\x00/g, "\\");
+
+  const truncated = truncateUnclosedScript(code);
+  if (!truncated.code.trim()) return null;
+  return { title, code: truncated.code, showOverlay: truncated.truncated };
+}
+
+function truncateUnclosedScript(code: string): { code: string; truncated: boolean } {
+  const lastScript = code.lastIndexOf("<script");
+  if (lastScript === -1) return { code, truncated: false };
+  const afterScript = code.slice(lastScript);
+  if (/<script[\s\S]*?<\/script>/i.test(afterScript)) {
+    return { code, truncated: false };
+  }
+  return { code: code.slice(0, lastScript).trim(), truncated: true };
+}
+
+/**
+ * Check if text contains any show-widget fences (including partial ones during streaming).
+ */
+export function hasWidgetFence(text: string): boolean {
+  return /`{1,3}show-widget/.test(text);
+}
+
+/**
+ * Sanitize widget HTML for streaming preview. Preview mode intentionally
+ * removes scripts and event handlers so partial JS is never shown as text.
+ */
+export function sanitizeForIframe(code: string): string {
+  return stripDangerousEmbeds(code);
+}
+
+export function sanitizeForStreaming(code: string): string {
+  return stripDangerousEmbeds(code)
+    .replace(/\s+on[a-z]+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>"']*)/gi, "")
+    .replace(/<script[\s\S]*?<\/script>/gi, "")
+    .replace(/<script\b[^>]*\/?>/gi, "")
+    .replace(/\s+(href|src|action)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>"']*))/gi, (match, _attr: string, dq?: string, sq?: string, uq?: string) => {
+      const url = (dq ?? sq ?? uq ?? "").trim();
+      return /^\s*(javascript|data)\s*:/i.test(url) ? "" : match;
+    });
+}
+
+const DANGEROUS_TAGS = /<(iframe|object|embed|meta|link|base|form)[\s>][\s\S]*?<\/\1>/gi;
+const DANGEROUS_VOID = /<(iframe|object|embed|meta|link|base)\b[^>]*\/?>/gi;
+
+function stripDangerousEmbeds(code: string): string {
+  return code.replace(DANGEROUS_TAGS, "").replace(DANGEROUS_VOID, "");
+}
+
+const THEME_VAR_NAMES = [
+  "--bg",
+  "--bg-panel",
+  "--bg-hover",
+  "--bg-selected",
+  "--border",
+  "--text",
+  "--text-muted",
+  "--text-dim",
+  "--accent",
+  "--accent-hover",
+];
+
+export function resolveWidgetThemeVars(): Record<string, string> {
+  if (typeof document === "undefined") return {};
+  const computed = getComputedStyle(document.documentElement);
+  const vars: Record<string, string> = {};
+  for (const name of THEME_VAR_NAMES) {
+    const value = computed.getPropertyValue(name).trim();
+    if (value) vars[name] = value;
+  }
+  return vars;
+}
+
+export function getWidgetIframeStyleBlock(vars: Record<string, string>): string {
+  const mergedVars = {
+    "--bg": "#ffffff",
+    "--bg-panel": "#f5f5f5",
+    "--bg-hover": "#eeeeee",
+    "--bg-selected": "#e8e8e8",
+    "--border": "#e0e0e0",
+    "--text": "#1a1a1a",
+    "--text-muted": "#6b7280",
+    "--text-dim": "#9ca3af",
+    "--accent": "#2563eb",
+    "--accent-hover": "#1d4ed8",
+    ...vars,
+    "--font-mono": "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+  };
+  const rootVars = Object.entries(mergedVars)
+    .map(([key, value]) => `  ${key}: ${value};`)
+    .join("\n");
+
+  return `
+:root {
+${rootVars}
+}
+.dark { color-scheme: dark; }
+body {
+  --color-background-primary: var(--bg, #fff);
+  --color-background-secondary: var(--bg-panel, #f5f5f5);
+  --color-background-tertiary: var(--bg-hover, #eee);
+  --color-text-primary: var(--text, #1a1a1a);
+  --color-text-secondary: var(--text-muted, #6b7280);
+  --color-text-tertiary: var(--text-dim, #9ca3af);
+  --color-border-tertiary: var(--border, #e0e0e0);
+  --color-border-secondary: var(--border, #e0e0e0);
+  --color-border-primary: var(--accent, #2563eb);
+  --font-sans: -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif;
+  --border-radius-md: 8px;
+  --border-radius-lg: 12px;
+  margin: 0;
+  padding: 0;
+  font-family: var(--font-sans);
+  font-size: 14px;
+  line-height: 1.6;
+  color: var(--color-text-primary);
+  background: transparent;
+}
+* { box-sizing: border-box; }
+svg { max-width: 100%; height: auto; display: block; }
+a { color: var(--accent, #2563eb); }
+button, input, select, textarea { font: inherit; }
+button {
+  border: 1px solid var(--color-border-tertiary);
+  border-radius: var(--border-radius-md);
+  background: var(--color-background-secondary);
+  color: var(--color-text-primary);
+  padding: 5px 10px;
+  cursor: pointer;
+}
+button:hover { background: var(--color-background-tertiary); }
+input[type="range"] { accent-color: var(--accent, #2563eb); }
+`;
+}
+
+export function buildReceiverSrcdoc(styleBlock = "", isDark = false): string {
+  const csp = [
+    "default-src 'none'",
+    "script-src 'unsafe-inline' https://cdnjs.cloudflare.com https://cdn.jsdelivr.net https://unpkg.com https://esm.sh",
+    "style-src 'unsafe-inline'",
+    "img-src * data: blob:",
+    "font-src * data:",
+    "connect-src 'none'",
+  ].join("; ");
+
+  return `<!DOCTYPE html>
+<html class="${isDark ? "dark" : ""}">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<meta http-equiv="Content-Security-Policy" content="${csp}">
+<style>
+${styleBlock}
+</style>
+</head>
+<body>
+<div id="__root" style="height:fit-content;"></div>
+<script>
+(function() {
+  var root = document.getElementById("__root");
+  var timer = null;
+  var first = true;
+  var lastHeight = 0;
+
+  function notifyReady() {
+    parent.postMessage({ type: "widget:ready" }, "*");
+  }
+
+  function reportHeight() {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(function() {
+      var rect = root.getBoundingClientRect();
+      var h = Math.ceil(Math.max(rect.height, document.body.scrollHeight, document.documentElement.scrollHeight));
+      if (h > 0 && h !== lastHeight) {
+        lastHeight = h;
+        parent.postMessage({ type: "widget:resize", height: h, first: first }, "*");
+      }
+      first = false;
+    }, 60);
+  }
+
+  function handleUpdate(html) {
+    root.innerHTML = html;
+    reportHeight();
+  }
+
+  function handleFinalize(html) {
+    var tmp = document.createElement("div");
+    tmp.innerHTML = html;
+    var nodes = tmp.querySelectorAll("script");
+    var scripts = [];
+    for (var i = 0; i < nodes.length; i++) {
+      var item = { src: nodes[i].src || "", text: nodes[i].textContent || "", attrs: [] };
+      for (var j = 0; j < nodes[i].attributes.length; j++) {
+        var attr = nodes[i].attributes[j];
+        if (attr.name !== "src" && attr.name !== "onload") item.attrs.push({ name: attr.name, value: attr.value });
+      }
+      scripts.push(item);
+      nodes[i].remove();
+    }
+    var visualHtml = tmp.innerHTML;
+    if (root.innerHTML !== visualHtml) root.innerHTML = visualHtml;
+
+    var cdnScripts = scripts.filter(function(s) { return !!s.src; });
+    var inlineScripts = scripts.filter(function(s) { return !s.src && s.text; });
+    function appendInline() {
+      for (var k = 0; k < inlineScripts.length; k++) {
+        var s = document.createElement("script");
+        s.textContent = inlineScripts[k].text;
+        for (var a = 0; a < inlineScripts[k].attrs.length; a++) {
+          s.setAttribute(inlineScripts[k].attrs[a].name, inlineScripts[k].attrs[a].value);
+        }
+        root.appendChild(s);
+      }
+      reportHeight();
+      setTimeout(function() { parent.postMessage({ type: "widget:scriptsReady" }, "*"); }, 50);
+    }
+    if (cdnScripts.length === 0) {
+      appendInline();
+    } else {
+      var pending = cdnScripts.length;
+      function done() { pending--; if (pending <= 0) appendInline(); }
+      for (var c = 0; c < cdnScripts.length; c++) {
+        var n = document.createElement("script");
+        n.src = cdnScripts[c].src;
+        n.onload = done;
+        n.onerror = done;
+        for (var d = 0; d < cdnScripts[c].attrs.length; d++) {
+          n.setAttribute(cdnScripts[c].attrs[d].name, cdnScripts[c].attrs[d].value);
+        }
+        root.appendChild(n);
+      }
+    }
+    reportHeight();
+    setTimeout(reportHeight, 150);
+    setTimeout(reportHeight, 600);
+  }
+
+  function handleTheme(vars) {
+    Object.entries(vars || {}).forEach(function(_a) {
+      var key = _a[0], val = _a[1];
+      document.documentElement.style.setProperty(key, val);
+    });
+    if (typeof arguments[1] === "boolean") {
+      document.documentElement.className = arguments[1] ? "dark" : "";
+    }
+    reportHeight();
+  }
+
+  function captureRenderedWidget(requestId) {
+    try {
+      var html = root.innerHTML;
+      var styles = "";
+      var styleEls = document.querySelectorAll("style");
+      for (var si = 0; si < styleEls.length; si++) {
+        styles += styleEls[si].textContent || "";
+      }
+
+      var canvases = document.querySelectorAll("canvas");
+      var snapshots = [];
+      var placeholders = [];
+      var hidden = [];
+      for (var ci = 0; ci < canvases.length; ci++) {
+        try {
+          var canvas = canvases[ci];
+          var placeholder = document.createElement("img");
+          placeholder.setAttribute("data-canvas-export", String(ci));
+          placeholder.style.cssText = "width:" + canvas.offsetWidth + "px;height:" + canvas.offsetHeight + "px;display:block;";
+          canvas.parentNode.insertBefore(placeholder, canvas);
+          placeholders.push(placeholder);
+          hidden.push({ node: canvas, display: canvas.style.display });
+          canvas.style.display = "none";
+          snapshots.push({
+            dataUrl: canvas.toDataURL("image/png"),
+            width: canvas.offsetWidth,
+            height: canvas.offsetHeight,
+          });
+        } catch (_err) {
+          snapshots.push(null);
+        }
+      }
+
+      html = root.innerHTML;
+
+      for (var pi = 0; pi < placeholders.length; pi++) {
+        placeholders[pi].remove();
+      }
+      for (var hi = 0; hi < hidden.length; hi++) {
+        hidden[hi].node.style.display = hidden[hi].display;
+      }
+
+      parent.postMessage({
+        type: "widget:captured",
+        requestId: requestId,
+        html: html,
+        styles: styles,
+        canvases: snapshots,
+        bodyWidth: document.body.scrollWidth,
+        bodyHeight: document.body.scrollHeight,
+      }, "*");
+    } catch (_err) {
+      parent.postMessage({ type: "widget:captured", requestId: requestId, html: null }, "*");
+    }
+  }
+
+  var ro = new ResizeObserver(reportHeight);
+  ro.observe(root);
+
+  window.addEventListener("message", function(e) {
+    if (!e.data || typeof e.data.type !== "string") return;
+    switch (e.data.type) {
+      case "widget:update": handleUpdate(e.data.html || ""); break;
+      case "widget:finalize": handleFinalize(e.data.html || ""); break;
+      case "widget:theme": handleTheme(e.data.vars, e.data.isDark); break;
+      case "widget:capture": captureRenderedWidget(e.data.requestId); break;
+      case "widget:crossFilter":
+        window.dispatchEvent(new CustomEvent("widget-filter", { detail: e.data.payload }));
+        break;
+    }
+  });
+
+  document.addEventListener("click", function(e) {
+    var a = e.target && e.target.closest ? e.target.closest("a[href]") : null;
+    if (!a) return;
+    var href = a.getAttribute("href");
+    if (!href || href.charAt(0) === "#") return;
+    e.preventDefault();
+    parent.postMessage({ type: "widget:link", href: href }, "*");
+  });
+
+  window.__widgetSendMessage = function(text) {
+    if (typeof text === "string" && text.length <= 500) {
+      parent.postMessage({ type: "widget:sendMessage", text: text }, "*");
+    }
+  };
+
+  window.__widgetPublish = function(topic, data) {
+    if (typeof topic === "string") {
+      parent.postMessage({ type: "widget:publish", topic: topic, data: data }, "*");
+    }
+  };
+
+  notifyReady();
+})();
+</script>
+</body>
+</html>`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seqyuan/annodex",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "AI-native bioinformatics workspace by Annoroad",
   "license": "MIT",
   "bin": {
@@ -8,14 +8,16 @@
   },
   "files": [
     "bin",
-    ".next",
-    "!.next/cache",
-    "!.next/dev",
-    "!.next/**/*.js.map",
-    "lib/default-SOUL.md",
-    "lib/default-HARNESS.md",
+    "app",
+    "components",
+    "hooks",
+    "lib",
     "public",
+    "scripts/postinstall.cjs",
+    "proxy.ts",
     "next.config.ts",
+    "postcss.config.mjs",
+    "tsconfig.json",
     "package.json"
   ],
   "scripts": {
@@ -24,7 +26,10 @@
     "start": "next start -p 30121",
     "lint": "eslint .",
     "test:compat": "node --test tests/compat-proxy.test.mjs",
-    "release": "npm version patch --no-git-tag-version && npm run build && npm publish --access public"
+    "pack:check": "node scripts/check-npm-pack.mjs",
+    "prepublishOnly": "node scripts/check-npm-pack.mjs",
+    "release": "npm version patch --no-git-tag-version && npm publish --access public",
+    "postinstall": "node scripts/postinstall.cjs"
   },
   "dependencies": {
     "@codemirror/autocomplete": "^6.20.2",
@@ -45,7 +50,13 @@
     "@codemirror/theme-one-dark": "^6.1.3",
     "@codemirror/view": "^6.43.0",
     "@openai/codex": "^0.118.0",
+    "@tailwindcss/postcss": "^4.2.2",
+    "@types/bcryptjs": "^2.4.6",
+    "@types/node": "^25",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
     "@types/react-syntax-highlighter": "^15.5.13",
+    "@types/ws": "^8.18.1",
     "bcryptjs": "^3.0.3",
     "codemirror": "^6.0.2",
     "docx-preview": "^0.3.7",
@@ -53,26 +64,20 @@
     "mermaid": "^11.15.0",
     "next": "16.2.1",
     "pdfjs-dist": "^5.7.284",
+    "postcss": "^8",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
     "react-markdown": "^10.1.0",
     "react-syntax-highlighter": "^16.1.1",
     "remark-gfm": "^4.0.1",
     "smol-toml": "^1.6.1",
+    "tailwindcss": "^4.2.2",
+    "typescript": "^5",
     "ws": "^8.18.0",
     "xlsx": "^0.18.5"
   },
   "devDependencies": {
-    "@tailwindcss/postcss": "^4.2.2",
-    "@types/bcryptjs": "^2.4.6",
-    "@types/node": "^25",
-    "@types/react": "^19",
-    "@types/react-dom": "^19",
-    "@types/ws": "^8.18.1",
     "eslint": "^9",
-    "eslint-config-next": "16.2.1",
-    "postcss": "^8",
-    "tailwindcss": "^4.2.2",
-    "typescript": "^5"
+    "eslint-config-next": "16.2.1"
   }
 }

package/postcss.config.mjs

@@ -0,0 +1,8 @@
+/** @type {import('postcss').Config} */
+const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;