@coderook/cli 0.22.2 → 0.24.0

package/dist/cli/src/git_history.js

@@ -0,0 +1,188 @@
+"use strict";
+/**
+ * The decisions the git remote helper makes, with nothing plugged in.
+ *
+ * Ordering a version graph, reading and writing the commit marker, parsing a
+ * remote URL, quoting a path for fast-import: none of it needs a network, a
+ * token, an upload engine or a git binary, and all of it is where a mistake is
+ * silent rather than loud. Kept apart so a test can exercise it directly —
+ * importing the helper itself drags in the uploader and the downloader, which
+ * is why this file exists at all.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRAILER = exports.EMPTY_TREE = void 0;
+exports.parseRemoteUrl = parseRemoteUrl;
+exports.commitFromMessage = commitFromMessage;
+exports.messageWithCommit = messageWithCommit;
+exports.messageWithoutMarker = messageWithoutMarker;
+exports.tagOf = tagOf;
+exports.branchOf = branchOf;
+exports.versionsInOrder = versionsInOrder;
+exports.stamp = stamp;
+exports.importRef = importRef;
+exports.quotePath = quotePath;
+/**
+ * Git's constant hash for the empty tree.
+ *
+ * Diffing a root commit against this gives the same "everything is added"
+ * answer as a normal parent diff, so the first commit is not a special case
+ * with its own code path to get wrong.
+ */
+exports.EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+/**
+ * The line that ties a CodeRook version back to the git commit it came from.
+ *
+ * Written into the version message because it has to survive somewhere both
+ * machines can see. A file under `.git/` would be invisible to a colleague and
+ * to this same person on another laptop, and the consequence of losing the
+ * mapping is not a missing feature — it is re-pushing a history the project
+ * already holds, as a second copy. `git-svn` and `git-p4` put their marker in
+ * the message for the same reason.
+ */
+exports.TRAILER = "CodeRook-Git-Commit:";
+/** `coderook://project`, `coderook://owner/project`, `coderook::project`. */
+function parseRemoteUrl(url) {
+    let rest = url.trim();
+    for (const prefix of ["coderook://", "coderook::", "coderook:"]) {
+        if (rest.startsWith(prefix)) {
+            rest = rest.slice(prefix.length);
+            break;
+        }
+    }
+    rest = rest.replace(/^\/+/, "").replace(/\/+$/, "");
+    // An owner segment is accepted and ignored: a token already says who this
+    // is, and silently pushing to a different account than the URL named would
+    // be a worse outcome than not supporting the form at all.
+    const parts = rest.split("/").filter(Boolean);
+    const slug = parts[parts.length - 1] ?? "";
+    if (!slug)
+        throw new Error(`Not a CodeRook remote URL: ${url}`);
+    return { slug };
+}
+/**
+ * Pull the git commit id back out of a version message, if it carries one.
+ *
+ * The *last* marker wins. A message can hold more than one after a round trip
+ * — clone a project, push it back, and the message carries the marker it was
+ * imported with plus the one this publish adds. Taking the first would name
+ * the commit from the original repository rather than the one just published,
+ * and every incremental push after that would compute its range from a commit
+ * this repository has never heard of.
+ */
+function commitFromMessage(message) {
+    const all = [
+        ...message.matchAll(new RegExp(`${exports.TRAILER}\\s*([0-9a-f]{40})\\b`, "g")),
+    ];
+    return all.length ? all[all.length - 1][1] : null;
+}
+/** Attach the marker to a commit message without disturbing what it says. */
+function messageWithCommit(message, sha) {
+    const body = message.replace(/\s+$/, "");
+    return `${body}\n\n${exports.TRAILER} ${sha}`;
+}
+/**
+ * The message as a person wrote it, with our bookkeeping taken back out.
+ *
+ * Used when rebuilding git commits: the marker names the commit a version came
+ * *from*, which is not the commit being created here, so leaving it in would
+ * stamp every imported commit with a false identity.
+ */
+function messageWithoutMarker(message) {
+    return message
+        .replace(new RegExp(`^\\s*${exports.TRAILER}\\s*[0-9a-f]{40}\\s*$`, "gm"), "")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+/** `refs/tags/v1.0` -> `v1.0`. Anything else is not a tag. */
+function tagOf(ref) {
+    return ref.startsWith("refs/tags/") ? ref.slice("refs/tags/".length) : null;
+}
+/** `refs/heads/main` -> `main`. Anything else is not a branch. */
+function branchOf(ref) {
+    return ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : null;
+}
+/**
+ * Every version reachable from these heads, oldest first.
+ *
+ * A plain sort by sequence would look right and be wrong: sequences are handed
+ * out per project as versions are made, so two lines interleave in a way that
+ * has nothing to do with ancestry. Walking `parentVersionIds` and emitting a
+ * version only once all of its parents have been emitted is what makes a
+ * commit's parents exist by the time git is told about them — fast-import
+ * refuses a mark it has not seen, so getting this wrong fails loudly, which is
+ * the one mercy of it.
+ */
+function versionsInOrder(heads, all) {
+    const byId = new Map(all.map((version) => [version.id, version]));
+    // Everything the heads can reach. Iterative rather than recursive: a long
+    // project is thousands of versions deep and a stack is not.
+    const reachable = new Set();
+    const pending = [...heads];
+    while (pending.length) {
+        const id = pending.pop();
+        if (!id || reachable.has(id) || !byId.has(id))
+            continue;
+        reachable.add(id);
+        for (const parent of byId.get(id).parentVersionIds)
+            pending.push(parent);
+    }
+    const emitted = new Set();
+    const order = [];
+    /*
+      Depth-first with an explicit stack, visiting parents before the child. The
+      `expanded` flag is what separates "I have queued this one's parents" from
+      "its parents are done", without which a diamond history emits the join
+      twice.
+    */
+    const stack = heads
+        .filter((id) => reachable.has(id))
+        .map((id) => ({ id, expanded: false }));
+    while (stack.length) {
+        const frame = stack.pop();
+        if (emitted.has(frame.id))
+            continue;
+        const version = byId.get(frame.id);
+        if (!version)
+            continue;
+        if (frame.expanded) {
+            emitted.add(frame.id);
+            order.push(version);
+            continue;
+        }
+        stack.push({ id: frame.id, expanded: true });
+        for (const parent of version.parentVersionIds) {
+            if (reachable.has(parent) && !emitted.has(parent)) {
+                stack.push({ id: parent, expanded: false });
+            }
+        }
+    }
+    return order;
+}
+/** Seconds since the epoch, for a fast-import person stamp. */
+function stamp(when) {
+    const at = Date.parse(when);
+    return Number.isFinite(at) ? Math.floor(at / 1000) : Math.floor(Date.now() / 1000);
+}
+/**
+ * Where an imported branch is written.
+ *
+ * Into the helper's own namespace rather than `refs/heads/*`, matching the
+ * `refspec` advertised in `capabilities`. Writing straight to `refs/heads/*`
+ * would have this remote overwrite local branches of the same name on every
+ * fetch.
+ */
+function importRef(ref) {
+    const branch = branchOf(ref);
+    return branch ? `refs/coderook/${branch}` : ref;
+}
+/** fast-import wants a path C-quoted when it holds a quote or a newline. */
+function quotePath(filePath) {
+    const normalised = filePath.replaceAll("\\", "/");
+    if (!/["\n\r]/.test(normalised))
+        return normalised;
+    return `"${normalised
+        .replaceAll("\\", "\\\\")
+        .replaceAll('"', '\\"')
+        .replaceAll("\n", "\\n")
+        .replaceAll("\r", "\\r")}"`;
+}