@coderook/cli 0.29.5 → 0.30.0

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

package/dist/cli/src/cli.js

@@ -35,6 +35,7 @@ const skill_command_js_1 = require("./skill_command.js");
 const licence_commands_js_1 = require("./licence_commands.js");
 const service_commands_js_1 = require("./service_commands.js");
 const worktree_js_1 = require("../../desktop-app/src/main/worktree.js");
+const rules_js_1 = require("../../desktop-app/src/main/rules.js");
 const upload_js_1 = require("../../desktop-app/src/main/upload.js");
 const download_js_1 = require("../../desktop-app/src/main/download.js");
 const faults_js_1 = require("../../desktop-app/src/main/faults.js");
@@ -349,7 +350,22 @@ async function commandStatus(parsed) {
         console.log(dim("Offline — comparing with the last Version cached for this folder."));
     }
     const rules = await (0, worktree_js_1.readRules)(folder);
-    const files = await (0, worktree_js_1.changedFiles)(folder, rules, baseline);
+    /*
+      Scanned the way `cbx diff` scans, and reported the way `cbx submit` acts.
+  
+      Status used to ask only for additions and updates, which is exactly what a
+      plain save sends — so it was not wrong. But a deleted file then appeared
+      nowhere: `cbx diff` showed it as removed, `cbx status` said nothing, and
+      the two commands disagreed about the same folder. Somebody who had deleted
+      a file read that as CodeRook not having noticed it.
+  
+      So deletions are found and named here, kept apart from what a save will
+      send, with the flag that would send them spelled out. The safe default
+      does not change: a save adds and updates.
+    */
+    const found = await (0, worktree_js_1.changedFiles)(folder, rules, baseline, "synchronize");
+    const gone = found.filter((file) => file.deleted);
+    const files = found.filter((file) => !file.deleted);
     console.log(bold(node_path_1.default.basename(folder)) + dim(`  ${folder}`));
     console.log(link
         ? `Account holds ${accent(`v${link.sequence}`)} · ${Object.keys(link.manifest).length} files ${dim(`(${link.slug})`)}`
@@ -370,18 +386,85 @@ async function commandStatus(parsed) {
         for (const [path] of stale.slice(0, 10))
             console.log(dim(`  behind  ${path}`));
     }
+    /** The deletions, and what a plain save will do about them. */
+    /*
+      What this folder is, and what its own rules never heard about.
+  
+      A real .gitignore always wins — that is not negotiable — but it also meant
+      that a Unity project whose file was written before the engine rules
+      existed went on sending its entire import cache, and nothing anywhere
+      said so. One real upload of forty-seven thousand files was forty-five
+      thousand of rebuildable cache, and it broke the project on the machine it
+      was downloaded to.
+    */
+    const engine = async () => {
+        const { kind, missing } = await (0, worktree_js_1.missingEngineRules)(folder);
+        if (!kind.length || !missing.length)
+            return;
+        /*
+          Only the rules that would actually leave something out.
+    
+          Naming every line the template has and this folder does not produced
+          sixty-odd of them, most matching nothing at all — a Visual Studio
+          template mentions `[Dd]ebug/x64/` whether or not you have one. What a
+          person needs is the two that are costing them forty thousand files, so
+          each candidate is measured against what this folder is currently
+          sending and the ones worth nothing are not mentioned.
+        */
+        const sending = found.map((one) => one.path);
+        const worth = missing
+            .map((rule) => {
+            const layers = [{ base: "", rules: (0, rules_js_1.parseRules)(rule) }];
+            return {
+                rule,
+                files: sending.filter((one) => (0, rules_js_1.excludes)(one, false, layers)).length,
+            };
+        })
+            .filter((one) => one.files > 0)
+            .sort((left, right) => right.files - left.files);
+        if (!worth.length)
+            return;
+        const total = worth.reduce((sum, one) => sum + one.files, 0);
+        console.log(dim(`\nThis looks like a ${kind.join(" + ")} project, and its own rules are ` +
+            `missing ${worth.length} that would leave out ` +
+            `${total.toLocaleString()} file${total === 1 ? "" : "s"} you are sending — ` +
+            `${accent("cbx ignore --template " + kind[0])} adds them.`));
+        for (const one of worth.slice(0, 6)) {
+            console.log(dim(`  ${String(one.files).padStart(7)}  ${one.rule}`));
+        }
+    };
+    const deletions = () => {
+        if (!gone.length)
+            return;
+        const many = gone.length === 1 ? "" : "s";
+        console.log(dim(`\n${gone.length} file${many} deleted here ${gone.length === 1 ? "is" : "are"} ` +
+            `still in the saved version. A save adds and updates, so ` +
+            `${gone.length === 1 ? "it stays" : "they stay"} until you pass ` +
+            `${accent("--sync")}.`));
+        for (const file of gone.slice(0, 10)) {
+            console.log(`  ${red("deleted")}  ${file.path}`);
+        }
+        if (gone.length > 10)
+            console.log(dim(`  …and ${gone.length - 10} more`));
+    };
     if (!files.length) {
         console.log(stale.length
             ? "Nothing to submit; your own work is all saved."
-            : "Nothing to submit; this folder matches the saved version.");
+            : gone.length
+                ? "Nothing here to add or update."
+                : "Nothing to submit; this folder matches the saved version.");
+        deletions();
+        await engine();
         return 0;
     }
     console.log(`\n${files.length} file${files.length === 1 ? "" : "s"} to submit:`);
     for (const file of files.slice(0, 50)) {
-        console.log(`  ${file.deleted ? red("deleted") : accent("changed")}  ${file.path}`);
+        console.log(`  ${accent("changed")}  ${file.path}`);
     }
     if (files.length > 50)
         console.log(dim(`  …and ${files.length - 50} more`));
+    deletions();
+    await engine();
     return 0;
 }
 /**
@@ -1311,11 +1394,14 @@ async function commandRules(parsed) {
         return suggestRules(folder, hasFlag(parsed, "apply"));
     }
     if (hasFlag(parsed, "init")) {
+        /*
+          Whatever `readRules` decided, which is now the template that matches the
+          folder rather than one generic list. Writing STARTER_IGNORE here would
+          have handed a Unity project the JavaScript rules, which is how an upload
+          came back missing things inside Assets.
+        */
         const existing = await (0, worktree_js_1.readRules)(folder);
-        await (0, worktree_js_1.writeRules)(folder, {
-            shared: existing.shared.trim() ? existing.shared : worktree_js_1.STARTER_IGNORE,
-            local: existing.local,
-        });
+        await (0, worktree_js_1.writeRules)(folder, existing);
         console.log(`Wrote ${node_path_1.default.join(folder, ".gitignore")}`);
         return 0;
     }

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

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.STARTER_TOPUP_HEADING = exports.SUGGESTED_HEADING = void 0;
+exports.templatesFor = templatesFor;
 exports.suggestExclusions = suggestExclusions;
 exports.suggestBulkDirectories = suggestBulkDirectories;
 exports.rulesFromSuggestions = rulesFromSuggestions;
@@ -122,6 +123,83 @@ const norm = (value) => value.split("\\").join("/");
  * their upload will take and the biggest item answers it. Anything matching
  * nothing is simply absent — silence is the right output for a tidy folder.
  */
+/**
+ * Which of github/gitignore's templates this folder is asking for.
+ *
+ * The templates have been vendored all along — three hundred of them, taken
+ * from github/gitignore — but nothing ever chose one. A folder with no rules
+ * of its own got the generic starter instead, and for a game project that is
+ * the wrong list: it carries `build/`, `dist/`, `out/` and `models/**` from
+ * the JavaScript and Python worlds, none of which are anchored, all of which
+ * can reach into somewhere like `Assets/Art/models`.
+ *
+ * Recognised from the files a project must have to be that kind of project,
+ * rather than from anything a person configures. Order matters: an engine is
+ * decided first, because a Unity project also has a package.json somewhere
+ * and the engine's own template is the one that knows about `Assets`.
+ */
+function templatesFor(entries) {
+    const here = new Set(entries.map((name) => name.toLowerCase()));
+    const any = (test) => entries.some(test);
+    const picked = [];
+    const take = (key) => {
+        if (!picked.includes(key))
+            picked.push(key);
+    };
+    /* An engine first, and at most one: their templates overlap and disagree. */
+    if (here.has("assets") && here.has("projectsettings"))
+        take("unity");
+    else if (any((name) => name.toLowerCase().endsWith(".uproject"))) {
+        take("unrealengine");
+    }
+    else if (here.has("project.godot"))
+        take("godot");
+    /*
+      Cocos before Node, and this order is the whole reason it is written down.
+  
+      A Cocos project carries a package.json, so recognising Node first called
+      it a Node project and handed it Node's rules — which know nothing about
+      `library` or `temp`, the caches Cocos rebuilds. Measured on the soak
+      shape: eight and a half thousand cache files went from left out to sent.
+    */
+    else if (here.has("project.json") && here.has("assets"))
+        take("cocos");
+    /* Then the languages, of which a folder may honestly be several. */
+    if (here.has("package.json"))
+        take("node");
+    if (here.has("pyproject.toml") ||
+        here.has("requirements.txt") ||
+        here.has("setup.py")) {
+        take("python");
+    }
+    if (here.has("cargo.toml"))
+        take("rust");
+    if (here.has("go.mod"))
+        take("go");
+    if (here.has("build.gradle") || here.has("build.gradle.kts"))
+        take("gradle");
+    /*
+      An engine's own project files are not a second kind of project.
+  
+      Unity writes the .sln and the .csproj itself, and every engine here does
+      something similar. Reading that as "also a Visual Studio project" and
+      stacking GitHub's template on top is not a harmless extra: that template
+      ignores `*.meta`, which in the .NET world is build output and in Unity is
+      the sidecar carrying every asset's GUID. On a real project it would have
+      dropped 13,689 of them, and a Unity project without its metas is exactly
+      the broken-materials mess this was all started by.
+    */
+    const engine = picked.length > 0;
+    if (!engine && any((name) => name.toLowerCase().endsWith(".sln"))) {
+        take("visualstudio");
+    }
+    if (!engine && any((name) => name.toLowerCase().endsWith(".xcodeproj"))) {
+        take("objective-c");
+    }
+    if (!engine && here.has("cmakelists.txt"))
+        take("cmake");
+    return picked;
+}
 function suggestExclusions(files) {
     const totals = new Map();
     for (const entry of files) {

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

@@ -7,6 +7,7 @@ exports.parseRules = parseRules;
 exports.ruleMatches = ruleMatches;
 exports.lastMatchingRule = lastMatchingRule;
 exports.decide = decide;
+exports.decidingRule = decidingRule;
 exports.excludes = excludes;
 exports.negationReachesInto = negationReachesInto;
 exports.isIgnored = isIgnored;
@@ -198,7 +199,21 @@ function decide(relativePath, isDirectory, layers) {
  * is the dangerous direction to differ in: it uploads what somebody thought
  * they had excluded.
  */
-function excludes(relativePath, isDirectory, layers) {
+/**
+ * The rule that settles this path, counting the directories above it.
+ *
+ * A directory rule is written about the directory — `/[Ll]ibrary/` matches
+ * `Library`, not `Library/Artifacts/f1.dat` — so anything asking only about
+ * the file finds no rule and calls it included. The upload has always walked
+ * the ancestors; the filter screen asked about the file alone, and so showed
+ * a Unity project's whole import cache as going up when the save would have
+ * left every byte of it behind.
+ *
+ * Returned as the rule rather than a yes or no, because the screen names the
+ * line responsible — "Library/ — 400 files" is the useful form, and a boolean
+ * cannot say it.
+ */
+function decidingRule(relativePath, isDirectory, layers) {
     /*
       Ancestors first, outermost in. The moment one is excluded the answer is
       settled and nothing below it can appeal.
@@ -208,9 +223,12 @@ function excludes(relativePath, isDirectory, layers) {
         const ancestor = parts.slice(0, depth).join("/");
         const above = decide(ancestor, true, layers);
         if (above && !above.negated)
-            return true;
+            return above;
     }
-    const rule = decide(relativePath, isDirectory, layers);
+    return decide(relativePath, isDirectory, layers);
+}
+function excludes(relativePath, isDirectory, layers) {
+    const rule = decidingRule(relativePath, isDirectory, layers);
     return Boolean(rule && !rule.negated);
 }
 /**

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

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferProgress = void 0;
+/**
+ * How much of an upload has happened, and how fast it is going.
+ *
+ * Lifted out of the upload pass because nearly every number a person watches
+ * during a save comes from here, and three separate faults have come out of it
+ * being a handful of loose counters in the middle of a very long function:
+ *
+ *   - Six lanes each added their own offset to one shared total, so the figure
+ *     jumped between six different answers and the bar ran backwards.
+ *   - The rate was `transferred` over the whole elapsed time while the bar
+ *     beside it showed something else, so one real upload sat at
+ *     "152 MB of 1.1 GB · 10 B/s" — not a slow upload, a number describing a
+ *     different thing.
+ *   - A lifetime average meant a slow first minute went on dragging the figure
+ *     down long after the link had recovered, which is the opposite of what
+ *     somebody watching it wants to know.
+ *
+ * So the counters and the arithmetic over them live together, with names, and
+ * can be tested without starting an upload.
+ */
+class TransferProgress {
+    windowMs;
+    now;
+    /** Bytes of files that have finished, whether they travelled or not. */
+    settled = 0;
+    /** Bytes that actually crossed the wire. */
+    moved = 0;
+    /** Files the service already held, so nothing crossed the wire for them. */
+    reused = 0;
+    /*
+      How far each lane is through the file it currently holds, kept apart so the
+      total is the sum of real work rather than six lanes' guesses about one
+      shared number.
+    */
+    inFlight = new Map();
+    samples = [];
+    constructor(
+    /** How long a window the rate is measured over. */
+    windowMs = 5000, 
+    /** Injected so a test can move time without waiting for it. */
+    now = Date.now) {
+        this.windowMs = windowMs;
+        this.now = now;
+    }
+    /** A file finished: its own size, and what it cost to send. */
+    finished(sourceBytes, wireBytes) {
+        this.settled += sourceBytes;
+        this.moved += wireBytes;
+    }
+    /** A file the service already had. Counted apart so "sent" stays honest. */
+    alreadyHeld() {
+        this.reused += 1;
+    }
+    /** Where one lane has got to inside the file it is sending. */
+    lane(index, offset) {
+        this.inFlight.set(index, offset);
+    }
+    /** That lane has finished, so its offset is now part of the settled total. */
+    laneDone(index) {
+        this.inFlight.delete(index);
+    }
+    /** Everything settled, plus how far the open lanes have got. */
+    bytes() {
+        let total = this.settled;
+        for (const offset of this.inFlight.values())
+            total += offset;
+        return total;
+    }
+    get sentBytes() {
+        return this.settled;
+    }
+    get transferred() {
+        return this.moved;
+    }
+    get alreadyOnAccount() {
+        return this.reused;
+    }
+    /**
+     * How fast the thing on screen is moving, over a short trailing window.
+     *
+     * The same counter the bar uses, so the two agree. Sampled rather than
+     * recorded per call: this is asked once per report, and reports arrive per
+     * file, which for small files is thousands a second.
+     */
+    rate() {
+        const now = this.now();
+        const bytes = this.bytes();
+        const last = this.samples[this.samples.length - 1];
+        if (!last || now - last.at >= 250)
+            this.samples.push({ at: now, bytes });
+        while (this.samples.length > 2 && now - this.samples[0].at > this.windowMs) {
+            this.samples.shift();
+        }
+        const oldest = this.samples[0];
+        const seconds = (now - oldest.at) / 1000;
+        /*
+          Nothing until there is something to divide. Answering zero keeps the
+          window quiet rather than showing a figure computed from a fraction of a
+          second, which reads as a stall on an upload that has barely begun.
+        */
+        if (seconds < 0.5)
+            return 0;
+        return Math.max(0, Math.round((bytes - oldest.bytes) / seconds));
+    }
+}
+exports.TransferProgress = TransferProgress;