gencode-ai 0.1.1 → 0.1.2

package/src/config/manager.test.ts

@@ -0,0 +1,215 @@
+/**
+ * ConfigManager Tests
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { ConfigManager } from './manager.js';
+import { createTestProject, writeSettings, type TestProject } from './test-utils.js';
+
+describe('ConfigManager', () => {
+  let test: TestProject;
+
+  beforeEach(async () => {
+    test = await createTestProject('gencode-config-');
+  });
+
+  afterEach(() => test.cleanup());
+
+  describe('load', () => {
+    it('should load settings from .gencode directory', async () => {
+      await writeSettings(test.projectDir, 'gencode', { provider: 'anthropic', model: 'claude-sonnet' });
+
+      const config = await new ConfigManager({ cwd: test.projectDir }).load();
+
+      expect(config.settings.provider).toBe('anthropic');
+      expect(config.settings.model).toBe('claude-sonnet');
+    });
+
+    it('should load settings from .claude directory', async () => {
+      await writeSettings(test.projectDir, 'claude', { provider: 'openai', model: 'gpt-4' });
+
+      const config = await new ConfigManager({ cwd: test.projectDir }).load();
+
+      expect(config.settings.provider).toBe('openai');
+      expect(config.settings.model).toBe('gpt-4');
+    });
+
+    it('should merge both .claude and .gencode with gencode winning', async () => {
+      await writeSettings(test.projectDir, 'claude', { provider: 'openai', model: 'gpt-4', theme: 'dark' });
+      await writeSettings(test.projectDir, 'gencode', { provider: 'anthropic' });
+
+      const config = await new ConfigManager({ cwd: test.projectDir }).load();
+
+      expect(config.settings.provider).toBe('anthropic'); // gencode wins
+      expect(config.settings.model).toBe('gpt-4'); // preserved from claude
+      expect(config.settings.theme).toBe('dark'); // preserved from claude
+    });
+
+    it('should concatenate permission arrays from both namespaces', async () => {
+      await writeSettings(test.projectDir, 'claude', {
+        permissions: { allow: ['Bash(git:*)'], deny: ['WebFetch'] },
+      });
+      await writeSettings(test.projectDir, 'gencode', {
+        permissions: { allow: ['Bash(npm:*)'], deny: ['Bash(rm -rf:*)'] },
+      });
+
+      const { settings } = await new ConfigManager({ cwd: test.projectDir }).load();
+
+      expect(settings.permissions?.allow).toContain('Bash(git:*)');
+      expect(settings.permissions?.allow).toContain('Bash(npm:*)');
+      expect(settings.permissions?.deny).toContain('WebFetch');
+      expect(settings.permissions?.deny).toContain('Bash(rm -rf:*)');
+    });
+
+    it('should load local settings with higher priority', async () => {
+      await writeSettings(test.projectDir, 'gencode', { model: 'claude-sonnet', theme: 'light' });
+      await writeSettings(test.projectDir, 'gencode', { model: 'claude-opus' }, true);
+
+      const { settings } = await new ConfigManager({ cwd: test.projectDir }).load();
+
+      expect(settings.model).toBe('claude-opus'); // local wins
+      expect(settings.theme).toBe('light'); // preserved
+    });
+
+    it('should load from extra config dirs', async () => {
+      const extraDir = path.join(test.tempDir, 'team-config');
+      await fs.mkdir(extraDir, { recursive: true });
+      await fs.writeFile(path.join(extraDir, 'settings.json'), JSON.stringify({ teamSetting: 'enabled' }));
+      process.env.GENCODE_CONFIG_DIRS = extraDir;
+
+      const { settings } = await new ConfigManager({ cwd: test.projectDir }).load();
+
+      expect(settings.teamSetting).toBe('enabled');
+    });
+  });
+
+  describe('setCliArgs', () => {
+    it('should apply CLI args with highest priority', async () => {
+      await writeSettings(test.projectDir, 'gencode', { model: 'claude-sonnet', provider: 'anthropic' });
+
+      const manager = new ConfigManager({ cwd: test.projectDir });
+      manager.setCliArgs({ model: 'gpt-4o' });
+      const { settings } = await manager.load();
+
+      expect(settings.model).toBe('gpt-4o'); // CLI wins
+      expect(settings.provider).toBe('anthropic'); // unchanged
+    });
+  });
+
+  describe('saveToLevel', () => {
+    it('should save to project and local levels', async () => {
+      const manager = new ConfigManager({ cwd: test.projectDir });
+      await manager.load();
+
+      await manager.saveToLevel({ model: 'project-model' }, 'project');
+      await manager.saveToLevel({ debug: true }, 'local');
+
+      const projectContent = JSON.parse(await fs.readFile(
+        path.join(test.projectDir, '.gencode', 'settings.json'), 'utf-8'
+      ));
+      const localContent = JSON.parse(await fs.readFile(
+        path.join(test.projectDir, '.gencode', 'settings.local.json'), 'utf-8'
+      ));
+
+      expect(projectContent.model).toBe('project-model');
+      expect(localContent.debug).toBe(true);
+    });
+
+    it('should merge with existing settings', async () => {
+      await writeSettings(test.projectDir, 'gencode', { model: 'old', theme: 'dark' });
+
+      const manager = new ConfigManager({ cwd: test.projectDir });
+      await manager.load();
+      await manager.saveToLevel({ model: 'new' }, 'project');
+
+      const saved = JSON.parse(await fs.readFile(
+        path.join(test.projectDir, '.gencode', 'settings.json'), 'utf-8'
+      ));
+
+      expect(saved.model).toBe('new');
+      expect(saved.theme).toBe('dark'); // preserved
+    });
+  });
+
+  describe('addPermissionRule', () => {
+    it('should add allow and deny rules', async () => {
+      const manager = new ConfigManager({ cwd: test.projectDir });
+      await manager.load();
+
+      await manager.addPermissionRule('Bash(npm:*)', 'allow', 'project');
+      await manager.addPermissionRule('Bash(rm:*)', 'deny', 'project');
+
+      const saved = JSON.parse(await fs.readFile(
+        path.join(test.projectDir, '.gencode', 'settings.json'), 'utf-8'
+      ));
+
+      expect(saved.permissions?.allow).toContain('Bash(npm:*)');
+      expect(saved.permissions?.deny).toContain('Bash(rm:*)');
+    });
+  });
+
+  describe('getEffectivePermissions', () => {
+    it('should return all permission lists', async () => {
+      await writeSettings(test.projectDir, 'gencode', {
+        permissions: { allow: ['A'], ask: ['B'], deny: ['C'] },
+      });
+
+      const manager = new ConfigManager({ cwd: test.projectDir });
+      await manager.load();
+      const perms = manager.getEffectivePermissions();
+
+      expect(perms.allow).toContain('A');
+      expect(perms.ask).toContain('B');
+      expect(perms.deny).toContain('C');
+    });
+  });
+
+  describe('isAllowed and shouldAsk', () => {
+    it('should check permissions correctly', async () => {
+      await writeSettings(test.projectDir, 'gencode', {
+        permissions: { allow: ['Bash(git:*)'], deny: ['Bash(rm:*)'], ask: ['WebFetch'] },
+      });
+
+      const manager = new ConfigManager({ cwd: test.projectDir });
+      await manager.load();
+
+      expect(manager.isAllowed('Bash(git:status)')).toBe(true);
+      expect(manager.isAllowed('Bash(rm:file)')).toBe(false);
+      expect(manager.isAllowed('Unknown')).toBe(false);
+
+      expect(manager.shouldAsk('Bash(git:status)')).toBe(false); // allowed
+      expect(manager.shouldAsk('Bash(rm:file)')).toBe(false); // denied
+      expect(manager.shouldAsk('WebFetch')).toBe(true);
+      expect(manager.shouldAsk('Unknown')).toBe(true); // default ask
+    });
+  });
+
+  describe('getSources', () => {
+    it('should return all loaded sources', async () => {
+      await writeSettings(test.projectDir, 'claude', { model: 'gpt-4' });
+      await writeSettings(test.projectDir, 'gencode', { provider: 'anthropic' });
+
+      const manager = new ConfigManager({ cwd: test.projectDir });
+      await manager.load();
+      const sources = manager.getSources();
+
+      expect(sources.find((s) => s.namespace === 'claude')).toBeDefined();
+      expect(sources.find((s) => s.namespace === 'gencode')).toBeDefined();
+    });
+  });
+
+  describe('getDebugSummary', () => {
+    it('should return summary or indicate not loaded', async () => {
+      const manager = new ConfigManager({ cwd: test.projectDir });
+
+      expect(manager.getDebugSummary()).toBe('Configuration not loaded');
+
+      await writeSettings(test.projectDir, 'gencode', { model: 'test' });
+      await manager.load();
+
+      expect(manager.getDebugSummary()).toContain('Configuration Sources');
+    });
+  });
+});

package/src/config/manager.ts

@@ -1,77 +1,365 @@
 /**
- * Settings Manager - Persists user settings (Claude Code style)
+ * Configuration Manager - Unified multi-level configuration (Claude Code compatible)
+ *
+ * Configuration hierarchy (merged in order, later overrides earlier):
+ * 1. User: ~/.claude/ + ~/.gencode/ (gencode wins within level)
+ * 2. Extra: GENCODE_CONFIG_DIRS directories
+ * 3. Project: .claude/ + .gencode/ (gencode wins within level)
+ * 4. Local: *.local.* files (gencode wins within level)
+ * 5. CLI: Command line arguments
+ * 6. Managed: System-wide enforced settings (cannot be overridden)
+ *
+ * Within each level, both .claude and .gencode directories are loaded and merged,
+ * with .gencode taking higher priority.
  */
 
 import * as fs from 'fs/promises';
 import * as path from 'path';
-import * as os from 'os';
-import type { Settings, SettingsManagerOptions } from './types.js';
-import { DEFAULT_SETTINGS_DIR, SETTINGS_FILE_NAME } from './types.js';
+import type { Settings, MergedConfig, ConfigSource, SettingsManagerOptions } from './types.js';
+import { SETTINGS_FILE_NAME, SETTINGS_LOCAL_FILE_NAME } from './types.js';
+import { loadAllSources, getExistingConfigFiles } from './loader.js';
+import { mergeAllSources, mergeWithCliArgs, deepMerge, createMergeSummary } from './merger.js';
+import { findProjectRoot, getPrimarySettingsDir, getSettingsFilePath } from './levels.js';
 
-export class SettingsManager {
-  private settingsDir: string;
-  private settingsPath: string;
-  private settings: Settings = {};
+/**
+ * Configuration Manager
+ *
+ * Manages multi-level configuration loading, merging, and persistence.
+ * Compatible with both GenCode (.gencode/) and Claude Code (.claude/) directories.
+ */
+export class ConfigManager {
+  private cwd: string;
+  private projectRoot: string | null = null;
+  private mergedConfig: MergedConfig | null = null;
+  private cliArgs: Partial<Settings> = {};
 
-  constructor(options: SettingsManagerOptions = {}) {
-    const dir = options.settingsDir ?? DEFAULT_SETTINGS_DIR;
-    this.settingsDir = dir.replace('~', os.homedir());
-    this.settingsPath = path.join(this.settingsDir, SETTINGS_FILE_NAME);
+  constructor(options: { cwd?: string } = {}) {
+    this.cwd = options.cwd ?? process.cwd();
   }
 
   /**
-   * Ensure settings directory exists
+   * Load and merge all configuration sources
    */
-  private async ensureDir(): Promise<void> {
-    try {
-      await fs.mkdir(this.settingsDir, { recursive: true });
-    } catch {
-      // Directory may already exist
+  async load(): Promise<MergedConfig> {
+    // Find project root
+    this.projectRoot = await findProjectRoot(this.cwd);
+
+    // Load all sources
+    const sources = await loadAllSources(this.cwd);
+
+    // Merge all sources
+    let merged = mergeAllSources(sources);
+
+    // Apply CLI arguments if any
+    if (Object.keys(this.cliArgs).length > 0) {
+      merged = mergeWithCliArgs(merged, this.cliArgs);
     }
+
+    this.mergedConfig = merged;
+    return merged;
   }
 
   /**
-   * Load settings from disk
+   * Set CLI argument overrides
    */
-  async load(): Promise<Settings> {
+  setCliArgs(args: Partial<Settings>): void {
+    this.cliArgs = args;
+  }
+
+  /**
+   * Get the current merged settings
+   */
+  get(): Settings {
+    if (!this.mergedConfig) {
+      return {};
+    }
+    return { ...this.mergedConfig.settings };
+  }
+
+  /**
+   * Get the full merged config with sources info
+   */
+  getMergedConfig(): MergedConfig | null {
+    return this.mergedConfig;
+  }
+
+  /**
+   * Get all loaded sources
+   */
+  getSources(): ConfigSource[] {
+    return this.mergedConfig?.sources ?? [];
+  }
+
+  /**
+   * Get managed deny rules
+   */
+  getManagedDeny(): string[] {
+    return this.mergedConfig?.managedDeny ?? [];
+  }
+
+  /**
+   * Save settings to a specific level
+   */
+  async saveToLevel(
+    updates: Partial<Settings>,
+    level: 'user' | 'project' | 'local'
+  ): Promise<void> {
+    if (!this.projectRoot) {
+      this.projectRoot = await findProjectRoot(this.cwd);
+    }
+
+    const dir = getPrimarySettingsDir(level, this.projectRoot);
+    const fileName = level === 'local' ? SETTINGS_LOCAL_FILE_NAME : SETTINGS_FILE_NAME;
+    const filePath = path.join(dir, fileName);
+
+    // Ensure directory exists
+    await fs.mkdir(dir, { recursive: true });
+
+    // Load existing settings for this level
+    let existing: Settings = {};
     try {
-      const content = await fs.readFile(this.settingsPath, 'utf-8');
-      this.settings = JSON.parse(content);
-      return this.settings;
+      const content = await fs.readFile(filePath, 'utf-8');
+      existing = JSON.parse(content);
     } catch {
-      // File doesn't exist or is invalid
-      this.settings = {};
-      return this.settings;
+      // File doesn't exist, start fresh
     }
+
+    // Merge updates into existing
+    const merged = deepMerge(existing, updates);
+
+    // Write back
+    await fs.writeFile(filePath, JSON.stringify(merged, null, 2), 'utf-8');
+
+    // Reload configuration
+    await this.load();
   }
 
   /**
-   * Save settings to disk (merges with existing)
+   * Save to global user settings (default)
    */
   async save(updates: Partial<Settings>): Promise<void> {
-    await this.ensureDir();
+    await this.saveToLevel(updates, 'user');
+  }
 
-    // Merge updates with existing settings
-    this.settings = { ...this.settings, ...updates };
+  /**
+   * Add a permission rule
+   */
+  async addPermissionRule(
+    pattern: string,
+    type: 'allow' | 'deny' | 'ask',
+    level: 'user' | 'project' | 'local' = 'project'
+  ): Promise<void> {
+    const updates: Settings = {
+      permissions: {
+        [type]: [pattern],
+      },
+    };
+    await this.saveToLevel(updates, level);
+  }
 
-    await fs.writeFile(
-      this.settingsPath,
-      JSON.stringify(this.settings, null, 2),
-      'utf-8'
-    );
+  /**
+   * Get existing config files
+   */
+  async getExistingFiles(): Promise<string[]> {
+    return getExistingConfigFiles(this.cwd);
   }
 
   /**
-   * Get current settings
+   * Get debug summary of configuration
    */
-  get(): Settings {
-    return { ...this.settings };
+  getDebugSummary(): string {
+    if (!this.mergedConfig) {
+      return 'Configuration not loaded';
+    }
+    return createMergeSummary(this.mergedConfig);
   }
 
   /**
-   * Get settings file path
+   * Get the project root directory
    */
+  getProjectRoot(): string {
+    return this.projectRoot ?? this.cwd;
+  }
+
+  /**
+   * Get the current working directory
+   */
+  getCwd(): string {
+    return this.cwd;
+  }
+
+  /**
+   * Get the primary settings file path for a level
+   */
+  getSettingsPath(level: 'user' | 'project' | 'local' = 'user'): string {
+    const projectRoot = this.projectRoot ?? this.cwd;
+    return getSettingsFilePath(level, projectRoot);
+  }
+
+  /**
+   * Get effective permissions (merged from all sources)
+   */
+  getEffectivePermissions(): {
+    allow: string[];
+    ask: string[];
+    deny: string[];
+    managedDeny: string[];
+  } {
+    const settings = this.get();
+    const permissions = settings.permissions ?? {};
+
+    return {
+      allow: permissions.allow ?? [],
+      ask: permissions.ask ?? [],
+      deny: permissions.deny ?? [],
+      managedDeny: this.getManagedDeny(),
+    };
+  }
+
+  /**
+   * Check if a permission pattern is allowed
+   */
+  isAllowed(pattern: string): boolean {
+    const { allow, deny, managedDeny } = this.getEffectivePermissions();
+
+    // Managed deny always wins
+    if (managedDeny.some((p) => this.matchPattern(pattern, p))) {
+      return false;
+    }
+
+    // Check deny list
+    if (deny.some((p) => this.matchPattern(pattern, p))) {
+      return false;
+    }
+
+    // Check allow list
+    return allow.some((p) => this.matchPattern(pattern, p));
+  }
+
+  /**
+   * Check if a permission pattern requires asking
+   */
+  shouldAsk(pattern: string): boolean {
+    const { ask, allow, deny, managedDeny } = this.getEffectivePermissions();
+
+    // Managed deny always wins
+    if (managedDeny.some((p) => this.matchPattern(pattern, p))) {
+      return false; // Don't ask, just deny
+    }
+
+    // If explicitly allowed, don't ask
+    if (allow.some((p) => this.matchPattern(pattern, p))) {
+      return false;
+    }
+
+    // If explicitly denied, don't ask
+    if (deny.some((p) => this.matchPattern(pattern, p))) {
+      return false;
+    }
+
+    // Check ask list
+    if (ask.some((p) => this.matchPattern(pattern, p))) {
+      return true;
+    }
+
+    // Default: ask for unknown patterns
+    return true;
+  }
+
+  /**
+   * Simple pattern matching (supports * and :* wildcards)
+   */
+  private matchPattern(value: string, pattern: string): boolean {
+    // Exact match
+    if (value === pattern) return true;
+
+    // Handle :* suffix (e.g., "Bash(git:*)" matches "Bash(git:status)")
+    if (pattern.endsWith(':*)')) {
+      const prefix = pattern.slice(0, -3); // Remove ":*)"
+      const valuePrefix = value.slice(0, value.lastIndexOf(':'));
+      return valuePrefix.startsWith(prefix);
+    }
+
+    // Handle * wildcards
+    if (pattern.includes('*')) {
+      const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+      return regex.test(value);
+    }
+
+    return false;
+  }
+}
+
+// =============================================================================
+// Legacy SettingsManager (backward compatibility)
+// =============================================================================
+
+/**
+ * Legacy SettingsManager for backward compatibility
+ *
+ * @deprecated Use ConfigManager instead
+ */
+export class SettingsManager {
+  private configManager: ConfigManager;
+  private globalDir: string;
+  private projectDir: string;
+
+  constructor(options: SettingsManagerOptions & { cwd?: string } = {}) {
+    this.configManager = new ConfigManager({ cwd: options.cwd });
+
+    // For legacy compatibility
+    const cwd = options.cwd ?? process.cwd();
+    this.globalDir = options.settingsDir ?? getPrimarySettingsDir('user', cwd);
+    this.projectDir = getPrimarySettingsDir('project', cwd);
+  }
+
+  async load(): Promise<Settings> {
+    const merged = await this.configManager.load();
+    return merged.settings;
+  }
+
+  async save(updates: Partial<Settings>): Promise<void> {
+    await this.configManager.save(updates);
+  }
+
+  async saveToLevel(
+    updates: Partial<Settings>,
+    level: 'global' | 'project' | 'local'
+  ): Promise<void> {
+    const mappedLevel = level === 'global' ? 'user' : level;
+    await this.configManager.saveToLevel(updates, mappedLevel);
+  }
+
+  async addPermissionRule(
+    pattern: string,
+    type: 'allow' | 'deny',
+    level: 'global' | 'project' | 'local' = 'project'
+  ): Promise<void> {
+    const mappedLevel = level === 'global' ? 'user' : level;
+    await this.configManager.addPermissionRule(pattern, type, mappedLevel);
+  }
+
+  get(): Settings {
+    return this.configManager.get();
+  }
+
   getPath(): string {
-    return this.settingsPath;
+    return this.configManager.getSettingsPath('user');
+  }
+
+  getProjectPath(): string {
+    return this.configManager.getSettingsPath('project');
+  }
+
+  getLocalPath(): string {
+    return this.configManager.getSettingsPath('local');
+  }
+
+  getCwd(): string {
+    return this.configManager.getCwd();
+  }
+
+  getProjectDir(): string {
+    return this.projectDir;
   }
 }