rx-worktrees

1import { atom, read, update } from "claude-code";
2import type { EngineInterface, Register } from "claude-code";
3
4import { baseName } from "./base-name";
5import { prLabel } from "./pr-label";
6import { parsePrs } from "./parse-prs";
7import { parseWorktrees } from "./parse-worktrees";
8
9const PANE = "rx-worktrees";
10const view = atom({ plugin: "rx-worktrees", key: "view" } as const, {
11  rows: [],
12  error: null,
13  isLoading: false,
14});
15
16/** Reads the worktrees and their pull requests into the pane's state. */
17const refresh = async ($: EngineInterface): Promise<void> => {
18  await update($, view, (current) => ({ ...current, isLoading: true }));
19
20  const list = await $.process.run(["git", "worktree", "list", "--porcelain"]);
21  if (list.exitCode !== 0) {
22    await update($, view, () => ({
23      rows: [],
24      error: list.stderr.trim() || "Not a git repository.",
25      isLoading: false,
26    }));
27    return;
28  }
29
30  const prs = await $.process
31    .run([
32      "gh",
33      "pr",
34      "list",
35      "--state",
36      "all",
37      "--limit",
38      "200",
39      "--json",
40      "headRefName,number,state",
41    ])
42    .then((run) => parsePrs(run.exitCode === 0 ? run.stdout : "[]"))
43    .catch(() => parsePrs("[]"));
44
45  const rows = parseWorktrees(list.stdout).map((row) => ({
46    ...row,
47    pr: prs.get(row.branch) ?? null,
48  }));
49  await update($, view, () => ({ rows, error: null, isLoading: false }));
50};
51
52/** Runs `git worktree prune` (records of worktrees whose folder is gone) and reads the list again. */
53const prune = async ($: EngineInterface): Promise<void> => {
54  const run = await $.process.run(["git", "worktree", "prune", "--verbose"]);
55  const pruned = `${run.stdout}\n${run.stderr}`
56    .split("\n")
57    .filter((line) => line.startsWith("Removing")).length;
58  $.ui.toast(
59    run.exitCode === 0
60      ? `rx-worktrees: pruned ${pruned} stale worktree record(s)`
61      : `rx-worktrees: prune failed: ${run.stderr.trim()}`,
62  );
63  await refresh($);
64};
65
66export const register: Register = (on) => {
67  on("session.start", async ($, e, next) => {
68    await $.command.register({
69      name: "worktrees",
70      description: "Show the git worktrees of this repository with their pull requests",
71    });
72
73    return next(e);
74  });
75
76  on("command.run", { command: "worktrees" }, async ($) => {
77    await $.ui.open({ id: PANE, title: "Worktrees" });
78    await refresh($);
79
80    return { text: "Worktrees pane opened." };
81  });
82
83  on("ui.render", { component: "Pane", requestId: PANE }, async ($, e) => {
84    const { Box, Button, Text } = $.ui.resolve(e);
85    const { rows, error, isLoading } = await read($, view);
86    const prunable = rows.filter((row) => row.isPrunable).length;
87
88    return (
89      <Box flexDirection="column">
90        <Box flexDirection="row" gap={1}>
91          <Button
92            key="refresh"
93            hotkey="r"
94            label={isLoading ? "Loading" : "Refresh"}
95            onPress={() => refresh($)}
96          />
97          {prunable > 0 && (
98            <Button key="prune" hotkey="p" label={`Prune ${prunable}`} onPress={() => prune($)} />
99          )}
100        </Box>
101        {error !== null && <Text color="red">{error}</Text>}
102        {error === null && rows.length === 0 && (
103          <Text dimColor>{isLoading ? "Reading worktrees." : "No worktrees."}</Text>
104        )}
105        {rows.map((row) => (
106          <Button
107            key={`row-${row.path}`}
108            plain
109            onPress={async (press) => {
110              await $.ui.copy({ text: row.path, surface: press.surface });
111              $.ui.toast(`Copied ${row.path}`);
112            }}
113          >
114            {row.branch}{" "}
115            <Text dimColor>
116              {prLabel(row.pr)}
117              {row.isPrunable ? " · prunable" : ""} · {baseName(row.path)}
118            </Text>
119          </Button>
120        ))}
121      </Box>
122    );
123  });
124};
125

1/** The last segment of a path. */
2export const baseName = (path: string): string => path.split("/").filter(Boolean).pop() ?? path;
3

1import type { Worktree } from "../types";
2
3/** A row's pull request as `#12 merged`, or `no PR`. */
4export const prLabel = (pr: Worktree["pr"]): string =>
5  pr === null ? "no PR" : `#${pr.number} ${pr.state.toLowerCase()}`;
6

1import type { Worktree } from "../types";
2
3/** The newest pull request per head branch, from `gh pr list --json headRefName,number,state`; empty when the JSON does not parse. */
4export const parsePrs = (json: string): Map<string, NonNullable<Worktree["pr"]>> => {
5  const byBranch = new Map<string, NonNullable<Worktree["pr"]>>();
6  try {
7    const list = JSON.parse(json) as { headRefName: string; number: number; state: string }[];
8    for (const pr of list) {
9      if (!byBranch.has(pr.headRefName)) {
10        byBranch.set(pr.headRefName, { number: pr.number, state: pr.state });
11      }
12    }
13  } catch {
14    // gh missing or not a GitHub repository: rows show no PR.
15  }
16
17  return byBranch;
18};
19

1import type { Worktree } from "../types";
2
3/** The worktrees `git worktree list --porcelain` lists, without their pull requests. */
4export const parseWorktrees = (porcelain: string): Omit<Worktree, "pr">[] =>
5  porcelain
6    .split("\n\n")
7    .map((block) => block.split("\n").filter((line) => line !== ""))
8    .filter((lines) => lines[0]?.startsWith("worktree ") === true)
9    .map((lines) => {
10      const field = (name: string) =>
11        lines.find((line) => line === name || line.startsWith(`${name} `));
12      const branch = field("branch")?.slice("branch refs/heads/".length);
13
14      return {
15        path: (field("worktree") ?? "").slice("worktree ".length),
16        branch: branch ?? (field("bare") === undefined ? "(detached)" : "(bare)"),
17        isPrunable: field("prunable") !== undefined,
18      };
19    });
20

1export type Worktree = {
2  path: string;
3  branch: string;
4  isPrunable: boolean;
5  pr: { number: number; state: string } | null;
6};
7
8export type WorktreesView = {
9  rows: Worktree[];
10  error: string | null;
11  isLoading: boolean;
12};
13
14declare module "claude-code" {
15  interface PluginState {
16    "rx-worktrees": { view: WorktreesView };
17  }
18}
19