silvermoon 0.0.3 → 0.1.1

package/src/dialogue.js

@@ -0,0 +1,327 @@
+import {
+  DEFAULT_LANGUAGE,
+  resolveOutputLanguage,
+} from "./language.js";
+
+const ACTIVE_STATES = new Set(["preparing", "implementing", "deploying"]);
+const IDEA_STATES = [
+  "preparing",
+  "implementing",
+  "deploying",
+  "completed",
+  "abandoned",
+];
+
+function isChinese(language) {
+  return language?.toLowerCase().startsWith("zh");
+}
+
+export function localize(language, english, chinese) {
+  return isChinese(language) ? chinese : english;
+}
+
+export function diagnosticProblem(diagnostic, language = "en-US") {
+  const location = diagnostic.path ? ` (${diagnostic.path})` : "";
+  return {
+    type: diagnostic.code.replaceAll(".", "-"),
+    summary: localize(
+      language,
+      `${diagnostic.message}${location}`.trim(),
+      diagnostic.path
+        ? `在 ${diagnostic.path} 发现 ${diagnostic.code}：${diagnostic.message}`
+        : `发现 ${diagnostic.code}：${diagnostic.message}`,
+    ),
+  };
+}
+
+export function diagnosticInstruction(diagnostic, language = "en-US") {
+  return localize(
+    language,
+    diagnostic.remediation,
+    diagnostic.path
+      ? `修复 ${diagnostic.path} 的 ${diagnostic.code}：${diagnostic.remediation}`
+      : `修复 ${diagnostic.code}：${diagnostic.remediation}`,
+  );
+}
+
+export function outcome(type, status, summary) {
+  return { type, status, summary };
+}
+
+export function summarizeIdeas(ideas) {
+  const counts = Object.fromEntries(IDEA_STATES.map((state) => [state, 0]));
+  const activeIdeas = [];
+  for (const idea of ideas) {
+    counts[idea.state] += 1;
+    if (ACTIVE_STATES.has(idea.state)) {
+      const reference = { id: idea.id, state: idea.state };
+      if (idea.alias !== undefined) reference.alias = idea.alias;
+      activeIdeas.push(reference);
+    }
+  }
+  activeIdeas.sort((left, right) => left.id.localeCompare(right.id));
+  return { counts, activeIdeas };
+}
+
+export function resolvedConfiguration(config, preferredLanguage) {
+  return {
+    primaryRepository: config.primaryRepository,
+    primaryBranch: config.primaryBranch,
+    preferredLanguage,
+  };
+}
+
+export function createEnvelope(intention, observation, outcomes, instructions) {
+  return { intention, observation, outcomes, instructions };
+}
+
+export function dialogueReadyObservation(observation, state, details = {}) {
+  const { root, version, configuration, outputLanguage, problems } = observation;
+  return {
+    state,
+    root,
+    version,
+    configuration,
+    outputLanguage,
+    problems,
+    ...details,
+  };
+}
+
+function renderIntention(intention, language, contentLanguage) {
+  if (intention.command === "whats-next") {
+    return intention.args.idea === null
+      ? localize(
+        language,
+        "Determine the available next work.",
+        "查看当前可推进的工作。",
+      )
+      : localize(
+        language,
+        `Determine what is next for idea ${intention.args.idea}.`,
+        `查看 idea ${intention.args.idea} 接下来应做什么。`,
+      );
+  }
+  if (intention.command === "create-idea") {
+    return intention.args.language === null
+      ? localize(
+        language,
+        `Create one new idea and use ${contentLanguage} for natural-language content.`,
+        `创建一个新 idea，并使用 ${contentLanguage} 撰写自然语言内容。`,
+      )
+      : localize(
+        language,
+        `Create one new idea with language ${intention.args.language}.`,
+        `使用 ${intention.args.language} 创建一个新 idea。`,
+      );
+  }
+  throw new Error(`Cannot render dialogue for ${intention.command}`);
+}
+
+function renderVersion(version) {
+  if (!version) return null;
+  if (version.type === "commit" || version.type === "remote") {
+    return version.commit === null
+      ? version.type
+      : `${version.type} ${version.commit}`;
+  }
+  return version.type;
+}
+
+function codeSpan(value) {
+  const text = String(value);
+  let longest = 0;
+  for (const [run] of text.matchAll(/`+/g)) {
+    longest = Math.max(longest, run.length);
+  }
+  const fence = "`".repeat(longest + 1);
+  return longest === 0 ? `${fence}${text}${fence}` : `${fence} ${text} ${fence}`;
+}
+
+function renderObservation(observation, language) {
+  if (observation.state === "idea-selected") {
+    const idea = observation.selectedIdea;
+    const alias = idea.alias === undefined ? "" : ` (${idea.alias})`;
+    return localize(
+      language,
+      `The project and repository are ready. Selected idea: ${codeSpan(idea.id)}${alias}; state: ${idea.state}.`,
+      `项目与 repository 已就绪。当前 idea：${codeSpan(idea.id)}${alias}；状态：${idea.state}。`,
+    );
+  }
+  if (observation.state === "idea-created") {
+    return localize(
+      language,
+      `The local repository was ready before creation. Created idea: ${codeSpan(observation.createdIdea.id)}; path: ${codeSpan(observation.createdIdea.path)}; state: preparing.`,
+      `创建前项目与本地 repository 已就绪。新建 idea：${codeSpan(observation.createdIdea.id)}；路径：${codeSpan(observation.createdIdea.path)}；状态：preparing。`,
+    );
+  }
+  if (observation.state === "idea-create-failed") {
+    return localize(
+      language,
+      "The repository was ready before creation, but creating the idea failed.",
+      "创建前项目与 repository 已就绪，但创建 idea 失败。",
+    );
+  }
+  const state = {
+    "project-setup-required": localize(
+      language,
+      "The project requires Silvermoon setup.",
+      "项目需要完成 Silvermoon 整备。",
+    ),
+    "repository-sync-required": localize(
+      language,
+      "The project is configured, but the repository requires synchronization.",
+      "项目配置已就绪，但 repository 仍需整备或同步。",
+    ),
+    "repository-preparation-required": localize(
+      language,
+      "The project is ready, but the local repository must be prepared before creating an idea.",
+      "项目已就绪，但创建 idea 前仍需整备本地 repository。",
+    ),
+    "navigation-ready": localize(
+      language,
+      observation.ideas?.activeIdeas.length > 0
+        ? "The project and repository are ready, and work is available."
+        : "The project and repository are ready, with no active idea.",
+      observation.ideas?.activeIdeas.length > 0
+        ? "项目与 repository 已就绪，当前有工作可以推进。"
+        : "项目与 repository 已就绪，当前没有 active idea。",
+    ),
+    "idea-not-found": localize(
+      language,
+      "The project and repository are ready, but the requested idea was not found.",
+      "项目与 repository 已就绪，但未找到指定的 idea。",
+    ),
+  }[observation.state];
+  const lines = [
+    state,
+    `- ${localize(language, "root", "根目录")}: ${codeSpan(observation.root)}`,
+  ];
+  if (observation.observedThrough) {
+    lines.push(
+      `- ${localize(language, "observed through", "观测至")}: ${observation.observedThrough}`,
+    );
+  }
+  const version = renderVersion(observation.version);
+  if (version) {
+    lines.push(`- ${localize(language, "version", "版本")}: ${codeSpan(version)}`);
+  }
+  if (observation.configuration) {
+    lines.push(
+      `- ${localize(language, "primary", "主仓库")}: ${codeSpan(`${observation.configuration.primaryRepository}#${observation.configuration.primaryBranch}`)}`,
+    );
+    lines.push(
+      `- ${localize(language, "content language", "内容语言")}: ${observation.configuration.preferredLanguage}`,
+    );
+  }
+  if (observation.ideas) {
+    const counts = observation.ideas.counts;
+    lines.push(
+      `- ${localize(language, "ideas", "ideas")}: preparing=${counts.preparing}, implementing=${counts.implementing}, `
+      + `deploying=${counts.deploying}, completed=${counts.completed}, abandoned=${counts.abandoned}`,
+    );
+  }
+  const sections = [`${lines[0]}\n\n${lines.slice(1).join("\n")}`];
+  const candidates = observation.state === "idea-not-found"
+    ? observation.candidates
+    : observation.ideas?.activeIdeas;
+  if (candidates?.length > 0) {
+    const active = candidates.map((idea) => {
+      const alias = idea.alias === undefined ? "" : ` (${idea.alias})`;
+      return `- ${codeSpan(idea.id)}${alias} ${idea.state}`;
+    });
+    sections.push(`### ${localize(language, "Ideas you can continue", "可继续推进的想法")}\n\n${active.join("\n")}`);
+  }
+  if (observation.problems.length > 0) {
+    const problems = observation.problems.map((problem) =>
+      `- [${problem.type}] ${problem.summary}`
+    );
+    sections.push(`### ${localize(language, "Issues to address", "需要处理的问题")}\n\n${problems.join("\n")}`);
+  }
+  return sections.join("\n\n");
+}
+
+function renderOutcomes(outcomes, language) {
+  return outcomes
+    .map((item) => {
+      const status = item.status === "success"
+        ? localize(language, "success", "成功")
+        : localize(language, "failure", "失败");
+      return `- ${status} [${item.type}]: ${item.summary}`;
+    })
+    .join("\n");
+}
+
+export function renderDialogue(report) {
+  const contentLanguage =
+    report.observation.configuration?.preferredLanguage
+    ?? DEFAULT_LANGUAGE;
+  const language = report.observation.outputLanguage
+    ?? resolveOutputLanguage({
+      content: contentLanguage,
+      override: report.intention.command === "whats-next"
+        ? report.intention.args.language ?? undefined
+        : undefined,
+    }).tag;
+  const visibleOutcomes = report.outcomes.filter((item) =>
+    !(item.type === "fetch-primary"
+      && item.status === "success"
+      && ["navigation-ready", "idea-selected", "idea-not-found", "idea-created", "idea-create-failed"]
+        .includes(report.observation.state))
+  );
+  const sections = [
+    [
+      localize(language, "Current instruction", "本次指示"),
+      renderIntention(report.intention, language, contentLanguage),
+    ],
+    [
+      localize(language, "Project status", "项目现状"),
+      renderObservation(report.observation, language),
+    ],
+    ...(visibleOutcomes.length > 0
+      ? [[
+        localize(language, "Actions and results", "本次操作及结果"),
+        renderOutcomes(visibleOutcomes, language),
+      ]]
+      : []),
+    [
+      localize(language, "Suggested next steps", "下一步建议"),
+      report.instructions,
+    ],
+  ];
+  return sections.map(([heading, body]) => `## ${heading}\n\n${body}`).join("\n\n");
+}
+
+export function renderCheck(report) {
+  const language = report.observation.outputLanguage
+    ?? resolveOutputLanguage({
+      content: report.observation.configuration?.preferredLanguage,
+      override: report.intention.args.language ?? undefined,
+    }).tag;
+  const { target } = report.intention.args;
+  const version = renderVersion(report.observation.version);
+  const label = target.type === "commit"
+    ? `${target.type} ${target.revision}`
+    : target.type;
+  const valid = report.observation.state === "project-ready";
+  const lines = [
+    `## ${localize(language, "Check", "检查")}`,
+    "",
+    `- ${localize(language, "Target", "目标")}: ${codeSpan(label)}`,
+  ];
+  if (version) lines.push(`- ${localize(language, "Version", "版本")}: ${codeSpan(version)}`);
+  lines.push(
+    `- ${localize(language, "Result", "结果")}: ${valid
+      ? localize(language, "valid", "通过")
+      : localize(language, "invalid or unavailable", "未通过或无法验证")}`,
+  );
+  if (report.observation.problems.length > 0) {
+    lines.push("", `### ${localize(language, "Issues to address", "需要处理的问题")}`, "");
+    for (const problem of report.observation.problems) {
+      lines.push(`- [${problem.type}] ${problem.summary}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+export { ACTIVE_STATES, IDEA_STATES };

package/src/git.js

@@ -4,15 +4,33 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
+import { traceAsync, traceSync } from "./trace.js";
+
 let commandObserver = null;
 
-export function runGit(root, args, { env } = {}) {
+export function runGit(root, args, { env, input } = {}) {
   if (commandObserver) commandObserver([...args]);
-  const result = spawnSync("git", ["-C", root, ...args], {
-    encoding: "utf8",
-    env,
-    windowsHide: true,
-  });
+  const result = traceSync(
+    "git.command",
+    {
+      argumentCount: args.length - 1,
+      network: args[0] === "fetch" || args[0] === "ls-remote",
+      subcommand: args[0] ?? null,
+    },
+    () => spawnSync("git", ["-C", root, ...args], {
+      encoding: "utf8",
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0", ...env },
+      input,
+      windowsHide: true,
+    }),
+    (completed) => ({
+      attributes: {
+        exitCode: completed.status,
+        signal: completed.signal,
+      },
+      status: completed.status === 0 ? "ok" : "error",
+    }),
+  );
   return {
     error: result.error ?? null,
     ok: result.status === 0,
@@ -59,45 +77,31 @@ function requireGit(root, args, label, options) {
   return result.stdout;
 }
 
-export function gitObjectIdLength(root) {
-  const format = requireGit(
+export function inspectTreePaths(root, tree, paths) {
+  if (paths.length === 0) return new Map();
+  const input = `${paths.map((path) => `${tree}:${path}`).join("\n")}\n`;
+  const output = requireGit(
     root,
-    ["rev-parse", "--show-object-format"],
-    "Cannot determine Git object format",
+    ["cat-file", "--batch-check=%(objectname) %(objecttype)"],
+    "Cannot inspect snapshot world trees",
+    { input },
   );
-  if (format === "sha1") return 40;
-  if (format === "sha256") return 64;
-  throw new Error(`Unsupported Git object format: ${format}`);
-}
-
-export function worktreePathTree(root, path) {
-  const directory = mkdtempSync(join(tmpdir(), "silvermoon-index-"));
-  const env = { ...process.env, GIT_INDEX_FILE: join(directory, "index") };
-  try {
-    const populated = runGit(root, ["read-tree", "HEAD"], { env });
-    if (!populated.ok) {
-      requireGit(root, ["read-tree", "--empty"], "Cannot initialize snapshot index", { env });
-    }
-    requireGit(
-      root,
-      ["add", "--all", "--", path],
-      `Cannot snapshot ${path}`,
-      { env },
+  const lines = output.split(/\r?\n/);
+  if (lines.length !== paths.length) {
+    throw new Error(
+      `Cannot inspect snapshot world trees: expected ${paths.length} result(s), received ${lines.length}`,
     );
-    const tree = requireGit(root, ["write-tree"], "Cannot write snapshot tree", { env });
-    const object = requireGit(
-      root,
-      ["rev-parse", `${tree}:${path}`],
-      `Cannot resolve tree for ${path}`,
-    );
-    const type = requireGit(root, ["cat-file", "-t", object], `Cannot inspect ${path}`);
-    if (type !== "tree") throw new Error(`${path} does not resolve to a Git tree`);
-    return object;
-  } finally {
-    rmSync(directory, { recursive: true, force: true });
   }
+  return new Map(paths.map((path, index) => {
+    const [object, type, ...unexpected] = lines[index].split(" ");
+    if (!object || !type || unexpected.length > 0) {
+      throw new Error(`Cannot parse snapshot world tree result for ${path}`);
+    }
+    return [path, { object: type === "missing" ? null : object, type }];
+  }));
 }
-export function worktreeSnapshot(root) {
+
+export function worktreeSnapshot(root, { paths } = {}) {
   const directory = mkdtempSync(join(tmpdir(), "silvermoon-index-"));
   const env = { ...process.env, GIT_INDEX_FILE: join(directory, "index") };
   try {
@@ -105,7 +109,9 @@ export function worktreeSnapshot(root) {
     if (!populated.ok) {
       requireGit(root, ["read-tree", "--empty"], "Cannot initialize snapshot index", { env });
     }
-    requireGit(root, ["add", "--all"], "Cannot snapshot worktree", { env });
+    const add = ["add", "--all"];
+    if (paths !== undefined) add.push("--", ...paths);
+    requireGit(root, add, "Cannot snapshot worktree", { env });
     return {
       tree: requireGit(root, ["write-tree"], "Cannot write worktree snapshot", { env }),
     };
@@ -114,10 +120,6 @@ export function worktreeSnapshot(root) {
   }
 }
 
-function paths(stdout) {
-  return stdout.split(/\r?\n/).filter(Boolean);
-}
-
 const CHANGE_KINDS = {
   A: "added",
   C: "copied",
@@ -195,6 +197,87 @@ export function parseWorktreeChanges(source) {
   return result;
 }
 
+export function inspectWorktreeChanges(root) {
+  const source = requireGit(
+    root,
+    ["status", "--porcelain=v2", "--untracked-files=all", "-z"],
+    "Cannot inspect worktree changes",
+  );
+  return parseWorktreeChanges(`${source}\0`);
+}
+
+export function resolveHead(root) {
+  const result = runGit(root, ["rev-parse", "--verify", "HEAD^{commit}"]);
+  return result.ok ? result.stdout : null;
+}
+
+export function inspectCurrentBranch(root) {
+  const branch = runGit(root, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+  if (!branch.ok) {
+    return { branch: null, remote: null, repository: null, upstreamBranch: null };
+  }
+  const remote = runGit(root, ["config", "--get", `branch.${branch.stdout}.remote`]);
+  const merge = runGit(root, ["config", "--get", `branch.${branch.stdout}.merge`]);
+  if (!remote.ok || !merge.ok || !merge.stdout.startsWith("refs/heads/")) {
+    return {
+      branch: branch.stdout,
+      remote: remote.ok ? remote.stdout : null,
+      repository: null,
+      upstreamBranch: merge.ok && merge.stdout.startsWith("refs/heads/")
+        ? merge.stdout.slice("refs/heads/".length)
+        : null,
+    };
+  }
+  const repository = remote.stdout === "."
+    ? null
+    : runGit(root, ["config", "--get", `remote.${remote.stdout}.url`]);
+  return {
+    branch: branch.stdout,
+    remote: remote.stdout,
+    repository: repository?.ok ? repository.stdout : null,
+    upstreamBranch: merge.stdout.slice("refs/heads/".length),
+  };
+}
+
+export function compareCommits(root, local, remote) {
+  if (local === remote) return "aligned";
+  const localAncestor = runGit(
+    root,
+    ["merge-base", "--is-ancestor", local, remote],
+  );
+  if (localAncestor.ok) {
+    return "behind";
+  }
+  if (localAncestor.status !== 1) {
+    throw new Error(
+      `Cannot compare local and primary commits: `
+      + `${sanitizeGitMessage(localAncestor.stderr || localAncestor.error?.message)}`,
+    );
+  }
+  const remoteAncestor = runGit(
+    root,
+    ["merge-base", "--is-ancestor", remote, local],
+  );
+  if (remoteAncestor.ok) {
+    return "ahead";
+  }
+  if (remoteAncestor.status !== 1) {
+    throw new Error(
+      `Cannot compare local and primary commits: `
+      + `${sanitizeGitMessage(remoteAncestor.stderr || remoteAncestor.error?.message)}`,
+    );
+  }
+  const shallow = runGit(root, ["rev-parse", "--is-shallow-repository"]);
+  if (!shallow.ok) {
+    throw new Error(
+      `Cannot determine repository history depth: `
+      + `${sanitizeGitMessage(shallow.stderr || shallow.error?.message)}`,
+    );
+  }
+  if (shallow.stdout === "true") return "unknown";
+  return "diverged";
+}
+
 export function resolveCommit(root, revision) {
   return requireGit(
     root,
@@ -203,51 +286,41 @@ export function resolveCommit(root, revision) {
   );
 }
 
-export function commitChangedPaths(root, commit) {
-  const parent = runGit(root, ["rev-parse", "--verify", `${commit}^1`]);
-  const changed = parent.ok
-    ? requireGit(root, ["diff", "--name-only", parent.stdout, commit, "--"], `Cannot inspect commit ${commit}`)
-    : requireGit(
-      root,
-      ["diff-tree", "--root", "--no-commit-id", "--name-only", "-r", commit, "--"],
-      `Cannot inspect root commit ${commit}`,
-    );
-  return paths(changed);
-}
-
 export function indexSnapshot(root) {
   return {
-    paths: paths(requireGit(root, ["diff", "--cached", "--name-only", "--"], "Cannot inspect staged changes")),
     tree: requireGit(root, ["write-tree"], "Cannot snapshot the index"),
   };
 }
 
 export function fetchRepositoryBranch(root, repository, branch) {
   const remoteRef = `refs/heads/${branch}`;
-  for (let attempt = 0; attempt < 3; attempt += 1) {
-    const advertised = requireGit(
-      root,
-      ["ls-remote", "--refs", repository, remoteRef],
-      `Cannot inspect ${branch}`,
-    );
-    const [primary, advertisedRef] = advertised.split(/\s+/);
-    if (!primary || advertisedRef !== remoteRef) {
-      throw new Error(`Cannot resolve remote branch ${branch}`);
-    }
-    requireGit(
-      root,
-      [
-        "fetch",
-        "--no-tags",
-        "--no-write-fetch-head",
-        repository,
-        remoteRef,
-      ],
-      `Cannot fetch ${branch}`,
+  const fetched = requireGit(
+    root,
+    [
+      "fetch",
+      "--porcelain",
+      "--no-tags",
+      repository,
+      remoteRef,
+    ],
+    `Cannot fetch ${branch}`,
+  );
+  const updates = fetched
+    .split(/\r?\n/)
+    .map((line) => line.trim().split(/\s+/))
+    .filter((fields) =>
+      fields.length === 4
+      && fields[3] === "FETCH_HEAD"
+      && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(fields[2])
     );
-    if (runGit(root, ["cat-file", "-e", `${primary}^{commit}`]).ok) return primary;
+  if (updates.length !== 1) {
+    throw new Error(`Cannot determine fetched commit for branch ${branch}`);
   }
-  throw new Error(`Remote branch ${branch} moved repeatedly while fetching`);
+  const primary = updates[0][2];
+  if (!runGit(root, ["cat-file", "-e", `${primary}^{commit}`]).ok) {
+    throw new Error(`Fetched branch ${branch} does not resolve to a commit`);
+  }
+  return primary;
 }
 
 export function fetchPrimary(root, config) {
@@ -264,21 +337,23 @@ export async function withTemporaryWorktree(root, commit, callback) {
 }
 
 export async function withTemporaryTree(root, tree, callback) {
-  const temporaryRoot = await mkdtemp(join(tmpdir(), "silvermoon-tree-"));
-  const directory = join(temporaryRoot, "snapshot");
-  const env = { ...process.env, GIT_INDEX_FILE: join(temporaryRoot, "index") };
-  try {
-    await mkdir(directory);
-    requireGit(root, ["read-tree", tree], "Cannot populate isolated index", { env });
-    const prefix = `${directory.replaceAll("\\", "/")}/`;
-    requireGit(
-      root,
-      ["checkout-index", "--all", "--force", `--prefix=${prefix}`],
-      "Cannot populate isolated tree snapshot",
-      { env },
-    );
-    return await callback(directory, tree);
-  } finally {
-    await rm(temporaryRoot, { recursive: true, force: true });
-  }
+  return traceAsync("snapshot.materialize", {}, async () => {
+    const temporaryRoot = await mkdtemp(join(tmpdir(), "silvermoon-tree-"));
+    const directory = join(temporaryRoot, "snapshot");
+    const env = { ...process.env, GIT_INDEX_FILE: join(temporaryRoot, "index") };
+    try {
+      await mkdir(directory);
+      requireGit(root, ["read-tree", tree], "Cannot populate isolated index", { env });
+      const prefix = `${directory.replaceAll("\\", "/")}/`;
+      requireGit(
+        root,
+        ["checkout-index", "--all", "--force", `--prefix=${prefix}`],
+        "Cannot populate isolated tree snapshot",
+        { env },
+      );
+      return await callback(directory, tree);
+    } finally {
+      await rm(temporaryRoot, { recursive: true, force: true });
+    }
+  });
 }