@pellux/goodvibes-tui 0.18.4

package/src/panels/watchers-panel.ts

@@ -0,0 +1,241 @@
+import type { Line } from '@pellux/goodvibes-sdk/platform/types/grid';
+import { createEmptyLine } from '@pellux/goodvibes-sdk/platform/types/grid';
+import { BasePanel } from './base-panel.ts';
+import type { UiReadModel, UiWatchersSnapshot } from '../runtime/ui-read-models.ts';
+import { truncateDisplay } from '@pellux/goodvibes-sdk/platform/utils/terminal-width';
+import {
+  buildEmptyState,
+  buildGuidanceLine,
+  buildKeyValueLine,
+  buildPanelLine,
+  buildPanelWorkspace,
+  DEFAULT_PANEL_PALETTE,
+  resolvePrimaryScrollableSection,
+  type PanelWorkspaceSection,
+} from './polish.ts';
+
+const C = {
+  ...DEFAULT_PANEL_PALETTE,
+  header: '#94a3b8',
+  headerBg: '#1e293b',
+  ok: '#22c55e',
+  warn: '#eab308',
+  error: '#ef4444',
+  info: '#38bdf8',
+  selectBg: '#0f172a',
+} as const;
+
+function stateColor(state: string): string {
+  if (state === 'running') return C.ok;
+  if (state === 'degraded') return C.warn;
+  if (state === 'failed') return C.error;
+  return C.dim;
+}
+
+function sourceStatusColor(state?: string): string {
+  if (state === 'healthy') return C.ok;
+  if (state === 'lagging' || state === 'stale' || state === 'degraded') return C.warn;
+  if (state === 'failed') return C.error;
+  return C.dim;
+}
+
+function formatLag(value?: number): string {
+  if (!value || value <= 0) return 'n/a';
+  if (value < 1000) return `${value}ms`;
+  if (value < 60_000) return `${Math.round(value / 1000)}s`;
+  return `${Math.round(value / 60_000)}m`;
+}
+
+function formatTime(value?: number): string {
+  if (!value) return 'n/a';
+  return new Date(value).toLocaleString();
+}
+
+export class WatchersPanel extends BasePanel {
+  private readonly readModel?: UiReadModel<UiWatchersSnapshot>;
+  private readonly unsub: (() => void) | null;
+  private selectedIndex = 0;
+  private scrollOffset = 0;
+
+  public constructor(readModel?: UiReadModel<UiWatchersSnapshot>) {
+    super('watchers', 'Watchers', 'W', 'monitoring');
+    this.readModel = readModel;
+    this.unsub = readModel ? readModel.subscribe(() => this.markDirty()) : null;
+  }
+
+  public override onDestroy(): void {
+    this.unsub?.();
+  }
+
+  public handleInput(key: string): boolean {
+    const watchers = this.watchers();
+    if (watchers.length === 0) return false;
+    if (key === 'up' || key === 'k') {
+      this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+      this.markDirty();
+      return true;
+    }
+    if (key === 'down' || key === 'j') {
+      this.selectedIndex = Math.min(watchers.length - 1, this.selectedIndex + 1);
+      this.markDirty();
+      return true;
+    }
+    return false;
+  }
+
+  private watchers() {
+    if (!this.readModel) return [];
+    return [...this.readModel.getSnapshot().watchers];
+  }
+
+  public render(width: number, height: number): Line[] {
+    this.needsRender = false;
+    const intro = 'Managed watchers and source health used to trigger automation, refresh routes, and surface degraded upstream conditions.';
+
+    if (!this.readModel) {
+      const workspace = buildPanelWorkspace(width, height, {
+        title: 'Watchers',
+        intro,
+        sections: [{
+          lines: buildEmptyState(
+            width,
+            ' Runtime store not wired.',
+            'This panel needs the shared runtime store to inspect watcher health and source lag.',
+            [{ command: '/services auth-review', summary: 'inspect supporting services until watcher wiring is available' }],
+            C,
+          ),
+        }],
+        palette: C,
+      });
+      while (workspace.length < height) workspace.push(createEmptyLine(width));
+      return workspace;
+    }
+
+    const snapshot = this.readModel.getSnapshot();
+    const watchers = this.watchers();
+    const summarySection: PanelWorkspaceSection = {
+      title: 'Posture',
+      lines: [
+        buildKeyValueLine(width, [
+          { label: 'watchers', value: String(snapshot.totalWatchers), valueColor: snapshot.totalWatchers > 0 ? C.info : C.dim },
+          { label: 'active', value: String(snapshot.activeWatcherIds.length), valueColor: snapshot.activeWatcherIds.length > 0 ? C.ok : C.dim },
+          { label: 'degraded', value: String(snapshot.totalDegraded), valueColor: snapshot.totalDegraded > 0 ? C.warn : C.dim },
+          { label: 'lagged', value: String(snapshot.totalLagged), valueColor: snapshot.totalLagged > 0 ? C.warn : C.dim },
+        ], C),
+        buildGuidanceLine(width, '/schedule list', 'verify jobs consuming these sources and use daemon APIs for watcher lifecycle control', C),
+      ],
+    };
+
+    if (watchers.length === 0) {
+      const workspace = buildPanelWorkspace(width, height, {
+        title: 'Watchers',
+        intro,
+        sections: [
+          summarySection,
+          {
+            lines: buildEmptyState(
+              width,
+              ' No watchers registered.',
+              'Register daemon watchers or enable polling/integration sources to populate this control room.',
+              [
+                { command: '/schedule list', summary: 'review automation that will consume watcher events' },
+                { command: '/services auth-review', summary: 'validate integration credentials before enabling remote watchers' },
+              ],
+              C,
+            ),
+          },
+        ],
+        palette: C,
+      });
+      while (workspace.length < height) workspace.push(createEmptyLine(width));
+      return workspace;
+    }
+
+    this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, watchers.length - 1));
+    const selected = watchers[this.selectedIndex]!;
+
+    const detailSection: PanelWorkspaceSection = {
+      title: 'Selected Watcher',
+      lines: [
+        buildPanelLine(width, [
+          ['  Watcher: ', C.label],
+          [selected.label, C.value],
+          ['  Kind: ', C.label],
+          [selected.kind, C.info],
+        ]),
+        buildPanelLine(width, [
+          ['  State: ', C.label],
+          [selected.state, stateColor(selected.state)],
+          ['  Source: ', C.label],
+          [selected.source.kind, C.value],
+        ]),
+        buildPanelLine(width, [
+          ['  Source status: ', C.label],
+          [selected.sourceStatus ?? 'unknown', sourceStatusColor(selected.sourceStatus)],
+          ['  Lag: ', C.label],
+          [formatLag(selected.sourceLagMs), selected.sourceLagMs ? C.warn : C.dim],
+        ]),
+        buildPanelLine(width, [
+          ['  Heartbeat: ', C.label],
+          [formatTime(selected.lastHeartbeatAt), C.dim],
+          ['  Checkpoint: ', C.label],
+          [truncateDisplay(selected.lastCheckpoint ?? 'n/a', Math.max(0, width - 38)), C.dim],
+        ]),
+        ...(selected.degradedReason ? [
+          buildPanelLine(width, [
+            ['  Reason: ', C.label],
+            [truncateDisplay(selected.degradedReason, Math.max(0, width - 11)), C.warn],
+          ]),
+        ] : []),
+        ...(selected.lastError ? [
+          buildPanelLine(width, [
+            ['  Error: ', C.label],
+            [truncateDisplay(selected.lastError, Math.max(0, width - 10)), C.error],
+          ]),
+        ] : []),
+      ],
+    };
+
+    const resolvedWatchers = resolvePrimaryScrollableSection(width, height, {
+      intro,
+      footerLines: [buildPanelLine(width, [['  Up/Down move through watchers', C.dim]])],
+      palette: C,
+      beforeSections: [summarySection],
+      section: {
+        title: 'Watchers',
+        scrollableLines: watchers.map((watcher, absolute) => {
+          const bg = absolute === this.selectedIndex ? C.selectBg : undefined;
+          return buildPanelLine(width, [
+            [' ', C.label, bg],
+            [watcher.state.padEnd(10), stateColor(watcher.state), bg],
+            [` ${truncateDisplay(watcher.label, 18).padEnd(18)}`, C.value, bg],
+            [` ${String(watcher.sourceStatus ?? 'unknown').padEnd(10)}`, sourceStatusColor(watcher.sourceStatus), bg],
+            [` ${truncateDisplay(formatLag(watcher.sourceLagMs), Math.max(0, width - 43))}`, C.dim, bg],
+          ]);
+        }),
+        selectedIndex: this.selectedIndex,
+        scrollOffset: this.scrollOffset,
+        guardRows: 1,
+        minRows: 5,
+        appendWindowSummary: { dimColor: C.dim },
+      },
+      afterSections: [detailSection],
+    });
+    this.scrollOffset = resolvedWatchers.scrollOffset;
+
+    const sections: PanelWorkspaceSection[] = [
+      summarySection,
+      resolvedWatchers.section,
+      detailSection,
+    ];
+    const lines = buildPanelWorkspace(width, height, {
+      title: 'Watchers',
+      intro,
+      sections,
+      footerLines: [buildPanelLine(width, [['  Up/Down move through watchers', C.dim]])],
+      palette: C,
+    });
+    while (lines.length < height) lines.push(createEmptyLine(width));
+    return lines.slice(0, height);
+  }
+}

package/src/panels/welcome-panel.ts

@@ -0,0 +1,64 @@
+import type { Line } from '@pellux/goodvibes-sdk/platform/types/grid';
+import { BasePanel } from './base-panel.ts';
+import { buildGuidanceLine, buildPanelLine, buildPanelWorkspace, DEFAULT_PANEL_PALETTE } from './polish.ts';
+
+const C = {
+  ...DEFAULT_PANEL_PALETTE,
+  header: '#f8fafc',
+  headerBg: '#1e293b',
+  label: '#93c5fd',
+  good: '#22c55e',
+  empty: '#475569',
+} as const;
+
+export class WelcomePanel extends BasePanel {
+  public constructor() {
+    super('welcome', 'Welcome', 'W', 'monitoring');
+  }
+
+  public render(width: number, height: number): Line[] {
+    this.needsRender = false;
+    return buildPanelWorkspace(width, height, {
+      title: 'Welcome To GoodVibes',
+      intro: 'Local-first operator shell for setup, trust, orchestration, ecosystem, and self-hosted remote work.',
+      palette: C,
+      sections: [
+        {
+          lines: [buildGuidanceLine(width, '/cockpit', 'open the unified control room first if you want a complete runtime overview', C)],
+        },
+        {
+          title: 'Quick Start',
+          lines: [
+            buildGuidanceLine(width, '/setup onboarding', 'first-run checklist, doctor, and environment posture', C),
+            buildGuidanceLine(width, '/login provider <name> start', 'begin a supported provider auth flow from the product front door', C),
+            buildGuidanceLine(width, '/subscription', 'review stored provider sessions and active subscription-backed routes', C),
+            buildGuidanceLine(width, '/sandbox review', 'inspect VM isolation posture, presets, and Windows/WSL mode', C),
+          ],
+        },
+        {
+          title: 'Operate',
+          lines: [
+            buildGuidanceLine(width, '/marketplace open', 'browse curated plugins, skills, hook packs, and policy packs', C),
+            buildGuidanceLine(width, '/remote-setup', 'review bridge, tunnel, env, bootstrap, and runner-pool flows', C),
+            buildGuidanceLine(width, '/runner-pool list', 'inspect remote runner pools and dispatch posture', C),
+            buildGuidanceLine(width, '/teleport export <path>', 'package a portable remote-session handoff bundle', C),
+            buildGuidanceLine(width, '/security', 'review trust posture, approval pressure, and incidents', C),
+            buildGuidanceLine(width, '/cockpit', 'open the unified operator control room', C),
+          ],
+        },
+        {
+          title: 'Advanced',
+          lines: [
+            buildGuidanceLine(width, '/hooks', 'author, simulate, and import hook workflows', C),
+            buildGuidanceLine(width, '/memory-review queue', 'review project and team memory, handoffs, and evidence', C),
+            buildGuidanceLine(width, '/team-memory export <path>', 'package a team handoff bundle for shared-memory transfer', C),
+            buildGuidanceLine(width, '/release checklist', 'run certification checks and export evidence bundles', C),
+          ],
+        },
+      ],
+      footerLines: [
+        buildPanelLine(width, [['  This surface stays intentionally short so the real control rooms stay authoritative.', C.good]]),
+      ],
+    });
+  }
+}

package/src/panels/worktree-panel.ts

@@ -0,0 +1,180 @@
+import type { Line } from '@pellux/goodvibes-sdk/platform/types/grid';
+import { createEmptyLine } from '@pellux/goodvibes-sdk/platform/types/grid';
+import { BasePanel } from './base-panel.ts';
+import { buildKeyValueLine, buildPanelLine, buildPanelWorkspace, DEFAULT_PANEL_PALETTE, resolvePrimaryScrollableSection, type PanelWorkspaceSection } from './polish.ts';
+import { summarizeWorktreeOwnership, type WorktreeRegistry, type WorktreeStatusRecord } from '../runtime/worktree/registry.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 BasePanel {
+  private rows: WorktreeStatusRecord[] = [];
+  private selectedIndex = 0;
+  private scrollOffset = 0;
+  private loading = false;
+  private readonly worktreeRegistry: WorktreeRegistry;
+
+  public constructor(worktreeRegistry: WorktreeRegistry) {
+    super('worktrees', 'Worktrees', 'W', 'monitoring');
+    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;
+    }
+    if (this.rows.length === 0) return false;
+    if (key === 'up' || key === 'k') {
+      this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+      this.markDirty();
+      return true;
+    }
+    if (key === 'down' || key === 'j') {
+      this.selectedIndex = Math.min(this.rows.length - 1, this.selectedIndex + 1);
+      this.markDirty();
+      return true;
+    }
+    return false;
+  }
+
+  private async refresh(): Promise<void> {
+    this.loading = true;
+    this.markDirty();
+    try {
+      this.rows = await this.worktreeRegistry.list();
+      this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.rows.length - 1));
+    } 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.cleanupPending), valueColor: summary.cleanupPending > 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.cleanupPending > 0 || summary.discard > 0
+              ? ' Review cleanup-pending 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.cleanupPending > 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 === 'cleanup-pending'
+                ? ` 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.scrollOffset,
+          guardRows: 1,
+          minRows: 4,
+          appendWindowSummary: { dimColor: C.dim },
+        },
+        afterSections: [detailSection],
+      });
+      this.scrollOffset = 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);
+  }
+}