silvermoon 0.2.1 → 0.3.0-rc.1

package/src/response.js

@@ -163,13 +163,13 @@ function dialogueResponse(intention, internalObservation, language) {
         summary: choices.length === 0
           ? localize(
             language,
-            "No active ideas are available.",
-            "当前没有 active idea。",
+            "Current state: navigation-ready. No active ideas are available.",
+            "当前状态：navigation-ready。当前没有 active idea。",
           )
           : localize(
             language,
-            `${choices.length} active idea(s) are available.`,
-            `当前有 ${choices.length} 个 active idea。`,
+            `Current state: navigation-ready. ${choices.length} active idea(s) are available.`,
+            `当前状态：navigation-ready。当前有 ${choices.length} 个 active idea。`,
           ),
         choices,
         nextSteps,
@@ -304,34 +304,85 @@ function markdownTableCell(value) {
     .replaceAll(/\r?\n/g, " ");
 }
 
-function renderIdeaList(response, language) {
+function renderMarkdownTable(headers, rows) {
+  return [
+    `| ${headers.join(" | ")} |`,
+    `| ${headers.map(() => "---").join(" | ")} |`,
+    ...rows.map((row) =>
+      `| ${row.map(markdownTableCell).join(" | ")} |`
+    ),
+  ];
+}
+
+function formatDate(timestamp, language, now) {
+  const date = new Date(timestamp);
+  if (!Number.isFinite(date.getTime()) || !Number.isFinite(now.getTime())) {
+    throw new TypeError("Cannot render an invalid timestamp");
+  }
+  const duration = now.getTime() - date.getTime();
+  const elapsed = Math.abs(duration);
+  const minute = 60_000;
+  const hour = 60 * minute;
+  const day = 24 * hour;
+  if (elapsed > 7 * day) {
+    return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+  }
+  if (elapsed < minute) {
+    return duration < 0
+      ? localize(language, "soon", "马上")
+      : localize(language, "just now", "刚刚");
+  }
+  const [amount, unit, chineseUnit] = elapsed < hour
+    ? [Math.floor(elapsed / minute), "m", "分钟"]
+    : elapsed < day
+      ? [Math.floor(elapsed / hour), "h", "小时"]
+      : [Math.floor(elapsed / day), "d", "天"];
+  return duration < 0
+    ? localize(language, `in ${amount}${unit}`, `${amount}${chineseUnit}后`)
+    : localize(language, `${amount}${unit} ago`, `${amount}${chineseUnit}前`);
+}
+
+function renderIdeaTable(ideas, language, now) {
   const headers = [
-    localize(language, "ID", "ID"),
-    localize(language, "Alias", "Alias"),
+    "Alias / ID",
     localize(language, "State", "状态"),
     localize(language, "Created", "创建时间"),
     localize(language, "Title", "标题"),
   ];
+  return renderMarkdownTable(
+    headers,
+    ideas.map((idea) => [
+      idea.alias ?? idea.id,
+      idea.state,
+      formatDate(idea.createdAt, language, now),
+      idea.title,
+    ]),
+  );
+}
+
+function renderIdeaList(response, language, now) {
   const counts = Object.entries(response.inventory.counts)
+    .filter(([, count]) => count > 0)
     .map(([state, count]) => `${state}=${count}`)
-    .join(", ");
-  const lines = [
-    `${response.summary} ${localize(language, "Counts", "计数")}: ${counts}.`,
-    "",
-    `| ${headers.join(" | ")} |`,
-    `| ${headers.map(() => "---").join(" | ")} |`,
-  ];
-  for (const idea of response.items) {
+    .join(localize(language, ", ", "，"));
+  const lines = [counts.length === 0
+    ? response.summary
+    : localize(
+      language,
+      `${response.summary} Counts: ${counts}.`,
+      `${response.summary}计数：${counts}。`,
+    )];
+  if (response.query?.createdSince) {
+    lines.push(
+      `- ${localize(language, "Created since", "创建时间下界")}: ${formatDate(response.query.createdSince, language, now)}`,
+    );
+  }
+  if (response.query?.createdBefore) {
     lines.push(
-      `| ${[
-        idea.id,
-        idea.alias,
-        idea.state,
-        idea.createdAt,
-        idea.title,
-      ].map(markdownTableCell).join(" | ")} |`,
+      `- ${localize(language, "Created before", "创建时间上界")}: ${formatDate(response.query.createdBefore, language, now)}`,
     );
   }
+  lines.push("", ...renderIdeaTable(response.items, language, now));
   if (response.items.length === 0) {
     lines.push(
       "",
@@ -341,56 +392,17 @@ function renderIdeaList(response, language) {
   return lines.join("\n");
 }
 
-export function renderResponse(response) {
+export function renderResponse(response, { now = new Date() } = {}) {
   const language = response.language ?? DEFAULT_LANGUAGE;
   if (response.kind === "idea-list") {
     return [
       `## ${responseTitle(response)}`,
       "",
-      renderIdeaList(response, language),
+      renderIdeaList(response, language, now),
     ].join("\n");
   }
   const lines = [`## ${responseTitle(response)}`, "", response.summary];
 
-  if (response.inventory) {
-    const counts = Object.entries(response.inventory.counts)
-      .map(([state, count]) => `${state}=${count}`)
-      .join(", ");
-    lines.push(
-      "",
-      `- ${localize(language, "States", "状态")}: ${response.query.states
-        .map(codeSpan)
-        .join(", ")}`,
-    );
-    if (response.query.query !== null) {
-      lines.push(
-        `- ${localize(language, "Query", "查询")}: ${codeSpan(response.query.query)}`,
-      );
-    }
-    if (response.query.createdSince !== null) {
-      lines.push(
-        `- ${localize(language, "Created since", "创建时间下界")}: ${codeSpan(response.query.createdSince)}`,
-      );
-    }
-    if (response.query.createdBefore !== null) {
-      lines.push(
-        `- ${localize(language, "Created before", "创建时间上界")}: ${codeSpan(response.query.createdBefore)}`,
-      );
-    }
-    lines.push(
-      `- ${localize(language, "Sort", "排序")}: ${codeSpan(response.query.sort)}`,
-      `- ${localize(language, "Limit", "上限")}: ${response.query.limit === null
-        ? localize(language, "none", "无")
-        : codeSpan(response.query.limit)}`,
-      `- ${localize(language, "Matched", "匹配")}: ${response.inventory.matched}`,
-      `- ${localize(language, "Returned", "返回")}: ${response.inventory.returned}`,
-      `- ${localize(language, "Truncated", "已截断")}: ${response.inventory.truncated
-        ? localize(language, "yes", "是")
-        : localize(language, "no", "否")}`,
-      `- ${localize(language, "Counts", "计数")}: ${counts}`,
-    );
-  }
-
   if (response.validation) {
     const target = response.validation.target.type === "commit"
       ? `${response.validation.target.type} ${response.validation.target.revision}`
@@ -432,40 +444,22 @@ export function renderResponse(response) {
     );
   }
 
-  if (response.choices?.length > 0) {
+  if (response.choices) {
     lines.push(
       "",
-      `### ${localize(language, "Available ideas", "可用 ideas")}`,
+      `### ${localize(language, "Active ideas", "Active ideas")}`,
       "",
     );
-    for (const idea of response.choices) {
-      const alias = idea.alias === undefined ? "" : ` (${idea.alias})`;
-      lines.push(`- ${codeSpan(idea.id)}${alias} ${idea.state}`);
-    }
-  }
-
-  if (response.items) {
-    lines.push("", `### ${localize(language, "Results", "结果")}`, "");
-    if (response.items.length === 0) {
-      lines.push(localize(language, "No ideas matched.", "没有匹配的 idea。"));
+    if (response.choices.length === 0) {
+      lines.push(
+        localize(
+          language,
+          "No active ideas are available.",
+          "当前没有 active idea。",
+        ),
+      );
     } else {
-      for (const idea of response.items) {
-        const details = [
-          `${localize(language, "State", "状态")}=${codeSpan(idea.state)}`,
-          `${localize(language, "Created", "创建时间")}=${codeSpan(idea.createdAt)}`,
-        ];
-        if (idea.alias !== undefined) {
-          details.push(
-            `${localize(language, "Alias", "Alias")}=${codeSpan(idea.alias)}`,
-          );
-        }
-        if (idea.title !== undefined) {
-          details.push(
-            `${localize(language, "Title", "标题")}=${codeSpan(idea.title)}`,
-          );
-        }
-        lines.push(`- ${codeSpan(idea.id)}: ${details.join("; ")}`);
-      }
+      lines.push(...renderIdeaTable(response.choices, language, now));
     }
   }
 
@@ -475,9 +469,13 @@ export function renderResponse(response) {
       `### ${localize(language, "Issues to address", "需要处理的问题")}`,
       "",
     );
-    for (const problem of response.problems) {
-      lines.push(`- [${problem.type}] ${problem.summary}`);
-    }
+    lines.push(...renderMarkdownTable(
+      [
+        localize(language, "Type", "类型"),
+        localize(language, "Summary", "概要"),
+      ],
+      response.problems.map(({ type, summary }) => [type, summary]),
+    ));
   }
 
   if (response.nextSteps?.length > 0) {

package/src/subprocess.js

@@ -0,0 +1,27 @@
+import { spawnSync } from "node:child_process";
+
+import { traceSync } from "./trace.js";
+
+export function runSubprocess(
+  command,
+  args,
+  options,
+  {
+    attributes = {},
+    spanName = "process.command",
+    spawn = spawnSync,
+  } = {},
+) {
+  return traceSync(
+    spanName,
+    attributes,
+    () => spawn(command, args, options),
+    (completed) => ({
+      attributes: {
+        exitCode: completed.status,
+        signal: completed.signal,
+      },
+      status: completed.status === 0 ? "ok" : "error",
+    }),
+  );
+}

package/src/trace.js

@@ -1,7 +1,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash, randomUUID } from "node:crypto";
 import { constants } from "node:fs";
-import { access, lstat, writeFile } from "node:fs/promises";
+import { access, lstat, open } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 
 export const TRACE_SCHEMA_VERSION = 2;
@@ -217,6 +217,41 @@ export function traceSync(name, attributes, callback, summarize = () => ({})) {
   );
 }
 
+async function flushTrace(path, trace) {
+  const span = trace.start("trace.flush", null, {});
+  let handle;
+  let failure;
+  let spanEnded = false;
+  try {
+    handle = await open(path, "wx");
+    await handle.writeFile(trace.serialize(), { encoding: "utf8" });
+    await handle.sync();
+    trace.end(span, "ok", { eventCount: trace.events.length + 1 });
+    spanEnded = true;
+    await handle.appendFile(
+      `${JSON.stringify(trace.events.at(-1))}\n`,
+      { encoding: "utf8" },
+    );
+    await handle.sync();
+  } catch (caught) {
+    if (!spanEnded) {
+      trace.end(span, "error", { errorName: errorName(caught) });
+    }
+    failure = caught;
+  }
+
+  if (handle) {
+    try {
+      await handle.close();
+    } catch (caught) {
+      failure = failure
+        ? new AggregateError([failure, caught], `Cannot close trace file: ${path}`)
+        : caught;
+    }
+  }
+  if (failure) throw failure;
+}
+
 export async function withTraceFile(file, name, attributes, callback) {
   if (file === undefined) return callback();
 
@@ -236,7 +271,7 @@ export async function withTraceFile(file, name, attributes, callback) {
 
   let traceError;
   try {
-    await writeFile(path, trace.serialize(), { encoding: "utf8", flag: "wx" });
+    await flushTrace(path, trace);
   } catch (caught) {
     traceError = caught;
   }

package/src/tui-table.js

@@ -0,0 +1,71 @@
+import stringWidth from "string-width";
+import { parse } from "tui-md";
+
+function cellText(node) {
+  if (node.type === "image") return node.alt ?? "";
+  if (typeof node.value === "string") return node.value;
+  return (node.children ?? []).map(cellText).join("");
+}
+
+function tableLines(node) {
+  const rows = node.children.map((row) => row.children.map(cellText));
+  const widths = rows[0].map((_, column) =>
+    Math.max(3, ...rows.map((row) => stringWidth(row[column] ?? "") + 2))
+  );
+  const border = (left, middle, right) =>
+    `${left}${widths.map((width) => "─".repeat(width)).join(middle)}${right}`;
+  const rowLine = (row) =>
+    `│${widths.map((width, column) => {
+      const value = row[column] ?? "";
+      const space = width - 2 - stringWidth(value);
+      const alignment = node.align?.[column];
+      const left = alignment === "right"
+        ? space
+        : alignment === "center" ? Math.floor(space / 2) : 0;
+      return ` ${" ".repeat(left)}${value}${" ".repeat(space - left)} │`;
+    }).join("")}`;
+  const lines = [
+    border("┌", "┬", "┐"),
+    rowLine(rows[0]),
+    border("├", "┼", "┤"),
+  ];
+  for (const [index, row] of rows.slice(1).entries()) {
+    if (index > 0) lines.push(border("├", "┼", "┤"));
+    lines.push(rowLine(row));
+  }
+  lines.push(border("└", "┴", "┘"));
+  return { lines, width: stringWidth(lines[0]) };
+}
+
+export function tuiMarkdownBlocks(content, availableWidth) {
+  if (!content.includes("|")) return [{ kind: "markdown", content }];
+  const blocks = [];
+  let offset = 0;
+  for (const node of parse(content).children) {
+    if (node.type !== "table") continue;
+    if (!node.children.every((row) =>
+      row.children.every((cell) =>
+        cell.children.every((child) => child.type === "text")
+      )
+    )) continue;
+    const table = tableLines(node);
+    const hasWideText = node.children.some((row) =>
+      row.children.some((cell) => {
+        const text = cellText(cell);
+        return stringWidth(text) > text.length;
+      })
+    );
+    if (!hasWideText || table.width > availableWidth) continue;
+    const start = node.position.start.offset;
+    const end = node.position.end.offset;
+    if (start > offset) {
+      blocks.push({ kind: "markdown", content: content.slice(offset, start) });
+    }
+    blocks.push({ kind: "table", lines: table.lines, width: table.width });
+    offset = end;
+  }
+  if (offset < content.length) {
+    blocks.push({ kind: "markdown", content: content.slice(offset) });
+  }
+  return blocks.length === 0 ? [{ kind: "markdown", content }] : blocks;
+}

package/src/tui.js

@@ -0,0 +1,205 @@
+import { createCliRenderer } from "@opentui/core";
+import { win32 } from "node:path";
+import {
+  createRoot,
+  useKeyboard,
+  useRenderer,
+  useTerminalDimensions,
+} from "@opentui/react";
+import { createElement, useEffect, useMemo, useRef, useState } from "react";
+import { Markdown } from "tui-md";
+
+import { runSubprocess } from "./subprocess.js";
+import { tuiMarkdownBlocks } from "./tui-table.js";
+
+const COPY_STATUS_DURATION_MS = 3000;
+const SHORTCUT_HINT = "  [q/Esc] quit  [scroll] navigate  [drag, y] copy";
+const SUCCESS_COLOR = "#9ccb9e";
+const WARNING_COLOR = "#e2b86b";
+
+function spawnClipboard(command, args, options) {
+  return runSubprocess(command, args, options, {
+    attributes: { operation: "windows-clipboard" },
+  });
+}
+
+export function copyStatusColor(status) {
+  if (status === null) return "#6b6b6b";
+  if (status.kind === "success") return SUCCESS_COLOR;
+  if (status.kind === "warning") return WARNING_COLOR;
+  throw new Error(`Unsupported copy status kind: ${status.kind}`);
+}
+
+export function copyWindowsClipboard(
+  text,
+  spawn = spawnClipboard,
+  systemRoot = process.env.SystemRoot,
+) {
+  if (!systemRoot) return { ok: false, reason: "SystemRoot is unavailable" };
+  const script = [
+    "$ErrorActionPreference = 'Stop'",
+    "[Console]::InputEncoding = New-Object System.Text.UTF8Encoding($false)",
+    "$value = [Console]::In.ReadToEnd()",
+    "Set-Clipboard -Value $value",
+  ].join("; ");
+  const result = spawn(win32.join(
+    systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe",
+  ), [
+    "-NoProfile", "-NonInteractive", "-Command", script,
+  ], {
+    encoding: "utf8",
+    input: Buffer.from(text, "utf8"),
+    timeout: 5000,
+    windowsHide: true,
+  });
+  if (result.error) return { ok: false, reason: result.error.message };
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      reason: result.stderr?.trim().split(/\r?\n/, 1)[0]
+        || `PowerShell exited with status ${result.status}`,
+    };
+  }
+  return { ok: true };
+}
+
+export function copyTuiSelection(renderer, {
+  stdout = process.stdout,
+  platform = process.platform,
+  windowsClipboard = copyWindowsClipboard,
+} = {}) {
+  const text = renderer.getSelection()?.getSelectedText();
+  if (!text) return { message: "Select text first", kind: "warning" };
+  if (renderer.copyToClipboardOSC52(text)) {
+    return { message: "Copy sent to terminal clipboard", kind: "success" };
+  }
+  if (platform === "win32" && stdout === process.stdout) {
+    const result = windowsClipboard(text);
+    return result.ok
+      ? { message: "Copied to Windows clipboard", kind: "success" }
+      : { message: `Copy failed: ${result.reason}`, kind: "warning" };
+  }
+  return { message: "No clipboard; Shift+drag", kind: "warning" };
+}
+
+function MarkdownViewer({ content, stdout }) {
+  const renderer = useRenderer();
+  const { height, width } = useTerminalDimensions();
+  const [copyStatus, setCopyStatus] = useState(null);
+  const copyStatusTimeout = useRef(null);
+  const contentWidth = Math.max(1, width - 4);
+  const blocks = useMemo(
+    () => tuiMarkdownBlocks(content, contentWidth),
+    [content, contentWidth],
+  );
+
+  useEffect(() => () => clearTimeout(copyStatusTimeout.current), []);
+
+  useKeyboard((key) => {
+    if (key.name === "q" || key.name === "escape") renderer.destroy();
+    if (key.name === "y") {
+      clearTimeout(copyStatusTimeout.current);
+      setCopyStatus(copyTuiSelection(renderer, { stdout }));
+      copyStatusTimeout.current = setTimeout(() => {
+        setCopyStatus(null);
+        copyStatusTimeout.current = null;
+      }, COPY_STATUS_DURATION_MS);
+    }
+  });
+
+  return createElement(
+    "box",
+    {
+      flexDirection: "column",
+      height,
+      width,
+    },
+    createElement(
+      "box",
+      {
+        backgroundColor: "#1e1e1e",
+        flexShrink: 0,
+        paddingX: 1,
+        width: "100%",
+      },
+      createElement("text", { fg: "#569cd6" }, "Silvermoon"),
+      createElement(
+        "text",
+        {
+          fg: copyStatusColor(copyStatus),
+          height: 1,
+          truncate: true,
+          width: "100%",
+          wrapMode: "none",
+        },
+        copyStatus ? `  ${copyStatus.message}` : SHORTCUT_HINT,
+      ),
+    ),
+    createElement(
+      "scrollbox",
+      {
+        flexGrow: 1,
+        flexShrink: 1,
+        scrollY: true,
+        width: "100%",
+      },
+      createElement(
+        "box",
+        {
+          flexDirection: "column",
+          paddingX: 2,
+          paddingY: 1,
+          width: contentWidth,
+        },
+        ...blocks.map((block, index) =>
+          block.kind === "markdown"
+            ? createElement(Markdown, { key: index, content: block.content })
+            : createElement(
+              "box",
+              { key: index, flexDirection: "column", marginBottom: 1, width: "100%" },
+              ...block.lines.map((line, lineIndex) =>
+                createElement("text", {
+                  key: lineIndex,
+                  fg: lineIndex === 1 ? "#569cd6" : "#d4d4d4",
+                  width: block.width,
+                  wrapMode: "none",
+                }, line)
+              ),
+            )
+        ),
+      ),
+    ),
+  );
+}
+
+export function tuiOutputStream(stdout, platform = process.platform) {
+  if (platform !== "win32") return stdout;
+
+  // A distinct stream makes OpenTUI use its byte feed instead of writing UTF-8
+  // directly through the native Windows console's legacy output code page.
+  return {
+    get columns() { return stdout.columns; },
+    get rows() { return stdout.rows; },
+    get isTTY() { return stdout.isTTY; },
+    write: (...args) => stdout.write(...args),
+    getColorDepth: (...args) => stdout.getColorDepth(...args),
+  };
+}
+
+export async function renderTuiMarkdown(content, { stdin, stdout }) {
+  let renderer;
+  try {
+    renderer = await createCliRenderer({
+      clearOnShutdown: true,
+      exitOnCtrlC: true,
+      screenMode: "alternate-screen",
+      stdin,
+      stdout: tuiOutputStream(stdout),
+    });
+    renderer.setTerminalTitle("Silvermoon");
+    createRoot(renderer).render(createElement(MarkdownViewer, { content, stdout }));
+  } catch (caught) {
+    renderer?.destroy();
+    throw caught;
+  }
+}