@coderook/cli 0.30.0 → 0.30.1

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

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

@@ -60,24 +60,24 @@ const RULES = [
       project where the question "what should I leave out?" has the largest
       possible answer was the one the detector had nothing to say about.
     */
-    { directory: "Library", reason: "Unity's import cache — rebuilt when the project next opens", recommended: true },
-    { directory: "Temp", reason: "Unity's scratch folder for the running editor", recommended: true },
-    { directory: "MemoryCaptures", reason: "Unity memory snapshots — large, and not the project", recommended: true },
-    { directory: "Recordings", reason: "Unity recorder output", recommended: true },
-    { directory: "UserSettings", reason: "Your own editor layout — not part of the project", recommended: true },
-    { directory: "DerivedDataCache", reason: "Unreal's derived data cache — rebuilt on demand", recommended: true },
-    { directory: "Intermediate", reason: "Unreal build intermediates — rebuilt when you build", recommended: true },
-    { directory: "Binaries", reason: "Unreal compiled output — rebuilt when you build", recommended: true },
+    { directory: "Library", atRoot: true, reason: "Unity's import cache — rebuilt when the project next opens", recommended: true },
+    { directory: "Temp", atRoot: true, reason: "Unity's scratch folder for the running editor", recommended: true },
+    { directory: "MemoryCaptures", atRoot: true, reason: "Unity memory snapshots — large, and not the project", recommended: true },
+    { directory: "Recordings", atRoot: true, reason: "Unity recorder output", recommended: true },
+    { directory: "UserSettings", atRoot: true, reason: "Your own editor layout — not part of the project", recommended: true },
+    { directory: "DerivedDataCache", atRoot: true, reason: "Unreal's derived data cache — rebuilt on demand", recommended: true },
+    { directory: "Intermediate", atRoot: true, reason: "Unreal build intermediates — rebuilt when you build", recommended: true },
+    { directory: "Binaries", atRoot: true, reason: "Unreal compiled output — rebuilt when you build", recommended: true },
     /*
       Named like the work, and it is not: Unreal keeps logs, crash reports and
       autosaves here. Offered rather than ticked, because a folder called
       "Saved" is the one nobody should have excluded on our say-so.
     */
-    { directory: "Saved", reason: "Unreal logs and autosaves — check before excluding", recommended: false },
-    { directory: ".godot", reason: "Godot's import cache — rebuilt when the project next opens", recommended: true },
-    { directory: ".import", reason: "Godot's import cache — rebuilt when the project next opens", recommended: true },
-    { directory: "Logs", reason: "Editor logs", recommended: true },
-    { directory: "obj", reason: "Compiler intermediates — rebuilt when you build", recommended: true },
+    { directory: "Saved", atRoot: true, reason: "Unreal logs and autosaves — check before excluding", recommended: false },
+    { directory: ".godot", atRoot: true, reason: "Godot's import cache — rebuilt when the project next opens", recommended: true },
+    { directory: ".import", atRoot: true, reason: "Godot's import cache — rebuilt when the project next opens", recommended: true },
+    { directory: "Logs", atRoot: true, reason: "Editor logs", recommended: true },
+    { directory: "obj", atRoot: true, reason: "Compiler intermediates — rebuilt when you build", recommended: true },
     { directory: ".vs", reason: "Visual Studio's local cache", recommended: true },
     /*
       Offered, not ticked. JetBrains keeps run configurations in here that some
@@ -104,7 +104,7 @@ const RULES = [
     { directory: "dist", reason: "Usually build output — check before excluding", recommended: false },
     { directory: "build", reason: "Usually build output — check before excluding", recommended: false },
     { directory: "out", reason: "Usually build output — check before excluding", recommended: false },
-    { directory: "bin", reason: "Usually build output — check before excluding", recommended: false },
+    { directory: "bin", atRoot: true, reason: "Usually build output — check before excluding", recommended: false },
     { extension: ".safetensors", reason: "Model weights — large, and usually downloadable", recommended: false },
     { extension: ".ckpt", reason: "Model weights — large, and usually downloadable", recommended: false },
     { extension: ".pt", reason: "Model weights — large, and usually downloadable", recommended: false },
@@ -222,11 +222,17 @@ function suggestExclusions(files) {
                   gets written matching the folder that is there.
                 */
                 const wanted = rule.directory.toLowerCase();
-                const found = segments
-                    .slice(0, -1)
-                    .find((segment) => segment.toLowerCase() === wanted);
+                /*
+                  At the root, where the rule is about the project's own output, and
+                  written anchored so it stays there. Unanchored, this offered to
+                  leave out `Assets/Props/obj` — a folder of 3D models — because a
+                  C# build also writes to a folder called obj. The file it proposed
+                  removing was the one the rules had just been fixed to protect.
+                */
+                const within = rule.atRoot ? segments.slice(0, 1) : segments.slice(0, -1);
+                const found = within.find((segment) => segment.toLowerCase() === wanted);
                 if (found)
-                    pattern = `${found}/`;
+                    pattern = rule.atRoot ? `/${found}/` : `${found}/`;
             }
             if (!pattern && rule.file && name === rule.file) {
                 pattern = rule.file;

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

@@ -132,17 +132,36 @@ function matcher(pattern) {
     }
     return expression;
 }
+/** A directory pattern with or without its trailing slash is the same rule. */
+function trailingSlashOff(pattern) {
+    let end = pattern.length;
+    while (end > 0 && pattern[end - 1] === "/")
+        end -= 1;
+    return pattern.slice(0, end);
+}
 function ruleMatches(relativePath, isDirectory, rule) {
     const expression = matcher(rule.pattern);
     if (rule.directoryOnly) {
-        if (rule.anchored || rule.pattern.includes("/")) {
-            return (expression.test(relativePath) ||
-                relativePath.startsWith(`${rule.pattern.replace(/\/+$/, "")}/`));
-        }
-        const segments = relativePath.split("/");
-        // A file inside an ignored directory is matched by its parent segments.
-        const scope = isDirectory ? segments : segments.slice(0, -1);
-        return scope.some((segment) => expression.test(segment));
+        /*
+          A rule written `dir/` speaks about directories and about nothing else.
+          Everything under an excluded directory goes too, but that is git
+          declining to look inside it rather than the pattern reaching down, and
+          the difference shows the moment a later rule re-includes the directory:
+          `build/` then `!build/` leaves `build/keep.txt` travelling, which is the
+          escape hatch people are told to use. It shows again in reverse, which is
+          how this was found — asking `!Library/PackageCache/a.package/` about a
+          file let the whole cache out of a folder only meant to be opened.
+    
+          So the pattern answers only for directories, and a file's ancestors are
+          asked separately, outermost in, by `decidingRule`.
+        */
+        if (!isDirectory)
+            return false;
+        const bare = trailingSlashOff(rule.pattern);
+        if (rule.anchored || bare.includes("/"))
+            return expression.test(relativePath);
+        const own = relativePath.split("/").pop() ?? relativePath;
+        return expression.test(own);
     }
     if (rule.anchored || rule.pattern.includes("/")) {
         return expression.test(relativePath);

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

@@ -3,13 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LOCAL_EXCLUDE_FILE = exports.IGNORE_FILE = exports.STARTER_IGNORE = exports.CODEROOK_TAIL = exports.CODEROOK_TAIL_HEADING = exports.KEPT_ANYWAY = exports.KEPT_ANYWAY_HEADING = exports.ALSO_LEFT_OUT = exports.ALSO_LEFT_OUT_HEADING = exports.STARTER_MARKER = exports.EVALUATION_FILE_LIMIT = void 0;
+exports.IGNORE_HEADING = exports.KEEP_HEADING = exports.LOCAL_EXCLUDE_FILE = exports.IGNORE_FILE = exports.STARTER_IGNORE = exports.CODEROOK_TAIL = exports.CODEROOK_TAIL_HEADING = exports.KEPT_ANYWAY = exports.KEPT_ANYWAY_HEADING = exports.ALSO_LEFT_OUT = exports.ALSO_LEFT_OUT_HEADING = exports.STARTER_MARKER = exports.EVALUATION_FILE_LIMIT = void 0;
 exports.starterAuthored = starterAuthored;
 exports.missingStarterRules = missingStarterRules;
 exports.missingEngineRules = missingEngineRules;
 exports.isRepository = isRepository;
 exports.migrateRetiredRules = migrateRetiredRules;
 exports.starterFor = starterFor;
+exports.moveRule = moveRule;
 exports.readRules = readRules;
 exports.writeRules = writeRules;
 exports.collectLayers = collectLayers;
@@ -38,6 +39,8 @@ const ignore_templates_js_1 = require("./ignore_templates.js");
 const rules_js_1 = require("./rules.js");
 const secret_patterns_js_1 = require("./secret_patterns.js");
 const run = (0, node_util_1.promisify)(node_child_process_1.execFile);
+/* A code point, so nothing between here and disk can eat the escape. */
+const NEWLINE = String.fromCharCode(10);
 /** Past this the evaluation reports truncated rather than walking forever. */
 exports.EVALUATION_FILE_LIMIT = 300_000;
 async function git(root, ...args) {
@@ -359,9 +362,14 @@ const EXTRA_TEMPLATES = {
 /.creator/`,
     },
 };
-async function starterFor(root) {
+async function starterFor(root, chosen) {
+    /*
+      What somebody said it is beats what the folder looks like.
+      `none` is a real answer — "this is not any of those" — and gets the plain
+      starter rather than being read as "no answer given".
+    */
     const entries = await (0, promises_1.readdir)(root).catch(() => []);
-    const keys = (0, detect_js_1.templatesFor)(entries);
+    const keys = chosen ? (chosen === "none" ? [] : [chosen]) : (0, detect_js_1.templatesFor)(entries);
     if (!keys.length)
         return exports.STARTER_IGNORE;
     const parts = [exports.STARTER_MARKER];
@@ -377,6 +385,106 @@ async function starterFor(root) {
     parts.push("", exports.CODEROOK_TAIL_HEADING, exports.CODEROOK_TAIL);
     return `${parts.join("\n")}\n`;
 }
+/**
+ * Move one path onto the ignore list, or onto the keep list.
+ *
+ * Both are the same act — writing a line into the project's own rules — which
+ * is why they are one function. Keeping means a `!` rule, and a `!` rule only
+ * means anything if it comes after whatever would have taken the file, so the
+ * line goes at the end under its own heading.
+ *
+ * Lifted out of the window's event handler so it can be tested. It could not
+ * be before, which is how a folder came to be written as a rule that also
+ * matched a file of the same name.
+ */
+async function moveRule(root, file, keep) {
+    /*
+      The rules travel with the project. A .gitignore that excluded itself would
+      never reach the website, the command line, or another machine.
+    */
+    if (file === exports.IGNORE_FILE) {
+        throw new Error("The ignore rules have to travel with the project");
+    }
+    const rules = await readRules(root);
+    /*
+      A folder is written as a folder rule.
+  
+      The path arrives without a trailing slash, and writing it as-is makes a
+      rule that also matches a *file* of that name — not what anybody meant by
+      excluding a directory, and a disagreement with what the command line
+      prints for the same folder. Any slash already there is taken off first, so
+      a caller passing a rule rather than a path cannot produce `name//`.
+    */
+    const bare = file.replace(/\/+$/, "");
+    const directory = await (0, promises_1.stat)(node_path_1.default.join(root, bare))
+        .then((entry) => entry.isDirectory())
+        .catch(() => file.endsWith("/"));
+    const target = directory ? `${bare}/` : bare;
+    const line = keep ? `!${target}` : target;
+    /* Saying it twice changes nothing and makes the file harder to read. */
+    const already = ruleLines(rules.shared).some((one) => one === line);
+    if (already)
+        return rules;
+    const heading = keep ? exports.KEEP_HEADING : exports.IGNORE_HEADING;
+    let body = rules.shared.replace(/\s*$/, "");
+    /*
+      A keep inside an excluded folder needs the folder opened first.
+  
+      Rules cannot re-include a file whose directory is excluded — nothing ever
+      looks inside a directory it has already decided to skip, so `!Library/x`
+      under `Library/` does precisely nothing. That is most of what this button
+      is for: rescuing one file out of a cache.
+  
+      The way through is the documented one. `Library/` becomes `Library/**`,
+      which leaves the directory itself includable, and every directory on the
+      way down to the file is named back in. Written here rather than asked of
+      the person, because the alternative is a button that looks like it worked.
+    */
+    if (keep) {
+        /*
+          Which rule is in the way is a question for the matcher, not for string
+          comparison. The line is `/[Ll]ibrary/` — a pattern — and no amount of
+          comparing it against `Library/PackageCache/...` will ever match, which
+          is exactly how the first version of this wrote a negation that did
+          nothing at all.
+        */
+        const parts = target.split("/");
+        for (let depth = 1; depth < parts.length; depth += 1) {
+            const ancestor = parts.slice(0, depth).join("/");
+            const layers = [{ base: "", rules: (0, rules_js_1.parseRules)(body) }];
+            const blocking = (0, rules_js_1.decide)(ancestor, true, layers);
+            if (!blocking || blocking.negated || !blocking.directoryOnly)
+                continue;
+            /*
+              Replaced line by line rather than by pattern. The thing being found
+              is itself a pattern — `/[Ll]ibrary/` — so building a regular
+              expression out of it means escaping a string that is mostly regular
+              expression already, for no gain over comparing the text.
+            */
+            const was = (blocking.anchored ? "/" : "") + blocking.pattern + "/";
+            const opened = (blocking.anchored ? "/" : "") + blocking.pattern + "/**";
+            body = body
+                .split(NEWLINE)
+                .map((one) => (one.trim() === was ? opened : one))
+                .join(NEWLINE);
+            /* Then name every directory between it and the file back in. */
+            for (let at = depth; at < parts.length - 1; at += 1) {
+                const open = "!" + parts.slice(0, at + 1).join("/") + "/";
+                if (!ruleLines(body).includes(open))
+                    body += NEWLINE + open;
+            }
+        }
+    }
+    const shared = body.includes(heading)
+        ? body + NEWLINE + line + NEWLINE
+        : body + NEWLINE + NEWLINE + heading + NEWLINE + line + NEWLINE;
+    const next = { ...rules, shared };
+    await writeRules(root, next);
+    return next;
+}
+/** The two headings a move writes under, so a person can find their own edits. */
+exports.KEEP_HEADING = "# Always include";
+exports.IGNORE_HEADING = "# Left out from the filter screen";
 async function readRules(root) {
     const shared = await readIfPresent(node_path_1.default.join(root, exports.IGNORE_FILE));
     const local = await readIfPresent(node_path_1.default.join(root, exports.LOCAL_EXCLUDE_FILE));

package/package.json

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