silvermoon 0.1.0 → 0.1.1

package/src/index.js

@@ -14,6 +14,10 @@ import {
   withTemporaryTree,
   withTemporaryWorktree,
 } from "./git.js";
+import {
+  canonicalizeOutputLanguage,
+  DEFAULT_LANGUAGE,
+} from "./language.js";
 import {
   observeSnapshot,
   unavailableObservation,
@@ -29,18 +33,25 @@ function targetArgument({ commit, remote, staged, worktree }) {
 
 function failureReport({
   intention,
+  outputLanguage,
   problem,
   root,
   version,
 }) {
   return {
     intention,
-    observation: unavailableObservation({ problem, root, version }),
+    observation: unavailableObservation({
+      outputLanguage,
+      problem,
+      root,
+      version,
+    }),
   };
 }
 
 async function inspectTree({
   gitRoot,
+  outputLanguage,
   root,
   tree,
   userHome,
@@ -50,6 +61,7 @@ async function inspectTree({
     observeSnapshot({
       contentRoot,
       gitRoot,
+      outputLanguage,
       root,
       projectOnly: true,
       snapshotTree: tree,
@@ -65,12 +77,17 @@ function finishCheck(intention, observed) {
 
 export async function checkRepository({
   commit,
+  language,
   remote = false,
   root = process.cwd(),
   staged = false,
   userHome,
   worktree = false,
 } = {}) {
+  const canonicalLanguage = language === undefined
+    ? undefined
+    : canonicalizeOutputLanguage(language);
+  const fallbackOutputLanguage = canonicalLanguage ?? DEFAULT_LANGUAGE;
   const requestedRoot = resolve(root);
   const targetCount = [remote, commit !== undefined, staged, worktree]
     .filter(Boolean).length;
@@ -82,10 +99,17 @@ export async function checkRepository({
     throw error;
   }
   const target = targetArgument({ commit, remote, staged, worktree });
-  const intention = { command: "check", args: { target } };
+  const intention = {
+    command: "check",
+    args: {
+      target,
+      language: canonicalLanguage ?? null,
+    },
+  };
   const repository = runGit(requestedRoot, ["rev-parse", "--show-toplevel"]);
   if (!repository.ok) {
     const observed = await observeSnapshot({
+      outputLanguage: canonicalLanguage,
       projectOnly: true,
       root: requestedRoot,
       userHome,
@@ -106,6 +130,7 @@ export async function checkRepository({
     } catch (caught) {
       return failureReport({
         intention,
+        outputLanguage: fallbackOutputLanguage,
         problem: {
           type: "head-unavailable",
           summary: sanitizeGitMessage(caught.message),
@@ -124,6 +149,7 @@ export async function checkRepository({
     } catch (caught) {
       return failureReport({
         intention,
+        outputLanguage: fallbackOutputLanguage,
         problem: {
           type: "snapshot-inspection-failed",
           summary: sanitizeGitMessage(caught.message),
@@ -140,8 +166,9 @@ export async function checkRepository({
           observedThrough: "version",
           root: repositoryRoot,
           version: { type: "remote", commit: null },
+          outputLanguage: fallbackOutputLanguage,
           problems: bootstrap.diagnostics.map((diagnostic) =>
-            diagnosticProblem(diagnostic)
+            diagnosticProblem(diagnostic, fallbackOutputLanguage)
           ),
         },
       };
@@ -154,6 +181,7 @@ export async function checkRepository({
       const summary = sanitizeGitMessage(caught.message);
       return failureReport({
         intention,
+        outputLanguage: fallbackOutputLanguage,
         root: repositoryRoot,
         version: { type: "remote", commit: null },
         problem: { type: "primary-fetch-failed", summary },
@@ -166,6 +194,7 @@ export async function checkRepository({
         (contentRoot, tree) => observeSnapshot({
           contentRoot,
           gitRoot: repositoryRoot,
+          outputLanguage: canonicalLanguage,
           root: repositoryRoot,
           projectOnly: true,
           snapshotTree: tree,
@@ -177,6 +206,7 @@ export async function checkRepository({
     } catch (caught) {
       return failureReport({
         intention,
+        outputLanguage: fallbackOutputLanguage,
         problem: {
           type: "snapshot-inspection-failed",
           summary: sanitizeGitMessage(caught.message),
@@ -195,6 +225,7 @@ export async function checkRepository({
     } catch (caught) {
       return failureReport({
         intention,
+        outputLanguage: fallbackOutputLanguage,
         problem: {
           type: "commit-unavailable",
           summary: sanitizeGitMessage(caught.message),
@@ -210,6 +241,7 @@ export async function checkRepository({
         (contentRoot, tree) => observeSnapshot({
           contentRoot,
           gitRoot: repositoryRoot,
+          outputLanguage: canonicalLanguage,
           root: repositoryRoot,
           projectOnly: true,
           snapshotTree: tree,
@@ -221,6 +253,7 @@ export async function checkRepository({
     } catch (caught) {
       return failureReport({
         intention,
+        outputLanguage: fallbackOutputLanguage,
         problem: {
           type: "snapshot-inspection-failed",
           summary: sanitizeGitMessage(caught.message),
@@ -236,6 +269,7 @@ export async function checkRepository({
       const snapshot = indexSnapshot(repositoryRoot);
       const observed = await inspectTree({
         gitRoot: repositoryRoot,
+        outputLanguage: canonicalLanguage,
         root: repositoryRoot,
         tree: snapshot.tree,
         userHome,
@@ -245,6 +279,7 @@ export async function checkRepository({
     } catch (caught) {
       return failureReport({
         intention,
+        outputLanguage: fallbackOutputLanguage,
         problem: {
           type: "snapshot-inspection-failed",
           summary: sanitizeGitMessage(caught.message),
@@ -259,6 +294,7 @@ export async function checkRepository({
     const snapshot = worktreeSnapshot(repositoryRoot);
     const observed = await inspectTree({
       gitRoot: repositoryRoot,
+      outputLanguage: canonicalLanguage,
       root: repositoryRoot,
       tree: snapshot.tree,
       userHome,
@@ -268,6 +304,7 @@ export async function checkRepository({
   } catch (caught) {
     return failureReport({
       intention,
+      outputLanguage: fallbackOutputLanguage,
       problem: {
         type: "snapshot-inspection-failed",
         summary: sanitizeGitMessage(caught.message),

package/src/language.js

@@ -1,4 +1,7 @@
 export const DEFAULT_LANGUAGE = "en-US";
+export const OUTPUT_LANGUAGES = Object.freeze(["en-US", "zh-CN"]);
+
+const OUTPUT_LANGUAGE_SET = new Set(OUTPUT_LANGUAGES);
 
 export function canonicalizeLanguageTag(value) {
   if (typeof value !== "string" || value.length === 0 || value.trim() !== value) {
@@ -21,9 +24,43 @@ export function isCanonicalLanguageTag(value) {
   }
 }
 
+export function canonicalizeOutputLanguage(value) {
+  let canonical;
+  try {
+    canonical = canonicalizeLanguageTag(value);
+  } catch (caught) {
+    caught.exitCode = 2;
+    throw caught;
+  }
+  if (!OUTPUT_LANGUAGE_SET.has(canonical)) {
+    const error = new Error(
+      `unsupported output language: ${canonical}; expected ${OUTPUT_LANGUAGES.join(" or ")}`,
+    );
+    error.exitCode = 2;
+    throw error;
+  }
+  return canonical;
+}
+
 export function resolveLanguage({ idea, project, global } = {}) {
   if (idea !== undefined) return { tag: idea, source: "idea" };
   if (project !== undefined) return { tag: project, source: "project" };
   if (global !== undefined) return { tag: global, source: "global" };
   return { tag: DEFAULT_LANGUAGE, source: "default" };
 }
+
+export function resolveOutputLanguage({ content, override } = {}) {
+  if (override !== undefined) {
+    return {
+      tag: canonicalizeOutputLanguage(override),
+      source: "override",
+    };
+  }
+  if (content?.toLowerCase().startsWith("zh")) {
+    return { tag: "zh-CN", source: "content" };
+  }
+  return {
+    tag: DEFAULT_LANGUAGE,
+    source: content === undefined ? "default" : "content",
+  };
+}

package/src/observation.js

@@ -7,13 +7,14 @@ import {
   summarizeIdeas,
 } from "./dialogue.js";
 import { inspectIdeaLayout } from "./idea-layout.js";
-import { resolveLanguage } from "./language.js";
+import { resolveLanguage, resolveOutputLanguage } from "./language.js";
 import { traceAsync } from "./trace.js";
 import { loadUserConfig } from "./user-config.js";
 
 function projectObservation({
   configuration,
   ideas,
+  outputLanguage,
   problems,
   root,
   version,
@@ -23,6 +24,7 @@ function projectObservation({
       state: "project-setup-required",
       observedThrough: "root",
       root,
+      outputLanguage,
       problems,
     };
   }
@@ -32,6 +34,7 @@ function projectObservation({
       observedThrough: "version",
       root,
       version,
+      outputLanguage,
       problems,
     };
   }
@@ -42,6 +45,7 @@ function projectObservation({
       root,
       version,
       configuration,
+      outputLanguage,
       problems,
     };
   }
@@ -52,6 +56,7 @@ function projectObservation({
     version,
     configuration,
     ideas,
+    outputLanguage,
     problems,
   };
 }
@@ -85,6 +90,7 @@ function localizeFinding(finding, language) {
 export function incompleteObservation({
   configuration,
   ideas,
+  outputLanguage,
   problem,
   root,
   version,
@@ -92,17 +98,24 @@ export function incompleteObservation({
   return projectObservation({
     configuration,
     ideas,
+    outputLanguage,
     problems: [problem],
     root,
     version,
   });
 }
 
-export function unavailableObservation({ root, version, problem }) {
+export function unavailableObservation({
+  outputLanguage,
+  root,
+  version,
+  problem,
+}) {
   return {
     state: "check-unavailable",
     root,
     version,
+    outputLanguage,
     problems: [problem],
   };
 }
@@ -120,12 +133,16 @@ async function observeSnapshotInternal({
   contentRoot,
   gitRoot,
   ideaLanguage,
+  outputLanguage: requestedOutputLanguage,
   projectOnly = false,
   root,
   snapshotTree,
   userHome,
   version,
 }) {
+  const outputLanguageOverride = requestedOutputLanguage === undefined
+    ? undefined
+    : resolveOutputLanguage({ override: requestedOutputLanguage }).tag;
   const adoption = await traceAsync(
     "adoption.inspect",
     {},
@@ -144,55 +161,69 @@ async function observeSnapshotInternal({
   }));
   const baseFindings = [...adoption.findings, ...userFindings]
     .sort((left, right) => left.priority - right.priority);
-  const fallbackLanguage = resolveLanguage({
+  const fallbackContentLanguage = resolveLanguage({
     global: user.config?.preferredLanguage,
   }).tag;
+  const fallbackOutputLanguage = resolveOutputLanguage({
+    content: fallbackContentLanguage,
+    override: outputLanguageOverride,
+  }).tag;
 
   if (!adoption.gitReady) {
     const findings = baseFindings.map((finding) =>
-      localizeFinding(finding, fallbackLanguage)
+      localizeFinding(finding, fallbackOutputLanguage)
     );
     const observation = projectObservation({
+      outputLanguage: fallbackOutputLanguage,
       problems: findings.map(({ problem }) => problem),
       root: adoption.root,
     });
     return {
       config: null,
+      contentLanguage: fallbackContentLanguage,
       findings,
-      language: fallbackLanguage,
       layout: null,
       observation,
+      outputLanguage: fallbackOutputLanguage,
+      outputLanguageOverride,
       projectReady: false,
     };
   }
 
   if (!adoption.config) {
     const findings = baseFindings.map((finding) =>
-      localizeFinding(finding, fallbackLanguage)
+      localizeFinding(finding, fallbackOutputLanguage)
     );
     const observation = projectObservation({
+      outputLanguage: fallbackOutputLanguage,
       problems: findings.map(({ problem }) => problem),
       root: adoption.root,
       version,
     });
     return {
       config: null,
+      contentLanguage: fallbackContentLanguage,
       findings,
-      language: fallbackLanguage,
       layout: null,
       observation,
+      outputLanguage: fallbackOutputLanguage,
+      outputLanguageOverride,
       projectReady: false,
     };
   }
 
-  const language = resolveLanguage({
+  const contentLanguage = resolveLanguage({
     idea: ideaLanguage,
     project: adoption.config.preferredLanguage,
     global: user.config?.preferredLanguage,
   }).tag;
-  const configuration = resolvedConfiguration(adoption.config, language);
+  const outputLanguage = resolveOutputLanguage({
+    content: contentLanguage,
+    override: outputLanguageOverride,
+  }).tag;
+  const configuration = resolvedConfiguration(adoption.config, contentLanguage);
   const findings = baseFindings.map((finding) =>
-    localizeFinding(finding, language)
+    localizeFinding(finding, outputLanguage)
   );
   let layout;
   try {
@@ -225,8 +256,8 @@ async function observeSnapshotInternal({
 
   const layoutFindings = layout.diagnostics.map((diagnostic) => ({
     priority: 50,
-    problem: diagnosticProblem(diagnostic, language),
-    instruction: diagnosticInstruction(diagnostic, language),
+    problem: diagnosticProblem(diagnostic, outputLanguage),
+    instruction: diagnosticInstruction(diagnostic, outputLanguage),
   }));
   findings.push(...layoutFindings);
   findings.sort((left, right) => left.priority - right.priority);
@@ -234,16 +265,19 @@ async function observeSnapshotInternal({
   if (layout.diagnostics.length > 0) {
     const observation = projectObservation({
       configuration,
+      outputLanguage,
       problems: findings.map(({ problem }) => problem),
       root: adoption.root,
       version,
     });
     return {
       config: adoption.config,
+      contentLanguage,
       findings,
-      language,
       layout,
       observation,
+      outputLanguage,
+      outputLanguageOverride,
       projectReady: false,
     };
   }
@@ -253,24 +287,27 @@ async function observeSnapshotInternal({
     const observation = projectObservation({
       configuration,
       ideas,
+      outputLanguage,
       problems: findings.map(({ problem }) => problem),
       root: adoption.root,
       version,
     });
     return {
       config: adoption.config,
+      contentLanguage,
       findings,
-      language,
       layout,
       observation,
+      outputLanguage,
+      outputLanguageOverride,
       projectReady: false,
     };
   }
 
   return {
     config: adoption.config,
+    contentLanguage,
     findings,
-    language,
     layout,
     observation: {
       state: projectOnly
@@ -280,8 +317,11 @@ async function observeSnapshotInternal({
       version,
       configuration,
       ideas,
+      outputLanguage,
       problems: [],
     },
+    outputLanguage,
+    outputLanguageOverride,
     projectReady: true,
   };
 }
@@ -296,10 +336,15 @@ export async function observeSnapshot(options) {
 
 export function withObservationLanguage(observed, ideaLanguage) {
   if (!observed.config || !ideaLanguage) return observed;
-  const language = resolveLanguage({ idea: ideaLanguage }).tag;
+  const contentLanguage = resolveLanguage({ idea: ideaLanguage }).tag;
+  const outputLanguage = resolveOutputLanguage({
+    content: contentLanguage,
+    override: observed.outputLanguageOverride,
+  }).tag;
   const observation = {
     ...observed.observation,
-    configuration: resolvedConfiguration(observed.config, language),
+    configuration: resolvedConfiguration(observed.config, contentLanguage),
+    outputLanguage,
   };
-  return { ...observed, language, observation };
+  return { ...observed, contentLanguage, observation, outputLanguage };
 }

package/src/whatsnext.js

@@ -14,6 +14,7 @@ import {
   resolveHead,
   sanitizeGitMessage,
 } from "./git.js";
+import { canonicalizeOutputLanguage } from "./language.js";
 import {
   observeSnapshot,
   repositoryProblemObservation,
@@ -217,7 +218,7 @@ async function assessRepositoryReadinessInternal({
   root,
   synchronizePrimary = true,
 }) {
-  const language = observed.language;
+  const language = observed.outputLanguage;
   let changes;
   try {
     changes = inspectWorktreeChanges(root);
@@ -515,19 +516,30 @@ export async function assessIdeaCreationReadiness(options) {
 
 export async function whatsNext({
   idea: selector,
+  language,
   root = process.cwd(),
   userHome,
 } = {}) {
+  const canonicalLanguage = language === undefined
+    ? undefined
+    : canonicalizeOutputLanguage(language);
   const requestedRoot = resolve(root);
   const intention = {
     command: "whats-next",
-    args: { idea: selector ?? null },
+    args: {
+      idea: selector ?? null,
+      language: canonicalLanguage ?? null,
+    },
   };
-  const recheckCommand = selector === undefined
+  const baseRecheckCommand = selector === undefined
     ? "silvermoon whats-next"
     : `silvermoon whats-next ${JSON.stringify(selector)}`;
+  const recheckCommand = canonicalLanguage === undefined
+    ? baseRecheckCommand
+    : `${baseRecheckCommand} --language ${canonicalLanguage}`;
   const outcomes = [];
   let observed = await observeSnapshot({
+    outputLanguage: canonicalLanguage,
     root: requestedRoot,
     userHome,
     version: { type: "worktree" },
@@ -540,7 +552,7 @@ export async function whatsNext({
       projectInstructions(
         observed,
         observed.observation.root,
-        observed.language,
+        observed.outputLanguage,
         recheckCommand,
       ),
     );
@@ -570,7 +582,7 @@ export async function whatsNext({
       intention,
       { ...readiness.observation, state: "navigation-ready" },
       outcomes,
-      navigationInstruction(observed.layout.ideas, observed.language),
+      navigationInstruction(observed.layout.ideas, observed.outputLanguage),
     );
   }
   if (!selected) {
@@ -582,11 +594,11 @@ export async function whatsNext({
       outcomes,
       joinInstructions([
         localize(
-          observed.language,
+          observed.outputLanguage,
           `Idea ${selector} does not match an observed ULID or unique alias.`,
           `Idea ${selector} 未匹配任何已观察到的 ULID 或唯一 alias。`,
         ),
-        navigationInstruction(observed.layout.ideas, observed.language),
+        navigationInstruction(observed.layout.ideas, observed.outputLanguage),
       ]),
     );
   }
@@ -600,6 +612,6 @@ export async function whatsNext({
       },
     }),
     outcomes,
-    lifecycleInstruction(selected, observed.language),
+    lifecycleInstruction(selected, observed.outputLanguage),
   );
 }