silvermoon 0.3.0-rc.2 → 0.4.0

package/src/trace.js

@@ -1,292 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import { createHash, randomUUID } from "node:crypto";
-import { constants } from "node:fs";
-import { access, lstat, open } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-
-export const TRACE_SCHEMA_VERSION = 2;
-const traceContext = new AsyncLocalStorage();
-
-function durationMilliseconds(started) {
-  return Math.round(Number(process.hrtime.bigint() - started) / 1_000) / 1_000;
-}
-
-function errorName(caught) {
-  return caught instanceof Error ? caught.name : typeof caught;
-}
-
-class Trace {
-  constructor() {
-    this.events = [];
-    this.nextSequence = 1;
-    this.nextSpanId = 1;
-    this.traceId = randomUUID();
-  }
-
-  emit(event) {
-    this.events.push({
-      schemaVersion: TRACE_SCHEMA_VERSION,
-      traceId: this.traceId,
-      sequence: this.nextSequence,
-      timestamp: new Date().toISOString(),
-      ...event,
-    });
-    this.nextSequence += 1;
-  }
-
-  start(name, parentSpanId, attributes) {
-    const span = {
-      attributes,
-      id: String(this.nextSpanId),
-      name,
-      parentSpanId,
-      started: process.hrtime.bigint(),
-    };
-    this.nextSpanId += 1;
-    this.emit({
-      channel: "telemetry",
-      event: "span-start",
-      spanId: span.id,
-      parentSpanId,
-      name,
-      attributes,
-    });
-    return span;
-  }
-
-  end(span, status, attributes = {}) {
-    this.emit({
-      channel: "telemetry",
-      event: "span-end",
-      spanId: span.id,
-      parentSpanId: span.parentSpanId,
-      name: span.name,
-      status,
-      durationMs: durationMilliseconds(span.started),
-      attributes: { ...span.attributes, ...attributes },
-    });
-  }
-
-  serialize() {
-    return `${this.events.map((event) => JSON.stringify(event)).join("\n")}\n`;
-  }
-}
-
-async function requireAvailableTracePath(path) {
-  const parent = dirname(path);
-  const parentMetadata = await lstat(parent);
-  if (!parentMetadata.isDirectory()) {
-    throw new Error(`Trace parent is not a directory: ${parent}`);
-  }
-  await access(parent, constants.W_OK);
-  try {
-    await lstat(path);
-  } catch (caught) {
-    if (caught.code === "ENOENT") return;
-    throw caught;
-  }
-  throw new Error(`Trace file already exists: ${path}`);
-}
-
-export async function traceAsync(
-  name,
-  attributes,
-  callback,
-  summarize = () => ({}),
-) {
-  const context = traceContext.getStore();
-  if (!context) return callback();
-
-  const span = context.trace.start(name, context.parentSpanId, attributes);
-  return traceContext.run(
-    { parentSpanId: span.id, trace: context.trace },
-    async () => {
-      try {
-        const result = await callback();
-        const summary = summarize(result);
-        context.trace.end(
-          span,
-          summary.status ?? "ok",
-          summary.attributes ?? {},
-        );
-        return result;
-      } catch (caught) {
-        context.trace.end(span, "error", { errorName: errorName(caught) });
-        throw caught;
-      }
-    },
-  );
-}
-
-function hash(value) {
-  return createHash("sha256")
-    .update(JSON.stringify(value))
-    .digest("hex");
-}
-
-function projectDomainMessage(message) {
-  const base = {
-    channel: "domain",
-    event: message.type,
-    messageSequence: message.sequence,
-  };
-  if (message.type === "intention.accepted") {
-    return {
-      ...base,
-      command: message.intention.command,
-      argumentNames: Object.keys(message.intention.args ?? {}).sort(),
-      intentionHash: hash(message.intention),
-    };
-  }
-  if (message.type === "observation.fact") {
-    return {
-      ...base,
-      factType: message.fact.type,
-      progress: message.fact.progress,
-      state: message.fact.observation.state,
-      problemCount: message.fact.observation.problems?.length ?? 0,
-      problemTypes: (message.fact.observation.problems ?? [])
-        .map(({ type }) => type),
-      ...(message.fact.observation.selectedIdea?.id === undefined
-        ? {}
-        : { selectedIdeaId: message.fact.observation.selectedIdea.id }),
-      ...(message.fact.observation.createdIdea?.id === undefined
-        ? {}
-        : { createdIdeaId: message.fact.observation.createdIdea.id }),
-    };
-  }
-  if (message.type === "action.requested") {
-    return {
-      ...base,
-      actionId: message.actionId,
-      actionType: message.action.type,
-    };
-  }
-  if (message.type === "action.finished") {
-    return {
-      ...base,
-      actionId: message.actionId,
-      actionType: message.actionType,
-      status: message.status,
-      ...(message.problem?.type === undefined
-        ? {}
-        : { problemType: message.problem.type }),
-      resultFields: Object.keys(message.result ?? {}).sort(),
-    };
-  }
-  if (message.type === "response.created") {
-    return {
-      ...base,
-      kind: message.kind,
-      responseHash: message.metadata.hash,
-      nextStepCount: message.metadata.nextStepCount,
-      itemCount: message.metadata.itemCount,
-    };
-  }
-  throw new Error(`Cannot trace unknown domain message type: ${message.type}`);
-}
-
-export function emitDomainMessage(message) {
-  const context = traceContext.getStore();
-  if (!context) return;
-  context.trace.emit(projectDomainMessage(message));
-}
-
-export function traceSync(name, attributes, callback, summarize = () => ({})) {
-  const context = traceContext.getStore();
-  if (!context) return callback();
-
-  const span = context.trace.start(name, context.parentSpanId, attributes);
-  return traceContext.run(
-    { parentSpanId: span.id, trace: context.trace },
-    () => {
-      try {
-        const result = callback();
-        const summary = summarize(result);
-        context.trace.end(
-          span,
-          summary.status ?? "ok",
-          summary.attributes ?? {},
-        );
-        return result;
-      } catch (caught) {
-        context.trace.end(span, "error", { errorName: errorName(caught) });
-        throw caught;
-      }
-    },
-  );
-}
-
-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();
-
-  const path = resolve(file);
-  await requireAvailableTracePath(path);
-  const trace = new Trace();
-  let result;
-  let commandError;
-  try {
-    result = await traceContext.run(
-      { parentSpanId: null, trace },
-      () => traceAsync(name, attributes, callback),
-    );
-  } catch (caught) {
-    commandError = caught;
-  }
-
-  let traceError;
-  try {
-    await flushTrace(path, trace);
-  } catch (caught) {
-    traceError = caught;
-  }
-
-  if (commandError && traceError) {
-    throw new AggregateError(
-      [commandError, traceError],
-      `Command failed and trace file could not be written: ${path}`,
-    );
-  }
-  if (commandError) throw commandError;
-  if (traceError) {
-    throw new Error(`Cannot write trace file ${path}: ${traceError.message}`, {
-      cause: traceError,
-    });
-  }
-  return result;
-}

package/src/tui-table.js

@@ -1,71 +0,0 @@
-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

@@ -1,205 +0,0 @@
-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/user-config.js

@@ -1,135 +0,0 @@
-import { lstat, readFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { resolve } from "node:path";
-
-import { isCanonicalLanguageTag } from "./language.js";
-import { parseStrictYaml, stringifyCanonicalYaml } from "./yaml.js";
-
-export const USER_CONFIG_PATH = ".config/silvermoon/config.yaml";
-
-const USER_CONFIG_KEYS = new Set(["version", "preferredLanguage"]);
-
-function diagnostic(code, path, message, remediation) {
-  return { code, level: "error", path, message, remediation };
-}
-
-function serializeUserConfig(config) {
-  const canonical = { version: 1 };
-  if (config.preferredLanguage !== undefined) {
-    canonical.preferredLanguage = config.preferredLanguage;
-  }
-  return stringifyCanonicalYaml(canonical);
-}
-
-export async function loadUserConfig({ home = homedir() } = {}) {
-  const configPath = resolve(home, USER_CONFIG_PATH);
-  let metadata;
-  let source;
-  try {
-    metadata = await lstat(configPath);
-    if (!metadata.isFile() || metadata.isSymbolicLink()) {
-      throw Object.assign(new Error("User configuration must be a regular file"), {
-        code: "EINVAL",
-      });
-    }
-    source = await readFile(configPath, "utf8");
-  } catch (caught) {
-    if (caught.code === "ENOENT") {
-      return { config: null, configPath, diagnostics: [] };
-    }
-    return {
-      config: null,
-      configPath,
-      diagnostics: [diagnostic(
-        "user-config.invalid-file",
-        configPath,
-        `Cannot read Silvermoon user configuration: ${caught.message}`,
-        `Replace ${configPath} with a readable regular file or remove it.`,
-      )],
-    };
-  }
-
-  const normalizedSource = source.replaceAll("\r\n", "\n");
-  let value;
-  try {
-    value = parseStrictYaml(normalizedSource);
-  } catch (caught) {
-    return {
-      config: null,
-      configPath,
-      diagnostics: [diagnostic(
-        "user-config.invalid-yaml",
-        configPath,
-        `Cannot parse Silvermoon user configuration: ${caught.message}`,
-        `Use the strict YAML contract in ${configPath}.`,
-      )],
-    };
-  }
-
-  if (value === null || Array.isArray(value) || typeof value !== "object") {
-    return {
-      config: null,
-      configPath,
-      diagnostics: [diagnostic(
-        "user-config.invalid-type",
-        configPath,
-        "The Silvermoon user configuration must be a YAML mapping.",
-        `Replace ${configPath} with the documented mapping.`,
-      )],
-    };
-  }
-
-  const diagnostics = [];
-  for (const key of Object.keys(value).sort()) {
-    if (!USER_CONFIG_KEYS.has(key)) {
-      diagnostics.push(diagnostic(
-        "user-config.unknown-key",
-        `${configPath}#${key}`,
-        `Unknown Silvermoon user configuration key: ${key}`,
-        `Remove ${key}.`,
-      ));
-    }
-  }
-  if (!Object.hasOwn(value, "version")) {
-    diagnostics.push(diagnostic(
-      "user-config.missing-version",
-      `${configPath}#version`,
-      "Missing required key: version",
-      `Add version: 1 to ${configPath}.`,
-    ));
-  } else if (value.version !== 1) {
-    diagnostics.push(diagnostic(
-      "user-config.unsupported-version",
-      `${configPath}#version`,
-      `Unsupported Silvermoon user configuration version: ${String(value.version)}`,
-      "Use version: 1.",
-    ));
-  }
-  if (
-    Object.hasOwn(value, "preferredLanguage") &&
-    !isCanonicalLanguageTag(value.preferredLanguage)
-  ) {
-    diagnostics.push(diagnostic(
-      "user-config.invalid-preferred-language",
-      `${configPath}#preferredLanguage`,
-      "preferredLanguage must be a canonical BCP 47 language tag.",
-      "Use a canonical tag such as en or zh-CN.",
-    ));
-  }
-  if (diagnostics.length === 0 && serializeUserConfig(value) !== normalizedSource) {
-    diagnostics.push(diagnostic(
-      "user-config.noncanonical",
-      configPath,
-      "The Silvermoon user configuration is valid but not canonical.",
-      "Rewrite properties in version, preferredLanguage order with LF endings.",
-    ));
-  }
-
-  return {
-    config: diagnostics.length === 0 ? value : null,
-    configPath,
-    diagnostics,
-  };
-}
-
-export { serializeUserConfig };