silvermoon 0.2.1 → 0.3.0-rc.1

package/src/create-idea.js

@@ -10,10 +10,7 @@ import {
 import { createCommandRun } from "./domain.js";
 import { inspectPhaseGuidance } from "./guidance.js";
 import {
-  DEPLOYMENT_TEMPLATE,
-  IDEA_TEMPLATE,
-  IMPLEMENTATION_TEMPLATE,
-  LEDGER_TEMPLATE,
+  ideaTemplates,
 } from "./idea-templates.js";
 import { isValidUlid, serializeIdeaStatus } from "./ideas.js";
 import { canonicalizeLanguageTag } from "./language.js";
@@ -209,6 +206,7 @@ async function cleanupScaffold(cleanupPlan, operations) {
 
 async function createScaffold({
   canonicalLanguage,
+  contentLanguage,
   generateId,
   operations,
   repositoryRoot,
@@ -263,11 +261,12 @@ async function createScaffold({
       paths.innerPath,
       paths.idealPath,
     ];
+    const templates = ideaTemplates(contentLanguage);
     const files = [
-      [paths.ideaDocumentPath, IDEA_TEMPLATE],
-      [paths.implementationDocumentPath, IMPLEMENTATION_TEMPLATE],
-      [paths.deploymentDocumentPath, DEPLOYMENT_TEMPLATE],
-      [paths.ledgerPath, LEDGER_TEMPLATE],
+      [paths.ideaDocumentPath, templates.idea],
+      [paths.implementationDocumentPath, templates.implementation],
+      [paths.deploymentDocumentPath, templates.deployment],
+      [paths.ledgerPath, templates.ledger],
       [paths.statusPath, serializeIdeaStatus({
         version: 1,
         id,
@@ -420,6 +419,7 @@ export async function createIdea({
     },
     () => createScaffold({
       canonicalLanguage,
+      contentLanguage: observed.contentLanguage,
       generateId,
       operations,
       repositoryRoot,
@@ -467,6 +467,18 @@ export async function createIdea({
   }
 
   const { createdIdea, paths } = completion.result;
+  const templates = ideaTemplates(observed.contentLanguage);
+  const languageInstruction = templates.localized
+    ? localize(
+      observed.outputLanguage,
+      `Use ${observed.contentLanguage} for all natural-language content in the canonical idea documents and ledger.`,
+      `在 canonical idea 文档和 ledger 的所有自然语言内容中使用 ${observed.contentLanguage}。`,
+    )
+    : localize(
+      observed.outputLanguage,
+      `Silvermoon has no built-in ${observed.contentLanguage} scaffold, so the new files contain explicit ${templates.templateLanguage} fallback placeholders. Replace all natural-language placeholders with ${observed.contentLanguage} before continuing.`,
+      `Silvermoon 没有内置的 ${observed.contentLanguage} 脚手架，因此新文件包含明确的 ${templates.templateLanguage} fallback 占位。继续前，将所有自然语言占位替换为 ${observed.contentLanguage}。`,
+    );
   return runtime.complete(
     dialogueReadyObservation(readiness.observation, "idea-created", {
       createdIdea,
@@ -477,8 +489,8 @@ export async function createIdea({
     {
       nextSteps: localize(
         observed.outputLanguage,
-        `Use ${observed.contentLanguage} for natural-language content while describing the requested Ideal World in ${paths.ideaDocumentPath}; keep the stable IDs and placeholders in ${paths.implementationDocumentPath}, ${paths.deploymentDocumentPath}, and ${paths.ledgerPath} synchronized.`,
-        `使用 ${observed.contentLanguage} 在 ${paths.ideaDocumentPath} 中描述请求的理想契约，并保持 ${paths.implementationDocumentPath}、${paths.deploymentDocumentPath} 与 ${paths.ledgerPath} 中的稳定 ID 和占位同步。`,
+        `${languageInstruction} Describe the requested Ideal World in ${paths.ideaDocumentPath}; keep canonical headings, stable IDs, and placeholders in ${paths.implementationDocumentPath}, ${paths.deploymentDocumentPath}, and ${paths.ledgerPath} synchronized.`,
+        `${languageInstruction} 在 ${paths.ideaDocumentPath} 中描述请求的理想契约；保持 ${paths.implementationDocumentPath}、${paths.deploymentDocumentPath} 与 ${paths.ledgerPath} 中的 canonical 标题、稳定 ID 和占位同步。`,
       ),
     },
   );

package/src/git-snapshot.js

@@ -0,0 +1,212 @@
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { posix } from "node:path";
+
+import {
+  inspectTreeLineage,
+  readGitBlob,
+  readGitBlobs,
+} from "./git.js";
+import { traceSync } from "./trace.js";
+
+const REGULAR_FILE_MODES = new Set(["100644", "100755"]);
+
+function fileSystemError(code, path, message) {
+  return Object.assign(new Error(`${message}: ${path}`), { code, path });
+}
+
+class SnapshotMetadata {
+  constructor(entry, name) {
+    this.entry = entry;
+    this.name = name;
+  }
+
+  isDirectory() {
+    return this.entry.type === "tree" && this.entry.mode === "040000";
+  }
+
+  isFile() {
+    return this.entry.type === "blob"
+      && REGULAR_FILE_MODES.has(this.entry.mode);
+  }
+
+  isSymbolicLink() {
+    return this.entry.type === "blob" && this.entry.mode === "120000";
+  }
+}
+
+function normalizedRelativePath(root, path) {
+  const normalizedRoot = resolve(root);
+  const absolutePath = resolve(path);
+  const value = relative(normalizedRoot, absolutePath);
+  if (
+    value === ""
+    || (!isAbsolute(value) && value !== ".." && !value.startsWith(`..${sep}`))
+  ) {
+    return value.split(sep).join("/");
+  }
+  throw fileSystemError("ENOENT", path, "Snapshot path is outside the root");
+}
+
+function childName(path) {
+  const separator = path.lastIndexOf("/");
+  return separator < 0 ? path : path.slice(separator + 1);
+}
+
+export function createGitSnapshotFileSystem({
+  gitRoot,
+  preload = () => false,
+  root = gitRoot,
+  tree,
+}) {
+  return traceSync(
+    "snapshot.open",
+    {},
+    () => {
+      const entries = inspectTreeLineage(gitRoot, tree, ".");
+      const entriesByPath = new Map(entries.map((entry) => [entry.name, entry]));
+      const childrenByPath = new Map();
+      for (const entry of entries) {
+        const parent = posix.dirname(entry.name);
+        const key = parent === "." ? "" : parent;
+        const children = childrenByPath.get(key) ?? [];
+        children.push(entry);
+        childrenByPath.set(key, children);
+      }
+      const preloadObjects = entries
+        .filter((entry) =>
+          entry.mode === "120000"
+          || (entry.type === "blob" && preload(entry))
+        )
+        .map(({ object }) => object);
+      const blobs = readGitBlobs(gitRoot, preloadObjects);
+
+      async function blob(entry) {
+        const cached = blobs.get(entry.object);
+        if (cached !== undefined) return cached;
+        const loaded = readGitBlob(gitRoot, entry.object);
+        blobs.set(entry.object, loaded);
+        return loaded;
+      }
+
+      async function resolveEntry(path, { followFinal = true } = {}) {
+        const requested = normalizedRelativePath(root, path);
+        if (requested === "") {
+          return {
+            entry: {
+              mode: "040000",
+              name: "",
+              object: tree,
+              size: null,
+              type: "tree",
+            },
+            path: "",
+          };
+        }
+
+        let parts = requested.split("/");
+        let resolvedParts = [];
+        const followed = new Set();
+        for (let index = 0; index < parts.length; index += 1) {
+          const candidate = [...resolvedParts, parts[index]].join("/");
+          const entry = entriesByPath.get(candidate);
+          if (entry === undefined) {
+            throw fileSystemError("ENOENT", path, "Snapshot path does not exist");
+          }
+          const shouldFollow = entry.mode === "120000"
+            && (followFinal || index < parts.length - 1);
+          if (!shouldFollow) {
+            resolvedParts.push(parts[index]);
+            continue;
+          }
+          if (followed.has(candidate) || followed.size >= 40) {
+            throw fileSystemError("ELOOP", path, "Snapshot symlink cycle");
+          }
+          followed.add(candidate);
+          const target = (await blob(entry)).toString("utf8");
+          if (
+            target.includes("\0")
+            || target.startsWith("/")
+            || /^[A-Za-z]:[\\/]/.test(target)
+          ) {
+            throw fileSystemError(
+              "ENOENT",
+              path,
+              "Snapshot symlink target is outside the root",
+            );
+          }
+          const normalizedTarget = posix.normalize(
+            posix.join(posix.dirname(candidate), target.replaceAll("\\", "/")),
+          );
+          if (
+            normalizedTarget === ".."
+            || normalizedTarget.startsWith("../")
+          ) {
+            throw fileSystemError(
+              "ENOENT",
+              path,
+              "Snapshot symlink target is outside the root",
+            );
+          }
+          parts = [
+            ...normalizedTarget.split("/").filter(Boolean),
+            ...parts.slice(index + 1),
+          ];
+          resolvedParts = [];
+          index = -1;
+        }
+        const resolvedPath = resolvedParts.join("/");
+        return { entry: entriesByPath.get(resolvedPath), path: resolvedPath };
+      }
+
+      const filesystem = {
+        async lstat(path) {
+          const resolved = await resolveEntry(path, { followFinal: false });
+          return new SnapshotMetadata(resolved.entry, childName(resolved.path));
+        },
+        async readFile(path, encoding) {
+          const resolved = await resolveEntry(path);
+          const metadata = new SnapshotMetadata(
+            resolved.entry,
+            childName(resolved.path),
+          );
+          if (!metadata.isFile()) {
+            throw fileSystemError("EISDIR", path, "Snapshot path is not a file");
+          }
+          const content = await blob(resolved.entry);
+          return encoding === undefined ? Buffer.from(content) : content.toString(encoding);
+        },
+        async readdir(path, options = {}) {
+          const resolved = await resolveEntry(path);
+          const metadata = new SnapshotMetadata(
+            resolved.entry,
+            childName(resolved.path),
+          );
+          if (!metadata.isDirectory()) {
+            throw fileSystemError("ENOTDIR", path, "Snapshot path is not a directory");
+          }
+          const children = childrenByPath.get(resolved.path) ?? [];
+          if (options.withFileTypes === true) {
+            return children.map((entry) =>
+              new SnapshotMetadata(entry, childName(entry.name))
+            );
+          }
+          return children.map(({ name }) => childName(name));
+        },
+        snapshotEntry(path) {
+          return entriesByPath.get(path) ?? null;
+        },
+        snapshotEntries(path) {
+          return [...(childrenByPath.get(path) ?? [])];
+        },
+        async snapshotFile(path) {
+          const entry = entriesByPath.get(path);
+          if (entry === undefined || entry.type !== "blob") {
+            throw fileSystemError("ENOENT", path, "Snapshot blob does not exist");
+          }
+          return Buffer.from(await blob(entry));
+        },
+      };
+      return filesystem;
+    },
+  );
+}

package/src/git.js

@@ -1,35 +1,32 @@
-import { spawnSync } from "node:child_process";
 import { mkdir, mkdtemp, rm } from "node:fs/promises";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { traceAsync, traceSync } from "./trace.js";
+import { runSubprocess } from "./subprocess.js";
+import { traceAsync } from "./trace.js";
 
 let commandObserver = null;
 
 function executeGit(root, args, { encoding, env, input } = {}) {
   if (commandObserver) commandObserver([...args]);
-  return traceSync(
-    "git.command",
+  return runSubprocess(
+    "git",
+    root === null ? args : ["-C", root, ...args],
     {
-      argumentCount: args.length - 1,
-      network: args[0] === "fetch" || args[0] === "ls-remote",
-      subcommand: args[0] ?? null,
-    },
-    () => spawnSync("git", ["-C", root, ...args], {
       encoding,
       env: { ...process.env, GIT_TERMINAL_PROMPT: "0", ...env },
       input,
       windowsHide: true,
-    }),
-    (completed) => ({
+    },
+    {
+      spanName: "git.command",
       attributes: {
-        exitCode: completed.status,
-        signal: completed.signal,
+        argumentCount: args.length - 1,
+        network: args[0] === "fetch" || args[0] === "ls-remote",
+        subcommand: args[0] ?? null,
       },
-      status: completed.status === 0 ? "ok" : "error",
-    }),
+    },
   );
 }
 
@@ -98,6 +95,24 @@ function parseTreeEntries(source, label) {
   return entries;
 }
 
+function parseLongTreeEntries(source, label) {
+  const entries = [];
+  for (const record of source.split("\0")) {
+    if (!record) continue;
+    const match = /^([0-7]{6}) (blob|tree|commit) ([0-9a-f]{40}|[0-9a-f]{64}) +(-|(?:0|[1-9]\d*))\t([\s\S]+)$/
+      .exec(record);
+    if (!match) throw new Error(`Cannot parse ${label} entry`);
+    entries.push({
+      mode: match[1],
+      type: match[2],
+      object: match[3],
+      size: match[4] === "-" ? null : Number(match[4]),
+      name: match[5],
+    });
+  }
+  return entries;
+}
+
 export function inspectTreeEntry(root, tree, path) {
   const output = requireGit(
     root,
@@ -121,6 +136,22 @@ export function listTreeEntries(root, tree, path) {
   return parseTreeEntries(output, `snapshot directory ${path}`);
 }
 
+export function inspectTree(root, tree, path) {
+  return inspectTreeLineage(root, tree, path)
+    .filter((entry) =>
+      entry.name === path || entry.name.startsWith(`${path}/`)
+    );
+}
+
+export function inspectTreeLineage(root, tree, path) {
+  const output = requireGit(
+    root,
+    ["ls-tree", "-r", "-t", "-l", "-z", tree, "--", path],
+    `Cannot inspect snapshot tree ${path}`,
+  );
+  return parseLongTreeEntries(output, `snapshot tree ${path}`);
+}
+
 export function gitObjectSize(root, object) {
   const output = requireGit(
     root,
@@ -151,6 +182,54 @@ export function readGitBlob(root, object) {
   return Buffer.from(result.stdout);
 }
 
+export function readGitBlobs(root, objects) {
+  const requested = [...new Set(objects)];
+  if (requested.length === 0) return new Map();
+  const result = executeGit(
+    root,
+    ["cat-file", "--batch"],
+    {
+      encoding: null,
+      input: Buffer.from(`${requested.join("\n")}\n`, "utf8"),
+    },
+  );
+  if (result.status !== 0) {
+    const stderr = Buffer.isBuffer(result.stderr)
+      ? result.stderr.toString("utf8")
+      : result.stderr;
+    throw new Error(
+      "Cannot read Git blobs: "
+      + `${sanitizeGitMessage(stderr?.trim() || result.error?.message || "Git failed")}`,
+    );
+  }
+
+  const source = Buffer.from(result.stdout);
+  const blobs = new Map();
+  let offset = 0;
+  for (const object of requested) {
+    const headerEnd = source.indexOf(0x0a, offset);
+    if (headerEnd < 0) throw new Error(`Missing Git blob header for ${object}`);
+    const header = source.subarray(offset, headerEnd).toString("utf8");
+    const match = /^([0-9a-f]{40}|[0-9a-f]{64}) blob (0|[1-9]\d*)$/
+      .exec(header);
+    if (!match || match[1] !== object) {
+      throw new Error(`Cannot parse Git blob header for ${object}`);
+    }
+    const size = Number(match[2]);
+    const contentStart = headerEnd + 1;
+    const contentEnd = contentStart + size;
+    if (contentEnd >= source.length || source[contentEnd] !== 0x0a) {
+      throw new Error(`Incomplete Git blob content for ${object}`);
+    }
+    blobs.set(object, source.subarray(contentStart, contentEnd));
+    offset = contentEnd + 1;
+  }
+  if (offset !== source.length) {
+    throw new Error("Unexpected trailing Git blob batch output");
+  }
+  return blobs;
+}
+
 export function inspectTreePaths(root, tree, paths) {
   if (paths.length === 0) return new Map();
   const input = `${paths.map((path) => `${tree}:${path}`).join("\n")}\n`;
@@ -271,6 +350,88 @@ export function parseWorktreeChanges(source) {
   return result;
 }
 
+export function parseRepositoryStatus(source) {
+  let branch = null;
+  let head = null;
+  for (const record of source.split("\0")) {
+    if (record.startsWith("# branch.oid ")) {
+      const value = record.slice("# branch.oid ".length);
+      if (value !== "(initial)") {
+        if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(value)) {
+          throw new Error(`Unsupported Git HEAD object ID: ${value}`);
+        }
+        head = value;
+      }
+    } else if (record.startsWith("# branch.head ")) {
+      const value = record.slice("# branch.head ".length);
+      branch = value === "(detached)" ? null : value;
+    }
+  }
+  return {
+    branch,
+    changes: parseWorktreeChanges(source),
+    head,
+  };
+}
+
+function escapeConfigKeyPattern(value) {
+  return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+
+function parseConfigRecords(source) {
+  const values = new Map();
+  for (const record of source.split("\0")) {
+    if (!record) continue;
+    const separator = record.indexOf("\n");
+    if (separator < 1) throw new Error("Cannot parse Git configuration record");
+    values.set(record.slice(0, separator), record.slice(separator + 1));
+  }
+  return values;
+}
+
+function inspectBranchConfiguration(root, branch) {
+  if (branch === null) {
+    return { branch: null, remote: null, repository: null, upstreamBranch: null };
+  }
+  const escapedBranch = escapeConfigKeyPattern(branch);
+  const result = runGit(root, [
+    "config",
+    "--null",
+    "--get-regexp",
+    `^(branch\\.${escapedBranch}\\.(remote|merge)|remote\\..*\\.url)$`,
+  ]);
+  const values = result.ok ? parseConfigRecords(result.stdout) : new Map();
+  const remote = values.get(`branch.${branch}.remote`) ?? null;
+  const merge = values.get(`branch.${branch}.merge`) ?? null;
+  const upstreamBranch = merge?.startsWith("refs/heads/")
+    ? merge.slice("refs/heads/".length)
+    : null;
+  const repository = remote === null || remote === "."
+    ? null
+    : values.get(`remote.${remote}.url`) ?? null;
+  return { branch, remote, repository, upstreamBranch };
+}
+
+export function inspectRepositoryState(root) {
+  const source = requireGit(
+    root,
+    [
+      "status",
+      "--porcelain=v2",
+      "--branch",
+      "--untracked-files=all",
+      "-z",
+    ],
+    "Cannot inspect repository state",
+  );
+  const status = parseRepositoryStatus(`${source}\0`);
+  return {
+    changes: status.changes,
+    head: status.head,
+    branch: inspectBranchConfiguration(root, status.branch),
+  };
+}
+
 export function inspectWorktreeChanges(root) {
   const source = requireGit(
     root,
@@ -360,6 +521,39 @@ export function resolveCommit(root, revision) {
   );
 }
 
+export function resolveSnapshot(root, revision) {
+  if (typeof revision !== "string" || /[\0\r\n]/.test(revision)) {
+    throw new Error(`Cannot resolve snapshot ${JSON.stringify(revision)}`);
+  }
+  const expressions = [`${revision}^{commit}`, `${revision}^{tree}`];
+  const result = runGit(
+    root,
+    ["cat-file", "--batch-check=%(objectname) %(objecttype)"],
+    { input: `${expressions.join("\n")}\n` },
+  );
+  if (!result.ok) {
+    throw new Error(
+      `Cannot resolve snapshot ${revision}: `
+      + `${sanitizeGitMessage(result.stderr || result.error?.message || "Git failed")}`,
+    );
+  }
+  const lines = result.stdout.split(/\r?\n/);
+  if (lines.length !== 2) {
+    throw new Error(`Cannot resolve snapshot ${revision}: unexpected Git output`);
+  }
+  const parsed = lines.map((line, index) => {
+    const match = /^([0-9a-f]{40}|[0-9a-f]{64}) (commit|tree)$/.exec(line);
+    if (!match) {
+      throw new Error(`Cannot resolve ${expressions[index]}`);
+    }
+    return { object: match[1], type: match[2] };
+  });
+  if (parsed[0].type !== "commit" || parsed[1].type !== "tree") {
+    throw new Error(`Cannot resolve snapshot ${revision}: invalid object types`);
+  }
+  return { commit: parsed[0].object, tree: parsed[1].object };
+}
+
 export function indexSnapshot(root) {
   return {
     tree: requireGit(root, ["write-tree"], "Cannot snapshot the index"),
@@ -391,9 +585,6 @@ export function fetchRepositoryBranch(root, repository, branch) {
     throw new Error(`Cannot determine fetched commit for branch ${branch}`);
   }
   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;
 }