silvermoon 0.2.1 → 0.3.0-rc.1

package/src/index.js

@@ -1,20 +1,20 @@
 import { resolve } from "node:path";
 
+import { REPOSITORY_SKILL_PATH } from "./adoption.js";
 import {
   diagnosticProblem,
 } from "./dialogue.js";
-import { loadConfig } from "./config.js";
+import { loadConfigSnapshot } from "./config.js";
 import { createCommandRun } from "./domain.js";
 import {
   fetchPrimary,
   indexSnapshot,
-  resolveCommit,
+  resolveSnapshot,
   runGit,
   sanitizeGitMessage,
   worktreeSnapshot,
-  withTemporaryTree,
-  withTemporaryWorktree,
 } from "./git.js";
+import { createGitSnapshotFileSystem } from "./git-snapshot.js";
 import {
   canonicalizeOutputLanguage,
   DEFAULT_LANGUAGE,
@@ -23,6 +23,24 @@ import {
   observeSnapshot,
   unavailableObservation,
 } from "./observation.js";
+import {
+  CONFIG_PATH,
+  GUIDANCE_ROOT,
+  IDEAS_ROOT,
+} from "./layout.js";
+
+function preloadCheckBlob({ name }) {
+  return (
+    name === CONFIG_PATH
+    || name === "package.json"
+    || name.startsWith(`${REPOSITORY_SKILL_PATH}/`)
+    || name.startsWith(`${GUIDANCE_ROOT}/`)
+    || (
+      name.startsWith(`${IDEAS_ROOT}/`)
+      && name.endsWith("/status.yaml")
+    )
+  );
+}
 
 function targetArgument({ commit, remote, staged, worktree }) {
   if (remote) return { type: "remote" };
@@ -59,18 +77,23 @@ async function inspectTree({
   userHome,
   version,
 }) {
-  return withTemporaryTree(gitRoot, tree, (contentRoot) =>
-    observeSnapshot({
-      contentRoot,
-      gitRoot,
-      outputLanguage,
-      root,
-      projectOnly: true,
-      snapshotTree: tree,
-      userHome,
-      version,
-    })
-  );
+  const filesystem = createGitSnapshotFileSystem({
+    gitRoot,
+    preload: preloadCheckBlob,
+    root,
+    tree,
+  });
+  return observeSnapshot({
+    contentRoot: root,
+    filesystem,
+    gitRoot,
+    outputLanguage,
+    root,
+    projectOnly: true,
+    snapshotTree: tree,
+    userHome,
+    version,
+  });
 }
 
 function finishCheck(runtime, observed) {
@@ -133,7 +156,7 @@ export async function checkRepository({
   if (remote) {
     let head;
     try {
-      head = resolveCommit(repositoryRoot, "HEAD");
+      head = resolveSnapshot(repositoryRoot, "HEAD");
     } catch (caught) {
       return failureReport({
         runtime,
@@ -148,11 +171,10 @@ export async function checkRepository({
     }
     let bootstrap;
     try {
-      bootstrap = await withTemporaryWorktree(
-        repositoryRoot,
-        head,
-        (contentRoot) => loadConfig({ root: contentRoot }),
-      );
+      bootstrap = await loadConfigSnapshot({
+        gitRoot: repositoryRoot,
+        tree: head.tree,
+      });
     } catch (caught) {
       return failureReport({
         runtime,
@@ -205,20 +227,15 @@ export async function checkRepository({
     }
     const primary = fetched.result.commit;
     try {
-      const observed = await withTemporaryWorktree(
-        repositoryRoot,
-        primary,
-        (contentRoot, tree) => observeSnapshot({
-          contentRoot,
-          gitRoot: repositoryRoot,
-          outputLanguage: canonicalLanguage,
-          root: repositoryRoot,
-          projectOnly: true,
-          snapshotTree: tree,
-          userHome,
-          version: { type: "remote", commit: primary },
-        }),
-      );
+      const snapshot = resolveSnapshot(repositoryRoot, primary);
+      const observed = await inspectTree({
+        gitRoot: repositoryRoot,
+        outputLanguage: canonicalLanguage,
+        root: repositoryRoot,
+        tree: snapshot.tree,
+        userHome,
+        version: { type: "remote", commit: primary },
+      });
       return finishCheck(runtime, observed);
     } catch (caught) {
       return failureReport({
@@ -236,9 +253,9 @@ export async function checkRepository({
 
   if (commit !== undefined || (!staged && !worktree)) {
     const revision = commit ?? "HEAD";
-    let resolvedCommit;
+    let snapshot;
     try {
-      resolvedCommit = resolveCommit(repositoryRoot, revision);
+      snapshot = resolveSnapshot(repositoryRoot, revision);
     } catch (caught) {
       return failureReport({
         runtime,
@@ -252,20 +269,14 @@ export async function checkRepository({
       });
     }
     try {
-      const observed = await withTemporaryWorktree(
-        repositoryRoot,
-        resolvedCommit,
-        (contentRoot, tree) => observeSnapshot({
-          contentRoot,
-          gitRoot: repositoryRoot,
-          outputLanguage: canonicalLanguage,
-          root: repositoryRoot,
-          projectOnly: true,
-          snapshotTree: tree,
-          userHome,
-          version: { type: "commit", commit: resolvedCommit },
-        }),
-      );
+      const observed = await inspectTree({
+        gitRoot: repositoryRoot,
+        outputLanguage: canonicalLanguage,
+        root: repositoryRoot,
+        tree: snapshot.tree,
+        userHome,
+        version: { type: "commit", commit: snapshot.commit },
+      });
       return finishCheck(runtime, observed);
     } catch (caught) {
       return failureReport({
@@ -276,7 +287,7 @@ export async function checkRepository({
           summary: sanitizeGitMessage(caught.message),
         },
         root: repositoryRoot,
-        version: { type: "commit", commit: resolvedCommit },
+        version: { type: "commit", commit: snapshot.commit },
       });
     }
   }

package/src/language.js

@@ -40,6 +40,10 @@ export function canonicalizeOutputLanguage(value) {
     caught.exitCode = 2;
     throw caught;
   }
+  canonical = {
+    en: "en-US",
+    zh: "zh-CN",
+  }[canonical.toLowerCase()] ?? canonical;
   if (!OUTPUT_LANGUAGE_SET.has(canonical)) {
     const error = new Error(
       `unsupported output language: ${canonical}; expected ${OUTPUT_LANGUAGES.join(" or ")}`,

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) {