@coderook/cli 0.29.4 → 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/dist/desktop-app/src/shared/merge_diff.js

@@ -0,0 +1,191 @@
+"use strict";
+/**
+ * Showing what two people actually did to the same file.
+ *
+ * The merge screen used to offer four buttons — keep yours, keep theirs, keep
+ * both, remove it — above nothing at all. You were asked which side wins for
+ * a file you could not look at, which is not a decision so much as a guess,
+ * and the safe guess ("keep both") leaves the project holding two copies of
+ * everything anybody ever disagreed about.
+ *
+ * So the two sides are laid out line by line. Nothing here is a merge
+ * algorithm: the service already tried that and put the file on a Track
+ * precisely because the automatic answer was wrong. This is for reading.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linesOf = linesOf;
+exports.diffLines = diffLines;
+exports.foldUnchanged = foldUnchanged;
+exports.conflictDraft = conflictDraft;
+exports.hasConflictMarkers = hasConflictMarkers;
+/**
+ * The lines two texts share, longest run first.
+ *
+ * A plain longest-common-subsequence table. Both sides of a conflicted file
+ * are one file's worth of lines, so the quadratic table is a few hundred
+ * kilobytes at worst — and the alternative, a heuristic diff, sometimes
+ * reports a change where there is none, which on this screen would mean
+ * showing somebody a disagreement that does not exist.
+ */
+function commonRuns(left, right) {
+    const table = Array.from({ length: left.length + 1 }, () => new Array(right.length + 1).fill(0));
+    for (let a = left.length - 1; a >= 0; a -= 1) {
+        for (let b = right.length - 1; b >= 0; b -= 1) {
+            table[a][b] =
+                left[a] === right[b]
+                    ? table[a + 1][b + 1] + 1
+                    : Math.max(table[a + 1][b], table[a][b + 1]);
+        }
+    }
+    return table;
+}
+/** Split into lines without inventing a trailing empty one. */
+function linesOf(text) {
+    if (text === "")
+        return [];
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    if (lines.length > 1 && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines;
+}
+/**
+ * How the saved file and the uploaded file differ, in order.
+ *
+ * `target` is what the project already held and `candidate` is what was
+ * uploaded, named the way the service names them rather than "old" and "new"
+ * — neither side is older, which is the whole reason there is a decision to
+ * make.
+ */
+function diffLines(target, candidate) {
+    const left = linesOf(target);
+    const right = linesOf(candidate);
+    const table = commonRuns(left, right);
+    const out = [];
+    let a = 0;
+    let b = 0;
+    while (a < left.length && b < right.length) {
+        if (left[a] === right[b]) {
+            out.push({
+                side: "same",
+                targetLine: a + 1,
+                candidateLine: b + 1,
+                text: left[a],
+            });
+            a += 1;
+            b += 1;
+        }
+        else if (table[a + 1][b] >= table[a][b + 1]) {
+            out.push({ side: "target", targetLine: a + 1, candidateLine: null, text: left[a] });
+            a += 1;
+        }
+        else {
+            out.push({
+                side: "candidate",
+                targetLine: null,
+                candidateLine: b + 1,
+                text: right[b],
+            });
+            b += 1;
+        }
+    }
+    while (a < left.length) {
+        out.push({ side: "target", targetLine: a + 1, candidateLine: null, text: left[a] });
+        a += 1;
+    }
+    while (b < right.length) {
+        out.push({
+            side: "candidate",
+            targetLine: null,
+            candidateLine: b + 1,
+            text: right[b],
+        });
+        b += 1;
+    }
+    return out;
+}
+function foldUnchanged(lines, context = 3) {
+    const interesting = new Set();
+    lines.forEach((line, index) => {
+        if (line.side === "same")
+            return;
+        for (let at = Math.max(0, index - context); at <= Math.min(lines.length - 1, index + context); at += 1) {
+            interesting.add(at);
+        }
+    });
+    /*
+      A file with no differences at all is still worth showing — a conflict can
+      be about two people creating the same path with identical content, or
+      about a file one side deleted, and folding the whole thing away would
+      leave the screen empty with no explanation.
+    */
+    if (!interesting.size)
+        return [{ kind: "lines", lines }];
+    const chunks = [];
+    let run = [];
+    let skipped = 0;
+    for (let index = 0; index < lines.length; index += 1) {
+        if (interesting.has(index)) {
+            if (skipped) {
+                chunks.push({ kind: "gap", skipped });
+                skipped = 0;
+            }
+            run.push(lines[index]);
+        }
+        else {
+            if (run.length) {
+                chunks.push({ kind: "lines", lines: run });
+                run = [];
+            }
+            skipped += 1;
+        }
+    }
+    if (run.length)
+        chunks.push({ kind: "lines", lines: run });
+    if (skipped)
+        chunks.push({ kind: "gap", skipped });
+    return chunks;
+}
+/**
+ * A starting point for somebody who wants to edit rather than choose.
+ *
+ * Both sides, marked the way every merge tool has marked them since RCS, so
+ * the text is immediately familiar and every editor already highlights it.
+ * Agreed lines appear once; the rest are stacked with the markers between
+ * them, and it is the person's job to delete the markers along with whatever
+ * they decided against.
+ */
+function conflictDraft(target, candidate, labels = {
+    target: "saved on the project",
+    candidate: "your upload",
+}) {
+    const out = [];
+    let held = { target: [], candidate: [] };
+    const flush = () => {
+        if (!held.target.length && !held.candidate.length)
+            return;
+        out.push(`<<<<<<< ${labels.target}`);
+        out.push(...held.target);
+        out.push("=======");
+        out.push(...held.candidate);
+        out.push(`>>>>>>> ${labels.candidate}`);
+        held = { target: [], candidate: [] };
+    };
+    for (const line of diffLines(target, candidate)) {
+        if (line.side === "same") {
+            flush();
+            out.push(line.text);
+        }
+        else if (line.side === "target") {
+            held.target.push(line.text);
+        }
+        else {
+            held.candidate.push(line.text);
+        }
+    }
+    flush();
+    return out.join("\n");
+}
+/** Whether any conflict marker is still in the text somebody is about to send. */
+function hasConflictMarkers(text) {
+    return /^(?:<{7}|={7}|>{7})(?:\s|$)/m.test(text);
+}

package/package.json

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