@pellux/goodvibes-agent 0.1.0

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

@@ -0,0 +1,274 @@
+import type { Line } from '../types/grid.ts';
+import type { ExecutionPlan, PlanItem, PlanItemStatus } from '@pellux/goodvibes-sdk/platform/core';
+import { BasePanel } from './base-panel.ts';
+import type { PlanDashboardQuery } from '../runtime/ui-service-queries.ts';
+import {
+  buildEmptyState,
+  buildPanelLine,
+  buildPanelWorkspace,
+  resolveScrollablePanelSection,
+  DEFAULT_PANEL_PALETTE,
+  type PanelWorkspaceSection,
+} from './polish.ts';
+
+// ---------------------------------------------------------------------------
+// Status display maps
+// ---------------------------------------------------------------------------
+
+const STATUS_ICON: Record<PlanItemStatus, string> = {
+  complete: '✓',
+  in_progress: '▸',
+  pending: '•',
+  failed: '✗',
+  skipped: '–',
+};
+
+const STATUS_FG: Record<PlanItemStatus, string> = {
+  complete: '#22c55e',
+  in_progress: '#00ffff',
+  pending: '244',
+  failed: '#ef4444',
+  skipped: '238',
+};
+
+// ---------------------------------------------------------------------------
+// PlanDashboardPanel
+// ---------------------------------------------------------------------------
+
+export class PlanDashboardPanel extends BasePanel {
+  private scrollOffset = 0;
+  private selectedIndex = 0;
+
+  // Flat list of navigable row indices (set during render)
+  private totalRows = 0;
+  private readonly planManager: PlanDashboardQuery;
+
+  constructor(planManager: PlanDashboardQuery) {
+    super('plan', 'Plan', 'P', 'agent');
+    this.planManager = planManager;
+  }
+
+  override onActivate(): void {
+    super.onActivate();
+    // Re-read plan from disk each time the panel is activated
+    this.markDirty();
+  }
+
+  // --------------------------------------------------------------------------
+  // Input
+  // --------------------------------------------------------------------------
+
+  handleInput(key: string): boolean {
+    if (key === 'up' || key === 'k') {
+      if (this.selectedIndex > 0) {
+        this.selectedIndex--;
+        this.markDirty();
+        return true;
+      }
+    } else if (key === 'down' || key === 'j') {
+      if (this.selectedIndex < this.totalRows - 1) {
+        this.selectedIndex++;
+        this.markDirty();
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // --------------------------------------------------------------------------
+  // Render
+  // --------------------------------------------------------------------------
+
+  render(width: number, height: number): Line[] {
+    return this.trackedRender(() => {
+    const plan = this.planManager.getActive();
+    if (!plan) {
+      return buildPanelWorkspace(width, height, {
+        title: ' Plan Dashboard',
+        intro: 'Track the active execution plan, item status, phase grouping, and overall completion.',
+        sections: [
+          {
+            lines: buildEmptyState(
+              width,
+              ' No active execution plan',
+              'Use /plan to create a plan and the execution dashboard will populate here.',
+              [],
+              DEFAULT_PANEL_PALETTE,
+            ),
+          },
+        ],
+        palette: DEFAULT_PANEL_PALETTE,
+      });
+    }
+    return this.renderPlan(plan, width, height);
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // Empty state
+  // --------------------------------------------------------------------------
+
+  private renderPlan(plan: ExecutionPlan, width: number, height: number): Line[] {
+    const phaseOrder: string[] = [];
+    const byPhase = new Map<string, PlanItem[]>();
+    for (const item of plan.items) {
+      if (!byPhase.has(item.phase)) {
+        byPhase.set(item.phase, []);
+        phaseOrder.push(item.phase);
+      }
+      byPhase.get(item.phase)!.push(item);
+    }
+
+    // Build a set of complete item IDs for dependency blocking detection
+    const completeIds = new Set(
+      plan.items
+        .filter((i) => i.status === 'complete' || i.status === 'skipped')
+        .map((i) => i.id),
+    );
+
+    let rowCount = 0;
+    let selectedLineIndex = 0;
+    const planLines: Line[] = [];
+
+    for (const phase of phaseOrder) {
+      const items = byPhase.get(phase)!;
+      planLines.push(this.renderPhaseHeaderLine(phase, items, width));
+      for (const item of items) {
+        const isSelected = rowCount === this.selectedIndex;
+        if (isSelected) selectedLineIndex = planLines.length;
+        const isBlocked =
+          item.status === 'pending' &&
+          item.dependencies !== undefined &&
+          item.dependencies.length > 0 &&
+          !item.dependencies.every((depId) => completeIds.has(depId));
+
+        planLines.push(this.renderItem(item, isSelected, isBlocked, width));
+        rowCount++;
+      }
+    }
+
+    this.totalRows = rowCount;
+    if (this.selectedIndex >= this.totalRows) {
+      this.selectedIndex = Math.max(0, this.totalRows - 1);
+    }
+
+    const total = plan.items.length;
+    const done = plan.items.filter((i) => i.status === 'complete' || i.status === 'skipped').length;
+    const pct = total > 0 ? Math.round((done / total) * 100) : 0;
+    const summary: PanelWorkspaceSection = {
+      title: 'Summary',
+      lines: [
+        buildPanelLine(width, [
+          [' Status ', DEFAULT_PANEL_PALETTE.label],
+          [plan.status, this.statusColor(plan.status)],
+          ['   Progress ', DEFAULT_PANEL_PALETTE.label],
+          [`${pct}%`, pct === 100 ? DEFAULT_PANEL_PALETTE.good : DEFAULT_PANEL_PALETTE.info],
+          ['   Items ', DEFAULT_PANEL_PALETTE.label],
+          [`${done}/${total}`, DEFAULT_PANEL_PALETTE.value],
+        ]),
+      ],
+    };
+
+    const planSection = resolveScrollablePanelSection(width, height, {
+      intro: plan.title,
+      footerLines: [
+        buildPanelLine(width, [[' Up/Down', DEFAULT_PANEL_PALETTE.info], [' navigate', DEFAULT_PANEL_PALETTE.dim]]),
+      ],
+      palette: DEFAULT_PANEL_PALETTE,
+      beforeSections: [summary],
+      section: {
+        title: 'Execution Plan',
+        scrollableLines: planLines,
+        selectedIndex: selectedLineIndex,
+        scrollOffset: this.scrollOffset,
+        minRows: 8,
+      },
+    });
+    this.scrollOffset = planSection.scrollOffset;
+
+    return buildPanelWorkspace(width, height, {
+      title: ` Plan Dashboard`,
+      intro: plan.title,
+      sections: [
+        summary,
+        planSection.section,
+      ],
+      footerLines: [
+        buildPanelLine(width, [[' Up/Down', DEFAULT_PANEL_PALETTE.info], [' navigate', DEFAULT_PANEL_PALETTE.dim]]),
+      ],
+      palette: DEFAULT_PANEL_PALETTE,
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // Header — title + overall completion percentage
+  // --------------------------------------------------------------------------
+
+  private renderPhaseHeaderLine(phase: string, items: PlanItem[], width: number): Line {
+    const done = items.filter(
+      (i) => i.status === 'complete' || i.status === 'skipped',
+    ).length;
+    const total = items.length;
+    const active = items.some((i) => i.status === 'in_progress');
+    const failed = items.some((i) => i.status === 'failed');
+
+    const phaseFg = failed ? '#ef4444' : active ? '#00ffff' : done === total ? '#22c55e' : '250';
+
+    const barW = 8;
+    const filledB = total > 0 ? Math.round((done / total) * barW) : 0;
+    const bar = '#'.repeat(filledB) + '-'.repeat(barW - filledB);
+
+    const progressText = `[${bar}] ${done}/${total}`;
+    const phaseText = ` > ${phase}`;
+    const spacer = Math.max(1, width - phaseText.length - progressText.length - 1);
+    return buildPanelLine(width, [
+      [phaseText, phaseFg],
+      [' '.repeat(spacer), phaseFg],
+      [progressText, phaseFg],
+      [' ', phaseFg],
+    ]);
+  }
+
+  // --------------------------------------------------------------------------
+  // Individual item
+  // --------------------------------------------------------------------------
+
+  private renderItem(
+    item: PlanItem,
+    isSelected: boolean,
+    isBlocked: boolean,
+    width: number,
+  ): Line {
+    const icon = STATUS_ICON[item.status];
+    const fg = isBlocked ? '238' : STATUS_FG[item.status];
+    const dim = item.status === 'skipped' || isBlocked;
+
+    // Indent blocked items to visually signal they depend on others
+    const indent = isBlocked ? '      ' : '   ';
+    const selectedMark = isSelected ? '▸' : ' ';
+
+    let text = `${selectedMark}${indent}${icon} ${item.description}`;
+
+    // Append agent ID for in-progress and complete items
+    if (item.agentId && (item.status === 'in_progress' || item.status === 'complete')) {
+      text += ` [${item.agentId}]`;
+    }
+
+    // Append dependency note for blocked items (first unmet dep description)
+    if (isBlocked && item.dependencies && item.dependencies.length > 0) {
+      text += ' (blocked)';
+    }
+
+    return buildPanelLine(width, [[text, fg, isSelected ? '#1e293b' : undefined]]);
+  }
+
+  private statusColor(status: ExecutionPlan['status']): string {
+    return status === 'complete'
+      ? DEFAULT_PANEL_PALETTE.good
+      : status === 'failed'
+      ? DEFAULT_PANEL_PALETTE.bad
+      : status === 'active'
+      ? DEFAULT_PANEL_PALETTE.info
+      : DEFAULT_PANEL_PALETTE.dim;
+  }
+}

package/src/panels/plugins-panel.ts

@@ -0,0 +1,178 @@
+import type { Line } from '../types/grid.ts';
+import { createEmptyLine } from '../types/grid.ts';
+import { ScrollableListPanel } from './scrollable-list-panel.ts';
+import type { PluginManagerObserver, PluginStatus } from '@pellux/goodvibes-sdk/platform/plugins';
+import {
+  buildEmptyState,
+  buildPanelLine,
+  buildPanelWorkspace,
+  DEFAULT_PANEL_PALETTE,
+  type PanelPalette,
+} 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 trustColor(tier: PluginStatus['trustTier']): string {
+  switch (tier) {
+    case 'trusted':
+      return C.ok;
+    case 'limited':
+      return C.warn;
+    case 'untrusted':
+      return C.error;
+  }
+}
+
+function statusColor(status: PluginStatus): string {
+  if (status.quarantined) return C.error;
+  if (status.active) return C.ok;
+  if (status.enabled) return C.warn;
+  return C.dim;
+}
+
+function statusLabel(status: PluginStatus): string {
+  if (status.quarantined) return 'QUARANTINED';
+  if (status.active) return 'ACTIVE';
+  if (status.enabled) return 'ENABLED';
+  return 'DISABLED';
+}
+
+export class PluginsPanel extends ScrollableListPanel<PluginStatus> {
+  private readonly manager: PluginManagerObserver;
+  private readonly unsub: (() => void) | null;
+
+  public constructor(manager: PluginManagerObserver) {
+    super('plugins', 'Plugins', 'P', 'monitoring');
+    this.showSelectionGutter = true; // I5: non-color selection affordance
+    this.manager = manager;
+    this.unsub = manager.subscribe(() => this.markDirty());
+  }
+
+  public override onActivate(): void {
+    super.onActivate();
+    this.selectedIndex = 0;
+  }
+
+  public override onDestroy(): void {
+    this.unsub?.();
+  }
+
+  protected override getPalette(): PanelPalette {
+    return C;
+  }
+
+  protected getItems(): readonly PluginStatus[] {
+    return this.manager.list();
+  }
+
+  protected renderItem(plugin: PluginStatus, _index: number, selected: boolean, width: number): Line {
+    const bg = selected ? C.selectBg : undefined;
+    return buildPanelLine(width, [
+      [' ', C.label, bg],
+      [plugin.name.padEnd(22), C.value, bg],
+      [` ${statusLabel(plugin).padEnd(11)}`, statusColor(plugin), bg],
+      [` ${plugin.trustTier.toUpperCase().padEnd(10)}`, trustColor(plugin.trustTier), bg],
+      [` ${plugin.version}`, C.dim, bg],
+    ]);
+  }
+
+  protected override getEmptyStateMessage(): string {
+    return ' No plugins discovered.';
+  }
+
+  protected override getEmptyStateActions(): Array<{ command: string; summary: string }> {
+    return [
+      { command: '/plugin list', summary: 'inspect plugin discovery paths and current registry state' },
+      { command: '/marketplace', summary: 'review curated ecosystem entries and provenance posture' },
+    ];
+  }
+
+  public render(width: number, height: number): Line[] {
+    const intro = 'Plugin trust, capabilities, signatures, and quarantine posture for the active ecosystem surface.';
+    const plugins = this.getItems();
+
+    if (plugins.length === 0) {
+      const workspace = buildPanelWorkspace(width, height, {
+        title: 'Plugin Control Room',
+        intro,
+        sections: [{
+          lines: buildEmptyState(
+            width,
+            ' No plugins discovered.',
+            'Use /plugin list for search paths, install hints, and trust review before activating plugin-backed flows.',
+            [
+              { command: '/plugin list', summary: 'inspect plugin discovery paths and current registry state' },
+              { command: '/marketplace', summary: 'review curated ecosystem entries and provenance posture' },
+            ],
+            C,
+          ),
+        }],
+        palette: C,
+      });
+      while (workspace.length < height) workspace.push(createEmptyLine(width));
+      return workspace;
+    }
+
+    this.clampSelection();
+    const selected = plugins[this.selectedIndex]!;
+    const selectedCaps = this.manager.capabilities(selected.name);
+    const trustRecord = this.manager.getTrustRecord(selected.name);
+    const quarantineRecord = this.manager.getQuarantineRecord(selected.name);
+    const detailLines: Line[] = [
+      buildPanelLine(width, [
+        ['  Plugin: ', C.label],
+        [selected.name, C.value],
+        ['  State: ', C.label],
+        [statusLabel(selected), statusColor(selected)],
+        ['  Trust: ', C.label],
+        [selected.trustTier, trustColor(selected.trustTier)],
+      ]),
+      buildPanelLine(width, [
+        ['  Description: ', C.label],
+        [selected.description.slice(0, Math.max(0, width - 15)), C.dim],
+      ]),
+    ];
+
+    if (selectedCaps) {
+      detailLines.push(buildPanelLine(width, [
+        ['  Capabilities: ', C.label],
+        [String(selectedCaps.requested.length), C.value],
+        ['  High-risk: ', C.label],
+        [String(selectedCaps.highRisk.length), selectedCaps.highRisk.length > 0 ? C.warn : C.ok],
+        ['  Blocked: ', C.label],
+        [String(selectedCaps.blocked.length), selectedCaps.blocked.length > 0 ? C.error : C.ok],
+      ]));
+    }
+
+    if (trustRecord?.signatureFingerprint) {
+      detailLines.push(buildPanelLine(width, [
+        ['  Signature: ', C.label],
+        [trustRecord.signatureFingerprint, C.info],
+      ]));
+    }
+
+    if (quarantineRecord) {
+      detailLines.push(buildPanelLine(width, [
+        ['  Quarantine: ', C.label],
+        [quarantineRecord.reason.slice(0, Math.max(0, width - 14)), C.error],
+      ]));
+    }
+
+    detailLines.push(buildPanelLine(width, [['  Inspect trust and capability state here, then use /plugin to take action.', C.dim]]));
+    detailLines.push(buildPanelLine(width, [['  Up/Down move through discovered plugins', C.dim]]));
+
+    return this.renderList(width, height, {
+      title: 'Plugin Control Room',
+      footer: detailLines,
+    });
+  }
+}