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

package/dist/cli/src/api.js

@@ -18,6 +18,8 @@ exports.cancelMerge = cancelMerge;
 exports.aiAccess = aiAccess;
 exports.setAiAccess = setAiAccess;
 exports.updateProject = updateProject;
+exports.compareVersions = compareVersions;
+exports.fileTextAt = fileTextAt;
 exports.versions = versions;
 exports.markRelease = markRelease;
 exports.issues = issues;
@@ -313,7 +315,50 @@ async function updateProject(repositoryId, change) {
         body: change,
     });
 }
-/** Every saved version of a project, newest first. */
+/**
+ * What changed between two saved versions.
+ *
+ * The service answers this from the stored trees, so an untouched folder deep
+ * in the project costs nothing: identical subtree ids short-circuit before
+ * either side is listed. That is why this asks the service rather than
+ * fetching both file lists and comparing them here — on a project of twenty
+ * thousand files the difference is one request against two very large ones.
+ */
+async function compareVersions(repositoryId, from, to) {
+    const body = await call(`/v1/repositories/${repositoryId}/compare` +
+        `?from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`);
+    return body.changes ?? [];
+}
+/**
+ * One file's contents at one version, as text.
+ *
+ * Returns null for anything that is not text — a diff of a PNG is noise, and
+ * deciding that here keeps every caller from having to guess. The byte cap is
+ * the same reasoning: past it a file is data, and a line-by-line comparison of
+ * data is neither readable nor quick.
+ */
+async function fileTextAt(repositoryId, versionId, filePath, mostBytes = 2 * 1024 * 1024) {
+    const token = await (0, config_js_1.loadToken)();
+    if (!token)
+        throw new Error("Not signed in. Run: cbx sign-in");
+    const route = `${(0, config_js_1.apiOrigin)()}/v1/repositories/${repositoryId}` +
+        `/versions/${versionId}/file?path=${encodeURIComponent(filePath)}`;
+    const response = await fetch(route, {
+        headers: {
+            authorization: `Bearer ${token}`,
+            "user-agent": "CodeRook-CLI/0.1",
+            ...(0, identify_js_1.clientHeaders)(),
+            range: `bytes=0-${mostBytes - 1}`,
+        },
+    });
+    if (!response.ok)
+        return null;
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    /* A NUL byte is the cheapest reliable sign that this is not text. */
+    if (bytes.includes(0))
+        return null;
+    return new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+}
 async function versions(repositoryId) {
     const body = await call(`/v1/repositories/${encodeURIComponent(repositoryId)}/versions`);
     return (body.versions ?? []).map((row) => ({

package/dist/cli/src/cli.js

@@ -35,11 +35,13 @@ 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");
 const version_commands_js_1 = require("./version_commands.js");
 const identify_js_1 = require("../../desktop-app/src/main/identify.js");
+const diff_command_js_1 = require("./diff_command.js");
 const profile_js_1 = require("../../desktop-app/src/main/profile.js");
 const detect_js_1 = require("../../desktop-app/src/main/detect.js");
 const cbx_js_1 = require("../../desktop-app/src/main/cbx.js");
@@ -348,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})`)}`
@@ -369,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;
 }
 /**
@@ -1310,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;
     }
@@ -1722,6 +1809,30 @@ const SPECS = [
         ],
         run: commandSubmit,
     },
+    {
+        name: "diff",
+        aliases: ["changes"],
+        group: "Working with a folder",
+        summary: "what changed, line by line",
+        usage: "diff [from] [to]",
+        detail: "With nothing after it, compares this folder against the version it is\n" +
+            "on. With one version, compares this folder against that one. With two,\n" +
+            "compares two saved versions — which the service answers from its own\n" +
+            "stored trees, so an untouched corner of a large project costs nothing.\n\n" +
+            "A version can be given as a number, as v12, or by the name it was\n" +
+            "released under.",
+        options: [
+            { flags: "--name-only", description: "list the files and not their lines" },
+            { flags: "--path <text>", description: "only paths containing this" },
+            {
+                flags: "--context <n>",
+                description: "lines of context around a change (default 3)",
+            },
+            { flags: "--project <name>", description: "which project" },
+        ],
+        examples: ["cbx diff", "cbx diff 12", "cbx diff 11 12 --name-only"],
+        run: diff_command_js_1.commandDiff,
+    },
     {
         name: "unlink",
         group: "Working with a folder",

package/dist/cli/src/diff_command.js

@@ -0,0 +1,218 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandDiff = commandDiff;
+/**
+ * What changed, from the terminal.
+ *
+ * This was the one central thing the command line could not do. The service
+ * has been able to compare two versions since the beginning — GET /compare
+ * answers it from the stored trees — and nothing called the route. Meanwhile
+ * the desktop application's diff shells out to `git diff`, so on a project
+ * that is not a git repository the feature is silently absent, which is an odd
+ * thing for a version host to depend on.
+ *
+ * So this reads the service's own answer and renders it. Two questions, which
+ * people mean at different times:
+ *
+ *   cbx diff            what have I changed since the version I am on
+ *   cbx diff 12         the same, against version 12
+ *   cbx diff 11 12      what changed between two saved versions
+ */
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = __importDefault(require("node:process"));
+const api_js_1 = require("./api.js");
+const config_js_1 = require("./config.js");
+const project_commands_js_1 = require("./project_commands.js");
+const merge_diff_js_1 = require("../../desktop-app/src/shared/merge_diff.js");
+const worktree_js_1 = require("../../desktop-app/src/main/worktree.js");
+/*
+  Built rather than typed, so the escape character never sits literally in the
+  source. The other command files spell theirs out; this reads the same on a
+  terminal and survives being copied through a tool that eats control bytes.
+*/
+const ESC = String.fromCharCode(27);
+const paint = (code) => (value) => `${ESC}[${code}m${value}${ESC}[0m`;
+const dim = paint("2");
+const bold = paint("1");
+const red = paint("31");
+const green = paint("32");
+const accent = paint("33");
+/*
+  The line comparison builds a table of one side's lines against the other's,
+  which is exact and quadratic. On a conflicted file — what it was written for
+  — that is a few hundred kilobytes. On this repository's own eighteen-thousand
+  line runtime it would be gigabytes, so past this a file is reported as
+  changed without its lines. Saying so beats both wedging the terminal and
+  printing a heuristic diff that quietly invents a change.
+*/
+const MOST_LINES_COMPARED = 4_000;
+/** How a change reads at a glance. */
+const MARK = {
+    added: green("+"),
+    removed: red("-"),
+    changed: accent("~"),
+};
+/** Print one file's lines, folded to the interesting parts. */
+function printHunks(before, after, context) {
+    const left = (0, merge_diff_js_1.linesOf)(before);
+    const right = (0, merge_diff_js_1.linesOf)(after);
+    if (left.length > MOST_LINES_COMPARED || right.length > MOST_LINES_COMPARED) {
+        console.log(dim(`    ${Math.max(left.length, right.length).toLocaleString()} lines — ` +
+            `too large to compare line by line`));
+        return;
+    }
+    for (const chunk of (0, merge_diff_js_1.foldUnchanged)((0, merge_diff_js_1.diffLines)(before, after), context)) {
+        if (chunk.kind === "gap") {
+            console.log(dim(`    ... ${chunk.skipped} unchanged`));
+            continue;
+        }
+        for (const line of chunk.lines) {
+            const at = String(line.candidateLine ?? line.targetLine ?? "").padStart(5);
+            if (line.side === "same")
+                console.log(dim(`${at}   ${line.text}`));
+            else if (line.side === "candidate")
+                console.log(`${dim(at)} ${green("+")} ${green(line.text)}`);
+            else
+                console.log(`${dim(at)} ${red("-")} ${red(line.text)}`);
+        }
+    }
+}
+/** Resolve `12`, `v12` or a version's name against the newest-first list. */
+function versionBy(list, reference) {
+    const bare = reference.replace(/^v/i, "");
+    if (/^[0-9]+$/.test(bare)) {
+        const found = list.find((one) => one.sequence === Number(bare));
+        return found ? { id: found.id, sequence: found.sequence } : null;
+    }
+    const named = list.find((one) => (one.name ?? "").toLowerCase() === reference.toLowerCase());
+    return named ? { id: named.id, sequence: named.sequence } : null;
+}
+/** Whether these bytes are something a line comparison can speak about. */
+function isText(value) {
+    return !value.includes(String.fromCharCode(0));
+}
+async function commandDiff(parsed) {
+    const nameOnly = parsed.flags.has("name-only");
+    const context = Number(parsed.flags.get("context") ?? 3) || 3;
+    const only = parsed.flags.get("path");
+    const named = parsed.flags.get("project");
+    const project = await (0, project_commands_js_1.resolveProject)(typeof named === "string" ? named : undefined);
+    if (!project)
+        return 1;
+    const list = await (0, api_js_1.versions)(project.id);
+    if (!list.length) {
+        console.log("Nothing saved yet, so there is nothing to compare.");
+        return 0;
+    }
+    const [first, second] = parsed.positional;
+    /*
+      Two saved versions, compared by the service. That is the whole point of
+      asking it rather than fetching both file lists: it walks the stored trees
+      and skips any subtree whose id has not moved, so an untouched corner of a
+      twenty-thousand-file project costs nothing.
+    */
+    if (first && second) {
+        const from = versionBy(list, first);
+        const to = versionBy(list, second);
+        if (!from || !to) {
+            console.error(red(`No such version: ${from ? second : first}`));
+            return 1;
+        }
+        const changes = (await (0, api_js_1.compareVersions)(project.id, from.id, to.id))
+            .filter((change) => !only || change.path.includes(String(only)))
+            .sort((left, right) => left.path.localeCompare(right.path));
+        console.log(`${bold(project.slug)} ${dim(`v${from.sequence} -> v${to.sequence}`)}`);
+        if (!changes.length) {
+            console.log("Nothing differs between them.");
+            return 0;
+        }
+        for (const change of changes) {
+            console.log(`${MARK[change.kind]} ${change.path}`);
+            if (nameOnly || change.kind !== "changed")
+                continue;
+            const [before, after] = await Promise.all([
+                (0, api_js_1.fileTextAt)(project.id, from.id, change.path),
+                (0, api_js_1.fileTextAt)(project.id, to.id, change.path),
+            ]);
+            if (before === null || after === null) {
+                console.log(dim("    not text"));
+                continue;
+            }
+            printHunks(before, after, context);
+        }
+        const many = changes.length === 1 ? "" : "s";
+        console.log(dim(`\n${changes.length} file${many} differ${many ? "" : "s"}`));
+        return 0;
+    }
+    /*
+      This folder against a saved version — the question somebody has open in
+      front of them, and the reason `cbx status` was never enough on its own: it
+      says which files changed and never what changed inside them.
+    */
+    const link = await (0, config_js_1.readLink)(node_process_1.default.cwd());
+    if (!link) {
+        console.error(red("This folder is not linked to a project, so there is no local side."));
+        return 1;
+    }
+    const against = first
+        ? versionBy(list, first)
+        : { id: link.baseVersionId ?? list[0].id, sequence: link.sequence };
+    if (!against) {
+        console.error(red(`No such version: ${first}`));
+        return 1;
+    }
+    const folder = node_process_1.default.cwd();
+    const rules = await (0, worktree_js_1.readRules)(folder);
+    /*
+      Which files differ is decided here, from digests, before anything is
+      fetched.
+  
+      The first version of this compared contents, which meant downloading every
+      file in the project to find out which ones had moved — on this repository
+      that is eleven hundred requests to report a handful of edits. `changedFiles`
+      already answers the question locally and keeps a digest cache while it does
+      it, so the service is asked only for the files that actually differ.
+    */
+    const saved = link.manifest ?? {};
+    const changed = (await (0, worktree_js_1.changedFiles)(folder, rules, new Map(Object.entries(saved)), "synchronize"))
+        .filter((one) => !only || one.path.includes(String(only)))
+        .sort((left, right) => left.path.localeCompare(right.path));
+    console.log(`${bold(node_path_1.default.basename(folder))} ${dim(`this folder -> v${against.sequence}`)}`);
+    let differing = 0;
+    for (const one of changed) {
+        const wasSaved = Object.prototype.hasOwnProperty.call(saved, one.path);
+        const kind = one.deleted
+            ? "removed"
+            : wasSaved
+                ? "changed"
+                : "added";
+        differing += 1;
+        console.log(`${MARK[kind]} ${one.path}`);
+        if (nameOnly || kind !== "changed")
+            continue;
+        if (one.binary) {
+            console.log(dim("    not text"));
+            continue;
+        }
+        const [before, after] = await Promise.all([
+            (0, api_js_1.fileTextAt)(project.id, against.id, one.path),
+            (0, promises_1.readFile)(node_path_1.default.join(folder, one.path), "utf8").catch(() => null),
+        ]);
+        if (before === null || after === null || !isText(after)) {
+            console.log(dim("    not text"));
+            continue;
+        }
+        printHunks(before, after, context);
+    }
+    if (!differing) {
+        console.log("This folder matches the saved version.");
+        return 0;
+    }
+    const many = differing === 1 ? "" : "s";
+    console.log(dim(`\n${differing} file${many} differ${many ? "" : "s"}`));
+    return 0;
+}

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

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": 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;
@@ -121,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) {
@@ -267,12 +346,19 @@ function suggestBulkDirectories(files) {
  * looking: the detector proposes, this records a decision, and the two are
  * only connected by somebody choosing.
  */
+/**
+ * The one heading under which accepted suggestions are recorded.
+ *
+ * Exported because three places wrote three different sentences for the same
+ * idea, and a .gitignore could end up carrying all of them. The tick screen
+ * keeps its own CHOSEN_HEADING: that block is a different statement, and it is
+ * rewritten wholesale where this one is added to.
+ */
+exports.SUGGESTED_HEADING = "# Suggested for this folder, and accepted.";
+/** And the one under which the starter rules are brought up to date. */
+exports.STARTER_TOPUP_HEADING = "# Added when the starter rules were brought up to date.";
 function rulesFromSuggestions(accepted) {
     if (!accepted.length)
         return "";
-    return [
-        "# Suggested when this folder was added, and accepted.",
-        ...accepted.map((one) => one.pattern),
-        "",
-    ].join("\n");
+    return [exports.SUGGESTED_HEADING, ...accepted.map((one) => one.pattern), ""].join("\n");
 }

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);
 }
 /**