@pellux/goodvibes-agent 0.1.0

package/src/panels/work-plan-panel.ts

@@ -0,0 +1,175 @@
+import type { Line } from '../types/grid.ts';
+import { UIFactory } from '../renderer/ui-factory.ts';
+import { ScrollableListPanel } from './scrollable-list-panel.ts';
+import type { WorkPlanItem, WorkPlanItemStatus, WorkPlanStore } from '../work-plans/work-plan-store.ts';
+
+const STATUS_LABEL: Record<WorkPlanItemStatus, string> = {
+  pending: '[ ]',
+  in_progress: '[>]',
+  blocked: '[!]',
+  done: '[x]',
+  failed: '[x]',
+  cancelled: '[-]',
+};
+
+const STATUS_COLOR: Record<WorkPlanItemStatus, string> = {
+  pending: '#94a3b8',
+  in_progress: '#38bdf8',
+  blocked: '#f59e0b',
+  done: '#22c55e',
+  failed: '#ef4444',
+  cancelled: '#64748b',
+};
+
+function line(text: string, width: number, style: Parameters<typeof UIFactory.stringToLine>[2] = {}): Line {
+  return UIFactory.stringToLine(text.padEnd(width).slice(0, width), width, style);
+}
+
+function compactDate(value: number): string {
+  return new Date(value).toISOString().replace('T', ' ').slice(0, 16);
+}
+
+function statusName(status: WorkPlanItemStatus): string {
+  return status.replace(/_/g, ' ');
+}
+
+export class WorkPlanPanel extends ScrollableListPanel<WorkPlanItem> {
+  private items: readonly WorkPlanItem[] = [];
+  private lastPlanUpdatedAt = 0;
+
+  constructor(private readonly store: WorkPlanStore) {
+    super('work-plan', 'Work Plan', 'L', 'agent');
+    this.showSelectionGutter = true;
+  }
+
+  onActivate(): void {
+    super.onActivate();
+    this.refresh();
+  }
+
+  render(width: number, height: number): Line[] {
+    this.refresh();
+    return this.renderList(width, height, {
+      title: 'Work Plan',
+      header: this.renderHeader(width),
+      footer: this.renderFooter(width),
+      emptyMessage: 'No work plan items yet',
+    });
+  }
+
+  handleInput(key: string): boolean {
+    if (this.lastError !== null) this.clearError();
+    const item = this.items[this.selectedIndex];
+    try {
+      switch (key) {
+        case ' ':
+        case 'return':
+        case 'enter':
+          if (!item) return false;
+          this.store.cycleItemStatus(item.id);
+          this.refresh();
+          return true;
+        case '1':
+          return this.setSelectedStatus('pending');
+        case '2':
+          return this.setSelectedStatus('in_progress');
+        case '3':
+          return this.setSelectedStatus('blocked');
+        case '4':
+          return this.setSelectedStatus('done');
+        case '5':
+          return this.setSelectedStatus('failed');
+        case '6':
+          return this.setSelectedStatus('cancelled');
+        case 'd':
+        case 'delete':
+          if (!item) return false;
+          this.store.removeItem(item.id);
+          this.refresh();
+          return true;
+        case 'c':
+          this.store.clearCompleted();
+          this.refresh();
+          return true;
+        case 'r':
+          this.refresh(true);
+          return true;
+        default:
+          return super.handleInput(key);
+      }
+    } catch (error) {
+      this.setError(error instanceof Error ? error.message : String(error));
+      return true;
+    }
+  }
+
+  protected getItems(): readonly WorkPlanItem[] {
+    return this.items;
+  }
+
+  protected getEmptyStateActions(): Array<{ command: string; summary: string }> {
+    return [
+      { command: '/workplan add <title>', summary: 'add a persistent item' },
+      { command: '/workplan list', summary: 'print the current plan' },
+    ];
+  }
+
+  protected renderItem(item: WorkPlanItem, _index: number, selected: boolean, width: number): Line {
+    const status = STATUS_LABEL[item.status];
+    const owner = item.owner ? ` @${item.owner}` : '';
+    const source = item.source ? ` (${item.source})` : '';
+    const text = `${status} ${item.title}${owner}${source}`;
+    return line(text, width, {
+      fg: selected ? '#e2e8f0' : STATUS_COLOR[item.status],
+      bg: selected ? '#1e293b' : undefined,
+      bold: selected || item.status === 'in_progress',
+    });
+  }
+
+  private setSelectedStatus(status: WorkPlanItemStatus): boolean {
+    const item = this.items[this.selectedIndex];
+    if (!item) return false;
+    this.store.setItemStatus(item.id, status);
+    this.refresh();
+    return true;
+  }
+
+  private refresh(force = false): void {
+    const plan = this.store.getActivePlan();
+    if (!force && plan.updatedAt === this.lastPlanUpdatedAt && this.items.length === plan.items.length) return;
+    this.items = plan.items;
+    this.lastPlanUpdatedAt = plan.updatedAt;
+    this.clampSelection();
+    this.needsRender = true;
+  }
+
+  private renderHeader(width: number): Line[] {
+    const plan = this.store.getActivePlan();
+    const counts = new Map<WorkPlanItemStatus, number>();
+    for (const status of Object.keys(STATUS_LABEL) as WorkPlanItemStatus[]) counts.set(status, 0);
+    for (const item of plan.items) counts.set(item.status, (counts.get(item.status) ?? 0) + 1);
+    const active = this.items[this.selectedIndex];
+    const header = [
+      line(`Persistent Work Plan`, width, { fg: '#22d3ee', bold: true }),
+      line(`Project: ${plan.projectRoot}`, width, { fg: '#cbd5e1' }),
+      line(
+        `Items: ${plan.items.length}  pending ${counts.get('pending') ?? 0}  active ${counts.get('in_progress') ?? 0}  blocked ${counts.get('blocked') ?? 0}  done ${counts.get('done') ?? 0}`,
+        width,
+        { fg: '#94a3b8' },
+      ),
+      line(`Saved: ${this.store.filePath}`, width, { fg: '#64748b' }),
+    ];
+    if (active) {
+      header.push(line('', width));
+      header.push(line(`Selected: ${active.id}  ${statusName(active.status)}  updated ${compactDate(active.updatedAt)}`, width, { fg: '#a5b4fc' }));
+      if (active.notes) header.push(line(`Notes: ${active.notes}`, width, { fg: '#cbd5e1' }));
+    }
+    return header;
+  }
+
+  private renderFooter(width: number): Line[] {
+    return [
+      line('Enter/Space cycle  1 pending  2 active  3 blocked  4 done  5 failed  6 cancelled  d delete  c clear done  r refresh', width, { fg: '#94a3b8' }),
+    ];
+  }
+}

package/src/panels/worktree-panel.ts

@@ -0,0 +1,182 @@
+import type { Line } from '../types/grid.ts';
+import { createEmptyLine } from '../types/grid.ts';
+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;
+
+function stateColor(state: WorktreeStatusRecord['state']): string {
+  switch (state) {
+    case 'active': return C.ok;
+    case 'paused':
+    case 'kept': return C.warn;
+    default: return C.dim;
+  }
+}
+
+export class WorktreePanel extends ScrollableListPanel<WorktreeStatusRecord> {
+  private rows: WorktreeStatusRecord[] = [];
+  private loading = false;
+  private readonly worktreeRegistry: WorktreeRegistry;
+
+  public constructor(worktreeRegistry: WorktreeRegistry) {
+    super('worktrees', 'Worktrees', 'W', 'monitoring');
+    this.showSelectionGutter = true; // I5: non-color selection affordance
+    this.worktreeRegistry = worktreeRegistry;
+    void this.refresh();
+  }
+
+  public override onActivate(): void {
+    super.onActivate();
+    if (!this.loading) void this.refresh();
+  }
+
+  public handleInput(key: string): boolean {
+    if (key === 'r') {
+      void this.refresh();
+      return true;
+    }
+    return super.handleInput(key);
+  }
+
+  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],
+    ]);
+  }
+
+  private async refresh(): Promise<void> {
+    this.loading = true;
+    this.markDirty();
+    try {
+      this.rows = await this.worktreeRegistry.list();
+      this.clampSelection();
+    } finally {
+      this.loading = false;
+      this.markDirty();
+    }
+  }
+
+  public render(width: number, height: number): Line[] {
+    this.needsRender = false;
+    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]])] });
+    } else {
+      const summary = summarizeWorktreeOwnership(this.rows);
+      sections.push({
+        title: 'Worktree posture',
+        lines: [
+          buildKeyValueLine(width, [
+            { label: 'total', value: String(summary.total), valueColor: C.value },
+            { label: 'active', value: String(summary.active), valueColor: C.ok },
+            { 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),
+          buildKeyValueLine(width, [
+            { label: 'session attached', value: String(summary.sessionAttached), valueColor: summary.sessionAttached > 0 ? C.info : C.dim },
+            { label: 'task attached', value: String(summary.taskAttached), valueColor: summary.taskAttached > 0 ? C.info : C.dim },
+            { label: 'agent owned', value: String(summary.agentOwned), valueColor: summary.agentOwned > 0 ? C.value : C.dim },
+            { label: 'orchestrator', value: String(summary.orchestratorOwned), valueColor: summary.orchestratorOwned > 0 ? C.value : C.dim },
+          ], 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 detailSection: PanelWorkspaceSection = {
+        title: 'Details',
+        lines: [
+          buildPanelLine(width, [[' path ', C.label], [selected.path, C.dim]]),
+          buildPanelLine(width, [[' branch ', C.label], [selected.branch, C.value], ['  head ', C.label], [selected.head.slice(0, 12), C.info], ['  state ', C.label], [selected.state, stateColor(selected.state)]]),
+          buildPanelLine(width, [[' kind ', C.label], [selected.kind, C.info], ['  owner ', C.label], [selected.ownerId ?? 'n/a', C.dim], ['  session ', C.label], [selected.sessionId ?? 'n/a', C.dim]]),
+          buildPanelLine(width, [[' task ', C.label], [selected.taskId ?? 'n/a', C.dim], ['  updated ', C.label], [new Date(selected.updatedAt).toLocaleString(), C.dim]]),
+          buildPanelLine(width, [[
+            selected.sessionId || selected.taskId
+              ? ' Attached worktree can be resumed from session/task flows and should be merged or cleaned up by the orchestrator.'
+              : ' 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]])],
+        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],
+            ]);
+          }),
+          selectedIndex: this.selectedIndex,
+          scrollOffset: this.scrollStart,
+          guardRows: 1,
+          minRows: 4,
+          appendWindowSummary: { dimColor: C.dim },
+        },
+        afterSections: [detailSection],
+      });
+      this.scrollStart = resolvedWorktreesSection.scrollOffset;
+      sections.push(resolvedWorktreesSection.section);
+      sections.push(detailSection);
+    }
+
+    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]])],
+      palette: C,
+    });
+    while (lines.length < height) lines.push(createEmptyLine(width));
+    return lines.slice(0, height);
+  }
+}