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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robota-sdk/agent-command",
-  "version": "3.0.0-beta.74",
+  "version": "3.0.0-beta.76",
   "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.76",
+    "@robota-sdk/agent-framework": "3.0.0-beta.76",
+    "@robota-sdk/agent-interface-transport": "3.0.0-beta.76",
+    "@robota-sdk/agent-preset": "3.0.0-beta.76"
   },
   "devDependencies": {
     "@types/node": "^22.19.21",

package/src/context/context-command.ts

@@ -1,3 +1,4 @@
+import { CONTEXT_ESTIMATE_CHARS_PER_TOKEN } from '@robota-sdk/agent-core';
 import {
   addCommandContextReference,
   clearCommandContextReferences,
@@ -282,12 +283,11 @@ function formatContextReferenceSummary(references: readonly IContextReferenceIte
   return `References: ${active} active, ${observed} observed`;
 }
 
-// 1 token ≈ 4 chars — same approximation used across the codebase (limits-helpers.ts)
-const CHARS_PER_TOKEN = 4;
+// 1 token ≈ 4 chars — sourced from the agent-core estimation SSOT.
 const TOOL_ARG_MAX_LEN = 60;
 
 function estimateTokens(charLength: number): number {
-  return Math.ceil(charLength / CHARS_PER_TOKEN);
+  return Math.ceil(charLength / CONTEXT_ESTIMATE_CHARS_PER_TOKEN);
 }
 
 function formatContextReferenceLine(reference: IContextReferenceItem): string {
@@ -349,7 +349,7 @@ function computeMessageTokensByRole(rawMessages: TUniversalMessage[]): IMessageT
   let toolCallCount = 0;
 
   for (const msg of rawMessages) {
-    const t = Math.ceil(JSON.stringify(msg).length / CHARS_PER_TOKEN);
+    const t = Math.ceil(JSON.stringify(msg).length / CONTEXT_ESTIMATE_CHARS_PER_TOKEN);
     if (msg.role === 'system') {
       systemTokens += t;
     } else if (msg.role === 'user') {

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)', async () => {
+    const module = createPresetCommandModule();
+    expect(module.systemCommands?.map((command) => command.name)).toContain('preset');
+  });
+
+  it('TC-01: lists every preset and marks the active one', async () => {
+    const runtime = createSessionRuntime({ getActivePresetId: () => 'autonomous-builder' });
+    const context = createCommandHostContext(runtime);
+
+    const result = await 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', async () => {
+    const setActivePresetId = vi.fn();
+    const setPermissionMode = vi.fn();
+    const applyModelOptions = vi.fn();
+    const runtime = createSessionRuntime({
+      setActivePresetId,
+      setPermissionMode,
+      applyModelOptions,
+    });
+    const context = createCommandHostContext(runtime);
+
+    const result = await 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', async () => {
+    const setActivePresetId = vi.fn();
+    const runtime = createSessionRuntime({ setActivePresetId });
+    const context = createCommandHostContext(runtime);
+
+    const result = await 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,61 @@
+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 async function executePresetCommand(
+  context: ICommandHostContext,
+  args: string,
+): Promise<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);
+  await applyPresetToSession(context, id, resolved);
+  return {
+    message: `Switched to preset: ${id}`,
+    success: true,
+    data: { preset: id },
+  };
+}

package/src/session/model-pricing.ts

@@ -1,69 +1,16 @@
-/** USD prices per 1,000,000 tokens (as of May 2026 — update when providers change rates). */
-interface IModelPrice {
-  inputPerMillion: number;
-  outputPerMillion: number;
-}
-
-const MODEL_PRICES: Record<string, IModelPrice> = {
-  // Anthropic Claude 4
-  'claude-opus-4-7': { inputPerMillion: 15, outputPerMillion: 75 },
-  'claude-opus-4-5': { inputPerMillion: 15, outputPerMillion: 75 },
-  'claude-sonnet-4-6': { inputPerMillion: 3, outputPerMillion: 15 },
-  'claude-sonnet-4-5': { inputPerMillion: 3, outputPerMillion: 15 },
-  'claude-haiku-4-5': { inputPerMillion: 0.8, outputPerMillion: 4 },
-  // Anthropic Claude 3
-  'claude-3-5-sonnet-20241022': { inputPerMillion: 3, outputPerMillion: 15 },
-  'claude-3-5-haiku-20241022': { inputPerMillion: 0.8, outputPerMillion: 4 },
-  'claude-3-opus-20240229': { inputPerMillion: 15, outputPerMillion: 75 },
-  // OpenAI
-  'gpt-4o': { inputPerMillion: 2.5, outputPerMillion: 10 },
-  'gpt-4o-mini': { inputPerMillion: 0.15, outputPerMillion: 0.6 },
-  o1: { inputPerMillion: 15, outputPerMillion: 60 },
-  'o1-mini': { inputPerMillion: 3, outputPerMillion: 12 },
-  o3: { inputPerMillion: 10, outputPerMillion: 40 },
-  'o3-mini': { inputPerMillion: 1.1, outputPerMillion: 4.4 },
-  // DeepSeek
-  'deepseek-chat': { inputPerMillion: 0.14, outputPerMillion: 0.28 },
-  'deepseek-reasoner': { inputPerMillion: 0.55, outputPerMillion: 2.19 },
-  // Google Gemini
-  'gemini-2.0-flash': { inputPerMillion: 0.1, outputPerMillion: 0.4 },
-  'gemini-2.0-flash-thinking': { inputPerMillion: 0.35, outputPerMillion: 3.5 },
-  'gemini-1.5-pro': { inputPerMillion: 1.25, outputPerMillion: 5 },
-  'gemini-1.5-flash': { inputPerMillion: 0.075, outputPerMillion: 0.3 },
-};
-
-const PATTERN_PRICES: Array<{ pattern: RegExp; price: IModelPrice }> = [
-  { pattern: /claude-opus/i, price: { inputPerMillion: 15, outputPerMillion: 75 } },
-  { pattern: /claude-sonnet/i, price: { inputPerMillion: 3, outputPerMillion: 15 } },
-  { pattern: /claude-haiku/i, price: { inputPerMillion: 0.8, outputPerMillion: 4 } },
-  { pattern: /gpt-4o-mini/i, price: { inputPerMillion: 0.15, outputPerMillion: 0.6 } },
-  { pattern: /gpt-4/i, price: { inputPerMillion: 2.5, outputPerMillion: 10 } },
-  { pattern: /deepseek/i, price: { inputPerMillion: 0.14, outputPerMillion: 0.28 } },
-  { pattern: /gemini-2/i, price: { inputPerMillion: 0.1, outputPerMillion: 0.4 } },
-  { pattern: /gemini-1/i, price: { inputPerMillion: 1.25, outputPerMillion: 5 } },
-];
-
-function lookupPrice(modelId: string): IModelPrice | undefined {
-  const exact = MODEL_PRICES[modelId];
-  if (exact) return exact;
-  for (const { pattern, price } of PATTERN_PRICES) {
-    if (pattern.test(modelId)) return price;
-  }
-  return undefined;
-}
+import { calculateModelCost } from '@robota-sdk/agent-core';
 
-/** Returns USD cost, or undefined if the model is not in the pricing table. */
+/**
+ * Returns USD cost, or undefined if the model is not in the pricing table.
+ * Delegates to the agent-core pricing SSOT (`calculateModelCost`); this package owns only the
+ * command-facing display helpers below.
+ */
 export function calculateCost(
   modelId: string,
   inputTokens: number,
   outputTokens: number,
 ): number | undefined {
-  const price = lookupPrice(modelId);
-  if (!price) return undefined;
-  return (
-    (inputTokens / 1_000_000) * price.inputPerMillion +
-    (outputTokens / 1_000_000) * price.outputPerMillion
-  );
+  return calculateModelCost(modelId, inputTokens, outputTokens);
 }
 
 /** Format a USD amount for display (e.g. "$0.0043"). */