@coderook/cli 0.1.0

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

@@ -0,0 +1,626 @@
+"use strict";
+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.EVALUATION_FILE_LIMIT = void 0;
+exports.isRepository = isRepository;
+exports.migrateRetiredRules = migrateRetiredRules;
+exports.readRules = readRules;
+exports.writeRules = writeRules;
+exports.collectLayers = collectLayers;
+exports.assertReadable = assertReadable;
+exports.branchName = branchName;
+exports.changedFiles = changedFiles;
+exports.totalSize = totalSize;
+exports.fileDiff = fileDiff;
+exports.projectTree = projectTree;
+exports.evaluateRules = evaluateRules;
+exports.detectSecrets = detectSecrets;
+/** Reading a project folder: changed files, diffs, and rule measurement. */
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const rules_js_1 = require("./rules.js");
+const run = (0, node_util_1.promisify)(node_child_process_1.execFile);
+/** Past this the evaluation reports truncated rather than walking forever. */
+exports.EVALUATION_FILE_LIMIT = 300_000;
+async function git(root, ...args) {
+    try {
+        const { stdout } = await run("git", ["-C", root, ...args], {
+            maxBuffer: 64 * 1024 * 1024,
+            windowsHide: true,
+        });
+        return stdout;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * A starter template, offered rather than imposed: these lines are written
+ * into the project's own .gitignore, so nothing is hidden in the client.
+ *
+ * Credentials are deliberately absent. Silently omitting a configuration
+ * file would produce an incomplete project that looked backed up, so likely
+ * secrets are warned about instead (docs/UPLOAD_POLICY.md).
+ */
+exports.STARTER_IGNORE = `# Dependencies and generated output
+node_modules/
+dist/
+build/
+out/
+.next/
+target/
+__pycache__/
+.venv/
+venv/
+*.log
+
+# Large model weights
+models/**
+*.safetensors
+*.ckpt
+*.pt
+*.pth
+`;
+/** The shared rules file, committed with the project. */
+exports.IGNORE_FILE = ".gitignore";
+/** Personal exclusions, which must never reach a collaborator. */
+exports.LOCAL_EXCLUDE_FILE = node_path_1.default.join(".git", "info", "exclude");
+/** The two files an earlier build wrote, kept only so they can be migrated. */
+const RETIRED_IGNORE = ".coderookignore";
+const RETIRED_KEEP = ".coderookkeep";
+async function readIfPresent(full) {
+    try {
+        const contents = await (0, promises_1.readFile)(full, "utf8");
+        return contents.trim() ? contents : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Whether the folder is a git repository, worktree or otherwise. */
+async function isRepository(root) {
+    try {
+        await (0, promises_1.stat)(node_path_1.default.join(root, ".git"));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Convert the rules an earlier build wrote into one .gitignore.
+ *
+ * `.coderookkeep` held "always include" lines, which gitignore expresses as
+ * `!` negations, so those are translated rather than dropped. Nothing is
+ * deleted here; the retired files are removed only once the new rules have
+ * been written successfully.
+ */
+function migrateRetiredRules(ignore, keep) {
+    if (!ignore && !keep)
+        return null;
+    const lines = [];
+    if (ignore)
+        lines.push(ignore.replace(/\s*$/, ""));
+    const negations = (keep ?? "")
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith("#"))
+        .map((line) => (line.startsWith("!") ? line : `!${line}`));
+    if (negations.length) {
+        lines.push("", "# Always include (migrated from .coderookkeep)", ...negations);
+    }
+    return `${lines.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));
+    if (shared !== null)
+        return { shared, local: local ?? "" };
+    // 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 ?? "" };
+}
+/** Write the rules where the project, the CLI and git all expect them. */
+async function writeRules(root, rules) {
+    await (0, promises_1.writeFile)(node_path_1.default.join(root, exports.IGNORE_FILE), rules.shared, "utf8");
+    if (rules.local.trim() && (await isRepository(root))) {
+        const target = node_path_1.default.join(root, exports.LOCAL_EXCLUDE_FILE);
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(target), { recursive: true });
+        await (0, promises_1.writeFile)(target, rules.local, "utf8");
+    }
+    // Only now that the real file exists are the retired ones removed.
+    for (const retired of [RETIRED_IGNORE, RETIRED_KEEP]) {
+        await (0, promises_1.rm)(node_path_1.default.join(root, retired), { force: true });
+    }
+}
+/**
+ * Every .gitignore that governs this tree, root first. Nested files apply to
+ * their own directory downwards and, being deeper, have the final say.
+ */
+async function collectLayers(root, rules) {
+    const layers = [
+        // Personal exclusions sit at the root but must never be shared.
+        ...(rules.local.trim() ? [{ base: "", rules: (0, rules_js_1.parseRules)(rules.local) }] : []),
+        { base: "", rules: (0, rules_js_1.parseRules)(rules.shared) },
+    ];
+    const walk = async (directory, base) => {
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(directory, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if ((0, rules_js_1.isUncounted)(entry.name) || entry.isSymbolicLink())
+                continue;
+            const relative = base ? `${base}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                // A directory already excluded cannot contribute rules of its own.
+                if ((0, rules_js_1.excludes)(relative, true, layers))
+                    continue;
+                await walk(node_path_1.default.join(directory, entry.name), relative);
+            }
+            else if (entry.name === exports.IGNORE_FILE && base) {
+                const contents = await readIfPresent(node_path_1.default.join(directory, entry.name));
+                if (contents)
+                    layers.push({ base, rules: (0, rules_js_1.parseRules)(contents) });
+            }
+        }
+    };
+    await walk(root, "");
+    return layers;
+}
+/** Fail loudly on a folder that is gone, rather than reporting it as empty. */
+async function assertReadable(root) {
+    try {
+        const info = await (0, promises_1.stat)(root);
+        if (!info.isDirectory())
+            throw new Error("not a folder");
+    }
+    catch {
+        throw new Error(`${root} is not a folder this machine can read`);
+    }
+}
+async function branchName(root) {
+    const output = await git(root, "branch", "--show-current");
+    return output?.trim() || "main";
+}
+/** Files bigger than this are listed but not read to count their lines. */
+const LINE_COUNT_LIMIT = 4 * 1024 * 1024;
+/** Enough rows for any real project; past it the rail would be unusable. */
+const LISTED_FILE_LIMIT = 20_000;
+/** How a file reads: line count, or binary, or too big to bother. */
+async function measure(full, size) {
+    if (size > LINE_COUNT_LIMIT)
+        return { lines: 0, binary: true, hash: "" };
+    try {
+        const contents = await (0, promises_1.readFile)(full);
+        const binary = contents.subarray(0, 8192).includes(0);
+        return {
+            lines: binary ? 0 : contents.toString("utf8").split(/\r?\n/).length,
+            binary,
+            hash: (0, node_crypto_1.createHash)("sha256").update(contents).digest("hex"),
+        };
+    }
+    catch {
+        return { lines: 0, binary: true, hash: "" };
+    }
+}
+/**
+ * The files that would go into the next version.
+ *
+ * This deliberately does not ask git. A CodeRook version is not a commit:
+ * a folder that is not a repository at all still has everything to upload,
+ * and a repository with a spotlessly clean worktree still has everything to
+ * upload when no version has ever been saved. The filter rules decide what
+ * is a candidate; the baseline decides what is new.
+ */
+async function changedFiles(root, rules, baseline = null, mode = "add-and-update") {
+    const layers = await collectLayers(root, rules);
+    const files = [];
+    const present = new Set();
+    const pending = [root];
+    while (pending.length && files.length < LISTED_FILE_LIMIT) {
+        const directory = pending.pop();
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(directory, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const full = node_path_1.default.join(directory, entry.name);
+            if (entry.isSymbolicLink())
+                continue;
+            if ((0, rules_js_1.isUncounted)(entry.name))
+                continue;
+            const relative = node_path_1.default.relative(root, full).split(node_path_1.default.sep).join("/");
+            if (entry.isDirectory()) {
+                // Skipping an excluded directory outright is what keeps this fast,
+                // but a `!` rule exists to rescue what is inside one, so the subtree
+                // is only skipped when no negation could reach into it.
+                if ((0, rules_js_1.excludes)(relative, true, layers) && !(0, rules_js_1.negationReachesInto)(relative, layers)) {
+                    continue;
+                }
+                pending.push(full);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if ((0, rules_js_1.excludes)(relative, false, layers))
+                continue;
+            let size;
+            try {
+                size = (await (0, promises_1.stat)(full)).size;
+            }
+            catch {
+                continue;
+            }
+            present.add(relative);
+            const measured = await measure(full, size);
+            const saved = baseline?.get(relative);
+            if (saved && measured.hash && saved === measured.hash)
+                continue;
+            files.push({
+                path: relative,
+                // Against a saved version the true line delta needs the old copy;
+                // until a version exists to fetch, a changed file counts as rewritten.
+                added: measured.lines,
+                removed: 0,
+                included: true,
+                binary: measured.binary,
+            });
+        }
+    }
+    // A file that was in the last version and is gone now is only a change in
+    // synchronize mode. The safe default adds and updates, and leaves the
+    // saved copy of a missing file alone (docs/UPLOAD_POLICY.md).
+    if (mode === "synchronize") {
+        for (const [saved] of baseline ?? []) {
+            if (present.has(saved))
+                continue;
+            files.push({
+                path: saved,
+                added: 0,
+                removed: 0,
+                included: true,
+                binary: false,
+                deleted: true,
+            });
+        }
+    }
+    return files.sort((left, right) => left.path.localeCompare(right.path));
+}
+/** The size on disk of everything the rules would upload. */
+async function totalSize(root, files) {
+    let total = 0;
+    for (const file of files) {
+        try {
+            total += (await (0, promises_1.stat)(node_path_1.default.join(root, file.path))).size;
+        }
+        catch {
+            /* deleted since the scan; it contributes nothing */
+        }
+    }
+    return total;
+}
+/** The unified diff for one file, including files git does not track yet. */
+async function fileDiff(root, file, ignoreWhitespace = false) {
+    const output = await git(root, "diff", "--no-ext-diff", "--unified=3", ...(ignoreWhitespace ? ["--ignore-all-space"] : []), "--", file);
+    const hunks = [];
+    let current = null;
+    let oldLine = 0;
+    let newLine = 0;
+    for (const raw of (output ?? "").split(/\r?\n/)) {
+        if (raw.startsWith("@@")) {
+            current = { header: raw, lines: [] };
+            hunks.push(current);
+            const match = /@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(raw);
+            if (match) {
+                oldLine = Number(match[1]);
+                newLine = Number(match[2]);
+            }
+            continue;
+        }
+        if (!current)
+            continue;
+        if (/^(diff |index |--- |\+\+\+ )/.test(raw))
+            continue;
+        if (raw.startsWith("+")) {
+            current.lines.push({
+                kind: "add",
+                number: newLine++,
+                oldNumber: null,
+                text: raw.slice(1),
+            });
+        }
+        else if (raw.startsWith("-")) {
+            current.lines.push({
+                kind: "del",
+                number: oldLine,
+                oldNumber: oldLine++,
+                text: raw.slice(1),
+            });
+        }
+        else if (raw.startsWith(" ")) {
+            current.lines.push({
+                kind: "ctx",
+                number: newLine,
+                oldNumber: oldLine,
+                text: raw.slice(1),
+            });
+            oldLine += 1;
+            newLine += 1;
+        }
+    }
+    if (hunks.length)
+        return hunks;
+    // Untracked files have no diff; show them as wholly added.
+    try {
+        const contents = await (0, promises_1.readFile)(node_path_1.default.join(root, file));
+        if (contents.subarray(0, 8192).includes(0)) {
+            return [{ header: `Binary file added: ${file}`, lines: [] }];
+        }
+        const lines = contents.toString("utf8").split(/\r?\n/);
+        return [
+            {
+                header: `@@ -0,0 +1,${lines.length} @@ ${file}`,
+                lines: lines.slice(0, 10_000).map((text, index) => ({
+                    kind: "add",
+                    number: index + 1,
+                    oldNumber: null,
+                    text,
+                })),
+            },
+        ];
+    }
+    catch {
+        return [{ header: `No textual diff is available for ${file}`, lines: [] }];
+    }
+}
+/**
+ * The folder as a tree, so filtering can be done by ticking things rather
+ * than by writing glob patterns. Sizes are rolled up, because the only way
+ * to decide whether to keep a folder is to know what it costs.
+ */
+async function projectTree(root, limit = exports.EVALUATION_FILE_LIMIT) {
+    let seen = 0;
+    const walk = async (directory, relative) => {
+        const node = {
+            path: relative,
+            name: relative ? relative.slice(relative.lastIndexOf("/") + 1) : ".",
+            directory: true,
+            size: 0,
+            files: 0,
+            children: [],
+        };
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(directory, { withFileTypes: true });
+        }
+        catch {
+            return node;
+        }
+        for (const entry of entries) {
+            if (entry.isSymbolicLink())
+                continue;
+            if ((0, rules_js_1.isUncounted)(entry.name))
+                continue;
+            const full = node_path_1.default.join(directory, entry.name);
+            const childPath = relative ? `${relative}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                const child = await walk(full, childPath);
+                node.children.push(child);
+                node.size += child.size;
+                node.files += child.files;
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            seen += 1;
+            if (seen > limit) {
+                node.truncated = true;
+                break;
+            }
+            let size = 0;
+            try {
+                size = (await (0, promises_1.stat)(full)).size;
+            }
+            catch {
+                continue;
+            }
+            node.children.push({
+                path: childPath,
+                name: entry.name,
+                directory: false,
+                size,
+                files: 1,
+            });
+            node.size += size;
+            node.files += 1;
+        }
+        // Folders first, then files, each alphabetically — the familiar order.
+        node.children.sort((left, right) => left.directory === right.directory
+            ? left.name.localeCompare(right.name)
+            : left.directory
+                ? -1
+                : 1);
+        return node;
+    };
+    return walk(root, "");
+}
+/**
+ * Measure what the supplied rules would upload, skip and force-keep.
+ *
+ * This deliberately walks into ignored directories, because the filtering
+ * screen has to be able to say what each rule costs before it is accepted.
+ */
+async function evaluateRules(root, rules, options = {}) {
+    const layers = await collectLayers(root, rules);
+    const limit = options.limit ?? exports.EVALUATION_FILE_LIMIT;
+    const impactBytes = new Map();
+    const impactFiles = new Map();
+    const excluded = [];
+    let uploadFiles = 0;
+    let uploadBytes = 0;
+    let skippedFiles = 0;
+    let skippedBytes = 0;
+    let keptFiles = 0;
+    let keptBytes = 0;
+    let seen = 0;
+    let truncated = false;
+    const pending = [root];
+    while (pending.length) {
+        if (options.shouldStop?.())
+            return emptyEvaluation(true);
+        const directory = pending.pop();
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(directory, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (options.shouldStop?.())
+                return emptyEvaluation(true);
+            const full = node_path_1.default.join(directory, entry.name);
+            if (entry.isSymbolicLink())
+                continue;
+            if ((0, rules_js_1.isUncounted)(entry.name))
+                continue;
+            if (entry.isDirectory()) {
+                pending.push(full);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            seen += 1;
+            if (seen > limit) {
+                truncated = true;
+                pending.length = 0;
+                break;
+            }
+            let size;
+            try {
+                size = (await (0, promises_1.stat)(full)).size;
+            }
+            catch {
+                continue;
+            }
+            const relative = node_path_1.default.relative(root, full).split(node_path_1.default.sep).join("/");
+            // 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);
+            if (rule?.negated) {
+                keptFiles += 1;
+                keptBytes += size;
+                uploadFiles += 1;
+                uploadBytes += size;
+                excluded.push({
+                    path: relative,
+                    bytes: size,
+                    rule: `!${rule.pattern}`,
+                    forceKept: true,
+                });
+                continue;
+            }
+            if (rule) {
+                skippedFiles += 1;
+                skippedBytes += size;
+                impactBytes.set(rule.pattern, (impactBytes.get(rule.pattern) ?? 0) + size);
+                impactFiles.set(rule.pattern, (impactFiles.get(rule.pattern) ?? 0) + 1);
+                excluded.push({
+                    path: relative,
+                    bytes: size,
+                    rule: rule.pattern,
+                    forceKept: false,
+                });
+                continue;
+            }
+            uploadFiles += 1;
+            uploadBytes += size;
+        }
+    }
+    excluded.sort((left, right) => right.bytes - left.bytes);
+    const impacts = [...impactBytes.entries()]
+        .map(([pattern, bytes]) => ({
+        pattern,
+        bytes,
+        files: impactFiles.get(pattern) ?? 0,
+    }))
+        .sort((left, right) => right.bytes - left.bytes);
+    return {
+        uploadFiles,
+        uploadBytes,
+        skippedFiles,
+        skippedBytes,
+        keptFiles,
+        keptBytes,
+        impacts,
+        excluded: excluded.slice(0, 400),
+        truncated,
+    };
+}
+function emptyEvaluation(truncated) {
+    return {
+        uploadFiles: 0,
+        uploadBytes: 0,
+        skippedFiles: 0,
+        skippedBytes: 0,
+        keptFiles: 0,
+        keptBytes: 0,
+        impacts: [],
+        excluded: [],
+        truncated,
+    };
+}
+const SECRET_NAMES = new Set([".env", ".env.local", ".env.production"]);
+const SECRET_SUFFIXES = [".pem", ".key", ".p12", ".pfx"];
+/** Files the flow must ask about before the first upload. */
+async function detectSecrets(root) {
+    const found = [];
+    const pending = [root];
+    let seen = 0;
+    while (pending.length && found.length < 50) {
+        const directory = pending.pop();
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(directory, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (seen > 40_000)
+                return found;
+            const full = node_path_1.default.join(directory, entry.name);
+            if ((0, rules_js_1.isUncounted)(entry.name))
+                continue;
+            if (entry.isDirectory()) {
+                if (entry.name !== "node_modules")
+                    pending.push(full);
+                continue;
+            }
+            seen += 1;
+            const name = entry.name.toLowerCase();
+            const isSecret = SECRET_NAMES.has(name) ||
+                name.startsWith(".env.") ||
+                SECRET_SUFFIXES.some((suffix) => name.endsWith(suffix)) ||
+                node_path_1.default.relative(root, directory).split(node_path_1.default.sep).includes("secrets");
+            if (isSecret) {
+                found.push(node_path_1.default.relative(root, full).split(node_path_1.default.sep).join("/"));
+            }
+        }
+    }
+    return found;
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+/** Types shared by the Electron main process and the renderer. */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@coderook/cli",
+  "version": "0.1.0",
+  "description": "CodeRook from the command line, on any operating system",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "homepage": "https://coderook.com",
+  "bugs": {
+    "url": "https://coderook.com/contact"
+  },
+  "keywords": [
+    "coderook",
+    "versioning",
+    "backup",
+    "cbx"
+  ],
+  "engines": {
+    "node": ">=20.11.0"
+  },
+  "bin": {
+    "coderook": "dist/cli/src/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "tsc -p tsconfig.json && node --test --experimental-strip-types test/*.test.ts",
+    "start": "node dist/cli/src/cli.js",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "typescript": "5.9.3"
+  }
+}