@pellux/goodvibes-agent 0.1.0

package/src/input/commands/conversation-runtime.ts

@@ -0,0 +1,207 @@
+import { deriveComposerState } from '../../core/composer-state.ts';
+import type { TranscriptEventKind } from '@pellux/goodvibes-sdk/platform/core';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import { requireReadModels } from './runtime-services.ts';
+
+function parseTranscriptKind(raw: string | undefined): TranscriptEventKind | 'all' {
+  const normalized = (raw ?? 'all').toLowerCase().replace(/-/g, '_');
+  const allowed = new Set<TranscriptEventKind | 'all'>([
+    'all',
+    'user_input',
+    'assistant_output',
+    'tool_call',
+    'tool_result',
+    'approval_request',
+    'approval_resolution',
+    'task_transition',
+    'remote_status',
+    'policy_warning',
+    'artifact_preview',
+    'review_state',
+    'session_restore',
+    'diagnostic_notice',
+    'system_notice',
+  ]);
+  return allowed.has(normalized as TranscriptEventKind | 'all')
+    ? (normalized as TranscriptEventKind | 'all')
+    : 'all';
+}
+
+function buildTranscriptLines(
+  ctx: CommandContext,
+  kind: TranscriptEventKind | 'all',
+  mode: 'events' | 'groups' | 'hotspots',
+): string[] {
+  const index = ctx.session.conversationManager.getTranscriptEventIndex();
+  const events = kind === 'all' ? index.events : index.events.filter((event) => event.kind === kind);
+  const groups = kind === 'all' ? index.groups : index.groups.filter((group) => group.kind === kind);
+
+  if (mode === 'groups') {
+    return [
+      `Conversation Groups${kind === 'all' ? '' : `: ${kind}`}`,
+      `  groups: ${groups.length}`,
+      ...groups.slice(0, 12).map((group) => (
+        `  ${group.kind.padEnd(20)} ${String(group.events.length).padStart(2)} event(s)  msgs=${group.messageIndexes[0]}-${group.messageIndexes[group.messageIndexes.length - 1]}  ${group.title}`
+      )),
+      ...(groups.length > 12 ? [`  ... ${groups.length - 12} more group(s)`] : []),
+    ];
+  }
+
+  if (mode === 'hotspots') {
+    const kindCounts = new Map<TranscriptEventKind, number>();
+    for (const event of index.events) {
+      kindCounts.set(event.kind, (kindCounts.get(event.kind) ?? 0) + 1);
+    }
+    const busiestGroups = [...index.groups]
+      .sort((a, b) => b.events.length - a.events.length || a.messageIndexes[0]! - b.messageIndexes[0]!)
+      .slice(0, 8);
+    return [
+      'Conversation Hotspots',
+      ...[...kindCounts.entries()]
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .map(([eventKind, count]) => `  ${eventKind.padEnd(20)} ${count}`),
+      '',
+      'Busiest groups',
+      ...busiestGroups.map((group) => `  ${group.kind.padEnd(20)} ${String(group.events.length).padStart(2)}  ${group.title}`),
+    ];
+  }
+
+  return [
+    `Conversation Events${kind === 'all' ? '' : `: ${kind}`}`,
+    `  events: ${events.length}`,
+    ...events.slice(0, 16).map((event) => `  #${String(event.messageIndex).padStart(3)}  ${event.kind.padEnd(20)} ${event.title} - ${event.detail}`),
+    ...(events.length > 16 ? [`  ... ${events.length - 16} more event(s)`] : []),
+  ];
+}
+
+function buildComposerReview(ctx: CommandContext): string[] {
+  const session = requireReadModels(ctx).session.getSnapshot();
+  const composer = deriveComposerState({
+    text: '',
+    commandMode: false,
+    panelFocused: false,
+    pendingApproval: session.pendingApproval,
+    hasAttachments: false,
+    turnState: session.turnState,
+  });
+  return [
+    'Composer Review',
+    `  mode: ${composer.modeLabel}`,
+    `  status: ${composer.statusLabel}`,
+    `  risk: ${composer.pendingRisk}`,
+    `  flags: ${composer.flags.length > 0 ? composer.flags.join(', ') : 'none'}`,
+    `  turn state: ${session.turnState}`,
+    `  messages: ${session.messageCount || ctx.session.conversationManager.getMessageCount()}`,
+    `  context tokens: ${session.estimatedContextTokens}`,
+    `  context warning: ${session.contextWarningActive ? 'yes' : 'no'}`,
+  ];
+}
+
+function buildConversationSearch(ctx: CommandContext, query: string, kind: TranscriptEventKind | 'all'): string[] {
+  const index = ctx.session.conversationManager.getTranscriptEventIndex();
+  const q = query.trim().toLowerCase();
+  const events = (kind === 'all' ? index.events : index.events.filter((event) => event.kind === kind))
+    .filter((event) => q.length === 0 || event.title.toLowerCase().includes(q) || event.detail.toLowerCase().includes(q));
+  return [
+    `Conversation Search${kind === 'all' ? '' : `: ${kind}`}`,
+    `  query: ${query || '(empty)'}`,
+    `  matches: ${events.length}`,
+    ...events.slice(0, 16).map((event) => `  #${String(event.messageIndex).padStart(3)}  ${event.kind.padEnd(20)} ${event.title} - ${event.detail}`),
+    ...(events.length > 16 ? [`  ... ${events.length - 16} more match(es)`] : []),
+  ];
+}
+
+function buildConversationRestoreReview(ctx: CommandContext): string[] {
+  const index = ctx.session.conversationManager.getTranscriptEventIndex();
+  const restoreKinds = new Set<TranscriptEventKind>([
+    'session_restore',
+    'approval_request',
+    'approval_resolution',
+    'task_transition',
+    'remote_status',
+    'diagnostic_notice',
+  ]);
+  const events = index.events.filter((event) => restoreKinds.has(event.kind));
+  return [
+    'Conversation Restore Review',
+    `  restore-relevant events: ${events.length}`,
+    ...events.slice(0, 16).map((event) => `  #${String(event.messageIndex).padStart(3)}  ${event.kind.padEnd(20)} ${event.title} - ${event.detail}`),
+    ...(events.length > 16 ? [`  ... ${events.length - 16} more restore event(s)`] : []),
+    '  next: /conversation hotspots',
+    '  next: /session list',
+  ];
+}
+
+export function registerConversationRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'conversation',
+    aliases: ['transcript', 'composer'],
+    description: 'Review conversation structure, transcript hotspots, and composer posture',
+    usage: '[review|events [kind]|groups [kind]|hotspots|composer|find <query> [kind]|next [kind]|prev [kind]|restore]',
+    handler(args, ctx) {
+      const sub = (args[0] ?? 'review').toLowerCase();
+      if (sub === 'composer') {
+        ctx.print(buildComposerReview(ctx).join('\n'));
+        return;
+      }
+      if (sub === 'find' || sub === 'search') {
+        const trailing = args.length > 2 ? args[args.length - 1] : undefined;
+        const parsedTrailingKind = parseTranscriptKind(trailing);
+        const hasExplicitKind = Boolean(trailing) && parsedTrailingKind !== 'all';
+        const kind = hasExplicitKind ? parsedTrailingKind : 'all';
+        const queryParts = args.slice(1, hasExplicitKind ? -1 : undefined);
+        const query = queryParts.join(' ').trim();
+        ctx.print(buildConversationSearch(ctx, query, kind).join('\n'));
+        return;
+      }
+      if (sub === 'restore') {
+        ctx.print(buildConversationRestoreReview(ctx).join('\n'));
+        return;
+      }
+      if (sub === 'next' || sub === 'prev') {
+        const kind = parseTranscriptKind(args[1]);
+        const currentLine = ctx.getScrollTop?.() ?? 0;
+        const targetLine = sub === 'next'
+          ? ctx.session.conversationManager.nextTranscriptEventLine(currentLine, kind)
+          : ctx.session.conversationManager.prevTranscriptEventLine(currentLine, kind);
+        if (targetLine < 0) {
+          ctx.print(`No ${kind === 'all' ? 'transcript' : kind} events found.`);
+          return;
+        }
+        ctx.scrollToLine?.(targetLine);
+        ctx.print(`Jumped to ${kind === 'all' ? 'next transcript event' : `${kind} event`} at line ${targetLine + 1}.`);
+        return;
+      }
+      if (sub === 'events' || sub === 'groups' || sub === 'hotspots') {
+        const kind = parseTranscriptKind(args[1]);
+        ctx.print(buildTranscriptLines(ctx, kind, sub).join('\n'));
+        return;
+      }
+      if (sub !== 'review' && sub !== 'status') {
+        ctx.print('Usage: /conversation [review|events [kind]|groups [kind]|hotspots|composer|find <query> [kind]|next [kind]|prev [kind]|restore]');
+        return;
+      }
+
+      const index = ctx.session.conversationManager.getTranscriptEventIndex();
+      const session = requireReadModels(ctx).session.getSnapshot();
+      const byKind = new Map<TranscriptEventKind, number>();
+      for (const event of index.events) {
+        byKind.set(event.kind, (byKind.get(event.kind) ?? 0) + 1);
+      }
+      ctx.print([
+        'Conversation Review',
+        `  messages: ${session.messageCount || ctx.session.conversationManager.getMessageCount()}`,
+        `  events: ${index.events.length}`,
+        `  groups: ${index.groups.length}`,
+        `  turn state: ${session.turnState}`,
+        `  context tokens: ${session.estimatedContextTokens}`,
+        `  families: ${[...byKind.entries()].sort((a, b) => b[1] - a[1]).map(([kind, count]) => `${kind}=${count}`).join(', ') || 'none'}`,
+        '  next: /conversation hotspots',
+        '  next: /conversation composer',
+        '  next: /conversation find approval approval_request',
+        '  next: /conversation next tool_result',
+        '  next: /conversation restore',
+      ].join('\n'));
+    },
+  });
+}

package/src/input/commands/discovery-runtime.ts

@@ -0,0 +1,52 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import { scan, persistProviders } from '@pellux/goodvibes-sdk/platform/discovery';
+import { requireProviderApi, requireShellPaths } from './runtime-services.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../../config/surface.ts';
+
+export function registerDiscoveryRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'scan',
+    aliases: [],
+    description: 'Scan localhost and LAN for local LLM servers',
+    async handler(_args, ctx) {
+      ctx.print('Scanning for local LLM servers...');
+      ctx.renderRequest();
+
+      const result = await scan();
+
+      if (result.servers.length === 0) {
+        ctx.print(
+          `[Scan] No local LLM servers found (scanned ${result.scannedHosts} hosts, ` +
+          `${result.scannedPorts} ports in ${Math.round(result.durationMs / 1000)}s)`,
+        );
+      } else {
+        const lines = [
+          `[Scan] Found ${result.servers.length} server(s) in ${Math.round(result.durationMs / 1000)}s:`,
+          '',
+          ...result.servers.map((server) =>
+            `  ${server.name.padEnd(30)} ${server.models.length} model(s)  ${server.host}:${server.port}`,
+          ),
+          '',
+          'Use /model to select a discovered model.',
+        ];
+        ctx.print(lines.join('\n'));
+      }
+
+      try {
+        await requireProviderApi(ctx).registerDiscoveredProviders(result.servers);
+      } catch (err) {
+        ctx.print(`[Scan] Warning: failed to register some providers: ${summarizeError(err)}`);
+      }
+
+      if (result.servers.length > 0) {
+        const shellPaths = requireShellPaths(ctx);
+        persistProviders({
+          homeDirectory: shellPaths.homeDirectory,
+          surfaceRoot: GOODVIBES_AGENT_SURFACE_ROOT,
+        }, result.servers);
+      }
+      ctx.renderRequest();
+    },
+  });
+}

package/src/input/commands/eval.ts

@@ -0,0 +1,204 @@
+/**
+ * /eval command handler.
+ *
+ * Implements the Evaluation Harness commands:
+ *
+ *   /eval list                    — List all available eval suites
+ *   /eval run <suite>             — Run a named suite (or 'all')
+ *   /eval compare <baseline-file> — Compare last run against a baseline file
+ *   /eval gate <suite>            — Run suite and apply CI gate (exits 1 on regression)
+ */
+
+import type { SlashCommand, CommandContext } from '../command-registry.ts';
+import { EvalRunner } from '@/runtime/index.ts';
+import { BUILTIN_SUITES } from '@/runtime/index.ts';
+import { formatScorecard } from '@/runtime/index.ts';
+import { loadBaseline, captureBaseline, formatBaselineComparison, writeBaseline } from '@/runtime/index.ts';
+import type { EvalRegistry } from '../../panels/eval-panel.ts';
+import { formatSuiteResult, formatGateResult } from '@/runtime/index.ts';
+import { requireShellPaths } from './runtime-services.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+// ── Subcommand helpers ────────────────────────────────────────────────────────
+
+function printSuiteList(context: CommandContext): void {
+  context.print('[eval] Available suites:');
+  for (const [name, scenarios] of Object.entries(BUILTIN_SUITES)) {
+    context.print(`  ${name}  (${scenarios.length} scenarios)`);
+    for (const s of scenarios) {
+      context.print(`    - ${s.id}: ${s.name}`);
+    }
+  }
+  context.print('[eval] Usage: /eval run <suite>  or  /eval run all');
+}
+
+function getRegistry(context: CommandContext): EvalRegistry | undefined {
+  return context.extensions.evalRegistry;
+}
+
+// ── /eval list ────────────────────────────────────────────────────────────────
+
+function handleList(_args: string[], context: CommandContext): void {
+  printSuiteList(context);
+}
+
+// ── /eval run ────────────────────────────────────────────────────────────────
+
+async function handleRun(args: string[], context: CommandContext): Promise<void> {
+  const suiteName = args[0] ?? 'all';
+  const registry = getRegistry(context);
+
+  const suitesToRun =
+    suiteName === 'all'
+      ? Object.keys(BUILTIN_SUITES)
+      : BUILTIN_SUITES[suiteName]
+        ? [suiteName]
+        : null;
+
+  if (!suitesToRun) {
+    context.print(`[eval] Unknown suite: "${suiteName}". Run /eval list to see available suites.`);
+    return;
+  }
+
+  const runner = new EvalRunner();
+  registry?.setRunning(true);
+
+  for (const name of suitesToRun) {
+    const scenarios = BUILTIN_SUITES[name];
+    if (!scenarios) continue;
+
+    context.print(`[eval] Running suite: ${name} (${scenarios.length} scenarios)...`);
+    const result = await runner.runSuite(name, scenarios);
+    registry?.push(result);
+
+    context.print(formatSuiteResult(result));
+
+    for (const r of result.results) {
+      context.print(formatScorecard(r.scorecard));
+    }
+  }
+
+  registry?.setRunning(false);
+}
+
+// ── /eval compare ─────────────────────────────────────────────────────────────
+
+async function handleCompare(args: string[], context: CommandContext): Promise<void> {
+  const baselineFile = args[0] ?? '.goodvibes/eval/baseline.json';
+  const registry = getRegistry(context);
+  const projectRoot = requireShellPaths(context).workingDirectory;
+  const suiteResults = registry?.getSuiteResults() ?? [];
+
+  if (suiteResults.length === 0) {
+    context.print('[eval] No suite results to compare. Run /eval run <suite> first.');
+    return;
+  }
+
+  const baseline = await loadBaseline(baselineFile, projectRoot);
+  if (!baseline) {
+    context.print(`[eval] Baseline file not found: ${baselineFile}`);
+    context.print('[eval] Tip: run /eval gate <suite> to create a baseline.');
+    return;
+  }
+
+  for (const result of suiteResults) {
+    context.print(formatBaselineComparison(baseline, result));
+  }
+}
+
+// ── /eval gate ────────────────────────────────────────────────────────────────
+
+async function handleGate(args: string[], context: CommandContext): Promise<void> {
+  const suiteName = args[0];
+  const baselineFile = args[1] ?? '.goodvibes/eval/baseline.json';
+  const saveFlag = args.includes('--save-baseline');
+  const projectRoot = requireShellPaths(context).workingDirectory;
+
+  if (!suiteName) {
+    context.print('[eval] Usage: /eval gate <suite> [baseline-file] [--save-baseline]');
+    return;
+  }
+
+  const scenarios = BUILTIN_SUITES[suiteName];
+  if (!scenarios) {
+    context.print(`[eval] Unknown suite: "${suiteName}". Run /eval list to see available suites.`);
+    return;
+  }
+
+  const registry = getRegistry(context);
+  const runner = new EvalRunner();
+
+  context.print(`[eval] Gate: running suite "${suiteName}"...`);
+  registry?.setRunning(true);
+  const fresh = await runner.runSuite(suiteName, scenarios);
+  registry?.push(fresh);
+  registry?.setRunning(false);
+
+  const baseline = await loadBaseline(baselineFile, projectRoot);
+  const gate = runner.evaluateGate(fresh, baseline);
+  registry?.pushGate(gate);
+
+  context.print(formatGateResult(gate));
+
+  if (saveFlag || !baseline) {
+    const label = args[0] ?? 'latest';
+    const newBaseline = captureBaseline(label, [fresh]);
+    try {
+      await writeBaseline(baselineFile, newBaseline, projectRoot);
+      context.print(`[eval] Baseline saved to ${baselineFile}`);
+    } catch (err) {
+      context.print(`[eval] Warning: could not save baseline: ${summarizeError(err)}`);
+    }
+  }
+
+  if (!gate.passed) {
+    context.print(`[eval] Gate FAILED: ${gate.regressions.length} regression(s) detected.`);
+  } else {
+    context.print('[eval] Gate PASSED.');
+  }
+}
+
+// ── Top-level command ─────────────────────────────────────────────────────────
+
+export const evalCommand: SlashCommand = {
+  name: 'eval',
+  description: 'Evaluation harness: run benchmark suites, compare baselines, and gate regressions.',
+  usage: '<subcommand> [args]',
+  argsHint: 'list|run <suite>|compare <baseline>|gate <suite>',
+  handler: async (args: string[], context: CommandContext): Promise<void> => {
+    const [sub, ...rest] = args;
+
+    switch (sub) {
+      case 'list':
+      case 'ls':
+        handleList(rest, context);
+        break;
+
+      case 'run':
+        await handleRun(rest, context);
+        break;
+
+      case 'compare':
+      case 'cmp':
+        await handleCompare(rest, context);
+        break;
+
+      case 'gate':
+        await handleGate(rest, context);
+        break;
+
+      default: {
+        const usage = [
+          'Usage: /eval <subcommand>',
+          '  list                           — List all available eval suites',
+          '  run <suite|all>                — Run a named suite (or all suites)',
+          '  compare [baseline-file]        — Compare last results against baseline',
+          '  gate <suite> [baseline-file]   — Run suite and apply regression gate',
+          '    --save-baseline              — Save fresh run as new baseline',
+        ].join('\n');
+        context.print(usage);
+        break;
+      }
+    }
+  },
+};