@robota-sdk/agent-transport 3.0.0-beta.74 → 3.0.0-beta.76

package/src/tui/hooks/usePluginScreenData.ts

@@ -1,85 +0,0 @@
-/**
- * Hook: fetch data for PluginTUI screens.
- * Extracted from PluginTUI.tsx for single-responsibility.
- */
-
-import { useState, useEffect } from 'react';
-
-import type { IMenuSelectItem } from '../MenuSelect.js';
-import type { ICommandPluginAdapter } from '@robota-sdk/agent-interface-transport';
-
-export function usePluginScreenData(
-  screen: string,
-  marketplace: string | undefined,
-  callbacks: ICommandPluginAdapter,
-  refreshCounter: number,
-  stackLength: number,
-): { items: IMenuSelectItem[]; loading: boolean; error: string | undefined } {
-  const [items, setItems] = useState<IMenuSelectItem[]>([]);
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState<string | undefined>();
-
-  useEffect(() => {
-    setItems([]);
-    setError(undefined);
-
-    if (screen === 'marketplace-list') {
-      setLoading(true);
-      callbacks
-        .marketplaceList()
-        .then((sources) => {
-          const baseItems: IMenuSelectItem[] = [{ label: 'Add Marketplace', value: '__add__' }];
-          const sourceItems: IMenuSelectItem[] = sources.map((s) => ({
-            label: s.name,
-            value: s.name,
-            hint: s.type,
-          }));
-          setItems([...baseItems, ...sourceItems]);
-          setLoading(false);
-        })
-        .catch((err) => {
-          setError(err instanceof Error ? err.message : String(err));
-          setLoading(false);
-        });
-    } else if (screen === 'marketplace-browse') {
-      const mp = marketplace ?? '';
-      setLoading(true);
-      callbacks
-        .listAvailablePlugins(mp)
-        .then((plugins) => {
-          setItems(
-            plugins.map((p) => ({
-              label: p.name,
-              value: p.name,
-              hint: p.installed ? 'installed' : p.description,
-            })),
-          );
-          setLoading(false);
-        })
-        .catch((err) => {
-          setError(err instanceof Error ? err.message : String(err));
-          setLoading(false);
-        });
-    } else if (screen === 'installed-list') {
-      setLoading(true);
-      callbacks
-        .listInstalled()
-        .then((plugins) => {
-          setItems(
-            plugins.map((p) => ({
-              label: p.name,
-              value: p.name,
-              hint: p.description,
-            })),
-          );
-          setLoading(false);
-        })
-        .catch((err) => {
-          setError(err instanceof Error ? err.message : String(err));
-          setLoading(false);
-        });
-    }
-  }, [stackLength, screen, marketplace, callbacks, refreshCounter]);
-
-  return { items, loading, error };
-}

package/src/tui/hooks/useSideEffects.ts

@@ -1,175 +0,0 @@
-import { createSystemMessage, messageToHistoryEntry } from '@robota-sdk/agent-core';
-import { useApp } from 'ink';
-import { useState, useRef, useCallback } from 'react';
-
-import { applyCommandEffects } from './command-effect-handler.js';
-import { useTuiCliAdapter } from '../tui-cli-adapter-context.js';
-
-import type { IUseSideEffectsOptions, IUseSideEffectsResult } from './side-effects-types.js';
-import type { TInteractivePrompt } from './side-effects-types.js';
-import type { TSessionEndReason } from '@robota-sdk/agent-core';
-import type { ICommandInteraction, ICommandResult } from '@robota-sdk/agent-interface-transport';
-
-const EXIT_DELAY_MS = 500;
-
-export function useSideEffects({
-  cwd,
-  providerOverride,
-  interactiveSession,
-  commandEffectQueue,
-  addEntry,
-  baseHandleSubmit,
-  setSessionName,
-  setStatusLineSettings,
-  showSessionPickerOnStart,
-  openAgentSwitcher,
-}: IUseSideEffectsOptions): IUseSideEffectsResult {
-  const { exit } = useApp();
-  const cliAdapter = useTuiCliAdapter();
-  const [pendingInteractionPrompt, setPendingInteractionPrompt] =
-    useState<TInteractivePrompt | null>(null);
-  const commandInteractionRef = useRef<ICommandInteraction | null>(null);
-  const [showPluginTUI, setShowPluginTUI] = useState(false);
-  const [showSessionPicker, setShowSessionPicker] = useState(showSessionPickerOnStart ?? false);
-  const [showTransportTUI, setShowTransportTUI] = useState(false);
-
-  const requestShutdown = useCallback(
-    (reason: TSessionEndReason, message: string): void => {
-      addEntry(messageToHistoryEntry(createSystemMessage('Shutting down...')));
-      setTimeout(() => {
-        void interactiveSession.shutdown({ reason, message }).finally(() => exit());
-      }, EXIT_DELAY_MS);
-    },
-    [interactiveSession, addEntry, exit],
-  );
-
-  const applyEffects = useCallback(
-    (effects: Parameters<typeof applyCommandEffects>[0]): boolean =>
-      applyCommandEffects(effects, {
-        addEntry,
-        requestShutdown,
-        openPluginTUI: () => setShowPluginTUI(true),
-        openSessionPicker: () => setShowSessionPicker(true),
-        openTransportTUI: () => setShowTransportTUI(true),
-        openAgentSwitcher: () => openAgentSwitcher?.(),
-        renameSession: (name) => {
-          interactiveSession.setName(name);
-          setSessionName(name);
-        },
-        applyStatusLinePatch: (patch) => {
-          setStatusLineSettings(
-            cliAdapter.applyStatusLineSettings(cliAdapter.getUserSettingsPath(), patch),
-          );
-          return true;
-        },
-        cliAdapter,
-      }),
-    [
-      addEntry,
-      cliAdapter,
-      interactiveSession,
-      requestShutdown,
-      setSessionName,
-      setStatusLineSettings,
-    ],
-  );
-
-  const applyCommandResult = useCallback(
-    (result: ICommandResult): void => {
-      if (result.message.length > 0) {
-        addEntry(messageToHistoryEntry(createSystemMessage(result.message)));
-      }
-      if (result.interaction !== undefined) {
-        commandInteractionRef.current = result.interaction;
-        setPendingInteractionPrompt(result.interaction.prompt);
-        return;
-      }
-      commandInteractionRef.current = null;
-      setPendingInteractionPrompt(null);
-      if (result.effects !== undefined && result.effects.length > 0) {
-        applyEffects(result.effects);
-      }
-    },
-    [addEntry, applyEffects],
-  );
-
-  const applyQueuedCommandState = useCallback((): boolean => {
-    const queued = commandEffectQueue.drain();
-    if (queued === undefined) {
-      return false;
-    }
-    if (queued.type === 'interaction') {
-      const { interaction } = queued;
-      commandInteractionRef.current = interaction;
-      setPendingInteractionPrompt(interaction.prompt);
-      return true;
-    }
-    return applyEffects(queued.effects);
-  }, [applyEffects, commandEffectQueue]);
-
-  const handleSubmit = useCallback(
-    async (input: string): Promise<void> => {
-      await baseHandleSubmit(input);
-      applyQueuedCommandState();
-    },
-    [baseHandleSubmit, applyQueuedCommandState],
-  );
-
-  const handleInteractionSubmit = useCallback(
-    async (value: string): Promise<void> => {
-      const interaction = commandInteractionRef.current;
-      if (interaction === null) {
-        setPendingInteractionPrompt(null);
-        return;
-      }
-      try {
-        // allow-fallback: user-facing error display for plugin interaction submit
-        const result = await interaction.submit(value);
-        applyCommandResult(result);
-      } catch (err) {
-        // allow-fallback: user-facing error display for plugin interaction submit
-        commandInteractionRef.current = null;
-        setPendingInteractionPrompt(null);
-        addEntry(
-          messageToHistoryEntry(
-            createSystemMessage(`Failed: ${err instanceof Error ? err.message : String(err)}`),
-          ),
-        );
-      }
-    },
-    [addEntry, applyCommandResult],
-  );
-
-  const handleInteractionCancel = useCallback(() => {
-    const interaction = commandInteractionRef.current;
-    commandInteractionRef.current = null;
-    setPendingInteractionPrompt(null);
-    if (interaction?.cancel === undefined) {
-      addEntry(messageToHistoryEntry(createSystemMessage('Command interaction cancelled.')));
-      return;
-    }
-    Promise.resolve(interaction.cancel())
-      .then((result) => applyCommandResult(result))
-      .catch((err) => {
-        // allow-fallback: user-facing error display for interaction cancel
-        addEntry(
-          messageToHistoryEntry(
-            createSystemMessage(`Failed: ${err instanceof Error ? err.message : String(err)}`),
-          ),
-        );
-      });
-  }, [addEntry, applyCommandResult]);
-
-  return {
-    handleSubmit,
-    pendingInteractionPrompt,
-    showPluginTUI,
-    showSessionPicker,
-    showTransportTUI,
-    setShowPluginTUI,
-    setShowSessionPicker,
-    setShowTransportTUI,
-    handleInteractionSubmit,
-    handleInteractionCancel,
-  };
-}

package/src/tui/hooks/useSlashRouting.ts

@@ -1,118 +0,0 @@
-/**
- * Slash command routing logic for the TUI.
- * Extracted for single-responsibility.
- */
-
-import { createSystemMessage, messageToHistoryEntry } from '@robota-sdk/agent-core';
-import { useCallback } from 'react';
-
-import type { TuiStateManager } from '../tui-state-manager.js';
-import type { ICommandEffectQueue } from './command-effect-queue.js';
-import type { CommandRegistry } from '@robota-sdk/agent-framework';
-import type {
-  ICommandResult,
-  IInteractiveSession,
-  TCommandEffect,
-} from '@robota-sdk/agent-interface-transport';
-
-export function useSlashRouting(
-  interactiveSession: IInteractiveSession,
-  registry: CommandRegistry,
-  manager: TuiStateManager,
-  commandEffectQueue: ICommandEffectQueue,
-  reloadPluginCommandSource?: (registry: CommandRegistry) => void,
-): (input: string) => Promise<void> {
-  return useCallback(
-    async (input: string) => {
-      if (!input.startsWith('/')) {
-        await interactiveSession.submit(input);
-        manager.setPendingPrompt(interactiveSession.getPendingPrompt());
-        return;
-      }
-
-      const parts = input.slice(1).split(/\s+/);
-      const cmd = parts[0]?.toLowerCase() ?? '';
-      const args = parts.slice(1).join(' ');
-
-      // Try system command first
-      const result = await interactiveSession.executeCommand(cmd, args);
-      if (result) {
-        if (result.effects?.some((effect) => effect.type === 'session-execution-started')) {
-          manager.setPendingPrompt(interactiveSession.getPendingPrompt());
-          return;
-        }
-        applySystemCommandResult(
-          result,
-          interactiveSession,
-          registry,
-          manager,
-          commandEffectQueue,
-          reloadPluginCommandSource,
-        );
-        return;
-      }
-
-      manager.addEntry(
-        messageToHistoryEntry(
-          createSystemMessage(`Unknown command "/${cmd}". Type /help for help.`),
-        ),
-      );
-    },
-    [interactiveSession, registry, manager, commandEffectQueue, reloadPluginCommandSource],
-  );
-}
-
-export function applySystemCommandResult(
-  result: ICommandResult,
-  interactiveSession: IInteractiveSession,
-  registry: CommandRegistry,
-  manager: TuiStateManager,
-  commandEffectQueue: ICommandEffectQueue,
-  reloadPluginCommandSource?: (registry: CommandRegistry) => void,
-): void {
-  const pendingEffects = applyImmediateCommandEffects(
-    result.effects,
-    registry,
-    manager,
-    reloadPluginCommandSource,
-  );
-  manager.addEntry(messageToHistoryEntry(createSystemMessage(result.message)));
-
-  if (result.interaction !== undefined) {
-    commandEffectQueue.enqueueInteraction(result.interaction);
-  }
-  if (pendingEffects.length > 0) {
-    commandEffectQueue.enqueueEffects(pendingEffects);
-  }
-
-  if (interactiveSession.isInitialized) {
-    const ctx = interactiveSession.getContextState();
-    manager.setContextState({
-      percentage: ctx.usedPercentage,
-      usedTokens: ctx.usedTokens,
-      maxTokens: ctx.maxTokens,
-    });
-  }
-}
-
-function applyImmediateCommandEffects(
-  effects: readonly TCommandEffect[] | undefined,
-  registry: CommandRegistry,
-  manager: TuiStateManager,
-  reloadPluginCommandSource?: (registry: CommandRegistry) => void,
-): TCommandEffect[] {
-  if (effects === undefined || effects.length === 0) return [];
-  const pendingEffects: TCommandEffect[] = [];
-  for (const effect of effects) {
-    if (effect.type === 'conversation-history-cleared') {
-      manager.clearHistory();
-      continue;
-    }
-    if (effect.type === 'plugin-registry-reload-requested') {
-      reloadPluginCommandSource?.(registry);
-      continue;
-    }
-    pendingEffects.push(effect);
-  }
-  return pendingEffects;
-}

package/src/tui/hooks/useStatusLineSettings.ts

@@ -1,37 +0,0 @@
-import { DEFAULT_STATUS_LINE_COMMAND_SETTINGS } from '@robota-sdk/agent-framework';
-import { useState } from 'react';
-
-import { useTuiCliAdapter } from '../tui-cli-adapter-context.js';
-
-import type { TUniversalValue } from '@robota-sdk/agent-core';
-import type { IStatusLineCommandSettings } from '@robota-sdk/agent-interface-transport';
-
-function readStatusLineSettings(
-  settings: Record<string, TUniversalValue>,
-): IStatusLineCommandSettings {
-  const defaults = { ...DEFAULT_STATUS_LINE_COMMAND_SETTINGS };
-  const raw = settings.statusline;
-  if (!isRecord(raw)) {
-    return defaults;
-  }
-  return {
-    enabled: typeof raw.enabled === 'boolean' ? raw.enabled : defaults.enabled,
-    gitBranch: typeof raw.gitBranch === 'boolean' ? raw.gitBranch : defaults.gitBranch,
-  };
-}
-
-function isRecord(value: TUniversalValue): value is Record<string, TUniversalValue> {
-  return (
-    value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)
-  );
-}
-
-export function useStatusLineSettings(): [
-  IStatusLineCommandSettings,
-  (settings: IStatusLineCommandSettings) => void,
-] {
-  const cliAdapter = useTuiCliAdapter();
-  return useState<IStatusLineCommandSettings>(() =>
-    readStatusLineSettings(cliAdapter.readSettings(cliAdapter.getUserSettingsPath())),
-  );
-}

package/src/tui/hooks/useTuiChannel.ts

@@ -1,95 +0,0 @@
-/**
- * useTuiChannel — React hook that subscribes to TuiInteractionChannel state changes.
- *
- * Returns the same shape as the former IInteractiveSessionState so that App.tsx
- * changes are minimal.
- */
-
-import { useState, useEffect } from 'react';
-
-import type { TuiInteractionChannel } from '../TuiInteractionChannel.js';
-import type { ICommandEffectQueue } from './command-effect-queue.js';
-import type { IPermissionRequest } from '../types.js';
-import type { IHistoryEntry, TSessionEndReason } from '@robota-sdk/agent-core';
-import type { InteractiveSession, CommandRegistry } from '@robota-sdk/agent-framework';
-import type {
-  IExecutionDetailPage,
-  IExecutionWorkspaceSnapshot,
-  IToolState,
-} from '@robota-sdk/agent-interface-transport';
-
-export interface IInteractiveSessionState {
-  interactiveSession: InteractiveSession;
-  registry: CommandRegistry;
-  commandEffectQueue: ICommandEffectQueue;
-  history: IHistoryEntry[];
-  addEntry: (entry: IHistoryEntry) => void;
-  streamingText: string;
-  activeTools: IToolState[];
-  isThinking: boolean;
-  isAborting: boolean;
-  isShuttingDown: boolean;
-  pendingPrompt: string | null;
-  executionWorkspaceSnapshot: IExecutionWorkspaceSnapshot | null;
-  selectedExecutionEntryId?: string;
-  permissionRequest: IPermissionRequest | null;
-  contextState: { percentage: number; usedTokens: number; maxTokens: number };
-  handleSubmit: (input: string) => Promise<void>;
-  handleAbort: () => void;
-  handleCancelQueue: () => void;
-  handleShutdown: (reason?: TSessionEndReason) => Promise<void>;
-  selectExecutionWorkspaceEntry: (entryId: string) => void;
-  readExecutionWorkspaceDetail: (entryId: string) => Promise<IExecutionDetailPage>;
-}
-
-interface IHistoryReadableSession {
-  getFullHistory(): IHistoryEntry[];
-}
-
-interface IHistorySyncManager {
-  syncHistory(entries: IHistoryEntry[]): void;
-}
-
-export function applyCompactEventToManager(
-  interactiveSession: IHistoryReadableSession,
-  manager: IHistorySyncManager,
-): void {
-  manager.syncHistory(interactiveSession.getFullHistory());
-}
-
-export function useTuiChannel(channel: TuiInteractionChannel): IInteractiveSessionState {
-  const [, forceRender] = useState(0);
-
-  useEffect(() => {
-    channel.onChange = () => forceRender((n) => n + 1);
-    return () => {
-      channel.onChange = null;
-    };
-  }, [channel]);
-
-  const manager = channel.stateManager;
-
-  return {
-    interactiveSession: channel.getSession(),
-    registry: channel.getRegistry(),
-    commandEffectQueue: channel.getCommandEffectQueue(),
-    history: manager.history,
-    addEntry: (e) => manager.addEntry(e),
-    streamingText: manager.streamingText,
-    activeTools: manager.activeTools,
-    isThinking: manager.isThinking,
-    isAborting: manager.isAborting,
-    isShuttingDown: channel.isShuttingDown,
-    pendingPrompt: manager.pendingPrompt,
-    executionWorkspaceSnapshot: manager.executionWorkspaceSnapshot,
-    selectedExecutionEntryId: manager.selectedExecutionEntryId,
-    permissionRequest: channel.permissionRequest,
-    contextState: manager.contextState,
-    handleSubmit: (input) => channel.handleInput(input),
-    handleAbort: () => channel.abort(),
-    handleCancelQueue: () => channel.cancelQueue(),
-    handleShutdown: (reason) => channel.shutdown({ reason }),
-    selectExecutionWorkspaceEntry: (id) => channel.selectExecutionWorkspaceEntry(id),
-    readExecutionWorkspaceDetail: (id) => channel.readExecutionWorkspaceDetail(id),
-  };
-}

package/src/tui/index.ts

@@ -1,14 +0,0 @@
-export { TuiTransport } from './tui-transport.js';
-export { renderApp } from './render.js';
-export type { IRenderOptions } from './render.js';
-export type { ITuiCliAdapter } from './tui-cli-adapter.js';
-export type { IDefaultTuiCliAdapterOptions } from './create-default-tui-cli-adapter.js';
-export { createDefaultTuiCliAdapter } from './create-default-tui-cli-adapter.js';
-export type {
-  TOnMissingArgsAction,
-  ITuiPickerItem,
-  ITuiCommandInteraction,
-  ITuiPickerInteraction,
-  ITuiConfirmInteraction,
-  TAnyTuiCommandInteraction,
-} from './command-interaction.js';

package/src/tui/interactions/CommandConfirm.tsx

@@ -1,36 +0,0 @@
-import { Box, Text, useInput } from 'ink';
-import React from 'react';
-
-import type { ITuiConfirmInteraction } from '../command-interaction.js';
-
-interface IProps {
-  commandName: string;
-  interaction: ITuiConfirmInteraction;
-  onConfirm: () => void;
-  onCancel: () => void;
-}
-
-export default function CommandConfirm({
-  commandName,
-  interaction,
-  onConfirm,
-  onCancel,
-}: IProps): React.ReactElement {
-  useInput((input, key) => {
-    if (key.return || input === 'y' || input === 'Y') {
-      onConfirm();
-    } else if (key.escape || input === 'n' || input === 'N') {
-      onCancel();
-    }
-  });
-
-  return (
-    <Box paddingX={1}>
-      <Text bold color="yellow">
-        /{commandName}:{' '}
-      </Text>
-      <Text>{interaction.message} </Text>
-      <Text dimColor>[y/n]</Text>
-    </Box>
-  );
-}

package/src/tui/interactions/CommandPicker.tsx

@@ -1,77 +0,0 @@
-import { Box, Text, useInput, useStdout } from 'ink';
-import React, { useState } from 'react';
-
-import type { ITuiPickerInteraction, ITuiPickerItem } from '../command-interaction.js';
-
-interface IProps {
-  commandName: string;
-  interaction: ITuiPickerInteraction;
-  onSelect: (item: ITuiPickerItem) => void;
-  onCancel: () => void;
-}
-
-const MAX_VISIBLE = 8;
-const OUTER_CHROME = 4;
-const MIN_ROW_WIDTH = 40;
-
-function useRowWidth(): number {
-  const { stdout } = useStdout();
-  return Math.max(MIN_ROW_WIDTH, (stdout.columns ?? 80) - OUTER_CHROME);
-}
-
-export default function CommandPicker({
-  commandName,
-  interaction,
-  onSelect,
-  onCancel,
-}: IProps): React.ReactElement {
-  const items = interaction.getItems();
-  const [selectedIndex, setSelectedIndex] = useState(0);
-  const rowWidth = useRowWidth();
-
-  useInput((input, key) => {
-    if (key.upArrow) {
-      setSelectedIndex((i) => (i > 0 ? i - 1 : items.length - 1));
-    } else if (key.downArrow) {
-      setSelectedIndex((i) => (i < items.length - 1 ? i + 1 : 0));
-    } else if (key.return) {
-      const item = items[selectedIndex];
-      if (item) onSelect(item);
-    } else if (key.escape || input === 'q') {
-      onCancel();
-    }
-  });
-
-  const scrollOffset = (() => {
-    if (items.length <= MAX_VISIBLE) return 0;
-    if (selectedIndex < MAX_VISIBLE) return 0;
-    return Math.min(selectedIndex - MAX_VISIBLE + 1, items.length - MAX_VISIBLE);
-  })();
-  const visibleItems = items.slice(scrollOffset, scrollOffset + MAX_VISIBLE);
-
-  return (
-    <Box flexDirection="column" borderStyle="round" borderColor="cyan" paddingX={1}>
-      <Text bold color="cyan">
-        /{commandName}
-      </Text>
-      {visibleItems.map((item, i) => {
-        const isSelected = scrollOffset + i === selectedIndex;
-        const indicator = isSelected ? '▸ ' : '  ';
-        return (
-          <Box key={item.value} width={rowWidth}>
-            <Text
-              color={isSelected ? 'cyan' : undefined}
-              dimColor={!isSelected}
-              wrap="truncate-end"
-            >
-              {indicator}
-              {item.label}
-              {item.description != null ? `  ${item.description}` : ''}
-            </Text>
-          </Box>
-        );
-      })}
-      <Text dimColor>↑↓ navigate · Enter select · Esc cancel</Text>
-    </Box>
-  );
-}