silvermoon 0.0.2 → 0.1.0

package/src/idea-layout.js

@@ -2,15 +2,9 @@ import { lstat, readFile, readdir } from "node:fs/promises";
 import { relative, resolve } from "node:path";
 
 import { deriveIdeaState, isValidUlid, parseIdeaStatus } from "./ideas.js";
-import { gitObjectIdLength, runGit, worktreePathTree } from "./git.js";
+import { inspectTreePaths, worktreeSnapshot } from "./git.js";
 import { IDEAS_ROOT, ideaPaths } from "./layout.js";
 
-const REVISION_BINDINGS = {
-  approvedRevision: "idealRevision",
-  implementationAcceptedRevision: "implementationRevision",
-  deploymentAcceptedRevision: "deploymentRevision",
-};
-
 function displayPath(root, path) {
   return relative(root, path).replaceAll("\\", "/");
 }
@@ -28,91 +22,6 @@ async function metadata(path) {
   }
 }
 
-function validateRevisionObjects(root, statusPath, status, diagnostics) {
-  for (const key of Object.keys(REVISION_BINDINGS)) {
-    if (!status[key]) continue;
-    const type = runGit(root, ["cat-file", "-t", status[key]]);
-    if (!type.ok || type.stdout !== "tree") {
-      diagnostics.push(error(
-        "idea.revision.invalid-object",
-        `${statusPath}#${key}`,
-        `${key} must resolve to a Git tree object: ${status[key]}`,
-        "Use the current corresponding world tree object ID from Git.",
-      ));
-    }
-  }
-}
-
-function validateRevisionHistory(root, commit, idea, diagnostics) {
-  for (const [statusKey, revisionKey] of Object.entries(REVISION_BINDINGS)) {
-    const revision = idea.status[statusKey];
-    if (!revision) continue;
-    const history = runGit(root, [
-      "log",
-      "--reverse",
-      "--format=%H",
-      "-S",
-      `${statusKey}: ${revision}`,
-      commit,
-      "--",
-      idea.statusPath,
-    ]);
-    const evidenceCommit = history.ok
-      ? history.stdout.split(/\r?\n/).filter(Boolean)[0]
-      : null;
-    if (!evidenceCommit) {
-      const shallow = runGit(root, ["rev-parse", "--is-shallow-repository"]);
-      diagnostics.push(error(
-        shallow.ok && shallow.stdout === "true"
-          ? "history.incomplete"
-          : "idea.revision.history-missing",
-        `${idea.statusPath}#${statusKey}`,
-        `Primary history does not prove when ${statusKey} recorded ${revision}.`,
-        "Fetch complete primary history or repair the decision through a forward commit.",
-      ));
-      continue;
-    }
-    const tree = runGit(root, ["rev-parse", `${evidenceCommit}:${idea.worlds[revisionKey].path}`]);
-    if (!tree.ok || tree.stdout !== revision) {
-      diagnostics.push(error(
-        "idea.revision.history-mismatch",
-        `${idea.statusPath}#${statusKey}`,
-        `${statusKey} was not bound to its world tree in commit ${evidenceCommit}.`,
-        "Record the decision only for the corresponding world tree in the same candidate commit.",
-      ));
-    }
-  }
-}
-
-function validateCandidateRevisions(root, baseRevision, idea, diagnostics, objectIdLength) {
-  let previous = {};
-  if (baseRevision) {
-    const previousSource = runGit(root, ["show", `${baseRevision}:${idea.statusPath}`]);
-    if (previousSource.ok) {
-      try {
-        previous = parseIdeaStatus(previousSource.stdout + "\n", { objectIdLength });
-      } catch {
-        previous = {};
-      }
-    }
-  }
-  for (const [statusKey, revisionKey] of Object.entries(REVISION_BINDINGS)) {
-    if (
-      idea.status[statusKey] === previous[statusKey] ||
-      idea.status[statusKey] === undefined
-    ) continue;
-    const expected = idea.revisions[revisionKey];
-    if (idea.status[statusKey] !== expected) {
-      diagnostics.push(error(
-        "idea.revision.candidate-mismatch",
-        `${idea.statusPath}#${statusKey}`,
-        `${statusKey} must equal the corresponding world tree in the same candidate snapshot.`,
-        `Use ${expected} for ${revisionKey} or omit the stale mutation.`,
-      ));
-    }
-  }
-}
-
 async function requireDirectory(root, path, diagnostics) {
   const absolute = resolve(root, path);
   const value = await metadata(absolute);
@@ -184,23 +93,25 @@ async function rejectSymlinks(root, path, diagnostics) {
   }
 }
 
-function resolveTree({ gitRoot, root, snapshotTree }, path) {
-  if (snapshotTree) {
-    const resolved = runGit(gitRoot, ["rev-parse", `${snapshotTree}:${path}`]);
-    if (!resolved.ok) throw new Error(resolved.stderr || `Cannot resolve ${path}`);
-    return resolved.stdout;
+function objectIdLength(tree) {
+  if (/^[0-9a-f]{40}$/.test(tree)) return 40;
+  if (/^[0-9a-f]{64}$/.test(tree)) return 64;
+  throw new Error(`Unsupported Git tree object ID: ${tree}`);
+}
+
+function requiredTree(objects, path) {
+  const inspected = objects.get(path);
+  if (!inspected || inspected.type !== "tree" || inspected.object === null) {
+    throw new Error(`${path} does not resolve to a Git tree`);
   }
-  return worktreePathTree(root, path);
+  return inspected.object;
 }
 
 export async function inspectIdeaLayout({
-  baseRevision,
   config: _config,
-  historyCommit,
   root,
   gitRoot = root,
   snapshotTree,
-  validateCandidate = false,
 }) {
   const diagnostics = [];
   const ideasRoot = resolve(root, IDEAS_ROOT);
@@ -228,9 +139,12 @@ export async function inspectIdeaLayout({
     };
   }
 
-  let objectIdLength;
+  let resolvedSnapshotTree;
+  let repositoryObjectIdLength;
   try {
-    objectIdLength = gitObjectIdLength(gitRoot);
+    resolvedSnapshotTree = snapshotTree
+      ?? worktreeSnapshot(gitRoot, { paths: [IDEAS_ROOT] }).tree;
+    repositoryObjectIdLength = objectIdLength(resolvedSnapshotTree);
   } catch (caught) {
     return {
       diagnostics: [error(
@@ -246,7 +160,30 @@ export async function inspectIdeaLayout({
   const aliases = new Map();
   const ideas = [];
   const caseNames = new Map();
-  for (const entry of await readdir(ideasRoot, { withFileTypes: true })) {
+  const entries = (await readdir(ideasRoot, { withFileTypes: true }))
+    .sort((left, right) => left.name.localeCompare(right.name));
+  const ideaIds = new Set(
+    entries.filter((entry) => isValidUlid(entry.name)).map((entry) => entry.name),
+  );
+  const worldPaths = [...ideaIds].flatMap((id) => {
+    const paths = ideaPaths(id);
+    return [paths.idealPath, paths.innerPath, paths.outerPath];
+  });
+  let worldObjects;
+  try {
+    worldObjects = inspectTreePaths(gitRoot, resolvedSnapshotTree, worldPaths);
+  } catch (caught) {
+    return {
+      diagnostics: [error(
+        "idea.revision.unavailable",
+        IDEAS_ROOT,
+        caught.message,
+        "Ensure every world can be represented as a Git tree.",
+      )],
+      ideas: [],
+    };
+  }
+  for (const entry of entries) {
     const folderPath = resolve(ideasRoot, entry.name);
     const folderMetadata = await lstat(folderPath);
     const relativePath = displayPath(root, folderPath);
@@ -282,7 +219,9 @@ export async function inspectIdeaLayout({
     }
 
     const paths = ideaPaths(entry.name);
-    for (const child of await readdir(folderPath, { withFileTypes: true })) {
+    const children = (await readdir(folderPath, { withFileTypes: true }))
+      .sort((left, right) => left.name.localeCompare(right.name));
+    for (const child of children) {
       if (
         child.name === "status.yaml" ||
         child.name === "ledger.md" ||
@@ -331,7 +270,7 @@ export async function inspectIdeaLayout({
     try {
       status = parseIdeaStatus(
         await readFile(resolve(root, paths.statusPath), "utf8"),
-        { objectIdLength },
+        { objectIdLength: repositoryObjectIdLength },
       );
     } catch (caught) {
       diagnostics.push(error(
@@ -351,6 +290,14 @@ export async function inspectIdeaLayout({
       ));
     }
     if (status.alias !== undefined) {
+      if (ideaIds.has(status.alias)) {
+        diagnostics.push(error(
+          "idea.alias.id-collision",
+          `${paths.statusPath}#alias`,
+          `Alias ${status.alias} collides with an idea ULID.`,
+          "Choose an alias that is distinct from every idea ULID.",
+        ));
+      }
       const aliasOwner = aliases.get(status.alias);
       if (aliasOwner) {
         diagnostics.push(error(
@@ -374,15 +321,9 @@ export async function inspectIdeaLayout({
     let revisions;
     try {
       revisions = {
-        idealRevision: resolveTree({ gitRoot, root, snapshotTree }, paths.idealPath),
-        implementationRevision: resolveTree(
-          { gitRoot, root, snapshotTree },
-          paths.innerPath,
-        ),
-        deploymentRevision: resolveTree(
-          { gitRoot, root, snapshotTree },
-          paths.outerPath,
-        ),
+        idealRevision: requiredTree(worldObjects, paths.idealPath),
+        implementationRevision: requiredTree(worldObjects, paths.innerPath),
+        deploymentRevision: requiredTree(worldObjects, paths.outerPath),
       };
     } catch (caught) {
       diagnostics.push(error(
@@ -394,23 +335,22 @@ export async function inspectIdeaLayout({
       continue;
     }
 
-    validateRevisionObjects(gitRoot, paths.statusPath, status, diagnostics);
     const worlds = {
       idealRevision: {
         name: "Ideal World",
-        displayName: "道心",
+        displayName: "理想世界",
         path: paths.idealPath,
         documentPath: paths.ideaDocumentPath,
       },
       implementationRevision: {
         name: "Inner World",
-        displayName: "内景",
+        displayName: "主体世界",
         path: paths.innerPath,
         documentPath: paths.implementationDocumentPath,
       },
       deploymentRevision: {
         name: "Outer World",
-        displayName: "现世",
+        displayName: "现实世界",
         path: paths.outerPath,
         documentPath: paths.deploymentDocumentPath,
       },
@@ -428,10 +368,6 @@ export async function inspectIdeaLayout({
       worlds,
     };
     if (status.alias !== undefined) idea.alias = status.alias;
-    if (validateCandidate) {
-      validateCandidateRevisions(gitRoot, baseRevision, idea, diagnostics, objectIdLength);
-    }
-    if (historyCommit) validateRevisionHistory(gitRoot, historyCommit, idea, diagnostics);
     ideas.push(idea);
   }