fix: address CodeRabbit review feedback for multilingual PR

       - Fix code block language tag in spec (markdownlint MD040)
       - Fix extend mode language selection to prompt user with stored language as default
       - Add tests for extend mode language change scenarios

       Addresses CodeRabbit feedback on PR #300

Author: eust-w

src/core/init.ts

@@ -400,6 +400,11 @@ export class InitCommand {
 
     this.renderBanner(extendMode);
 
+    // Read existing config before language selection to detect language changes
+    const existingConfigBeforeLanguageChange = extendMode 
+      ? await this.readConfigFile(openspecPath)
+      : null;
+
     // Get language configuration first (before AI tool selection)
     const selectedLanguage = await this.getSelectedLanguage(openspecPath, extendMode);
 
@@ -447,7 +452,7 @@ export class InitCommand {
         )
       );
       await this.createDirectoryStructure(openspecPath);
-      await this.ensureTemplateFiles(openspecPath, config);
+      await this.ensureTemplateFiles(openspecPath, config, existingConfigBeforeLanguageChange);
     }
 
     // Step 2: Configure AI tools
@@ -505,27 +510,23 @@ export class InitCommand {
     openspecPath: string,
     extendMode: boolean
   ): Promise<string> {
-    // Try to read existing config first
+    // Non-interactive mode - check for --language flag first
+    const nonInteractiveLanguage = this.resolveLanguageArg();
+    if (nonInteractiveLanguage !== null) {
+      return nonInteractiveLanguage;
+    }
+
+    // Try to read existing config for default value
+    let defaultLanguage = DEFAULT_LANGUAGE;
     if (extendMode) {
       const existingConfig = await this.readConfigFile(openspecPath);
       if (existingConfig?.language) {
-        // In extend mode, use existing language unless explicitly changed
-        const nonInteractiveLanguage = this.resolveLanguageArg();
-        if (nonInteractiveLanguage !== null) {
-          return nonInteractiveLanguage;
-        }
-        return existingConfig.language;
+        defaultLanguage = existingConfig.language;
       }
     }
 
-    // Non-interactive mode
-    const nonInteractiveLanguage = this.resolveLanguageArg();
-    if (nonInteractiveLanguage !== null) {
-      return nonInteractiveLanguage;
-    }
-
-    // Interactive mode - prompt for language
-    return this.promptForLanguage();
+    // Interactive mode - prompt for language with default
+    return this.promptForLanguage(defaultLanguage);
   }
 
   private resolveLanguageArg(): string | null {
@@ -555,7 +556,7 @@ export class InitCommand {
     return language.code;
   }
 
-  private async promptForLanguage(): Promise<string> {
+  private async promptForLanguage(defaultLanguage: string = DEFAULT_LANGUAGE): Promise<string> {
     const { select } = await import('@inquirer/prompts');
 
     const language = await select({
@@ -564,18 +565,23 @@ export class InitCommand {
         name: `${lang.nativeName} (${lang.code})`,
         value: lang.code,
       })),
-      default: DEFAULT_LANGUAGE,
+      default: defaultLanguage,
     });
 
     return language;
   }
 
-  private async readConfigFile(openspecPath: string): Promise<{ language?: string } | null> {
+  private async readConfigFile(
+    openspecPath: string
+  ): Promise<Partial<OpenSpecConfig> | null> {
     const configPath = path.join(openspecPath, CONFIG_FILE_NAME);
-    return await FileSystemUtils.readJsonFile<{ language?: string }>(configPath);
+    return await FileSystemUtils.readJsonFile<Partial<OpenSpecConfig>>(configPath);
   }
 
-  private async saveConfigFile(openspecPath: string, config: { language?: string }): Promise<void> {
+  private async saveConfigFile(
+    openspecPath: string,
+    config: Partial<OpenSpecConfig>
+  ): Promise<void> {
     const configPath = path.join(openspecPath, CONFIG_FILE_NAME);
     const existingConfig = await this.readConfigFile(openspecPath) || {};
     const mergedConfig = { ...existingConfig, ...config };
@@ -829,9 +835,19 @@ export class InitCommand {
 
   private async ensureTemplateFiles(
     openspecPath: string,
-    config: OpenSpecConfig
+    config: OpenSpecConfig,
+    previousConfig: Partial<OpenSpecConfig> | null = null
   ): Promise<void> {
-    await this.writeTemplateFiles(openspecPath, config, true);
+    // Check if language has changed - if so, regenerate templates
+    // Use previousConfig if provided (read before language was saved), otherwise read from file
+    const existingConfig =
+      previousConfig || (await this.readConfigFile(openspecPath));
+    const languageChanged = existingConfig?.language && 
+                            existingConfig.language !== config.language;
+    
+    // If language changed, force regeneration (skipExisting = false)
+    // Otherwise, skip existing files to preserve user modifications
+    await this.writeTemplateFiles(openspecPath, config, !languageChanged);
   }
 
   private async writeTemplateFiles(
@@ -1074,3 +1090,4 @@ export class InitCommand {
     }).start();
   }
 }
+

test/core/init.test.ts

@@ -4,6 +4,16 @@ import path from 'path';
 import os from 'os';
 import { InitCommand } from '../../src/core/init.js';
 
+// Mock @inquirer/prompts for language selection
+const mockSelect = vi.fn();
+vi.mock('@inquirer/prompts', async () => {
+  const actual = await vi.importActual('@inquirer/prompts');
+  return {
+    ...actual,
+    select: mockSelect,
+  };
+});
+
 const DONE = '__done__';
 
 type SelectionQueue = string[][];
@@ -43,6 +53,7 @@ describe('InitCommand', () => {
     await fs.mkdir(testDir, { recursive: true });
     selectionQueue = [];
     mockPrompt.mockReset();
+    mockSelect.mockReset();
     initCommand = new InitCommand({ prompt: mockPrompt });
 
     // Route Codex global directory into the test sandbox
@@ -51,6 +62,11 @@ describe('InitCommand', () => {
 
     // Mock console.log to suppress output during tests
     vi.spyOn(console, 'log').mockImplementation(() => {});
+    
+    // Default language selection mock - return default language unless overridden
+    mockSelect.mockImplementation(async (options: any) => {
+      return options.default || 'en-US';
+    });
   });
 
   afterEach(async () => {
@@ -1296,22 +1312,61 @@ describe('InitCommand', () => {
       expect(projectContent).toContain('Project Context');
     });
 
-    it('should read existing language config in extend mode', async () => {
+    it('should read existing language config in extend mode and allow changing', async () => {
       // First init with Chinese
       const firstCommand = new InitCommand({ tools: 'none', language: 'zh-CN' });
       await firstCommand.execute(testDir);
 
-      // Second init in extend mode should use existing language
+      // Second init in extend mode - should prompt with Chinese as default, but allow changing
+      // Mock language selection to return French (fr-FR)
+      mockSelect.mockResolvedValueOnce('fr-FR');
       queueSelections(DONE);
       await initCommand.execute(testDir);
 
+      // Verify language was changed to French
+      const configPath = path.join(testDir, 'openspec', 'config.json');
+      const configContent = await fs.readFile(configPath, 'utf-8');
+      const config = JSON.parse(configContent);
+      expect(config.language).toBe('fr-FR');
+
+      // Verify French templates were used
       const projectPath = path.join(testDir, 'openspec', 'project.md');
       const projectContent = await fs.readFile(projectPath, 'utf-8');
-      // Should still be Chinese (though file might not be regenerated in extend mode)
+      expect(projectContent).toContain('Contexte');
+      
+      // Verify language prompt was called with Chinese as default
+      expect(mockSelect).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: 'Select your preferred language:',
+          default: 'zh-CN',
+        })
+      );
+    });
+
+    it('should use existing language as default in extend mode when user confirms', async () => {
+      // First init with Japanese
+      const firstCommand = new InitCommand({ tools: 'none', language: 'ja-JP' });
+      await firstCommand.execute(testDir);
+
+      // Second init in extend mode - user confirms default (Japanese)
+      // Mock language selection to return Japanese (default)
+      mockSelect.mockResolvedValueOnce('ja-JP');
+      queueSelections(DONE);
+      await initCommand.execute(testDir);
+
+      // Verify language remains Japanese
       const configPath = path.join(testDir, 'openspec', 'config.json');
       const configContent = await fs.readFile(configPath, 'utf-8');
       const config = JSON.parse(configContent);
-      expect(config.language).toBe('zh-CN');
+      expect(config.language).toBe('ja-JP');
+      
+      // Verify language prompt was called with Japanese as default
+      expect(mockSelect).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: 'Select your preferred language:',
+          default: 'ja-JP',
+        })
+      );
     });
 
     it('should use French templates when language is fr-FR', async () => {