@robota-sdk/agent-command 3.0.0-beta.79 → 3.0.0-beta.82

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

@@ -5,6 +5,7 @@ import type {
 } from '@robota-sdk/agent-framework';
 import { SystemCommandExecutor } from '@robota-sdk/agent-framework';
 import { createModeCommandModule } from '../mode-command-module.js';
+import { createTestCommandHost } from '@robota-sdk/agent-framework/testing';
 
 type TPermissionModeName = 'plan' | 'default' | 'acceptEdits' | 'bypassPermissions';
 type TSetPermissionModeSpy = ReturnType<typeof vi.fn<(nextMode: TPermissionModeName) => void>>;
@@ -25,7 +26,7 @@ function createCheckpointResult(): IEditCheckpointRestoreResult {
   };
 }
 
-function createCommandHostContext(): ICommandHostContext & {
+function createCommandHostContext(): ReturnType<typeof createTestCommandHost> & {
   setPermissionMode: TSetPermissionModeSpy;
 } {
   let mode: TPermissionModeName = 'default';
@@ -34,34 +35,41 @@ function createCommandHostContext(): ICommandHostContext & {
   });
 
   return {
-    getSession: () => {
-      throw new Error('mode command should use the permission mode adapter');
-    },
-    getCommandHostAdapters: () => ({
-      permissionMode: {
-        getPermissionMode: () => mode,
-        setPermissionMode,
-        listSessionAllowedTools: () => [],
+    ...createTestCommandHost({
+      overrides: {
+        getSession: () => {
+          throw new Error('mode command should use the permission mode adapter');
+        },
+        getCommandHostAdapters: () => ({
+          permissionMode: {
+            getPermissionMode: () => mode,
+            setPermissionMode,
+            listSessionAllowedTools: () => [],
+            getPermissionRules: () => ({ allow: [], deny: [], ask: [] }),
+            listRecentDenials: () => [],
+            retryDenial: () => undefined,
+          },
+        }),
+        getContextState: () => ({
+          usedTokens: 0,
+          maxTokens: 1,
+          usedPercentage: 0,
+          remainingPercentage: 100,
+        }),
+        getAutoCompactThreshold: () => 0.835,
+        compactContext: async () => undefined,
+        getCwd: () => '/workspace',
+        listEditCheckpoints: () => [],
+        restoreEditCheckpoint: async () => createCheckpointResult(),
+        rollbackEditCheckpoint: async () => createCheckpointResult(),
+        getUsedMemoryReferences: () => [],
+        recordMemoryEvent: () => undefined,
+        listBackgroundTasks: () => [],
+        readBackgroundTaskLog: async () => ({ taskId: 'task_1', lines: [] }),
+        cancelBackgroundTask: async () => undefined,
+        closeBackgroundTask: async () => undefined,
       },
     }),
-    getContextState: () => ({
-      usedTokens: 0,
-      maxTokens: 1,
-      usedPercentage: 0,
-      remainingPercentage: 100,
-    }),
-    getAutoCompactThreshold: () => 0.835,
-    compactContext: async () => undefined,
-    getCwd: () => '/workspace',
-    listEditCheckpoints: () => [],
-    restoreEditCheckpoint: async () => createCheckpointResult(),
-    rollbackEditCheckpoint: async () => createCheckpointResult(),
-    getUsedMemoryReferences: () => [],
-    recordMemoryEvent: () => undefined,
-    listBackgroundTasks: () => [],
-    readBackgroundTaskLog: async () => ({ taskId: 'task_1', lines: [] }),
-    cancelBackgroundTask: async () => undefined,
-    closeBackgroundTask: async () => undefined,
     setPermissionMode,
   };
 }
@@ -77,7 +85,7 @@ describe('createModeCommandModule', () => {
       expect.objectContaining({
         name: 'mode',
         description: 'Show/change permission mode',
-        argumentHint: 'plan | default | acceptEdits | bypassPermissions',
+        argumentHint: 'plan | default | acceptEdits | bypassPermissions | auto',
         source: 'mode',
         modelInvocable: false,
       }),
@@ -87,12 +95,13 @@ describe('createModeCommandModule', () => {
       'default',
       'acceptEdits',
       'bypassPermissions',
+      'auto',
     ]);
     expect(command).toEqual(
       expect.objectContaining({
         name: 'mode',
         description: 'Show/change permission mode',
-        argumentHint: 'plan | default | acceptEdits | bypassPermissions',
+        argumentHint: 'plan | default | acceptEdits | bypassPermissions | auto',
         lifecycle: 'inline',
         modelInvocable: false,
       }),
@@ -136,7 +145,7 @@ describe('createModeCommandModule', () => {
 
     expect(result?.success).toBe(false);
     expect(result?.message).toBe(
-      'Invalid mode. Valid: plan | default | acceptEdits | bypassPermissions',
+      'Invalid mode. Valid: plan | default | acceptEdits | bypassPermissions | auto',
     );
     expect(context.setPermissionMode).not.toHaveBeenCalled();
   });
@@ -146,10 +155,12 @@ describe('createModeCommandModule', () => {
       ...(createModeCommandModule().systemCommands ?? []),
     ]);
     const context = createCommandHostContext();
-    const contextWithAsk: ICommandHostContext = {
-      ...context,
-      getUserInteraction: () => ({ ask: async () => ({ type: 'answer', values: ['plan'] }) }),
-    };
+    const contextWithAsk = createTestCommandHost({
+      overrides: {
+        ...context,
+        getUserInteraction: () => ({ ask: async () => ({ type: 'answer', values: ['plan'] }) }),
+      },
+    });
 
     const result = await executor.execute('mode', contextWithAsk, '');
 
@@ -163,10 +174,12 @@ describe('createModeCommandModule', () => {
       ...(createModeCommandModule().systemCommands ?? []),
     ]);
     const context = createCommandHostContext();
-    const contextWithAsk: ICommandHostContext = {
-      ...context,
-      getUserInteraction: () => ({ ask: async () => ({ type: 'cancelled' }) }),
-    };
+    const contextWithAsk = createTestCommandHost({
+      overrides: {
+        ...context,
+        getUserInteraction: () => ({ ask: async () => ({ type: 'cancelled' }) }),
+      },
+    });
 
     const result = await executor.execute('mode', contextWithAsk, '');
 

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

@@ -7,7 +7,7 @@ import {
 import { executeModeCommand } from './mode-command.js';
 
 import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
-import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-transport';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
 
 export function createModeCommandEntry(): ICommand {
   return {
@@ -17,6 +17,7 @@ export function createModeCommandEntry(): ICommand {
     source: 'mode',
     argumentHint: PERMISSION_MODE_ARGUMENT_HINT,
     subcommands: buildPermissionModeSubcommands('mode'),
+    // User-only: changes the permission mode; permission widening is the user's.
     modelInvocable: false,
   };
 }

package/src/mode/mode-command.ts

@@ -5,19 +5,26 @@ import {
   isPermissionMode,
   parsePermissionModeArgument,
   readCommandPermissionMode,
-  writeCommandPermissionMode,
 } from '@robota-sdk/agent-framework';
 
-import type { ICommandHostContext } from '@robota-sdk/agent-framework';
-import type { ICommandResult } from '@robota-sdk/agent-interface-transport';
+import { tryWritePermissionMode } from '../permissions/permissions-command.js';
+
+import type {
+  ICommandHostAdapterAccess,
+  ICommandHostSessionAccess,
+  ICommandHostUserInteraction,
+} from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
 
 /**
  * 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?.();
+async function resolveModeViaAsk(
+  context: ICommandHostUserInteraction,
+): Promise<string | undefined> {
+  const ui = context.getUserInteraction();
   if (!ui) return undefined;
   const options = buildPermissionModeSubcommands().map((sub) => ({
     value: sub.name,
@@ -29,7 +36,7 @@ async function resolveModeViaAsk(context: ICommandHostContext): Promise<string |
 }
 
 export async function executeModeCommand(
-  context: ICommandHostContext,
+  context: ICommandHostAdapterAccess & ICommandHostSessionAccess & ICommandHostUserInteraction,
   args: string,
 ): Promise<ICommandResult> {
   let arg: string | undefined = parsePermissionModeArgument(args);
@@ -50,7 +57,8 @@ export async function executeModeCommand(
     };
   }
 
-  writeCommandPermissionMode(context, arg);
+  const refused = tryWritePermissionMode(context, arg);
+  if (refused !== undefined) return refused;
   return {
     message: `Permission mode set to: ${arg}`,
     success: true,

package/src/output-style/__tests__/output-style-command.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createTestCommandHost } from '@robota-sdk/agent-framework/testing';
+
+import {
+  createOutputStyleCommandEntry,
+  executeOutputStyleCommand,
+} from '../output-style-command-module.js';
+
+const styles = [
+  {
+    id: 'default',
+    name: 'Default',
+    description: 'Balanced responses.',
+    tokenCost: 'baseline',
+    source: 'built-in',
+  },
+  {
+    id: 'concise',
+    name: 'Concise',
+    description: 'Lead with the answer.',
+    tokenCost: 'low',
+    source: 'built-in',
+  },
+] as const;
+
+function context() {
+  const ask = vi.fn().mockResolvedValue({ type: 'answer', values: ['concise'] });
+  const host = createTestCommandHost({
+    overrides: {
+      getActiveOutputStyleId: () => 'default',
+      getUserInteraction: () => ({ ask }),
+      getCommandHostAdapters: () => ({
+        outputStyleRegistry: {
+          listOutputStyles: () => styles,
+          getOutputStyle: (id) =>
+            id === 'concise'
+              ? {
+                  id: 'concise',
+                  name: 'Concise',
+                  instructions: 'Lead with the answer.',
+                  keepCodingInstructions: true,
+                  tokenCost: 'low',
+                }
+              : undefined,
+        },
+      }),
+    },
+  });
+  return { host, ask };
+}
+
+describe('/output-style', () => {
+  it('lists styles with the active marker and token-cost metadata', async () => {
+    const { host } = context();
+    const result = await executeOutputStyleCommand(host, 'list');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toContain(
+      '* default — Default: Balanced responses. [input cost: baseline]',
+    );
+    expect(result.message).toContain(
+      '  concise — Concise: Lead with the answer. [input cost: low]',
+    );
+    expect(result.data).toEqual({ outputStyles: styles, active: 'default' });
+  });
+
+  it('uses the inline picker when no id is supplied and emits only a style id action', async () => {
+    const { host, ask } = context();
+    const result = await executeOutputStyleCommand(host, '');
+
+    expect(ask).toHaveBeenCalledTimes(1);
+    expect(result).toMatchObject({
+      success: true,
+      hostActions: [{ type: 'output-style-change', styleId: 'concise' }],
+      data: { outputStyle: 'concise' },
+    });
+  });
+
+  it('rejects unknown ids and never emits an action', async () => {
+    const { host } = context();
+    const result = await executeOutputStyleCommand(host, 'missing');
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('Unknown output style');
+    expect(result.hostActions).toBeUndefined();
+  });
+
+  it('is operator-only', () => {
+    expect(createOutputStyleCommandEntry()).toMatchObject({
+      name: 'output-style',
+      modelInvocable: false,
+      userInvocable: true,
+    });
+  });
+});

package/src/output-style/index.ts

@@ -0,0 +1,6 @@
+export {
+  OutputStyleCommandSource,
+  createOutputStyleCommandEntry,
+  createOutputStyleCommandModule,
+  executeOutputStyleCommand,
+} from './output-style-command-module.js';

package/src/output-style/output-style-command-module.ts

@@ -0,0 +1,143 @@
+import { selectAction } from '@robota-sdk/agent-core';
+
+import type {
+  ICommandHostAdapterAccess,
+  ICommandHostSessionAccess,
+  ICommandHostUserInteraction,
+  ICommandModule,
+  ISystemCommand,
+  ICommandOutputStyleRegistryAdapter,
+} from '@robota-sdk/agent-framework';
+import type { ICommand, ICommandResult, ICommandSource } from '@robota-sdk/agent-interface-command';
+
+const OUTPUT_STYLE_DESCRIPTION = 'List or switch the active provider-neutral response style';
+const OUTPUT_STYLE_ARGUMENT_HINT = 'list | <style-id>';
+
+function getRegistry(
+  context: ICommandHostAdapterAccess,
+): ICommandOutputStyleRegistryAdapter | undefined {
+  return context.getCommandHostAdapters?.().outputStyleRegistry;
+}
+
+function formatStyleList(active: string, registry: ICommandOutputStyleRegistryAdapter): string {
+  const lines = registry.listOutputStyles().map((style) => {
+    const marker = style.id === active ? '* ' : '  ';
+    const cost = style.tokenCost ? ` [input cost: ${style.tokenCost}]` : '';
+    return `${marker}${style.id} — ${style.name}: ${style.description}${cost}`;
+  });
+  return ['Available output styles:', ...lines].join('\n');
+}
+
+function listResult(
+  context: ICommandHostSessionAccess,
+  registry: ICommandOutputStyleRegistryAdapter,
+): ICommandResult {
+  const active = context.getActiveOutputStyleId();
+  const outputStyles = registry.listOutputStyles();
+  return {
+    success: true,
+    message: formatStyleList(active, registry),
+    data: { outputStyles, active },
+  };
+}
+
+async function chooseStyle(
+  context: ICommandHostUserInteraction,
+  registry: ICommandOutputStyleRegistryAdapter,
+): Promise<string | undefined> {
+  const interaction = context.getUserInteraction();
+  if (!interaction) return undefined;
+  const options = registry.listOutputStyles().map((style) => ({
+    value: style.id,
+    label: style.id,
+    description: style.description,
+  }));
+  const response = await interaction.ask(
+    selectAction('output-style', 'Select an output style', options),
+  );
+  return response.type === 'answer' ? response.values[0] : undefined;
+}
+
+export async function executeOutputStyleCommand(
+  context: ICommandHostAdapterAccess & ICommandHostSessionAccess & ICommandHostUserInteraction,
+  args: string,
+): Promise<ICommandResult> {
+  const registry = getRegistry(context);
+  if (!registry) {
+    return {
+      success: false,
+      message: 'Output styles are not available in this environment.',
+    };
+  }
+
+  let styleId = args.trim();
+  if (styleId === 'list') return listResult(context, registry);
+  if (!styleId) {
+    styleId = (await chooseStyle(context, registry)) ?? '';
+    if (!styleId) return listResult(context, registry);
+  }
+
+  const style = registry.getOutputStyle(styleId);
+  if (!style) {
+    return {
+      success: false,
+      message: `Unknown output style "${styleId}". Available: ${
+        registry
+          .listOutputStyles()
+          .map((entry) => entry.id)
+          .join(', ') || '(none)'
+      }`,
+    };
+  }
+
+  return {
+    success: true,
+    message: `Switching output style to ${style.name}...`,
+    data: { outputStyle: style.id },
+    hostActions: [{ type: 'output-style-change', styleId: style.id }],
+  };
+}
+
+export function createOutputStyleCommandEntry(): ICommand {
+  return {
+    name: 'output-style',
+    displayName: 'Output Style',
+    description: OUTPUT_STYLE_DESCRIPTION,
+    argumentHint: OUTPUT_STYLE_ARGUMENT_HINT,
+    source: 'output-style',
+    userInvocable: true,
+    // User-only: the user's presentation preference.
+    modelInvocable: false,
+  };
+}
+
+function createOutputStyleSystemCommand(): ISystemCommand {
+  const entry = createOutputStyleCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    argumentHint: entry.argumentHint,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    lifecycle: 'inline',
+    execute: executeOutputStyleCommand,
+  };
+}
+
+export class OutputStyleCommandSource implements ICommandSource {
+  readonly name = 'output-style';
+
+  getCommands(): ICommand[] {
+    return [createOutputStyleCommandEntry()];
+  }
+}
+
+export function createOutputStyleCommandModule(): ICommandModule {
+  return {
+    name: 'agent-command-output-style',
+    commandSources: [new OutputStyleCommandSource()],
+    systemCommands: [createOutputStyleSystemCommand()],
+  };
+}