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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robota-sdk/agent-command",
-  "version": "3.0.0-beta.74",
+  "version": "3.0.0-beta.75",
   "description": "Consolidated command module implementations for Robota SDK CLI",
   "type": "module",
   "main": "dist/node/index.js",
@@ -24,9 +24,10 @@
     "src"
   ],
   "dependencies": {
-    "@robota-sdk/agent-core": "3.0.0-beta.74",
-    "@robota-sdk/agent-framework": "3.0.0-beta.74",
-    "@robota-sdk/agent-interface-transport": "3.0.0-beta.74"
+    "@robota-sdk/agent-core": "3.0.0-beta.75",
+    "@robota-sdk/agent-framework": "3.0.0-beta.75",
+    "@robota-sdk/agent-interface-transport": "3.0.0-beta.75",
+    "@robota-sdk/agent-preset": "3.0.0-beta.75"
   },
   "devDependencies": {
     "@types/node": "^22.19.21",

package/src/default/__tests__/default-command-modules.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest';
+
+import type { IProviderDefinition } from '@robota-sdk/agent-core';
+import type {
+  IProviderCommandSettingsAdapter,
+  TProviderSettingsDocument,
+} from '@robota-sdk/agent-framework';
+
+import { createDefaultCommandModules } from '../default-command-modules.js';
+
+const providerDefinitions: readonly IProviderDefinition[] = [
+  {
+    type: 'anthropic',
+    defaults: { model: 'claude-sonnet-4-6', apiKey: '$ENV:ANTHROPIC_API_KEY' },
+    setupSteps: [{ key: 'apiKey', title: 'anthropic API key', masked: true }],
+    requiresApiKey: true,
+    createProvider: () => {
+      throw new Error('not used');
+    },
+  },
+];
+
+const providerSettingsAdapter: IProviderCommandSettingsAdapter = {
+  readMergedSettings: () => ({}) as TProviderSettingsDocument,
+  readTargetSettings: () => ({}) as TProviderSettingsDocument,
+  writeTargetSettings: () => undefined,
+};
+
+const baseOptions = { cwd: '/tmp', providerDefinitions, providerSettingsAdapter } as const;
+
+function moduleNames(opts: Parameters<typeof createDefaultCommandModules>[0]): string[] {
+  return createDefaultCommandModules(opts).map((module) => module.name);
+}
+
+describe('createDefaultCommandModules — PRESET-004 module-selection delta', () => {
+  // Module `name`s are the stable ICommandModule ids (the `agent-command-*` form).
+  const HELP = 'agent-command-help';
+  const AGENT = 'agent-command-agent';
+  const BACKGROUND = 'agent-command-background';
+
+  it('TC-04: neither enabled nor disabled given → full default set unchanged (no-regression)', () => {
+    const names = moduleNames(baseOptions);
+    // No-regression: the default set length is the documented 21 modules.
+    expect(names).toHaveLength(21);
+    expect(names).toEqual([
+      'agent-command-skills',
+      'agent-command-help',
+      'agent-command-agent',
+      'agent-command-permissions',
+      'agent-command-mode',
+      'agent-command-preset',
+      'agent-command-language',
+      'agent-command-background',
+      'agent-command-memory',
+      'agent-command-user-local',
+      'agent-command-compact',
+      'agent-command-context',
+      'agent-command-exit',
+      'agent-command-session',
+      'agent-command-reset',
+      'agent-command-rewind',
+      'agent-command-schedule',
+      'agent-command-statusline',
+      'agent-command-plugin',
+      'agent-command-settings',
+      'agent-command-provider',
+    ]);
+  });
+
+  it('TC-01: enabledCommandModules whitelist keeps exactly the listed module names', () => {
+    const names = moduleNames({ ...baseOptions, enabledCommandModules: [HELP, AGENT] });
+    expect(new Set(names)).toEqual(new Set([HELP, AGENT]));
+    expect(names).toHaveLength(2);
+  });
+
+  it('TC-02: disabledCommandModules blacklist removes the named module', () => {
+    const full = moduleNames(baseOptions);
+    const names = moduleNames({ ...baseOptions, disabledCommandModules: [BACKGROUND] });
+    expect(names).not.toContain(BACKGROUND);
+    expect(names).toHaveLength(full.length - 1);
+  });
+
+  it('TC-03: a name in both enabled and disabled is excluded (deny > allow)', () => {
+    const names = moduleNames({
+      ...baseOptions,
+      enabledCommandModules: [HELP, AGENT],
+      disabledCommandModules: [AGENT],
+    });
+    expect(new Set(names)).toEqual(new Set([HELP]));
+    expect(names).not.toContain(AGENT);
+  });
+
+  it('whitelist with an unknown name simply yields no module for it', () => {
+    const names = moduleNames({ ...baseOptions, enabledCommandModules: [HELP, 'does-not-exist'] });
+    expect(names).toEqual([HELP]);
+  });
+});

package/src/default/default-command-modules.ts

@@ -9,6 +9,7 @@ import { createMemoryCommandModule } from '../memory/index.js';
 import { createModeCommandModule } from '../mode/index.js';
 import { createPermissionsCommandModule } from '../permissions/index.js';
 import { createPluginCommandModule } from '../plugin/index.js';
+import { createPresetCommandModule } from '../preset/index.js';
 import { createProviderCommandModule } from '../provider/index.js';
 import { createResetCommandModule } from '../reset/index.js';
 import { createRewindCommandModule } from '../rewind/index.js';
@@ -26,19 +27,56 @@ export interface IDefaultCommandModulesOptions {
   cwd: string;
   providerDefinitions: readonly IProviderDefinition[];
   providerSettingsAdapter: IProviderCommandSettingsAdapter;
+  /**
+   * Whitelist of module `name`s to keep. When provided, only modules whose `name`
+   * appears here survive. Omitted → all modules kept (no-regression).
+   */
+  enabledCommandModules?: readonly string[];
+  /**
+   * Blacklist of module `name`s to remove. Applied after the whitelist, so a name
+   * present in both is removed (deny > allow). Omitted → no modules removed.
+   */
+  disabledCommandModules?: readonly string[];
+}
+
+/**
+ * Apply the preset module-selection delta to the default module set.
+ *
+ * Rules: if `enabled` is provided, keep only modules whose `name` is in it; then
+ * remove any module whose `name` is in `disabled` (deny > allow). Neither given →
+ * the full default set is returned unchanged (no-regression).
+ */
+function applyModuleSelection(
+  modules: readonly ICommandModule[],
+  enabled: readonly string[] | undefined,
+  disabled: readonly string[] | undefined,
+): readonly ICommandModule[] {
+  let selected = modules;
+  if (enabled !== undefined) {
+    const allow = new Set(enabled);
+    selected = selected.filter((module) => allow.has(module.name));
+  }
+  if (disabled !== undefined) {
+    const deny = new Set(disabled);
+    selected = selected.filter((module) => !deny.has(module.name));
+  }
+  return selected;
 }
 
 export function createDefaultCommandModules({
   cwd,
   providerDefinitions,
   providerSettingsAdapter,
+  enabledCommandModules,
+  disabledCommandModules,
 }: IDefaultCommandModulesOptions): readonly ICommandModule[] {
-  return [
+  const modules: readonly ICommandModule[] = [
     createSkillsCommandModule({ cwd }),
     createHelpCommandModule(),
     createAgentCommandModule(),
     createPermissionsCommandModule(),
     createModeCommandModule(),
+    createPresetCommandModule(),
     createLanguageCommandModule(),
     createBackgroundCommandModule(),
     createMemoryCommandModule(),
@@ -58,4 +96,5 @@ export function createDefaultCommandModules({
       settings: providerSettingsAdapter,
     }),
   ];
+  return applyModuleSelection(modules, enabledCommandModules, disabledCommandModules);
 }

package/src/index.ts

@@ -10,6 +10,7 @@ export * from './memory/index.js';
 export * from './mode/index.js';
 export * from './permissions/index.js';
 export * from './plugin/index.js';
+export * from './preset/index.js';
 export * from './provider/index.js';
 export * from './reset/index.js';
 export * from './rewind/index.js';

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

@@ -0,0 +1,138 @@
+import { describe, expect, it, vi } from 'vitest';
+import { listPresets } from '@robota-sdk/agent-preset';
+import type { ICommandHostContext, ICommandSessionRuntime } from '@robota-sdk/agent-framework';
+import { createPresetCommandModule, executePresetCommand } from '../index.js';
+
+function createSessionRuntime(overrides?: Partial<ICommandSessionRuntime>): ICommandSessionRuntime {
+  return {
+    clearHistory: () => undefined,
+    compact: async () => undefined,
+    getContextState: () => ({
+      maxTokens: 100,
+      usedTokens: 10,
+      usedPercentage: 10,
+      remainingPercentage: 90,
+    }),
+    getPermissionMode: () => 'default',
+    setPermissionMode: () => undefined,
+    getSessionId: () => 'session_1',
+    getMessageCount: () => 0,
+    getSessionAllowedTools: () => [],
+    getAutoCompactThreshold: () => false,
+    getFullHistory: () => [],
+    getHistory: () => [],
+    ...overrides,
+  };
+}
+
+function createCommandHostContext(
+  runtime: ICommandSessionRuntime,
+  overrides?: Partial<ICommandHostContext>,
+): ICommandHostContext {
+  return {
+    getSession: () => runtime,
+    getContextState: () => ({
+      maxTokens: 100,
+      usedTokens: 10,
+      usedPercentage: 10,
+      remainingPercentage: 90,
+    }),
+    getAutoCompactThreshold: () => 0.8,
+    compactContext: async () => undefined,
+    getCwd: () => '/workspace',
+    listEditCheckpoints: () => [],
+    restoreEditCheckpoint: async () => ({
+      target: {
+        id: 'checkpoint_1',
+        sessionId: 'session_1',
+        sequence: 1,
+        prompt: 'edit',
+        createdAt: '2026-05-03T00:00:00.000Z',
+        fileCount: 0,
+      },
+      restoredCheckpointCount: 1,
+      restoredFileCount: 0,
+      removedCheckpointCount: 0,
+    }),
+    rollbackEditCheckpoint: async () => ({
+      target: {
+        id: 'checkpoint_1',
+        sessionId: 'session_1',
+        sequence: 1,
+        prompt: 'edit',
+        createdAt: '2026-05-03T00:00:00.000Z',
+        fileCount: 0,
+      },
+      restoredCheckpointCount: 1,
+      restoredFileCount: 0,
+      removedCheckpointCount: 0,
+    }),
+    getUsedMemoryReferences: () => [],
+    recordMemoryEvent: () => undefined,
+    listBackgroundTasks: () => [],
+    readBackgroundTaskLog: async (taskId) => ({ taskId, lines: [] }),
+    cancelBackgroundTask: async () => undefined,
+    closeBackgroundTask: async () => undefined,
+    ...overrides,
+  };
+}
+
+describe('preset command module', () => {
+  it('exposes a single preset system command (structure)', () => {
+    const module = createPresetCommandModule();
+    expect(module.systemCommands?.map((command) => command.name)).toContain('preset');
+  });
+
+  it('TC-01: lists every preset and marks the active one', () => {
+    const runtime = createSessionRuntime({ getActivePresetId: () => 'autonomous-builder' });
+    const context = createCommandHostContext(runtime);
+
+    const result = executePresetCommand(context, '');
+
+    expect(result.success).toBe(true);
+    for (const preset of listPresets()) {
+      expect(result.message).toContain(preset.id);
+    }
+    // The active preset is marked with the `* ` prefix.
+    expect(result.message).toContain('* autonomous-builder');
+    expect(result.message).not.toContain('* default');
+    expect(result.data?.active).toBe('autonomous-builder');
+  });
+
+  it('TC-02: switches to a valid preset and drives the live re-apply seams', () => {
+    const setActivePresetId = vi.fn();
+    const setPermissionMode = vi.fn();
+    const applyModelOptions = vi.fn();
+    const runtime = createSessionRuntime({
+      setActivePresetId,
+      setPermissionMode,
+      applyModelOptions,
+    });
+    const context = createCommandHostContext(runtime);
+
+    const result = executePresetCommand(context, 'careful-reviewer');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe('Switched to preset: careful-reviewer');
+    expect(result.data?.preset).toBe('careful-reviewer');
+    expect(setActivePresetId).toHaveBeenCalledWith('careful-reviewer');
+    // careful-reviewer resolves autonomy ask-first → default permission posture (PRESET-012)
+    // and effort high → applyModelOptions (PRESET-013).
+    expect(setPermissionMode).toHaveBeenCalledWith('default');
+    expect(applyModelOptions).toHaveBeenCalledWith(expect.objectContaining({ effort: 'high' }));
+  });
+
+  it('TC-04: rejects an unknown preset id without switching', () => {
+    const setActivePresetId = vi.fn();
+    const runtime = createSessionRuntime({ setActivePresetId });
+    const context = createCommandHostContext(runtime);
+
+    const result = executePresetCommand(context, '__nope__');
+
+    expect(result.success).toBe(false);
+    for (const preset of listPresets()) {
+      expect(result.message).toContain(preset.id);
+    }
+    expect(setActivePresetId).not.toHaveBeenCalled();
+  });
+});

package/src/preset/index.ts

@@ -0,0 +1,6 @@
+export {
+  createPresetCommandEntry,
+  createPresetCommandModule,
+  PresetCommandSource,
+} from './preset-command-module.js';
+export { executePresetCommand } from './preset-command.js';

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

@@ -0,0 +1,79 @@
+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';
+
+const PRESET_COMMAND_DESCRIPTION = 'List presets or switch the active preset';
+const PRESET_ARGUMENT_HINT = 'list | <preset-id>';
+
+/** Build one subcommand per registered preset id (mirrors the permission-mode subcommands). */
+function buildPresetSubcommands(source = 'preset'): ICommand[] {
+  return listPresets().map((preset) => ({
+    name: preset.id,
+    description: preset.description,
+    source,
+  }));
+}
+
+export function createPresetCommandEntry(): ICommand {
+  return {
+    name: 'preset',
+    displayName: 'Agent Preset',
+    description: PRESET_COMMAND_DESCRIPTION,
+    source: 'preset',
+    argumentHint: PRESET_ARGUMENT_HINT,
+    subcommands: buildPresetSubcommands('preset'),
+    modelInvocable: false,
+  };
+}
+
+function createPresetSystemCommand(): ISystemCommand {
+  const entry = createPresetCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    argumentHint: entry.argumentHint,
+    subcommands: entry.subcommands,
+    lifecycle: 'inline',
+    execute: executePresetCommand,
+  };
+}
+
+export class PresetCommandSource implements ICommandSource {
+  readonly name = 'preset';
+
+  getCommands(): ICommand[] {
+    return [createPresetCommandEntry()];
+  }
+}
+
+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

@@ -0,0 +1,58 @@
+import { applyPresetToSession } from '@robota-sdk/agent-framework';
+import { getPreset, listPresets, resolvePreset } from '@robota-sdk/agent-preset';
+
+import type { ICommandHostContext } from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-transport';
+
+/** Default active preset id reported when the runtime has no recorded active preset. */
+const DEFAULT_ACTIVE_PRESET_ID = 'default';
+
+/** Read the active preset id from the session, defaulting when the optional seam is absent. */
+function readActivePresetId(context: ICommandHostContext): string {
+  return context.getSession().getActivePresetId?.() ?? DEFAULT_ACTIVE_PRESET_ID;
+}
+
+/** Build the `/preset` listing: one line per preset, marking the active one with a `*` prefix. */
+function formatPresetList(active: string): string {
+  const lines = listPresets().map((preset) => {
+    const marker = preset.id === active ? '* ' : '  ';
+    return `${marker}${preset.id} — ${preset.title}: ${preset.description}`;
+  });
+  return ['Available presets:', ...lines].join('\n');
+}
+
+/** Build the rejection message for an unknown preset id, listing the valid ids. */
+function formatUnknownPresetMessage(id: string): string {
+  const ids = listPresets()
+    .map((preset) => preset.id)
+    .join(', ');
+  return `Unknown preset: ${id}. Available: ${ids}`;
+}
+
+export function executePresetCommand(context: ICommandHostContext, args: string): ICommandResult {
+  const id = args.trim().split(/\s+/)[0];
+
+  if (id === undefined || id.length === 0 || id === 'list') {
+    const active = readActivePresetId(context);
+    return {
+      message: formatPresetList(active),
+      success: true,
+      data: { presets: listPresets(), active },
+    };
+  }
+
+  if (getPreset(id) === undefined) {
+    return {
+      message: formatUnknownPresetMessage(id),
+      success: false,
+    };
+  }
+
+  const resolved = resolvePreset(id);
+  applyPresetToSession(context, id, resolved);
+  return {
+    message: `Switched to preset: ${id}`,
+    success: true,
+    data: { preset: id },
+  };
+}