@pellux/goodvibes-tui 0.18.10 → 0.18.12

package/src/runtime/emitters/turn.ts

@@ -1,155 +0,0 @@
-/**
- * Turn emitters — typed emission wrappers for TurnEvent domain.
- *
- * Import and call these instead of emitting raw strings.
- */
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-import type { PartialToolCall } from '@pellux/goodvibes-sdk/platform/providers/interface';
-
-/** Emit TURN_SUBMITTED when a user prompt is submitted. */
-export function emitTurnSubmitted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { turnId: string; prompt: string }
-): void {
-  bus.emit('turn', createEventEnvelope('TURN_SUBMITTED', { type: 'TURN_SUBMITTED', ...data }, ctx));
-}
-
-/** Emit PREFLIGHT_OK when preflight checks pass. */
-export function emitPreflightOk(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { turnId: string }
-): void {
-  bus.emit('turn', createEventEnvelope('PREFLIGHT_OK', { type: 'PREFLIGHT_OK', ...data }, ctx));
-}
-
-/** Emit PREFLIGHT_FAIL when preflight checks fail. */
-export function emitPreflightFail(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: {
-    turnId: string;
-    reason: string;
-    stopReason: 'preflight_failed' | 'context_overflow';
-  }
-): void {
-  bus.emit('turn', createEventEnvelope('PREFLIGHT_FAIL', { type: 'PREFLIGHT_FAIL', ...data }, ctx));
-}
-
-/** Emit STREAM_START when provider streaming begins. */
-export function emitStreamStart(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { turnId: string }
-): void {
-  bus.emit('turn', createEventEnvelope('STREAM_START', { type: 'STREAM_START', ...data }, ctx));
-}
-
-/** Emit STREAM_DELTA for each incremental content chunk. */
-export function emitStreamDelta(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { turnId: string; content: string; accumulated: string; reasoning?: string; toolCalls?: PartialToolCall[] }
-): void {
-  bus.emit('turn', createEventEnvelope('STREAM_DELTA', { type: 'STREAM_DELTA', ...data }, ctx));
-}
-
-/** Emit STREAM_END when provider streaming ends. */
-export function emitStreamEnd(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { turnId: string }
-): void {
-  bus.emit('turn', createEventEnvelope('STREAM_END', { type: 'STREAM_END', ...data }, ctx));
-}
-
-/** Emit LLM_RESPONSE_RECEIVED when a provider chat call completes within a turn iteration. */
-export function emitLlmResponseReceived(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: {
-    turnId: string;
-    provider: string;
-    model: string;
-    content: string;
-    toolCallCount: number;
-    inputTokens: number;
-    outputTokens: number;
-    cacheReadTokens?: number;
-    cacheWriteTokens?: number;
-  }
-): void {
-  bus.emit('turn', createEventEnvelope('LLM_RESPONSE_RECEIVED', { type: 'LLM_RESPONSE_RECEIVED', ...data }, ctx));
-}
-
-/** Emit TOOL_BATCH_READY when a set of tool calls is ready for execution. */
-export function emitToolBatchReady(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { turnId: string; toolCalls: string[] }
-): void {
-  bus.emit('turn', createEventEnvelope('TOOL_BATCH_READY', { type: 'TOOL_BATCH_READY', ...data }, ctx));
-}
-
-/** Emit TOOLS_DONE when all tool calls in the current batch have completed. */
-export function emitToolsDone(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { turnId: string }
-): void {
-  bus.emit('turn', createEventEnvelope('TOOLS_DONE', { type: 'TOOLS_DONE', ...data }, ctx));
-}
-
-/** Emit POST_HOOKS_DONE when post-processing hooks have completed. */
-export function emitPostHooksDone(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { turnId: string }
-): void {
-  bus.emit('turn', createEventEnvelope('POST_HOOKS_DONE', { type: 'POST_HOOKS_DONE', ...data }, ctx));
-}
-
-/** Emit TURN_COMPLETED when the turn finishes successfully. */
-export function emitTurnCompleted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: {
-    turnId: string;
-    response: string;
-    stopReason: 'completed' | 'empty_response';
-  }
-): void {
-  bus.emit('turn', createEventEnvelope('TURN_COMPLETED', { type: 'TURN_COMPLETED', ...data }, ctx));
-}
-
-/** Emit TURN_ERROR when the turn fails. */
-export function emitTurnError(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: {
-    turnId: string;
-    error: string;
-    stopReason:
-      | 'preflight_failed'
-      | 'context_overflow'
-      | 'provider_exhausted'
-      | 'provider_error'
-      | 'hook_denied'
-      | 'tool_loop_circuit_breaker'
-      | 'unexpected_error';
-  }
-): void {
-  bus.emit('turn', createEventEnvelope('TURN_ERROR', { type: 'TURN_ERROR', ...data }, ctx));
-}
-
-/** Emit TURN_CANCEL when the turn is cancelled. */
-export function emitTurnCancel(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { turnId: string; reason?: string; stopReason: 'cancelled' }
-): void {
-  bus.emit('turn', createEventEnvelope('TURN_CANCEL', { type: 'TURN_CANCEL', ...data }, ctx));
-}

package/src/runtime/emitters/ui.ts

@@ -1,57 +0,0 @@
-/**
- * UI emitters — typed wrappers for UIEvent domain.
- */
-
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { UIEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/ui';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-
-function uiEvent<T extends UIEvent['type']>(
-  type: T,
-  data: Omit<Extract<UIEvent, { type: T }>, 'type'>,
-  ctx: EmitterContext,
-): RuntimeEventEnvelope<T, Extract<UIEvent, { type: T }>> {
-  return createEventEnvelope(type, { type, ...data } as Extract<UIEvent, { type: T }>, ctx);
-}
-
-export function emitUiRenderRequest(bus: RuntimeEventBus, ctx: EmitterContext): void {
-  bus.emit('ui', uiEvent('UI_RENDER_REQUEST', {}, ctx));
-}
-
-export function emitUiScrollDelta(bus: RuntimeEventBus, ctx: EmitterContext, data: { delta: number }): void {
-  bus.emit('ui', uiEvent('UI_SCROLL_DELTA', data, ctx));
-}
-
-export function emitUiScrollTo(bus: RuntimeEventBus, ctx: EmitterContext, data: { line: number }): void {
-  bus.emit('ui', uiEvent('UI_SCROLL_TO', data, ctx));
-}
-
-export function emitUiBlockToggleCollapse(bus: RuntimeEventBus, ctx: EmitterContext, data: { blockIndex: number }): void {
-  bus.emit('ui', uiEvent('UI_BLOCK_TOGGLE_COLLAPSE', data, ctx));
-}
-
-export function emitUiBlockRerun(bus: RuntimeEventBus, ctx: EmitterContext, data: { blockIndex: number; content: string }): void {
-  bus.emit('ui', uiEvent('UI_BLOCK_RERUN', data, ctx));
-}
-
-export function emitUiClearScreen(bus: RuntimeEventBus, ctx: EmitterContext): void {
-  bus.emit('ui', uiEvent('UI_CLEAR_SCREEN', {}, ctx));
-}
-
-export function emitUiPanelOpen(bus: RuntimeEventBus, ctx: EmitterContext, data: { panelId: string }): void {
-  bus.emit('ui', uiEvent('UI_PANEL_OPEN', data, ctx));
-}
-
-export function emitUiPanelClose(bus: RuntimeEventBus, ctx: EmitterContext, data: { panelId: string }): void {
-  bus.emit('ui', uiEvent('UI_PANEL_CLOSE', data, ctx));
-}
-
-export function emitUiPanelFocus(bus: RuntimeEventBus, ctx: EmitterContext, data: { panelId: string }): void {
-  bus.emit('ui', uiEvent('UI_PANEL_FOCUS', data, ctx));
-}
-
-export function emitUiViewChanged(bus: RuntimeEventBus, ctx: EmitterContext, data: { from: string; to: string }): void {
-  bus.emit('ui', uiEvent('UI_VIEW_CHANGED', data, ctx));
-}

package/src/runtime/emitters/watchers.ts

@@ -1,57 +0,0 @@
-/**
- * Watcher emitters — typed wrappers for WatcherEvent domain.
- */
-
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { WatcherEvent, WatcherSourceKind } from '@pellux/goodvibes-sdk/platform/runtime/events/watchers';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-
-function watcherEvent<T extends WatcherEvent['type']>(
-  type: T,
-  data: Omit<Extract<WatcherEvent, { type: T }>, 'type'>,
-  ctx: EmitterContext,
-): RuntimeEventEnvelope<T, Extract<WatcherEvent, { type: T }>> {
-  return createEventEnvelope(type, { type, ...data } as Extract<WatcherEvent, { type: T }>, ctx);
-}
-
-export function emitWatcherStarted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { watcherId: string; sourceKind: WatcherSourceKind; name: string },
-): void {
-  bus.emit('watchers', watcherEvent('WATCHER_STARTED', data, ctx));
-}
-
-export function emitWatcherHeartbeat(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { watcherId: string; sourceKind: WatcherSourceKind; seenAt: number; checkpoint: string },
-): void {
-  bus.emit('watchers', watcherEvent('WATCHER_HEARTBEAT', data, ctx));
-}
-
-export function emitWatcherCheckpointAdvanced(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { watcherId: string; sourceKind: WatcherSourceKind; checkpoint: string },
-): void {
-  bus.emit('watchers', watcherEvent('WATCHER_CHECKPOINT_ADVANCED', data, ctx));
-}
-
-export function emitWatcherFailed(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { watcherId: string; sourceKind: WatcherSourceKind; error: string; retryable: boolean },
-): void {
-  bus.emit('watchers', watcherEvent('WATCHER_FAILED', data, ctx));
-}
-
-export function emitWatcherStopped(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { watcherId: string; sourceKind: WatcherSourceKind; reason: string },
-): void {
-  bus.emit('watchers', watcherEvent('WATCHER_STOPPED', data, ctx));
-}

package/src/runtime/emitters/workflows.ts

@@ -1,79 +0,0 @@
-/**
- * Workflow emitters — typed emission wrappers for WRFC workflow events.
- */
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { WrfcState } from '@pellux/goodvibes-sdk/platform/agents/wrfc-types';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-
-export function emitWorkflowChainCreated(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { chainId: string; task: string }
-): void {
-  bus.emit('workflows', createEventEnvelope('WORKFLOW_CHAIN_CREATED', { type: 'WORKFLOW_CHAIN_CREATED', ...data }, ctx));
-}
-
-export function emitWorkflowStateChanged(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { chainId: string; from: WrfcState; to: WrfcState }
-): void {
-  bus.emit('workflows', createEventEnvelope('WORKFLOW_STATE_CHANGED', { type: 'WORKFLOW_STATE_CHANGED', ...data }, ctx));
-}
-
-export function emitWorkflowReviewCompleted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { chainId: string; score: number; passed: boolean }
-): void {
-  bus.emit('workflows', createEventEnvelope('WORKFLOW_REVIEW_COMPLETED', { type: 'WORKFLOW_REVIEW_COMPLETED', ...data }, ctx));
-}
-
-export function emitWorkflowFixAttempted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { chainId: string; attempt: number; maxAttempts: number }
-): void {
-  bus.emit('workflows', createEventEnvelope('WORKFLOW_FIX_ATTEMPTED', { type: 'WORKFLOW_FIX_ATTEMPTED', ...data }, ctx));
-}
-
-export function emitWorkflowGateResult(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { chainId: string; gate: string; passed: boolean }
-): void {
-  bus.emit('workflows', createEventEnvelope('WORKFLOW_GATE_RESULT', { type: 'WORKFLOW_GATE_RESULT', ...data }, ctx));
-}
-
-export function emitWorkflowChainPassed(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { chainId: string }
-): void {
-  bus.emit('workflows', createEventEnvelope('WORKFLOW_CHAIN_PASSED', { type: 'WORKFLOW_CHAIN_PASSED', ...data }, ctx));
-}
-
-export function emitWorkflowChainFailed(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { chainId: string; reason: string }
-): void {
-  bus.emit('workflows', createEventEnvelope('WORKFLOW_CHAIN_FAILED', { type: 'WORKFLOW_CHAIN_FAILED', ...data }, ctx));
-}
-
-export function emitWorkflowAutoCommitted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { chainId: string; commitHash?: string }
-): void {
-  bus.emit('workflows', createEventEnvelope('WORKFLOW_AUTO_COMMITTED', { type: 'WORKFLOW_AUTO_COMMITTED', ...data }, ctx));
-}
-
-export function emitWorkflowCascadeAborted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { chainId: string; reason: string }
-): void {
-  bus.emit('workflows', createEventEnvelope('WORKFLOW_CASCADE_ABORTED', { type: 'WORKFLOW_CASCADE_ABORTED', ...data }, ctx));
-}

package/src/runtime/eval/index.ts

@@ -1,48 +0,0 @@
-/**
- * Evaluation Harness — barrel export.
- *
- * Provides the eval runner, scorecard scorer, built-in suites,
- * and baseline persistence utilities.
- *
- * @example
- * ```ts
- * import { EvalRunner, BUILTIN_SUITES, captureBaseline, loadBaseline } from './eval/index.ts';
- *
- * const runner = new EvalRunner();
- * const result = await runner.runSuite('core-performance', BUILTIN_SUITES['core-performance']);
- * const gate = runner.evaluateGate(result, await loadBaseline('.goodvibes/eval/baseline.json'));
- * if (!gate.passed) process.exit(1);
- * ```
- */
-
-export type {
-  EvalScenario,
-  EvalRawResult,
-  EvalResult,
-  EvalSuiteResult,
-  EvalScorecard,
-  EvalBaseline,
-  EvalGateResult,
-  EvalDimension,
-  DimensionScore,
-  RegressionEntry,
-  BaselineSuiteSummary,
-} from '@pellux/goodvibes-sdk/platform/runtime/eval/types';
-
-export { EvalRunner } from '@pellux/goodvibes-sdk/platform/runtime/eval/runner';
-export type { EvalRunnerOptions } from '@pellux/goodvibes-sdk/platform/runtime/eval/runner';
-
-export { scoreScenario, formatScorecard, DIMENSION_FLOOR } from '@pellux/goodvibes-sdk/platform/runtime/eval/scorecard';
-
-export { BUILTIN_SUITES, ALL_SCENARIOS } from '@pellux/goodvibes-sdk/platform/runtime/eval/suites';
-
-export {
-  captureBaseline,
-  serialiseBaseline,
-  deserialiseBaseline,
-  writeBaseline,
-  loadBaseline,
-  formatBaselineComparison,
-} from '@pellux/goodvibes-sdk/platform/runtime/eval/baseline';
-
-export { formatSuiteResult, formatGateResult } from '@pellux/goodvibes-sdk/platform/runtime/eval/format';

package/src/runtime/eval/runner.ts

@@ -1,163 +0,0 @@
-/**
- * Evaluation Harness — EvalRunner.
- *
- * Runs eval suites using production runtime paths:
- * - PerfMonitor for budget evaluation
- * - SloCollector for SLO p95 measurements
- * - scoreScenario() for dimension scoring
- *
- * The runner does not mock any dependencies — it exercises the real
- * production code paths that gate CI.
- */
-
-import type { EvalScenario, EvalRawResult, EvalResult, EvalSuiteResult, EvalGateResult, EvalBaseline, RegressionEntry } from '@pellux/goodvibes-sdk/platform/runtime/eval/types';
-import { scoreScenario } from '@pellux/goodvibes-sdk/platform/runtime/eval/scorecard';
-import { createPerfMonitor } from '@pellux/goodvibes-sdk/platform/runtime/perf/index';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
-
-// ── EvalRunner ────────────────────────────────────────────────────────────────
-
-export interface EvalRunnerOptions {
-  /**
-   * Regression threshold for gate comparisons.
-   * A scenario regresses if its composite score drops by more than this amount.
-   * Default: 5 (5-point drop).
-   */
-  regressionThreshold?: number;
-}
-
-/**
- * Runs eval suites and produces structured results.
- *
- * @example
- * ```ts
- * const runner = new EvalRunner();
- * const result = await runner.runSuite(mySuite);
- * if (!result.passed) process.exit(1);
- * ```
- */
-export class EvalRunner {
-  private readonly regressionThreshold: number;
-
-  constructor(options: EvalRunnerOptions = {}) {
-    this.regressionThreshold = options.regressionThreshold ?? 5;
-  }
-
-  /**
-   * Run all scenarios in a suite sequentially.
-   *
-   * Each scenario:
-   * 1. Calls scenario.run() via the production code path
-   * 2. Evaluates the raw result through PerfMonitor (if perfReport is absent)
-   * 3. Scores the result via scoreScenario()
-   *
-   * @param suite - Suite name (used for logging and baseline matching).
-   * @param scenarios - Scenarios to run.
-   * @returns Aggregated EvalSuiteResult.
-   */
-  async runSuite(suite: string, scenarios: EvalScenario[]): Promise<EvalSuiteResult> {
-    const startedAt = Date.now();
-    const results: EvalResult[] = [];
-
-    for (const scenario of scenarios) {
-      const result = await this._runScenario(scenario);
-      results.push(result);
-    }
-
-    const finishedAt = Date.now();
-    const meanScore =
-      results.length > 0
-        ? results.reduce((acc, r) => acc + r.scorecard.compositeScore, 0) / results.length
-        : 0;
-
-    const passed = results.every((r) => r.scorecard.passed);
-
-    return { suite, startedAt, finishedAt, results, meanScore, passed };
-  }
-
-  /**
-   * Compare a fresh suite result against a stored baseline.
-   * Produces an EvalGateResult indicating whether CI should pass.
-   *
-   * @param fresh - Result from a freshly-run suite.
-   * @param baseline - Previously stored baseline (may be undefined).
-   * @returns Gate result with per-scenario regression entries.
-   */
-  evaluateGate(fresh: EvalSuiteResult, baseline: EvalBaseline | undefined): EvalGateResult {
-    const regressions: RegressionEntry[] = [];
-
-    if (baseline) {
-      const baselineSuite = baseline.suites[fresh.suite];
-      if (baselineSuite) {
-        for (const result of fresh.results) {
-          const baselineScore = baselineSuite.scenarioScores[result.scenario.id];
-          if (baselineScore === undefined) continue;
-          const freshScore = result.scorecard.compositeScore;
-          const delta = freshScore - baselineScore;
-          if (delta < -this.regressionThreshold) {
-            regressions.push({
-              scenarioId: result.scenario.id,
-              scenarioName: result.scenario.name,
-              baselineScore,
-              freshScore,
-              delta,
-            });
-          }
-        }
-      }
-    }
-
-    return {
-      suite: fresh.suite,
-      passed: regressions.length === 0,
-      regressionThreshold: this.regressionThreshold,
-      fresh,
-      baseline,
-      regressions,
-    };
-  }
-
-  // ── Internal ────────────────────────────────────────────────────────────────
-
-  private async _runScenario(scenario: EvalScenario): Promise<EvalResult> {
-    const startedAt = Date.now();
-    let raw = await this._executeScenario(scenario);
-
-    // If the scenario did not include a perfReport, run a minimal PerfMonitor
-    // evaluation against an empty snapshot to at least populate the field.
-    if (!raw.perfReport) {
-      const monitor = createPerfMonitor();
-      const { createInitialSurfacePerfState } = await import('@pellux/goodvibes-sdk/platform/runtime/store/domains/surface-perf');
-      raw = {
-        ...raw,
-        perfReport: monitor.evaluate({
-          surfacePerf: createInitialSurfacePerfState(),
-          extraMetrics: {},
-        }),
-      };
-    }
-
-    const scorecard = scoreScenario(scenario.id, scenario.name, raw);
-    const finishedAt = Date.now();
-
-    return { scenario, raw, scorecard, startedAt, finishedAt };
-  }
-
-  /** Execute a scenario's run() function, catching and normalising errors. */
-  private async _executeScenario(scenario: EvalScenario): Promise<EvalRawResult> {
-    const t0 = Date.now();
-    try {
-      const raw = await scenario.run();
-      return raw;
-    } catch (err) {
-      const durationMs = Date.now() - t0;
-      const errorMessage = summarizeError(err);
-      return {
-        completed: false,
-        durationMs,
-        errorMessage,
-        safetyViolations: 0,
-      };
-    }
-  }
-}