feat(rules): allow agent language to follow project config

- Override agent's communication.language with codingbuddy.config.js language setting at runtime. This enables consistent language responses across all agents based on project configuration.

close #220

Author: JeremyDev87

apps/mcp-server/src/rules/rules.service.spec.ts

@@ -28,10 +28,11 @@ const createMockCustomService = (): CustomService =>
   }) as unknown as CustomService;
 
 // Create a mock ConfigService
-const createMockConfigService = (): ConfigService =>
+const createMockConfigService = (language?: string): ConfigService =>
   ({
     getProjectRoot: vi.fn().mockReturnValue('/test/project'),
     getSettings: vi.fn().mockResolvedValue({}),
+    getLanguage: vi.fn().mockResolvedValue(language),
   }) as unknown as ConfigService;
 
 describe('RulesService', () => {
@@ -307,6 +308,141 @@ describe('RulesService', () => {
         'Failed to read rule file',
       );
     });
+
+    describe('language override from config', () => {
+      it('should override communication.language with config language', async () => {
+        const mockAgent = {
+          name: 'Frontend Developer',
+          description: 'Frontend development specialist',
+          role: {
+            title: 'Senior Frontend Developer',
+            expertise: ['React', 'TypeScript'],
+          },
+          communication: {
+            language: 'en',
+            style: 'Technical and precise',
+          },
+        };
+        vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockAgent));
+
+        // Create service with config language 'ko'
+        const serviceWithLang = new RulesService(
+          createMockCustomService(),
+          createMockConfigService('ko'),
+        );
+
+        const result = await serviceWithLang.getAgent('frontend-developer');
+
+        expect(result.communication?.language).toBe('ko');
+        // Other communication properties should be preserved
+        expect(result.communication?.style).toBe('Technical and precise');
+      });
+
+      it('should preserve agent language when config has no language', async () => {
+        const mockAgent = {
+          name: 'Frontend Developer',
+          description: 'Frontend development specialist',
+          role: {
+            title: 'Senior Frontend Developer',
+            expertise: ['React', 'TypeScript'],
+          },
+          communication: {
+            language: 'en',
+          },
+        };
+        vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockAgent));
+
+        // Create service with no config language
+        const serviceWithoutLang = new RulesService(
+          createMockCustomService(),
+          createMockConfigService(undefined),
+        );
+
+        const result = await serviceWithoutLang.getAgent('frontend-developer');
+
+        expect(result.communication?.language).toBe('en');
+      });
+
+      it('should create communication object with config language when agent has none', async () => {
+        const mockAgent = {
+          name: 'Frontend Developer',
+          description: 'Frontend development specialist',
+          role: {
+            title: 'Senior Frontend Developer',
+            expertise: ['React', 'TypeScript'],
+          },
+          // No communication field
+        };
+        vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockAgent));
+
+        // Create service with config language 'ja'
+        const serviceWithLang = new RulesService(
+          createMockCustomService(),
+          createMockConfigService('ja'),
+        );
+
+        const result = await serviceWithLang.getAgent('frontend-developer');
+
+        expect(result.communication?.language).toBe('ja');
+      });
+
+      it('should not modify agent when config language is undefined and agent has no communication', async () => {
+        const mockAgent = {
+          name: 'Frontend Developer',
+          description: 'Frontend development specialist',
+          role: {
+            title: 'Senior Frontend Developer',
+            expertise: ['React', 'TypeScript'],
+          },
+          // No communication field
+        };
+        vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockAgent));
+
+        // Create service without config language
+        const serviceWithoutLang = new RulesService(
+          createMockCustomService(),
+          createMockConfigService(undefined),
+        );
+
+        const result = await serviceWithoutLang.getAgent('frontend-developer');
+
+        expect(result.communication).toBeUndefined();
+      });
+
+      it('should return agent with original language when getLanguage() fails', async () => {
+        const mockAgent = {
+          name: 'Frontend Developer',
+          description: 'Frontend development specialist',
+          role: {
+            title: 'Senior Frontend Developer',
+            expertise: ['React', 'TypeScript'],
+          },
+          communication: {
+            language: 'en',
+            style: 'Technical and precise',
+          },
+        };
+        vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockAgent));
+
+        // Create service with failing getLanguage
+        const failingConfigService = {
+          getProjectRoot: vi.fn().mockReturnValue('/test/project'),
+          getSettings: vi.fn().mockResolvedValue({}),
+          getLanguage: vi.fn().mockRejectedValue(new Error('Config error')),
+        } as unknown as ConfigService;
+
+        const serviceWithError = new RulesService(
+          createMockCustomService(),
+          failingConfigService,
+        );
+
+        const result = await serviceWithError.getAgent('frontend-developer');
+
+        // Should still return agent with original language
+        expect(result.communication?.language).toBe('en');
+        expect(result.communication?.style).toBe('Technical and precise');
+      });
+    });
   });
 
   describe('searchRules', () => {

apps/mcp-server/src/rules/rules.service.ts

@@ -128,7 +128,27 @@ export class RulesService {
       // Validate against schema and check for prototype pollution
       const validated = parseAgentProfile(parsed);
       // Add source field for default agents
-      return { ...(validated as unknown as AgentProfile), source: 'default' };
+      const agent: AgentProfile = {
+        ...(validated as unknown as AgentProfile),
+        source: 'default',
+      };
+
+      // Override communication.language with config language if available
+      try {
+        const configLanguage = await this.configService.getLanguage();
+        if (configLanguage) {
+          agent.communication = {
+            ...agent.communication,
+            language: configLanguage,
+          };
+        }
+      } catch (error) {
+        this.logger.warn(
+          `Failed to get config language for agent '${name}', using agent default: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        );
+      }
+
+      return agent;
     } catch (error) {
       if (error instanceof AgentSchemaError) {
         this.logger.warn(`Invalid agent profile: ${name}`, error.message);

apps/mcp-server/src/rules/rules.types.ts

@@ -1,5 +1,12 @@
 export type RuleSource = 'custom' | 'default';
 
+export interface AgentCommunication {
+  language?: string;
+  style?: string;
+  approach?: string[];
+  [key: string]: unknown; // Allow additional fields for extensibility
+}
+
 export interface AgentProfile {
   name: string;
   description: string;
@@ -9,6 +16,7 @@ export interface AgentProfile {
     tech_stack_reference?: string;
     responsibilities?: string[];
   };
+  communication?: AgentCommunication;
   source?: RuleSource;
   [key: string]: unknown; // Allow additional fields (passthrough)
 }