@robota-sdk/agent-command 3.0.0-beta.75 → 3.0.0-beta.77

package/src/goal/index.ts

@@ -0,0 +1,6 @@
+export {
+  createGoalCommandModule,
+  createGoalCommandEntry,
+  GoalCommandSource,
+} from './goal-command-module.js';
+export { executeGoalCommand, GOAL_COMMAND_DESCRIPTION } from './goal-command.js';

package/src/index.ts

@@ -1,8 +1,10 @@
 export * from './agent/index.js';
 export * from './default/index.js';
 export * from './background/index.js';
+export * from './goal/index.js';
 export * from './compact/index.js';
 export * from './context/index.js';
+export * from './editor/index.js';
 export * from './exit/index.js';
 export * from './help/index.js';
 export * from './language/index.js';
@@ -11,6 +13,7 @@ export * from './mode/index.js';
 export * from './permissions/index.js';
 export * from './plugin/index.js';
 export * from './preset/index.js';
+export * from './shell/index.js';
 export * from './provider/index.js';
 export * from './reset/index.js';
 export * from './rewind/index.js';

package/src/language/__tests__/language-command-module.test.ts

@@ -102,4 +102,20 @@ describe('createLanguageCommandModule', () => {
     expect(result?.success).toBe(false);
     expect(result?.message).toBe('Usage: language <code> (e.g., ko, en, ja, zh)');
   });
+
+  it('asks the user to pick a language when none is provided (CMD-004)', async () => {
+    const executor = new SystemCommandExecutor([
+      ...(createLanguageCommandModule().systemCommands ?? []),
+    ]);
+    const contextWithAsk: ICommandHostContext = {
+      ...commandHostContext,
+      getUserInteraction: () => ({ ask: async () => ({ type: 'answer', values: ['ko'] }) }),
+    };
+
+    const result = await executor.execute('language', contextWithAsk, '');
+
+    expect(result?.success).toBe(true);
+    expect(result?.data?.language).toBe('ko');
+    expect(result?.effects).toEqual([{ type: 'language-change-requested', language: 'ko' }]);
+  });
 });

package/src/language/language-command-module.ts

@@ -7,11 +7,7 @@ import {
 import { executeLanguageCommand } from './language-command.js';
 
 import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
-import type {
-  ICommand,
-  ICommandInteractionHint,
-  ICommandSource,
-} from '@robota-sdk/agent-interface-transport';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-transport';
 
 export function createLanguageCommandEntry(): ICommand {
   return {
@@ -49,23 +45,10 @@ export class LanguageCommandSource implements ICommandSource {
   }
 }
 
-const LANGUAGE_INTERACTION_HINTS: Record<string, ICommandInteractionHint> = {
-  language: {
-    type: 'pick',
-    getItems: () =>
-      buildLanguageCommandSubcommands().map((sub) => ({
-        label: `${sub.name}  ${sub.description ?? ''}`.trimEnd(),
-        value: sub.name,
-        description: sub.description,
-      })),
-  },
-};
-
 export function createLanguageCommandModule(): ICommandModule {
   return {
     name: 'agent-command-language',
     commandSources: [new LanguageCommandSource()],
     systemCommands: [createLanguageSystemCommand()],
-    interactionHints: LANGUAGE_INTERACTION_HINTS,
   };
 }

package/src/language/language-command.ts

@@ -1,18 +1,44 @@
-import { formatLanguageUsageMessage, parseLanguageArgument } from '@robota-sdk/agent-framework';
+import { selectAction } from '@robota-sdk/agent-core';
+import {
+  buildLanguageCommandSubcommands,
+  formatLanguageUsageMessage,
+  parseLanguageArgument,
+} from '@robota-sdk/agent-framework';
 
 import type { ICommandHostContext } from '@robota-sdk/agent-framework';
 import type { ICommandResult } from '@robota-sdk/agent-interface-transport';
 
-export function executeLanguageCommand(
-  _context: ICommandHostContext,
+/**
+ * Ask the user to pick a language (CMD-004 inline ask). Returns a validated language, or `undefined`
+ * when no interactive renderer is attached or the user cancelled — the caller then shows usage.
+ */
+async function resolveLanguageViaAsk(context: ICommandHostContext): Promise<string | undefined> {
+  const ui = context.getUserInteraction?.();
+  if (!ui) return undefined;
+  const options = buildLanguageCommandSubcommands().map((sub) => ({
+    value: sub.name,
+    label: sub.name,
+    description: sub.description,
+  }));
+  const response = await ui.ask(selectAction('language', 'Select language', options));
+  const picked = response.type === 'answer' ? response.values[0] : undefined;
+  return picked === undefined ? undefined : parseLanguageArgument(picked);
+}
+
+export async function executeLanguageCommand(
+  context: ICommandHostContext,
   args: string,
-): ICommandResult {
-  const language = parseLanguageArgument(args);
+): Promise<ICommandResult> {
+  let language = parseLanguageArgument(args);
+
   if (language === undefined) {
-    return {
-      message: formatLanguageUsageMessage(),
-      success: false,
-    };
+    language = await resolveLanguageViaAsk(context);
+    if (language === undefined) {
+      return {
+        message: formatLanguageUsageMessage(),
+        success: false,
+      };
+    }
   }
 
   return {

package/src/mode/__tests__/mode-command-module.test.ts

@@ -140,4 +140,38 @@ describe('createModeCommandModule', () => {
     );
     expect(context.setPermissionMode).not.toHaveBeenCalled();
   });
+
+  it('asks the user to pick a mode when no arg is given and a renderer is attached (CMD-004)', async () => {
+    const executor = new SystemCommandExecutor([
+      ...(createModeCommandModule().systemCommands ?? []),
+    ]);
+    const context = createCommandHostContext();
+    const contextWithAsk: ICommandHostContext = {
+      ...context,
+      getUserInteraction: () => ({ ask: async () => ({ type: 'answer', values: ['plan'] }) }),
+    };
+
+    const result = await executor.execute('mode', contextWithAsk, '');
+
+    expect(result?.success).toBe(true);
+    expect(result?.message).toBe('Permission mode set to: plan');
+    expect(context.setPermissionMode).toHaveBeenCalledWith('plan');
+  });
+
+  it('reports the current mode when the user cancels the pick (CMD-004)', async () => {
+    const executor = new SystemCommandExecutor([
+      ...(createModeCommandModule().systemCommands ?? []),
+    ]);
+    const context = createCommandHostContext();
+    const contextWithAsk: ICommandHostContext = {
+      ...context,
+      getUserInteraction: () => ({ ask: async () => ({ type: 'cancelled' }) }),
+    };
+
+    const result = await executor.execute('mode', contextWithAsk, '');
+
+    expect(result?.success).toBe(true);
+    expect(result?.message).toBe('Current mode: default');
+    expect(context.setPermissionMode).not.toHaveBeenCalled();
+  });
 });

package/src/mode/mode-command-module.ts

@@ -7,11 +7,7 @@ import {
 import { executeModeCommand } from './mode-command.js';
 
 import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
-import type {
-  ICommand,
-  ICommandInteractionHint,
-  ICommandSource,
-} from '@robota-sdk/agent-interface-transport';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-transport';
 
 export function createModeCommandEntry(): ICommand {
   return {
@@ -49,23 +45,10 @@ export class ModeCommandSource implements ICommandSource {
   }
 }
 
-const MODE_INTERACTION_HINTS: Record<string, ICommandInteractionHint> = {
-  mode: {
-    type: 'pick',
-    getItems: () =>
-      buildPermissionModeSubcommands().map((sub) => ({
-        label: sub.name,
-        value: sub.name,
-        description: sub.description,
-      })),
-  },
-};
-
 export function createModeCommandModule(): ICommandModule {
   return {
     name: 'agent-command-mode',
     commandSources: [new ModeCommandSource()],
     systemCommands: [createModeSystemCommand()],
-    interactionHints: MODE_INTERACTION_HINTS,
   };
 }

package/src/mode/mode-command.ts

@@ -1,4 +1,6 @@
+import { selectAction } from '@robota-sdk/agent-core';
 import {
+  buildPermissionModeSubcommands,
   formatInvalidPermissionModeMessage,
   isPermissionMode,
   parsePermissionModeArgument,
@@ -9,15 +11,36 @@ import {
 import type { ICommandHostContext } from '@robota-sdk/agent-framework';
 import type { ICommandResult } from '@robota-sdk/agent-interface-transport';
 
-export function executeModeCommand(context: ICommandHostContext, args: string): ICommandResult {
-  const arg = parsePermissionModeArgument(args);
+/**
+ * Ask the user to pick a permission mode (CMD-004 inline ask). Returns the chosen mode name, or
+ * `undefined` when no interactive renderer is attached or the user cancelled — the caller then reports
+ * the current mode instead of changing it (never a silent guess).
+ */
+async function resolveModeViaAsk(context: ICommandHostContext): Promise<string | undefined> {
+  const ui = context.getUserInteraction?.();
+  if (!ui) return undefined;
+  const options = buildPermissionModeSubcommands().map((sub) => ({
+    value: sub.name,
+    label: sub.name,
+    description: sub.description,
+  }));
+  const response = await ui.ask(selectAction('mode', 'Select interaction mode', options));
+  return response.type === 'answer' ? response.values[0] : undefined;
+}
+
+export async function executeModeCommand(
+  context: ICommandHostContext,
+  args: string,
+): Promise<ICommandResult> {
+  let arg: string | undefined = parsePermissionModeArgument(args);
+
   if (arg === undefined) {
-    const mode = readCommandPermissionMode(context);
-    return {
-      message: `Current mode: ${mode}`,
-      success: true,
-      data: { mode },
-    };
+    arg = await resolveModeViaAsk(context);
+    if (arg === undefined) {
+      // No interactive answer — report the current mode without changing it.
+      const mode = readCommandPermissionMode(context);
+      return { message: `Current mode: ${mode}`, success: true, data: { mode } };
+    }
   }
 
   if (!isPermissionMode(arg)) {

package/src/preset/__tests__/preset-command-module.test.ts

@@ -78,16 +78,16 @@ function createCommandHostContext(
 }
 
 describe('preset command module', () => {
-  it('exposes a single preset system command (structure)', () => {
+  it('exposes a single preset system command (structure)', async () => {
     const module = createPresetCommandModule();
     expect(module.systemCommands?.map((command) => command.name)).toContain('preset');
   });
 
-  it('TC-01: lists every preset and marks the active one', () => {
+  it('TC-01: lists every preset and marks the active one', async () => {
     const runtime = createSessionRuntime({ getActivePresetId: () => 'autonomous-builder' });
     const context = createCommandHostContext(runtime);
 
-    const result = executePresetCommand(context, '');
+    const result = await executePresetCommand(context, '');
 
     expect(result.success).toBe(true);
     for (const preset of listPresets()) {
@@ -99,7 +99,7 @@ describe('preset command module', () => {
     expect(result.data?.active).toBe('autonomous-builder');
   });
 
-  it('TC-02: switches to a valid preset and drives the live re-apply seams', () => {
+  it('TC-02: switches to a valid preset and drives the live re-apply seams', async () => {
     const setActivePresetId = vi.fn();
     const setPermissionMode = vi.fn();
     const applyModelOptions = vi.fn();
@@ -110,7 +110,7 @@ describe('preset command module', () => {
     });
     const context = createCommandHostContext(runtime);
 
-    const result = executePresetCommand(context, 'careful-reviewer');
+    const result = await executePresetCommand(context, 'careful-reviewer');
 
     expect(result.success).toBe(true);
     expect(result.message).toBe('Switched to preset: careful-reviewer');
@@ -122,12 +122,12 @@ describe('preset command module', () => {
     expect(applyModelOptions).toHaveBeenCalledWith(expect.objectContaining({ effort: 'high' }));
   });
 
-  it('TC-04: rejects an unknown preset id without switching', () => {
+  it('TC-04: rejects an unknown preset id without switching', async () => {
     const setActivePresetId = vi.fn();
     const runtime = createSessionRuntime({ setActivePresetId });
     const context = createCommandHostContext(runtime);
 
-    const result = executePresetCommand(context, '__nope__');
+    const result = await executePresetCommand(context, '__nope__');
 
     expect(result.success).toBe(false);
     for (const preset of listPresets()) {
@@ -135,4 +135,40 @@ describe('preset command module', () => {
     }
     expect(setActivePresetId).not.toHaveBeenCalled();
   });
+
+  it('CMD-004: asks the user to pick a preset when none is given, then switches', async () => {
+    const setActivePresetId = vi.fn();
+    const setPermissionMode = vi.fn();
+    const applyModelOptions = vi.fn();
+    const runtime = createSessionRuntime({
+      setActivePresetId,
+      setPermissionMode,
+      applyModelOptions,
+    });
+    const context = createCommandHostContext(runtime, {
+      getUserInteraction: () => ({
+        ask: async () => ({ type: 'answer', values: ['careful-reviewer'] }),
+      }),
+    });
+
+    const result = await executePresetCommand(context, '');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe('Switched to preset: careful-reviewer');
+    expect(setActivePresetId).toHaveBeenCalledWith('careful-reviewer');
+  });
+
+  it('CMD-004: shows the preset list when the pick is cancelled', async () => {
+    const setActivePresetId = vi.fn();
+    const runtime = createSessionRuntime({ setActivePresetId });
+    const context = createCommandHostContext(runtime, {
+      getUserInteraction: () => ({ ask: async () => ({ type: 'cancelled' }) }),
+    });
+
+    const result = await executePresetCommand(context, '');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('Available presets:');
+    expect(setActivePresetId).not.toHaveBeenCalled();
+  });
 });

package/src/preset/preset-command-module.ts

@@ -3,11 +3,7 @@ import { listPresets } from '@robota-sdk/agent-preset';
 import { executePresetCommand } from './preset-command.js';
 
 import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
-import type {
-  ICommand,
-  ICommandInteractionHint,
-  ICommandSource,
-} from '@robota-sdk/agent-interface-transport';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-transport';
 
 const PRESET_COMMAND_DESCRIPTION = 'List presets or switch the active preset';
 const PRESET_ARGUMENT_HINT = 'list | <preset-id>';
@@ -57,23 +53,10 @@ export class PresetCommandSource implements ICommandSource {
   }
 }
 
-const PRESET_INTERACTION_HINTS: Record<string, ICommandInteractionHint> = {
-  preset: {
-    type: 'pick',
-    getItems: () =>
-      buildPresetSubcommands().map((sub) => ({
-        label: sub.name,
-        value: sub.name,
-        description: sub.description,
-      })),
-  },
-};
-
 export function createPresetCommandModule(): ICommandModule {
   return {
     name: 'agent-command-preset',
     commandSources: [new PresetCommandSource()],
     systemCommands: [createPresetSystemCommand()],
-    interactionHints: PRESET_INTERACTION_HINTS,
   };
 }

package/src/preset/preset-command.ts

@@ -1,3 +1,4 @@
+import { selectAction } from '@robota-sdk/agent-core';
 import { applyPresetToSession } from '@robota-sdk/agent-framework';
 import { getPreset, listPresets, resolvePreset } from '@robota-sdk/agent-preset';
 
@@ -29,16 +30,47 @@ function formatUnknownPresetMessage(id: string): string {
   return `Unknown preset: ${id}. Available: ${ids}`;
 }
 
-export function executePresetCommand(context: ICommandHostContext, args: string): ICommandResult {
-  const id = args.trim().split(/\s+/)[0];
+/** The `/preset` (or `/preset list`) listing result. */
+function presetListResult(context: ICommandHostContext): ICommandResult {
+  const active = readActivePresetId(context);
+  return {
+    message: formatPresetList(active),
+    success: true,
+    data: { presets: listPresets(), active },
+  };
+}
 
-  if (id === undefined || id.length === 0 || id === 'list') {
-    const active = readActivePresetId(context);
-    return {
-      message: formatPresetList(active),
-      success: true,
-      data: { presets: listPresets(), active },
-    };
+/**
+ * Ask the user to pick a preset (CMD-004 inline ask). Returns the chosen id, or `undefined` when no
+ * interactive renderer is attached or the user cancelled — the caller then shows the preset list.
+ */
+async function resolvePresetViaAsk(context: ICommandHostContext): Promise<string | undefined> {
+  const ui = context.getUserInteraction?.();
+  if (!ui) return undefined;
+  const options = listPresets().map((preset) => ({
+    value: preset.id,
+    label: preset.id,
+    description: preset.description,
+  }));
+  const response = await ui.ask(selectAction('preset', 'Select a preset', options));
+  return response.type === 'answer' ? response.values[0] : undefined;
+}
+
+export async function executePresetCommand(
+  context: ICommandHostContext,
+  args: string,
+): Promise<ICommandResult> {
+  let id: string | undefined = args.trim().split(/\s+/)[0];
+
+  if (id === 'list') {
+    return presetListResult(context);
+  }
+
+  if (id === undefined || id.length === 0) {
+    id = await resolvePresetViaAsk(context);
+    if (id === undefined) {
+      return presetListResult(context);
+    }
   }
 
   if (getPreset(id) === undefined) {
@@ -49,7 +81,7 @@ export function executePresetCommand(context: ICommandHostContext, args: string)
   }
 
   const resolved = resolvePreset(id);
-  applyPresetToSession(context, id, resolved);
+  await applyPresetToSession(context, id, resolved);
   return {
     message: `Switched to preset: ${id}`,
     success: true,

package/src/provider/__tests__/org-policy.test.ts

@@ -8,6 +8,7 @@ import type {
   TProviderSettingsDocument,
 } from '@robota-sdk/agent-framework';
 import { createProviderCommandModule } from '../provider-command-module.js';
+import { scriptedContext } from './scripted-interaction.js';
 
 const providerDefinitions: readonly IProviderDefinition[] = [
   {
@@ -62,7 +63,8 @@ function createExecutor(
   return new SystemCommandExecutor([...(module.systemCommands ?? [])]);
 }
 
-const session = {} as ICommandHostContext;
+/** Context with no interactive renderer attached (headless/automation). */
+const headlessContext = {} as ICommandHostContext;
 
 describe('org policy enforcement in provider commands', () => {
   afterEach(() => {
@@ -83,7 +85,7 @@ describe('org policy enforcement in provider commands', () => {
 
     const result = await createExecutor(adapter, orgPolicy).execute(
       'provider',
-      session,
+      headlessContext,
       'switch openai',
     );
 
@@ -105,7 +107,7 @@ describe('org policy enforcement in provider commands', () => {
 
     const result = await createExecutor(adapter, orgPolicy).execute(
       'provider',
-      session,
+      headlessContext,
       'switch openai',
     );
 
@@ -128,12 +130,14 @@ describe('org policy enforcement in provider commands', () => {
     });
     const orgPolicy: IOrgPolicy = { requireApiKeyFromEnv: true, adminContact: 'sec@example.com' };
 
-    const listed = await createExecutor(adapter, orgPolicy).execute('provider', session, 'list');
-    const selected = await listed?.interaction?.submit('anthropic');
-    const editRequested = await selected?.interaction?.submit('edit');
     // Anthropic has 2 setup steps: apiKey then model
-    const modelPrompt = await editRequested?.interaction?.submit('sk-plaintext-key');
-    const completed = await modelPrompt?.interaction?.submit('claude-sonnet-4-6');
+    const { context } = scriptedContext([
+      { type: 'answer', values: ['anthropic'] },
+      { type: 'answer', values: ['edit'] },
+      { type: 'answer', values: [], text: 'sk-plaintext-key' },
+      { type: 'answer', values: [], text: 'claude-sonnet-4-6' },
+    ]);
+    const completed = await createExecutor(adapter, orgPolicy).execute('provider', context, 'list');
 
     expect(completed?.success).toBe(false);
     expect(completed?.message).toContain('environment variable references');
@@ -154,11 +158,13 @@ describe('org policy enforcement in provider commands', () => {
     });
     const orgPolicy: IOrgPolicy = { requireApiKeyFromEnv: true };
 
-    const listed = await createExecutor(adapter, orgPolicy).execute('provider', session, 'list');
-    const selected = await listed?.interaction?.submit('anthropic');
-    const editRequested = await selected?.interaction?.submit('edit');
-    const modelPrompt = await editRequested?.interaction?.submit('$ENV:ORG_TEST_KEY');
-    const completed = await modelPrompt?.interaction?.submit('claude-opus-4-5');
+    const { context } = scriptedContext([
+      { type: 'answer', values: ['anthropic'] },
+      { type: 'answer', values: ['edit'] },
+      { type: 'answer', values: [], text: '$ENV:ORG_TEST_KEY' },
+      { type: 'answer', values: [], text: 'claude-opus-4-5' },
+    ]);
+    const completed = await createExecutor(adapter, orgPolicy).execute('provider', context, 'list');
 
     expect(completed?.success).toBe(true);
   });