@coderook/cli 0.30.2 → 0.31.1

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

@@ -4,6 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (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.ruleTarget = ruleTarget;
+exports.keptTargets = keptTargets;
+exports.withoutOpposites = withoutOpposites;
 exports.starterAuthored = starterAuthored;
 exports.missingStarterRules = missingStarterRules;
 exports.missingEngineRules = missingEngineRules;
@@ -11,6 +14,7 @@ exports.isRepository = isRepository;
 exports.migrateRetiredRules = migrateRetiredRules;
 exports.starterFor = starterFor;
 exports.moveRule = moveRule;
+exports.acceptSuggestions = acceptSuggestions;
 exports.readRules = readRules;
 exports.writeRules = writeRules;
 exports.collectLayers = collectLayers;
@@ -224,6 +228,93 @@ function ruleLines(text) {
         .map((line) => line.trim())
         .filter((line) => line.length > 0 && !line.startsWith("#"));
 }
+/**
+ * What a rule line is about, with the parts that do not change the answer
+ * taken off: the `!`, and a slash at either end.
+ *
+ * `output/`, `/output/` and `!output/` all name the same folder, and deciding
+ * whether two lines disagree has to compare what they name rather than how they
+ * were spelt — the detector writes one spelling, the filter screen another, and
+ * a person a third.
+ */
+function ruleTarget(line) {
+    return line.trim().replace(/^!/, "").replace(/^\/+|\/+$/g, "");
+}
+/** Every thing this file explicitly keeps, by {@link ruleTarget}. */
+function keptTargets(text) {
+    return new Set(ruleLines(text)
+        .filter((line) => line.startsWith("!"))
+        .map(ruleTarget));
+}
+/**
+ * The file without any line that says the opposite of `line` about the same
+ * thing, and without a heading that is left with nothing under it.
+ *
+ * Needed because every writer here appends. A keep has to come after whatever
+ * would take the file, and a new ignore after a keep beats it, so the last
+ * word always wins — but the earlier word stayed in the file. A real project
+ * ended up with `# Always include` / `!output/` directly above
+ * `# Suggested for this folder, and accepted.` / `output/`: correct to a
+ * matcher, and to anybody reading it, a file that says both things.
+ *
+ * Only the exact opposite goes. A broader rule — `*.log` above a kept
+ * `!important.log` — is not about the same thing and is what makes the keep
+ * mean anything, so it is left alone. Everything the removal did not touch is
+ * returned byte for byte, line endings included.
+ */
+function withoutOpposites(body, line) {
+    const target = ruleTarget(line);
+    const keeping = line.trim().startsWith("!");
+    const lines = body.split(NEWLINE);
+    const plain = (at) => (lines[at] ?? "").trim();
+    const isRule = (at) => plain(at).length > 0 && !plain(at).startsWith("#");
+    const drop = new Set();
+    /* Paragraphs are runs of non-blank lines; a heading belongs to its own. */
+    let start = 0;
+    while (start < lines.length) {
+        if (!plain(start)) {
+            start += 1;
+            continue;
+        }
+        let end = start;
+        while (end + 1 < lines.length && plain(end + 1))
+            end += 1;
+        let touched = false;
+        for (let at = start; at <= end; at += 1) {
+            if (!isRule(at))
+                continue;
+            const other = plain(at);
+            if (ruleTarget(other) === target && other.startsWith("!") !== keeping) {
+                drop.add(at);
+                touched = true;
+            }
+        }
+        /*
+          A heading over nothing is a claim about nothing. Dropped with its
+          paragraph, and one blank line beside it, so the file does not gather
+          empty gaps where decisions used to be.
+        */
+        if (touched) {
+            let left = false;
+            for (let at = start; at <= end; at += 1) {
+                if (isRule(at) && !drop.has(at))
+                    left = true;
+            }
+            if (!left) {
+                for (let at = start; at <= end; at += 1)
+                    drop.add(at);
+                if (end + 1 < lines.length && !plain(end + 1))
+                    drop.add(end + 1);
+                else if (start > 0 && !plain(start - 1))
+                    drop.add(start - 1);
+            }
+        }
+        start = end + 1;
+    }
+    if (!drop.size)
+        return body;
+    return lines.filter((_line, at) => !drop.has(at)).join(NEWLINE);
+}
 /**
  * Whether this .gitignore was written by CodeRook rather than by a person.
  *
@@ -255,7 +346,14 @@ function starterAuthored(text) {
  */
 function missingStarterRules(text, reference = exports.STARTER_IGNORE) {
     const present = new Set(ruleLines(text));
-    return ruleLines(reference).filter((line) => !present.has(line));
+    /*
+      Not a line the person has already answered. A starter rule for something
+      this file explicitly keeps is not missing, it was overruled — and offering
+      it back would append it after the keep, where it wins, and take out the
+      very thing somebody said to always include.
+    */
+    const kept = keptTargets(text);
+    return ruleLines(reference).filter((line) => !present.has(line) && (line.startsWith("!") || !kept.has(ruleTarget(line))));
 }
 /**
  * The rules this folder's own file is missing for the kind of project it is.
@@ -423,12 +521,23 @@ async function moveRule(root, file, keep) {
         .catch(() => file.endsWith("/"));
     const target = directory ? `${bare}/` : bare;
     const line = keep ? `!${target}` : target;
+    /*
+      The opposite answer goes first. Moving a folder that was kept onto the
+      ignore list used to add `output/` after `!output/` and leave both, so the
+      file said both things and only the order decided which it meant.
+    */
+    const settled = withoutOpposites(rules.shared, line);
     /* 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 already = ruleLines(settled).some((one) => one === line);
+    if (already) {
+        if (settled === rules.shared)
+            return rules;
+        const next = { ...rules, shared: settled };
+        await writeRules(root, next);
+        return next;
+    }
     const heading = keep ? exports.KEEP_HEADING : exports.IGNORE_HEADING;
-    let body = rules.shared.replace(/\s*$/, "");
+    let body = settled.replace(/\s*$/, "");
     /*
       A keep inside an excluded folder needs the folder opened first.
   
@@ -484,6 +593,85 @@ async function moveRule(root, file, keep) {
     await writeRules(root, next);
     return next;
 }
+/**
+ * Take the suggestions somebody accepted, and write them.
+ *
+ * The accepted patterns and the missing starter lines are written as two
+ * labelled blocks rather than one, because they answer different questions:
+ * one is "this folder holds a cache", the other is "the rules this folder
+ * was set up with have moved on". A person reading the file later should be
+ * able to tell which was which.
+ *
+ * Lifted out of the window's event handler for the same reason `moveRule` was:
+ * inside it nothing could test it, and the defect it had — leaving the keep it
+ * had just overruled in the file — was found by a person reading their own
+ * .gitignore rather than by anything here.
+ */
+async function acceptSuggestions(root, patterns, starter) {
+    const rules = await readRules(root);
+    /*
+      A suggestion somebody accepts is their answer about that folder, and it
+      replaces any earlier one. A real project kept `# Always include` /
+      `!output/` directly above the `output/` the size prompt had just
+      written: right to a matcher, because the later line wins, and to
+      anybody reading the file a flat contradiction.
+  
+      Starter lines are the other way round. Nobody chose those one by one,
+      so they never overrule a keep — `missingStarterRules` already leaves
+      out anything kept, and this skips it again in case the file changed
+      between the prompt being drawn and the button being pressed.
+    */
+    let settled = rules.shared;
+    for (const pattern of patterns)
+        settled = withoutOpposites(settled, pattern);
+    const keptNow = keptTargets(settled);
+    starter = starter.filter((line) => line.startsWith("!") || !keptNow.has(ruleTarget(line)));
+    /*
+      Added to, never stacked.
+  
+      The first version of this appended a fresh block every time, so a
+      folder that grew a second cache later ended up with two identical
+      headings and the same rule written twice — the same fault the template
+      appender had already been fixed for. Lines that are already in the file
+      are skipped, and a heading that is already there is extended under
+      itself rather than repeated.
+    */
+    const has = new Set(settled
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean));
+    const add = (heading, lines) => {
+        const wanted = lines.filter((line) => !has.has(line.trim()));
+        if (!wanted.length)
+            return "";
+        for (const line of wanted)
+            has.add(line.trim());
+        return [heading, ...wanted].join("\n");
+    };
+    let shared = settled.replace(/\s*$/, "");
+    for (const [heading, lines] of [
+        [detect_js_1.SUGGESTED_HEADING, patterns],
+        [detect_js_1.STARTER_TOPUP_HEADING, starter],
+    ]) {
+        const block = add(heading, lines);
+        if (!block)
+            continue;
+        const at = shared.indexOf(heading);
+        if (at === -1) {
+            shared = shared ? `${shared}\n\n${block}` : block;
+            continue;
+        }
+        /* Extend the block that is already there, directly under its heading. */
+        const after = at + heading.length;
+        shared =
+            shared.slice(0, after) +
+                block.slice(heading.length) +
+                shared.slice(after);
+    }
+    const next = { ...rules, shared: `${shared}\n` };
+    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";

package/dist/desktop-app/src/shared/compression_policy.js

@@ -6,16 +6,21 @@
  * make the same decision for the same object.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WORTHWHILE_COMPRESSION_RATIO = exports.SMALLEST_WORTH_COMPRESSING = void 0;
+exports.GZIP_KEEP_RATE = exports.GZIP_REVIEW_EVERY = exports.SAMPLE_BYTES = exports.WORTHWHILE_COMPRESSION_RATIO = exports.SMALLEST_WORTH_COMPRESSING = void 0;
 exports.looksCompressed = looksCompressed;
 exports.shouldTryGzip = shouldTryGzip;
+exports.worthSampling = worthSampling;
+exports.sampleWindows = sampleWindows;
+exports.sampleSaysDoNotBother = sampleSaysDoNotBother;
 exports.gzipIsWorthKeeping = gzipIsWorthKeeping;
+exports.freshGzipVerdict = freshGzipVerdict;
+exports.noteChunkOutcome = noteChunkOutcome;
 const ALREADY_COMPRESSED = new Set([
     ".7z", ".aac", ".avi", ".br", ".bz2", ".cbx", ".docx", ".flac", ".gif",
-    ".gz", ".heic", ".jpeg", ".jpg", ".jxl", ".m4a", ".m4v", ".mkv", ".mov",
-    ".mp3", ".mp4", ".odp", ".ods", ".odt", ".ogg", ".opus", ".pdf", ".png",
-    ".pptx", ".rar", ".safetensors", ".webm", ".webp", ".xlsx", ".xz", ".zip",
-    ".zst",
+    ".gguf", ".gz", ".heic", ".jpeg", ".jpg", ".jxl", ".m4a", ".m4v", ".mkv",
+    ".mov", ".mp3", ".mp4", ".odp", ".ods", ".odt", ".ogg", ".onnx", ".opus",
+    ".pdf", ".png", ".pptx", ".rar", ".safetensors", ".webm", ".webp", ".xlsx",
+    ".xz", ".zip", ".zst",
 ]);
 exports.SMALLEST_WORTH_COMPRESSING = 4 * 1024;
 exports.WORTHWHILE_COMPRESSION_RATIO = 0.95;
@@ -30,6 +35,118 @@ function shouldTryGzip(relativePath, sourceBytes, allowGzip) {
         sourceBytes >= exports.SMALLEST_WORTH_COMPRESSING &&
         !looksCompressed(relativePath));
 }
+/**
+ * Above this, find out by trying a little before trying all of it.
+ *
+ * The extension list above is a guess, and the cost of a miss is unbounded.
+ * A project of thirteen `.gguf` model weights — 10.6 GB, an extension nothing
+ * here had heard of — was deflated at level 6, in full, to discover that it
+ * compressed by 3.3% and the result had to be thrown away. That was 87% of the
+ * time the save spent before it sent a single byte, and the save runs the whole
+ * pipeline twice, so it was paid twice. The project never finished saving.
+ *
+ * A quarter of a megabyte is eight times deflate's window, which is enough for
+ * the answer to mean something, and 6% of a maximum chunk, which is what makes
+ * a wrong guess in the list above cheap instead of ruinous.
+ */
+exports.SAMPLE_BYTES = 256 * 1024;
+/** Whether a piece is big enough that guessing wrong on it is worth avoiding. */
+function worthSampling(sourceBytes) {
+    /*
+      Only where the sample is a real saving over the whole thing. Sampling a
+      300 KB file costs most of what compressing it would and answers a question
+      that was about to be answered properly anyway.
+    */
+    return sourceBytes >= exports.SAMPLE_BYTES * 8;
+}
+/**
+ * Where to look, for a piece of this size.
+ *
+ * Two windows, not one, because a single window at the front judges the whole
+ * file by its header. A container with a text manifest and an incompressible
+ * payload would be compressed in full on the strength of its first block —
+ * which is the waste this exists to avoid — and one shaped the other way round
+ * would be abandoned despite compressing. The middle disagrees with the front
+ * in both cases, and either window arguing for compression is enough.
+ *
+ * Shared rather than chosen per caller so Desktop and the browser make the same
+ * decision about the same bytes, which is the point of this module.
+ */
+function sampleWindows(sourceBytes) {
+    return [
+        { at: 0, size: exports.SAMPLE_BYTES },
+        { at: Math.floor(sourceBytes / 2), size: exports.SAMPLE_BYTES },
+    ];
+}
+/**
+ * Whether a window that compressed this little argues against the whole piece.
+ *
+ * Deliberately the same test {@link gzipIsWorthKeeping} applies at the end: the
+ * sample is an estimate of that answer, so estimating it against a softer
+ * threshold was the bug in the first attempt at this. A window that saved 3%
+ * would have passed a "did it compress at all" test, committed the file to a
+ * full deflate, and then had the result discarded for saving 3% — which is
+ * exactly the several minutes this was meant to stop spending.
+ *
+ * Getting it wrong costs a little space and never a wrong result: an object's
+ * identity is the digest of its original bytes, whatever travels.
+ */
+function sampleSaysDoNotBother(sampleBytes, compressedSampleBytes) {
+    return !gzipIsWorthKeeping(sampleBytes, compressedSampleBytes);
+}
 function gzipIsWorthKeeping(sourceBytes, compressedBytes) {
     return compressedBytes < sourceBytes * exports.WORTHWHILE_COMPRESSION_RATIO;
 }
+/** How often a chunked file's compression is reviewed. */
+exports.GZIP_REVIEW_EVERY = 16;
+/** The fraction of reviewed chunks that must have kept gzip, as its divisor. */
+exports.GZIP_KEEP_RATE = 4;
+/** A file nothing is known about yet. */
+function freshGzipVerdict() {
+    return { allowed: true, tried: 0, kept: 0, chunks: 0 };
+}
+/**
+ * Record how one chunk turned out, and decide whether to keep trying.
+ *
+ * A large file is not one object, it is hundreds: a 1 GB file at a 1 MB target
+ * is a thousand chunks, each compressed and judged on its own. So the guard
+ * that stops wasted work on a whole *file* cannot live in the piece — sampling
+ * inside a 1 MB chunk saves a fraction of a job that was already small.
+ *
+ * Thirteen `.gguf` model weights, 10.6 GB, went chunk by chunk through deflate
+ * at level 6. That was 87% of the time the save spent before it sent a byte,
+ * and a save runs the whole pipeline twice, so it was spent twice. The project
+ * never finished saving.
+ *
+ * Measured on one of those files, 24 of 208 chunks did clear the 5% threshold
+ * and keep their compression — so "give up once nothing has compressed" never
+ * fired, which was the first attempt at this. What those 24 chunks saved was
+ * 0.7% of the file. The question is a rate, not an existence.
+ *
+ * Each window is judged on itself, and the count starts again after every
+ * review. Judging the file cumulatively instead lets a compressible opening buy
+ * an arbitrarily long incompressible tail: a run of 256 chunks that compressed
+ * would carry the next thousand that did not, which is the cost this exists to
+ * bound. Starting again means the work wasted after a file changes character is
+ * never more than one window, whereever in the file that happens.
+ *
+ * Being wrong costs a little storage and never a wrong result: an object's
+ * identity is the digest of its original bytes, whatever those bytes travelled
+ * as, so chunks already sent compressed stay exactly as valid as before.
+ */
+function noteChunkOutcome(verdict, keptGzip) {
+    if (!verdict.allowed)
+        return;
+    verdict.chunks += 1;
+    verdict.tried += 1;
+    if (keptGzip)
+        verdict.kept += 1;
+    if (verdict.tried < exports.GZIP_REVIEW_EVERY)
+        return;
+    if (verdict.kept * exports.GZIP_KEEP_RATE < verdict.tried) {
+        verdict.allowed = false;
+        return;
+    }
+    verdict.tried = 0;
+    verdict.kept = 0;
+}

package/dist/desktop-app/src/shared/format.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Number formatting in the design's phrasing, where both sides can reach it.
+ *
+ * Byte sizes started out in the renderer, because only the renderer showed
+ * them. Then the detector began writing a person-facing sentence of its own —
+ * "10.7 GB of 10.8 GB, and no source in it" — and a second formatter in the
+ * main process would have meant the same folder described two ways in two
+ * places. The renderer re-exports these, so nothing that already imports from
+ * `renderer/format` had to change.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBytes = formatBytes;
+exports.formatCount = formatCount;
+/** Short byte text: "812 MB", "3.6 GB", "24 GB". A fraction only when there is one. */
+function formatBytes(value) {
+    let size = value;
+    for (const unit of ["B", "KB", "MB", "GB", "TB"]) {
+        if (size < 1024 || unit === "TB") {
+            if (unit === "B")
+                return `${Math.round(size)} B`;
+            const text = size >= 100 ? size.toFixed(0) : size.toFixed(1);
+            return `${text.endsWith(".0") ? text.slice(0, -2) : text} ${unit}`;
+        }
+        size /= 1024;
+    }
+    return `${value} B`;
+}
+function formatCount(value) {
+    return value.toLocaleString("en-US");
+}

package/package.json

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