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

package/src/tui/__tests__/selection-flow.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest';
+import {
+  applySelectionInput,
+  createSelectionFlowState,
+  getDirectionalSelectionInputAction,
+  getVerticalSelectionInputAction,
+} from '../flows/selection-flow.js';
+
+describe('selection flow', () => {
+  it('Given first item selected When previous is applied Then selection stays bounded', () => {
+    const result = applySelectionInput(createSelectionFlowState(), 'previous', { itemCount: 3 });
+
+    expect(result.state.selectedIndex).toBe(0);
+    expect(result.effect).toEqual({ type: 'none' });
+  });
+
+  it('Given last item selected When next is applied Then selection stays bounded', () => {
+    const state = { selectedIndex: 2, scrollOffset: 0, resolved: false };
+
+    const result = applySelectionInput(state, 'next', { itemCount: 3 });
+
+    expect(result.state.selectedIndex).toBe(2);
+  });
+
+  it('Given wrapping selection When previous from first is applied Then it wraps to last', () => {
+    const result = applySelectionInput(createSelectionFlowState(), 'previous', {
+      itemCount: 3,
+      wrap: true,
+    });
+
+    expect(result.state.selectedIndex).toBe(2);
+  });
+
+  it('Given max visible window When moving below viewport Then scroll offset follows', () => {
+    const state = applySelectionInput(createSelectionFlowState(), 'next', {
+      itemCount: 4,
+      maxVisible: 2,
+    }).state;
+
+    const result = applySelectionInput(state, 'next', { itemCount: 4, maxVisible: 2 });
+
+    expect(result.state).toMatchObject({ selectedIndex: 2, scrollOffset: 1 });
+  });
+
+  it('Given selected item When select is applied Then selected index is emitted once', () => {
+    const state = { selectedIndex: 1, scrollOffset: 0, resolved: false };
+
+    const selected = applySelectionInput(state, 'select', { itemCount: 3 });
+    const ignored = applySelectionInput(selected.state, 'select', { itemCount: 3 });
+
+    expect(selected.effect).toEqual({ type: 'select', index: 1 });
+    expect(ignored.effect).toEqual({ type: 'none' });
+  });
+
+  it('Given raw key info When mapped Then vertical and directional actions are produced', () => {
+    expect(getVerticalSelectionInputAction({ downArrow: true })).toBe('next');
+    expect(getVerticalSelectionInputAction({ escape: true })).toBe('cancel');
+    expect(getDirectionalSelectionInputAction({ leftArrow: true })).toBe('previous');
+    expect(getDirectionalSelectionInputAction({ rightArrow: true })).toBe('next');
+  });
+});

package/src/tui/__tests__/slash-routing-effects.test.ts

@@ -0,0 +1,225 @@
+import { homedir } from 'node:os';
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { afterEach, vi } from 'vitest';
+import {
+  CommandRegistry,
+  BundlePluginLoader,
+  PluginCommandSource,
+} from '@robota-sdk/agent-framework';
+import type { ICommandInteraction, IInteractiveSession } from '@robota-sdk/agent-framework';
+import { TuiStateManager } from '../tui-state-manager.js';
+import { applySystemCommandResult } from '../hooks/useSlashRouting.js';
+import { CommandEffectQueue } from '../hooks/command-effect-queue.js';
+
+const PLUGIN_SOURCE_NAME = 'plugin';
+
+function reloadPluginCommandSource(registry: CommandRegistry): void {
+  const pluginsDir = join(process.env.HOME ?? homedir(), '.robota', 'plugins');
+  const loader = new BundlePluginLoader(pluginsDir);
+  try {
+    // allow-fallback: test helper — empty registry on load error is safe
+    const plugins = loader.loadPluginsSync();
+    if (plugins.length === 0) {
+      registry.replaceSource(PLUGIN_SOURCE_NAME);
+    } else {
+      registry.replaceSource(PLUGIN_SOURCE_NAME, new PluginCommandSource(plugins));
+    }
+  } catch {
+    // allow-fallback: test helper — empty registry on load error is safe
+    registry.replaceSource(PLUGIN_SOURCE_NAME);
+  }
+}
+
+describe('applySystemCommandResult', () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  function createRegistry(): CommandRegistry {
+    return new CommandRegistry();
+  }
+
+  function legacyCommandField(suffix: 'Interaction' | 'Effects'): string {
+    return `_pendingCommand${suffix}`;
+  }
+
+  it('stores statusline settings patch as a CLI side effect', () => {
+    const session = {
+      getContextState: () => ({ usedPercentage: 0, usedTokens: 0, maxTokens: 0 }),
+    } as unknown as IInteractiveSession;
+    const manager = new TuiStateManager();
+    const queue = new CommandEffectQueue();
+
+    applySystemCommandResult(
+      {
+        success: true,
+        message: 'Status line disabled.',
+        effects: [{ type: 'statusline-settings-patch', patch: { enabled: false } }],
+      },
+      session,
+      createRegistry(),
+      manager,
+      queue,
+    );
+
+    expect(queue.drain()).toEqual({
+      type: 'effects',
+      effects: [{ type: 'statusline-settings-patch', patch: { enabled: false } }],
+    });
+    expect(Object.hasOwn(session, legacyCommandField('Effects'))).toBe(false);
+  });
+
+  it('stores generic command interactions without interpreting command-specific data', () => {
+    const session = {
+      getContextState: () => ({ usedPercentage: 0, usedTokens: 0, maxTokens: 0 }),
+    } as unknown as IInteractiveSession;
+    const manager = new TuiStateManager();
+    const queue = new CommandEffectQueue();
+    const interaction: ICommandInteraction = {
+      prompt: {
+        kind: 'choice',
+        title: 'Change provider?',
+        options: [
+          { value: 'yes', label: 'Yes' },
+          { value: 'no', label: 'No' },
+        ],
+      },
+      submit: () => ({ success: true, message: 'done' }),
+    };
+
+    applySystemCommandResult(
+      {
+        success: true,
+        message: 'Switch provider?',
+        interaction,
+      },
+      session,
+      createRegistry(),
+      manager,
+      queue,
+    );
+
+    expect(queue.drain()).toEqual({ type: 'interaction', interaction });
+    expect(Object.hasOwn(session, legacyCommandField('Interaction'))).toBe(false);
+  });
+
+  it('stores host command side effects', () => {
+    const session = {
+      getContextState: () => ({ usedPercentage: 0, usedTokens: 0, maxTokens: 0 }),
+    } as unknown as IInteractiveSession;
+    const manager = new TuiStateManager();
+    const queue = new CommandEffectQueue();
+
+    applySystemCommandResult(
+      {
+        success: true,
+        message: 'Opening plugin manager...',
+        effects: [{ type: 'plugin-tui-requested' }],
+      },
+      session,
+      createRegistry(),
+      manager,
+      queue,
+    );
+
+    expect(queue.drain()).toEqual({
+      type: 'effects',
+      effects: [{ type: 'plugin-tui-requested' }],
+    });
+    expect(Object.hasOwn(session, legacyCommandField('Effects'))).toBe(false);
+  });
+
+  it('applies conversation history clearing immediately before adding the command result', () => {
+    const session = {
+      getContextState: () => ({ usedPercentage: 0, usedTokens: 0, maxTokens: 0 }),
+    } as unknown as IInteractiveSession;
+    const manager = new TuiStateManager();
+    const queue = new CommandEffectQueue();
+    manager.addEntry({
+      id: 'old',
+      timestamp: new Date('2026-05-03T00:00:00.000Z'),
+      category: 'chat',
+      type: 'user',
+      data: { role: 'user', content: 'old message' },
+    });
+
+    applySystemCommandResult(
+      {
+        success: true,
+        message: 'Conversation cleared.',
+        effects: [{ type: 'conversation-history-cleared' }],
+      },
+      session,
+      createRegistry(),
+      manager,
+      queue,
+    );
+
+    expect(manager.history).toHaveLength(1);
+    expect(manager.history[0]?.type).toBe('system');
+    expect(manager.history[0]?.data).toMatchObject({ content: 'Conversation cleared.' });
+    expect(queue.drain()).toBeUndefined();
+    expect(Object.hasOwn(session, legacyCommandField('Effects'))).toBe(false);
+  });
+
+  it('reloads plugin command source immediately when requested', () => {
+    const home = mkdtempSync(join(tmpdir(), 'robota-plugin-reload-'));
+    const pluginDir = join(
+      home,
+      '.robota',
+      'plugins',
+      'cache',
+      'community',
+      'fresh-plugin',
+      '1.0.0',
+    );
+    mkdirSync(join(pluginDir, '.claude-plugin'), { recursive: true });
+    mkdirSync(join(pluginDir, 'skills', 'fresh-skill'), { recursive: true });
+    writeFileSync(
+      join(pluginDir, '.claude-plugin', 'plugin.json'),
+      JSON.stringify({
+        name: 'fresh-plugin',
+        version: '1.0.0',
+        description: 'Fresh plugin',
+        features: { skills: true },
+      }),
+      'utf8',
+    );
+    writeFileSync(
+      join(pluginDir, 'skills', 'fresh-skill', 'SKILL.md'),
+      '---\ndescription: Fresh skill\n---\n# Fresh Skill\n',
+      'utf8',
+    );
+    vi.stubEnv('HOME', home);
+    const session = {
+      getContextState: () => ({ usedPercentage: 0, usedTokens: 0, maxTokens: 0 }),
+    } as unknown as IInteractiveSession;
+    const registry = createRegistry();
+    const queue = new CommandEffectQueue();
+    registry.addSource({
+      name: 'plugin',
+      getCommands: () => [{ name: 'stale-skill', description: 'Stale', source: 'plugin' }],
+    });
+    const manager = new TuiStateManager();
+
+    applySystemCommandResult(
+      {
+        success: true,
+        message: 'Reloaded 1 plugin resource.',
+        effects: [{ type: 'plugin-registry-reload-requested' }],
+      },
+      session,
+      registry,
+      manager,
+      queue,
+      reloadPluginCommandSource,
+    );
+
+    expect(registry.getCommands().map((command) => command.name)).toEqual(['fresh-skill']);
+    expect(queue.drain()).toBeUndefined();
+    expect(Object.hasOwn(session, legacyCommandField('Effects'))).toBe(false);
+  });
+});

package/src/tui/__tests__/status-activity.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest';
+import { formatStatusActivity } from '../status-activity.js';
+
+describe('formatStatusActivity', () => {
+  it('prioritizes running tools over thinking, background work, and queued prompts', () => {
+    const activity = formatStatusActivity({
+      isThinking: true,
+      activeToolCount: 2,
+      activeBackgroundTaskCount: 3,
+      hasPendingPrompt: true,
+    });
+
+    expect(activity.kind).toBe('tools');
+    expect(activity.label).toBe('Tools x2');
+    expect(activity.color).toBe('cyan');
+    expect(activity.segments).toEqual(['queued']);
+    expect(activity.text).toBe('Tools x2 · queued');
+  });
+
+  it('shows thinking as the primary model waiting state', () => {
+    const activity = formatStatusActivity({
+      isThinking: true,
+      activeToolCount: 0,
+      activeBackgroundTaskCount: 0,
+      hasPendingPrompt: false,
+    });
+
+    expect(activity.kind).toBe('thinking');
+    expect(activity.label).toBe('Thinking');
+    expect(activity.segments).toEqual([]);
+  });
+
+  it('shows background activity when foreground work is idle', () => {
+    const activity = formatStatusActivity({
+      isThinking: false,
+      activeToolCount: 0,
+      activeBackgroundTaskCount: 1,
+      hasPendingPrompt: false,
+    });
+
+    expect(activity.kind).toBe('background');
+    expect(activity.label).toBe('Background x1');
+    expect(activity.color).toBe('cyan');
+  });
+
+  it('shows queued prompt before idle when no work is active', () => {
+    const activity = formatStatusActivity({
+      isThinking: false,
+      activeToolCount: 0,
+      activeBackgroundTaskCount: 0,
+      hasPendingPrompt: true,
+    });
+
+    expect(activity.kind).toBe('queued');
+    expect(activity.label).toBe('Queued');
+    expect(activity.color).toBe('yellow');
+  });
+
+  it('keeps idle compact and dim', () => {
+    const activity = formatStatusActivity({
+      isThinking: false,
+      activeToolCount: 0,
+      activeBackgroundTaskCount: 0,
+      hasPendingPrompt: false,
+    });
+
+    expect(activity.kind).toBe('idle');
+    expect(activity.text).toBe('Idle');
+    expect(activity.color).toBe('gray');
+  });
+});

package/src/tui/__tests__/status-bar.test.tsx

@@ -0,0 +1,157 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, it, expect } from 'vitest';
+import StatusBar from '../StatusBar.js';
+
+describe('StatusBar', () => {
+  const baseProps = {
+    permissionMode: 'default' as const,
+    modelName: 'test-model',
+    sessionId: 'sess-1',
+    isThinking: false,
+    activeToolCount: 0,
+    activeBackgroundTaskCount: 0,
+    hasPendingPrompt: false,
+    contextPercentage: 10,
+    contextUsedTokens: 1000,
+    contextMaxTokens: 200000,
+  };
+
+  it('renders without session name', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('test-model');
+    expect(frame).not.toContain('Mode: default');
+  });
+
+  it('hides default permission mode', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} permissionMode="default" />);
+    const frame = lastFrame()!;
+    expect(frame).not.toContain('Mode:');
+    expect(frame).not.toContain('default');
+  });
+
+  it('shows non-default permission modes', () => {
+    for (const permissionMode of ['plan', 'acceptEdits', 'bypassPermissions'] as const) {
+      const { lastFrame, unmount } = render(
+        <StatusBar {...baseProps} permissionMode={permissionMode} />,
+      );
+      const frame = lastFrame()!;
+      expect(frame).toContain('Mode:');
+      expect(frame).toContain(permissionMode);
+      unmount();
+    }
+  });
+
+  it('renders session name when provided', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} sessionName="my-feature" />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('my-feature');
+  });
+
+  it('does not show session name when undefined', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} sessionName={undefined} />);
+    const frame = lastFrame()!;
+    // Should not have extra separator for missing name
+    expect(frame).not.toContain('my-feature');
+  });
+
+  it('renders model name', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('test-model');
+  });
+
+  it('renders provider display name and model when provided', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} providerDisplayName="Anthropic" />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('Anthropic');
+    expect(frame).toContain('test-model');
+  });
+
+  it('does not render message count in the status bar', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} />);
+    const frame = lastFrame()!;
+    expect(frame).not.toContain('msgs:');
+  });
+
+  it('shows thinking indicator when isThinking is true', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} isThinking={true} />);
+    const frame = lastFrame()!;
+    expect(frame).not.toContain('Activity:');
+    expect(frame).toContain('Thinking');
+    expect(frame.indexOf('Thinking')).toBeLessThan(frame.indexOf('test-model'));
+  });
+
+  it('does not duplicate thinking state in secondary status text', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} isThinking={true} />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('Thinking');
+    expect(frame).not.toContain('thinking...');
+    expect(frame).not.toContain('msgs:');
+  });
+
+  it('hides the lower-right prompt-processing indicator while idle', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} isThinking={false} />);
+    const frame = lastFrame()!;
+    expect(frame).not.toContain('thinking...');
+  });
+
+  it('prioritizes tool activity in the primary scan path', () => {
+    const { lastFrame } = render(
+      <StatusBar
+        {...baseProps}
+        isThinking={true}
+        activeToolCount={2}
+        activeBackgroundTaskCount={1}
+        hasPendingPrompt={true}
+      />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).not.toContain('Activity:');
+    expect(frame).toContain('Tools x2');
+    expect(frame).toContain('queued');
+    expect(frame).not.toContain('thinking...');
+    expect(frame.indexOf('Tools x2')).toBeLessThan(frame.indexOf('test-model'));
+    expect(frame).not.toContain('Thinking...');
+  });
+
+  it('shows background activity when no foreground execution is active', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} activeBackgroundTaskCount={3} />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('Background x3');
+    expect(frame.indexOf('Background x3')).toBeLessThan(frame.indexOf('test-model'));
+  });
+
+  it('keeps the activity segment compact for narrow terminals', () => {
+    const { lastFrame } = render(
+      <StatusBar
+        {...baseProps}
+        isThinking={true}
+        activeToolCount={12}
+        activeBackgroundTaskCount={9}
+        hasPendingPrompt={true}
+      />,
+    );
+    const frame = lastFrame()!;
+    const firstLine = frame.split('\n')[1] ?? '';
+    const activityEnd = firstLine.indexOf('test-model');
+    const activitySegment = firstLine.slice(0, activityEnd);
+    expect(activitySegment).toContain('Tools x12');
+    expect(activitySegment.length).toBeLessThanOrEqual(40);
+  });
+
+  it('renders git branch when provided', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} gitBranch="feat/status-line" />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('feat/status-line');
+  });
+
+  it('does not render git branch when visibility is disabled', () => {
+    const { lastFrame } = render(
+      <StatusBar {...baseProps} gitBranch="feat/status-line" showGitBranch={false} />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).not.toContain('feat/status-line');
+  });
+});

package/src/tui/__tests__/streaming-indicator.test.tsx

@@ -0,0 +1,137 @@
+import React from 'react';
+import { describe, it, expect } from 'vitest';
+import { render } from 'ink-testing-library';
+import StreamingIndicator from '../StreamingIndicator.js';
+
+describe('StreamingIndicator', () => {
+  it('renders empty when no tools and no text', () => {
+    const { lastFrame } = render(<StreamingIndicator text="" activeTools={[]} />);
+    expect(lastFrame()).not.toContain('Thinking');
+  });
+
+  it('shows a generic thinking state when foreground work has no text or tools yet', () => {
+    const { lastFrame } = render(<StreamingIndicator text="" activeTools={[]} isThinking={true} />);
+
+    expect(lastFrame()).toContain('Thinking...');
+  });
+
+  it('shows Tools: section with running tool', () => {
+    const { lastFrame } = render(
+      <StreamingIndicator
+        text=""
+        activeTools={[{ toolName: 'Bash', firstArg: 'ls -la', isRunning: true }]}
+      />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).toContain('Tools:');
+    expect(frame).toContain('Bash(ls -la)');
+  });
+
+  it('shows ⟳ for running and ✓ for completed tools', () => {
+    const { lastFrame } = render(
+      <StreamingIndicator
+        text=""
+        activeTools={[
+          { toolName: 'Read', firstArg: '/src/index.ts', isRunning: false },
+          { toolName: 'Bash', firstArg: 'ls', isRunning: true },
+        ]}
+      />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).toContain('✓ Read(/src/index.ts)');
+    expect(frame).toContain('⟳ Bash(ls)');
+  });
+
+  it('shows Robota: section with streaming text', () => {
+    const { lastFrame } = render(<StreamingIndicator text="Hello world" activeTools={[]} />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('Robota:');
+    expect(frame).toContain('Hello world');
+    expect(frame).not.toContain('Tools:');
+  });
+
+  it('preserves CJK and emoji text in streaming output', () => {
+    const text = '긴 한국어 응답과 emoji 🎉 를 스트리밍합니다';
+    const { lastFrame } = render(<StreamingIndicator text={text} activeTools={[]} />);
+
+    expect(lastFrame()).toContain(text);
+  });
+
+  it('shows Tools: before Robota: when both present', () => {
+    const { lastFrame } = render(
+      <StreamingIndicator
+        text="Analyzing..."
+        activeTools={[{ toolName: 'Read', firstArg: 'file.ts', isRunning: false }]}
+      />,
+    );
+    const frame = lastFrame()!;
+    const toolsIndex = frame.indexOf('Tools:');
+    const robotaIndex = frame.indexOf('Robota:');
+    expect(toolsIndex).toBeGreaterThanOrEqual(0);
+    expect(robotaIndex).toBeGreaterThanOrEqual(0);
+    expect(toolsIndex).toBeLessThan(robotaIndex);
+  });
+
+  it('does not show Thinking... when tools are active', () => {
+    const { lastFrame } = render(
+      <StreamingIndicator
+        text=""
+        activeTools={[{ toolName: 'Glob', firstArg: '**/*.md', isRunning: true }]}
+      />,
+    );
+    expect(lastFrame()).not.toContain('Thinking...');
+  });
+
+  it('does not show Thinking... when text is present', () => {
+    const { lastFrame } = render(
+      <StreamingIndicator text="Some response" activeTools={[]} isThinking={true} />,
+    );
+    expect(lastFrame()).not.toContain('Thinking...');
+  });
+
+  it('shows multiple tools in order', () => {
+    const { lastFrame } = render(
+      <StreamingIndicator
+        text=""
+        activeTools={[
+          { toolName: 'Read', firstArg: 'a.ts', isRunning: false },
+          { toolName: 'Bash', firstArg: 'echo hi', isRunning: false },
+          { toolName: 'Glob', firstArg: '**/*.md', isRunning: true },
+        ]}
+      />,
+    );
+    const frame = lastFrame()!;
+    const readIdx = frame.indexOf('Read(a.ts)');
+    const bashIdx = frame.indexOf('Bash(echo hi)');
+    const globIdx = frame.indexOf('Glob(**/*.md)');
+    expect(readIdx).toBeLessThan(bashIdx);
+    expect(bashIdx).toBeLessThan(globIdx);
+  });
+
+  it('renders tool diffs through markdown diff body format', () => {
+    const { lastFrame } = render(
+      <StreamingIndicator
+        text=""
+        activeTools={[
+          {
+            toolName: 'Edit',
+            firstArg: '/src/index.ts',
+            isRunning: false,
+            result: 'success',
+            diffFile: '/src/index.ts',
+            diffLines: [
+              { type: 'remove', lineNumber: 1, text: 'const oldValue = true;' },
+              { type: 'add', lineNumber: 1, text: 'const newValue = true;' },
+            ],
+          },
+        ]}
+      />,
+    );
+
+    const frame = lastFrame() ?? '';
+    expect(frame).toContain('/src/index.ts');
+    expect(frame).toContain('- 1 | const oldValue = true;');
+    expect(frame).toContain('+ 1 | const newValue = true;');
+    expect(frame).not.toContain('│ 1 - const oldValue = true;');
+  });
+});