@coderook/cli 0.29.5 → 0.30.0

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

@@ -3,11 +3,13 @@ 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.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.readRules = readRules;
 exports.writeRules = writeRules;
 exports.collectLayers = collectLayers;
@@ -31,6 +33,8 @@ 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);
@@ -57,6 +61,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 +248,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 +325,58 @@ 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) {
+    const entries = await (0, promises_1.readdir)(root).catch(() => []);
+    const keys = (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`;
+}
 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 +385,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 +1039,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.0",
   "description": "CodeRook from the command line, on any operating system",
   "license": "SEE LICENSE IN LICENSE.txt",
   "homepage": "https://coderook.com",