rl-workspaces 0.0.0-stage → 0.6.0

package/dist/display.js

@@ -0,0 +1,134 @@
+import { activityView } from "./activity.js";
+import { accessLabel } from "./access.js";
+import { stripVTControlCharacters } from "node:util";
+import { homedir } from "node:os";
+import path from "node:path";
+// Keep names and remote titles on one terminal line without control sequences.
+const text = (value) => stripVTControlCharacters(String(value ?? ""))
+    .replace(/[\x00-\x1f\x7f-\x9f]/g, " ")
+    .trim();
+export function prText(pr) {
+    if (!pr)
+        return "PR: none saved. Run rl pr sync to refresh.";
+    const number = typeof pr.number === "number" ? ` #${pr.number}` : "";
+    const state = [pr.isDraft ? "draft" : "", text(pr.state).toLowerCase()]
+        .filter(Boolean)
+        .join(" · ");
+    return [
+        `PR${number}${pr.title ? `: ${text(pr.title)}` : ""}${state ? ` [${state}]` : ""}`,
+        pr.headRefName && pr.baseRefName
+            ? `  ${text(pr.headRefName)} → ${text(pr.baseRefName)}`
+            : "",
+        `  ${text(pr.url)}`,
+        pr.syncedAt ? `  Cached ${text(pr.syncedAt)}` : "",
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+export function statusText(data, git, workflow = null) {
+    const color = process.env.NO_COLOR === undefined &&
+        process.env.FORCE_COLOR !== "0" &&
+        process.env.TERM !== "dumb" &&
+        (!!process.stdout.isTTY || !!process.env.FORCE_COLOR);
+    const paint = (value, code) => color ? `\x1b[${code}m${value}\x1b[0m` : value;
+    const muted = (value) => paint(value, 90);
+    const row = (label, value) => `  ${muted(label.padEnd(10))}${value}`;
+    const files = (count, state, code) => count ? paint(`${count} ${state} file${count === 1 ? "" : "s"}`, code) : "";
+    const changes = [
+        files(git.staged, "staged", 32),
+        files(git.unstaged, "modified", 33),
+        files(git.untracked, "untracked", 33),
+        files(git.conflicts, "conflicted", 31),
+    ].filter(Boolean);
+    const home = homedir();
+    const directory = data.worktree === home
+        ? "~"
+        : data.worktree.startsWith(home + path.sep)
+            ? "~" + data.worktree.slice(home.length)
+            : data.worktree;
+    const lines = [
+        "",
+        `  ${paint(text(data.id), 1)}`,
+        "",
+        ...(data.branch !== data.id ? [row("Branch", text(data.branch))] : []),
+        row("Path", muted(text(directory))),
+        ...(data.baseBranch ? [row("Base", text(data.baseBranch))] : []),
+        row("Git", git.availability === "ok"
+            ? changes.join(" · ") || paint("clean", 32)
+            : paint(text(git.error ?? git.availability), 31)),
+    ];
+    if (git.upstream) {
+        const sync = git.ahead === 0 && git.behind === 0
+            ? paint("up to date", 32)
+            : git.ahead === null || git.behind === null
+                ? muted("commit counts unavailable")
+                : `${paint(`${git.ahead} ahead`, git.ahead ? 32 : 90)} · ${paint(`${git.behind} behind`, git.behind ? 33 : 90)} ${muted("(commits)")}`;
+        lines.push(row("Upstream", `${sync} ${muted("· " + text(git.upstream))}`));
+    }
+    lines.push("");
+    const pr = data.pr;
+    if (pr) {
+        const number = typeof pr.number === "number" ? ` #${pr.number}` : "";
+        const state = text(pr.state).toLowerCase();
+        const label = [pr.isDraft ? "draft" : "", state]
+            .filter(Boolean)
+            .join(" · ");
+        const badge = paint(label, pr.isDraft
+            ? 33
+            : state === "open"
+                ? 32
+                : state === "merged"
+                    ? 35
+                    : state === "closed"
+                        ? 31
+                        : 33);
+        const target = pr.baseRefName
+            ? `${pr.headRefName && pr.headRefName !== data.branch ? text(pr.headRefName) + " " : ""}→ ${text(pr.baseRefName)}`
+            : "";
+        lines.push(`  ${paint(`PR${number}`, 1)}${badge ? ` · ${badge}` : ""}${target ? ` ${muted("· " + target)}` : ""}`);
+        if (pr.title)
+            lines.push(`  ${text(pr.title)}`);
+        lines.push(`  ${paint(text(pr.url), 36)}`);
+        if (pr.syncedAt) {
+            const stamp = text(pr.syncedAt);
+            lines.push(`  ${muted(`Cached ${Number.isFinite(Date.parse(stamp)) ? accessLabel(stamp) : stamp}`)}`);
+        }
+    }
+    else {
+        lines.push(`  ${paint("PR", 1)} ${muted("· none saved")}`, `  ${muted("Run rl pr sync to refresh")}`);
+    }
+    lines.push("", `  ${paint("Sessions", 1)}`);
+    for (const agent of ["codex", "claude"]) {
+        const activity = activityView(data.activity?.[agent]).filter((item) => !item.childId);
+        const states = ["working", "idle", "stale"]
+            .map((state) => {
+            const count = activity.filter((item) => item.state === state).length;
+            return count
+                ? paint(`${count} ${state}`, state === "working" ? 32 : state === "stale" ? 33 : 90)
+                : "";
+        })
+            .filter(Boolean);
+        lines.push(row(agent === "codex" ? "Codex" : "Claude", `${data.sessions[agent].length} saved${states.length ? ` · ${states.join(" · ")}` : ""}`));
+    }
+    if (workflow) {
+        lines.push("", `  ${paint("Workflow", 1)} · ${text(workflow.workflow)} · ${text(workflow.status)}`, row("Steps", `${workflow.completed}/${workflow.total} completed`), ...(workflow.owner
+            ? [
+                row("Owner", `${workflow.owner.agent} · native subagents · ${workflow.owner.sessionId}`),
+            ]
+            : []), ...(workflow.verdict
+            ? [
+                row("Review", `${workflow.score === null ? "not scored" : `${workflow.score}/100`} · ${text(workflow.verdict)}`),
+            ]
+            : []));
+    }
+    const handoff = data.task?.handoffs.at(-1);
+    if (handoff) {
+        lines.push("", `  ${paint("Task", 1)} · ${paint(data.task.state, data.task.state === "paused" ? 33 : 32)}`, `  ${text(handoff.summary)}`, row("Next", text(handoff.next)));
+        if (handoff.blockers)
+            lines.push(row("Blockers", paint(text(handoff.blockers), 33)));
+    }
+    if (Object.values(data.sessions).some((sessions) => sessions.length))
+        lines.push("", `  ${muted("Resume with")} ${paint("rl resume", 36)}`);
+    lines.push("");
+    return lines.join("\n");
+}

package/dist/doctor.js

@@ -0,0 +1,145 @@
+import fs from "node:fs";
+import path from "node:path";
+import { adapters, agentAdapter } from "./agent-registry.js";
+import { activityView, STALE_AFTER_MS } from "./activity.js";
+import { execute, isSymlink, json, message } from "./common.js";
+import { hookCommand } from "./store.js";
+import { isJsonObject, readJsonObject } from "./json.js";
+const PROBE_TIMEOUT_MS = 2000;
+const MAX_VERSION_LENGTH = 200;
+export async function doctor(store, selected, asJson = false) {
+    const [file, data] = store.current();
+    const selectedAdapters = selected
+        ? [agentAdapter(selected)]
+        : Object.values(adapters);
+    const agents = await Promise.all(selectedAdapters.map(async (adapter) => {
+        const configPath = path.join(data.worktree, adapter.configPath);
+        const expectedEvents = Object.keys({
+            ...adapter.events,
+            ...(data.extendedHooks ? adapter.extraEvents : {}),
+        });
+        const executablePath = (process.env.PATH ?? "")
+            .split(path.delimiter)
+            .map((directory) => path.resolve(data.worktree, directory, adapter.name))
+            .find((candidate) => {
+            try {
+                fs.accessSync(candidate, fs.constants.X_OK);
+                return fs.statSync(candidate).isFile();
+            }
+            catch {
+                return false;
+            }
+        }) ?? null;
+        let configError = null;
+        let installedEvents = [];
+        try {
+            if (isSymlink(configPath) || isSymlink(path.dirname(configPath)))
+                throw new Error("Hook configuration is a symlink");
+            const config = readJsonObject(configPath);
+            if (!isJsonObject(config.hooks))
+                throw new Error("Missing hooks object");
+            const command = hookCommand(store, data, adapter.name);
+            const hooks = config.hooks;
+            installedEvents = expectedEvents.filter((event) => {
+                const groups = hooks[event];
+                if (!Array.isArray(groups))
+                    return false;
+                return groups.some((group) => isJsonObject(group) &&
+                    (group.matcher === undefined ||
+                        group.matcher === "" ||
+                        group.matcher === "*") &&
+                    Array.isArray(group.hooks) &&
+                    group.hooks.some((h) => isJsonObject(h) &&
+                        h.type === "command" &&
+                        h.command === command &&
+                        h.async !== true));
+            });
+        }
+        catch (error) {
+            configError = message(error);
+        }
+        const missingEvents = expectedEvents.filter((event) => !installedEvents.includes(event));
+        let cliAvailable = false, version = null, cliError = null, launchVerified = false;
+        try {
+            const result = await execute([adapter.name, "--version"], data.worktree, { timeoutMs: PROBE_TIMEOUT_MS });
+            cliAvailable = result.code === 0;
+            version = result.stdout.trim().slice(0, MAX_VERSION_LENGTH) || null;
+            if (!cliAvailable)
+                cliError = "Version probe failed or timed out";
+            if (cliAvailable) {
+                const help = await execute(adapter.name === "codex"
+                    ? [adapter.name, "exec", "--help"]
+                    : [adapter.name, "--help"], data.worktree, { timeoutMs: PROBE_TIMEOUT_MS });
+                launchVerified =
+                    help.code === 0 &&
+                        (adapter.name === "codex"
+                            ? /codex exec/.test(help.stdout) && /PROMPT/.test(help.stdout)
+                            : /--print/.test(help.stdout) && /--resume/.test(help.stdout));
+            }
+        }
+        catch (error) {
+            cliError = message(error);
+        }
+        const health = data.hookHealth?.[adapter.name];
+        return {
+            agent: adapter.name,
+            configPath,
+            installed: !configError && missingEvents.length === 0,
+            installedEvents,
+            missingEvents,
+            configError,
+            cliAvailable,
+            executablePath,
+            launchVerified,
+            extendedHooks: !!data.extendedHooks,
+            delivery: health?.lastSuccess ? "observed" : "not-observed",
+            version,
+            cliError,
+            compatibility: "unverified",
+            trust: "unknown",
+            lastSuccess: health?.lastSuccess ?? null,
+            lastError: health?.lastError ?? null,
+            activity: activityView(data.activity?.[adapter.name]),
+        };
+    }));
+    let stateWritable = true;
+    try {
+        fs.accessSync(store.root, fs.constants.W_OK);
+        fs.accessSync(path.dirname(file), fs.constants.W_OK);
+    }
+    catch {
+        stateWritable = false;
+    }
+    const report = {
+        workspace: data.worktree,
+        stateDirectory: path.dirname(file),
+        stateWritable,
+        staleAfterMs: STALE_AFTER_MS,
+        agents,
+    };
+    if (asJson)
+        json(report);
+    else {
+        console.log(`RL doctor: ${data.worktree}\nState writable from this process: ${stateWritable ? "yes" : "no"}`);
+        for (const item of agents) {
+            console.log(`\n${item.agent}: hooks ${item.installed ? "installed" : "incomplete"}; CLI ${item.cliAvailable ? (item.version ?? "available") : "unavailable"}`);
+            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.`);
+            if (item.configError)
+                console.log(`  Configuration error: ${item.configError}`);
+            if (item.cliError)
+                console.log(`  CLI error: ${item.cliError}`);
+            if (item.lastError)
+                console.log(`  Last recorded hook error: ${item.lastError.message} at ${item.lastError.at}`);
+            for (const activity of item.activity)
+                console.log(`  ${activity.sessionId}${activity.childId ? ` / child ${activity.childId}` : ""}: ${activity.state}${activity.resumable ? "" : " (observation only)"}`);
+        }
+        console.log("\nInstallation does not prove hooks are enabled or trusted. Review agent hook settings and start a session here to verify delivery. Version compatibility is not certified. Activity is based on received events; after 30 minutes without an event it is stale, not confirmed running. Agent sandbox access may differ from this process.");
+    }
+    return stateWritable &&
+        agents.every((item) => item.installed && item.cliAvailable)
+        ? 0
+        : 1;
+}

package/dist/git-safety.js

@@ -0,0 +1,24 @@
+import fs from "node:fs";
+import { git } from "./common.js";
+export const GIT_WORKFLOW_DIRECTORY = ".git-workflow";
+export const GIT_WORKFLOW_LOCK = ".lock";
+const OPERATION_FILES = [
+    "MERGE_HEAD",
+    "CHERRY_PICK_HEAD",
+    "REVERT_HEAD",
+    "rebase-merge",
+    "rebase-apply",
+    "sequencer",
+];
+/** Shared mutation guard; untracked content counts as dirty. */
+export function assertReady(root, clean, expectedBranch) {
+    if (git(root, "branch", "--show-current") !== expectedBranch)
+        throw new Error("Workspace branch changed; retry from the intended branch");
+    for (const marker of OPERATION_FILES)
+        if (fs.existsSync(git(root, "rev-parse", "--path-format=absolute", "--git-path", marker)))
+            throw new Error(`An operation is already in progress in ${root}; finish or abort it first`);
+    if (git(root, "ls-files", "--unmerged"))
+        throw new Error(`Unresolved conflicts in ${root}`);
+    if (clean && git(root, "status", "--porcelain", "--untracked-files=normal"))
+        throw new Error(`Workspace is dirty: ${root}. Commit or stash changes explicitly first`);
+}

package/dist/git-workflow.js

@@ -0,0 +1,89 @@
+import path from "node:path";
+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";
+function revision(root, ref) {
+    return git(root, "rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`);
+}
+export async function main(argv) {
+    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);
+    return locked(path.join(context.store.root, GIT_WORKFLOW_DIRECTORY), GIT_WORKFLOW_LOCK, async () => {
+        const selected = rest[0] ?? context.defaultBase.replace(/^origin\//, "");
+        const targetRecord = worktrees(context.repo).find((record) => record.branch === `refs/heads/${selected}`);
+        if (!targetRecord)
+            throw new Error(`Target must be a checked-out local branch: ${selected}`);
+        const target = canonical(targetRecord.worktree);
+        // Main and managed worktrees are the only mutation targets.
+        resolveWorkspace(context, target === context.repo ? "@" : target);
+        if (target === source.path)
+            throw new Error("Source and target are the same worktree");
+        if ("locked" in targetRecord)
+            throw new Error("Target worktree is locked");
+        assertReady(source.path, true, source.branch);
+        assertReady(target, true, selected);
+        const sourceHead = revision(source.path, "HEAD");
+        const targetHead = revision(target, "HEAD");
+        const mergeBase = git(target, "merge-base", targetHead, sourceHead);
+        if (!values.squash &&
+            mergeBase !== targetHead &&
+            mergeBase !== sourceHead)
+            throw new Error("Fast-forward merge is not possible. Rebase the feature explicitly first");
+        if (values.squash)
+            required(values, "message");
+        if (values["dry-run"]) {
+            console.log(`Would ${values.squash ? "squash merge" : "fast-forward merge"} ${source.branch} into ${selected}${values.cleanup ? " and remove the clean source worktree" : ""}`);
+            return 0;
+        }
+        const result = await execute([
+            "git",
+            "-C",
+            target,
+            "merge",
+            ...(values.squash ? ["--squash"] : ["--ff-only"]),
+            sourceHead,
+        ], target);
+        process.stdout.write(result.stdout);
+        if (result.code)
+            throw new Error(`${result.stderr.trim()}\nMerge did not complete in ${target}; source workspace was retained. Inspect git status before continuing`);
+        if (values.squash) {
+            const integratedTree = git(target, "write-tree");
+            const staged = await execute(["git", "-C", target, "diff", "--cached", "--quiet"], target);
+            if (staged.code > 1)
+                throw new Error(staged.stderr || "Cannot inspect squash result");
+            if (staged.code === 1)
+                console.log(git(target, "commit", "-m", required(values, "message")));
+            if (git(target, "rev-parse", "HEAD^{tree}") !== integratedTree)
+                throw new Error("Squash result changed during commit; source workspace retained");
+        }
+        assertReady(target, true, selected);
+        if (!values.squash &&
+            git(target, "merge-base", "HEAD", sourceHead) !== sourceHead)
+            throw new Error("Target no longer contains the source; cleanup skipped");
+        if (!values.cleanup)
+            return 0;
+        // Recheck source immediately before removal; never force worktree/branch deletion.
+        assertReady(source.path, true, source.branch);
+        if (revision(source.path, "HEAD") !== sourceHead)
+            throw new Error("Source changed during merge; cleanup skipped");
+        if (source.path === context.repo)
+            throw new Error("Integration succeeded; main checkout cannot be removed");
+        process.chdir(target);
+        git(context.repo, "worktree", "remove", source.path);
+        await context.store.locked(() => context.store.archiveWorktrees([source.path]));
+        const deleted = await execute(["git", "-C", target, "branch", "-d", "--", source.branch], target);
+        if (deleted.code)
+            console.log(`Worktree removed; branch ${source.branch} retained: ${deleted.stderr.trim()}`);
+        else
+            process.stdout.write(deleted.stdout);
+        return 0;
+    });
+}