silvermoon 0.2.2 → 0.3.0-rc.2

package/src/list-ideas.js

@@ -1,71 +1,129 @@
-import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
-
 import { createCommandRun } from "./domain.js";
 import {
-  extractIdeaTitle,
   ideaInventoryItem,
   normalizeIdeaQuery,
   queryIdeaInventory,
 } from "./idea-query.js";
-import { localize } from "./language.js";
+import {
+  metadataFailureObservation,
+  readIdeaInventoryItem,
+} from "./idea-metadata.js";
+import { canonicalizeOutputLanguage } from "./language.js";
 import { observeSnapshot } from "./observation.js";
 import { traceAsync } from "./trace.js";
 
-async function readInventoryItem(root, idea) {
-  const documentPath = idea.worlds.idealRevision.documentPath;
-  try {
-    const source = await readFile(
-      resolve(root, ...documentPath.split("/")),
-      "utf8",
-    );
-    return ideaInventoryItem(idea, extractIdeaTitle(source));
-  } catch (caught) {
-    throw new Error(
-      `Cannot read idea metadata for ${idea.id} at ${documentPath}: ${caught.message}`,
-      { cause: caught },
-    );
-  }
+function withoutTitleQuery(query, { limit = query.limit } = {}) {
+  return { ...query, limit, query: null };
 }
 
-function metadataFailureObservation(observed, caught) {
-  const { ideas: _ideas, ...base } = observed.observation;
-  const problem = {
-    type: "idea-metadata-unavailable",
-    summary: localize(
-      observed.outputLanguage,
-      caught.message,
-      `无法读取 idea metadata：${caught.message}`,
-    ),
-  };
-  return {
-    observation: {
-      ...base,
-      state: "project-setup-required",
-      observedThrough: "configuration",
-      problems: [problem],
+function matchesIdentity(item, needle) {
+  return [item.id, item.alias]
+    .filter((value) => value !== undefined)
+    .some((value) => value.toLowerCase().includes(needle));
+}
+
+async function queryObservedInventory({
+  ideas,
+  metadataReader,
+  normalizedQuery,
+  root,
+}) {
+  const ideasById = new Map(ideas.map((idea) => [idea.id, idea]));
+  const baseItems = ideas.map((idea) => ideaInventoryItem(idea));
+  const candidates = queryIdeaInventory(
+    baseItems,
+    withoutTitleQuery(normalizedQuery, { limit: null }),
+  ).ideas;
+
+  return traceAsync(
+    "ideas.inventory-metadata",
+    {
+      candidateCount: candidates.length,
+      ideaCount: ideas.length,
     },
-    responseContext: {
-      nextSteps: localize(
-        observed.outputLanguage,
-        "Repair the reported idea document and retry `silvermoon list-ideas`.",
-        "修复报告的 idea document 后，重新运行 `silvermoon list-ideas`。",
-      ),
+    async () => {
+      const loadedItems = new Map();
+      let queryCandidateCount = 0;
+      let titleReadCount = 0;
+
+      const readItems = async (items) => {
+        const unread = items.filter(({ id }) => !loadedItems.has(id));
+        titleReadCount += unread.length;
+        const loaded = await Promise.all(unread.map(({ id }) => {
+          const idea = ideasById.get(id);
+          if (idea === undefined) {
+            throw new Error(`Missing observed idea metadata for ${id}`);
+          }
+          return metadataReader(root, idea);
+        }));
+        for (const item of loaded) loadedItems.set(item.id, item);
+      };
+
+      let matchingItems = candidates;
+      if (normalizedQuery.query !== null) {
+        const needle = normalizedQuery.query.toLowerCase();
+        const directMatchIds = new Set(
+          candidates
+            .filter((item) => matchesIdentity(item, needle))
+            .map(({ id }) => id),
+        );
+        const titleCandidates = candidates.filter(
+          ({ id }) => !directMatchIds.has(id),
+        );
+        queryCandidateCount = titleCandidates.length;
+        await readItems(titleCandidates);
+        matchingItems = candidates
+          .filter(({ id }) =>
+            directMatchIds.has(id)
+            || loadedItems.get(id)?.title?.toLowerCase().includes(needle)
+          )
+          .map((item) => loadedItems.get(item.id) ?? item);
+      }
+
+      const selected = queryIdeaInventory(
+        matchingItems,
+        withoutTitleQuery(normalizedQuery),
+      );
+      await readItems(selected.ideas);
+      const inventory = {
+        summary: selected.summary,
+        ideas: selected.ideas.map(({ id }) => {
+          const item = loadedItems.get(id);
+          if (item === undefined) {
+            throw new Error(`Missing selected idea metadata for ${id}`);
+          }
+          return item;
+        }),
+      };
+      return { inventory, queryCandidateCount, titleReadCount };
     },
-  };
+    ({ inventory, queryCandidateCount, titleReadCount }) => ({
+      attributes: {
+        matchedCount: inventory.summary.matched,
+        queryCandidateCount,
+        returnedCount: inventory.summary.returned,
+        titleReadCount,
+      },
+    }),
+  );
 }
 
 export async function listIdeas({
   all,
   createdBefore,
   createdSince,
+  language,
   limit,
+  metadataReader = readIdeaInventoryItem,
   query,
   root = process.cwd(),
   sort,
   states,
   userHome,
 } = {}) {
+  const canonicalLanguage = language === undefined
+    ? undefined
+    : canonicalizeOutputLanguage(language);
   const normalizedQuery = normalizeIdeaQuery({
     all,
     createdBefore,
@@ -77,11 +135,15 @@ export async function listIdeas({
   });
   const intention = {
     command: "list-ideas",
-    args: normalizedQuery,
+    args: {
+      ...normalizedQuery,
+      language: canonicalLanguage ?? null,
+    },
   };
   const runtime = createCommandRun(intention);
   const observed = await observeSnapshot({
     root,
+    outputLanguage: canonicalLanguage,
     userHome,
     version: { type: "worktree" },
   });
@@ -93,19 +155,20 @@ export async function listIdeas({
     );
   }
 
-  let items;
+  let queried;
   try {
-    items = await traceAsync(
-      "ideas.inventory-metadata",
-      { ideaCount: observed.layout.ideas.length },
-      () => Promise.all(
-        observed.layout.ideas.map((idea) =>
-          readInventoryItem(observed.observation.root, idea)
-        ),
-      ),
-    );
+    queried = await queryObservedInventory({
+      ideas: observed.layout.ideas,
+      metadataReader,
+      normalizedQuery,
+      root: observed.observation.root,
+    });
   } catch (caught) {
-    const failure = metadataFailureObservation(observed, caught);
+    const failure = metadataFailureObservation(
+      observed,
+      caught,
+      "silvermoon list-ideas",
+    );
     return runtime.complete(
       failure.observation,
       failure.responseContext,
@@ -113,7 +176,7 @@ export async function listIdeas({
     );
   }
 
-  const inventory = queryIdeaInventory(items, normalizedQuery);
+  const { inventory } = queried;
   const {
     configuration,
     outputLanguage,

package/src/observation.js

@@ -132,6 +132,7 @@ export function repositoryProblemObservation(observation, problems) {
 async function observeSnapshotInternal({
   allowMissingIdeas = false,
   contentRoot,
+  filesystem,
   gitRoot,
   ideaLanguage,
   outputLanguage: requestedOutputLanguage,
@@ -147,7 +148,12 @@ async function observeSnapshotInternal({
   const adoption = await traceAsync(
     "adoption.inspect",
     {},
-    () => inspectAdoption({ contentRoot, root }),
+    () => inspectAdoption({
+      contentRoot,
+      filesystem,
+      repositoryRoot: gitRoot,
+      root,
+    }),
   );
   const user = await traceAsync(
     "user-config.load",
@@ -233,6 +239,7 @@ async function observeSnapshotInternal({
       {},
       () => inspectIdeaLayout({
         config: adoption.config,
+        filesystem,
         gitRoot: gitRoot ?? adoption.root,
         root: contentRoot ?? adoption.root,
         snapshotTree,
@@ -257,6 +264,7 @@ async function observeSnapshotInternal({
 
   const guidanceDiagnostics = projectOnly
     ? (await inspectAllGuidance({
+      filesystem,
       gitRoot: gitRoot ?? adoption.root,
       snapshotTree,
     })).diagnostics

package/src/repository.js

@@ -1,5 +1,4 @@
 import { createHash } from "node:crypto";
-import { spawnSync } from "node:child_process";
 
 const CONTROL_CHARACTER = /[\u0000-\u001f\u007f]/;
 const ENCODED_SEPARATOR = /%(?:2f|5c)/i;
@@ -58,6 +57,7 @@ export function validBranchName(value) {
     typeof value !== "string" ||
     value.length === 0 ||
     value === "@" ||
+    value === "HEAD" ||
     value.startsWith("-") ||
     value.startsWith("refs/") ||
     value.startsWith("remotes/") ||
@@ -74,13 +74,7 @@ export function validBranchName(value) {
   const structurallyValid = value
     .split("/")
     .every((component) => component && !component.startsWith(".") && !component.endsWith(".lock"));
-  if (!structurallyValid) return false;
-
-  const checked = spawnSync("git", ["check-ref-format", "--branch", value], {
-    encoding: "utf8",
-    windowsHide: true,
-  });
-  return checked.status === 0;
+  return structurallyValid;
 }
 
 export function effectiveSourceRepository(config, record) {

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