@coderook/cli 0.31.1 → 0.31.2

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.31.1",
+  "version": "0.31.2",
   "author": {
     "name": "ACCA Gaming Productions",
     "url": "https://coderook.com"

package/dist/cli/src/cli.js

@@ -18,6 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const promises_1 = require("node:readline/promises");
 const node_os_1 = __importDefault(require("node:os"));
 const promises_2 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const node_process_1 = __importDefault(require("node:process"));
 const api_js_1 = require("./api.js");
@@ -385,6 +386,22 @@ async function commandStatus(parsed) {
             `— run ${accent("cbx get")} to bring ${stale.length === 1 ? "it" : "them"} down.`));
         for (const [path] of stale.slice(0, 10))
             console.log(dim(`  behind  ${path}`));
+        /*
+          Behind, and not here at all. Usually somebody else's file that has not
+          been fetched — but it is also what a file deleted here looked like after
+          a save that did not send the deletion, because until 0.31.2 that save
+          dropped it from this folder's record. Told plainly, since the one advice
+          above would bring back a file the person meant to be rid of.
+        */
+        const absent = stale.filter(([file]) => !(0, node_fs_1.existsSync)(node_path_1.default.join(folder, ...file.split("/"))));
+        if (absent.length) {
+            const one = absent.length === 1;
+            const which = absent.length === stale.length
+                ? one ? "It is not" : "They are not"
+                : `${absent.length} of them ${one ? "is" : "are"} not`;
+            console.log(dim(`${which} in this folder at all. If you deleted ${one ? "it" : "them"} yourself, ` +
+                `run ${accent("cbx get")}, delete ${one ? "it" : "them"} again, and save with ${accent("--sync")}.`));
+        }
     }
     /** The deletions, and what a plain save will do about them. */
     /*

package/dist/desktop-app/src/main/upload.js

@@ -915,6 +915,53 @@ class Uploader {
         if (!completed.mergeTrack && !Object.keys(acceptedManifest).length) {
             acceptedManifest = Object.fromEntries([...(await this.versionFiles(repositoryId, completed.version.id))].map(([file, descriptor]) => [file, descriptor.sha256]));
         }
+        const manifest = Object.keys(acceptedManifest).length
+            ? acceptedManifest
+            : {
+                ...Object.fromEntries(reused.map((file) => [file.path, prior.get(file.path).sha256])),
+                ...Object.fromEntries(declarations.map((declaration) => [declaration.path, declaration.sha256])),
+            };
+        /*
+          What this folder holds after the save. A file that was sent holds
+          the bytes that were sent. Anything else keeps whatever digest was
+          recorded before: an unticked edit therefore stays pending rather
+          than looking saved, and a copy left stale by somebody else's merge
+          stays recognisably stale rather than looking like a new edit.
+    
+          Looked up in a map rather than by searching the declarations for each
+          file, which on a 47,000-file project was over a billion comparisons at
+          the very end of a save.
+        */
+        const sentDigest = new Map(declarations.map((declaration) => [declaration.path, declaration.sha256]));
+        const onDisk = new Set(everything.map((file) => file.path));
+        const local = Object.fromEntries(everything.flatMap((file) => {
+            const sent = sentDigest.get(file.path);
+            if (sent)
+                return [[file.path, sent]];
+            const before = request.known?.[file.path] ?? prior.get(file.path)?.sha256;
+            return before ? [[file.path, before]] : [];
+        }));
+        /*
+          And a file deleted here that this save carried forward keeps its place.
+    
+          A plain save adds and updates, so a file somebody deleted stays in the
+          version. It used to vanish from this record all the same, because the
+          record was built only from what is on disk — and the next status then
+          found the version holding a file this folder did not, called it
+          "behind", and offered to fetch it back. The person had deleted it; the
+          only thing that brought it back was being told to run `cbx get`.
+    
+          Only where the record already had it. A file that was never here — one
+          somebody else's save merged into the version — has no entry to keep, so
+          it stays "behind", which is exactly what it is.
+        */
+        for (const path of Object.keys(manifest)) {
+            if (onDisk.has(path))
+                continue;
+            const held = request.known?.[path];
+            if (held)
+                local[path] = held;
+        }
         report({
             stage: "done",
             files: declarations.length,
@@ -940,29 +987,8 @@ class Uploader {
             /** Selected, but the service already held the content. */
             alreadyStoredFiles: progress.alreadyOnAccount,
             telemetry: this.telemetry.snapshot(),
-            // A file that kept its old object records the digest of *that* copy,
-            // not of the file on disk, so an unticked edit is still pending next
-            // time rather than looking as though it had been saved.
-            /*
-              What this folder holds after the save. A file that was sent holds
-              the bytes that were sent. Anything else keeps whatever digest was
-              recorded before: an unticked edit therefore stays pending rather
-              than looking saved, and a copy left stale by somebody else's merge
-              stays recognisably stale rather than looking like a new edit.
-            */
-            local: Object.fromEntries(everything.flatMap((file) => {
-                const sent = declarations.find((one) => one.path === file.path);
-                if (sent)
-                    return [[file.path, sent.sha256]];
-                const before = request.known?.[file.path] ?? prior.get(file.path)?.sha256;
-                return before ? [[file.path, before]] : [];
-            })),
-            manifest: Object.keys(acceptedManifest).length
-                ? acceptedManifest
-                : {
-                    ...Object.fromEntries(reused.map((file) => [file.path, prior.get(file.path).sha256])),
-                    ...Object.fromEntries(declarations.map((declaration) => [declaration.path, declaration.sha256])),
-                },
+            local,
+            manifest,
         };
     }
     /**

package/package.json

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