clawt 2.13.0 → 2.14.0

package/src/constants/index.ts

@@ -3,7 +3,7 @@ export { INVALID_BRANCH_CHARS } from './branch.js';
 export { MESSAGES } from './messages/index.js';
 export { EXIT_CODES } from './exitCodes.js';
 export { ENABLE_BRACKETED_PASTE, DISABLE_BRACKETED_PASTE, PASTE_THRESHOLD_MS, VALID_TERMINAL_APPS, ITERM2_APP_PATH } from './terminal.js';
-export { DEFAULT_CONFIG, CONFIG_DESCRIPTIONS, APPEND_SYSTEM_PROMPT } from './config.js';
+export { DEFAULT_CONFIG, CONFIG_DESCRIPTIONS, CONFIG_DEFINITIONS, APPEND_SYSTEM_PROMPT } from './config.js';
 export { AUTO_SAVE_COMMIT_MESSAGE } from './git.js';
 export { DEBUG_LOG_PREFIX, DEBUG_TIMESTAMP_FORMAT } from './logger.js';
 export {

package/src/constants/messages/config.ts

@@ -2,4 +2,26 @@
 export const CONFIG_CMD_MESSAGES = {
   /** 配置已恢复为默认值 */
   CONFIG_RESET_SUCCESS: '✓ 配置已恢复为默认值',
+  /** 配置项设置成功 */
+  CONFIG_SET_SUCCESS: (key: string, value: string) => `✓ ${key} 已设置为 ${value}`,
+  /** 获取配置值显示 */
+  CONFIG_GET_VALUE: (key: string, value: string) => `${key} = ${value}`,
+  /** 无效配置项名称 */
+  CONFIG_INVALID_KEY: (key: string, validKeys: string[]) =>
+    `无效的配置项: ${key}\n可用的配置项: ${validKeys.join(', ')}`,
+  /** 布尔类型值无效 */
+  CONFIG_INVALID_BOOLEAN: (key: string) =>
+    `配置项 ${key} 为布尔类型，仅接受 true 或 false`,
+  /** 数字类型值无效 */
+  CONFIG_INVALID_NUMBER: (key: string) =>
+    `配置项 ${key} 为数字类型，请输入有效的数字`,
+  /** 枚举类型配置项值无效（通用版） */
+  CONFIG_INVALID_ENUM: (key: string, validValues: readonly string[]) =>
+    `配置项 ${key} 仅接受以下值: ${validValues.join(', ')}`,
+  /** 交互式选择配置项提示 */
+  CONFIG_SELECT_PROMPT: '选择要修改的配置项',
+  /** 交互式输入新值提示 */
+  CONFIG_INPUT_PROMPT: (key: string) => `输入 ${key} 的新值`,
+  /** 缺少 value 参数提示 */
+  CONFIG_MISSING_VALUE: (key: string) => `缺少配置值，用法: clawt config set ${key} <value>`,
 } as const;

package/src/types/config.ts

@@ -22,6 +22,8 @@ export interface ConfigItemDefinition<T> {
   defaultValue: T;
   /** 配置项描述，用于 config 命令展示 */
   description: string;
+  /** 可选：允许的枚举值列表，仅对 string 类型有效 */
+  allowedValues?: T extends string ? readonly string[] : never;
 }
 
 /** 所有配置项的完整定义映射 */

package/src/utils/config-strategy.ts

@@ -0,0 +1,196 @@
+import chalk from 'chalk';
+import Enquirer from 'enquirer';
+import { DEFAULT_CONFIG, CONFIG_DEFINITIONS, MESSAGES } from '../constants/index.js';
+import type { ClawtConfig } from '../types/index.js';
+
+/**
+ * 校验 key 是否为有效的配置项名称
+ * @param {string} key - 待校验的配置项名称
+ * @returns {boolean} 是否有效
+ */
+export function isValidConfigKey(key: string): key is keyof ClawtConfig {
+  return key in DEFAULT_CONFIG;
+}
+
+/**
+ * 获取所有有效配置项名称列表
+ * @returns {string[]} 配置项名称数组
+ */
+export function getValidConfigKeys(): string[] {
+  return Object.keys(DEFAULT_CONFIG);
+}
+
+/**
+ * 将字符串值解析并校验为目标配置项的正确类型
+ *
+ * 策略分发规则：
+ * - boolean → 解析 'true'/'false'
+ * - number → Number() 解析
+ * - string + 有 allowedValues → 枚举校验
+ * - string + 无 allowedValues → 无额外校验
+ *
+ * @param {keyof ClawtConfig} key - 配置项名称
+ * @param {string} rawValue - 原始字符串值
+ * @returns {{ success: true; value: ClawtConfig[keyof ClawtConfig] } | { success: false; error: string }} 解析结果
+ */
+export function parseConfigValue(
+  key: keyof ClawtConfig,
+  rawValue: string,
+): { success: true; value: ClawtConfig[keyof ClawtConfig] } | { success: false; error: string } {
+  const expectedType = typeof DEFAULT_CONFIG[key];
+
+  // 布尔类型策略
+  if (expectedType === 'boolean') {
+    if (rawValue === 'true') return { success: true, value: true };
+    if (rawValue === 'false') return { success: true, value: false };
+    return { success: false, error: MESSAGES.CONFIG_INVALID_BOOLEAN(key) };
+  }
+
+  // 数字类型策略
+  if (expectedType === 'number') {
+    const num = Number(rawValue);
+    if (Number.isNaN(num)) {
+      return { success: false, error: MESSAGES.CONFIG_INVALID_NUMBER(key) };
+    }
+    return { success: true, value: num };
+  }
+
+  // 字符串类型：根据 allowedValues 自动选择校验策略
+  const definition = CONFIG_DEFINITIONS[key];
+  if (definition.allowedValues && !definition.allowedValues.includes(rawValue)) {
+    return { success: false, error: MESSAGES.CONFIG_INVALID_ENUM(key, definition.allowedValues) };
+  }
+
+  return { success: true, value: rawValue };
+}
+
+/**
+ * 交互式提示用户输入配置值
+ *
+ * 策略分发规则：
+ * - boolean → Select(true, false)
+ * - number → Input(带数字校验)
+ * - string + 有 allowedValues → Select(枚举列表)
+ * - string + 无 allowedValues → Input(自由输入)
+ *
+ * @param {keyof ClawtConfig} key - 配置项名称
+ * @param {ClawtConfig[keyof ClawtConfig]} currentValue - 当前值
+ * @returns {Promise<ClawtConfig[keyof ClawtConfig]>} 用户输入/选择的新值
+ */
+export async function promptConfigValue(
+  key: keyof ClawtConfig,
+  currentValue: ClawtConfig[keyof ClawtConfig],
+): Promise<ClawtConfig[keyof ClawtConfig]> {
+  const expectedType = typeof currentValue;
+
+  // 布尔类型策略
+  if (expectedType === 'boolean') {
+    return promptBooleanValue(key, currentValue as boolean);
+  }
+
+  // 数字类型策略
+  if (expectedType === 'number') {
+    return promptNumberValue(key, currentValue as number);
+  }
+
+  // 字符串类型：根据 allowedValues 自动选择提示策略
+  const definition = CONFIG_DEFINITIONS[key];
+  if (definition.allowedValues) {
+    return promptEnumValue(key, currentValue as string, definition.allowedValues);
+  }
+
+  return promptStringValue(key, currentValue as string);
+}
+
+/**
+ * 格式化配置值的显示样式
+ * @param {ClawtConfig[keyof ClawtConfig]} value - 配置值
+ * @returns {string} 格式化后的字符串
+ */
+export function formatConfigValue(value: ClawtConfig[keyof ClawtConfig]): string {
+  if (typeof value === 'boolean') {
+    return value ? chalk.green('true') : chalk.yellow('false');
+  }
+  return chalk.cyan(String(value));
+}
+
+/**
+ * 交互式布尔值选择（内部辅助函数）
+ * @param {keyof ClawtConfig} key - 配置项名称
+ * @param {boolean} currentValue - 当前值
+ * @returns {Promise<boolean>} 用户选择的布尔值
+ */
+async function promptBooleanValue(key: keyof ClawtConfig, currentValue: boolean): Promise<boolean> {
+  const choices = [
+    { name: 'true', message: 'true' },
+    { name: 'false', message: 'false' },
+  ];
+
+  // @ts-expect-error enquirer 类型声明未导出 Select 类，但运行时存在
+  const selected: string = await new Enquirer.Select({
+    message: MESSAGES.CONFIG_INPUT_PROMPT(key),
+    choices,
+    initial: currentValue ? 0 : 1,
+  }).run();
+
+  return selected === 'true';
+}
+
+/**
+ * 交互式数字输入（内部辅助函数）
+ * @param {keyof ClawtConfig} key - 配置项名称
+ * @param {number} currentValue - 当前值
+ * @returns {Promise<number>} 用户输入的数字值
+ */
+async function promptNumberValue(key: keyof ClawtConfig, currentValue: number): Promise<number> {
+  // @ts-expect-error enquirer 类型声明未导出 Input 类，但运行时存在
+  const input: string = await new Enquirer.Input({
+    message: MESSAGES.CONFIG_INPUT_PROMPT(key),
+    initial: String(currentValue),
+    validate: (val: string) => {
+      if (Number.isNaN(Number(val))) return '请输入有效的数字';
+      return true;
+    },
+  }).run();
+
+  return Number(input);
+}
+
+/**
+ * 交互式枚举值选择（内部辅助函数，用于有 allowedValues 的 string 配置项）
+ * @param {keyof ClawtConfig} key - 配置项名称
+ * @param {string} currentValue - 当前值
+ * @param {readonly string[]} allowedValues - 允许的枚举值列表
+ * @returns {Promise<string>} 用户选择的枚举值
+ */
+async function promptEnumValue(
+  key: keyof ClawtConfig,
+  currentValue: string,
+  allowedValues: readonly string[],
+): Promise<string> {
+  const choices = allowedValues.map((v) => ({
+    name: v,
+    message: v,
+  }));
+
+  // @ts-expect-error enquirer 类型声明未导出 Select 类，但运行时存在
+  return await new Enquirer.Select({
+    message: MESSAGES.CONFIG_INPUT_PROMPT(key),
+    choices,
+    initial: allowedValues.indexOf(currentValue),
+  }).run();
+}
+
+/**
+ * 交互式字符串自由输入（内部辅助函数，用于无 allowedValues 的 string 配置项）
+ * @param {keyof ClawtConfig} key - 配置项名称
+ * @param {string} currentValue - 当前值
+ * @returns {Promise<string>} 用户输入的字符串值
+ */
+async function promptStringValue(key: keyof ClawtConfig, currentValue: string): Promise<string> {
+  // @ts-expect-error enquirer 类型声明未导出 Input 类，但运行时存在
+  return await new Enquirer.Input({
+    message: MESSAGES.CONFIG_INPUT_PROMPT(key),
+    initial: currentValue,
+  }).run();
+}

package/src/utils/config.ts

@@ -39,6 +39,14 @@ export function writeDefaultConfig(): void {
   writeConfig(DEFAULT_CONFIG);
 }
 
+/**
+ * 将配置对象完整写入配置文件
+ * @param {ClawtConfig} config - 要持久化的配置对象
+ */
+export function saveConfig(config: ClawtConfig): void {
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+}
+
 /**
  * 获取配置中指定字段的值
  * @param {keyof ClawtConfig} key - 配置字段名

package/src/utils/index.ts

@@ -48,7 +48,7 @@ export {
 export { sanitizeBranchName, generateBranchNames, validateBranchesNotExist } from './branch.js';
 export { validateMainWorktree, validateGitInstalled, validateClaudeCodeInstalled } from './validation.js';
 export { createWorktrees, getProjectWorktrees, getProjectWorktreeDir, cleanupWorktrees, getWorktreeStatus, createWorktreesByBranches } from './worktree.js';
-export { loadConfig, writeDefaultConfig, writeConfig, getConfigValue, ensureClawtDirs } from './config.js';
+export { loadConfig, writeDefaultConfig, writeConfig, saveConfig, getConfigValue, ensureClawtDirs } from './config.js';
 export { printSuccess, printError, printWarning, printInfo, printSeparator, printDoubleSeparator, confirmAction, confirmDestructiveAction, formatWorktreeStatus, isWorktreeIdle, formatDuration } from './formatter.js';
 export { ensureDir, removeEmptyDir } from './fs.js';
 export { multilineInput } from './prompt.js';
@@ -61,4 +61,5 @@ export { parseTaskFile, loadTaskFile } from './task-file.js';
 export { executeBatchTasks } from './task-executor.js';
 export { detectTerminalApp, openCommandInNewTerminalTab } from './terminal.js';
 export { applyAliases } from './alias.js';
+export { isValidConfigKey, getValidConfigKeys, parseConfigValue, promptConfigValue, formatConfigValue } from './config-strategy.js';
 

package/tests/unit/commands/config.test.ts

@@ -1,85 +1,156 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { Command } from 'commander';
 
+// mock enquirer（必须在所有 import 之前）
+const { mockSelectRun, mockInputRun } = vi.hoisted(() => {
+  const mockSelectRun = vi.fn();
+  const mockInputRun = vi.fn();
+  return { mockSelectRun, mockInputRun };
+});
+
+vi.mock('enquirer', () => ({
+  default: {
+    Select: function MockSelect() { return { run: mockSelectRun }; },
+    Input: function MockInput() { return { run: mockInputRun }; },
+  },
+}));
+
 // mock 依赖模块
 vi.mock('../../../src/logger/index.js', () => ({
   logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
 }));
 
-vi.mock('../../../src/utils/index.js', () => ({
-  loadConfig: vi.fn(),
-  writeDefaultConfig: vi.fn(),
-  printInfo: vi.fn(),
-  printSuccess: vi.fn(),
-  printSeparator: vi.fn(),
-  confirmDestructiveAction: vi.fn(),
-}));
+vi.mock('../../../src/utils/index.js', async (importOriginal) => {
+  const original = await importOriginal<typeof import('../../../src/utils/index.js')>();
+  return {
+    loadConfig: vi.fn(),
+    writeDefaultConfig: vi.fn(),
+    saveConfig: vi.fn(),
+    printInfo: vi.fn(),
+    printSuccess: vi.fn(),
+    printError: vi.fn(),
+    confirmDestructiveAction: vi.fn(),
+    // 策略工具函数透传真实实现（因为常量已被 mock，工具函数可以正常工作）
+    isValidConfigKey: original.isValidConfigKey,
+    getValidConfigKeys: original.getValidConfigKeys,
+    parseConfigValue: original.parseConfigValue,
+    promptConfigValue: original.promptConfigValue,
+    formatConfigValue: original.formatConfigValue,
+  };
+});
 
 vi.mock('../../../src/constants/index.js', () => ({
   CONFIG_PATH: '/mock/.clawt/config.json',
   DEFAULT_CONFIG: {
-    claudeCodeCommand: 'claude',
     autoDeleteBranch: false,
+    claudeCodeCommand: 'claude',
     autoPullPush: false,
     confirmDestructiveOps: true,
+    maxConcurrency: 0,
+    terminalApp: 'auto',
   },
   CONFIG_DESCRIPTIONS: {
-    claudeCodeCommand: 'Claude Code CLI 命令',
     autoDeleteBranch: '自动删除分支',
+    claudeCodeCommand: 'Claude Code CLI 命令',
     autoPullPush: '自动 pull/push',
     confirmDestructiveOps: '破坏性操作确认',
+    maxConcurrency: '最大并发数',
+    terminalApp: '终端应用',
+  },
+  CONFIG_DEFINITIONS: {
+    autoDeleteBranch: { defaultValue: false, description: '自动删除分支' },
+    claudeCodeCommand: { defaultValue: 'claude', description: 'Claude Code CLI 命令' },
+    autoPullPush: { defaultValue: false, description: '自动 pull/push' },
+    confirmDestructiveOps: { defaultValue: true, description: '破坏性操作确认' },
+    maxConcurrency: { defaultValue: 0, description: '最大并发数' },
+    terminalApp: { defaultValue: 'auto', description: '终端应用', allowedValues: ['auto', 'iterm2', 'terminal'] },
   },
   MESSAGES: {
     CONFIG_RESET_SUCCESS: '配置已恢复为默认值',
     DESTRUCTIVE_OP_CANCELLED: '已取消操作',
+    CONFIG_SET_SUCCESS: (key: string, value: string) => `✓ ${key} 已设置为 ${value}`,
+    CONFIG_GET_VALUE: (key: string, value: string) => `${key} = ${value}`,
+    CONFIG_INVALID_KEY: (key: string, validKeys: string[]) =>
+      `无效的配置项: ${key}\n可用的配置项: ${validKeys.join(', ')}`,
+    CONFIG_INVALID_BOOLEAN: (key: string) =>
+      `配置项 ${key} 为布尔类型，仅接受 true 或 false`,
+    CONFIG_INVALID_NUMBER: (key: string) =>
+      `配置项 ${key} 为数字类型，请输入有效的数字`,
+    CONFIG_INVALID_ENUM: (key: string, validValues: readonly string[]) =>
+      `配置项 ${key} 仅接受以下值: ${validValues.join(', ')}`,
+    CONFIG_SELECT_PROMPT: '选择要修改的配置项',
+    CONFIG_INPUT_PROMPT: (key: string) => `输入 ${key} 的新值`,
+    CONFIG_MISSING_VALUE: (key: string) => `缺少配置值，用法: clawt config set ${key} <value>`,
   },
 }));
 
 import { registerConfigCommand } from '../../../src/commands/config.js';
-import { loadConfig, writeDefaultConfig, printInfo, printSuccess, confirmDestructiveAction } from '../../../src/utils/index.js';
+import { loadConfig, writeDefaultConfig, saveConfig, printInfo, printSuccess, printError, confirmDestructiveAction } from '../../../src/utils/index.js';
 
 const mockedLoadConfig = vi.mocked(loadConfig);
 const mockedWriteDefaultConfig = vi.mocked(writeDefaultConfig);
+const mockedSaveConfig = vi.mocked(saveConfig);
 const mockedPrintInfo = vi.mocked(printInfo);
 const mockedPrintSuccess = vi.mocked(printSuccess);
+const mockedPrintError = vi.mocked(printError);
 const mockedConfirmDestructiveAction = vi.mocked(confirmDestructiveAction);
 
+/** 创建默认配置对象用于 mock */
+function createMockConfig() {
+  return {
+    autoDeleteBranch: false,
+    claudeCodeCommand: 'claude',
+    autoPullPush: false,
+    confirmDestructiveOps: true,
+    maxConcurrency: 0,
+    terminalApp: 'auto',
+  };
+}
+
 beforeEach(() => {
   mockedLoadConfig.mockReset();
   mockedWriteDefaultConfig.mockReset();
+  mockedSaveConfig.mockReset();
   mockedPrintInfo.mockReset();
   mockedPrintSuccess.mockReset();
+  mockedPrintError.mockReset();
   mockedConfirmDestructiveAction.mockReset();
+  mockSelectRun.mockReset();
+  mockInputRun.mockReset();
 });
 
 describe('registerConfigCommand', () => {
-  it('注册 config 命令和 config reset 子命令', () => {
+  it('注册 config 命令及所有子命令', () => {
     const program = new Command();
     registerConfigCommand(program);
     const configCmd = program.commands.find((c) => c.name() === 'config');
     expect(configCmd).toBeDefined();
-    const resetCmd = configCmd!.commands.find((c) => c.name() === 'reset');
-    expect(resetCmd).toBeDefined();
+
+    const subcommandNames = configCmd!.commands.map((c) => c.name());
+    expect(subcommandNames).toContain('reset');
+    expect(subcommandNames).toContain('set');
+    expect(subcommandNames).toContain('get');
   });
 });
 
 describe('handleConfig（通过 action 间接测试）', () => {
-  it('展示配置列表', () => {
-    mockedLoadConfig.mockReturnValue({
-      claudeCodeCommand: 'claude',
-      autoDeleteBranch: false,
-      autoPullPush: false,
-      confirmDestructiveOps: true,
-    });
+  it('无子命令时进入交互式配置', async () => {
+    mockedLoadConfig.mockReturnValue(createMockConfig());
+    // 第一次 Select.run 选择配置项
+    mockSelectRun.mockResolvedValueOnce('autoDeleteBranch');
+    // 第二次 Select.run 选择布尔值
+    mockSelectRun.mockResolvedValueOnce('true');
 
     const program = new Command();
     program.exitOverride();
     registerConfigCommand(program);
-    program.parse(['config'], { from: 'user' });
+    await program.parseAsync(['config'], { from: 'user' });
 
     expect(mockedLoadConfig).toHaveBeenCalled();
-    // 应输出配置信息
-    expect(mockedPrintInfo).toHaveBeenCalled();
+    expect(mockedSaveConfig).toHaveBeenCalledWith(
+      expect.objectContaining({ autoDeleteBranch: true }),
+    );
+    expect(mockedPrintSuccess).toHaveBeenCalled();
   });
 });
 
@@ -108,3 +179,232 @@ describe('handleConfigReset（通过 action 间接测试）', () => {
     expect(mockedPrintInfo).toHaveBeenCalled();
   });
 });
+
+describe('handleConfigSet — 直接模式', () => {
+  it('设置布尔值 true', async () => {
+    mockedLoadConfig.mockReturnValue(createMockConfig());
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'set', 'autoDeleteBranch', 'true'], { from: 'user' });
+
+    expect(mockedSaveConfig).toHaveBeenCalledWith(
+      expect.objectContaining({ autoDeleteBranch: true }),
+    );
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('设置布尔值 false', async () => {
+    mockedLoadConfig.mockReturnValue({ ...createMockConfig(), confirmDestructiveOps: true });
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'set', 'confirmDestructiveOps', 'false'], { from: 'user' });
+
+    expect(mockedSaveConfig).toHaveBeenCalledWith(
+      expect.objectContaining({ confirmDestructiveOps: false }),
+    );
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('布尔值无效时报错', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'set', 'autoDeleteBranch', 'abc'], { from: 'user' });
+
+    expect(mockedSaveConfig).not.toHaveBeenCalled();
+    expect(mockedPrintError).toHaveBeenCalled();
+  });
+
+  it('设置数字值', async () => {
+    mockedLoadConfig.mockReturnValue(createMockConfig());
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'set', 'maxConcurrency', '4'], { from: 'user' });
+
+    expect(mockedSaveConfig).toHaveBeenCalledWith(
+      expect.objectContaining({ maxConcurrency: 4 }),
+    );
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('数字值无效时报错', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'set', 'maxConcurrency', 'abc'], { from: 'user' });
+
+    expect(mockedSaveConfig).not.toHaveBeenCalled();
+    expect(mockedPrintError).toHaveBeenCalled();
+  });
+
+  it('设置字符串值', async () => {
+    mockedLoadConfig.mockReturnValue(createMockConfig());
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'set', 'claudeCodeCommand', 'cc'], { from: 'user' });
+
+    expect(mockedSaveConfig).toHaveBeenCalledWith(
+      expect.objectContaining({ claudeCodeCommand: 'cc' }),
+    );
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('设置 terminalApp 有效值', async () => {
+    mockedLoadConfig.mockReturnValue(createMockConfig());
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'set', 'terminalApp', 'iterm2'], { from: 'user' });
+
+    expect(mockedSaveConfig).toHaveBeenCalledWith(
+      expect.objectContaining({ terminalApp: 'iterm2' }),
+    );
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('设置 terminalApp 无效值时报错', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'set', 'terminalApp', 'invalid'], { from: 'user' });
+
+    expect(mockedSaveConfig).not.toHaveBeenCalled();
+    expect(mockedPrintError).toHaveBeenCalled();
+  });
+
+  it('无效 key 时报错', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'set', 'foobar', 'true'], { from: 'user' });
+
+    expect(mockedSaveConfig).not.toHaveBeenCalled();
+    expect(mockedPrintError).toHaveBeenCalled();
+  });
+
+  it('缺少 value 参数时报错', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'set', 'autoDeleteBranch'], { from: 'user' });
+
+    expect(mockedSaveConfig).not.toHaveBeenCalled();
+    expect(mockedPrintError).toHaveBeenCalled();
+  });
+});
+
+describe('handleConfigSet — 交互模式', () => {
+  it('交互选择布尔配置项并修改', async () => {
+    mockedLoadConfig.mockReturnValue(createMockConfig());
+    // 第一次 Select.run 选择配置项
+    mockSelectRun.mockResolvedValueOnce('autoDeleteBranch');
+    // 第二次 Select.run 选择布尔值
+    mockSelectRun.mockResolvedValueOnce('true');
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'set'], { from: 'user' });
+
+    expect(mockedSaveConfig).toHaveBeenCalledWith(
+      expect.objectContaining({ autoDeleteBranch: true }),
+    );
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('交互选择数字配置项并修改', async () => {
+    mockedLoadConfig.mockReturnValue(createMockConfig());
+    // 选择配置项
+    mockSelectRun.mockResolvedValueOnce('maxConcurrency');
+    // 输入数字
+    mockInputRun.mockResolvedValueOnce('8');
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'set'], { from: 'user' });
+
+    expect(mockedSaveConfig).toHaveBeenCalledWith(
+      expect.objectContaining({ maxConcurrency: 8 }),
+    );
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('交互选择字符串配置项并修改', async () => {
+    mockedLoadConfig.mockReturnValue(createMockConfig());
+    // 选择配置项
+    mockSelectRun.mockResolvedValueOnce('claudeCodeCommand');
+    // 输入字符串
+    mockInputRun.mockResolvedValueOnce('cc');
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'set'], { from: 'user' });
+
+    expect(mockedSaveConfig).toHaveBeenCalledWith(
+      expect.objectContaining({ claudeCodeCommand: 'cc' }),
+    );
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('交互选择 terminalApp 配置项时使用 Select', async () => {
+    mockedLoadConfig.mockReturnValue(createMockConfig());
+    // 选择配置项
+    mockSelectRun.mockResolvedValueOnce('terminalApp');
+    // 选择 terminalApp 值
+    mockSelectRun.mockResolvedValueOnce('iterm2');
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'set'], { from: 'user' });
+
+    expect(mockedSaveConfig).toHaveBeenCalledWith(
+      expect.objectContaining({ terminalApp: 'iterm2' }),
+    );
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+});
+
+describe('handleConfigGet', () => {
+  it('获取有效配置项的值', () => {
+    mockedLoadConfig.mockReturnValue(createMockConfig());
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    program.parse(['config', 'get', 'maxConcurrency'], { from: 'user' });
+
+    expect(mockedPrintInfo).toHaveBeenCalled();
+  });
+
+  it('获取布尔配置项的值', () => {
+    mockedLoadConfig.mockReturnValue({ ...createMockConfig(), autoDeleteBranch: true });
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    program.parse(['config', 'get', 'autoDeleteBranch'], { from: 'user' });
+
+    expect(mockedPrintInfo).toHaveBeenCalled();
+  });
+
+  it('无效 key 时报错', () => {
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    program.parse(['config', 'get', 'invalidKey'], { from: 'user' });
+
+    expect(mockedPrintError).toHaveBeenCalled();
+  });
+});