@coderook/cli 0.29.5 → 0.30.1

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

@@ -3,11 +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.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;
@@ -31,9 +34,13 @@ const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const node_util_1 = require("node:util");
+const detect_js_1 = require("./detect.js");
+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) {
@@ -57,6 +64,73 @@ async function git(root, ...args) {
  * secrets are warned about instead (docs/UPLOAD_POLICY.md).
  */
 exports.STARTER_MARKER = "# CodeRook starter rules — edit freely below";
+/**
+ * What github/gitignore has no template for, kept beside whichever it picks.
+ *
+ * A browser or Electron profile left in a project folder holds files another
+ * program keeps open — a LOCK that cannot be read while it runs will stop a
+ * save outright — and none of it is the work. No language template mentions
+ * them, because no language puts them there.
+ */
+/**
+ * Where CodeRook and git want different things, and CodeRook wins.
+ *
+ * A .gitignore is written for a repository, where an archive is something you
+ * could rebuild from the source beside it, so github/gitignore leaves
+ * `*.unitypackage` out. CodeRook is not that. A version here is meant to be
+ * the whole of a folder, and an asset-store package sitting inside `Assets`
+ * is not rebuildable from anything in the project — it is a thing somebody
+ * bought, and on the other machine it would simply be gone.
+ *
+ * Measured on a real project: forty-two of them, one per render pipeline and
+ * Unity version, all inside `Assets`. Exactly the kind of "missing stuff"
+ * that a save is supposed to make impossible.
+ *
+ * The `.meta` line guards against this application's own layering, and
+ * nothing more. Unity's template keeps metas; `*.meta` is build output to
+ * Visual Studio and its template says so, and a Unity folder has a .sln in it
+ * because Unity writes one. Placed after every template so it is the last
+ * word among the rules we stack — it cannot, and should not, outrank a line
+ * somebody writes in their own file afterwards.
+ */
+/**
+ * Caches and weights the chosen template has no reason to mention.
+ *
+ * A github/gitignore template is written for a repository on that platform,
+ * not for every way somebody lays a project out. Xcode is the plain case:
+ * DerivedData normally sits in your home folder, so GitHub never mentions it,
+ * and a project configured to keep it alongside the source sent seven
+ * thousand files of build output that the old generic list had caught.
+ *
+ * Anchored, every one of them. `models/` unanchored is what used to reach
+ * into a Unity project's `Assets/Art/models`, which is the whole reason any
+ * of this was looked at.
+ */
+exports.ALSO_LEFT_OUT_HEADING = "# Also left out by CodeRook: caches and weights no template mentions.";
+exports.ALSO_LEFT_OUT = `/DerivedData/
+/models/
+*.safetensors
+*.ckpt
+*.pt
+*.pth`;
+exports.KEPT_ANYWAY_HEADING = "# Kept even though the template leaves them out: not rebuildable from this folder.";
+exports.KEPT_ANYWAY = `!/[Aa]ssets/**/*.meta
+!/[Aa]ssets/**/*.unitypackage
+!/[Aa]ssets/**/*.unitypackage.meta`;
+exports.CODEROOK_TAIL_HEADING = "# Left out by CodeRook, whatever the project is.";
+exports.CODEROOK_TAIL = `IndexedDB/
+Local Storage/
+Session Storage/
+Service Worker/
+Network/
+GPUCache/
+Code Cache/
+blob_storage/
+Local State
+Preferences
+
+# Archives of the project, inside the project
+*.cbx`;
 exports.STARTER_IGNORE = `${exports.STARTER_MARKER}
 
 # Dependencies and generated output
@@ -177,9 +251,32 @@ function starterAuthored(text) {
  * line on purpose, and re-adding it silently would be this application
  * overruling them in their own file.
  */
-function missingStarterRules(text) {
+function missingStarterRules(text, reference = exports.STARTER_IGNORE) {
     const present = new Set(ruleLines(text));
-    return ruleLines(exports.STARTER_IGNORE).filter((line) => !present.has(line));
+    return ruleLines(reference).filter((line) => !present.has(line));
+}
+/**
+ * The rules this folder's own file is missing for the kind of project it is.
+ *
+ * The gap nothing could reach. A folder with a `.gitignore` of its own keeps
+ * it — that is right, and a real one must always win — but it also meant that
+ * every improvement to the rules could never arrive anywhere that needed
+ * them. A Unity project whose file had been written before the engine rules
+ * existed went on sending its whole import cache, and nothing said so.
+ *
+ * Reported rather than applied. A person may have deleted a line on purpose,
+ * and putting it back without asking is this application overruling them in
+ * their own file.
+ */
+async function missingEngineRules(root) {
+    const entries = await (0, promises_1.readdir)(root).catch(() => []);
+    const kind = (0, detect_js_1.templatesFor)(entries);
+    if (!kind.length)
+        return { kind, missing: [] };
+    const shared = await readIfPresent(node_path_1.default.join(root, exports.IGNORE_FILE));
+    if (shared === null)
+        return { kind, missing: [] };
+    return { kind, missing: missingStarterRules(shared, await starterFor(root)) };
 }
 /** The shared rules file, committed with the project. */
 exports.IGNORE_FILE = ".gitignore";
@@ -231,6 +328,163 @@ function migrateRetiredRules(ignore, keep) {
     }
     return `${lines.join("\n")}\n`;
 }
+/**
+ * The rules a folder gets when it has none of its own.
+ *
+ * github/gitignore's templates have been carried in this application all
+ * along, and until now nothing chose one: every folder got the same generic
+ * starter. For a game project that is the wrong list. It carries `build/`,
+ * `dist/`, `out/` and `models/**` from the JavaScript and Python worlds, none
+ * of them anchored, so a folder like `Assets/Art/models` or
+ * `Assets/Plugins/Binaries` is matched by a rule that was written about
+ * somewhere else entirely — and the files inside it are quietly not sent.
+ *
+ * So the folder is asked what it is, and the template that knows about its
+ * layout is used. GitHub's Unity rules anchor every one of theirs — `/[Oo]bj/`
+ * rather than `obj/` — precisely so they cannot reach into `Assets`.
+ *
+ * The starter still follows, for the things no language template covers: a
+ * browser profile left in the folder, and CodeRook's own archives.
+ */
+/**
+ * Engines github/gitignore has no template for.
+ *
+ * Kept deliberately small and anchored. An unanchored `library/` would reach
+ * a folder of that name anywhere in the project, which is the mistake the
+ * generic starter was already making.
+ */
+const EXTRA_TEMPLATES = {
+    cocos: {
+        name: "Cocos",
+        body: `/[Ll]ibrary/
+/[Tt]emp/
+/[Bb]uild/
+/.creator/`,
+    },
+};
+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 = chosen ? (chosen === "none" ? [] : [chosen]) : (0, detect_js_1.templatesFor)(entries);
+    if (!keys.length)
+        return exports.STARTER_IGNORE;
+    const parts = [exports.STARTER_MARKER];
+    for (const key of keys) {
+        const template = ignore_templates_js_1.IGNORE_TEMPLATES[key] ?? EXTRA_TEMPLATES[key];
+        if (!template)
+            continue;
+        const from = ignore_templates_js_1.IGNORE_TEMPLATES[key] ? ", from github/gitignore" : "";
+        parts.push("", `# ${template.name}${from}`, template.body.trimEnd());
+    }
+    parts.push("", exports.ALSO_LEFT_OUT_HEADING, exports.ALSO_LEFT_OUT);
+    parts.push("", exports.KEPT_ANYWAY_HEADING, exports.KEPT_ANYWAY);
+    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));
@@ -239,7 +493,7 @@ async function readRules(root) {
     // No .gitignore yet. Anything an earlier build wrote is carried over, so a
     // project that was already set up does not silently lose its rules.
     const migrated = migrateRetiredRules(await readIfPresent(node_path_1.default.join(root, RETIRED_IGNORE)), await readIfPresent(node_path_1.default.join(root, RETIRED_KEEP)));
-    return { shared: migrated ?? exports.STARTER_IGNORE, local: local ?? "" };
+    return { shared: migrated ?? (await starterFor(root)), local: local ?? "" };
 }
 /** Write the rules where the project, the CLI and git all expect them. */
 async function writeRules(root, rules) {
@@ -893,7 +1147,14 @@ async function evaluateRules(root, rules, options = {}) {
             // The last rule to speak wins, across every .gitignore that governs
             // this path. A `!` rule brings the file back and is worth reporting,
             // because it is how "always include" is expressed.
-            const rule = (0, rules_js_1.decide)(relative, false, layers);
+            /*
+              The directories above it count. Asking `decide` about the file alone
+              is what made this screen report a Unity project's whole Library as
+              going up: `/[Ll]ibrary/` speaks about the directory, so no rule
+              matched the file and every one of them looked included — while the
+              save, which has always walked the ancestors, left them all behind.
+            */
+            const rule = (0, rules_js_1.decidingRule)(relative, false, layers);
             if (rule?.negated) {
                 keptFiles += 1;
                 keptBytes += size;

package/package.json

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