rl-workspaces 0.5.0 → 0.7.0

package/dist/common.js

@@ -6,6 +6,7 @@ import { spawnSync, spawn } from "node:child_process";
 import { parseArgs } from "node:util";
 import lockfile from "proper-lockfile";
 import { readJsonObject } from "./json.js";
+import { executableError } from "./dependencies.js";
 export const now = () => new Date().toISOString();
 export const message = (error) => error instanceof Error ? error.message : String(error);
 export const json = (data) => console.log(JSON.stringify(data, null, 2));
@@ -54,7 +55,7 @@ export function run(argv, cwd, raw = false) {
         maxBuffer: 32 * 1024 * 1024,
     });
     if (result.error)
-        throw result.error;
+        throw executableError(result.error, argv[0], cwd);
     if (result.status !== 0)
         throw new Error(result.stderr.trim() || `Command failed: ${argv.join(" ")}`);
     return raw ? result.stdout : result.stdout.trim();
@@ -130,7 +131,7 @@ export async function execute(argv, cwd, options = {}) {
         };
         child.on("error", (error) => {
             cleanup();
-            reject(error);
+            reject(executableError(error, argv[0], cwd));
         });
         child.on("close", (code, signal) => {
             cleanup();

package/dist/dependencies.js

@@ -0,0 +1,197 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { parseArgs } from "node:util";
+import { fileURLToPath } from "node:url";
+export const TOOL_NAMES = ["git", "zsh", "fzf", "gh"];
+export function findExecutable(name, env = process.env) {
+    for (const directory of (env.PATH ?? "").split(path.delimiter)) {
+        if (!directory)
+            continue;
+        const file = path.resolve(directory, name);
+        try {
+            fs.accessSync(file, fs.constants.X_OK);
+            if (fs.statSync(file).isFile())
+                return file;
+        }
+        catch {
+            /* Try the next PATH entry. */
+        }
+    }
+    return null;
+}
+export function inspectDependencies(env = process.env) {
+    return TOOL_NAMES.map((name) => {
+        const executable = findExecutable(name, env);
+        const probe = executable
+            ? spawnSync(executable, ["--version"], {
+                env,
+                encoding: "utf8",
+                timeout: 5000,
+            })
+            : undefined;
+        return {
+            name,
+            path: executable,
+            available: probe?.status === 0,
+            version: probe?.status === 0
+                ? (probe.stdout.trim().split(/\r?\n/)[0]?.slice(0, 200) ?? null)
+                : null,
+        };
+    });
+}
+function installPlan(missing, host, interactive) {
+    const env = host.env ?? process.env;
+    const platform = host.platform ?? process.platform;
+    const brew = findExecutable("brew", env);
+    if (brew)
+        return [{ executable: brew, args: ["install", ...missing] }];
+    if (platform === "darwin")
+        throw new Error("Homebrew is required to install missing RL tools on macOS. Install it from https://brew.sh, then run 'rl setup dependencies'.");
+    if (platform !== "linux")
+        throw new Error("RL supports macOS and Linux");
+    const managers = [
+        { name: "apt-get", args: ["install", "-y"], packages: missing },
+        { name: "dnf", args: ["install", "-y"], packages: missing },
+        { name: "yum", args: ["install", "-y"], packages: missing },
+        {
+            name: "pacman",
+            args: ["-S", "--needed", "--noconfirm"],
+            packages: missing.map((name) => (name === "gh" ? "github-cli" : name)),
+        },
+        {
+            name: "apk",
+            args: ["add"],
+            packages: missing.map((name) => (name === "gh" ? "github-cli" : name)),
+        },
+    ];
+    for (const manager of managers) {
+        const executable = findExecutable(manager.name, env);
+        if (!executable)
+            continue;
+        const commands = manager.name === "apt-get"
+            ? [
+                { executable, args: ["update"] },
+                { executable, args: [...manager.args, ...manager.packages] },
+            ]
+            : [{ executable, args: [...manager.args, ...manager.packages] }];
+        const uid = host.uid ?? process.getuid?.();
+        if (uid === 0)
+            return commands;
+        const sudo = findExecutable("sudo", env);
+        if (!sudo)
+            throw new Error(`Installing missing RL tools requires administrator access. Run: sudo ${manager.name} ${[...manager.args, ...manager.packages].join(" ")}`);
+        return commands.map((command) => ({
+            executable: sudo,
+            args: [
+                ...(interactive ? [] : ["-n"]),
+                command.executable,
+                ...command.args,
+            ],
+        }));
+    }
+    throw new Error("No supported package manager found. Install Git, zsh, fzf and gh, then run 'rl setup dependencies --check'.");
+}
+export async function setupDependencies(argv, host = {}) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            install: { type: "boolean" },
+            check: { type: "boolean" },
+            "dry-run": { type: "boolean" },
+            json: { type: "boolean" },
+        },
+    });
+    if (positionals.length ||
+        (values.check && (values.install || values["dry-run"])))
+        throw new Error("Usage: rl setup dependencies [--check | --dry-run] [--json]");
+    const env = host.env ?? process.env;
+    let tools = inspectDependencies(env);
+    const missing = tools
+        .filter((tool) => !tool.available)
+        .map((tool) => tool.name);
+    let commands = [];
+    let error;
+    const interactive = !!process.stdin.isTTY && !!process.stdout.isTTY && !values.json;
+    if (missing.length && !values.check) {
+        try {
+            commands = installPlan(missing, host, interactive);
+            if (!values["dry-run"]) {
+                console.error(`RL: installing missing tools: ${missing.join(", ")}`);
+                for (const command of commands) {
+                    const result = spawnSync(command.executable, command.args, {
+                        env: {
+                            ...env,
+                            HOMEBREW_NO_AUTO_UPDATE: "1",
+                            ...(interactive ? {} : { NONINTERACTIVE: "1" }),
+                        },
+                        stdio: interactive ? "inherit" : ["ignore", "pipe", "pipe"],
+                        encoding: "utf8",
+                        maxBuffer: 8 * 1024 * 1024,
+                    });
+                    if (!interactive) {
+                        if (result.stdout)
+                            process.stderr.write(result.stdout);
+                        if (result.stderr)
+                            process.stderr.write(result.stderr);
+                    }
+                    if (result.error || result.status !== 0)
+                        throw new Error(`Could not install RL tools. Run '${command.executable} ${command.args.filter((arg) => arg !== "-n").join(" ")}' in your terminal, then rerun 'rl setup dependencies'.`);
+                }
+                tools = inspectDependencies(env);
+                const remaining = tools
+                    .filter((tool) => !tool.available)
+                    .map((tool) => tool.name);
+                if (remaining.length)
+                    throw new Error(`Tools still unavailable on PATH: ${remaining.join(", ")}. Add the package manager's bin directory to PATH, then rerun 'rl setup dependencies'.`);
+            }
+        }
+        catch (failure) {
+            error = failure instanceof Error ? failure.message : String(failure);
+        }
+    }
+    const ready = tools.every((tool) => tool.available);
+    const report = {
+        ready,
+        dryRun: !!values["dry-run"],
+        tools,
+        commands,
+        ...(error ? { error } : {}),
+    };
+    if (values.json)
+        console.log(JSON.stringify(report, null, 2));
+    else {
+        for (const tool of tools)
+            console.log(`${tool.name}: ${tool.available ? (tool.version ?? "installed") : "missing or not working"}`);
+        if (values["dry-run"])
+            for (const command of commands)
+                console.log(`Would run: ${command.executable} ${command.args.join(" ")}`);
+        if (error)
+            console.error(`RL: ${error}`);
+        else if (!ready && values.check)
+            console.error("Run 'rl setup dependencies' to install missing tools.");
+    }
+    return error ? 1 : values["dry-run"] || ready ? 0 : 1;
+}
+export function executableError(error, executable, cwd) {
+    if (error.code !== "ENOENT")
+        return error;
+    if (!fs.existsSync(cwd))
+        return new Error(`Working directory does not exist: ${cwd}`, {
+            cause: error,
+        });
+    if (TOOL_NAMES.includes(path.basename(executable)))
+        return new Error(`Missing required tool ${path.basename(executable)}. Run 'rl setup dependencies' to install Git, zsh, fzf and gh.`, { cause: error });
+    return error;
+}
+if (process.argv[1] &&
+    path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    try {
+        process.exitCode = await setupDependencies(process.argv.slice(2));
+    }
+    catch (error) {
+        console.error(`RL: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    }
+}

package/dist/doctor.js

@@ -126,7 +126,7 @@ export async function doctor(store, selected, asJson = false) {
             console.log(`  CLI: ${item.executablePath ?? "not on PATH"}; launch flags: ${item.launchVerified ? "verified in installed help" : "unverified"}; hook trust: unknown`);
             console.log(`  Last received event: ${item.lastSuccess ? `${item.lastSuccess.event} at ${item.lastSuccess.at}` : "none"}`);
             if (item.missingEvents.length)
-                console.log(`  Missing hooks: ${item.missingEvents.join(", ")}. Run rl adopt.`);
+                console.log(`  Missing hooks: ${item.missingEvents.join(", ")}. Run rl setup adopt.`);
             if (item.configError)
                 console.log(`  Configuration error: ${item.configError}`);
             if (item.cliError)

package/dist/git-workflow.js

@@ -1,116 +1,22 @@
 import path from "node:path";
-import { randomUUID } from "node:crypto";
-import { args, arity, canonical, execute, git, gitRaw, locked, required, } from "./common.js";
+import { args, arity, canonical, execute, git, locked, required, } from "./common.js";
 import { commandContext, contextOptions, resolveWorkspace, } from "./command-context.js";
 import { worktrees } from "./repos.js";
 import { assertReady, GIT_WORKFLOW_DIRECTORY, GIT_WORKFLOW_LOCK, } from "./git-safety.js";
-const BACKUP_PREFIX = "refs/rl/backups/";
-const READ_OPTIONS = new Set([
-    "--stat",
-    "--name-only",
-    "--name-status",
-    "--numstat",
-    "--patch",
-    "--oneline",
-    "--graph",
-    "--decorate",
-    "--all",
-]);
 function revision(root, ref) {
     return git(root, "rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`);
 }
 export async function main(argv) {
-    const separator = argv.indexOf("--");
-    const trailing = separator < 0 ? [] : argv.slice(separator + 1);
-    const { values, positionals } = args(separator < 0 ? argv : argv.slice(0, separator), [...contextOptions, "base", "message"], ["all", "squash", "cleanup", "dry-run"], { message: "m" });
-    const context = commandContext(values);
+    const { values, positionals } = args(argv, [...contextOptions, "message"], ["squash", "cleanup", "dry-run"], { message: "m" });
     const [command, ...rest] = positionals;
+    if (command !== "merge")
+        throw new Error("Unknown Git workflow command");
+    arity(rest, 0, 1);
+    if (values.message && !values.squash)
+        throw new Error("Invalid merge options");
+    const context = commandContext(values);
     const source = resolveWorkspace(context);
-    if (command === "diff" || command === "log") {
-        arity(rest, 0);
-        if (values.all ||
-            values.squash ||
-            values.cleanup ||
-            values.message ||
-            values["dry-run"])
-            throw new Error("Invalid display options");
-        const pathSeparator = trailing.indexOf("--");
-        const flags = pathSeparator < 0 ? trailing : trailing.slice(0, pathSeparator);
-        const paths = pathSeparator < 0 ? [] : trailing.slice(pathSeparator + 1);
-        for (const flag of flags)
-            if (!READ_OPTIONS.has(flag) && !/^(-\d+|--max-count=\d+)$/.test(flag))
-                throw new Error(`Unsupported display option: ${flag}`);
-        const base = revision(source.path, String(values.base ?? context.defaultBase));
-        const range = command === "diff"
-            ? git(source.path, "merge-base", base, "HEAD")
-            : `${base}..HEAD`;
-        process.stdout.write(gitRaw(source.path, "--no-pager", command, "--no-ext-diff", "--no-textconv", ...(command === "log" ? ["--oneline"] : []), ...flags, range, "--", ...paths));
-        return 0;
-    }
-    if (trailing.length)
-        throw new Error("Extra arguments are only supported by diff and log");
     return locked(path.join(context.store.root, GIT_WORKFLOW_DIRECTORY), GIT_WORKFLOW_LOCK, async () => {
-        if (command === "step") {
-            arity(rest, 1);
-            const [action] = rest;
-            if (!["commit", "rebase", "squash"].includes(action))
-                throw new Error("Usage: rl step commit|rebase|squash");
-            if (values.cleanup ||
-                values.squash ||
-                (values.all && action !== "commit"))
-                throw new Error("Invalid step options");
-            assertReady(source.path, action !== "commit", source.branch);
-            if (action === "commit") {
-                if (values.base)
-                    throw new Error("commit does not accept --base");
-                const commitMessage = required(values, "message");
-                if (values["dry-run"]) {
-                    const changes = git(source.path, "diff", "--name-only", ...(values.all ? ["HEAD"] : ["--cached"]));
-                    if (!changes)
-                        throw new Error("No changes to commit");
-                    console.log(`Would commit ${values.all ? "tracked" : "staged"} changes in ${source.branch}: ${commitMessage}\n${changes}`);
-                    return 0;
-                }
-                console.log(git(source.path, "commit", ...(values.all ? ["--all"] : []), "-m", required(values, "message")));
-                return 0;
-            }
-            if (action === "rebase" && values.message)
-                throw new Error("rebase does not accept --message");
-            const base = revision(source.path, String(values.base ?? context.defaultBase));
-            if (action === "rebase") {
-                if (values["dry-run"]) {
-                    console.log(`Would rebase ${source.branch} onto ${base}`);
-                    return 0;
-                }
-                const result = await execute(["git", "-C", source.path, "rebase", base], source.path);
-                process.stdout.write(result.stdout);
-                if (result.code)
-                    throw new Error(`${result.stderr.trim()}\nRebase did not complete. Resolve conflicts and run git rebase --continue, or git rebase --abort in ${source.path}`);
-                return 0;
-            }
-            const message = required(values, "message");
-            const head = revision(source.path, "HEAD");
-            const baseCommit = git(source.path, "merge-base", base, head);
-            if (baseCommit === head)
-                throw new Error("No feature commits to squash");
-            if (values["dry-run"]) {
-                console.log(`Would squash commits after ${baseCommit} in ${source.branch}: ${message}`);
-                return 0;
-            }
-            const tree = git(source.path, "rev-parse", `${head}^{tree}`);
-            const backup = BACKUP_PREFIX + randomUUID();
-            const squashed = git(source.path, "commit-tree", tree, "-p", baseCommit, "-m", message);
-            git(source.path, "update-ref", backup, head);
-            // CAS leaves concurrent branch changes untouched; the worktree and index never change.
-            git(source.path, "update-ref", "-m", "rl step squash", `refs/heads/${source.branch}`, squashed, head);
-            console.log(`Squashed feature commits. Original HEAD retained at ${backup}`);
-            return 0;
-        }
-        if (command !== "merge")
-            throw new Error("Unknown Git workflow command");
-        arity(rest, 0, 1);
-        if (values.all || values.base || (values.message && !values.squash))
-            throw new Error("Invalid merge options");
         const selected = rest[0] ?? context.defaultBase.replace(/^origin\//, "");
         const targetRecord = worktrees(context.repo).find((record) => record.branch === `refs/heads/${selected}`);
         if (!targetRecord)