gencode-ai 0.1.0 → 0.1.2

package/src/config/merger.test.ts

@@ -0,0 +1,360 @@
+/**
+ * Config Merger Tests
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import {
+  deepMerge,
+  mergeSettings,
+  extractManagedDeny,
+  applyManagedRestrictions,
+  mergeAllSources,
+  mergeWithCliArgs,
+  createMergeSummary,
+} from './merger.js';
+import type { ConfigSource, Settings } from './types.js';
+
+describe('deepMerge', () => {
+  it('should merge simple objects', () => {
+    const base = { a: 1, b: 2 };
+    const override = { b: 3, c: 4 };
+    const result = deepMerge(base, override);
+
+    expect(result).toEqual({ a: 1, b: 3, c: 4 });
+  });
+
+  it('should deep merge nested objects', () => {
+    const base = {
+      provider: 'openai',
+      permissions: {
+        allow: ['Bash(git:*)'],
+        deny: ['WebFetch'],
+      },
+    };
+    const override = {
+      model: 'claude-sonnet',
+      permissions: {
+        allow: ['Bash(npm:*)'],
+      },
+    };
+    const result = deepMerge(base, override);
+
+    expect(result.provider).toBe('openai');
+    expect(result.model).toBe('claude-sonnet');
+    expect(result.permissions.allow).toContain('Bash(git:*)');
+    expect(result.permissions.allow).toContain('Bash(npm:*)');
+    expect(result.permissions.deny).toContain('WebFetch');
+  });
+
+  it('should concatenate and deduplicate arrays', () => {
+    const base = { items: ['a', 'b', 'c'] };
+    const override = { items: ['b', 'c', 'd'] };
+    const result = deepMerge(base, override);
+
+    expect(result.items).toEqual(['a', 'b', 'c', 'd']);
+  });
+
+  it('should override scalar values', () => {
+    const base = { model: 'gpt-4', theme: 'dark' };
+    const override = { model: 'claude-sonnet' };
+    const result = deepMerge(base, override);
+
+    expect(result.model).toBe('claude-sonnet');
+    expect(result.theme).toBe('dark');
+  });
+
+  it('should handle undefined values', () => {
+    const base = { a: 1, b: 2 };
+    const override = { a: undefined, c: 3 };
+    const result = deepMerge(base, override as any);
+
+    expect(result.a).toBe(1); // undefined should not override
+    expect(result.c).toBe(3);
+  });
+
+  it('should handle empty objects', () => {
+    const base = { a: 1 };
+    const override = {};
+    const result = deepMerge(base, override);
+
+    expect(result).toEqual({ a: 1 });
+  });
+});
+
+describe('mergeSettings', () => {
+  it('should merge multiple sources in order', () => {
+    const sources: ConfigSource[] = [
+      {
+        level: 'user',
+        path: '~/.claude/settings.json',
+        namespace: 'claude',
+        settings: { provider: 'openai', model: 'gpt-4' },
+      },
+      {
+        level: 'user',
+        path: '~/.gencode/settings.json',
+        namespace: 'gencode',
+        settings: { provider: 'anthropic' }, // Override provider
+      },
+      {
+        level: 'project',
+        path: '.gencode/settings.json',
+        namespace: 'gencode',
+        settings: { model: 'claude-sonnet' }, // Override model
+      },
+    ];
+
+    const result = mergeSettings(sources);
+
+    expect(result.provider).toBe('anthropic'); // From gencode user
+    expect(result.model).toBe('claude-sonnet'); // From project
+  });
+
+  it('should concatenate permission arrays', () => {
+    const sources: ConfigSource[] = [
+      {
+        level: 'user',
+        path: '~/.claude/settings.json',
+        namespace: 'claude',
+        settings: {
+          permissions: { allow: ['Bash(git:*)'] },
+        },
+      },
+      {
+        level: 'project',
+        path: '.gencode/settings.json',
+        namespace: 'gencode',
+        settings: {
+          permissions: { allow: ['Bash(npm:*)'], deny: ['WebFetch'] },
+        },
+      },
+    ];
+
+    const result = mergeSettings(sources);
+
+    expect(result.permissions?.allow).toContain('Bash(git:*)');
+    expect(result.permissions?.allow).toContain('Bash(npm:*)');
+    expect(result.permissions?.deny).toContain('WebFetch');
+  });
+
+  it('should return empty object for empty sources', () => {
+    const result = mergeSettings([]);
+    expect(result).toEqual({});
+  });
+});
+
+describe('extractManagedDeny', () => {
+  it('should extract deny rules from managed sources', () => {
+    const sources: ConfigSource[] = [
+      {
+        level: 'user',
+        path: '~/.gencode/settings.json',
+        namespace: 'gencode',
+        settings: {
+          permissions: { deny: ['WebFetch'] },
+        },
+      },
+      {
+        level: 'managed',
+        path: '/etc/gencode/managed-settings.json',
+        namespace: 'gencode',
+        settings: {
+          permissions: { deny: ['Bash(curl:*)'] },
+        },
+      },
+    ];
+
+    const result = extractManagedDeny(sources);
+
+    // Should only include managed deny rules
+    expect(result).toContain('Bash(curl:*)');
+    expect(result).not.toContain('WebFetch');
+  });
+
+  it('should deduplicate managed deny rules', () => {
+    const sources: ConfigSource[] = [
+      {
+        level: 'managed',
+        path: '/Library/.../ClaudeCode/managed-settings.json',
+        namespace: 'claude',
+        settings: {
+          permissions: { deny: ['Bash(curl:*)'] },
+        },
+      },
+      {
+        level: 'managed',
+        path: '/Library/.../GenCode/managed-settings.json',
+        namespace: 'gencode',
+        settings: {
+          permissions: { deny: ['Bash(curl:*)', 'WebFetch'] },
+        },
+      },
+    ];
+
+    const result = extractManagedDeny(sources);
+
+    expect(result).toEqual(['Bash(curl:*)', 'WebFetch']);
+  });
+
+  it('should return empty array if no managed sources', () => {
+    const sources: ConfigSource[] = [
+      {
+        level: 'user',
+        path: '~/.gencode/settings.json',
+        namespace: 'gencode',
+        settings: {
+          permissions: { deny: ['WebFetch'] },
+        },
+      },
+    ];
+
+    const result = extractManagedDeny(sources);
+    expect(result).toEqual([]);
+  });
+});
+
+describe('applyManagedRestrictions', () => {
+  it('should add managed deny rules to deny list', () => {
+    const settings: Settings = {
+      permissions: {
+        allow: ['Bash(git:*)'],
+        deny: ['WebFetch'],
+      },
+    };
+    const managedDeny = ['Bash(curl:*)'];
+
+    const result = applyManagedRestrictions(settings, managedDeny);
+
+    expect(result.permissions?.deny).toContain('WebFetch');
+    expect(result.permissions?.deny).toContain('Bash(curl:*)');
+  });
+
+  it('should remove managed deny from allow list', () => {
+    const settings: Settings = {
+      permissions: {
+        allow: ['Bash(git:*)', 'Bash(curl:*)'], // curl should be removed
+        deny: [],
+      },
+    };
+    const managedDeny = ['Bash(curl:*)'];
+
+    const result = applyManagedRestrictions(settings, managedDeny);
+
+    expect(result.permissions?.allow).toContain('Bash(git:*)');
+    expect(result.permissions?.allow).not.toContain('Bash(curl:*)');
+    expect(result.permissions?.deny).toContain('Bash(curl:*)');
+  });
+
+  it('should return unchanged settings if no managed deny', () => {
+    const settings: Settings = {
+      provider: 'anthropic',
+      permissions: { allow: ['Bash(git:*)'] },
+    };
+
+    const result = applyManagedRestrictions(settings, []);
+
+    expect(result).toEqual(settings);
+  });
+});
+
+describe('mergeAllSources', () => {
+  it('should merge all sources and extract managed deny', () => {
+    const sources: ConfigSource[] = [
+      {
+        level: 'user',
+        path: '~/.gencode/settings.json',
+        namespace: 'gencode',
+        settings: { provider: 'anthropic' },
+      },
+      {
+        level: 'managed',
+        path: '/etc/gencode/managed-settings.json',
+        namespace: 'gencode',
+        settings: {
+          permissions: { deny: ['Bash(curl:*)'] },
+        },
+      },
+    ];
+
+    const result = mergeAllSources(sources);
+
+    expect(result.settings.provider).toBe('anthropic');
+    expect(result.managedDeny).toContain('Bash(curl:*)');
+    expect(result.sources).toHaveLength(2);
+  });
+});
+
+describe('mergeWithCliArgs', () => {
+  it('should merge CLI args with highest priority', () => {
+    const sources: ConfigSource[] = [
+      {
+        level: 'user',
+        path: '~/.gencode/settings.json',
+        namespace: 'gencode',
+        settings: { provider: 'openai', model: 'gpt-4' },
+      },
+    ];
+
+    const merged = mergeAllSources(sources);
+    const result = mergeWithCliArgs(merged, { model: 'claude-sonnet' });
+
+    expect(result.settings.provider).toBe('openai');
+    expect(result.settings.model).toBe('claude-sonnet');
+    expect(result.sources).toHaveLength(2);
+    expect(result.sources[1].level).toBe('cli');
+  });
+
+  it('should not allow CLI args to override managed deny', () => {
+    const sources: ConfigSource[] = [
+      {
+        level: 'managed',
+        path: '/etc/gencode/managed-settings.json',
+        namespace: 'gencode',
+        settings: {
+          permissions: { deny: ['Bash(curl:*)'] },
+        },
+      },
+    ];
+
+    const merged = mergeAllSources(sources);
+    // Try to add curl to allow list via CLI
+    const result = mergeWithCliArgs(merged, {
+      permissions: { allow: ['Bash(curl:*)'] },
+    });
+
+    // curl should still be in deny, not in allow
+    expect(result.settings.permissions?.deny).toContain('Bash(curl:*)');
+    expect(result.settings.permissions?.allow).not.toContain('Bash(curl:*)');
+  });
+});
+
+describe('createMergeSummary', () => {
+  it('should create readable summary', () => {
+    const sources: ConfigSource[] = [
+      {
+        level: 'user',
+        path: '~/.gencode/settings.json',
+        namespace: 'gencode',
+        settings: { provider: 'anthropic' },
+      },
+      {
+        level: 'managed',
+        path: '/etc/gencode/managed-settings.json',
+        namespace: 'gencode',
+        settings: {
+          permissions: { deny: ['Bash(curl:*)'] },
+        },
+      },
+    ];
+
+    const merged = mergeAllSources(sources);
+    const summary = createMergeSummary(merged);
+
+    expect(summary).toContain('Configuration Sources');
+    expect(summary).toContain('user:gencode');
+    expect(summary).toContain('managed:gencode');
+    expect(summary).toContain('[enforced]');
+    expect(summary).toContain('Managed Deny Rules');
+    expect(summary).toContain('Bash(curl:*)');
+  });
+});

package/src/config/merger.ts

@@ -0,0 +1,221 @@
+/**
+ * Configuration Merger - Merge settings from multiple sources
+ *
+ * Implements the merge strategy:
+ * - Scalar values: Higher priority replaces lower
+ * - Arrays (permissions.allow, permissions.deny): Concatenate with deduplication
+ * - Objects: Deep merge recursively
+ * - Managed deny rules: Cannot be overridden by any level
+ */
+
+import type { Settings, ConfigSource, MergedConfig, PermissionRules } from './types.js';
+
+/**
+ * Check if a value is a plain object
+ */
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Deep merge two objects
+ *
+ * - Arrays are concatenated and deduplicated
+ * - Objects are recursively merged
+ * - Scalars from override replace base
+ */
+export function deepMerge<T extends Record<string, unknown>>(
+  base: T,
+  override: Partial<T>
+): T {
+  const result = { ...base };
+
+  for (const key in override) {
+    const baseValue = result[key];
+    const overrideValue = override[key];
+
+    if (overrideValue === undefined) {
+      continue;
+    }
+
+    if (isPlainObject(baseValue) && isPlainObject(overrideValue)) {
+      // Recursively merge objects
+      result[key] = deepMerge(
+        baseValue as Record<string, unknown>,
+        overrideValue as Record<string, unknown>
+      ) as T[Extract<keyof T, string>];
+    } else if (Array.isArray(baseValue) && Array.isArray(overrideValue)) {
+      // Concatenate arrays and deduplicate
+      result[key] = deduplicateArray([
+        ...baseValue,
+        ...overrideValue,
+      ]) as T[Extract<keyof T, string>];
+    } else {
+      // Override scalar values
+      result[key] = overrideValue as T[Extract<keyof T, string>];
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Deduplicate an array while preserving order
+ */
+function deduplicateArray<T>(arr: T[]): T[] {
+  const seen = new Set<string>();
+  const result: T[] = [];
+
+  for (const item of arr) {
+    const key = typeof item === 'object' ? JSON.stringify(item) : String(item);
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(item);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Merge all configuration sources into a single settings object
+ *
+ * Sources should be in priority order (lowest first).
+ * Each source is merged on top of the previous result.
+ */
+export function mergeSettings(sources: ConfigSource[]): Settings {
+  let merged: Settings = {};
+
+  for (const source of sources) {
+    merged = deepMerge(merged, source.settings);
+  }
+
+  return merged;
+}
+
+/**
+ * Extract managed deny rules from sources
+ *
+ * These rules are extracted from managed-level sources and cannot be
+ * overridden by any lower-level configuration.
+ */
+export function extractManagedDeny(sources: ConfigSource[]): string[] {
+  const managedDeny: string[] = [];
+
+  for (const source of sources) {
+    if (source.level === 'managed') {
+      const deny = source.settings.permissions?.deny;
+      if (deny) {
+        managedDeny.push(...deny);
+      }
+    }
+  }
+
+  return deduplicateArray(managedDeny);
+}
+
+/**
+ * Apply managed restrictions to the merged settings
+ *
+ * - Ensures managed deny rules are always in the deny list
+ * - Removes managed deny patterns from allow list
+ */
+export function applyManagedRestrictions(
+  settings: Settings,
+  managedDeny: string[]
+): Settings {
+  if (managedDeny.length === 0) {
+    return settings;
+  }
+
+  const result = { ...settings };
+  const permissions: PermissionRules = { ...(result.permissions || {}) };
+
+  // Ensure deny list includes all managed deny rules
+  const currentDeny = permissions.deny || [];
+  permissions.deny = deduplicateArray([...currentDeny, ...managedDeny]);
+
+  // Remove managed deny patterns from allow list
+  if (permissions.allow) {
+    permissions.allow = permissions.allow.filter(
+      (pattern) => !managedDeny.includes(pattern)
+    );
+  }
+
+  result.permissions = permissions;
+  return result;
+}
+
+/**
+ * Merge all configuration sources and apply restrictions
+ *
+ * This is the main entry point for configuration merging.
+ */
+export function mergeAllSources(sources: ConfigSource[]): MergedConfig {
+  // Extract managed deny rules first
+  const managedDeny = extractManagedDeny(sources);
+
+  // Merge all settings
+  let settings = mergeSettings(sources);
+
+  // Apply managed restrictions
+  settings = applyManagedRestrictions(settings, managedDeny);
+
+  return {
+    settings,
+    sources,
+    managedDeny,
+  };
+}
+
+/**
+ * Merge settings with CLI arguments
+ *
+ * CLI arguments have the highest priority (except managed restrictions).
+ */
+export function mergeWithCliArgs(
+  merged: MergedConfig,
+  cliArgs: Partial<Settings>
+): MergedConfig {
+  // Merge CLI args as a virtual source
+  const settings = deepMerge(merged.settings, cliArgs);
+
+  // Re-apply managed restrictions to ensure they're not overridden
+  const finalSettings = applyManagedRestrictions(settings, merged.managedDeny);
+
+  return {
+    ...merged,
+    settings: finalSettings,
+    sources: [
+      ...merged.sources,
+      {
+        level: 'cli',
+        path: '<cli>',
+        namespace: 'gencode',
+        settings: cliArgs,
+      },
+    ],
+  };
+}
+
+/**
+ * Create a debug summary of the merge process
+ */
+export function createMergeSummary(merged: MergedConfig): string {
+  const lines: string[] = ['Configuration Sources (in priority order):'];
+
+  for (const source of merged.sources) {
+    const marker = source.level === 'managed' ? ' [enforced]' : '';
+    lines.push(`  ${source.level}:${source.namespace} - ${source.path}${marker}`);
+  }
+
+  if (merged.managedDeny.length > 0) {
+    lines.push('');
+    lines.push('Managed Deny Rules (cannot be overridden):');
+    for (const rule of merged.managedDeny) {
+      lines.push(`  - ${rule}`);
+    }
+  }
+
+  return lines.join('\n');
+}

package/src/config/providers-config.ts

@@ -0,0 +1,85 @@
+/**
+ * Providers Config Manager - Reads providers.json for model-to-provider mapping
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import type { ProvidersConfig, ProviderName } from './types.js';
+import { DEFAULT_SETTINGS_DIR, PROVIDERS_FILE_NAME } from './types.js';
+
+export class ProvidersConfigManager {
+  private settingsDir: string;
+  private providersPath: string;
+  private config: ProvidersConfig | null = null;
+
+  constructor(settingsDir?: string) {
+    const dir = settingsDir ?? DEFAULT_SETTINGS_DIR;
+    this.settingsDir = dir.replace('~', os.homedir());
+    this.providersPath = path.join(this.settingsDir, PROVIDERS_FILE_NAME);
+  }
+
+  /**
+   * Load providers config from disk
+   */
+  async load(): Promise<ProvidersConfig | null> {
+    try {
+      const content = await fs.readFile(this.providersPath, 'utf-8');
+      this.config = JSON.parse(content);
+      return this.config;
+    } catch {
+      // File doesn't exist or is invalid
+      this.config = null;
+      return null;
+    }
+  }
+
+  /**
+   * Get cached config (call load() first)
+   */
+  get(): ProvidersConfig | null {
+    return this.config;
+  }
+
+  /**
+   * Infer provider from model ID using cached models in providers.json
+   * Returns undefined if model not found in any provider's cached list
+   */
+  inferProvider(modelId: string): ProviderName | undefined {
+    if (!this.config?.models) {
+      return undefined;
+    }
+
+    for (const [providerKey, providerModels] of Object.entries(this.config.models)) {
+      const found = providerModels.list?.some((m) => m.id === modelId);
+      if (found) {
+        // Map provider key to ProviderName
+        // Note: 'anthropic' in providers.json might use vertex connection
+        if (providerKey === 'gemini') {
+          return 'gemini';
+        } else if (providerKey === 'anthropic') {
+          // Check connection method to determine if vertex or direct
+          const connection = this.config.connections?.[providerKey];
+          if (connection?.method === 'vertex') {
+            return 'vertex-ai';
+          }
+          return 'anthropic';
+        } else if (providerKey === 'openai') {
+          return 'openai';
+        }
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Get all model IDs for a provider
+   */
+  getModelIds(provider: string): string[] {
+    if (!this.config?.models?.[provider]) {
+      return [];
+    }
+    return this.config.models[provider].list?.map((m) => m.id) ?? [];
+  }
+}