@coderook/cli 0.25.4 → 0.27.0

package/dist/cli/src/git_remote.js

@@ -47,9 +47,19 @@ exports.main = main;
  * `coderook://` URLs, which is what lets every editor's built-in git panel work
  * with CodeRook without any per-editor work.
  *
- * Both directions are implemented: `push` publishes commits as versions, and
- * `import` rebuilds a git history from versions so `git clone` and `git fetch`
- * work.
+ * Both directions are implemented: `push` publishes each commit as a save, and
+ * `import` rebuilds a git history from those saves so `git clone` and `git
+ * fetch` work.
+ *
+ * The vocabulary matters here, because the two products do not agree by
+ * accident. A pushed commit becomes a *commit* in CodeRook — a save, inside
+ * the project, that nobody outside can see. Tagging it names it, and a named
+ * save is a *version*, which is the only thing the public side offers. That
+ * is the same distinction git already draws between a commit and a tag, so
+ * the mapping is one-to-one rather than an approximation.
+ *
+ * A save also carries a description of its own, separate from its message.
+ * That travels as a git note on `refs/notes/coderook` in both directions.
  *
  * ## Why the `push` capability rather than `export`
  *
@@ -143,6 +153,26 @@ function git(args) {
     }
     return result.stdout;
 }
+/**
+ * Where CodeRook keeps a save's description inside a git repository.
+ *
+ * `refs/notes/coderook` rather than git's default `refs/notes/commits`,
+ * because the default is shared ground — anything else attaching notes writes
+ * there too, and a fetch that overwrote somebody's own notes with ours would
+ * be taking something that was not offered.
+ */
+const NOTES_REF = "refs/notes/coderook";
+/**
+ * The description attached to a commit, if there is one.
+ *
+ * Empty rather than throwing for every ordinary reason it can be missing: no
+ * notes ref at all, no note on this commit, or a repository where notes have
+ * never been used. None of those is a problem worth stopping a push for.
+ */
+function noteOn(sha) {
+    const result = (0, node_child_process_1.spawnSync)("git", ["notes", `--ref=${NOTES_REF}`, "show", sha], { encoding: "utf8", maxBuffer: 1024 * 1024 * 8 });
+    return result.status === 0 ? (result.stdout ?? "").trim() : "";
+}
 /** Run git for its exit status alone. False rather than throwing. */
 function gitOk(args) {
     return ((0, node_child_process_1.spawnSync)("git", args, { encoding: "utf8", stdio: "ignore" }).status === 0);
@@ -665,6 +695,40 @@ async function doImport(refs, url) {
                 say(`  ${done}/${fresh.length} versions`);
             }
         }
+        /*
+          What each save says about itself, as git notes.
+    
+          A CodeRook save carries a description separate from its message — the
+          thing the website shows as release info and `cbx notes` writes — and a
+          fetch used to drop all of it except on the few versions that were also
+          releases. Git's answer for text attached to a commit without changing
+          the commit is a note, so that is where it goes: `git log
+          --notes=coderook` shows them, and pushing them back returns them.
+    
+          Written as one commit on its own ref after every version commit exists,
+          because a note has to name a commit that is already in the stream.
+        */
+        const described = fresh.filter((version) => (version.notes ?? "").trim());
+        if (described.length) {
+            send(`commit ${(0, git_history_js_1.importRef)(NOTES_REF)}`);
+            send(`committer CodeRook <noreply@coderook.com> ` +
+                `${(0, git_history_js_1.stamp)(new Date().toISOString())} +0000`);
+            const why = Buffer.from("What each save says about itself\n", "utf8");
+            send(`data ${why.length}`);
+            node_process_1.default.stdout.write(why);
+            node_process_1.default.stdout.write("\n");
+            for (const version of described) {
+                const mark = commitMark.get(version.id);
+                if (mark === undefined)
+                    continue;
+                const body = Buffer.from(`${(version.notes ?? "").trim()}\n`, "utf8");
+                send(`N inline :${mark}`);
+                send(`data ${body.length}`);
+                node_process_1.default.stdout.write(body);
+                node_process_1.default.stdout.write("\n");
+            }
+            say(`  ${described.length} description${described.length === 1 ? "" : "s"} as git notes`);
+        }
         /* Every ref git asked for, named outright now the commits exist. */
         settleRefs();
         /*
@@ -856,7 +920,7 @@ async function doPush(requests, url) {
                     const existing = await releases(repositoryId).catch(() => []);
                     const already = existing.find((release) => release.versionId === versionId && release.name !== tag);
                     if (already) {
-                        say(`  note: v${already.sequence} was already released as "${already.name}".
+                        say(`  note: v${already.sequence} was already released as "${already.name}".
 ` +
                             `        A version carries one name, so it is now "${tag}".`);
                     }
@@ -1098,10 +1162,10 @@ async function doPush(requests, url) {
                           happened and go looking for a way to undo it.
                         */
                         send(`error ${request.dst} the connection failed part way through`);
-                        say(`
-  ${published} of ${commits.length} commits were published.
+                        say(`
+  ${published} of ${commits.length} commits were published.
 ` +
-                            `  Push again — commits already published are not sent twice.
+                            `  Push again — commits already published are not sent twice.
 `);
                         throw error;
                     }
@@ -1113,8 +1177,8 @@ async function doPush(requests, url) {
                           anyway.
                         */
                         send(`error ${request.dst} this commit carries a credential`);
-                        say(`
-  ${failure.message}
+                        say(`
+  ${failure.message}
 `);
                         /*
                           Deleting the file in a later commit does not help, and saying
@@ -1124,14 +1188,14 @@ async function doPush(requests, url) {
                           The history has to lose it.
                         */
                         say(`  A later commit that deletes it is not enough — every commit` +
-                            ` being pushed
+                            ` being pushed
   becomes a version, and the one that added` +
-                            ` the key still carries it.
+                            ` the key still carries it.
 ` +
                             `  Rewrite it out (git rebase -i, or git commit --amend if it` +
-                            ` is the last one),
+                            ` is the last one),
   or publish this deliberately with` +
-                            ` cbx submit --allow-secrets.
+                            ` cbx submit --allow-secrets.
 `);
                         /*
                           Reported already, and in more detail than the wrapper can. The
@@ -1141,8 +1205,8 @@ async function doPush(requests, url) {
                     }
                     if (failure?.kind === "conflict") {
                         send(`error ${request.dst} somebody published to "${branch}" while this push was running`);
-                        say(`
-  git fetch, then push again.
+                        say(`
+  git fetch, then push again.
 `);
                         throw error;
                     }
@@ -1154,6 +1218,27 @@ async function doPush(requests, url) {
                 }
                 currentRepositoryId = result.repositoryId;
                 baseVersionId = result.versionId;
+                /*
+                  A note on the commit becomes what the version says about itself.
+        
+                  CodeRook lets a save be described before anybody decides to publish
+                  it, and git has exactly one place for text attached to a commit
+                  without altering it. Sent after the publish rather than with it,
+                  because a note is not part of what was saved and a failure to
+                  record one must not fail the push.
+                */
+                const note = noteOn(sha);
+                if (note) {
+                    try {
+                        const { changeVersion } = await Promise.resolve().then(() => __importStar(require("./api.js")));
+                        await changeVersion(result.repositoryId, result.versionId, {
+                            notes: note,
+                        });
+                    }
+                    catch {
+                        say(`  note: the description on ${sha.slice(0, 8)} could not be saved`);
+                    }
+                }
                 /*
                   The version and the commit it came from are the same thing in this
                   repository from here on. Recorded so a later fetch does not rebuild

package/dist/cli/src/project_commands.js

@@ -131,20 +131,83 @@ async function commandVersions(parsed) {
         console.log(dim("Nothing has been saved to this project yet."));
         return 0;
     }
+    /*
+      The same two lanes the website shows.
+  
+      A version is a commit somebody named, so the lanes are a split of one
+      history rather than two histories — asking for commits gives the saves
+      still waiting on that decision, and asking for versions gives the ones
+      the public side can see. Neither contains the other; with no flag you get
+      both, which is what this always did.
+    */
+    const onlyVersions = parsed.flags.get("versions") === true;
+    const onlyCommits = parsed.flags.get("commits") === true;
+    if (onlyVersions && onlyCommits) {
+        console.error(red("Pick one: --versions or --commits, or neither for both."));
+        return 1;
+    }
+    const lane = saved.filter((version) => {
+        if (onlyVersions)
+            return Boolean(version.name);
+        if (onlyCommits)
+            return !version.name;
+        return true;
+    });
+    if (!lane.length) {
+        console.log(dim(onlyVersions
+            ? "Nothing has been made a version yet."
+            : "Every save here has been made a version."));
+        return 0;
+    }
+    const withNotes = parsed.flags.get("notes") === true;
     const asked = Number(parsed.flags.get("limit") ?? 20);
     const limit = Number.isFinite(asked) && asked > 0 ? asked : 20;
     console.log(bold(project.name));
-    for (const version of saved.slice(0, limit)) {
+    for (const version of lane.slice(0, limit)) {
         const when = version.createdAt
             ? new Date(version.createdAt).toLocaleString()
             : "";
+        /*
+          What the project has made of this version, said before the numbers.
+    
+          A name, a pin and a set of labels are how somebody finds the version
+          they meant among forty; the file count is how they check it once they
+          have. Putting the arrangement first is the difference between a log and
+          a list they organised.
+        */
+        const marks = [
+            /* Which one the project is standing on, which is not the same as which
+               one is at the top once somebody has pinned something. */
+            version.head ? green("current") : "",
+            version.pinned ? accent("pinned") : "",
+            version.name ? bold(version.name) : "",
+            version.state === "held" ? red("held") : "",
+            version.state === "declined" ? dim("declined") : "",
+            version.removedAt ? dim("taken down") : "",
+            /*
+              Said only of a version, because only a version is offered to anybody.
+              A commit nobody has promoted is not hidden — it was never on offer.
+            */
+            version.name && version.visibility === "private" ? dim("hidden") : "",
+            ...version.labels.map((label) => accent(label.name)),
+        ].filter(Boolean);
         console.log(`  ${accent(`v${version.sequence}`).padEnd(16)} ${when.padEnd(22)}` +
-            `${String(version.fileCount).padStart(5)} files  ${bytes(version.storedSize)}`);
+            `${String(version.fileCount).padStart(5)} files  ${bytes(version.storedSize)}` +
+            (marks.length ? `  ${marks.join(" ")}` : ""));
         if (version.message)
             console.log(`    ${dim(version.message)}`);
+        /*
+          Indented under the save it belongs to rather than printed flat, so a
+          note of several paragraphs still reads as part of one row.
+        */
+        if (withNotes && version.notes?.trim()) {
+            for (const line of version.notes.trim().split(/\r?\n/)) {
+                console.log(`      ${line}`);
+            }
+        }
     }
-    if (saved.length > limit) {
-        console.log(dim(`  … ${saved.length - limit} older. Use --limit to see more.`));
+    if (lane.length > limit) {
+        console.log(dim(`  … ${lane.length - limit} older. Use --limit to see more.`));
     }
     return 0;
 }

package/dist/cli/src/service_commands.js

@@ -105,7 +105,8 @@ async function commandRelease(parsed) {
     const wanted = parsed.flags.get("version");
     const target = typeof wanted === "string"
         ? all.find((version) => String(version.sequence) === wanted.replace(/^v/i, ""))
-        : all[0];
+        /* The newest by number rather than by position in the list. */
+        : all.reduce((newest, one) => (one.sequence > newest.sequence ? one : newest));
     if (!target) {
         console.error(red(`This project has no version ${String(wanted)}.`));
         return 1;