feat(config): implement config file loader, ignore parser, and context loader

- Load codingbuddy.config.{js,mjs,json} with validation
- Parse .codingignore files with gitignore-style patterns
- Load .codingbuddy/ directory files (context, prompts, agents)
- Add NestJS ConfigService integrating all loaders
- Add comprehensive test coverage

close #20

Author: wishket-pjw

mcp-server/src/config/config.loader.spec.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect } from 'vitest';
+import {
+  CONFIG_FILE_NAMES,
+  ConfigLoadError,
+  validateAndTransform,
+} from './config.loader';
+
+describe('config.loader', () => {
+  describe('CONFIG_FILE_NAMES', () => {
+    it('should have correct priority order', () => {
+      expect(CONFIG_FILE_NAMES[0]).toBe('codingbuddy.config.js');
+      expect(CONFIG_FILE_NAMES[1]).toBe('codingbuddy.config.mjs');
+      expect(CONFIG_FILE_NAMES[2]).toBe('codingbuddy.config.json');
+    });
+
+    it('should have 3 supported file names', () => {
+      expect(CONFIG_FILE_NAMES).toHaveLength(3);
+    });
+  });
+
+  describe('ConfigLoadError', () => {
+    it('should create error with message and file path', () => {
+      const error = new ConfigLoadError('Test error', '/path/to/config.js');
+
+      expect(error.message).toBe('Test error');
+      expect(error.filePath).toBe('/path/to/config.js');
+      expect(error.name).toBe('ConfigLoadError');
+    });
+
+    it('should include cause when provided', () => {
+      const cause = new Error('Original error');
+      const error = new ConfigLoadError('Wrapped error', '/path/to/config.js', cause);
+
+      expect(error.cause).toBe(cause);
+    });
+
+    it('should be instanceof Error', () => {
+      const error = new ConfigLoadError('Test', '/path');
+      expect(error).toBeInstanceOf(Error);
+    });
+  });
+
+  describe('validateAndTransform', () => {
+    it('should accept valid config', () => {
+      const raw = {
+        language: 'ko',
+        projectName: 'test-project',
+        techStack: {
+          frontend: ['React'],
+        },
+      };
+
+      const result = validateAndTransform(raw, '/path/config.json');
+
+      expect(result.config.language).toBe('ko');
+      expect(result.config.projectName).toBe('test-project');
+      expect(result.config.techStack?.frontend).toEqual(['React']);
+      expect(result.warnings).toEqual([]);
+    });
+
+    it('should accept empty config', () => {
+      const result = validateAndTransform({}, '/path/config.json');
+
+      expect(result.config).toEqual({});
+      expect(result.warnings).toEqual([]);
+    });
+
+    it('should throw ConfigLoadError for invalid config', () => {
+      const raw = {
+        testStrategy: {
+          coverage: 200, // invalid: max 100
+        },
+      };
+
+      expect(() => validateAndTransform(raw, '/path/config.json')).toThrow(ConfigLoadError);
+    });
+
+    it('should include field path in error message', () => {
+      const raw = {
+        conventions: {
+          naming: {
+            files: 'invalid-value',
+          },
+        },
+      };
+
+      try {
+        validateAndTransform(raw, '/path/config.json');
+        expect.fail('Should have thrown');
+      } catch (error) {
+        expect(error).toBeInstanceOf(ConfigLoadError);
+        expect((error as ConfigLoadError).message).toContain('conventions');
+      }
+    });
+
+    it('should throw ConfigLoadError for invalid URL in repository', () => {
+      const raw = {
+        repository: 'not-a-valid-url',
+      };
+
+      expect(() => validateAndTransform(raw, '/path/config.json')).toThrow(ConfigLoadError);
+    });
+  });
+});

mcp-server/src/config/config.loader.ts

@@ -0,0 +1,179 @@
+import * as fs from 'fs/promises';
+import { existsSync } from 'fs';
+import * as path from 'path';
+import { pathToFileURL } from 'url';
+import { validateConfig, type CodingBuddyConfig } from './config.schema';
+
+/**
+ * Supported config file names in priority order
+ */
+export const CONFIG_FILE_NAMES = [
+  'codingbuddy.config.js',
+  'codingbuddy.config.mjs',
+  'codingbuddy.config.json',
+] as const;
+
+/**
+ * Result of loading a config file
+ */
+export interface ConfigLoadResult {
+  /** Loaded and validated configuration */
+  config: CodingBuddyConfig;
+  /** Path to the loaded config file (null if no file found) */
+  source: string | null;
+  /** Warning messages (e.g., validation issues that were auto-fixed) */
+  warnings: string[];
+}
+
+/**
+ * Error thrown when config loading fails
+ */
+export class ConfigLoadError extends Error {
+  constructor(
+    message: string,
+    public readonly filePath: string,
+    public readonly cause?: Error,
+  ) {
+    super(message);
+    this.name = 'ConfigLoadError';
+  }
+}
+
+/**
+ * Find the config file in the project root
+ */
+export function findConfigFile(projectRoot: string): string | null {
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const filePath = path.join(projectRoot, fileName);
+    if (existsSync(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+}
+
+/**
+ * Load a JavaScript/ESM config file using dynamic import
+ */
+export async function loadJsConfig(filePath: string): Promise<unknown> {
+  try {
+    // Convert to file:// URL for cross-platform compatibility (Windows/Unix)
+    const fileUrl = pathToFileURL(filePath).href;
+    const module = await import(fileUrl);
+
+    // Handle both default export and module.exports
+    return module.default ?? module;
+  } catch (error) {
+    throw new ConfigLoadError(
+      `Failed to load JavaScript config: ${error instanceof Error ? error.message : String(error)}`,
+      filePath,
+      error instanceof Error ? error : undefined,
+    );
+  }
+}
+
+/**
+ * Load a JSON config file
+ */
+export async function loadJsonConfig(filePath: string): Promise<unknown> {
+  try {
+    const content = await fs.readFile(filePath, 'utf-8');
+    return JSON.parse(content);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new ConfigLoadError(
+        `Invalid JSON in config file: ${error.message}`,
+        filePath,
+        error,
+      );
+    }
+    throw new ConfigLoadError(
+      `Failed to read config file: ${error instanceof Error ? error.message : String(error)}`,
+      filePath,
+      error instanceof Error ? error : undefined,
+    );
+  }
+}
+
+/**
+ * Load config from a file path (auto-detects format)
+ */
+export async function loadConfigFromFile(filePath: string): Promise<unknown> {
+  const ext = path.extname(filePath).toLowerCase();
+
+  if (ext === '.json') {
+    return loadJsonConfig(filePath);
+  }
+
+  if (ext === '.js' || ext === '.mjs') {
+    return loadJsConfig(filePath);
+  }
+
+  throw new ConfigLoadError(
+    `Unsupported config file format: ${ext}`,
+    filePath,
+  );
+}
+
+/**
+ * Validate and transform raw config into CodingBuddyConfig
+ */
+export function validateAndTransform(
+  raw: unknown,
+  filePath: string,
+): { config: CodingBuddyConfig; warnings: string[] } {
+  const result = validateConfig(raw);
+
+  if (!result.success) {
+    const errorMessages = result.errors!
+      .map((e) => `  - ${e.path}: ${e.message}`)
+      .join('\n');
+
+    throw new ConfigLoadError(
+      `Invalid configuration:\n${errorMessages}`,
+      filePath,
+    );
+  }
+
+  return {
+    config: result.data!,
+    warnings: [],
+  };
+}
+
+/**
+ * Load project configuration from the specified root directory
+ *
+ * @param projectRoot - Project root directory (defaults to process.cwd())
+ * @returns Loaded configuration with metadata
+ */
+export async function loadConfig(projectRoot?: string): Promise<ConfigLoadResult> {
+  const root = projectRoot ?? process.cwd();
+  const configPath = findConfigFile(root);
+
+  // No config file found - return empty config
+  if (!configPath) {
+    return {
+      config: {},
+      source: null,
+      warnings: [],
+    };
+  }
+
+  // Load and validate config
+  const raw = await loadConfigFromFile(configPath);
+  const { config, warnings } = validateAndTransform(raw, configPath);
+
+  return {
+    config,
+    source: configPath,
+    warnings,
+  };
+}
+
+/**
+ * Check if a config file exists in the project root
+ */
+export function hasConfigFile(projectRoot: string): boolean {
+  return findConfigFile(projectRoot) !== null;
+}

mcp-server/src/config/config.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { ConfigService } from './config.service';
+
+@Module({
+  providers: [ConfigService],
+  exports: [ConfigService],
+})
+export class CodingBuddyConfigModule {}