silvermoon 0.0.1

package/src/create-idea.js

@@ -0,0 +1,235 @@
+import { randomBytes } from "node:crypto";
+import { lstat, mkdir, readFile, rm, rmdir, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+
+import { loadConfig } from "./config.js";
+import {
+  DEPLOYMENT_TEMPLATE,
+  IDEA_TEMPLATE,
+  IMPLEMENTATION_TEMPLATE,
+  LEDGER_TEMPLATE,
+} from "./idea-templates.js";
+import { isValidUlid, serializeIdeaStatus } from "./ideas.js";
+import { IDEAS_ROOT, ideaPaths } from "./layout.js";
+import { whatsNext } from "./whatsnext.js";
+
+const ULID_ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+const MAX_ID_ATTEMPTS = 32;
+
+function encode(value, length) {
+  let encoded = "";
+  for (let index = 0; index < length; index += 1) {
+    encoded = ULID_ALPHABET[Number(value & 31n)] + encoded;
+    value >>= 5n;
+  }
+  return encoded;
+}
+
+export function generateUlid({ now = Date.now(), random = randomBytes(10) } = {}) {
+  return encode(BigInt(now), 10) + encode(BigInt(`0x${Buffer.from(random).toString("hex")}`), 16);
+}
+
+async function pathExists(path, inspect) {
+  try {
+    await inspect(path);
+    return true;
+  } catch (caught) {
+    if (caught.code === "ENOENT") return false;
+    throw caught;
+  }
+}
+
+async function removeOwnedFile(path, expected, read, remove) {
+  let current;
+  try {
+    current = await read(path);
+  } catch (caught) {
+    if (caught.code === "ENOENT") return;
+    throw caught;
+  }
+  const expectedBytes = Buffer.from(expected);
+  if (
+    current.length <= expectedBytes.length &&
+    expectedBytes.subarray(0, current.length).equals(current)
+  ) {
+    await remove(path, { force: true });
+  }
+}
+
+async function removeCreatedDirectories(created, removeDirectory) {
+  for (const path of [...created].reverse()) {
+    try {
+      await removeDirectory(path);
+    } catch {
+      return;
+    }
+  }
+}
+
+async function ensureDirectoryPath(root, relativePath, inspect, makeDirectory, removeDirectory) {
+  const created = [];
+  let current = root;
+  try {
+    for (const segment of relativePath.split("/")) {
+      current = resolve(current, segment);
+      let metadata;
+      try {
+        metadata = await inspect(current);
+      } catch (caught) {
+        if (caught.code !== "ENOENT") throw caught;
+      }
+      if (metadata) {
+        if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+          throw new Error(`Silvermoon path segment is not a regular directory: ${current}`);
+        }
+        continue;
+      }
+      try {
+        await makeDirectory(current);
+        created.push(current);
+      } catch (caught) {
+        if (caught.code !== "EEXIST") throw caught;
+        metadata = await inspect(current);
+        if (!metadata.isDirectory() || metadata.isSymbolicLink()) throw caught;
+      }
+    }
+    return created;
+  } catch (caught) {
+    await removeCreatedDirectories(created, removeDirectory);
+    throw caught;
+  }
+}
+
+function failure(root, preflight, caught) {
+  return {
+    command: "create-idea",
+    ok: false,
+    root,
+    diagnostics: [{
+      code: "idea.create.failed",
+      level: "error",
+      message: caught.message,
+      remediation: "Preserve existing paths, resolve the filesystem error, and retry.",
+    }],
+    result: {
+      observedPrimaryCommit: preflight.result?.observedPrimaryCommit ?? null,
+      request: { kind: "create-idea" },
+      selectedIdea: null,
+      action: null,
+      createdIdea: null,
+    },
+  };
+}
+
+export async function createIdea({
+  generateId = generateUlid,
+  operations = {},
+  root = process.cwd(),
+} = {}) {
+  const repositoryRoot = resolve(root);
+  const preflight = await whatsNext({ create: true, root: repositoryRoot });
+  const routed = { ...preflight, command: "create-idea" };
+  if (!preflight.ok || preflight.result.action?.code !== "create-idea") return routed;
+
+  const loaded = await loadConfig({ root: repositoryRoot });
+  if (!loaded.config) return { ...routed, ok: false, diagnostics: loaded.diagnostics };
+
+  const inspect = operations.lstat ?? lstat;
+  const makeDirectory = operations.mkdir ?? mkdir;
+  const read = operations.readFile ?? readFile;
+  const remove = operations.rm ?? rm;
+  const removeDirectory = operations.rmdir ?? rmdir;
+  const write = operations.writeFile ?? writeFile;
+  let rootDirectories;
+  try {
+    rootDirectories = await ensureDirectoryPath(
+      repositoryRoot,
+      IDEAS_ROOT,
+      inspect,
+      makeDirectory,
+      removeDirectory,
+    );
+  } catch (caught) {
+    return failure(repositoryRoot, preflight, caught);
+  }
+
+  const failRoot = async (caught) => {
+    await removeCreatedDirectories(rootDirectories, removeDirectory);
+    return failure(repositoryRoot, preflight, caught);
+  };
+
+  for (let attempt = 0; attempt < MAX_ID_ATTEMPTS; attempt += 1) {
+    const id = await generateId();
+    if (!isValidUlid(id)) {
+      return failRoot(new Error(`Generated idea id is not a canonical ULID: ${id}`));
+    }
+    const paths = ideaPaths(id);
+    const folder = resolve(repositoryRoot, paths.ideaPath);
+    if (await pathExists(folder, inspect)) continue;
+
+    const directoryPaths = [
+      paths.ideaPath,
+      paths.outerPath,
+      paths.innerPath,
+      paths.idealPath,
+    ];
+    const files = [
+      [paths.ideaDocumentPath, IDEA_TEMPLATE],
+      [paths.implementationDocumentPath, IMPLEMENTATION_TEMPLATE],
+      [paths.deploymentDocumentPath, DEPLOYMENT_TEMPLATE],
+      [paths.ledgerPath, LEDGER_TEMPLATE],
+      [paths.statusPath, serializeIdeaStatus({ version: 1, id })],
+    ];
+    const createdDirectories = [];
+    const cleanupFiles = [];
+    try {
+      for (const relativePath of directoryPaths) {
+        const absolutePath = resolve(repositoryRoot, relativePath);
+        await makeDirectory(absolutePath);
+        createdDirectories.push(absolutePath);
+      }
+      for (const [relativePath, source] of files) {
+        const absolutePath = resolve(repositoryRoot, relativePath);
+        const cleanup = [absolutePath, source];
+        cleanupFiles.push(cleanup);
+        try {
+          await write(absolutePath, source, { flag: "wx" });
+        } catch (caught) {
+          if (caught.code === "EEXIST") cleanupFiles.pop();
+          throw caught;
+        }
+      }
+      return {
+        command: "create-idea",
+        ok: true,
+        root: repositoryRoot,
+        diagnostics: [],
+        result: {
+          observedPrimaryCommit: preflight.result.observedPrimaryCommit,
+          request: { kind: "create-idea" },
+          selectedIdea: null,
+          createdIdea: {
+            id,
+            ideaPath: paths.ideaPath,
+            statusPath: paths.statusPath,
+            ideaDocumentPath: paths.ideaDocumentPath,
+            implementationDocumentPath: paths.implementationDocumentPath,
+            deploymentDocumentPath: paths.deploymentDocumentPath,
+            ledgerPath: paths.ledgerPath,
+          },
+        },
+      };
+    } catch (caught) {
+      for (const [path, source] of [...cleanupFiles].reverse()) {
+        await removeOwnedFile(path, source, read, remove).catch(() => { });
+      }
+      await removeCreatedDirectories(createdDirectories, removeDirectory);
+      if (caught.code === "EEXIST") continue;
+      return failRoot(caught);
+    }
+  }
+
+  return failRoot(
+    new Error(`Could not allocate a unique idea id after ${MAX_ID_ATTEMPTS} attempts.`),
+  );
+}

package/src/git.js

@@ -0,0 +1,284 @@
+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";
+
+let commandObserver = null;
+
+export function runGit(root, args, { env } = {}) {
+  if (commandObserver) commandObserver([...args]);
+  const result = spawnSync("git", ["-C", root, ...args], {
+    encoding: "utf8",
+    env,
+    windowsHide: true,
+  });
+  return {
+    error: result.error ?? null,
+    ok: result.status === 0,
+    status: result.status,
+    stderr: result.stderr?.trim() ?? "",
+    stdout: result.stdout?.trim() ?? "",
+  };
+}
+
+export async function observeGitCommands(observer, callback) {
+  if (commandObserver) throw new Error("Git command observation is already active");
+  commandObserver = observer;
+  try {
+    return await callback();
+  } finally {
+    commandObserver = null;
+  }
+}
+
+export function sanitizeGitMessage(value) {
+  return String(value)
+    .replace(
+      /\b([a-z][a-z0-9+.-]*:\/\/)([^\s/@]+)@/gi,
+      "$1[redacted]@",
+    )
+    .replace(
+      /([?&](?:access_token|auth|credential|key|password|signature|token)=)[^&#\s]+/gi,
+      "$1[redacted]",
+    )
+    .replace(/\bgh[pousr]_[A-Za-z0-9_]{20,}\b/g, "[redacted]");
+}
+
+function requireGit(root, args, label, options) {
+  const result = runGit(root, args, options);
+  if (!result.ok) {
+    const safeResult = {
+      ...result,
+      stderr: sanitizeGitMessage(result.stderr),
+    };
+    const error = new Error(`${label}: ${safeResult.stderr || result.error?.message || "Git failed"}`);
+    error.git = safeResult;
+    throw error;
+  }
+  return result.stdout;
+}
+
+export function gitObjectIdLength(root) {
+  const format = requireGit(
+    root,
+    ["rev-parse", "--show-object-format"],
+    "Cannot determine Git object format",
+  );
+  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 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 });
+  }
+}
+export function worktreeSnapshot(root) {
+  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"], "Cannot snapshot worktree", { env });
+    return {
+      tree: requireGit(root, ["write-tree"], "Cannot write worktree snapshot", { env }),
+    };
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+}
+
+function paths(stdout) {
+  return stdout.split(/\r?\n/).filter(Boolean);
+}
+
+const CHANGE_KINDS = {
+  A: "added",
+  C: "copied",
+  D: "deleted",
+  M: "modified",
+  R: "renamed",
+  T: "type-changed",
+  U: "unmerged",
+};
+
+const CONFLICT_KINDS = {
+  AA: "both-added",
+  AU: "added-by-us",
+  DD: "both-deleted",
+  DU: "deleted-by-us",
+  UA: "added-by-them",
+  UD: "deleted-by-them",
+  UU: "both-modified",
+};
+
+function recordFields(record, count) {
+  const fields = [];
+  let offset = 2;
+  for (let index = 0; index < count; index += 1) {
+    const separator = record.indexOf(" ", offset);
+    if (separator < 0) throw new Error(`Malformed Git status record: ${record}`);
+    fields.push(record.slice(offset, separator));
+    offset = separator + 1;
+  }
+  return { fields, path: record.slice(offset) };
+}
+
+function changeEntry(path, code, originalPath) {
+  const entry = { path, kind: CHANGE_KINDS[code] ?? "unknown" };
+  if (originalPath !== undefined) entry.originalPath = originalPath;
+  return entry;
+}
+
+function sortChanges(changes) {
+  changes.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+}
+
+export function parseWorktreeChanges(source) {
+  const result = { staged: [], unstaged: [], untracked: [], conflicted: [] };
+  const records = source.split("\0");
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    if (!record) continue;
+    if (record.startsWith("? ")) {
+      result.untracked.push({ path: record.slice(2) });
+      continue;
+    }
+    if (record.startsWith("! ") || record.startsWith("# ")) continue;
+    if (record.startsWith("u ")) {
+      const { fields, path } = recordFields(record, 9);
+      result.conflicted.push({ path, kind: CONFLICT_KINDS[fields[0]] ?? "unmerged" });
+      continue;
+    }
+    if (record.startsWith("1 ") || record.startsWith("2 ")) {
+      const renamed = record.startsWith("2 ");
+      const { fields, path } = recordFields(record, renamed ? 8 : 7);
+      const [indexCode, worktreeCode] = fields[0];
+      const originalPath = renamed ? records[++index] : undefined;
+      if (indexCode !== ".") {
+        result.staged.push(changeEntry(path, indexCode, originalPath));
+      }
+      if (worktreeCode !== ".") {
+        result.unstaged.push(changeEntry(path, worktreeCode));
+      }
+      continue;
+    }
+    throw new Error(`Unsupported Git status record: ${record}`);
+  }
+  for (const changes of Object.values(result)) sortChanges(changes);
+  return result;
+}
+
+export function resolveCommit(root, revision) {
+  return requireGit(
+    root,
+    ["rev-parse", "--verify", "--end-of-options", `${revision}^{commit}`],
+    `Cannot resolve commit ${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}`,
+    );
+    if (runGit(root, ["cat-file", "-e", `${primary}^{commit}`]).ok) return primary;
+  }
+  throw new Error(`Remote branch ${branch} moved repeatedly while fetching`);
+}
+
+export function fetchPrimary(root, config) {
+  return fetchRepositoryBranch(
+    root,
+    config.primaryRepository,
+    config.primaryBranch,
+  );
+}
+
+export async function withTemporaryWorktree(root, commit, callback) {
+  const tree = requireGit(root, ["rev-parse", `${commit}^{tree}`], `Cannot resolve tree for ${commit}`);
+  return withTemporaryTree(root, tree, 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 });
+  }
+}