@robota-sdk/agent-transport 3.0.0-beta.64

package/src/tui/__tests__/fixtures/provider-setup-prompt-driver.tsx

@@ -0,0 +1,122 @@
+import React from 'react';
+import { writeFileSync } from 'node:fs';
+import { render, useApp } from 'ink';
+import InteractivePrompt from '../../InteractivePrompt.js';
+import type { TCommandInteractionPrompt as TInteractivePrompt } from '@robota-sdk/agent-framework';
+import {
+  createProviderSetupFlow,
+  formatProviderSetupHelpLinks,
+  getProviderSetupStep,
+  submitProviderSetupValue,
+  validateProviderSetupValue,
+  type IProviderSetupFlowState,
+  type TProviderSetupType,
+} from '@robota-sdk/agent-command';
+import type { IAIProvider, IProviderDefinition } from '@robota-sdk/agent-core';
+
+const openaiDefaults = {
+  apiKey: '$ENV:OPENAI_API_KEY',
+};
+
+const providerDefinitions: readonly IProviderDefinition[] = [
+  {
+    type: 'openai',
+    defaults: openaiDefaults,
+    setupHelpLinks: [
+      {
+        kind: 'api-key',
+        label: 'OpenAI API keys',
+        url: 'https://platform.openai.com/api-keys',
+      },
+    ],
+    setupSteps: [
+      {
+        key: 'model',
+        title: 'OpenAI model',
+        required: true,
+      },
+      {
+        key: 'apiKey',
+        title: 'OpenAI API key',
+        defaultValue: openaiDefaults.apiKey,
+        masked: true,
+      },
+    ],
+    requiresApiKey: true,
+    createProvider: () => {
+      throw new Error('not used');
+    },
+  } as IProviderDefinition & { createProvider: () => IAIProvider },
+  {
+    type: 'anthropic',
+    defaults: { model: 'claude-sonnet-4-6' },
+    setupSteps: [
+      { key: 'apiKey', title: 'Anthropic API key', required: true, masked: true },
+      { key: 'model', title: 'Anthropic model', defaultValue: 'claude-sonnet-4-6' },
+    ],
+    requiresApiKey: true,
+    createProvider: () => {
+      throw new Error('not used');
+    },
+  } as IProviderDefinition & { createProvider: () => IAIProvider },
+];
+
+const [, , outputPath, rawType] = process.argv;
+
+if (!outputPath || (rawType !== 'openai' && rawType !== 'anthropic')) {
+  process.stderr.write('Usage: provider-setup-prompt-driver <output-path> <openai|anthropic>\n');
+  process.exit(1);
+}
+
+function Driver({ type }: { type: TProviderSetupType }): React.ReactElement {
+  const { exit } = useApp();
+  const initial = createProviderSetupFlow(type, providerDefinitions);
+  const [state, setState] = React.useState<IProviderSetupFlowState>(initial);
+  const [prompt, setPrompt] = React.useState<TInteractivePrompt>(() => toPrompt(initial));
+
+  return (
+    <InteractivePrompt
+      prompt={prompt}
+      onSubmit={(value) => {
+        const result = submitProviderSetupValue(state, value);
+        if (result.status === 'complete') {
+          writeFileSync(outputPath, JSON.stringify(result.input), 'utf8');
+          exit();
+          setTimeout(() => process.exit(0), 0);
+          return;
+        }
+        if (result.status === 'error') {
+          throw new Error(result.message);
+        }
+        setState(result.state);
+        setPrompt(toPrompt(result.state));
+      }}
+      onCancel={() => {
+        exit();
+        setTimeout(() => process.exit(2), 0);
+      }}
+    />
+  );
+}
+
+function toPrompt(flow: IProviderSetupFlowState): TInteractivePrompt {
+  const step = getProviderSetupStep(flow);
+  return {
+    kind: 'text',
+    title: step.title,
+    ...toPromptDescription(flow),
+    ...(step.defaultValue !== undefined ? { placeholder: step.defaultValue } : {}),
+    ...(step.defaultValue !== undefined ? { allowEmpty: true } : {}),
+    ...(step.masked !== undefined ? { masked: step.masked } : {}),
+    validate: (value) => validateProviderSetupValue(step, value),
+  };
+}
+
+function toPromptDescription(
+  flow: IProviderSetupFlowState,
+): { description: string } | Record<string, never> {
+  const description = formatProviderSetupHelpLinks(flow.setupHelpLinks);
+  return description.length > 0 ? { description } : {};
+}
+
+render(<Driver type={rawType} />);

package/src/tui/__tests__/input-area-flow.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it } from 'vitest';
+import {
+  appendPromptHistory,
+  createPasteLabelChange,
+  createPromptHistoryNavigationState,
+  extractPromptHistory,
+  getAutocompletePopupAction,
+  getPromptHistoryInputAction,
+  getPendingPromptInputAction,
+  moveAutocompleteSelection,
+  navigatePromptHistory,
+  resolveEnterCommandSelection,
+  resolveTabCompletion,
+  shouldSubmitInput,
+} from '../flows/input-area-flow.js';
+import type { ICommand } from '@robota-sdk/agent-framework';
+import {
+  createAssistantMessage,
+  createSystemMessage,
+  createUserMessage,
+  messageToHistoryEntry,
+} from '@robota-sdk/agent-core';
+
+const command = (name: string, subcommands?: ICommand[]): ICommand => ({
+  name,
+  description: `${name} command`,
+  source: 'test',
+  subcommands,
+  execute: async () => {},
+});
+
+describe('input area flow', () => {
+  it('Given autocomplete key info When mapped Then popup actions are produced', () => {
+    expect(getAutocompletePopupAction({ upArrow: true })).toBe('previous');
+    expect(getAutocompletePopupAction({ downArrow: true })).toBe('next');
+    expect(getAutocompletePopupAction({ escape: true })).toBe('close');
+    expect(getAutocompletePopupAction({ tab: true })).toBe('complete');
+  });
+
+  it('Given pending prompt key info When mapped Then cancel queue action is produced', () => {
+    expect(getPendingPromptInputAction({ backspace: true })).toBe('cancelQueue');
+    expect(getPendingPromptInputAction({ delete: true })).toBe('cancelQueue');
+    expect(getPendingPromptInputAction({ downArrow: true })).toBeUndefined();
+  });
+
+  it('Given wrapping autocomplete When moving beyond bounds Then index wraps', () => {
+    expect(moveAutocompleteSelection(0, 3, 'previous')).toBe(2);
+    expect(moveAutocompleteSelection(2, 3, 'next')).toBe(0);
+  });
+
+  it('Given parent command input When tab completes subcommand Then child name is inserted', () => {
+    const result = resolveTabCompletion('/plugin i', command('install'));
+
+    expect(result).toEqual({ type: 'insert', value: '/plugin install ' });
+  });
+
+  it('Given command with subcommands When enter selects it Then command name is inserted', () => {
+    const result = resolveEnterCommandSelection('/pl', command('plugin', [command('list')]));
+
+    expect(result).toEqual({ type: 'insert', value: '/plugin ', selectedIndex: 0 });
+  });
+
+  it('Given leaf command When enter selects it Then submit value is emitted', () => {
+    const result = resolveEnterCommandSelection('/he', command('help'));
+
+    expect(result).toEqual({ type: 'submit', value: '/help' });
+  });
+
+  it('Given multiline paste When label change is created Then label is inserted at cursor', () => {
+    const result = createPasteLabelChange('abef', 2, 7, 'c\nd\ne');
+
+    expect(result).toEqual({
+      value: 'ab[Pasted text #7 +3 lines]ef',
+      cursorHint: 27,
+      label: '[Pasted text #7 +3 lines]',
+      lineCount: 3,
+    });
+  });
+
+  it('Given blank prompt When checked Then submit is rejected', () => {
+    expect(shouldSubmitInput('   ')).toBe(false);
+    expect(shouldSubmitInput(' hello ')).toBe(true);
+  });
+
+  it('Given prompt history key info When mapped Then history actions are produced', () => {
+    expect(getPromptHistoryInputAction({ upArrow: true })).toBe('previous');
+    expect(getPromptHistoryInputAction({ downArrow: true })).toBe('next');
+    expect(getPromptHistoryInputAction({ escape: true })).toBeUndefined();
+  });
+
+  it('Given empty prompt history When navigating Then input is unchanged', () => {
+    const result = navigatePromptHistory(
+      'draft',
+      [],
+      createPromptHistoryNavigationState(),
+      'previous',
+    );
+
+    expect(result).toEqual({
+      value: 'draft',
+      cursorHint: 5,
+      state: createPromptHistoryNavigationState(),
+    });
+  });
+
+  it('Given draft and history When pressing up Then latest prompt is recalled and draft is saved', () => {
+    const result = navigatePromptHistory(
+      'draft text',
+      ['first', 'second'],
+      createPromptHistoryNavigationState(),
+      'previous',
+    );
+
+    expect(result).toEqual({
+      value: 'second',
+      cursorHint: 6,
+      state: { selectedIndex: 1, draft: 'draft text' },
+    });
+  });
+
+  it('Given history navigation When pressing down past latest Then draft is restored', () => {
+    const result = navigatePromptHistory(
+      'second',
+      ['first', 'second'],
+      { selectedIndex: 1, draft: 'draft text' },
+      'next',
+    );
+
+    expect(result).toEqual({
+      value: 'draft text',
+      cursorHint: 10,
+      state: createPromptHistoryNavigationState(),
+    });
+  });
+
+  it('Given prompt submit When appended Then blank and consecutive duplicates are ignored', () => {
+    expect(appendPromptHistory(['first'], 'second')).toEqual(['first', 'second']);
+    expect(appendPromptHistory(['first'], 'first')).toEqual(['first']);
+    expect(appendPromptHistory(['first'], '   ')).toEqual(['first']);
+  });
+
+  it('Given history entries When extracted Then only user chat content is included', () => {
+    const entries = [
+      messageToHistoryEntry(createUserMessage('first')),
+      messageToHistoryEntry(createAssistantMessage('answer')),
+      messageToHistoryEntry(createSystemMessage('system')),
+      messageToHistoryEntry(createUserMessage('second')),
+    ];
+
+    expect(extractPromptHistory(entries)).toEqual(['first', 'second']);
+  });
+});

package/src/tui/__tests__/message-list-rendering.test.tsx

@@ -0,0 +1,353 @@
+/**
+ * Rendering tests for MessageList — verifies that IHistoryEntry[]
+ * entries render with correct labels and content.
+ *
+ * These tests catch rendering bugs that data-flow tests miss:
+ * - tool execution list must show "Tool:" label with tool names
+ * - chat messages must show correct role labels
+ * - event entries must show formatted content
+ */
+
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, it, expect } from 'vitest';
+import MessageList from '../MessageList.js';
+import type { IHistoryEntry } from '@robota-sdk/agent-core';
+import {
+  createUserMessage,
+  createAssistantMessage,
+  createSystemMessage,
+  createToolMessage,
+  messageToHistoryEntry,
+} from '@robota-sdk/agent-core';
+
+function makeToolSummaryEntry(): IHistoryEntry {
+  return {
+    id: 'tool-1',
+    timestamp: new Date(),
+    category: 'event',
+    type: 'tool-summary',
+    data: {
+      tools: [
+        { toolName: 'Read', firstArg: 'file.ts', isRunning: false, result: 'success' },
+        { toolName: 'Edit', firstArg: 'file.ts', isRunning: false, result: 'success' },
+      ],
+      summary: '✓ Read(file.ts)\n✓ Edit(file.ts)',
+    },
+  };
+}
+
+function makeSkillInvocationEntry(): IHistoryEntry {
+  return {
+    id: 'evt-1',
+    timestamp: new Date(),
+    category: 'event',
+    type: 'skill-activation',
+    data: {
+      type: 'skill-activation',
+      skillName: 'audit',
+      source: 'plugin',
+      invocation: 'user-slash',
+      mode: 'inject',
+      status: 'started',
+      timestamp: '2026-05-06T00:00:00.000Z',
+      message: 'Invoking plugin skill: audit',
+    },
+  };
+}
+
+describe('MessageList rendering', () => {
+  // ── Tool summary rendering ────────────────────────────────────
+
+  it('tool execution list renders with "Tool:" label and tool names', () => {
+    const history: IHistoryEntry[] = [makeToolSummaryEntry()];
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('Tool:');
+    expect(output).toContain('Read(file.ts)');
+    expect(output).toContain('Edit(file.ts)');
+  });
+
+  // ── Skill invocation rendering ────────────────────────────────
+
+  it('skill-activation event renders with "System:" label and message', () => {
+    const history: IHistoryEntry[] = [makeSkillInvocationEntry()];
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('System:');
+    expect(output).toContain('Invoking plugin skill: audit');
+  });
+
+  // ── Chat message rendering ────────────────────────────────────
+
+  it('user message renders with "You:" label', () => {
+    const history: IHistoryEntry[] = [messageToHistoryEntry(createUserMessage('hello'))];
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('You:');
+    expect(output).toContain('hello');
+  });
+
+  it('assistant message renders with "Robota:" label', () => {
+    const history: IHistoryEntry[] = [
+      messageToHistoryEntry(createAssistantMessage('response text')),
+    ];
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('Robota:');
+    expect(output).toContain('response text');
+  });
+
+  it('assistant message preserves CJK and emoji content', () => {
+    const content = '긴 한국어 응답과 emoji 🎉 를 표시합니다';
+    const history: IHistoryEntry[] = [messageToHistoryEntry(createAssistantMessage(content))];
+    const { lastFrame } = render(<MessageList history={history} />);
+
+    expect(lastFrame()).toContain(content);
+  });
+
+  it('assistant message renders markdown diff fenced code block content', () => {
+    const response = [
+      'Patch preview:',
+      '',
+      '```diff',
+      '- const oldValue = true;',
+      '+ const newValue = true;',
+      '```',
+    ].join('\n');
+    const history: IHistoryEntry[] = [messageToHistoryEntry(createAssistantMessage(response))];
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('Robota:');
+    expect(output).toContain('Patch preview:');
+    expect(output).toContain('- const oldValue = true;');
+    expect(output).toContain('+ const newValue = true;');
+  });
+
+  it('tool message diff summary renders through markdown diff body format', () => {
+    const toolSummary = [
+      {
+        line: 'Edit(/src/index.ts)',
+        diffFile: '/src/index.ts',
+        diffLines: [
+          { type: 'remove', lineNumber: 1, text: 'const oldValue = true;' },
+          { type: 'add', lineNumber: 1, text: 'const newValue = true;' },
+        ],
+      },
+    ];
+    const history: IHistoryEntry[] = [
+      messageToHistoryEntry(
+        createToolMessage(JSON.stringify(toolSummary), {
+          toolCallId: 'call_1',
+          name: 'tools',
+        }),
+      ),
+    ];
+
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('/src/index.ts');
+    expect(output).toContain('- 1 | const oldValue = true;');
+    expect(output).toContain('+ 1 | const newValue = true;');
+    expect(output).not.toContain('│ 1 - const oldValue = true;');
+  });
+
+  it('tool-summary event renders persisted edit diff metadata', () => {
+    const history: IHistoryEntry[] = [
+      {
+        id: 'summary_1',
+        timestamp: new Date(),
+        category: 'event',
+        type: 'tool-summary',
+        data: {
+          tools: [
+            {
+              toolName: 'Edit',
+              firstArg: '/src/index.ts',
+              isRunning: false,
+              result: 'success',
+              diffFile: '/src/index.ts',
+              diffLines: [
+                { type: 'remove', lineNumber: 1, text: 'const temporary = true;' },
+                { type: 'add', lineNumber: 1, text: 'const original = true;' },
+              ],
+            },
+          ],
+          summary: '✓ Edit(/src/index.ts)',
+        },
+      },
+    ];
+
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('/src/index.ts');
+    expect(output).toContain('- 1 | const temporary = true;');
+    expect(output).toContain('+ 1 | const original = true;');
+  });
+
+  it('tool-summary event collapses long command output with transcript hint', () => {
+    const commandOutput = Array.from({ length: 7 }, (_, index) => `line-${index + 1}`).join('\n');
+    const history: IHistoryEntry[] = [
+      {
+        id: 'summary_command_long',
+        timestamp: new Date(),
+        category: 'event',
+        type: 'tool-summary',
+        data: {
+          tools: [
+            {
+              toolName: 'Bash',
+              firstArg: 'pnpm test',
+              isRunning: false,
+              result: 'success',
+              toolResultData: JSON.stringify({
+                success: true,
+                output: commandOutput,
+                exitCode: 0,
+              }),
+            },
+          ],
+          summary: '✓ Bash(pnpm test)',
+        },
+      },
+    ];
+
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('✓ Bash(pnpm test)');
+    expect(output).toContain('line-1');
+    expect(output).toContain('line-4');
+    expect(output).not.toContain('line-5');
+    expect(output).toContain('... +3 lines (full output in session transcript)');
+  });
+
+  it('tool-summary event marks non-zero command exits as failed', () => {
+    const history: IHistoryEntry[] = [
+      {
+        id: 'summary_command_failed',
+        timestamp: new Date(),
+        category: 'event',
+        type: 'tool-summary',
+        data: {
+          tools: [
+            {
+              toolName: 'Bash',
+              firstArg: 'exit 42',
+              isRunning: false,
+              result: 'success',
+              toolResultData: JSON.stringify({ success: true, output: '', exitCode: 42 }),
+            },
+          ],
+          summary: '✓ Bash(exit 42)',
+        },
+      },
+    ];
+
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('✗ Bash(exit 42)');
+    expect(output).toContain('exit 42');
+  });
+
+  it('usage-summary event renders compact token and cost visibility', () => {
+    const history: IHistoryEntry[] = [
+      {
+        id: 'usage_1',
+        timestamp: new Date(),
+        category: 'event',
+        type: 'usage-summary',
+        data: {
+          kind: 'exact',
+          scope: 'turn',
+          promptTokens: 100,
+          completionTokens: 50,
+          totalTokens: 150,
+          contextUsedTokens: 150,
+          contextMaxTokens: 1000,
+          contextUsedPercentage: 15,
+          costStatus: 'unknown',
+        },
+      },
+    ];
+
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('Usage:');
+    expect(output).toContain('exact');
+    expect(output).toContain('150 tokens');
+    expect(output).toContain('in 100');
+    expect(output).toContain('out 50');
+    expect(output).toContain('cost unknown');
+  });
+
+  it('system message renders with "System:" label', () => {
+    const history: IHistoryEntry[] = [
+      messageToHistoryEntry(createSystemMessage('Interrupted by user.')),
+    ];
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('System:');
+    expect(output).toContain('Interrupted by user.');
+  });
+
+  // ── Display order after abort ─────────────────────────────────
+
+  it('abort display order: You → Tool → Robota → System', () => {
+    const history: IHistoryEntry[] = [
+      messageToHistoryEntry(createUserMessage('/audit')),
+      makeToolSummaryEntry(),
+      messageToHistoryEntry(createAssistantMessage('partial response')),
+      messageToHistoryEntry(createSystemMessage('Interrupted by user.')),
+    ];
+
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    const youIdx = output.indexOf('You:');
+    const toolIdx = output.indexOf('Tool:');
+    const robotaIdx = output.indexOf('Robota:');
+    const systemIdx = output.indexOf('Interrupted by user.');
+
+    // All must be present
+    expect(youIdx).toBeGreaterThanOrEqual(0);
+    expect(toolIdx).toBeGreaterThanOrEqual(0);
+    expect(robotaIdx).toBeGreaterThanOrEqual(0);
+    expect(systemIdx).toBeGreaterThanOrEqual(0);
+
+    // Order: You → Tool → Robota → System
+    expect(youIdx).toBeLessThan(toolIdx);
+    expect(toolIdx).toBeLessThan(robotaIdx);
+    expect(robotaIdx).toBeLessThan(systemIdx);
+  });
+
+  // ── Mixed history ─────────────────────────────────────────────
+
+  it('renders mixed chat and event entries in order', () => {
+    const history: IHistoryEntry[] = [
+      messageToHistoryEntry(createUserMessage('hello')),
+      makeSkillInvocationEntry(),
+      makeToolSummaryEntry(),
+      messageToHistoryEntry(createAssistantMessage('done')),
+    ];
+
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    // All four entries rendered
+    expect(output).toContain('You:');
+    expect(output).toContain('Invoking plugin skill: audit');
+    expect(output).toContain('Tool:');
+    expect(output).toContain('Robota:');
+  });
+});