@robota-sdk/agent-command 3.0.0-beta.64

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

@@ -0,0 +1,105 @@
+import { describe, expect, it } from 'vitest';
+import type {
+  ICommandHostContext,
+  IEditCheckpointRestoreResult,
+} from '@robota-sdk/agent-framework';
+import { SystemCommandExecutor } from '@robota-sdk/agent-framework';
+import { createLanguageCommandModule } from '../language-command-module.js';
+
+function createCheckpointResult(): IEditCheckpointRestoreResult {
+  return {
+    target: {
+      id: 'checkpoint_1',
+      sessionId: 'session_1',
+      sequence: 1,
+      prompt: 'edit files',
+      createdAt: '2026-05-03T00:00:00.000Z',
+      fileCount: 1,
+    },
+    restoredCheckpointCount: 0,
+    restoredFileCount: 0,
+    removedCheckpointCount: 0,
+  };
+}
+
+const commandHostContext: ICommandHostContext = {
+  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,
+};
+
+describe('createLanguageCommandModule', () => {
+  it('provides language metadata and executable command from one module owner', () => {
+    const module = createLanguageCommandModule();
+    const command = module.systemCommands?.[0];
+    const entry = module.commandSources?.[0]?.getCommands()[0];
+
+    expect(module.name).toBe('agent-command-language');
+    expect(entry).toEqual(
+      expect.objectContaining({
+        name: 'language',
+        description: 'Set response language',
+        argumentHint: '<code>',
+        source: 'language',
+        modelInvocable: false,
+      }),
+    );
+    expect(entry?.subcommands?.map((subcommand) => subcommand.name)).toEqual([
+      'ko',
+      'en',
+      'ja',
+      'zh',
+    ]);
+    expect(command).toEqual(
+      expect.objectContaining({
+        name: 'language',
+        description: 'Set response language',
+        argumentHint: '<code>',
+        lifecycle: 'inline',
+        modelInvocable: false,
+      }),
+    );
+    expect(command?.subcommands).toEqual(entry?.subcommands);
+  });
+
+  it('requests language changes through a typed command effect', async () => {
+    const executor = new SystemCommandExecutor([
+      ...(createLanguageCommandModule().systemCommands ?? []),
+    ]);
+
+    const result = await executor.execute('language', commandHostContext, 'ko');
+
+    expect(result?.success).toBe(true);
+    expect(result?.data?.language).toBe('ko');
+    expect(result?.effects).toEqual([{ type: 'language-change-requested', language: 'ko' }]);
+  });
+
+  it('shows usage when no language code is provided', async () => {
+    const executor = new SystemCommandExecutor([
+      ...(createLanguageCommandModule().systemCommands ?? []),
+    ]);
+
+    const result = await executor.execute('language', commandHostContext, '');
+
+    expect(result?.success).toBe(false);
+    expect(result?.message).toBe('Usage: language <code> (e.g., ko, en, ja, zh)');
+  });
+});

package/src/language/index.ts

@@ -0,0 +1,6 @@
+export {
+  createLanguageCommandEntry,
+  createLanguageCommandModule,
+  LanguageCommandSource,
+} from './language-command-module.js';
+export { executeLanguageCommand } from './language-command.js';

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

@@ -0,0 +1,56 @@
+import type {
+  ICommand,
+  ICommandModule,
+  ICommandSource,
+  ISystemCommand,
+} from '@robota-sdk/agent-framework';
+import {
+  buildLanguageCommandSubcommands,
+  LANGUAGE_COMMAND_ARGUMENT_HINT,
+  LANGUAGE_COMMAND_DESCRIPTION,
+} from '@robota-sdk/agent-framework';
+import { executeLanguageCommand } from './language-command.js';
+
+export function createLanguageCommandEntry(): ICommand {
+  return {
+    name: 'language',
+    displayName: 'Language',
+    description: LANGUAGE_COMMAND_DESCRIPTION,
+    source: 'language',
+    argumentHint: LANGUAGE_COMMAND_ARGUMENT_HINT,
+    subcommands: buildLanguageCommandSubcommands('language'),
+    modelInvocable: false,
+  };
+}
+
+function createLanguageSystemCommand(): ISystemCommand {
+  const entry = createLanguageCommandEntry();
+  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: executeLanguageCommand,
+  };
+}
+
+export class LanguageCommandSource implements ICommandSource {
+  readonly name = 'language';
+
+  getCommands(): ICommand[] {
+    return [createLanguageCommandEntry()];
+  }
+}
+
+export function createLanguageCommandModule(): ICommandModule {
+  return {
+    name: 'agent-command-language',
+    commandSources: [new LanguageCommandSource()],
+    systemCommands: [createLanguageSystemCommand()],
+  };
+}

package/src/language/language-command.ts

@@ -0,0 +1,22 @@
+import type { ICommandHostContext, ICommandResult } from '@robota-sdk/agent-framework';
+import { formatLanguageUsageMessage, parseLanguageArgument } from '@robota-sdk/agent-framework';
+
+export function executeLanguageCommand(
+  _context: ICommandHostContext,
+  args: string,
+): ICommandResult {
+  const language = parseLanguageArgument(args);
+  if (language === undefined) {
+    return {
+      message: formatLanguageUsageMessage(),
+      success: false,
+    };
+  }
+
+  return {
+    message: `Language set to "${language}".`,
+    success: true,
+    data: { language },
+    effects: [{ type: 'language-change-requested', language }],
+  };
+}

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

@@ -0,0 +1,272 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  InteractiveSession,
+  SystemCommandExecutor,
+  createCommandPendingMemoryStore,
+} from '@robota-sdk/agent-framework';
+import { MemoryCommandSource, createMemoryCommandModule, executeMemoryCommand } from '../index.js';
+
+const TMP_BASE = join(tmpdir(), `robota-command-memory-${process.pid}`);
+
+function makeProject(): string {
+  const dir = join(TMP_BASE, Math.random().toString(36).slice(2));
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function createMockRuntimeSession() {
+  return {
+    run: vi.fn().mockResolvedValue('mock response'),
+    abort: vi.fn(),
+    clearHistory: vi.fn(),
+    compact: vi.fn().mockResolvedValue(undefined),
+    injectMessage: vi.fn(),
+    getHistory: vi.fn().mockReturnValue([]),
+    getContextState: vi.fn().mockReturnValue({
+      usedTokens: 5000,
+      maxTokens: 200000,
+      usedPercentage: 2.5,
+      remainingPercentage: 97.5,
+    }),
+    getPermissionMode: vi.fn().mockReturnValue('default'),
+    setPermissionMode: vi.fn(),
+    getSessionId: vi.fn().mockReturnValue('test-session-id'),
+    getMessageCount: vi.fn().mockReturnValue(5),
+    getSessionAllowedTools: vi.fn().mockReturnValue([]),
+    getAutoCompactThreshold: vi.fn().mockReturnValue(0.835),
+    setAutoCompactThreshold: vi.fn(),
+    getSystemMessage: vi.fn().mockReturnValue('mock system prompt'),
+    getToolSchemas: vi.fn().mockReturnValue([]),
+  };
+}
+
+function createInteractiveSession(cwd = makeProject()): InteractiveSession {
+  return new InteractiveSession({
+    cwd,
+    session: createMockRuntimeSession() as never,
+    commandModules: [createMemoryCommandModule()],
+  });
+}
+
+function seedPendingMemory(cwd: string): void {
+  const pendingStore = createCommandPendingMemoryStore(
+    cwd,
+    () => new Date('2026-05-02T00:00:00.000Z'),
+  );
+  pendingStore.upsert(
+    {
+      id: 'mem_123',
+      type: 'project',
+      topic: 'build',
+      text: 'Use pnpm for package scripts.',
+      sourceMessageIds: ['turn-1:user'],
+      confidence: 0.9,
+      createdAt: '2026-05-02T00:00:00.000Z',
+      reason: 'explicit-memory-cue',
+    },
+    'pending',
+    'approval-required',
+  );
+}
+
+afterEach(() => {
+  if (existsSync(TMP_BASE)) rmSync(TMP_BASE, { recursive: true, force: true });
+});
+
+describe('createMemoryCommandModule', () => {
+  it('contributes write-safe model-invocable memory metadata and executable command', () => {
+    const module = createMemoryCommandModule();
+    const commands = module.commandSources?.flatMap((source) => source.getCommands()) ?? [];
+
+    expect(module.name).toBe('agent-command-memory');
+    expect(commands.map((command) => command.name)).toEqual(['memory']);
+    expect(commands[0]?.source).toBe('memory');
+    expect(commands[0]?.modelInvocable).toBe(true);
+    expect(commands[0]?.safety).toBe('write');
+    expect(commands[0]?.subcommands?.map((command) => command.name)).toEqual([
+      'list',
+      'show',
+      'add',
+      'pending',
+      'approve',
+      'reject',
+      'used',
+    ]);
+    expect(module.systemCommands?.map((command) => command.name)).toEqual(['memory']);
+    expect(module.systemCommands?.[0]?.userInvocable).toBe(true);
+  });
+
+  it('provides a stable command source', () => {
+    const source = new MemoryCommandSource();
+
+    expect(source.name).toBe('memory');
+    expect(source.getCommands()).toHaveLength(1);
+  });
+
+  it('exposes the command as a model-invocable descriptor', () => {
+    const executor = new SystemCommandExecutor([
+      ...(createMemoryCommandModule().systemCommands ?? []),
+    ]);
+    const descriptor = executor
+      .listModelInvocableCommands()
+      .find((command) => command.name === 'memory');
+
+    expect(executor.isModelInvocable('memory')).toBe(true);
+    expect(descriptor).toEqual(
+      expect.objectContaining({
+        name: 'memory',
+        kind: 'builtin-command',
+        userInvocable: true,
+        modelInvocable: true,
+        argumentHint:
+          'list | show [topic] | add <user|feedback|project|reference> <topic> <text> | pending | approve <id> | reject <id> | used',
+        safety: 'write',
+      }),
+    );
+    expect(descriptor?.description).toContain(
+      'inspect project memory when stored context may help',
+    );
+  });
+});
+
+describe('executeMemoryCommand', () => {
+  it('lists configured memory paths', async () => {
+    const cwd = makeProject();
+    const session = createInteractiveSession(cwd);
+
+    const result = await session.executeCommand('memory', 'list');
+
+    expect(result?.success).toBe(true);
+    expect(result?.message).toContain(join(cwd, '.robota', 'memory', 'MEMORY.md'));
+  });
+
+  it('persists index and topic entries through slash invocation', async () => {
+    const cwd = makeProject();
+    const session = createInteractiveSession(cwd);
+
+    const result = await session.executeCommand(
+      'memory',
+      'add project build Use pnpm for scripts.',
+    );
+
+    expect(result?.success).toBe(true);
+    expect(readFileSync(join(cwd, '.robota', 'memory', 'MEMORY.md'), 'utf8')).toContain(
+      '(project/build) Use pnpm for scripts.',
+    );
+  });
+
+  it('uses the same handler for model invocation', async () => {
+    const cwd = makeProject();
+    const session = createInteractiveSession(cwd);
+
+    const result = await session.executeModelCommand(
+      'memory',
+      'add project build Use pnpm for package scripts.',
+    );
+
+    expect(result?.success).toBe(true);
+    expect(readFileSync(join(cwd, '.robota', 'memory', 'MEMORY.md'), 'utf8')).toContain(
+      '(project/build) Use pnpm for package scripts.',
+    );
+  });
+
+  it('rejects sensitive content before writing files', async () => {
+    const cwd = makeProject();
+    const session = createInteractiveSession(cwd);
+
+    const result = await session.executeCommand(
+      'memory',
+      'add project secrets api key is sk-test-secret',
+    );
+
+    expect(result?.success).toBe(false);
+    expect(result?.message).toContain('sensitive');
+    expect(existsSync(join(cwd, '.robota', 'memory', 'MEMORY.md'))).toBe(false);
+  });
+
+  it('lists queued automatic memory candidates', async () => {
+    const cwd = makeProject();
+    seedPendingMemory(cwd);
+    const session = createInteractiveSession(cwd);
+
+    const result = await session.executeCommand('memory', 'pending');
+
+    expect(result?.success).toBe(true);
+    expect(result?.message).toContain('mem_123');
+    expect(result?.message).toContain('project/build');
+    expect(result?.message).toContain('Use pnpm for package scripts.');
+  });
+
+  it('approves and saves a pending candidate while recording audit events', async () => {
+    const cwd = makeProject();
+    seedPendingMemory(cwd);
+    const session = createInteractiveSession(cwd);
+    const recordMemoryEvent = vi.spyOn(session, 'recordMemoryEvent');
+
+    const result = await session.executeCommand('memory', 'approve mem_123');
+
+    expect(result?.success).toBe(true);
+    expect(result?.message).toContain('Saved memory candidate mem_123');
+    expect(readFileSync(join(cwd, '.robota', 'memory', 'MEMORY.md'), 'utf8')).toContain(
+      '(project/build) Use pnpm for package scripts.',
+    );
+    expect(createCommandPendingMemoryStore(cwd).get('mem_123')?.status).toBe('saved');
+    expect(recordMemoryEvent).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'memory_candidate_approved', candidateId: 'mem_123' }),
+    );
+    expect(recordMemoryEvent).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'memory_candidate_saved', candidateId: 'mem_123' }),
+    );
+  });
+
+  it('rejects a pending candidate while recording an audit event', async () => {
+    const cwd = makeProject();
+    seedPendingMemory(cwd);
+    const session = createInteractiveSession(cwd);
+    const recordMemoryEvent = vi.spyOn(session, 'recordMemoryEvent');
+
+    const result = await session.executeCommand('memory', 'reject mem_123');
+
+    expect(result?.success).toBe(true);
+    expect(result?.message).toContain('Rejected memory candidate mem_123');
+    expect(createCommandPendingMemoryStore(cwd).get('mem_123')?.status).toBe('rejected');
+    expect(recordMemoryEvent).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'memory_candidate_rejected', candidateId: 'mem_123' }),
+    );
+  });
+
+  it('reports references from the current turn', async () => {
+    const cwd = makeProject();
+    const session = createInteractiveSession(cwd);
+    vi.spyOn(session, 'getUsedMemoryReferences').mockReturnValue([
+      {
+        topic: 'build',
+        path: join(cwd, '.robota', 'memory', 'topics', 'build.md'),
+        score: 5,
+        truncated: false,
+      },
+    ]);
+
+    const result = await session.executeCommand('memory', 'used');
+
+    expect(result?.success).toBe(true);
+    expect(result?.message).toContain('build');
+    expect(result?.message).toContain(join(cwd, '.robota', 'memory', 'topics', 'build.md'));
+  });
+
+  it('returns usage for invalid arguments without mutating state', async () => {
+    const cwd = makeProject();
+    const session = createInteractiveSession(cwd);
+
+    const result = await executeMemoryCommand(session, 'add project missing-text');
+    const unknownResult = await executeMemoryCommand(session, 'unknown');
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('Usage: memory');
+    expect(unknownResult.success).toBe(false);
+    expect(existsSync(join(cwd, '.robota', 'memory', 'MEMORY.md'))).toBe(false);
+  });
+});

package/src/memory/index.ts

@@ -0,0 +1,6 @@
+export {
+  MemoryCommandSource,
+  createMemoryCommandEntry,
+  createMemoryCommandModule,
+} from './memory-command-module.js';
+export { executeMemoryCommand } from './memory-command.js';

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

@@ -0,0 +1,57 @@
+import type {
+  ICommand,
+  ICommandModule,
+  ICommandSource,
+  ISystemCommand,
+} from '@robota-sdk/agent-framework';
+import {
+  MEMORY_COMMAND_ARGUMENT_HINT,
+  MEMORY_COMMAND_DESCRIPTION,
+  buildMemoryCommandSubcommands,
+} from '@robota-sdk/agent-framework';
+import { executeMemoryCommand } from './memory-command.js';
+
+export function createMemoryCommandEntry(): ICommand {
+  return {
+    name: 'memory',
+    displayName: 'Memory',
+    description: MEMORY_COMMAND_DESCRIPTION,
+    source: 'memory',
+    argumentHint: MEMORY_COMMAND_ARGUMENT_HINT,
+    modelInvocable: true,
+    safety: 'write',
+    subcommands: buildMemoryCommandSubcommands(),
+  };
+}
+
+function createMemorySystemCommand(): ISystemCommand {
+  const entry = createMemoryCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: true,
+    argumentHint: entry.argumentHint,
+    safety: entry.safety,
+    subcommands: entry.subcommands,
+    execute: executeMemoryCommand,
+  };
+}
+
+export class MemoryCommandSource implements ICommandSource {
+  readonly name = 'memory';
+
+  getCommands(): ICommand[] {
+    return [createMemoryCommandEntry()];
+  }
+}
+
+export function createMemoryCommandModule(): ICommandModule {
+  return {
+    name: 'agent-command-memory',
+    commandSources: [new MemoryCommandSource()],
+    systemCommands: [createMemorySystemCommand()],
+  };
+}