@pellux/goodvibes-agent 0.1.0

package/src/runtime/diagnostics/panels/panel-resources.ts

@@ -0,0 +1,118 @@
+/**
+ * Panel resource diagnostics panel data provider.
+ *
+ * Polls the shared TUI-owned ComponentHealthMonitor and produces PanelResourceSnapshot
+ * values for the diagnostics panel to render.
+ */
+import type { ComponentHealthMonitor } from '../../perf/panel-health-monitor.ts';
+import type {
+  ComponentResourceEntry,
+  ComponentResourceSnapshot,
+} from '@/runtime/index.ts';
+
+const DEFAULT_POLL_INTERVAL_MS = 500;
+
+const HEALTH_ORDER: Record<string, number> = {
+  overloaded: 0,
+  warning: 1,
+  healthy: 2,
+};
+
+export class PanelResourcesPanel {
+  private readonly _pollIntervalMs: number;
+  private readonly _monitor: ComponentHealthMonitor;
+  private _current: ComponentResourceSnapshot;
+  private _timerId: ReturnType<typeof setInterval> | null = null;
+  private readonly _subscribers = new Set<() => void>();
+
+  constructor(monitor: ComponentHealthMonitor, pollIntervalMs: number = DEFAULT_POLL_INTERVAL_MS) {
+    this._monitor = monitor;
+    this._pollIntervalMs = pollIntervalMs;
+    this._current = this._buildSnapshot(Date.now());
+  }
+
+  start(): void {
+    if (this._timerId !== null) return;
+    this._timerId = setInterval(() => {
+      this._current = this._buildSnapshot(Date.now());
+      this._notify();
+    }, this._pollIntervalMs);
+  }
+
+  stop(): void {
+    if (this._timerId !== null) {
+      clearInterval(this._timerId);
+      this._timerId = null;
+    }
+  }
+
+  getSnapshot(): ComponentResourceSnapshot {
+    return this._current;
+  }
+
+  refresh(now: number = Date.now()): ComponentResourceSnapshot {
+    this._current = this._buildSnapshot(now);
+    return this._current;
+  }
+
+  subscribe(callback: () => void): () => void {
+    this._subscribers.add(callback);
+    return () => this._subscribers.delete(callback);
+  }
+
+  dispose(): void {
+    this.stop();
+    this._subscribers.clear();
+  }
+
+  private _buildSnapshot(capturedAt: number): ComponentResourceSnapshot {
+    const healthStates = this._monitor.getAllHealth();
+
+    const panels: ComponentResourceEntry[] = healthStates.map((health) => {
+      const contract = this._monitor.getContract(health.componentId);
+      return {
+        componentId: health.componentId,
+        throttleStatus: health.throttleStatus,
+        healthStatus: health.healthStatus,
+        renderP95Ms: health.renderP95Ms,
+        maxRenderMs: contract?.maxRenderMs ?? 0,
+        rendersInWindow: health.rendersInWindow,
+        maxUpdatesPerSecond: contract?.maxUpdatesPerSecond ?? 0,
+        consecutiveViolations: health.consecutiveViolations,
+        totalSuppressed: health.totalSuppressed,
+        totalPermitted: health.totalPermitted,
+        lastRenderAt: health.lastRenderAt,
+        nextAllowedAt: health.nextAllowedAt,
+      };
+    });
+
+    panels.sort((left, right) => {
+      const diff = (HEALTH_ORDER[left.healthStatus] ?? 2) - (HEALTH_ORDER[right.healthStatus] ?? 2);
+      return diff !== 0 ? diff : left.componentId.localeCompare(right.componentId);
+    });
+
+    const overloadedCount = panels.filter((panel) => panel.healthStatus === 'overloaded').length;
+    const warningCount = panels.filter((panel) => panel.healthStatus === 'warning').length;
+    const healthyCount = panels.filter((panel) => panel.healthStatus === 'healthy').length;
+    const totalSuppressed = panels.reduce((sum, panel) => sum + panel.totalSuppressed, 0);
+
+    return {
+      panels,
+      overloadedCount,
+      warningCount,
+      healthyCount,
+      totalSuppressed,
+      capturedAt,
+    };
+  }
+
+  private _notify(): void {
+    for (const callback of this._subscribers) {
+      try {
+        callback();
+      } catch {
+        // Subscriber failures must not take down diagnostics polling.
+      }
+    }
+  }
+}

package/src/runtime/diagnostics/panels/policy.ts

@@ -0,0 +1,177 @@
+/**
+ * Policy diagnostics panel data provider.
+ *
+ * Wraps a `PolicyRegistry` and optionally a `DivergencePanel` to expose
+ * combined policy state (current bundle, candidate, simulation status,
+ * divergence trends) for the diagnostics view.
+ *
+ * This panel is push-passive: it does not drive timers. Callers must
+ * call `recordTrendEntry()` periodically if a divergence panel is attached.
+ */
+
+import type { PolicyBundleVersion, PolicyDiffResult } from '@/runtime/index.ts';
+import { PolicyRegistry } from '@/runtime/index.ts';
+import type { DivergenceDashboardSnapshot } from '@/runtime/index.ts';
+import type { DivergencePanel } from '@/runtime/index.ts';
+import type { PanelConfig } from '@/runtime/index.ts';
+import { DEFAULT_PANEL_CONFIG } from '@/runtime/index.ts';
+import type { PermissionAuditEntry } from '@/runtime/index.ts';
+import type { PolicyLintFinding } from '@/runtime/index.ts';
+import type { PolicySimulationSummary } from '@/runtime/index.ts';
+import type { PolicyPreflightReview } from '@/runtime/index.ts';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+
+/**
+ * A point-in-time snapshot of policy state for diagnostics rendering.
+ */
+export interface PolicyPanelSnapshot {
+  /** The currently enforced bundle, or null if no policy is active. */
+  current: PolicyBundleVersion | null;
+  /** The pending candidate bundle, or null if none loaded. */
+  candidate: PolicyBundleVersion | null;
+  /** History of previous active bundles (most recent first). */
+  history: PolicyBundleVersion[];
+  /** Diff between current and candidate, or null if unavailable. */
+  diff: PolicyDiffResult | null;
+  /** Divergence dashboard snapshot, or null if no panel attached. */
+  divergence: DivergenceDashboardSnapshot | null;
+  /** Recent permission requests and decisions for operator audit review. */
+  recentPermissionAudit: readonly PermissionAuditEntry[];
+  /** Policy lint findings for current and candidate bundles. */
+  lintFindings: readonly PolicyLintFinding[];
+  /** Concrete scenario results from the most recent policy simulation run. */
+  lastSimulationSummary: PolicySimulationSummary | null;
+  /** Most recent proactive policy preflight review. */
+  lastPreflightReview: PolicyPreflightReview | null;
+  /** ISO 8601 timestamp of when this snapshot was captured. */
+  capturedAt: string;
+}
+
+/**
+ * PolicyPanel — diagnostics data provider for the policy registry.
+ *
+ * Usage:
+ * ```ts
+ * const registry = new PolicyRegistry();
+ * const panel = new PolicyPanel(registry, divergencePanel);
+ *
+ * panel.subscribe(() => {
+ *   const snap = panel.getSnapshot();
+ *   render(snap);
+ * });
+ *
+ * // Notify when the registry state changes:
+ * panel.notify();
+ *
+ * // On cleanup:
+ * panel.dispose();
+ * ```
+ */
+export class PolicyPanel {
+  private readonly _registry: PolicyRegistry;
+  private readonly _divergencePanel: DivergencePanel | null;
+  private readonly _config: PanelConfig;
+  private readonly _recentPermissionAudit: readonly PermissionAuditEntry[];
+  private readonly _lintFindings: readonly PolicyLintFinding[];
+  private readonly _lastSimulationSummary: PolicySimulationSummary | null;
+  private readonly _lastPreflightReview: PolicyPreflightReview | null;
+  private readonly _subscribers = new Set<() => void>();
+
+  constructor(
+    registry: PolicyRegistry,
+    divergencePanel: DivergencePanel | null = null,
+    recentPermissionAudit: readonly PermissionAuditEntry[] = [],
+    lintFindings: readonly PolicyLintFinding[] = [],
+    lastSimulationSummary: PolicySimulationSummary | null = null,
+    lastPreflightReview: PolicyPreflightReview | null = null,
+    config: PanelConfig = DEFAULT_PANEL_CONFIG,
+  ) {
+    this._registry = registry;
+    this._divergencePanel = divergencePanel;
+    this._recentPermissionAudit = recentPermissionAudit;
+    this._lintFindings = lintFindings;
+    this._lastSimulationSummary = lastSimulationSummary;
+    this._lastPreflightReview = lastPreflightReview;
+    this._config = config;
+  }
+
+  /**
+   * recordTrendEntry — Forwards to the attached DivergencePanel if present.
+   *
+   * Call periodically (e.g. every 30 seconds) while simulation is active.
+   */
+  public recordTrendEntry(): void {
+    this._divergencePanel?.recordTrendEntry();
+    this._notify();
+  }
+
+  /**
+   * notify — Trigger a subscriber notification.
+   *
+   * Call after registry state changes (load, promote, rollback) so the
+   * diagnostics view can re-render.
+   */
+  public notify(): void {
+    this._notify();
+  }
+
+  /**
+   * getSnapshot — Returns the current combined policy + divergence snapshot.
+   */
+  public getSnapshot(): PolicyPanelSnapshot {
+    const current = this._registry.getCurrent();
+    const candidate = this._registry.getCandidate();
+    const rawHistory = this._registry.getHistory();
+    // Most recent first, capped for display
+    const history = rawHistory
+      .slice()
+      .reverse()
+      .slice(0, this._config.bufferLimit);
+
+    const diff = this._registry.diff();
+
+    let divergence: DivergenceDashboardSnapshot | null = null;
+    if (this._divergencePanel) {
+      divergence = this._divergencePanel.getSnapshot();
+    }
+
+    return {
+      current,
+      candidate,
+      history,
+      diff,
+      divergence,
+      recentPermissionAudit: this._recentPermissionAudit.slice(0, this._config.bufferLimit),
+      lintFindings: this._lintFindings.slice(0, this._config.bufferLimit),
+      lastSimulationSummary: this._lastSimulationSummary,
+      lastPreflightReview: this._lastPreflightReview,
+      capturedAt: new Date().toISOString(),
+    };
+  }
+
+  /**
+   * Register a callback invoked whenever the panel state changes.
+   * @returns An unsubscribe function.
+   */
+  public subscribe(callback: () => void): () => void {
+    this._subscribers.add(callback);
+    return () => this._subscribers.delete(callback);
+  }
+
+  /**
+   * Release all subscriptions.
+   */
+  public dispose(): void {
+    this._subscribers.clear();
+  }
+
+  private _notify(): void {
+    for (const cb of this._subscribers) {
+      try {
+        cb();
+      } catch (err) {
+        logger.warn(`[PolicyPanel] subscriber error: ${err}`);
+      }
+    }
+  }
+}