cru-teams 1.0.0

package/src/commands/tasks.ts

@@ -0,0 +1,110 @@
+import { z } from 'incur'
+import { readFileSync, readdirSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+import { listTeams } from '@/lib/teams'
+
+function listTaskTeams(): string[] {
+  const dir = join(homedir(), '.claude', 'tasks')
+  if (!existsSync(dir)) return []
+  return readdirSync(dir).filter((f) => {
+    const full = join(dir, f)
+    try { return readdirSync(full).some((e) => e.endsWith('.json')) } catch { return false }
+  })
+}
+
+interface Task {
+  id: string
+  subject: string
+  description?: string
+  status: string
+  owner?: string
+  activeForm?: string
+  blocks: string[]
+  blockedBy: string[]
+}
+
+function tasksDir(teamName: string): string {
+  return join(homedir(), '.claude', 'tasks', teamName)
+}
+
+function readTasks(teamName: string): Task[] {
+  const dir = tasksDir(teamName)
+  if (!existsSync(dir)) return []
+
+  const tasks: Task[] = []
+  for (const file of readdirSync(dir)) {
+    if (!file.endsWith('.json')) continue
+    try {
+      tasks.push(JSON.parse(readFileSync(join(dir, file), 'utf-8')))
+    } catch {}
+  }
+  return tasks.sort((a, b) => Number(a.id) - Number(b.id))
+}
+
+const BOLD = '\x1b[1m'
+const DIM = '\x1b[2m'
+const RESET = '\x1b[0m'
+const GREEN = '\x1b[32m'
+const YELLOW = '\x1b[33m'
+const RED = '\x1b[31m'
+const CYAN = '\x1b[36m'
+
+function statusIcon(status: string): string {
+  switch (status) {
+    case 'completed': return `${GREEN}✓${RESET}`
+    case 'in_progress': return `${YELLOW}◉${RESET}`
+    case 'blocked': return `${RED}✗${RESET}`
+    default: return `${DIM}○${RESET}`
+  }
+}
+
+export const tasks = {
+  description: 'List tasks for a team',
+  args: z.object({
+    team: z.string().optional().describe('Team name (omit to show tasks from all active teams)'),
+  }),
+  options: z.object({
+    all: z.boolean().default(false).describe('Include tasks from all teams (not just active)'),
+    status: z.enum(['pending', 'in_progress', 'completed', 'blocked']).optional().describe('Filter by status'),
+  }),
+  run(c) {
+    const teamNames = c.args.team ? [c.args.team] : listTaskTeams()
+    if (teamNames.length === 0) return { teams: [], message: 'No teams found' }
+
+    const result: Array<{ team: string; tasks: Task[] }> = []
+
+    for (const name of teamNames) {
+      let teamTasks = readTasks(name)
+      if (teamTasks.length === 0) continue
+      if (c.options.status) {
+        teamTasks = teamTasks.filter((t) => t.status === c.options.status)
+      }
+      if (teamTasks.length > 0) {
+        result.push({ team: name, tasks: teamTasks })
+      }
+    }
+
+    if (result.length === 0) {
+      return { teams: [], message: 'No tasks found' }
+    }
+
+    if (c.agent) {
+      return { teams: result }
+    }
+
+    // Human-readable output
+    for (const { team, tasks: teamTasks } of result) {
+      const done = teamTasks.filter((t) => t.status === 'completed').length
+      console.log(`\n${BOLD}${team}${RESET} ${DIM}— ${done}/${teamTasks.length} done${RESET}`)
+
+      for (const t of teamTasks) {
+        const icon = statusIcon(t.status)
+        const owner = t.owner ? ` ${CYAN}@${t.owner}${RESET}` : ''
+        const blocked = t.blockedBy.length > 0 ? ` ${RED}blocked by ${t.blockedBy.join(', ')}${RESET}` : ''
+        console.log(`  ${icon} ${DIM}#${t.id}${RESET} ${t.subject}${owner}${blocked}`)
+      }
+    }
+    console.log()
+  },
+}

package/src/commands/teams.ts

@@ -0,0 +1,102 @@
+import { z } from 'incur'
+import { readTeamConfig, listTeams as getTeams } from '@/lib/teams'
+import { loadPanes, isTeamAlive } from '@/lib/panes'
+
+function age(createdAt: number): string {
+  const ms = Date.now() - createdAt
+  const mins = Math.floor(ms / 60_000)
+  if (mins < 60) return `${mins}m ago`
+  const hrs = Math.floor(mins / 60)
+  if (hrs < 24) return `${hrs}h ago`
+  const days = Math.floor(hrs / 24)
+  return `${days}d ago`
+}
+
+function teamDetail(teamName: string) {
+  const config = readTeamConfig(teamName)
+  const cruPanes = loadPanes(teamName)
+
+  const members = config.members.map((m) => ({
+    name: m.name,
+    role: m.agentType || 'worker',
+    pane: m.tmuxPaneId || 'none',
+    color: m.color || '',
+    active: m.isActive ?? true,
+  }))
+
+  // Merge workers from cru pane tracking that aren't in Claude's config yet
+  if (cruPanes) {
+    const known = new Set(members.map((m) => m.name))
+    for (const w of cruPanes.workers) {
+      if (!known.has(w.name)) {
+        members.push({
+          name: w.name,
+          role: 'worker',
+          pane: w.paneId,
+          color: w.color,
+          active: true,
+        })
+      }
+    }
+    for (const m of members) {
+      if (m.pane === 'none') {
+        const tracked = cruPanes.workers.find((w) => w.name === m.name)
+        if (tracked) {
+          m.pane = tracked.paneId
+          if (!m.color) m.color = tracked.color
+        }
+        if (m.name === 'team-lead') m.pane = cruPanes.leadPane
+      }
+    }
+  }
+
+  return {
+    team: config.name,
+    description: config.description,
+    status: isTeamAlive(teamName) ? 'active' : 'dead',
+    age: age(config.createdAt),
+    members,
+  }
+}
+
+export const teams = {
+  description: 'List teams or show team detail',
+  args: z.object({
+    team: z.string().optional().describe('Team name (omit to list all teams)'),
+  }),
+  options: z.object({
+    all: z.boolean().default(false).describe('Include dead teams'),
+  }),
+  run(c) {
+    // Show detail for a specific team
+    if (c.args.team) return teamDetail(c.args.team)
+
+    // List all teams
+    const teamNames = getTeams()
+    if (teamNames.length === 0) return { teams: [], message: 'No teams' }
+
+    const result = teamNames.map((t) => {
+      const config = readTeamConfig(t)
+      const alive = isTeamAlive(t)
+      return {
+        name: config.name,
+        members: config.members.length,
+        status: alive ? 'active' : 'dead',
+        age: age(config.createdAt),
+        description: config.description,
+      }
+    })
+
+    const filtered = c.options.all ? result : result.filter((t) => t.status === 'active')
+
+    if (filtered.length === 0 && !c.options.all) {
+      const dead = result.length
+      if (!c.agent && dead > 0) {
+        console.log(`No active teams (${dead} dead — use --all to show, or 'cru clean' to remove)`)
+      }
+      return { teams: [], message: 'No active teams' }
+    }
+
+    return { teams: filtered }
+  },
+}

package/src/lib/config.ts

@@ -0,0 +1,61 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+import type { LayoutConf } from './tmux'
+
+export const CONFIG_NAME = '.cru.json'
+
+export interface CruConfig {
+  layout: LayoutConf
+}
+
+export const DEFAULTS: CruConfig = {
+  layout: {
+    lead: { position: 'left', size: 40 },
+    grid: { fill: 'row', maxCols: null, maxRows: null },
+  },
+}
+
+export function configPaths(): string[] {
+  return [
+    join(process.cwd(), CONFIG_NAME),
+    join(homedir(), '.config', 'cru', 'config.json'),
+  ]
+}
+
+export function loadConfig(): CruConfig {
+  for (const p of configPaths()) {
+    if (existsSync(p)) {
+      try {
+        const raw = JSON.parse(readFileSync(p, 'utf-8'))
+        return deepMerge(structuredClone(DEFAULTS), raw)
+      } catch {
+        // malformed — fall through
+      }
+    }
+  }
+  return structuredClone(DEFAULTS)
+}
+
+export function writeConfig(path: string, config: CruConfig): void {
+  mkdirSync(join(path, '..'), { recursive: true })
+  writeFileSync(path, JSON.stringify(config, null, 2) + '\n')
+}
+
+export function deepMerge<T extends Record<string, any>>(target: T, source: Record<string, any>): T {
+  const t = target as Record<string, any>
+  for (const key of Object.keys(source)) {
+    if (
+      source[key] &&
+      typeof source[key] === 'object' &&
+      !Array.isArray(source[key]) &&
+      t[key] &&
+      typeof t[key] === 'object'
+    ) {
+      deepMerge(t[key], source[key])
+    } else {
+      t[key] = source[key]
+    }
+  }
+  return target
+}

package/src/lib/env.ts

@@ -0,0 +1,45 @@
+import { execSync } from 'node:child_process'
+
+/** Check if a binary exists on PATH. Returns its path or null. */
+export function hasBinary(name: string): string | null {
+  try {
+    return execSync(`which ${name}`, { encoding: 'utf-8' }).trim()
+  } catch {
+    return null
+  }
+}
+
+/** Get version string from a command, or null on failure. */
+export function getVersion(cmd: string): string | null {
+  try {
+    return execSync(cmd, { encoding: 'utf-8' }).trim()
+  } catch {
+    return null
+  }
+}
+
+/** Check if we're inside an active tmux session. */
+export function inTmux(): boolean {
+  return !!process.env.TMUX
+}
+
+/** Detect terminal emulator from environment. */
+export function detectTerminal(): string {
+  // Check TERM_PROGRAM first — it reflects the actual terminal in use,
+  // while vars like ITERM_SESSION_ID can leak from parent processes.
+  const tp = process.env.TERM_PROGRAM
+  if (tp === 'vscode') return 'vscode'
+  if (tp === 'iTerm.app') return 'iterm2'
+  if (tp === 'Apple_Terminal') return 'terminal'
+  if (tp === 'WezTerm') return 'wezterm'
+  if (tp === 'ghostty') return 'ghostty'
+  if (tp === 'Alacritty') return 'alacritty'
+  if (process.env.ITERM_SESSION_ID) return 'iterm2'
+  if (process.env.WT_SESSION) return 'windows-terminal'
+  return tp || 'unknown'
+}
+
+/** Check if we're in Ghostty without tmux (native pane mode). */
+export function inGhostty(): boolean {
+  return detectTerminal() === 'ghostty' && !inTmux()
+}

package/src/lib/ghostty.ts

@@ -0,0 +1,153 @@
+import { execFileSync, execSync } from 'node:child_process'
+
+/** Run an AppleScript snippet targeting Ghostty. */
+export function ghostty(script: string): string {
+  const wrapped = `tell application "Ghostty"\n${script}\nend tell`
+  return execSync('osascript', { input: wrapped, encoding: 'utf-8' }).trim()
+}
+
+/**
+ * Find the Ghostty terminal ID that THIS process is running in.
+ *
+ * Ghostty's AppleScript API doesn't expose PID or TTY per terminal,
+ * so we correlate via creation order:
+ * 1. Walk up the process tree to find our ancestor TTY
+ * 2. Find all of Ghostty's direct children (login processes) + their TTYs
+ * 3. Get all terminal IDs from AppleScript
+ * 4. Both lists are in creation order — match by position
+ *
+ * Falls back to the focused terminal if the lookup fails.
+ */
+export function currentTerminal(): string {
+  try {
+    // 1. Walk up from our PID to find the ancestor TTY
+    let pid = process.pid
+    let ourTty: string | null = null
+    for (let i = 0; i < 20; i++) {
+      const info = execFileSync('ps', ['-o', 'pid=,ppid=,tty=', '-p', String(pid)], { encoding: 'utf-8' }).trim()
+      const parts = info.split(/\s+/)
+      const tty = parts[2]
+      if (tty && tty !== '??' && !tty.startsWith('??')) {
+        ourTty = tty
+        break
+      }
+      pid = parseInt(parts[1])
+      if (!pid || pid <= 1) break
+    }
+    if (!ourTty) throw new Error('Could not find TTY')
+
+    // 2. Find Ghostty's PID
+    const ghosttyPid = execFileSync(
+      'ps', ['-ax', '-o', 'pid=,comm='],
+      { encoding: 'utf-8' },
+    ).split('\n')
+      .find((l) => l.includes('Ghostty.app/Contents/MacOS/ghostty'))
+      ?.trim().split(/\s+/)[0]
+    if (!ghosttyPid) throw new Error('Ghostty process not found')
+
+    // 3. Find all Ghostty children (login processes) sorted by PID (= creation order)
+    const children = execFileSync(
+      'ps', ['-ax', '-o', 'pid=,ppid=,tty='],
+      { encoding: 'utf-8' },
+    ).split('\n')
+      .map((l) => l.trim().split(/\s+/))
+      .filter((p) => p[1] === ghosttyPid)
+      .sort((a, b) => parseInt(a[0]) - parseInt(b[0]))
+
+    // 4. Find our position in the children list
+    const ourIndex = children.findIndex((c) => c[2] === ourTty)
+    if (ourIndex < 0) throw new Error(`TTY ${ourTty} not found in Ghostty children`)
+
+    // 5. Get terminal IDs from AppleScript (same creation order)
+    const terminalIds = listAllTerminals()
+    if (ourIndex >= terminalIds.length) throw new Error('Terminal index out of range')
+
+    return terminalIds[ourIndex]
+  } catch {
+    // Fallback: use the focused terminal (original behavior)
+    return ghostty('get id of focused terminal of selected tab of front window')
+  }
+}
+
+/** Get the frontmost window ID. */
+export function currentWindow(): string {
+  return ghostty('get id of front window')
+}
+
+/** List all terminals in the front window with their IDs. */
+export function listTerminals(_windowId?: string): Array<{ id: string; index: number }> {
+  // Ghostty's window id format doesn't work with `window id` in AppleScript.
+  // Use front window — caller should ensure the right window is focused.
+  const ids = ghostty('get id of every terminal of front window')
+  if (!ids) return []
+  return ids.split(', ').map((id, i) => ({ id, index: i }))
+}
+
+/** List all terminal IDs across all windows. */
+export function listAllTerminals(): string[] {
+  const ids = ghostty('get id of every terminal')
+  if (!ids) return []
+  return ids.split(', ')
+}
+
+/** Split a terminal and return the new terminal's ID. */
+export function splitTerminal(terminalId: string, direction: 'right' | 'down'): string {
+  // Snapshot terminal IDs before split
+  const before = new Set(listAllTerminals())
+  ghostty(`split terminal id "${terminalId}" direction ${direction}`)
+  // Find the new terminal by diffing
+  const after = listAllTerminals()
+  const newId = after.find((id) => !before.has(id))
+  if (!newId) throw new Error('Split did not create a new terminal')
+  return newId
+}
+
+/** Close a terminal. */
+export function closeTerminal(terminalId: string): void {
+  try {
+    ghostty(`close terminal id "${terminalId}"`)
+  } catch {
+    // terminal may already be closed
+  }
+}
+
+/** Send paste-style text input to a terminal. */
+export function inputText(terminalId: string, text: string): void {
+  const escaped = text.replace(/\\/g, '\\\\').replace(/"/g, '\\"')
+  ghostty(`input text "${escaped}" to terminal id "${terminalId}"`)
+}
+
+/** Send a key press to a terminal. */
+export function sendKey(terminalId: string, key: string): void {
+  ghostty(`send key "${key}" to terminal id "${terminalId}"`)
+}
+
+/** Send text followed by Enter (like typing a command). */
+export function sendCommand(terminalId: string, text: string): void {
+  inputText(terminalId, text)
+  sendKey(terminalId, 'enter')
+}
+
+/** Focus a terminal and bring its window to front. */
+export function focusTerminal(terminalId: string): void {
+  ghostty(`focus terminal id "${terminalId}"`)
+}
+
+/** Get Ghostty version string. */
+export function ghosttyVersion(): string | null {
+  try {
+    return ghostty('get version')
+  } catch {
+    return null
+  }
+}
+
+/** Check if Ghostty is running and scriptable. */
+export function isGhosttyScriptable(): boolean {
+  try {
+    ghostty('get name')
+    return true
+  } catch {
+    return false
+  }
+}

package/src/lib/layout.ts

@@ -0,0 +1,162 @@
+import type { LayoutConf } from './tmux'
+
+export function computeGrid(N: number, conf: LayoutConf): { cols: number; rows: number } {
+  let cols = Math.ceil(Math.sqrt(N))
+  let rows = Math.ceil(N / cols)
+
+  if (conf.grid.maxCols && cols > conf.grid.maxCols) {
+    cols = conf.grid.maxCols
+    rows = Math.ceil(N / cols)
+  }
+  if (conf.grid.maxRows && rows > conf.grid.maxRows) {
+    rows = conf.grid.maxRows
+    cols = Math.ceil(N / rows)
+  }
+  return { cols, rows }
+}
+
+export function buildLayout(
+  W: number, H: number, leadId: number | string, workerIds: (number | string)[], conf: LayoutConf,
+): string {
+  const pos = conf.lead.position
+  const sizePct = conf.lead.size
+  const N = workerIds.length
+  const { cols, rows } = computeGrid(N, conf)
+  const isHorizontal = pos === 'left' || pos === 'right'
+
+  const leadSize = Math.floor(((isHorizontal ? W : H) * sizePct) / 100)
+  const gridTotal = (isHorizontal ? W : H) - leadSize - 1
+  const gridCross = isHorizontal ? H : W
+
+  const colSizes = distribute(isHorizontal ? gridTotal : gridCross, cols)
+  const rowSizes = distribute(isHorizontal ? gridCross : gridTotal, rows)
+
+  const ordered =
+    conf.grid.fill === 'column'
+      ? reorderColumnFirst(workerIds, rows, cols)
+      : workerIds
+
+  const leadFirst = pos === 'left' || pos === 'top'
+  const gridOrigin = leadFirst ? leadSize + 1 : 0
+  const leadOrigin = leadFirst ? 0 : gridTotal + 1
+
+  const rowLayouts = buildRows({
+    rows,
+    cols,
+    N,
+    rowSizes,
+    colSizes,
+    gridOrigin,
+    gridTotal,
+    ordered,
+    isHorizontal,
+  })
+
+  let gridLayout: string
+  if (rowLayouts.length === 1) {
+    gridLayout = rowLayouts[0]
+  } else {
+    const gx = isHorizontal ? gridOrigin : 0
+    const gy = isHorizontal ? 0 : gridOrigin
+    const gw = isHorizontal ? gridTotal : W
+    const gh = isHorizontal ? H : gridTotal
+    const bracket = isHorizontal
+      ? `[${rowLayouts.join(',')}]`
+      : `{${rowLayouts.join(',')}}`
+    gridLayout = `${gw}x${gh},${gx},${gy}${bracket}`
+  }
+
+  const lx = isHorizontal ? leadOrigin : leadFirst ? 0 : gridTotal + 1
+  const ly = isHorizontal ? 0 : leadFirst ? 0 : gridTotal + 1
+  const lw = isHorizontal ? leadSize : W
+  const lh = isHorizontal ? H : leadSize
+  const leadLayout = `${lw}x${lh},${lx},${ly},${leadId}`
+
+  const parts = leadFirst
+    ? [leadLayout, gridLayout]
+    : [gridLayout, leadLayout]
+  const outerBracket = isHorizontal
+    ? `{${parts.join(',')}}`
+    : `[${parts.join(',')}]`
+
+  return `${W}x${H},0,0${outerBracket}`
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+function distribute(total: number, count: number): number[] {
+  const base = Math.floor((total - (count - 1)) / count)
+  const sizes = Array(count).fill(base)
+  sizes[count - 1] = total - (count - 1) - base * (count - 1)
+  return sizes
+}
+
+function reorderColumnFirst<T>(ids: T[], rows: number, cols: number): T[] {
+  const out: T[] = []
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const idx = c * rows + r
+      if (idx < ids.length) out.push(ids[idx])
+    }
+  }
+  return out
+}
+
+interface BuildRowsOpts {
+  rows: number
+  cols: number
+  N: number
+  rowSizes: number[]
+  colSizes: number[]
+  gridOrigin: number
+  gridTotal: number
+  ordered: (number | string)[]
+  isHorizontal: boolean
+}
+
+function buildRows(opts: BuildRowsOpts): string[] {
+  const {
+    rows, cols, N, rowSizes, colSizes,
+    gridOrigin, gridTotal, ordered, isHorizontal,
+  } = opts
+  const rowLayouts: string[] = []
+  let idx = 0
+  let primaryOffset = 0
+
+  for (let r = 0; r < rows; r++) {
+    const rSize = rowSizes[r]
+    const cellParts: string[] = []
+    let secondaryOffset = gridOrigin
+
+    for (let c = 0; c < cols; c++) {
+      if (idx >= N) break
+      let cSize = colSizes[c]
+      // Last pane in an incomplete row — expand to fill remaining space
+      if (idx === N - 1 && c < cols - 1) {
+        cSize = gridTotal - (secondaryOffset - gridOrigin)
+      }
+      const x = isHorizontal ? secondaryOffset : primaryOffset
+      const y = isHorizontal ? primaryOffset : secondaryOffset
+      const w = isHorizontal ? cSize : rSize
+      const h = isHorizontal ? rSize : cSize
+      cellParts.push(`${w}x${h},${x},${y},${ordered[idx]}`)
+      secondaryOffset += cSize + 1
+      idx++
+    }
+
+    if (cellParts.length === 1) {
+      rowLayouts.push(cellParts[0])
+    } else {
+      const x = isHorizontal ? gridOrigin : primaryOffset
+      const y = isHorizontal ? primaryOffset : gridOrigin
+      const w = isHorizontal ? gridTotal : rSize
+      const h = isHorizontal ? rSize : gridTotal
+      rowLayouts.push(`${w}x${h},${x},${y}{${cellParts.join(',')}}`)
+    }
+    primaryOffset += rSize + 1
+  }
+
+  return rowLayouts
+}