@doriandev/devcc 0.1.2 → 0.2.0

package/src/devcc/views/WorktreesView.ts

@@ -0,0 +1,270 @@
+import type { KeyEvent } from "@opentui/core"
+import type { AgentSession } from "../agents/agents.js"
+import { theme } from "../app/theme.js"
+import type { KeyHint } from "../components/Footer.js"
+import { RowList, type ListRow } from "../components/primitives.js"
+import { processBadge } from "../components/StatusBadge.js"
+import { chunk, dim, styled } from "../components/styled.js"
+import { setSelection, updateUi, type AppState, type ViewId } from "../core/state.js"
+import { isInside, worktreeLabel, type GitWorktree } from "../git/worktrees.js"
+import { isActive } from "../processes/ManagedProcess.js"
+import { errorMessage } from "../utils/errors.js"
+import { fit, formatDuration } from "../utils/format.js"
+import { tildify } from "../utils/paths.js"
+import { View, type ViewDeps } from "./View.js"
+
+export interface WorktreeEntry {
+  kind: "heading" | "blank" | "note" | "worktree" | "agent"
+  key: string
+  text?: string
+  worktree?: GitWorktree
+  agent?: AgentSession
+}
+
+/**
+ * The rows of the Worktrees view, derived from state alone so commands can
+ * resolve "the selected worktree" without asking the view.
+ */
+export function worktreeEntries(state: AppState): WorktreeEntry[] {
+  const entries: WorktreeEntry[] = [{ kind: "heading", key: "h-worktrees", text: "Worktrees" }]
+
+  if (!state.git.isRepository) {
+    entries.push({
+      kind: "note",
+      key: "n-repo",
+      text: state.git.lastRefreshedAt ? "Not a git repository." : "Reading git…",
+    })
+  } else {
+    for (const worktree of state.git.worktrees) {
+      entries.push({ kind: "worktree", key: `w-${worktree.path}`, worktree })
+    }
+  }
+
+  entries.push({ kind: "blank", key: "b-agents" })
+  entries.push({ kind: "heading", key: "h-agents", text: "AI agents" })
+  if (state.agents.length === 0) {
+    entries.push({
+      kind: "note",
+      key: "n-agents",
+      text: "No agents started. Select a worktree and press c (Claude) or x (Codex).",
+    })
+  } else {
+    for (const agent of state.agents) entries.push({ kind: "agent", key: `a-${agent.id}`, agent })
+  }
+  return entries
+}
+
+function selectable(entry: WorktreeEntry | undefined): boolean {
+  return entry?.kind === "worktree" || entry?.kind === "agent"
+}
+
+export function selectedWorktreeEntry(state: AppState): WorktreeEntry | undefined {
+  const entry = worktreeEntries(state)[state.ui.selection.worktrees]
+  return selectable(entry) ? entry : undefined
+}
+
+/**
+ * Git worktrees and the AI agents working in them.
+ *
+ * Keys act on the highlighted row: worktree actions on a worktree, stop/logs
+ * on an agent session. Everything here is also in the palette.
+ */
+export class WorktreesView extends View {
+  readonly id: ViewId = "worktrees"
+  readonly title = "Worktrees"
+
+  private readonly list: RowList
+  private entries: WorktreeEntry[] = []
+  /**
+   * The highlighted row's key. Rows shift when worktrees or agents appear, so
+   * the selection follows the row, not its index - `s` must never stop the
+   * wrong agent.
+   */
+  private selectedKey: string | undefined
+
+  constructor(deps: ViewDeps) {
+    super(deps)
+    this.list = new RowList(deps.ctx, { flexGrow: 1 })
+    this.box.add(this.list.box)
+  }
+
+  update(state: AppState): void {
+    this.entries = worktreeEntries(state)
+    const width = Math.max(40, state.ui.width - (state.ui.sidebarVisible ? 26 : 4))
+    const labelWidth = Math.min(30, Math.max(14, Math.floor(width * 0.3)))
+
+    let selected = state.ui.selection.worktrees
+    const followed = this.selectedKey ? this.entries.findIndex((entry) => entry.key === this.selectedKey) : -1
+    if (followed !== -1) selected = followed
+    else if (!selectable(this.entries[selected])) selected = this.entries.findIndex(selectable)
+    if (selected !== -1 && selected !== state.ui.selection.worktrees) {
+      setSelection(this.deps.app.store, "worktrees", selected)
+    }
+    this.selectedKey = this.entries[selected]?.key
+
+    const rows: ListRow[] = this.entries.map((entry) => {
+      switch (entry.kind) {
+        case "heading":
+          return {
+            key: entry.key,
+            disabled: true,
+            content: styled(chunk((entry.text ?? "").toUpperCase(), theme.accent)),
+          }
+        case "blank":
+          return { key: entry.key, disabled: true, content: "" }
+        case "note":
+          return { key: entry.key, disabled: true, content: styled(dim(`  ${entry.text ?? ""}`)) }
+        case "worktree":
+          return {
+            key: entry.key,
+            content: this.worktreeRow(entry.worktree as GitWorktree, state, labelWidth, width),
+          }
+        case "agent":
+          return { key: entry.key, content: this.agentRow(entry.agent as AgentSession, width) }
+      }
+    })
+
+    this.list.setRows(rows, selected)
+  }
+
+  private worktreeRow(worktree: GitWorktree, state: AppState, labelWidth: number, width: number) {
+    const agents = state.agents.filter(
+      (agent) => isActive(agent.status) && isInside(agent.cwd, worktree.path),
+    )
+    const flags = [
+      worktree.isMain ? "main" : undefined,
+      worktree.locked ? "locked" : undefined,
+      worktree.prunable ? "prunable" : undefined,
+    ].filter(Boolean)
+    const pathWidth = Math.max(10, width - labelWidth - 24)
+
+    return styled(
+      chunk(worktree.isCurrent ? "● " : "○ ", worktree.isCurrent ? theme.accent : theme.textDim),
+      chunk(fit(worktreeLabel(worktree), labelWidth), worktree.isCurrent ? theme.textBright : theme.text),
+      dim(fit(tildify(worktree.path), pathWidth)),
+      agents.length > 0
+        ? chunk(fit(` ${agents.length} agent${agents.length === 1 ? "" : "s"} ▸`, 12), theme.success)
+        : dim(fit("", 12)),
+      worktree.locked || worktree.prunable ? chunk(flags.join(" "), theme.warning) : dim(flags.join(" ")),
+    )
+  }
+
+  private agentRow(agent: AgentSession, width: number) {
+    const where = agent.branch ?? tildify(agent.cwd)
+    const elapsed = isActive(agent.status)
+      ? formatDuration(Date.now() - agent.startedAt.getTime())
+      : agent.exitCode !== undefined
+        ? `exit ${agent.exitCode}`
+        : ""
+    return styled(
+      ...processBadge(agent.status).chunks,
+      " ",
+      chunk(fit(agent.agentName, 13), theme.textBright),
+      chunk(fit(where, 24), theme.text),
+      dim(fit(agent.task, Math.max(10, width - 64))),
+      dim(elapsed),
+    )
+  }
+
+  override handleKey(key: KeyEvent, state: AppState): boolean {
+    const index = state.ui.selection.worktrees
+    const entry = this.entries[index]
+    const worktree = entry?.worktree
+    const agent = entry?.agent
+    const app = this.deps.app
+
+    switch (key.name) {
+      case "up":
+      case "k":
+        this.move(index, -1)
+        return true
+      case "down":
+      case "j":
+        this.move(index, 1)
+        return true
+      case "n":
+        void app.createWorktree()
+        return true
+      case "r":
+        void app.git.refresh().then(() => app.notify("info", "Worktrees refreshed"))
+        return true
+      case "d":
+        if (worktree) void app.removeWorktree(worktree)
+        else app.notify("warn", "Select a worktree to remove")
+        return true
+      case "o":
+      case "return":
+        if (agent) this.showLogs(agent)
+        else if (worktree) void this.openProject(worktree)
+        return true
+      case "t":
+        void app.openInTerminal(worktree?.path ?? agent?.cwd ?? state.project.rootDir)
+        return true
+      case "e":
+        void app.openInEditor(worktree?.path ?? agent?.cwd ?? state.project.rootDir)
+        return true
+      case "c":
+        void app.launchAgent("claude", worktree)
+        return true
+      case "x":
+        void app.launchAgent("codex", worktree)
+        return true
+      case "s":
+        if (agent && isActive(agent.status)) void this.stopAgent(agent)
+        else if (agent) app.notify("info", `${agent.agentName} is not running`)
+        return true
+      case "l":
+        if (agent) {
+          this.showLogs(agent)
+          return true
+        }
+        return false
+      default:
+        return false
+    }
+  }
+
+  override hints(): KeyHint[] {
+    return [
+      { keys: "↑↓", label: "select" },
+      { keys: "n", label: "new" },
+      { keys: "d", label: "remove" },
+      { keys: "o", label: "open" },
+      { keys: "t/e", label: "terminal/editor" },
+      { keys: "c/x", label: "claude/codex" },
+      { keys: "s", label: "stop agent" },
+      { keys: "r", label: "refresh" },
+    ]
+  }
+
+  private move(from: number, direction: 1 | -1): void {
+    for (let index = from + direction; index >= 0 && index < this.entries.length; index += direction) {
+      if (selectable(this.entries[index])) {
+        this.selectedKey = this.entries[index]?.key
+        setSelection(this.deps.app.store, "worktrees", index)
+        return
+      }
+    }
+  }
+
+  private async openProject(worktree: GitWorktree): Promise<void> {
+    if (worktree.isCurrent) {
+      this.deps.app.notify("info", "devcc is already showing this worktree")
+      return
+    }
+    await this.deps.app.switchProject(worktree.path)
+  }
+
+  private showLogs(agent: AgentSession): void {
+    updateUi(this.deps.app.store, { logSource: agent.id, view: "logs" })
+  }
+
+  private async stopAgent(agent: AgentSession): Promise<void> {
+    try {
+      await this.deps.app.agents.stop(agent.id)
+      this.deps.app.notify("info", `Stopped ${agent.agentName}`)
+    } catch (error) {
+      this.deps.app.notify("error", errorMessage(error))
+    }
+  }
+}