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

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

@@ -0,0 +1,57 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { scriptedSession } from '@robota-sdk/agent-framework/testing';
+
+import { createKeybindingsCommandModule } from '../keybindings-command-module.js';
+
+import type { ITerminalHandoff } from '@robota-sdk/agent-interface-session';
+
+function handoff(enabled: boolean): ITerminalHandoff {
+  return {
+    canHandoffTerminal: enabled,
+    runWithTerminal: async (operation) => operation(),
+  };
+}
+
+describe('/keybindings command', () => {
+  it('ensures and opens the exact capability-owned path', async () => {
+    const ensureFile = vi.fn().mockResolvedValue('/tmp/keybindings.json');
+    const previous = process.env.EDITOR;
+    process.env.EDITOR = 'true';
+    const session = scriptedSession({
+      turns: [{ text: 'unused' }],
+      terminalHandoff: handoff(true),
+      commandModules: [createKeybindingsCommandModule({ ensureFile })],
+    });
+    try {
+      const result = await session.command('keybindings', '');
+      expect(result).toMatchObject({
+        success: true,
+        message: 'Opened keybindings: /tmp/keybindings.json',
+        data: { path: '/tmp/keybindings.json' },
+      });
+      expect(ensureFile).toHaveBeenCalledTimes(1);
+    } finally {
+      await session.dispose();
+      if (previous === undefined) delete process.env.EDITOR;
+      else process.env.EDITOR = previous;
+    }
+  });
+
+  it('reports an unavailable terminal without creating a file', async () => {
+    const ensureFile = vi.fn().mockResolvedValue('/tmp/keybindings.json');
+    const session = scriptedSession({
+      turns: [{ text: 'unused' }],
+      terminalHandoff: handoff(false),
+      commandModules: [createKeybindingsCommandModule({ ensureFile })],
+    });
+    try {
+      const result = await session.command('keybindings', '');
+      expect(result?.success).toBe(false);
+      expect(result?.message).toMatch(/unavailable/i);
+      expect(ensureFile).not.toHaveBeenCalled();
+    } finally {
+      await session.dispose();
+    }
+  });
+});

package/src/keybindings/index.ts

@@ -0,0 +1,6 @@
+export {
+  createKeybindingsCommandEntry,
+  createKeybindingsCommandModule,
+  KeybindingsCommandSource,
+  type IKeybindingsFilePort,
+} from './keybindings-command-module.js';

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

@@ -0,0 +1,74 @@
+import { resolveEditor } from '../editor/resolve-editor.js';
+import { spawnInherited } from '../shell/spawn-inherited.js';
+
+import type {
+  ICommandHostTerminalHandoff,
+  ICommandHostWorkspace,
+  ICommandModule,
+  ISystemCommand,
+} from '@robota-sdk/agent-framework';
+import type { ICommand, ICommandResult, ICommandSource } from '@robota-sdk/agent-interface-command';
+
+export interface IKeybindingsFilePort {
+  ensureFile(): Promise<string>;
+}
+
+export function createKeybindingsCommandEntry(): ICommand {
+  return {
+    name: 'keybindings',
+    displayName: 'Keybindings',
+    description: 'Open the contextual terminal keybindings file in $EDITOR',
+    source: 'keybindings',
+    // User-only: UI preference.
+    modelInvocable: false,
+  };
+}
+
+async function executeKeybindingsCommand(
+  file: IKeybindingsFilePort,
+  context: ICommandHostTerminalHandoff & ICommandHostWorkspace,
+): Promise<ICommandResult> {
+  if (!context.canHandoffTerminal()) {
+    return { success: false, message: 'Keybindings editor is unavailable here.' };
+  }
+  const path = await file.ensureFile();
+  const editor = resolveEditor();
+  const exitCode = await context.runWithTerminal(() =>
+    spawnInherited(editor.command, [...editor.args, path], context.getCwd()),
+  );
+  if (exitCode !== 0) {
+    return {
+      success: false,
+      message: `Keybindings editor exited with code ${exitCode}.`,
+      data: { path, exitCode },
+    };
+  }
+  return { success: true, message: `Opened keybindings: ${path}`, data: { path } };
+}
+
+export class KeybindingsCommandSource implements ICommandSource {
+  readonly name = 'keybindings';
+
+  getCommands(): ICommand[] {
+    return [createKeybindingsCommandEntry()];
+  }
+}
+
+export function createKeybindingsCommandModule(file: IKeybindingsFilePort): ICommandModule {
+  const entry = createKeybindingsCommandEntry();
+  const command: ISystemCommand = {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    lifecycle: 'inline',
+    execute: (context) => executeKeybindingsCommand(file, context),
+  };
+  return {
+    name: 'agent-command-keybindings',
+    commandSources: [new KeybindingsCommandSource()],
+    systemCommands: [command],
+  };
+}

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

@@ -5,6 +5,7 @@ import type {
 } from '@robota-sdk/agent-framework';
 import { SystemCommandExecutor } from '@robota-sdk/agent-framework';
 import { createLanguageCommandModule } from '../language-command-module.js';
+import { createTestCommandHost } from '@robota-sdk/agent-framework/testing';
 
 function createCheckpointResult(): IEditCheckpointRestoreResult {
   return {
@@ -22,29 +23,31 @@ function createCheckpointResult(): IEditCheckpointRestoreResult {
   };
 }
 
-const commandHostContext: ICommandHostContext = {
-  getSession: () => {
-    throw new Error('language command should not read session runtime');
+const commandHostContext = createTestCommandHost({
+  overrides: {
+    getSession: () => {
+      throw new Error('language command should not read session runtime');
+    },
+    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,
-};
+});
 
 describe('createLanguageCommandModule', () => {
   it('provides language metadata and executable command from one module owner', () => {
@@ -89,7 +92,7 @@ describe('createLanguageCommandModule', () => {
 
     expect(result?.success).toBe(true);
     expect(result?.data?.language).toBe('ko');
-    expect(result?.effects).toEqual([{ type: 'language-change-requested', language: 'ko' }]);
+    expect(result?.hostActions).toEqual([{ type: 'language-change', language: 'ko' }]);
   });
 
   it('shows usage when no language code is provided', async () => {
@@ -107,15 +110,17 @@ describe('createLanguageCommandModule', () => {
     const executor = new SystemCommandExecutor([
       ...(createLanguageCommandModule().systemCommands ?? []),
     ]);
-    const contextWithAsk: ICommandHostContext = {
-      ...commandHostContext,
-      getUserInteraction: () => ({ ask: async () => ({ type: 'answer', values: ['ko'] }) }),
-    };
+    const contextWithAsk = createTestCommandHost({
+      overrides: {
+        ...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' }]);
+    expect(result?.hostActions).toEqual([{ type: 'language-change', language: 'ko' }]);
   });
 });

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

@@ -7,7 +7,7 @@ import {
 import { executeLanguageCommand } from './language-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 createLanguageCommandEntry(): ICommand {
   return {
@@ -17,6 +17,7 @@ export function createLanguageCommandEntry(): ICommand {
     source: 'language',
     argumentHint: LANGUAGE_COMMAND_ARGUMENT_HINT,
     subcommands: buildLanguageCommandSubcommands('language'),
+    // User-only: the user's response-language preference.
     modelInvocable: false,
   };
 }

package/src/language/language-command.ts

@@ -5,15 +5,17 @@ import {
   parseLanguageArgument,
 } from '@robota-sdk/agent-framework';
 
-import type { ICommandHostContext } from '@robota-sdk/agent-framework';
-import type { ICommandResult } from '@robota-sdk/agent-interface-transport';
+import type { ICommandHostUserInteraction } from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
 
 /**
  * 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?.();
+async function resolveLanguageViaAsk(
+  context: ICommandHostUserInteraction,
+): Promise<string | undefined> {
+  const ui = context.getUserInteraction();
   if (!ui) return undefined;
   const options = buildLanguageCommandSubcommands().map((sub) => ({
     value: sub.name,
@@ -26,7 +28,7 @@ async function resolveLanguageViaAsk(context: ICommandHostContext): Promise<stri
 }
 
 export async function executeLanguageCommand(
-  context: ICommandHostContext,
+  context: ICommandHostUserInteraction,
   args: string,
 ): Promise<ICommandResult> {
   let language = parseLanguageArgument(args);
@@ -45,6 +47,6 @@ export async function executeLanguageCommand(
     message: `Language set to "${language}".`,
     success: true,
     data: { language },
-    effects: [{ type: 'language-change-requested', language }],
+    hostActions: [{ type: 'language-change', language }],
   };
 }