@pellux/goodvibes-tui 0.27.0 → 0.29.0

package/src/panels/worktree-panel.ts

@@ -1,37 +1,120 @@
 import type { Line } from '../types/grid.ts';
 import { createEmptyLine } from '../types/grid.ts';
+import { basename } from 'node:path';
 import { ScrollableListPanel } from './scrollable-list-panel.ts';
-import { buildKeyValueLine, buildPanelLine, buildPanelWorkspace, DEFAULT_PANEL_PALETTE, resolvePrimaryScrollableSection, type PanelWorkspaceSection } from './polish.ts';
-import { summarizeWorktreeOwnership, type WorktreeRegistry, type WorktreeStatusRecord } from '@/runtime/index.ts';
-
-const C = {
-  ...DEFAULT_PANEL_PALETTE,
-  dim: '#475569',
-  info: '#38bdf8',
-  ok: '#22c55e',
-  warn: '#eab308',
-  headerBg: '#1e293b',
-} as const;
+import { buildAlignedRow, buildKeyValueLine, buildKeyboardHints, buildPanelLine, buildPanelWorkspace, DEFAULT_PANEL_PALETTE, resolvePrimaryScrollableSection, type ColumnSpec, type PanelWorkspaceSection } from './polish.ts';
+import { type ConfirmState, handleConfirmInput, renderConfirmLines } from './confirm-state.ts';
+import { summarizeWorktreeOwnership, type WorktreeStatusRecord } from '@/runtime/index.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import type { PanelIntegrationContext } from './types.ts';
+
+// Base chrome only — state colors and text tokens come straight from
+// DEFAULT_PANEL_PALETTE (WO-002).
+const C = DEFAULT_PANEL_PALETTE;
+
+/**
+ * Structural shape the panel actually needs from a worktree registry. The
+ * real `WorktreeRegistry` (from the SDK) satisfies this directly; it has no
+ * `subscribe()` method today, so the panel falls back to polling when one
+ * isn't provided (see constructor). Kept narrow and `Like`-suffixed per the
+ * project's duck-typing convention (see `agent-inspector-shared.ts`).
+ */
+export interface WorktreeRegistryLike {
+  list(): Promise<WorktreeStatusRecord[]>;
+  attach(path: string, target: { sessionId?: string; taskId?: string }): void;
+  setState(path: string, state: WorktreeStatusRecord['state']): void;
+  cleanup(path: string): Promise<void>;
+  /** Optional live-update hook; when present the panel prefers it over polling. */
+  subscribe?(listener: () => void): () => void;
+}
+
+/** What a pending destructive confirm will do once the user confirms. */
+interface WorktreeConfirmSubject {
+  readonly path: string;
+  readonly action: 'discard' | 'cleanup';
+}
+
+/** Poll cadence used only when the registry has no `subscribe()` method. */
+const POLL_INTERVAL_MS = 5_000;
 
 function stateColor(state: WorktreeStatusRecord['state']): string {
   switch (state) {
-    case 'active': return C.ok;
+    case 'active': return C.good;
     case 'paused':
     case 'kept': return C.warn;
     default: return C.dim;
   }
 }
 
+/** Glyph that reads at a glance: ● active, ◌ paused/kept, ⊘ discard/cleanup. */
+function stateGlyph(state: WorktreeStatusRecord['state']): string {
+  switch (state) {
+    case 'active': return '●';
+    case 'paused':
+    case 'kept': return '◌';
+    default: return '⊘';
+  }
+}
+
+/**
+ * One worktree row, aligned with display-width-aware columns so a wide-char or
+ * long branch name never shoves the path column out of alignment. The active
+ * worktree is flagged with a ● glyph and selection uses the shared marker.
+ */
+function buildWorktreeRow(width: number, row: WorktreeStatusRecord, selected: boolean): Line {
+  const pathW = Math.max(8, width - (2 + 10 + 13 + 20) - 4 - 2);
+  const columns: ColumnSpec[] = [
+    { width: 2 },
+    { width: 10 },
+    { width: 13 },
+    { width: 20 },
+    { width: pathW },
+  ];
+  return buildAlignedRow(
+    width,
+    [
+      { text: stateGlyph(row.state), fg: stateColor(row.state) },
+      { text: row.kind, fg: C.info },
+      { text: row.state, fg: stateColor(row.state) },
+      { text: row.branch, fg: C.value },
+      { text: basename(row.path) || row.path, fg: C.dim },
+    ],
+    columns,
+    { selected, selectedBg: C.headerBg, marker: '▸' },
+  );
+}
+
+const WORKTREE_HINTS = [
+  { keys: '↑/↓', label: 'select' },
+  { keys: 'p/u/k', label: 'pause/resume/keep' },
+  { keys: 'd/c', label: 'discard/cleanup' },
+  { keys: 'enter', label: 'jump to session/task' },
+  { keys: 'r', label: 'refresh' },
+] as const;
+
 export class WorktreePanel extends ScrollableListPanel<WorktreeStatusRecord> {
   private rows: WorktreeStatusRecord[] = [];
   private loading = false;
-  private readonly worktreeRegistry: WorktreeRegistry;
+  private confirm: ConfirmState<WorktreeConfirmSubject> | null = null;
+  private pendingJump: { targetPanel: 'sessions' | 'tasks' } | null = null;
+  private readonly worktreeRegistry: WorktreeRegistryLike;
+  private readonly requestRender: () => void;
+  private unsubscribe: (() => void) | null = null;
 
-  public constructor(worktreeRegistry: WorktreeRegistry) {
-    super('worktrees', 'Worktrees', 'W', 'monitoring');
+  public constructor(worktreeRegistry: WorktreeRegistryLike, requestRender: () => void = () => {}) {
+    super('worktrees', 'Worktrees', '▯', 'automation-control');
     this.showSelectionGutter = true; // I5: non-color selection affordance
     this.worktreeRegistry = worktreeRegistry;
+    this.requestRender = requestRender;
     void this.refresh();
+    // Live state: prefer a registry subscription when the caller provides one
+    // (matches the mock shape used by contract tests); otherwise poll, so the
+    // real SDK WorktreeRegistry (which has no subscribe() today) still stays live.
+    if (typeof this.worktreeRegistry.subscribe === 'function') {
+      this.unsubscribe = this.worktreeRegistry.subscribe(() => { void this.refresh(); });
+    } else {
+      this.registerTimer(setInterval(() => { void this.refresh(); }, POLL_INTERVAL_MS));
+    }
   }
 
   public override onActivate(): void {
@@ -39,26 +122,108 @@ export class WorktreePanel extends ScrollableListPanel<WorktreeStatusRecord> {
     if (!this.loading) void this.refresh();
   }
 
-  public handleInput(key: string): boolean {
+  public override onDestroy(): void {
+    super.onDestroy();
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+    }
+  }
+
+  public override handleInput(key: string): boolean {
+    if (this.lastError !== null) this.clearError();
+
+    const confirmResult = handleConfirmInput(this.confirm, key);
+    if (confirmResult === 'confirmed') {
+      const subject = this.confirm!.subject;
+      this.confirm = null;
+      if (subject.action === 'discard') {
+        this.worktreeRegistry.setState(subject.path, 'discard');
+        void this.refresh();
+      } else {
+        void this._cleanup(subject.path);
+      }
+      this.markDirty();
+      return true;
+    }
+    if (confirmResult === 'cancelled') {
+      this.confirm = null;
+      this.markDirty();
+      return true;
+    }
+    if (confirmResult === 'absorbed') return true;
+
     if (key === 'r') {
       void this.refresh();
       return true;
     }
+
+    const selected = this.getSelectedItem();
+
+    if (key === 'p' && selected && selected.state !== 'paused') {
+      this.worktreeRegistry.setState(selected.path, 'paused');
+      void this.refresh();
+      return true;
+    }
+    if (key === 'u' && selected && selected.state !== 'active') {
+      this.worktreeRegistry.setState(selected.path, 'active');
+      void this.refresh();
+      return true;
+    }
+    if (key === 'k' && selected && selected.state !== 'kept') {
+      this.worktreeRegistry.setState(selected.path, 'kept');
+      void this.refresh();
+      return true;
+    }
+    if (key === 'd' && selected && selected.state !== 'discard') {
+      this.confirm = {
+        subject: { path: selected.path, action: 'discard' },
+        label: `worktree ${basename(selected.path)} (${selected.branch})`,
+        verb: 'Discard',
+      };
+      this.markDirty();
+      return true;
+    }
+    if (key === 'c' && selected) {
+      this.confirm = {
+        subject: { path: selected.path, action: 'cleanup' },
+        label: `worktree ${basename(selected.path)} (${selected.branch})`,
+        verb: 'Clean up',
+      };
+      this.markDirty();
+      return true;
+    }
+    if ((key === 'enter' || key === 'return') && selected && (selected.sessionId || selected.taskId)) {
+      this.pendingJump = { targetPanel: selected.sessionId ? 'sessions' : 'tasks' };
+      return true;
+    }
+
     return super.handleInput(key);
   }
 
+  /**
+   * Enter on an attached worktree row jumps to the owning session/task panel.
+   * The actual `PanelManager.open()` call requires the integration context,
+   * which is only available here (invoked right after `handleInput` returns
+   * `true` for the same key) — same staged-pending-action pattern as
+   * `incident-review-panel.ts`.
+   */
+  public handlePanelIntegrationAction(_key: string, ctx: PanelIntegrationContext): boolean {
+    if (this.pendingJump) {
+      const jump = this.pendingJump;
+      this.pendingJump = null;
+      ctx.panelManager.open(jump.targetPanel);
+      return true;
+    }
+    return false;
+  }
+
   protected getItems(): readonly WorktreeStatusRecord[] {
     return this.rows;
   }
 
   protected renderItem(row: WorktreeStatusRecord, index: number, _selected: boolean, width: number): Line {
-    const bg = index === this.selectedIndex ? C.headerBg : undefined;
-    return buildPanelLine(width, [
-      [` ${row.kind}`.padEnd(14), C.info, bg],
-      [` ${row.state}`.padEnd(16), stateColor(row.state), bg],
-      [` ${row.branch}`.padEnd(24), C.value, bg],
-      [` ${row.path}`.slice(0, Math.max(0, width - 56)), C.dim, bg],
-    ]);
+    return buildWorktreeRow(width, row, index === this.selectedIndex);
   }
 
   private async refresh(): Promise<void> {
@@ -70,17 +235,45 @@ export class WorktreePanel extends ScrollableListPanel<WorktreeStatusRecord> {
     } finally {
       this.loading = false;
       this.markDirty();
+      this.requestRender();
+    }
+  }
+
+  private async _cleanup(path: string): Promise<void> {
+    try {
+      await this.worktreeRegistry.cleanup(path);
+    } catch (err) {
+      this.setError(summarizeError(err));
+    } finally {
+      await this.refresh();
     }
   }
 
   public render(width: number, height: number): Line[] {
     this.needsRender = false;
+
+    if (this.confirm) {
+      const lines = buildPanelWorkspace(width, height, {
+        title: 'Worktree Control Room',
+        sections: [{ title: 'Confirmation', lines: renderConfirmLines(width, this.confirm) }],
+        palette: C,
+      });
+      while (lines.length < height) lines.push(createEmptyLine(width));
+      return lines.slice(0, height);
+    }
+
     const sections: PanelWorkspaceSection[] = [];
 
     if (this.loading && this.rows.length === 0) {
       sections.push({ title: 'Worktrees', lines: [buildPanelLine(width, [[' Loading worktree state...', C.info]])] });
     } else if (this.rows.length === 0) {
-      sections.push({ title: 'Worktrees', lines: [buildPanelLine(width, [[' No git worktrees discovered for this project.', C.dim]])] });
+      sections.push({
+        title: 'Worktrees',
+        lines: [
+          buildPanelLine(width, [[' No git worktrees discovered for this project yet.', C.dim]]),
+          buildPanelLine(width, [['  /worktree attach <path>', C.info], ['  register a worktree for orchestrator-managed lifecycle', C.dim]]),
+        ],
+      });
     } else {
       const summary = summarizeWorktreeOwnership(this.rows);
       sections.push({
@@ -88,7 +281,7 @@ export class WorktreePanel extends ScrollableListPanel<WorktreeStatusRecord> {
         lines: [
           buildKeyValueLine(width, [
             { label: 'total', value: String(summary.total), valueColor: C.value },
-            { label: 'active', value: String(summary.active), valueColor: C.ok },
+            { label: 'active', value: String(summary.active), valueColor: C.good },
             { label: 'paused', value: String(summary.paused), valueColor: summary.paused > 0 ? C.warn : C.dim },
             { label: 'cleanup', value: String(summary.pendingCleanup), valueColor: summary.pendingCleanup > 0 ? C.warn : C.dim },
           ], C),
@@ -100,19 +293,7 @@ export class WorktreePanel extends ScrollableListPanel<WorktreeStatusRecord> {
           ], C),
         ],
       });
-      sections.push({
-        title: 'Next Actions',
-        lines: [
-          buildPanelLine(width, [[
-            summary.pendingCleanup > 0 || summary.discard > 0
-              ? ' Review pending-cleanup and discard-marked worktrees before they drift from orchestrator ownership.'
-              : ' Worktree ownership is healthy. Use the task and session links below for restore, merge, or cleanup review.',
-            summary.pendingCleanup > 0 || summary.discard > 0 ? C.warn : C.dim,
-          ]]),
-          buildPanelLine(width, [['  /worktree task <task-id>  /worktree session <session-id>  /worktree inspect <path>', C.info]]),
-        ],
-      });
-      const selected = this.rows[this.selectedIndex]!;
+      const selected = this.getSelectedItem()!;
       const detailSection: PanelWorkspaceSection = {
         title: 'Details',
         lines: [
@@ -126,36 +307,30 @@ export class WorktreePanel extends ScrollableListPanel<WorktreeStatusRecord> {
               : ' Unattached worktree detected. Review whether it should be attached, kept, discarded, or cleaned up.',
             selected.sessionId || selected.taskId ? C.info : C.warn,
           ]]),
-          buildPanelLine(width, [[
-            selected.state === 'paused'
-              ? ` Next: /worktree resume ${selected.path}`
-              : selected.state === 'discard' || selected.state === 'pending-cleanup'
-                ? ` Next: /worktree cleanup ${selected.path}`
-                : selected.taskId
-                  ? ` Next: /worktree task ${selected.taskId}`
-                  : selected.sessionId
-                    ? ` Next: /worktree session ${selected.sessionId}`
-                    : ` Next: /worktree inspect ${selected.path}`,
-            C.dim,
-          ]]),
         ],
       };
       const resolvedWorktreesSection = resolvePrimaryScrollableSection(width, height, {
         intro: 'Orchestrator-owned worktree lifecycle, attachments, pause/resume posture, and cleanup state.',
-        footerLines: [buildPanelLine(width, [[' r refresh  /worktree inspect <path>  /worktree attach|pause|resume|keep|discard|cleanup ', C.dim]])],
+        footerLines: [buildKeyboardHints(width, WORKTREE_HINTS, C)],
         palette: C,
         beforeSections: sections,
         section: {
           title: 'Worktrees',
-          scrollableLines: this.rows.map((row, absolute) => {
-            const bg = absolute === this.selectedIndex ? C.headerBg : undefined;
-            return buildPanelLine(width, [
-              [` ${row.kind}`.padEnd(14), C.info, bg],
-              [` ${row.state}`.padEnd(16), stateColor(row.state), bg],
-              [` ${row.branch}`.padEnd(24), C.value, bg],
-              [` ${row.path}`.slice(0, Math.max(0, width - 56)), C.dim, bg],
-            ]);
-          }),
+          fixedLines: [
+            buildAlignedRow(width, [
+              { text: '', fg: C.dim },
+              { text: 'KIND', fg: C.label, bold: true },
+              { text: 'STATE', fg: C.label, bold: true },
+              { text: 'BRANCH', fg: C.label, bold: true },
+              { text: 'WORKTREE', fg: C.label, bold: true },
+            ], [
+              { width: 2 }, { width: 10 }, { width: 13 }, { width: 20 },
+              { width: Math.max(8, width - (2 + 10 + 13 + 20) - 4 - 2) },
+            ], { marker: ' ' }),
+          ],
+          scrollableLines: this.rows.map((row, absolute) =>
+            buildWorktreeRow(width, row, absolute === this.selectedIndex),
+          ),
           selectedIndex: this.selectedIndex,
           scrollOffset: this.scrollStart,
           guardRows: 1,
@@ -169,11 +344,14 @@ export class WorktreePanel extends ScrollableListPanel<WorktreeStatusRecord> {
       sections.push(detailSection);
     }
 
+    const errorLine = this.renderErrorLine(width);
+    if (errorLine) sections.push({ title: 'Error', lines: [errorLine] });
+
     const lines = buildPanelWorkspace(width, height, {
       title: 'Worktree Control Room',
       intro: 'Orchestrator-owned worktree lifecycle, attachments, pause/resume posture, and cleanup state.',
       sections,
-      footerLines: [buildPanelLine(width, [[' r refresh  /worktree inspect <path>  /worktree attach|pause|resume|keep|discard|cleanup ', C.dim]])],
+      footerLines: [buildKeyboardHints(width, WORKTREE_HINTS, C)],
       palette: C,
     });
     while (lines.length < height) lines.push(createEmptyLine(width));

package/src/panels/wrfc-panel-format.ts

@@ -0,0 +1,133 @@
+import { truncateDisplay } from '../utils/terminal-width.ts';
+import type { WrfcState, Constraint, ConstraintFinding } from '@pellux/goodvibes-sdk/platform/agents';
+import { DEFAULT_PANEL_PALETTE, extendPalette } from './polish.ts';
+
+// ---------------------------------------------------------------------------
+// Colour palette + formatting helpers for the WRFC panel.
+//
+// Extracted from wrfc-panel.ts to keep that module under the architecture
+// line-count cap. Leaf module (only polish + terminal-width + sdk types); the
+// panel re-exports the public helpers so ./wrfc-panel.ts stays their import site.
+// ---------------------------------------------------------------------------
+export const C = extendPalette(DEFAULT_PANEL_PALETTE, {
+  // WRFC state-machine colours (domain status -- no shared equivalent)
+  passed:     '#22c55e', // green
+  failed:     '#ef4444', // red
+  reviewing:  '#eab308', // yellow
+  engineering:'#22d3ee', // cyan
+  fixing:     '#f97316', // orange
+  pending:    '#6b7280', // grey
+  gating:     '#a78bfa', // violet
+  committing: '#38bdf8', // sky
+  integrating:'#818cf8', // indigo
+
+  // Issue-severity ramp (domain -- no shared equivalent)
+  issueCrit:  '#ef4444',
+  issueMaj:   '#f97316',
+  issueMin:   '#eab308',
+  issueSug:   '#6b7280',
+
+  // Selection + divider chrome with no shared equivalent
+  selected:   '#1e40af', // selection bg
+  selectedFg: '#f8fafc',
+  border:     '#334155',
+});
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const SPARKLINE_CHARS = '._-:=+*#';
+
+export function sparkline(scores: number[], maxScore = 10): string {
+  if (scores.length === 0) return '';
+  return scores
+    .map(s => {
+      const ratio = Math.max(0, Math.min(1, s / maxScore));
+      const idx   = Math.round(ratio * (SPARKLINE_CHARS.length - 1));
+      return SPARKLINE_CHARS[idx];
+    })
+    .join('');
+}
+
+export function stateColor(state: WrfcState): string {
+  switch (state) {
+    case 'passed':          return C.passed;
+    case 'failed':          return C.failed;
+    case 'reviewing':       return C.reviewing;
+    case 'engineering':     return C.engineering;
+    case 'fixing':          return C.fixing;
+    case 'gating':
+    case 'awaiting_gates':  return C.gating;
+    case 'committing':      return C.committing;
+    case 'integrating':     return C.integrating;
+    default:                return C.pending;
+  }
+}
+
+export function stateLabel(state: WrfcState): string {
+  switch (state) {
+    case 'engineering':    return 'ENG';
+    case 'reviewing':      return 'REV';
+    case 'fixing':         return 'FIX';
+    case 'gating':         return 'GATE';
+    case 'awaiting_gates': return 'WAIT';
+    case 'committing':     return 'COMMIT';
+    case 'integrating':    return 'INTG';
+    case 'passed':         return 'PASS';
+    case 'failed':         return 'FAIL';
+    default:               return 'PEND';
+  }
+}
+
+export function issueColor(severity: string): string {
+  switch (severity) {
+    case 'critical': return C.issueCrit;
+    case 'major':    return C.issueMaj;
+    case 'minor':    return C.issueMin;
+    default:         return C.issueSug;
+  }
+}
+
+export function issuePrefix(severity: string): string {
+  switch (severity) {
+    case 'critical': return '[CRIT] ';
+    case 'major':    return '[MAJR] ';
+    case 'minor':    return '[MINR] ';
+    default:         return '[SUGG] ';
+  }
+}
+
+export function truncate(s: string, max: number): string {
+  return truncateDisplay(s, max);
+}
+
+// ---------------------------------------------------------------------------
+// Constraint helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns display tag, foreground colour, and dim flag for a single constraint
+ * based on whether a reviewer finding exists for it.
+ */
+export function constraintStatusMarker(
+  constraint: Constraint,
+  findings: ConstraintFinding[] | undefined,
+): { tag: string; fg: string; dim: boolean } {
+  const finding = findings?.find(f => f.constraintId === constraint.id);
+  if (!finding) {
+    return { tag: '[UNV]', fg: C.dim, dim: true };
+  }
+  if (finding.satisfied) {
+    return { tag: '[SAT]', fg: C.good, dim: false };
+  }
+  // Unsatisfied — use severity to pick colour and tag text
+  const sev = finding.severity ?? 'major';
+  let sevTag: string;
+  let fg: string;
+  switch (sev) {
+    case 'critical': sevTag = '[UNS CRIT]';  fg = C.issueCrit; break;
+    case 'minor':    sevTag = '[UNS MINOR]'; fg = C.issueMin;  break;
+    default:         sevTag = '[UNS MAJOR]'; fg = C.issueMaj;  break;
+  }
+  return { tag: sevTag, fg, dim: false };
+}