@coderook/cli 0.25.1 → 0.25.3

package/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "coderook",
   "displayName": "CodeRook",
   "description": "Save, browse and restore whole-snapshot versions of a project on CodeRook, from Claude Code.",
-  "version": "0.25.1",
+  "version": "0.25.3",
   "author": {
     "name": "ACCA Gaming Productions",
     "url": "https://coderook.com"

package/README.md

@@ -109,12 +109,15 @@ somebody looking for where they can save needs to see the one they cannot.
 ## Ignore rules
 
 ```
-cbx rules                      show the rules in force
-cbx rules --init               write a starter .gitignore
-cbx rules --suggest            what is here that probably should not be sent
-cbx rules --suggest --apply    add the confident ones
+cbx ignore                     show the rules in force
+cbx ignore --init              write a starter .gitignore
+cbx ignore --suggest           what is here that probably should not be sent
+cbx ignore --suggest --apply   add the confident ones
 ```
 
+`cbx rules` is the same command under another name, so anything already
+written against it keeps working.
+
 `--suggest` looks at what the folder would actually send and names the
 dependency directories, virtual environments and build output in it, with how
 much each is costing you. Lines marked `+` are safe to assume and are the ones

package/dist/cli/src/git_history.js

@@ -21,6 +21,7 @@ exports.versionsInOrder = versionsInOrder;
 exports.stamp = stamp;
 exports.importRef = importRef;
 exports.quotePath = quotePath;
+exports.refPlacements = refPlacements;
 /**
  * Git's constant hash for the empty tree.
  *
@@ -223,3 +224,35 @@ function quotePath(filePath) {
         .replaceAll("\n", "\\n")
         .replaceAll("\r", "\\r")}"`;
 }
+/**
+ * Where each ref git asked for has to be pointed, once the commits exist.
+ *
+ * Git holds the helper to the whole batch: it names the refs it wants, and
+ * if any one of them does not exist when the stream ends it aborts the fetch
+ * — `could not read ref refs/coderook/<name>` — and the clone fails with
+ * nothing to show for it.
+ *
+ * Emitting commits is not enough to guarantee that, because a commit is
+ * written once per *version* while refs are per *line*. Two lines can share
+ * one version — making a line from where another already is does exactly
+ * that — so a single commit is expected to satisfy two refs, and only the
+ * first is written. A line whose version arrived in an earlier fetch has no
+ * commit emitted for it at all, and lands in the same hole.
+ *
+ * So each ref is stated separately rather than inferred from the commits.
+ * A ref whose head has no mark is reported rather than guessed at: pointing
+ * it somewhere plausible would hand back a branch that is quietly not the
+ * one asked for.
+ */
+function refPlacements(wanted, markOfVersion) {
+    const placed = [];
+    const unplaceable = [];
+    for (const [ref, head] of wanted) {
+        const mark = markOfVersion.get(head);
+        if (mark === undefined)
+            unplaceable.push(ref);
+        else
+            placed.push({ ref, mark });
+    }
+    return { placed, unplaceable };
+}

package/dist/cli/src/git_remote.js

@@ -529,9 +529,40 @@ async function doImport(refs, url) {
     let nextMark = 1;
     for (const mark of commitMark.values())
         nextMark = Math.max(nextMark, mark + 1);
+    /*
+      Point every ref git asked for at the commit its line's head became.
+  
+      Which ref needs what is worked out in `refPlacements`; this only says it.
+      `reset` is idempotent, so naming a ref that a commit in this stream has
+      already set costs a line and changes nothing.
+    */
+    const settleRefs = () => {
+        const { placed, unplaceable } = (0, git_history_js_1.refPlacements)(wanted, commitMark);
+        for (const { ref, mark } of placed) {
+            send(`reset ${(0, git_history_js_1.importRef)(ref)}`);
+            send(`from :${mark}`);
+        }
+        for (const ref of unplaceable) {
+            say(`  could not place ${ref}: no commit for its head version`);
+        }
+    };
     const fresh = order.filter((version) => !commitMark.has(version.id));
     if (!fresh.length) {
         say(`Already up to date with ${slug}.`);
+        /*
+          Still has to name the refs. "Nothing new to fetch" and "this ref does
+          not exist" are different answers, and a line added since the last fetch
+          is the first case while looking like the second.
+    
+          The marks table is loaded first because the refs are placed by mark,
+          and without it those marks name nothing in this stream.
+        */
+        if (marks) {
+            send("feature done");
+            send(`feature import-marks-if-exists=${marks.file.replaceAll("\\", "/")}`);
+            send(`feature export-marks=${marks.file.replaceAll("\\", "/")}`);
+            settleRefs();
+        }
         send("done");
         return;
     }
@@ -612,6 +643,8 @@ async function doImport(refs, url) {
                 say(`  ${done}/${fresh.length} versions`);
             }
         }
+        /* Every ref git asked for, named outright now the commits exist. */
+        settleRefs();
         /*
           Releases come back as tags, because that is the same statement in the
           other vocabulary: a version somebody gave a name to.

package/dist/cli/src/transfer_command.js

@@ -321,6 +321,27 @@ async function commandTransfer(parsed) {
         if (!parsed.flags.has("issues")) {
             console.log(dim("  · issues — pass --issues to bring the open ones"));
         }
+        /*
+          Said plainly rather than implied by the word "transfer".
+    
+          Nothing here checks whose repository this is, and nothing could: a public
+          repository is readable by anybody, which is exactly why cloning one needs
+          no token. What that means in practice is that this is `git clone`
+          followed by a publish — no more permission than anyone already has, and
+          no claim of ownership either. The licence that came with the files is
+          still the thing that governs what may be done with them, which matters
+          most at the moment somebody makes the project public.
+        */
+        console.log([
+            "",
+            `${dim("On ownership:")} nothing was checked, and nothing could be.`,
+            "A public repository is readable by anyone, which is why cloning one",
+            "needs no token — so this is a clone and a publish, not a claim. The",
+            "licence that came with the files is still what governs them.",
+            ...(facts && facts.visibility === "public"
+                ? ["Worth reading before you make this project public."]
+                : []),
+        ].join("\n"));
         console.log(`\nFetch it anywhere with ${accent(`cbx clone ${project.slug}`)}` +
             `${dim(", or ")}${accent(`git clone coderook://${project.slug}`)}${dim(".")}`);
         return 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coderook/cli",
-  "version": "0.25.1",
+  "version": "0.25.3",
   "description": "CodeRook from the command line, on any operating system",
   "license": "SEE LICENSE IN LICENSE.txt",
   "homepage": "https://coderook.com",