indusagi-coding-agent 0.2.8 → 0.2.9

package/src/transcript-export/publish.ts

@@ -0,0 +1,260 @@
+/**
+ * publishTranscript — render a session transcript to a standalone, self-contained
+ * HTML document.
+ */
+import hljs from "highlight.js";
+import { marked } from "marked";
+import { briefingFault, type ExportTheme } from "../briefing/contract.js";
+import { paintSgr } from "./sgr.js";
+import { CLIENT_SCRIPT, fill, PAGE_SHELL, PAGE_STYLES, SHELL_SLOTS } from "./template.js";
+import { createThemeBridge, DefaultThemeBridge } from "./theme-bridge.js";
+
+interface TextPart {
+  type: "text";
+  text: string;
+}
+
+interface ImagePart {
+  type: "image";
+  data: string;
+  mimeType: string;
+}
+
+interface ThinkingPart {
+  type: "thinking";
+  thinking: string;
+}
+
+interface ToolCallPart {
+  type: "toolCall";
+  id: string;
+  name: string;
+  arguments: unknown;
+}
+
+type ContentPart = TextPart | ImagePart | ThinkingPart | ToolCallPart | { type: string };
+
+export interface TranscriptEntry {
+  readonly role: "user" | "assistant" | "tool" | "system" | "condense" | "note";
+  readonly message: {
+    readonly content: string | readonly ContentPart[];
+    readonly toolCallId?: string;
+    readonly toolName?: string;
+  };
+}
+
+export interface TranscriptWidget {
+  readonly callId: string;
+  readonly html: string;
+}
+
+export interface PublishOptions {
+  readonly theme?: ExportTheme;
+  readonly title?: string;
+  readonly widgets?: readonly TranscriptWidget[];
+}
+
+const MARKED_LICENSE = [
+  "marked \u2014 https://github.com/markedjs/marked",
+  "Copyright (c) 2018+, MarkedJS",
+  "Copyright (c) 2011-2018, Christopher Jeffrey",
+  "Released under the MIT License.",
+].join("\n");
+
+const HIGHLIGHT_LICENSE = [
+  "highlight.js \u2014 https://github.com/highlightjs/highlight.js",
+  "Copyright (c) 2006, Ivan Sagalaev. All rights reserved.",
+  "Released under the BSD-3-Clause License.",
+].join("\n");
+
+const ROLE_LABEL: Readonly<Record<TranscriptEntry["role"], string>> = {
+  user: "You",
+  assistant: "Assistant",
+  tool: "Tool",
+  system: "System",
+  condense: "Summary",
+  note: "Note",
+};
+
+function escapeHtml2(text: string): string {
+  return text
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+function hasAnsi(text: string): boolean {
+  return /\x1B\[/.test(text);
+}
+
+function highlightCode(code: string, language?: string): string {
+  try {
+    if (language && hljs.getLanguage(language)) {
+      return hljs.highlight(code, { language }).value;
+    }
+    return hljs.highlightAuto(code).value;
+  } catch {
+    return escapeHtml2(code);
+  }
+}
+
+function configuredMarked(): typeof marked {
+  marked.setOptions({ gfm: true, breaks: false, async: false });
+  marked.use({
+    renderer: {
+      code(token: string | { text: string; lang?: string }): string {
+        const text = typeof token === "string" ? token : token.text;
+        const lang =
+          typeof token === "string" ? undefined : (token.lang || "").trim() || undefined;
+        const highlighted = highlightCode(text, lang);
+        const cls = lang ? ` class="language-${escapeHtml2(lang)}"` : "";
+        return `<pre><code${cls}>${highlighted}</code></pre>`;
+      },
+    },
+  });
+  return marked;
+}
+
+function renderMarkdown(md: typeof marked, source: string): string {
+  const out = md.parse(source, { async: false });
+  return typeof out === "string" ? out : "";
+}
+
+function renderImage(part: ImagePart): string {
+  const src = `data:${escapeHtml2(part.mimeType)};base64,${part.data}`;
+  return `<img alt="attached image" src="${src}" />`;
+}
+
+function renderToolCall(name: string, args: unknown): string {
+  let payload: string;
+  try {
+    payload = JSON.stringify(args, null, 2);
+  } catch {
+    payload = String(args);
+  }
+  return `<div class="tool-frame"><strong>${escapeHtml2(name)}</strong>\n${escapeHtml2(payload)}</div>`;
+}
+
+function renderToolText(text: string): string {
+  const inner = hasAnsi(text) ? paintSgr(text) : escapeHtml2(text);
+  return `<pre class="tool-frame">${inner}</pre>`;
+}
+
+function partsOf(content: string | readonly ContentPart[]): readonly ContentPart[] {
+  if (typeof content === "string") {
+    return [{ type: "text", text: content }];
+  }
+  return content;
+}
+
+interface RenderedTurn {
+  readonly kind: "turn" | "note";
+  readonly role: TranscriptEntry["role"];
+  readonly label: string;
+  readonly html: string;
+}
+
+function renderEntry(
+  entry: TranscriptEntry,
+  md: typeof marked,
+  widgets: Map<string, TranscriptWidget>,
+): RenderedTurn {
+  const role = entry.role;
+  const label = ROLE_LABEL[role] ?? role;
+  if (role === "tool" && entry.message.toolCallId !== undefined) {
+    const widget = widgets.get(entry.message.toolCallId);
+    if (widget !== undefined) {
+      return { kind: "turn", role, label, html: widget.html };
+    }
+  }
+  const fragments: string[] = [];
+  for (const part of partsOf(entry.message.content)) {
+    switch (part.type) {
+      case "text":
+        if (role === "tool") {
+          fragments.push(renderToolText((part as TextPart).text));
+        } else {
+          fragments.push(renderMarkdown(md, (part as TextPart).text));
+        }
+        break;
+      case "image":
+        fragments.push(renderImage(part as ImagePart));
+        break;
+      case "thinking":
+        fragments.push(
+          `<div class="aside-note">${escapeHtml2((part as ThinkingPart).thinking)}</div>`,
+        );
+        break;
+      case "toolCall": {
+        const tc = part as ToolCallPart;
+        fragments.push(renderToolCall(tc.name, tc.arguments));
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  const html = fragments.join("\n");
+  const kind: "turn" | "note" = role === "system" || role === "condense" ? "note" : "turn";
+  return { kind, role, label, html };
+}
+
+function toBase64(text: string): string {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(text, "utf-8").toString("base64");
+  }
+  const bytes = encodeURIComponent(text).replace(/%([0-9A-F]{2})/g, (_m, h) =>
+    String.fromCharCode(parseInt(h, 16)),
+  );
+  return btoa(bytes);
+}
+
+function themeVarsBlock(bridge: DefaultThemeBridge): string {
+  const vars = bridge.toCssVars();
+  const hyphenate = (name: string): string =>
+    name.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+  return Object.entries(vars)
+    .map(([token, value]) => `  --x-${hyphenate(token)}: ${value};`)
+    .join("\n");
+}
+
+export function publishTranscript(
+  entries: readonly TranscriptEntry[],
+  opts: PublishOptions = {},
+): string {
+  try {
+    const bridge = opts.theme ? createThemeBridge(opts.theme) : createThemeBridge();
+    const md = configuredMarked();
+    const widgetIndex = new Map<string, TranscriptWidget>(
+      (opts.widgets ?? []).map((w) => [w.callId, w]),
+    );
+    const turns = entries.map((entry) => renderEntry(entry, md, widgetIndex));
+    const title = opts.title ?? "Session Transcript";
+    const payloadJson = JSON.stringify({
+      title,
+      turns: turns.map((t) => ({
+        kind: t.kind === "note" ? "note" : undefined,
+        role: t.role,
+        label: t.label,
+        html: t.html,
+      })),
+    });
+    const payload = toBase64(payloadJson);
+    const slots: Record<string, string> = {
+      [SHELL_SLOTS.themeVars]: themeVarsBlock(bridge),
+      [SHELL_SLOTS.pageSurface]: bridge.theme.pageSurface,
+      [SHELL_SLOTS.cardSurface]: bridge.theme.cardSurface,
+      [SHELL_SLOTS.noteSurface]: bridge.theme.noteSurface,
+      [SHELL_SLOTS.styles]: PAGE_STYLES,
+      [SHELL_SLOTS.script]: CLIENT_SCRIPT,
+      [SHELL_SLOTS.payload]: payload,
+      [SHELL_SLOTS.markedLib]: MARKED_LICENSE,
+      [SHELL_SLOTS.highlightLib]: HIGHLIGHT_LICENSE,
+    };
+    return fill(PAGE_SHELL, slots);
+  } catch (cause) {
+    throw briefingFault("publish", "Failed to render the HTML transcript.", cause);
+  }
+}

package/src/transcript-export/sgr.ts

@@ -0,0 +1,315 @@
+/**
+ * SGR painter — a table-driven ANSI Select-Graphic-Rendition state machine that
+ * converts a terminal byte stream into a sequence of styled HTML spans.
+ */
+import type { SgrMutation, SgrState, SgrToken } from "../briefing/contract.js";
+import { SGR_INITIAL_STATE } from "../briefing/contract.js";
+
+const LINE_FEED = "\n";
+const LINE_SEPARATOR = "\u2028";
+const LINE_SEPARATOR_ESCAPE = "\\u2028";
+const PARAGRAPH_SEPARATOR_ESCAPE = "\\u2029";
+const SEPARATOR_PATTERN = /[\u2028\u2029]/g;
+const TEXT_DECODER = new TextDecoder();
+
+function clampByte(value: number): number {
+  if (value < 0) return 0;
+  if (value > 255) return 255;
+  return value | 0;
+}
+
+function hexPair(value: number): string {
+  return clampByte(value).toString(16).padStart(2, "0");
+}
+
+function rgbHex(r: number, g: number, b: number): string {
+  return `#${hexPair(r)}${hexPair(g)}${hexPair(b)}`;
+}
+
+function color256(index: number): string {
+  const i = clampByte(index);
+  if (i < 16) {
+    return PALETTE_16[i] ?? "#000000";
+  }
+  if (i < 232) {
+    const c = i - 16;
+    const levels = [0, 95, 135, 175, 215, 255];
+    const r = levels[Math.floor(c / 36) % 6] ?? 0;
+    const g = levels[Math.floor(c / 6) % 6] ?? 0;
+    const b = levels[c % 6] ?? 0;
+    return rgbHex(r, g, b);
+  }
+  const step = 8 + (i - 232) * 10;
+  return rgbHex(step, step, step);
+}
+
+function buildCodeTable(): Map<number, SgrMutation> {
+  const table = new Map<number, SgrMutation>();
+  table.set(0, { ...SGR_INITIAL_STATE });
+  table.set(1, { bold: true });
+  table.set(2, { dim: true });
+  table.set(3, { italic: true });
+  table.set(4, { underline: true });
+  table.set(5, { blink: true });
+  table.set(6, { blink: true });
+  table.set(7, { inverse: true });
+  table.set(8, { hidden: true });
+  table.set(9, { strike: true });
+  table.set(21, { bold: false });
+  table.set(22, { bold: false, dim: false });
+  table.set(23, { italic: false });
+  table.set(24, { underline: false });
+  table.set(25, { blink: false });
+  table.set(27, { inverse: false });
+  table.set(28, { hidden: false });
+  table.set(29, { strike: false });
+  for (let n = 0; n < 8; n++) {
+    table.set(30 + n, { fg: BASE_PALETTE[n] ?? null });
+    table.set(90 + n, { fg: BRIGHT_PALETTE[n] ?? null });
+  }
+  table.set(39, { fg: null });
+  for (let n = 0; n < 8; n++) {
+    table.set(40 + n, { bg: BASE_PALETTE[n] ?? null });
+    table.set(100 + n, { bg: BRIGHT_PALETTE[n] ?? null });
+  }
+  table.set(49, { bg: null });
+  return table;
+}
+
+const BASE_PALETTE: readonly string[] = [
+  "#1c1c1c",
+  "#c14a4a",
+  "#5aa45a",
+  "#b5963c",
+  "#4a7fc1",
+  "#a05aa0",
+  "#42a0a0",
+  "#c9c9c9",
+];
+
+const BRIGHT_PALETTE: readonly string[] = [
+  "#5c5c5c",
+  "#e06666",
+  "#86d186",
+  "#e6cc66",
+  "#6fa8e6",
+  "#c986c9",
+  "#6fcccc",
+  "#f5f5f5",
+];
+
+const PALETTE_16: readonly string[] = [...BASE_PALETTE, ...BRIGHT_PALETTE];
+const CODE_TABLE = buildCodeTable();
+
+export const SGR_CODE_TABLE: ReadonlyMap<number, SgrMutation> = CODE_TABLE;
+
+function readExtendedColor(
+  params: readonly number[],
+  introducerIndex: number,
+): { color: string | null; consumed: number } {
+  const selector = params[introducerIndex + 1];
+  if (selector === 5) {
+    const index = params[introducerIndex + 2];
+    if (index === undefined) return { color: null, consumed: 1 };
+    return { color: color256(index), consumed: 3 };
+  }
+  if (selector === 2) {
+    const r = params[introducerIndex + 2];
+    const g = params[introducerIndex + 3];
+    const b = params[introducerIndex + 4];
+    if (r === undefined || g === undefined || b === undefined) {
+      return { color: null, consumed: 1 };
+    }
+    return { color: rgbHex(r, g, b), consumed: 5 };
+  }
+  return { color: null, consumed: 1 };
+}
+
+export function foldSgr(state: SgrState, params: readonly number[]): SgrState {
+  if (params.length === 0) {
+    return { ...SGR_INITIAL_STATE };
+  }
+  let next = state;
+  for (let i = 0; i < params.length; i++) {
+    const code = params[i];
+    if (code === undefined) continue;
+    if (code === 38 || code === 48) {
+      const { color, consumed } = readExtendedColor(params, i);
+      if (color !== null) {
+        next = code === 38 ? { ...next, fg: color } : { ...next, bg: color };
+      }
+      i += consumed - 1;
+      continue;
+    }
+    const mutation = CODE_TABLE.get(code);
+    if (mutation !== undefined) {
+      next = { ...next, ...mutation };
+    }
+  }
+  return next;
+}
+
+function isFinalByte(ch: string): boolean {
+  const code = ch.charCodeAt(0);
+  return code >= 64 && code <= 126;
+}
+
+function parseParams(body: string): number[] {
+  if (body.length === 0) return [];
+  return body.split(";").map((field) => {
+    const value = parseInt(field, 10);
+    return Number.isNaN(value) ? 0 : value;
+  });
+}
+
+export function tokenizeSgr(input: string): SgrToken[] {
+  const tokens: SgrToken[] = [];
+  let textStart = 0;
+  let i = 0;
+  const n = input.length;
+  const flushText = (end: number): void => {
+    if (end > textStart) {
+      tokens.push({ kind: "text", text: input.slice(textStart, end) });
+    }
+  };
+  while (i < n) {
+    if (input[i] !== ESC) {
+      i++;
+      continue;
+    }
+    flushText(i);
+    if (input[i + 1] !== "[") {
+      i += input[i + 1] === undefined ? 1 : 2;
+      textStart = i;
+      continue;
+    }
+    let j = i + 2;
+    while (j < n && !isFinalByte(input[j])) {
+      j++;
+    }
+    const finalByte = input[j];
+    const body = input.slice(i + 2, j);
+    if (finalByte === "m") {
+      tokens.push({ kind: "sgr", params: parseParams(body) });
+    }
+    i = j + 1;
+    textStart = i;
+  }
+  flushText(n);
+  return tokens;
+}
+
+const ESC = "\x1B";
+
+function escapeChar(ch: string): string | null {
+  switch (ch) {
+    case "&":
+      return "&amp;";
+    case "<":
+      return "&lt;";
+    case ">":
+      return "&gt;";
+    case '"':
+      return "&quot;";
+    case "'":
+      return "&#39;";
+    default:
+      return null;
+  }
+}
+
+function escapeHtml(text: string): string {
+  let out = "";
+  for (const ch of text) {
+    out += escapeChar(ch) ?? ch;
+  }
+  return out;
+}
+
+function classesFor(state: SgrState): string[] {
+  const classes: string[] = [];
+  for (const { key, suffix } of FLAG_CLASSES) {
+    if (state[key as keyof SgrState]) classes.push(`${CLASS_PREFIX}-${suffix}`);
+  }
+  if (state.inverse) classes.push(`${CLASS_PREFIX}-inverse`);
+  if (state.hidden) classes.push(`${CLASS_PREFIX}-hidden`);
+  return classes;
+}
+
+const CLASS_PREFIX = "sgr";
+const FLAG_CLASSES: ReadonlyArray<{ key: keyof SgrState; suffix: string }> = [
+  { key: "bold", suffix: "bold" },
+  { key: "dim", suffix: "dim" },
+  { key: "italic", suffix: "italic" },
+  { key: "underline", suffix: "underline" },
+  { key: "blink", suffix: "blink" },
+  { key: "strike", suffix: "strike" },
+];
+
+function stylesFor(state: SgrState): string[] {
+  let fg = state.fg;
+  let bg = state.bg;
+  if (state.inverse) {
+    const swapped = fg;
+    fg = bg ?? "var(--sgr-default-bg, #13161c)";
+    bg = swapped ?? "var(--sgr-default-fg, #e6e8ee)";
+  }
+  if (state.hidden) {
+    fg = bg ?? "transparent";
+  }
+  const decls: string[] = [];
+  if (fg !== null) decls.push(`color:${fg}`);
+  if (bg !== null) decls.push(`background-color:${bg}`);
+  return decls;
+}
+
+function isPlain(state: SgrState): boolean {
+  return (
+    state.fg === null &&
+    state.bg === null &&
+    !state.bold &&
+    !state.dim &&
+    !state.italic &&
+    !state.underline &&
+    !state.blink &&
+    !state.inverse &&
+    !state.hidden &&
+    !state.strike
+  );
+}
+
+function renderRun(text: string, state: SgrState): string {
+  const safe = escapeHtml(text);
+  if (isPlain(state)) {
+    return safe;
+  }
+  const classes = classesFor(state);
+  const styles = stylesFor(state);
+  const attrs: string[] = [];
+  if (classes.length > 0) attrs.push(`class="${classes.join(" ")}"`);
+  if (styles.length > 0) attrs.push(`style="${styles.join(";")}"`);
+  return `<span${attrs.length > 0 ? " " + attrs.join(" ") : ""}>${safe}</span>`;
+}
+
+export function paintSgr(input: string): string {
+  if (input.length === 0) return "";
+  const tokens = tokenizeSgr(input);
+  let state: SgrState = { ...SGR_INITIAL_STATE };
+  let out = "";
+  for (const token of tokens) {
+    if (token.kind === "sgr") {
+      state = foldSgr(state, token.params);
+    } else {
+      out += renderRun(token.text, state);
+    }
+  }
+  return out;
+}
+
+// Suppress unused warnings for symbols used only via shared state above.
+void LINE_FEED;
+void LINE_SEPARATOR;
+void LINE_SEPARATOR_ESCAPE;
+void PARAGRAPH_SEPARATOR_ESCAPE;
+void SEPARATOR_PATTERN;
+void TEXT_DECODER;