silvermoon 0.0.3 → 0.1.1

package/src/index.js

@@ -1,248 +1,318 @@
 import { resolve } from "node:path";
 
+import {
+  diagnosticProblem,
+} from "./dialogue.js";
 import { loadConfig } from "./config.js";
 import {
   fetchPrimary,
   indexSnapshot,
   resolveCommit,
   runGit,
+  sanitizeGitMessage,
   worktreeSnapshot,
   withTemporaryTree,
   withTemporaryWorktree,
 } from "./git.js";
-import { inspectIdeaLayout } from "./idea-layout.js";
+import {
+  canonicalizeOutputLanguage,
+  DEFAULT_LANGUAGE,
+} from "./language.js";
+import {
+  observeSnapshot,
+  unavailableObservation,
+} from "./observation.js";
 
-function ideaSummary(idea) {
-  const value = {
-    id: idea.id,
-    idealRevision: idea.idealRevision,
-    implementationRevision: idea.implementationRevision,
-    deploymentRevision: idea.deploymentRevision,
-    state: idea.state,
-  };
-  if (idea.alias !== undefined) value.alias = idea.alias;
-  return value;
+function targetArgument({ commit, remote, staged, worktree }) {
+  if (remote) return { type: "remote" };
+  if (commit !== undefined) return { type: "commit", revision: commit };
+  if (staged) return { type: "staged" };
+  if (worktree) return { type: "worktree" };
+  return { type: "head" };
 }
 
-async function inspectSnapshot({
-  baseRevision,
-  gitRoot = root,
-  historyCommit,
+function failureReport({
+  intention,
+  outputLanguage,
+  problem,
   root,
-  snapshotTree,
-  target = "local",
-  validateCandidate = false,
+  version,
 }) {
-  const repositoryRoot = resolve(root);
-  const loaded = await loadConfig({ root: repositoryRoot });
-  const layout = loaded.config
-    ? await inspectIdeaLayout({
-      baseRevision,
-      config: loaded.config,
-      gitRoot,
-      historyCommit,
-      root: repositoryRoot,
-      snapshotTree,
-      validateCandidate,
-    })
-    : { diagnostics: [], ideas: [] };
-  const diagnostics = [
-    ...loaded.diagnostics,
-    ...layout.diagnostics,
-  ];
-
-  const report = {
-    command: "check",
-    ok: diagnostics.every(({ level }) => level !== "error"),
-    root: repositoryRoot,
-    diagnostics,
-    result: {
-      target,
-      checked: layout.ideas.length,
-      ideas: layout.ideas.map(ideaSummary),
-    },
+  return {
+    intention,
+    observation: unavailableObservation({
+      outputLanguage,
+      problem,
+      root,
+      version,
+    }),
   };
-  return { config: loaded.config, layout, report };
 }
 
-function targetFailure(root, code, message, remediation) {
-  return {
-    command: "check",
-    ok: false,
-    root,
-    diagnostics: [{ code, level: "error", message, remediation }],
-    result: null,
-  };
+async function inspectTree({
+  gitRoot,
+  outputLanguage,
+  root,
+  tree,
+  userHome,
+  version,
+}) {
+  return withTemporaryTree(gitRoot, tree, (contentRoot) =>
+    observeSnapshot({
+      contentRoot,
+      gitRoot,
+      outputLanguage,
+      root,
+      projectOnly: true,
+      snapshotTree: tree,
+      userHome,
+      version,
+    })
+  );
 }
 
-function finishTarget({ commit, inspected, root, target }) {
-  const report = inspected.report;
-  report.root = root;
-  report.result = { ...report.result, target };
-  if (commit) report.result.commit = commit;
-  report.ok = report.diagnostics.every(({ level }) => level !== "error");
-  return report;
+function finishCheck(intention, observed) {
+  return { intention, observation: observed.observation };
 }
 
 export async function checkRepository({
   commit,
+  language,
   remote = false,
   root = process.cwd(),
   staged = false,
+  userHome,
   worktree = false,
 } = {}) {
-  const repositoryRoot = resolve(root);
-  const targetCount = [remote, commit !== undefined, staged, worktree].filter(Boolean).length;
+  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;
   if (targetCount > 1) {
-    return targetFailure(
-      repositoryRoot,
-      "check.target.conflict",
-      "Check targets are mutually exclusive.",
-      "Choose exactly one of remote, commit, staged, or worktree.",
+    const error = new Error(
+      "Check targets are mutually exclusive; choose one of remote, commit, staged, or worktree.",
     );
+    error.exitCode = 2;
+    throw error;
   }
+  const target = targetArgument({ commit, remote, staged, worktree });
+  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,
+      version: target.type === "commit" || target.type === "head"
+        ? { type: "commit", commit: null }
+        : target.type === "remote"
+          ? { type: "remote", commit: null }
+          : { type: target.type },
+    });
+    return finishCheck(intention, observed);
+  }
+  const repositoryRoot = resolve(repository.stdout);
 
   if (remote) {
+    let head;
     try {
-      const head = resolveCommit(repositoryRoot, "HEAD");
-      const bootstrap = await withTemporaryWorktree(repositoryRoot, head, (worktreeRoot, tree) =>
-        inspectSnapshot({
-          gitRoot: repositoryRoot,
-          root: worktreeRoot,
-          snapshotTree: tree,
-          target: "remote",
-        }),
+      head = resolveCommit(repositoryRoot, "HEAD");
+    } catch (caught) {
+      return failureReport({
+        intention,
+        outputLanguage: fallbackOutputLanguage,
+        problem: {
+          type: "head-unavailable",
+          summary: sanitizeGitMessage(caught.message),
+        },
+        root: repositoryRoot,
+        version: { type: "remote", commit: null },
+      });
+    }
+    let bootstrap;
+    try {
+      bootstrap = await withTemporaryWorktree(
+        repositoryRoot,
+        head,
+        (contentRoot) => loadConfig({ root: contentRoot }),
       );
-      if (!bootstrap.config) {
-        return finishTarget({ inspected: bootstrap, root: repositoryRoot, target: "remote" });
-      }
-      const primary = fetchPrimary(repositoryRoot, bootstrap.config);
-      const inspected = await withTemporaryWorktree(repositoryRoot, primary, (worktree, tree) =>
-        inspectSnapshot({
+    } catch (caught) {
+      return failureReport({
+        intention,
+        outputLanguage: fallbackOutputLanguage,
+        problem: {
+          type: "snapshot-inspection-failed",
+          summary: sanitizeGitMessage(caught.message),
+        },
+        root: repositoryRoot,
+        version: { type: "remote", commit: null },
+      });
+    }
+    if (!bootstrap.config) {
+      return {
+        intention,
+        observation: {
+          state: "project-setup-required",
+          observedThrough: "version",
+          root: repositoryRoot,
+          version: { type: "remote", commit: null },
+          outputLanguage: fallbackOutputLanguage,
+          problems: bootstrap.diagnostics.map((diagnostic) =>
+            diagnosticProblem(diagnostic, fallbackOutputLanguage)
+          ),
+        },
+      };
+    }
+
+    let primary;
+    try {
+      primary = fetchPrimary(repositoryRoot, bootstrap.config);
+    } catch (caught) {
+      const summary = sanitizeGitMessage(caught.message);
+      return failureReport({
+        intention,
+        outputLanguage: fallbackOutputLanguage,
+        root: repositoryRoot,
+        version: { type: "remote", commit: null },
+        problem: { type: "primary-fetch-failed", summary },
+      });
+    }
+    try {
+      const observed = await withTemporaryWorktree(
+        repositoryRoot,
+        primary,
+        (contentRoot, tree) => observeSnapshot({
+          contentRoot,
           gitRoot: repositoryRoot,
-          historyCommit: primary,
-          root: worktree,
+          outputLanguage: canonicalLanguage,
+          root: repositoryRoot,
+          projectOnly: true,
           snapshotTree: tree,
-          target: "remote",
+          userHome,
+          version: { type: "remote", commit: primary },
         }),
       );
-      return finishTarget({
-        commit: primary,
-        inspected,
+      return finishCheck(intention, observed);
+    } catch (caught) {
+      return failureReport({
+        intention,
+        outputLanguage: fallbackOutputLanguage,
+        problem: {
+          type: "snapshot-inspection-failed",
+          summary: sanitizeGitMessage(caught.message),
+        },
         root: repositoryRoot,
-        target: "remote",
+        version: { type: "remote", commit: primary },
       });
-    } catch (caught) {
-      return targetFailure(
-        repositoryRoot,
-        "git.fetch.failed",
-        caught.message,
-        "Check remote access and retry.",
-      );
     }
   }
 
   if (commit !== undefined || (!staged && !worktree)) {
     const revision = commit ?? "HEAD";
-    const target = commit === undefined ? "head" : "commit";
     let resolvedCommit;
     try {
       resolvedCommit = resolveCommit(repositoryRoot, revision);
     } catch (caught) {
-      return targetFailure(
-        repositoryRoot,
-        "git.commit.invalid",
-        caught.message,
-        commit === undefined
-          ? "Create or restore a valid HEAD commit."
-          : "Choose a commit available in the local repository.",
-      );
+      return failureReport({
+        intention,
+        outputLanguage: fallbackOutputLanguage,
+        problem: {
+          type: "commit-unavailable",
+          summary: sanitizeGitMessage(caught.message),
+        },
+        root: repositoryRoot,
+        version: { type: "commit", commit: null },
+      });
     }
     try {
-      const parent = runGit(repositoryRoot, ["rev-parse", `${resolvedCommit}^1`]);
-      const inspected = await withTemporaryWorktree(repositoryRoot, resolvedCommit, (worktree, tree) =>
-        inspectSnapshot({
-          baseRevision: parent.ok ? parent.stdout : null,
+      const observed = await withTemporaryWorktree(
+        repositoryRoot,
+        resolvedCommit,
+        (contentRoot, tree) => observeSnapshot({
+          contentRoot,
           gitRoot: repositoryRoot,
-          root: worktree,
+          outputLanguage: canonicalLanguage,
+          root: repositoryRoot,
+          projectOnly: true,
           snapshotTree: tree,
-          target,
-          validateCandidate: true,
+          userHome,
+          version: { type: "commit", commit: resolvedCommit },
         }),
       );
-      return finishTarget({
-        commit: resolvedCommit,
-        inspected,
+      return finishCheck(intention, observed);
+    } catch (caught) {
+      return failureReport({
+        intention,
+        outputLanguage: fallbackOutputLanguage,
+        problem: {
+          type: "snapshot-inspection-failed",
+          summary: sanitizeGitMessage(caught.message),
+        },
         root: repositoryRoot,
-        target,
+        version: { type: "commit", commit: resolvedCommit },
       });
-    } catch (caught) {
-      return targetFailure(
-        repositoryRoot,
-        "git.snapshot.failed",
-        caught.message,
-        "Resolve the repository state and retry the commit check.",
-      );
     }
   }
 
   if (staged) {
     try {
       const snapshot = indexSnapshot(repositoryRoot);
-      const inspected = await withTemporaryTree(repositoryRoot, snapshot.tree, (worktree) =>
-        inspectSnapshot({
-          baseRevision: "HEAD",
-          gitRoot: repositoryRoot,
-          root: worktree,
-          snapshotTree: snapshot.tree,
-          target: "staged",
-          validateCandidate: true,
-        }),
-      );
-      return finishTarget({
-        inspected,
+      const observed = await inspectTree({
+        gitRoot: repositoryRoot,
+        outputLanguage: canonicalLanguage,
         root: repositoryRoot,
-        target: "staged",
+        tree: snapshot.tree,
+        userHome,
+        version: { type: "staged" },
       });
+      return finishCheck(intention, observed);
     } catch (caught) {
-      return targetFailure(
-        repositoryRoot,
-        "git.snapshot.failed",
-        caught.message,
-        "Resolve the index state and retry the staged check.",
-      );
-    }
-  }
-
-  if (worktree) {
-    try {
-      const snapshot = worktreeSnapshot(repositoryRoot);
-      const inspected = await withTemporaryTree(repositoryRoot, snapshot.tree, (worktree) =>
-        inspectSnapshot({
-          baseRevision: "HEAD",
-          gitRoot: repositoryRoot,
-          root: worktree,
-          snapshotTree: snapshot.tree,
-          target: "worktree",
-          validateCandidate: true,
-        }),
-      );
-      return finishTarget({
-        inspected,
+      return failureReport({
+        intention,
+        outputLanguage: fallbackOutputLanguage,
+        problem: {
+          type: "snapshot-inspection-failed",
+          summary: sanitizeGitMessage(caught.message),
+        },
         root: repositoryRoot,
-        target: "worktree",
+        version: { type: "staged" },
       });
-    } catch (caught) {
-      return targetFailure(
-        repositoryRoot,
-        "git.snapshot.failed",
-        caught.message,
-        "Resolve the worktree state and retry the worktree check.",
-      );
     }
   }
 
-  throw new Error("Unreachable check target");
+  try {
+    const snapshot = worktreeSnapshot(repositoryRoot);
+    const observed = await inspectTree({
+      gitRoot: repositoryRoot,
+      outputLanguage: canonicalLanguage,
+      root: repositoryRoot,
+      tree: snapshot.tree,
+      userHome,
+      version: { type: "worktree" },
+    });
+    return finishCheck(intention, observed);
+  } catch (caught) {
+    return failureReport({
+      intention,
+      outputLanguage: fallbackOutputLanguage,
+      problem: {
+        type: "snapshot-inspection-failed",
+        summary: sanitizeGitMessage(caught.message),
+      },
+      root: repositoryRoot,
+      version: { type: "worktree" },
+    });
+  }
 }
 
 export {

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