silvermoon 0.2.2 → 0.3.0-rc.2

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;
+  }
+}

package/src/whatsnext.js

@@ -9,12 +9,14 @@ import {
 } from "./dialogue.js";
 import { createCommandRun } from "./domain.js";
 import { inspectPhaseGuidance } from "./guidance.js";
+import {
+  metadataFailureObservation,
+  readIdeaInventoryItem,
+} from "./idea-metadata.js";
 import {
   compareCommits,
   fetchPrimary,
-  inspectCurrentBranch,
-  inspectWorktreeChanges,
-  resolveHead,
+  inspectRepositoryState,
   sanitizeGitMessage,
 } from "./git.js";
 import { canonicalizeOutputLanguage } from "./language.js";
@@ -175,28 +177,36 @@ function selectIdea(ideas, selector) {
     ?? null;
 }
 
-function lifecycleInstruction(idea, language) {
+function lifecycleContentLanguageInstruction(contentLanguage, language) {
+  return localize(
+    language,
+    `Use ${contentLanguage} for natural-language content in the current world, its supporting files, and the ledger. Preserve canonical headings, stable IDs, paths, and machine fields.`,
+    `在当前世界、同世界辅助文件和 ledger 的自然语言内容中使用 ${contentLanguage}。保留 canonical 标题、稳定 ID、路径和机器字段。`,
+  );
+}
+
+function lifecycleInstruction(idea, language, contentLanguage) {
   const name = ideaName(idea);
   if (idea.state === "preparing") {
-    return localize(
+    return joinInstructions([localize(
       language,
       `Continue idea ${name} in ${idea.worlds.idealRevision.documentPath} and ${idea.ledgerPath}. Preserve the other worlds. When the Ideal World is ready, ask the user to approve exact revision ${idea.idealRevision}; only after explicit approval write it to approvedRevision in ${idea.statusPath}.`,
       `继续在 ${idea.worlds.idealRevision.documentPath} 和 ${idea.ledgerPath} 推进 idea ${name}，并保留其他世界。理想契约就绪后，请用户明确批准精确 revision ${idea.idealRevision}；只有获得明确批准后，才将其写入 ${idea.statusPath} 的 approvedRevision。`,
-    );
+    ), lifecycleContentLanguageInstruction(contentLanguage, language)]);
   }
   if (idea.state === "implementing") {
-    return localize(
+    return joinInstructions([localize(
       language,
       `Continue idea ${name} in ${idea.worlds.implementationRevision.documentPath}, its supporting files under ${idea.worlds.implementationRevision.path}, and ${idea.ledgerPath}. Do not change ${idea.worlds.idealRevision.path} unless the Ideal World must change. After all implementation evidence is published, ask the user to accept exact revision ${idea.implementationRevision}; only then write it to implementationAcceptedRevision in ${idea.statusPath}.`,
       `继续在 ${idea.worlds.implementationRevision.documentPath}、${idea.worlds.implementationRevision.path} 下的辅助文件和 ${idea.ledgerPath} 推进 idea ${name}。除非理想契约确实需要变化，否则不要修改 ${idea.worlds.idealRevision.path}。全部实现证据发布后，请用户明确验收精确 revision ${idea.implementationRevision}；只有获得明确验收后，才将其写入 ${idea.statusPath} 的 implementationAcceptedRevision。`,
-    );
+    ), lifecycleContentLanguageInstruction(contentLanguage, language)]);
   }
   if (idea.state === "deploying") {
-    return localize(
+    return joinInstructions([localize(
       language,
       `Continue idea ${name} from ${idea.worlds.deploymentRevision.documentPath}, its supporting files under ${idea.worlds.deploymentRevision.path}, and ${idea.ledgerPath}. Preserve nested worlds. After external evidence is complete and published, ask the user to accept exact revision ${idea.deploymentRevision}; only then write it to deploymentAcceptedRevision in ${idea.statusPath}.`,
       `从 ${idea.worlds.deploymentRevision.documentPath}、${idea.worlds.deploymentRevision.path} 下的辅助文件和 ${idea.ledgerPath} 继续推进 idea ${name}，并保留内层世界。外部证据完成且发布后，请用户明确验收精确 revision ${idea.deploymentRevision}；只有获得明确验收后，才将其写入 ${idea.statusPath} 的 deploymentAcceptedRevision。`,
-    );
+    ), lifecycleContentLanguageInstruction(contentLanguage, language)]);
   }
   if (idea.state === "abandoned") {
     return localize(
@@ -242,9 +252,9 @@ async function assessRepositoryReadinessInternal({
   synchronizePrimary = true,
 }) {
   const language = observed.outputLanguage;
-  let changes;
+  let repository;
   try {
-    changes = inspectWorktreeChanges(root);
+    repository = inspectRepositoryState(root);
   } catch (caught) {
     const problem = {
       type: "worktree-inspection-failed",
@@ -260,6 +270,7 @@ async function assessRepositoryReadinessInternal({
       ready: false,
     };
   }
+  const { branch, changes, head } = repository;
 
   const dirty =
     changes.conflicted.length > 0
@@ -307,7 +318,6 @@ async function assessRepositoryReadinessInternal({
     localSteps.push(...worktreeInstructionSteps(changes, language));
   }
 
-  const head = resolveHead(root);
   if (head === null) {
     localProblems.push({
       type: "head-missing",
@@ -324,7 +334,6 @@ async function assessRepositoryReadinessInternal({
     ));
   }
 
-  const branch = inspectCurrentBranch(root);
   if (branch.branch === null) {
     localProblems.push({
       type: "detached-head",
@@ -596,9 +605,49 @@ export async function whatsNext({
     );
   }
 
+  let navigationObservation = readiness.observation;
+  if (selector === undefined || !selected) {
+    let activeItems;
+    try {
+      const activeIds = new Set(
+        readiness.observation.ideas.activeIdeas.map(({ id }) => id),
+      );
+      activeItems = await traceAsync(
+        "ideas.navigation-metadata",
+        { ideaCount: activeIds.size },
+        () => Promise.all(
+          observed.layout.ideas
+            .filter(({ id }) => activeIds.has(id))
+            .map((idea) => readIdeaInventoryItem(observed.observation.root, idea)),
+        ),
+      );
+    } catch (caught) {
+      const failure = metadataFailureObservation(
+        observed,
+        caught,
+        recheckCommand,
+      );
+      return runtime.complete(failure.observation, failure.responseContext);
+    }
+    const itemsById = new Map(activeItems.map((item) => [item.id, item]));
+    navigationObservation = {
+      ...readiness.observation,
+      ideas: {
+        ...readiness.observation.ideas,
+        activeIdeas: readiness.observation.ideas.activeIdeas.map(({ id }) => {
+          const item = itemsById.get(id);
+          if (item === undefined) {
+            throw new Error(`Missing observed navigation metadata for ${id}`);
+          }
+          return item;
+        }),
+      },
+    };
+  }
+
   if (selector === undefined) {
     return runtime.complete(
-      { ...readiness.observation, state: "navigation-ready" },
+      { ...navigationObservation, state: "navigation-ready" },
       {
         nextSteps: navigationInstruction(
           observed.layout.ideas,
@@ -609,8 +658,8 @@ export async function whatsNext({
   }
   if (!selected) {
     return runtime.complete(
-      dialogueReadyObservation(readiness.observation, "idea-not-found", {
-        candidates: readiness.observation.ideas.activeIdeas,
+      dialogueReadyObservation(navigationObservation, "idea-not-found", {
+        candidates: navigationObservation.ideas.activeIdeas,
       }),
       {
         nextSteps: joinInstructions([
@@ -667,7 +716,11 @@ export async function whatsNext({
       ...(guidance === undefined ? {} : { guidance }),
     }),
     {
-      nextSteps: lifecycleInstruction(selected, observed.outputLanguage),
+      nextSteps: lifecycleInstruction(
+        selected,
+        observed.outputLanguage,
+        observed.contentLanguage,
+      ),
     },
   );
 }