@coderook/cli 0.31.7 → 0.31.8

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

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

@@ -19,6 +19,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const faults_js_1 = require("./faults.js");
 const identify_js_1 = require("./identify.js");
 const worktree_js_1 = require("./worktree.js");
+const rules_js_1 = require("./rules.js");
 const publish_name_js_1 = require("./publish_name.js");
 const compress_js_1 = require("./compress.js");
 const compression_policy_js_1 = require("../shared/compression_policy.js");
@@ -142,6 +143,8 @@ class Uploader {
      */
     plannedLayouts = new Map();
     plannedQuote = null;
+    /** Files sent only because git tracks them; named in the save so the service allows them. */
+    trackedByGit = [];
     /*
       Digests worked out while planning, so sending does not work them out again.
   
@@ -407,6 +410,13 @@ class Uploader {
         const rules = request.allowIgnored
             ? { shared: "", local: "" }
             : await (0, worktree_js_1.readRules)(request.localPath);
+        /*
+          What the survey keeps only because git tracks it, named for the
+          service: its own check of the rules would otherwise refuse them as a
+          rule this client forgot. See gitTracked.
+        */
+        this.trackedByGit = [];
+        const tracked = request.allowIgnored ? null : await (0, worktree_js_1.gitTracked)(request.localPath);
         /*
           Surveyed, not listed.
     
@@ -443,6 +453,12 @@ class Uploader {
             percent: 6,
             bytesPerSecond: 0,
         })));
+        if (tracked) {
+            const layers = await (0, worktree_js_1.collectLayers)(request.localPath, rules);
+            this.trackedByGit = everything
+                .map((file) => file.path)
+                .filter((file) => tracked.files.has(file) && (0, rules_js_1.excludes)(file, false, layers));
+        }
         (0, profile_js_1.counted)("files surveyed", everything.length);
         const unticked = new Set(request.excluded ?? []);
         const ticked = request.excluded
@@ -854,6 +870,7 @@ class Uploader {
                     : { expectedHeadVersionId: request.expectedHeadVersionId }),
                 ...(request.track ? { track: request.track } : {}),
                 ...(request.allowIgnored ? { allowIgnored: true } : {}),
+                ...(this.trackedByGit.length ? { trackedByGit: this.trackedByGit } : {}),
                 ...(request.allowSecrets ? { allowSecrets: true } : {}),
                 ...(request.linesAdded === undefined ? {} : { linesAdded: request.linesAdded }),
                 ...(request.linesRemoved === undefined

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

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-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.IGNORE_HEADING = exports.KEEP_HEADING = exports.TRACKED_BY_GIT = 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.ruleTarget = ruleTarget;
 exports.keptTargets = keptTargets;
 exports.withoutOpposites = withoutOpposites;
@@ -11,6 +11,7 @@ exports.starterAuthored = starterAuthored;
 exports.missingStarterRules = missingStarterRules;
 exports.missingEngineRules = missingEngineRules;
 exports.isRepository = isRepository;
+exports.gitTracked = gitTracked;
 exports.migrateRetiredRules = migrateRetiredRules;
 exports.starterFor = starterFor;
 exports.moveRule = moveRule;
@@ -404,6 +405,39 @@ async function isRepository(root) {
         return false;
     }
 }
+/** The label a file kept because git tracks it carries, where a rule would be. */
+exports.TRACKED_BY_GIT = "(tracked by git)";
+/**
+ * The files git tracks here, which an ignore rule does not take away.
+ *
+ * Git applies .gitignore only to files it does not track yet. Once a file is
+ * committed, a rule written later — or a broad one like `storage/` that also
+ * matches a source folder three levels down — leaves it exactly where it is.
+ * This applied the rules to everything, so a project whose .gitignore said
+ * `storage/` arrived without `internal/storage/*.go`: in git, whole; on
+ * CodeRook, missing the six files that made it build.
+ *
+ * Null when the folder is not a repository, or git cannot be asked — then the
+ * rules alone decide, as they always did.
+ */
+async function gitTracked(root) {
+    if (!(await isRepository(root)))
+        return null;
+    const listed = await git(root, "ls-files", "-z");
+    if (listed === null)
+        return null;
+    const files = new Set(listed.split(String.fromCharCode(0)).filter(Boolean));
+    const folders = new Set();
+    for (const file of files) {
+        for (let cut = file.lastIndexOf("/"); cut > 0; cut = file.lastIndexOf("/", cut - 1)) {
+            const folder = file.slice(0, cut);
+            if (folders.has(folder))
+                break;
+            folders.add(folder);
+        }
+    }
+    return { files, folders };
+}
 /**
  * Convert the rules an earlier build wrote into one .gitignore.
  *
@@ -519,6 +553,15 @@ async function moveRule(root, file, keep) {
     const directory = await (0, promises_1.stat)(node_path_1.default.join(root, bare))
         .then((entry) => entry.isDirectory())
         .catch(() => file.endsWith("/"));
+    /*
+      A file git tracks cannot be ignored by a rule — git keeps it, and so does
+      this. Writing the rule anyway would look like it worked and change
+      nothing, so it is refused with what would actually leave it out.
+    */
+    if (!keep && !directory && (await gitTracked(root))?.files.has(bare)) {
+        throw new Error(`git tracks ${bare}, so a rule cannot leave it out. Untick it for one ` +
+            `save, or stop git tracking it: git rm --cached "${bare}"`);
+    }
     const target = directory ? `${bare}/` : bare;
     const line = keep ? `!${target}` : target;
     /*
@@ -885,6 +928,8 @@ stats,
 /** Filled with how much of the folder the cap allowed through. */
 outcome) {
     const layers = await collectLayers(root, rules);
+    /* What git already tracks goes up whatever a rule says; see gitTracked. */
+    const tracked = await gitTracked(root);
     const files = [];
     const present = new Set();
     const pending = [root];
@@ -926,7 +971,9 @@ outcome) {
                 // Skipping an excluded directory outright is what keeps this fast,
                 // but a `!` rule exists to rescue what is inside one, so the subtree
                 // is only skipped when no negation could reach into it.
-                if ((0, rules_js_1.excludes)(relative, true, layers) && !(0, rules_js_1.negationReachesInto)(relative, layers)) {
+                if ((0, rules_js_1.excludes)(relative, true, layers) &&
+                    !(0, rules_js_1.negationReachesInto)(relative, layers) &&
+                    !tracked?.folders.has(relative)) {
                     continue;
                 }
                 pending.push(full);
@@ -934,7 +981,7 @@ outcome) {
             }
             if (!entry.isFile())
                 continue;
-            if ((0, rules_js_1.excludes)(relative, false, layers))
+            if ((0, rules_js_1.excludes)(relative, false, layers) && !tracked?.files.has(relative))
                 continue;
             wanted.push({ full, relative });
         }
@@ -1060,6 +1107,7 @@ async function surveyFiles(root, rules,
 */
 onFound) {
     const layers = await collectLayers(root, rules);
+    const tracked = await gitTracked(root);
     const found = [];
     /*
       A level at a time, eight in flight.
@@ -1094,7 +1142,8 @@ onFound) {
                     const relative = node_path_1.default.relative(root, full).split(node_path_1.default.sep).join("/");
                     if (entry.isDirectory()) {
                         if ((0, rules_js_1.excludes)(relative, true, layers) &&
-                            !(0, rules_js_1.negationReachesInto)(relative, layers)) {
+                            !(0, rules_js_1.negationReachesInto)(relative, layers) &&
+                            !tracked?.folders.has(relative)) {
                             continue;
                         }
                         next.push(full);
@@ -1102,7 +1151,7 @@ onFound) {
                     }
                     if (!entry.isFile())
                         continue;
-                    if ((0, rules_js_1.excludes)(relative, false, layers))
+                    if ((0, rules_js_1.excludes)(relative, false, layers) && !tracked?.files.has(relative))
                         continue;
                     here.push({ full, relative });
                 }
@@ -1408,6 +1457,7 @@ function relativeTo(root, full) {
  */
 async function evaluateRules(root, rules, options = {}) {
     const layers = await collectLayers(root, rules);
+    const tracked = await gitTracked(root);
     const impactBytes = new Map();
     const impactFiles = new Map();
     const excluded = [];
@@ -1449,6 +1499,18 @@ async function evaluateRules(root, rules, options = {}) {
             });
             continue;
         }
+        if (rule && tracked?.files.has(relative)) {
+            /*
+              A rule matches it, and git tracks it, so it goes up regardless — and
+              is listed with what kept it, beside the files a `!` rule keeps.
+            */
+            keptFiles += 1;
+            keptBytes += size;
+            uploadFiles += 1;
+            uploadBytes += size;
+            excluded.push({ path: relative, bytes: size, rule: exports.TRACKED_BY_GIT, forceKept: true });
+            continue;
+        }
         if (rule) {
             skippedFiles += 1;
             skippedBytes += size;

package/package.json

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