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

package/src/tui/execution-workspace-view-model.ts

@@ -0,0 +1,123 @@
+import type {
+  IExecutionDetailRecord,
+  IExecutionWorkspaceEntry,
+  IExecutionWorkspaceSnapshot,
+  TExecutionWorkspaceStatus,
+} from '@robota-sdk/agent-framework';
+
+const ACTIVE_STATUSES: readonly TExecutionWorkspaceStatus[] = [
+  'active',
+  'queued',
+  'running',
+  'waiting_permission',
+  'sleeping',
+];
+const DETAIL_RECORD_TEXT_LIMIT = 160;
+const PREVIEW_WHITESPACE = /\s+/g;
+const PREVIEW_SEPARATOR = ' ';
+
+export interface IExecutionWorkspaceEntryRow {
+  id: string;
+  radio: '●' | '○';
+  title: string;
+  subtitle?: string;
+  statusLabel: string;
+  preview?: string;
+  color: string;
+  isSelected: boolean;
+  accessibleText: string;
+}
+
+export interface IExecutionWorkspaceEntryRowOptions {
+  selectedEntryId?: string;
+}
+
+export function getDefaultBackgroundWorkspaceEntries(
+  snapshot: IExecutionWorkspaceSnapshot | null,
+): IExecutionWorkspaceEntry[] {
+  return (snapshot?.entries ?? []).filter(
+    (entry) => entry.kind === 'background_task' && entry.visibility === 'default',
+  );
+}
+
+export function countActiveBackgroundWorkspaceEntries(
+  snapshot: IExecutionWorkspaceSnapshot | null,
+): number {
+  return getDefaultBackgroundWorkspaceEntries(snapshot).filter((entry) =>
+    ACTIVE_STATUSES.includes(entry.status),
+  ).length;
+}
+
+export function formatExecutionWorkspaceEntryRow(
+  entry: IExecutionWorkspaceEntry,
+  options: IExecutionWorkspaceEntryRowOptions = {},
+): IExecutionWorkspaceEntryRow {
+  const isSelected = entry.id === options.selectedEntryId;
+  const row = {
+    id: entry.id,
+    radio: isSelected ? '●' : '○',
+    title: formatEntryTitle(entry),
+    subtitle: formatEntrySubtitle(entry),
+    statusLabel: formatStatusLabel(entry.status),
+    preview: trimPreview(entry.preview ?? entry.currentAction),
+    color: getEntryColor(entry),
+    isSelected,
+  } satisfies Omit<IExecutionWorkspaceEntryRow, 'accessibleText'>;
+  return { ...row, accessibleText: formatAccessibleText(row) };
+}
+
+export function formatExecutionDetailRecord(record: IExecutionDetailRecord): string {
+  const text = record.text.trim().replace(PREVIEW_WHITESPACE, PREVIEW_SEPARATOR);
+  if (!text) return record.kind;
+  return text.length > DETAIL_RECORD_TEXT_LIMIT
+    ? `${text.slice(0, DETAIL_RECORD_TEXT_LIMIT)}...`
+    : text;
+}
+
+function formatEntryTitle(entry: IExecutionWorkspaceEntry): string {
+  if (entry.kind === 'main_thread') return entry.title;
+  if (entry.kind === 'background_group') return `${entry.title} group`;
+  if (entry.taskKind === 'agent') return `${entry.title} agent`;
+  if (entry.taskKind === 'process') return entry.title || 'Process';
+  if (entry.taskKind === 'scheduled') return entry.title || 'Scheduled';
+  return entry.title;
+}
+
+function formatEntrySubtitle(entry: IExecutionWorkspaceEntry): string | undefined {
+  if (entry.kind === 'main_thread') return entry.subtitle;
+  const parts = [
+    entry.taskKind,
+    entry.subtitle,
+    entry.attention === 'none' ? undefined : entry.attention,
+  ];
+  return (
+    parts
+      .filter((part): part is string => typeof part === 'string' && part.length > 0)
+      .join(' · ') || undefined
+  );
+}
+
+function formatStatusLabel(status: TExecutionWorkspaceStatus): string {
+  return status.replace(/_/g, ' ');
+}
+
+function getEntryColor(entry: IExecutionWorkspaceEntry): string {
+  if (entry.attention === 'failed' || entry.status === 'failed') return 'red';
+  if (entry.attention === 'permission' || entry.status === 'waiting_permission') return 'yellow';
+  if (entry.status === 'completed') return 'green';
+  if (entry.status === 'cancelled') return 'yellow';
+  if (ACTIVE_STATUSES.includes(entry.status)) return 'cyan';
+  return 'white';
+}
+
+function trimPreview(value: string | undefined): string | undefined {
+  const preview = value?.trim().replace(PREVIEW_WHITESPACE, PREVIEW_SEPARATOR);
+  return preview || undefined;
+}
+
+function formatAccessibleText(row: Omit<IExecutionWorkspaceEntryRow, 'accessibleText'>): string {
+  const parts = [row.radio, row.title, row.statusLabel, row.subtitle, row.preview];
+  return parts
+    .filter((part): part is string => typeof part === 'string' && part.length > 0)
+    .join(' · ');
+}

package/src/tui/flows/cjk-text-input-flow.ts

@@ -0,0 +1,285 @@
+import stringWidth from 'string-width';
+
+const PASTE_START = '[200~';
+const PASTE_END = '[201~';
+const LAST_ASCII_CONTROL_CODE = 0x1f;
+const DELETE_CONTROL_CODE = 0x7f;
+
+export interface ICjkTextInputFlowState {
+  value: string;
+  cursor: number;
+  isPasting: boolean;
+  pasteBuffer: string;
+}
+
+export interface ICjkTextInputKey {
+  ctrl?: boolean;
+  tab?: boolean;
+  shift?: boolean;
+  upArrow?: boolean;
+  downArrow?: boolean;
+  return?: boolean;
+  leftArrow?: boolean;
+  rightArrow?: boolean;
+  backspace?: boolean;
+  delete?: boolean;
+}
+
+export interface ICjkTextInputFlowOptions {
+  availableWidth?: number;
+  canPaste: boolean;
+  enableVerticalNavigation?: boolean;
+}
+
+export type TCjkTextInputEffect =
+  | { type: 'none' }
+  | { type: 'change'; value: string }
+  | { type: 'submit'; value: string }
+  | { type: 'paste'; text: string; cursor: number }
+  | { type: 'render' };
+
+interface ICjkTextInputFlowResult {
+  state: ICjkTextInputFlowState;
+  effect: TCjkTextInputEffect;
+}
+
+export function createCjkTextInputFlowState(value: string): ICjkTextInputFlowState {
+  return { value, cursor: value.length, isPasting: false, pasteBuffer: '' };
+}
+
+export function syncCjkTextInputFlowState(
+  state: ICjkTextInputFlowState,
+  value: string,
+  cursorHint: number | null,
+): ICjkTextInputFlowState {
+  if (value === state.value) {
+    return state;
+  }
+  return {
+    ...state,
+    value,
+    cursor: cursorHint != null ? Math.min(cursorHint, value.length) : value.length,
+  };
+}
+
+export function applyCjkTextInput(
+  state: ICjkTextInputFlowState,
+  input: string,
+  key: ICjkTextInputKey,
+  options: ICjkTextInputFlowOptions,
+): ICjkTextInputFlowResult {
+  const pasteResult = applyPasteBoundaryInput(state, input, options);
+  if (pasteResult !== undefined) return pasteResult;
+  const controlResult = applyControlInput(state, input, key, options);
+  if (controlResult !== undefined) return controlResult;
+  const cursorResult = applyCursorInput(state, key, options);
+  if (cursorResult !== undefined) return cursorResult;
+  return insertPrintableInput(state, input);
+}
+
+export function applyCjkTextPaste(
+  state: ICjkTextInputFlowState,
+  text: string,
+  options: ICjkTextInputFlowOptions,
+): ICjkTextInputFlowResult {
+  const normalizedText = text.replace(/\r\n?/g, '\n');
+  if (normalizedText.length === 0) {
+    return { state, effect: { type: 'none' } };
+  }
+  if (normalizedText.includes('\n') && options.canPaste) {
+    return { state, effect: { type: 'paste', text: normalizedText, cursor: state.cursor } };
+  }
+  return insertPrintableInput(state, normalizedText);
+}
+
+function applyPasteBoundaryInput(
+  state: ICjkTextInputFlowState,
+  input: string,
+  options: ICjkTextInputFlowOptions,
+): ICjkTextInputFlowResult | undefined {
+  if (input === PASTE_START || input.startsWith(PASTE_START)) {
+    return startBracketedPaste(state, input);
+  }
+  if (state.isPasting) {
+    return continueBracketedPaste(state, input, options);
+  }
+  return undefined;
+}
+
+function applyControlInput(
+  state: ICjkTextInputFlowState,
+  input: string,
+  key: ICjkTextInputKey,
+  options: ICjkTextInputFlowOptions,
+): ICjkTextInputFlowResult | undefined {
+  if ((key.ctrl === true && input === 'c') || key.tab === true) {
+    return { state, effect: { type: 'none' } };
+  }
+  if (key.return === true) {
+    return { state, effect: { type: 'submit', value: state.value } };
+  }
+  if (input.length > 1 && (input.includes('\n') || input.includes('\r')) && options.canPaste) {
+    return {
+      state,
+      effect: { type: 'paste', text: input.replace(/\r\n?/g, '\n'), cursor: state.cursor },
+    };
+  }
+  return undefined;
+}
+
+function applyCursorInput(
+  state: ICjkTextInputFlowState,
+  key: ICjkTextInputKey,
+  options: ICjkTextInputFlowOptions,
+): ICjkTextInputFlowResult | undefined {
+  if (key.upArrow === true || key.downArrow === true) {
+    if (options.enableVerticalNavigation === false) {
+      return { state, effect: { type: 'none' } };
+    }
+    return moveCursorVertically(
+      state,
+      key.upArrow === true ? 'up' : 'down',
+      options.availableWidth,
+    );
+  }
+  if (key.leftArrow === true) {
+    return moveCursorHorizontally(state, 'left');
+  }
+  if (key.rightArrow === true) {
+    return moveCursorHorizontally(state, 'right');
+  }
+  if (key.backspace === true || key.delete === true) {
+    return deleteBeforeCursor(state);
+  }
+  return undefined;
+}
+
+export function filterPrintable(input: string | null | undefined): string {
+  if (!input || input.length === 0) return '';
+  let output = '';
+  for (const char of input) {
+    const code = char.charCodeAt(0);
+    if (code > LAST_ASCII_CONTROL_CODE && code !== DELETE_CONTROL_CODE) {
+      output += char;
+    }
+  }
+  return output;
+}
+
+export function insertAtCursor(
+  value: string,
+  cursor: number,
+  input: string,
+): { value: string; cursor: number } {
+  const next = value.slice(0, cursor) + input + value.slice(cursor);
+  return { value: next, cursor: cursor + input.length };
+}
+
+export function displayOffset(chars: string[], charIndex: number, width: number): number {
+  let offset = 0;
+  for (let i = 0; i < charIndex && i < chars.length; i++) {
+    const w = stringWidth(chars[i]!);
+    const col = offset % width;
+    if (col + w > width) offset += width - col;
+    offset += w;
+  }
+  return offset;
+}
+
+export function charIndexAtDisplayOffset(chars: string[], target: number, width: number): number {
+  let offset = 0;
+  for (let i = 0; i < chars.length; i++) {
+    if (offset >= target) return i;
+    const w = stringWidth(chars[i]!);
+    const col = offset % width;
+    if (col + w > width) offset += width - col;
+    offset += w;
+  }
+  return chars.length;
+}
+
+function startBracketedPaste(
+  state: ICjkTextInputFlowState,
+  input: string,
+): ICjkTextInputFlowResult {
+  return {
+    state: { ...state, isPasting: true, pasteBuffer: input.slice(PASTE_START.length) },
+    effect: { type: 'none' },
+  };
+}
+
+function continueBracketedPaste(
+  state: ICjkTextInputFlowState,
+  input: string,
+  options: ICjkTextInputFlowOptions,
+): ICjkTextInputFlowResult {
+  if (input !== PASTE_END && !input.includes(PASTE_END)) {
+    return {
+      state: { ...state, pasteBuffer: state.pasteBuffer + input },
+      effect: { type: 'none' },
+    };
+  }
+  const beforeMarker = input.split(PASTE_END)[0] ?? '';
+  const nextState = { ...state, isPasting: false, pasteBuffer: '' };
+  return applyCjkTextPaste(nextState, state.pasteBuffer + beforeMarker, options);
+}
+
+function moveCursorVertically(
+  state: ICjkTextInputFlowState,
+  direction: 'up' | 'down',
+  availableWidth: number | undefined,
+): ICjkTextInputFlowResult {
+  if (!availableWidth || availableWidth <= 0) {
+    return { state, effect: { type: 'none' } };
+  }
+  const chars = [...state.value];
+  const offset = displayOffset(chars, state.cursor, availableWidth);
+  const target = direction === 'up' ? offset - availableWidth : offset + availableWidth;
+  if (target < 0) {
+    return { state, effect: { type: 'none' } };
+  }
+  const cursor = charIndexAtDisplayOffset(chars, target, availableWidth);
+  if (cursor === state.cursor) {
+    return { state, effect: { type: 'none' } };
+  }
+  return { state: { ...state, cursor }, effect: { type: 'render' } };
+}
+
+function moveCursorHorizontally(
+  state: ICjkTextInputFlowState,
+  direction: 'left' | 'right',
+): ICjkTextInputFlowResult {
+  if (direction === 'left' && state.cursor > 0) {
+    return { state: { ...state, cursor: state.cursor - 1 }, effect: { type: 'render' } };
+  }
+  if (direction === 'right' && state.cursor < state.value.length) {
+    return { state: { ...state, cursor: state.cursor + 1 }, effect: { type: 'render' } };
+  }
+  return { state, effect: { type: 'none' } };
+}
+
+function deleteBeforeCursor(state: ICjkTextInputFlowState): ICjkTextInputFlowResult {
+  if (state.cursor === 0) {
+    return { state, effect: { type: 'none' } };
+  }
+  const value = state.value.slice(0, state.cursor - 1) + state.value.slice(state.cursor);
+  return {
+    state: { ...state, value, cursor: state.cursor - 1 },
+    effect: { type: 'change', value },
+  };
+}
+
+function insertPrintableInput(
+  state: ICjkTextInputFlowState,
+  input: string,
+): ICjkTextInputFlowResult {
+  const printable = filterPrintable(input);
+  if (printable.length === 0) {
+    return { state, effect: { type: 'none' } };
+  }
+  const result = insertAtCursor(state.value, state.cursor, printable);
+  return {
+    state: { ...state, value: result.value, cursor: result.cursor },
+    effect: { type: 'change', value: result.value },
+  };
+}

package/src/tui/flows/confirm-prompt-flow.ts

@@ -0,0 +1,45 @@
+import {
+  applySelectionInput,
+  getDirectionalSelectionInputAction,
+  type ISelectionFlowState,
+  type ISelectionInputKey,
+  type TSelectionEffect,
+  type TSelectionInputAction,
+} from './selection-flow.js';
+
+export type TConfirmPromptInputAction = TSelectionInputAction | { type: 'shortcut'; index: number };
+
+export function getConfirmPromptInputAction(
+  input: string,
+  key: ISelectionInputKey,
+  optionCount: number,
+): TConfirmPromptInputAction | undefined {
+  const action = getDirectionalSelectionInputAction({ ...key, escape: false });
+  if (action !== undefined) {
+    return action;
+  }
+  if (optionCount === 2 && input === 'y') {
+    return { type: 'shortcut', index: 0 };
+  }
+  if (optionCount === 2 && input === 'n') {
+    return { type: 'shortcut', index: 1 };
+  }
+  return undefined;
+}
+
+export function applyConfirmPromptInput(
+  state: ISelectionFlowState,
+  action: TConfirmPromptInputAction,
+  optionCount: number,
+): { state: ISelectionFlowState; effect: TSelectionEffect } {
+  if (state.resolved) {
+    return { state, effect: { type: 'none' } };
+  }
+  if (typeof action !== 'string') {
+    return {
+      state: { ...state, selectedIndex: action.index, resolved: true },
+      effect: { type: 'select', index: action.index },
+    };
+  }
+  return applySelectionInput(state, action, { itemCount: optionCount });
+}

package/src/tui/flows/input-area-flow.ts

@@ -0,0 +1,186 @@
+import type { IHistoryEntry, TUniversalValue } from '@robota-sdk/agent-core';
+import type { ICommand } from '@robota-sdk/agent-framework';
+import { parseSlashInput } from '../hooks/useAutocomplete.js';
+
+export interface IAutocompleteInputKey {
+  upArrow?: boolean;
+  downArrow?: boolean;
+  escape?: boolean;
+  tab?: boolean;
+  backspace?: boolean;
+  delete?: boolean;
+}
+
+export type TAutocompletePopupAction = 'previous' | 'next' | 'close' | 'complete';
+export type TPendingPromptInputAction = 'cancelQueue';
+export type TPromptHistoryInputAction = 'previous' | 'next';
+
+export type TCommandSelectionResult =
+  | { type: 'insert'; value: string; selectedIndex?: number }
+  | { type: 'submit'; value: string };
+
+export interface IPasteLabelChange {
+  value: string;
+  cursorHint: number;
+  label: string;
+  lineCount: number;
+}
+
+export interface IPromptHistoryNavigationState {
+  selectedIndex: number | null;
+  draft: string;
+}
+
+export interface IPromptHistoryNavigationResult {
+  value: string;
+  cursorHint: number;
+  state: IPromptHistoryNavigationState;
+}
+
+export function getAutocompletePopupAction(
+  key: IAutocompleteInputKey,
+): TAutocompletePopupAction | undefined {
+  if (key.upArrow === true) return 'previous';
+  if (key.downArrow === true) return 'next';
+  if (key.escape === true) return 'close';
+  if (key.tab === true) return 'complete';
+  return undefined;
+}
+
+export function getPendingPromptInputAction(
+  key: IAutocompleteInputKey,
+): TPendingPromptInputAction | undefined {
+  if (key.backspace === true || key.delete === true) {
+    return 'cancelQueue';
+  }
+  return undefined;
+}
+
+export function getPromptHistoryInputAction(
+  key: IAutocompleteInputKey,
+): TPromptHistoryInputAction | undefined {
+  if (key.upArrow === true) return 'previous';
+  if (key.downArrow === true) return 'next';
+  return undefined;
+}
+
+export function createPromptHistoryNavigationState(): IPromptHistoryNavigationState {
+  return { selectedIndex: null, draft: '' };
+}
+
+export function navigatePromptHistory(
+  value: string,
+  history: readonly string[],
+  state: IPromptHistoryNavigationState,
+  action: TPromptHistoryInputAction,
+): IPromptHistoryNavigationResult {
+  if (history.length === 0) {
+    return { value, cursorHint: value.length, state };
+  }
+
+  if (action === 'previous') {
+    const selectedIndex =
+      state.selectedIndex === null ? history.length - 1 : Math.max(0, state.selectedIndex - 1);
+    const nextValue = history[selectedIndex] ?? value;
+    return {
+      value: nextValue,
+      cursorHint: nextValue.length,
+      state: { selectedIndex, draft: state.selectedIndex === null ? value : state.draft },
+    };
+  }
+
+  if (state.selectedIndex === null) {
+    return { value, cursorHint: value.length, state };
+  }
+
+  if (state.selectedIndex < history.length - 1) {
+    const selectedIndex = state.selectedIndex + 1;
+    const nextValue = history[selectedIndex] ?? value;
+    return {
+      value: nextValue,
+      cursorHint: nextValue.length,
+      state: { ...state, selectedIndex },
+    };
+  }
+
+  return {
+    value: state.draft,
+    cursorHint: state.draft.length,
+    state: createPromptHistoryNavigationState(),
+  };
+}
+
+export function appendPromptHistory(history: readonly string[], value: string): string[] {
+  const prompt = value.trim();
+  if (prompt.length === 0) return [...history];
+  if (history[history.length - 1] === prompt) return [...history];
+  return [...history, prompt];
+}
+
+export function extractPromptHistory(entries: readonly IHistoryEntry[]): string[] {
+  let prompts: string[] = [];
+  for (const entry of entries) {
+    if (entry.category !== 'chat' || entry.type !== 'user') continue;
+    const data = entry.data as Record<string, TUniversalValue> | undefined;
+    if (typeof data?.content !== 'string') continue;
+    prompts = appendPromptHistory(prompts, data.content);
+  }
+  return prompts;
+}
+
+export function moveAutocompleteSelection(
+  selectedIndex: number,
+  commandCount: number,
+  direction: 'previous' | 'next',
+): number {
+  if (commandCount === 0) return 0;
+  if (direction === 'previous') {
+    return selectedIndex > 0 ? selectedIndex - 1 : commandCount - 1;
+  }
+  return selectedIndex < commandCount - 1 ? selectedIndex + 1 : 0;
+}
+
+export function resolveTabCompletion(value: string, command: ICommand): TCommandSelectionResult {
+  const parsed = parseSlashInput(value);
+  if (parsed.parentCommand) {
+    return { type: 'insert', value: `/${parsed.parentCommand} ${command.name} ` };
+  }
+  if (command.subcommands && command.subcommands.length > 0) {
+    return { type: 'insert', value: `/${command.name} `, selectedIndex: 0 };
+  }
+  return { type: 'insert', value: `/${command.name} ` };
+}
+
+export function resolveEnterCommandSelection(
+  value: string,
+  command: ICommand,
+): TCommandSelectionResult {
+  const parsed = parseSlashInput(value);
+  if (parsed.parentCommand) {
+    return { type: 'submit', value: `/${parsed.parentCommand} ${command.name}` };
+  }
+  if (command.subcommands && command.subcommands.length > 0) {
+    return { type: 'insert', value: `/${command.name} `, selectedIndex: 0 };
+  }
+  return { type: 'submit', value: `/${command.name}` };
+}
+
+export function createPasteLabelChange(
+  value: string,
+  cursorPosition: number,
+  pasteId: number,
+  text: string,
+): IPasteLabelChange {
+  const lineCount = text.split('\n').length;
+  const label = `[Pasted text #${pasteId} +${lineCount} lines]`;
+  return {
+    value: value.slice(0, cursorPosition) + label + value.slice(cursorPosition),
+    cursorHint: cursorPosition + label.length,
+    label,
+    lineCount,
+  };
+}
+
+export function shouldSubmitInput(text: string): boolean {
+  return text.trim().length > 0;
+}