silvermoon 0.2.2 → 0.3.0-rc.2

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;
 }
 

package/src/guidance.js

@@ -1,10 +1,8 @@
 import { TextDecoder } from "node:util";
 
 import {
-  gitObjectSize,
-  inspectTreeEntry,
-  listTreeEntries,
-  readGitBlob,
+  inspectTree,
+  readGitBlobs,
 } from "./git.js";
 import {
   GUIDANCE_PHASES,
@@ -50,22 +48,20 @@ function unexpectedEntry(name) {
   );
 }
 
-function inspectContent(gitRoot, entry, phase) {
+function contentSizeDiagnostic(entry, phase) {
   const path = phaseGuidancePath(phase);
-  const size = gitObjectSize(gitRoot, entry.object);
-  if (size > MAX_PHASE_GUIDANCE_BYTES) {
-    return {
-      diagnostic: error(
-        "guidance.file.too-large",
-        path,
-        `Phase guidance exceeds the ${MAX_PHASE_GUIDANCE_BYTES}-byte limit: ${path}`,
-        `Reduce ${path} to at most ${MAX_PHASE_GUIDANCE_BYTES} UTF-8 bytes.`,
-      ),
-    };
-  }
+  if (entry.size <= MAX_PHASE_GUIDANCE_BYTES) return null;
+  return error(
+    "guidance.file.too-large",
+    path,
+    `Phase guidance exceeds the ${MAX_PHASE_GUIDANCE_BYTES}-byte limit: ${path}`,
+    `Reduce ${path} to at most ${MAX_PHASE_GUIDANCE_BYTES} UTF-8 bytes.`,
+  );
+}
 
-  const bytes = readGitBlob(gitRoot, entry.object);
-  if (bytes.length !== size) {
+function inspectContent(bytes, entry, phase) {
+  const path = phaseGuidancePath(phase);
+  if (bytes.length !== entry.size) {
     throw new Error(
       `Git blob ${entry.object} changed size while reading ${path}`,
     );
@@ -121,11 +117,20 @@ function inspectContent(gitRoot, entry, phase) {
 }
 
 async function inspectGuidanceInternal({
+  filesystem,
   gitRoot,
   phase,
   snapshotTree,
 }) {
-  const rootEntry = inspectTreeEntry(gitRoot, snapshotTree, GUIDANCE_ROOT);
+  const treeEntries = filesystem === undefined
+    ? inspectTree(gitRoot, snapshotTree, GUIDANCE_ROOT)
+    : null;
+  const rootEntry = treeEntries === null
+    ? filesystem.snapshotEntry(GUIDANCE_ROOT)
+    : treeEntries.find(({ name }) => name === GUIDANCE_ROOT);
+  if (rootEntry === undefined) {
+    return { state: "absent", diagnostics: [] };
+  }
   if (rootEntry === null) {
     return { state: "absent", diagnostics: [] };
   }
@@ -133,7 +138,15 @@ async function inspectGuidanceInternal({
     return { state: "invalid", diagnostics: [invalidDirectory()] };
   }
 
-  const entries = listTreeEntries(gitRoot, rootEntry.object, GUIDANCE_ROOT);
+  const prefix = `${GUIDANCE_ROOT}/`;
+  const entries = (
+    treeEntries === null
+      ? filesystem.snapshotEntries(GUIDANCE_ROOT)
+      : treeEntries.filter(({ name }) =>
+        name.startsWith(prefix) && !name.slice(prefix.length).includes("/")
+      )
+  )
+    .map((entry) => ({ ...entry, name: entry.name.slice(prefix.length) }));
   const entriesByName = new Map(entries.map((entry) => [entry.name, entry]));
   const phases = phase === undefined ? GUIDANCE_PHASES : [phase];
   const diagnostics = [];
@@ -153,6 +166,7 @@ async function inspectGuidanceInternal({
 
   let selectedGuidance;
   let selectedPresent = false;
+  const contentEntries = [];
   for (const candidate of phases) {
     const path = phaseGuidancePath(candidate);
     const name = path.slice(`${GUIDANCE_ROOT}/`.length);
@@ -163,8 +177,29 @@ async function inspectGuidanceInternal({
       diagnostics.push(invalidFile(path));
       continue;
     }
-    const inspected = inspectContent(gitRoot, entry, candidate);
-    if (inspected.diagnostic) diagnostics.push(inspected.diagnostic);
+    const sizeDiagnostic = contentSizeDiagnostic(entry, candidate);
+    if (sizeDiagnostic) {
+      diagnostics.push(sizeDiagnostic);
+      continue;
+    }
+    contentEntries.push({ candidate, entry });
+  }
+
+  const blobs = filesystem === undefined
+    ? readGitBlobs(
+        gitRoot,
+        contentEntries.map(({ entry }) => entry.object),
+      )
+    : new Map(await Promise.all(contentEntries.map(async ({ candidate, entry }) => [
+        entry.object,
+        await filesystem.snapshotFile(phaseGuidancePath(candidate)),
+      ])));
+  for (const { candidate, entry } of contentEntries) {
+    const bytes = blobs.get(entry.object);
+    if (bytes === undefined) {
+      throw new Error(`Missing Git blob content for ${entry.object}`);
+    }
+    const inspected = inspectContent(bytes, entry, candidate);
     if (inspected.diagnostics) diagnostics.push(...inspected.diagnostics);
     if (phase !== undefined && inspected.guidance) {
       selectedGuidance = inspected.guidance;
@@ -183,6 +218,7 @@ async function inspectGuidanceInternal({
 }
 
 export async function inspectPhaseGuidance({
+  filesystem,
   gitRoot,
   phase,
   snapshotTree,
@@ -194,6 +230,7 @@ export async function inspectPhaseGuidance({
     async () => {
       try {
         return await inspectGuidanceInternal({
+          filesystem,
           gitRoot,
           phase,
           snapshotTree,
@@ -214,6 +251,7 @@ export async function inspectPhaseGuidance({
 }
 
 export async function inspectAllGuidance({
+  filesystem,
   gitRoot,
   snapshotTree,
 }) {
@@ -222,7 +260,11 @@ export async function inspectAllGuidance({
     { scope: "all" },
     async () => {
       try {
-        return await inspectGuidanceInternal({ gitRoot, snapshotTree });
+        return await inspectGuidanceInternal({
+          filesystem,
+          gitRoot,
+          snapshotTree,
+        });
       } catch (caught) {
         return {
           state: "invalid",