feat: improve CLI initialization and add new agents

- Add language and Primary Agent selection to CLI init command, add data-engineer/mobile-developer/i18n-specialist agents, and improve agent resolution logic

close #151

Author: wishket-pjw

apps/mcp-server/src/cli/init/init.command.spec.ts

@@ -13,6 +13,8 @@ const {
   mockRenderConfigAsJs,
   mockRenderConfigAsJson,
   mockPromptModelSelection,
+  mockPromptLanguageSelection,
+  mockPromptPrimaryAgentSelection,
 } = vi.hoisted(() => ({
   mockAnalyzeProject: vi.fn(),
   mockGenerate: vi.fn(),
@@ -22,6 +24,8 @@ const {
   mockRenderConfigAsJs: vi.fn(),
   mockRenderConfigAsJson: vi.fn(),
   mockPromptModelSelection: vi.fn(),
+  mockPromptLanguageSelection: vi.fn(),
+  mockPromptPrimaryAgentSelection: vi.fn(),
 }));
 
 // Mock all modules
@@ -50,7 +54,11 @@ vi.mock('./templates', () => ({
 
 vi.mock('./prompts', () => ({
   promptModelSelection: mockPromptModelSelection,
+  promptLanguageSelection: mockPromptLanguageSelection,
+  promptPrimaryAgentSelection: mockPromptPrimaryAgentSelection,
   DEFAULT_MODEL_CHOICE: 'claude-sonnet-4-20250514',
+  DEFAULT_LANGUAGE: 'ko',
+  DEFAULT_PRIMARY_AGENT: 'frontend-developer',
 }));
 
 vi.mock('../utils/console', () => ({
@@ -130,6 +138,8 @@ describe('init.command', () => {
     mockRenderConfigAsJs.mockReturnValue('// rendered config');
     mockRenderConfigAsJson.mockReturnValue('{}');
     mockPromptModelSelection.mockResolvedValue('claude-sonnet-4-20250514');
+    mockPromptLanguageSelection.mockResolvedValue('ko');
+    mockPromptPrimaryAgentSelection.mockResolvedValue('frontend-developer');
   });
 
   describe('getApiKey', () => {
@@ -246,12 +256,13 @@ describe('init.command', () => {
       );
     });
 
-    it('should pass language option to renderer', async () => {
+    it('should pass language option to renderer when skipPrompts', async () => {
       const options: InitOptions = {
         projectRoot: '/project',
         format: 'js',
         force: false,
         language: 'en',
+        skipPrompts: true,
       };
 
       await runInit(options);
@@ -262,7 +273,7 @@ describe('init.command', () => {
       );
     });
 
-    it('should call promptModelSelection when skipPrompts is false', async () => {
+    it('should call all prompts when skipPrompts is false', async () => {
       const options: InitOptions = {
         projectRoot: '/project',
         format: 'js',
@@ -272,10 +283,12 @@ describe('init.command', () => {
 
       await runInit(options);
 
+      expect(mockPromptLanguageSelection).toHaveBeenCalled();
+      expect(mockPromptPrimaryAgentSelection).toHaveBeenCalled();
       expect(mockPromptModelSelection).toHaveBeenCalled();
     });
 
-    it('should skip promptModelSelection when skipPrompts is true', async () => {
+    it('should skip all prompts when skipPrompts is true', async () => {
       const options: InitOptions = {
         projectRoot: '/project',
         format: 'js',
@@ -285,10 +298,14 @@ describe('init.command', () => {
 
       await runInit(options);
 
+      expect(mockPromptLanguageSelection).not.toHaveBeenCalled();
+      expect(mockPromptPrimaryAgentSelection).not.toHaveBeenCalled();
       expect(mockPromptModelSelection).not.toHaveBeenCalled();
     });
 
-    it('should pass selected model to renderer', async () => {
+    it('should pass selected values to renderer', async () => {
+      mockPromptLanguageSelection.mockResolvedValue('ja');
+      mockPromptPrimaryAgentSelection.mockResolvedValue('backend-developer');
       mockPromptModelSelection.mockResolvedValue('claude-opus-4-20250514');
 
       const options: InitOptions = {
@@ -302,11 +319,15 @@ describe('init.command', () => {
 
       expect(mockRenderConfigAsJs).toHaveBeenCalledWith(
         mockTemplateResult.template,
-        expect.objectContaining({ defaultModel: 'claude-opus-4-20250514' }),
+        expect.objectContaining({
+          language: 'ja',
+          primaryAgent: 'backend-developer',
+          defaultModel: 'claude-opus-4-20250514',
+        }),
       );
     });
 
-    it('should use default model when skipPrompts is true', async () => {
+    it('should use default values when skipPrompts is true', async () => {
       const options: InitOptions = {
         projectRoot: '/project',
         format: 'js',
@@ -318,7 +339,11 @@ describe('init.command', () => {
 
       expect(mockRenderConfigAsJs).toHaveBeenCalledWith(
         mockTemplateResult.template,
-        expect.objectContaining({ defaultModel: 'claude-sonnet-4-20250514' }),
+        expect.objectContaining({
+          language: 'ko',
+          primaryAgent: 'frontend-developer',
+          defaultModel: 'claude-sonnet-4-20250514',
+        }),
       );
     });
   });

apps/mcp-server/src/cli/init/init.command.ts

@@ -15,7 +15,14 @@ import {
   renderConfigAsJs,
   renderConfigAsJson,
 } from './templates';
-import { promptModelSelection, DEFAULT_MODEL_CHOICE } from './prompts';
+import {
+  promptModelSelection,
+  promptLanguageSelection,
+  promptPrimaryAgentSelection,
+  DEFAULT_MODEL_CHOICE,
+  DEFAULT_LANGUAGE,
+  DEFAULT_PRIMARY_AGENT,
+} from './prompts';
 import type { InitOptions, InitResult } from '../cli.types';
 
 /**
@@ -69,10 +76,24 @@ async function runTemplateInit(
     console.log.info(`  Detected: ${detectedFrameworks.join(', ')}`);
   }
 
-  // Step 3: Select AI model
+  // Step 3: Interactive prompts
+  let selectedLanguage = options.language ?? DEFAULT_LANGUAGE;
   let selectedModel = DEFAULT_MODEL_CHOICE;
+  let selectedAgent = DEFAULT_PRIMARY_AGENT;
+
   const shouldPrompt = !(options.skipPrompts ?? false);
   if (shouldPrompt) {
+    // 3a: Language selection
+    console.log.step('🌐', 'Select response language...');
+    selectedLanguage = await promptLanguageSelection();
+    console.log.success(`Language: ${selectedLanguage}`);
+
+    // 3b: Primary agent selection
+    console.log.step('👤', 'Select primary development agent...');
+    selectedAgent = await promptPrimaryAgentSelection();
+    console.log.success(`Agent: ${selectedAgent}`);
+
+    // 3c: AI model selection
     console.log.step('🤖', 'Select AI model...');
     selectedModel = await promptModelSelection();
     console.log.success(`Model: ${selectedModel}`);
@@ -84,8 +105,9 @@ async function runTemplateInit(
   const projectName = analysis.packageInfo?.name;
   const renderOptions = {
     projectName,
-    language: options.language,
+    language: selectedLanguage,
     defaultModel: selectedModel,
+    primaryAgent: selectedAgent,
   };
 
   const configContent =

apps/mcp-server/src/cli/init/prompts/agent-prompt.spec.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import { getPrimaryAgentChoices, DEFAULT_PRIMARY_AGENT } from './agent-prompt';
+import { ACT_PRIMARY_AGENTS } from '../../../keyword/keyword.types';
+
+describe('agent-prompt', () => {
+  describe('DEFAULT_PRIMARY_AGENT', () => {
+    it('should be frontend-developer', () => {
+      expect(DEFAULT_PRIMARY_AGENT).toBe('frontend-developer');
+    });
+  });
+
+  describe('getPrimaryAgentChoices', () => {
+    it('should return an array of agent choices', () => {
+      const choices = getPrimaryAgentChoices();
+      expect(Array.isArray(choices)).toBe(true);
+      expect(choices.length).toBeGreaterThan(0);
+    });
+
+    it('should include all ACT primary agents', () => {
+      const choices = getPrimaryAgentChoices();
+      const values = choices.map(c => c.value);
+
+      for (const agent of ACT_PRIMARY_AGENTS) {
+        expect(values).toContain(agent);
+      }
+    });
+
+    it('should have name and value for each choice', () => {
+      const choices = getPrimaryAgentChoices();
+      for (const choice of choices) {
+        expect(choice.name).toBeDefined();
+        expect(choice.value).toBeDefined();
+        expect(typeof choice.name).toBe('string');
+        expect(typeof choice.value).toBe('string');
+      }
+    });
+
+    it('should include frontend-developer with recommended label', () => {
+      const choices = getPrimaryAgentChoices();
+      const frontend = choices.find(c => c.value === 'frontend-developer');
+      expect(frontend).toBeDefined();
+      expect(frontend?.name).toContain('Recommended');
+    });
+
+    it('should include descriptions for agents', () => {
+      const choices = getPrimaryAgentChoices();
+      const withDescriptions = choices.filter(c => c.description);
+      expect(withDescriptions.length).toBeGreaterThan(0);
+    });
+
+    it('should include new primary agents (data-engineer, mobile-developer)', () => {
+      const choices = getPrimaryAgentChoices();
+      const values = choices.map(c => c.value);
+
+      expect(values).toContain('data-engineer');
+      expect(values).toContain('mobile-developer');
+    });
+  });
+});

apps/mcp-server/src/cli/init/prompts/agent-prompt.ts

@@ -0,0 +1,59 @@
+/**
+ * Primary Agent Selection Prompt
+ *
+ * Interactive CLI prompt for primary development agent selection
+ */
+
+import { select } from '@inquirer/prompts';
+import {
+  ACT_PRIMARY_AGENTS,
+  DEFAULT_ACT_AGENT,
+  ACT_AGENT_DISPLAY_INFO,
+  type ActPrimaryAgent,
+} from '../../../keyword/keyword.types';
+
+/**
+ * Agent choice option for the CLI prompt
+ */
+export interface AgentChoice {
+  name: string;
+  value: string;
+  description?: string;
+}
+
+/**
+ * Default primary agent - re-exported from keyword.types for backward compatibility
+ */
+export const DEFAULT_PRIMARY_AGENT = DEFAULT_ACT_AGENT;
+
+/**
+ * Get available primary agent choices for the CLI prompt
+ */
+export function getPrimaryAgentChoices(): AgentChoice[] {
+  return ACT_PRIMARY_AGENTS.map(agentId => {
+    const info = ACT_AGENT_DISPLAY_INFO[agentId as ActPrimaryAgent];
+    const isDefault = agentId === DEFAULT_PRIMARY_AGENT;
+    return {
+      name: isDefault ? `${info.name} (Recommended)` : info.name,
+      value: agentId,
+      description: info.description,
+    };
+  });
+}
+
+/**
+ * Prompt user to select primary development agent
+ * @param message - Custom message for the prompt
+ * @returns Selected agent ID
+ */
+export async function promptPrimaryAgentSelection(
+  message = 'Select your primary development agent:',
+): Promise<string> {
+  const choices = getPrimaryAgentChoices();
+
+  return select({
+    message,
+    choices,
+    default: DEFAULT_PRIMARY_AGENT,
+  });
+}

apps/mcp-server/src/cli/init/prompts/index.ts

@@ -11,3 +11,19 @@ export {
 } from './model-prompt';
 
 export type { ModelChoice } from './model-prompt';
+
+export {
+  getLanguageChoices,
+  promptLanguageSelection,
+  DEFAULT_LANGUAGE,
+} from './language-prompt';
+
+export type { LanguageChoice } from './language-prompt';
+
+export {
+  getPrimaryAgentChoices,
+  promptPrimaryAgentSelection,
+  DEFAULT_PRIMARY_AGENT,
+} from './agent-prompt';
+
+export type { AgentChoice } from './agent-prompt';

apps/mcp-server/src/cli/init/prompts/language-prompt.spec.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect } from 'vitest';
+import { getLanguageChoices, DEFAULT_LANGUAGE } from './language-prompt';
+
+describe('language-prompt', () => {
+  describe('DEFAULT_LANGUAGE', () => {
+    it('should be Korean (ko)', () => {
+      expect(DEFAULT_LANGUAGE).toBe('ko');
+    });
+  });
+
+  describe('getLanguageChoices', () => {
+    it('should return an array of language choices', () => {
+      const choices = getLanguageChoices();
+      expect(Array.isArray(choices)).toBe(true);
+      expect(choices.length).toBeGreaterThan(0);
+    });
+
+    it('should include Korean as first option', () => {
+      const choices = getLanguageChoices();
+      expect(choices[0].value).toBe('ko');
+      expect(choices[0].name).toContain('Korean');
+    });
+
+    it('should include English option', () => {
+      const choices = getLanguageChoices();
+      const english = choices.find(c => c.value === 'en');
+      expect(english).toBeDefined();
+      expect(english?.name).toBe('English');
+    });
+
+    it('should have name, value, and description for each choice', () => {
+      const choices = getLanguageChoices();
+      for (const choice of choices) {
+        expect(choice.name).toBeDefined();
+        expect(choice.value).toBeDefined();
+        expect(typeof choice.name).toBe('string');
+        expect(typeof choice.value).toBe('string');
+      }
+    });
+
+    it('should include all supported languages', () => {
+      const choices = getLanguageChoices();
+      const values = choices.map(c => c.value);
+      expect(values).toContain('ko');
+      expect(values).toContain('en');
+      expect(values).toContain('ja');
+      expect(values).toContain('zh');
+      expect(values).toContain('es');
+    });
+  });
+});