gencode-ai 0.2.0 → 0.3.0

package/src/cli/index.tsx

@@ -9,7 +9,9 @@ import { render } from 'ink';
 import React from 'react';
 import { App } from './components/App.js';
 import type { AgentConfig } from '../agent/types.js';
-import { SettingsManager, ProvidersConfigManager, type Settings, type ProviderName } from '../config/index.js';
+import { SettingsManager, ProvidersConfigManager, type Settings, type Provider } from '../config/index.js';
+import type { AuthMethod } from '../providers/types.js';
+import { inferProvider, inferAuthMethod } from '../providers/index.js';
 
 // ============================================================================
 // Proxy Setup
@@ -32,32 +34,43 @@ async function setupProxy(): Promise<void> {
 // Configuration
 // ============================================================================
 function detectConfig(settings: Settings, providersConfig: ProvidersConfigManager): AgentConfig {
-  let provider: ProviderName = 'gemini';
+  let provider: Provider = 'gemini';
+  let authMethod: AuthMethod | undefined;
   let model = 'gemini-2.0-flash';
 
-  // Check for explicit Vertex AI enablement first (highest priority for auto-detect)
-  if (process.env.GENCODE_USE_VERTEX === '1' || process.env.CLAUDE_CODE_USE_VERTEX === '1') {
-    provider = 'vertex-ai';
-    model = process.env.VERTEX_AI_MODEL ?? 'claude-sonnet-4-5@20250929';
-  }
-  // Auto-detect from API keys
-  else if (process.env.ANTHROPIC_API_KEY) {
+  // Auto-detect from environment variables
+  // Check Vertex AI first (requires explicit opt-in)
+  const useVertex = process.env.CLAUDE_CODE_USE_VERTEX === '1' || process.env.CLAUDE_CODE_USE_VERTEX === 'true';
+  const hasVertexProject = !!(
+    process.env.ANTHROPIC_VERTEX_PROJECT_ID ||
+    process.env.GCLOUD_PROJECT ||
+    process.env.GOOGLE_CLOUD_PROJECT
+  );
+
+  if (useVertex && hasVertexProject) {
+    provider = 'anthropic';
+    authMethod = 'vertex';
+    model = 'claude-sonnet-4-5@20250929';
+  } else if (process.env.ANTHROPIC_API_KEY) {
     provider = 'anthropic';
+    authMethod = 'api_key';
     model = 'claude-sonnet-4-20250514';
   } else if (process.env.OPENAI_API_KEY) {
     provider = 'openai';
+    authMethod = 'api_key';
     model = 'gpt-4o';
   } else if (process.env.GOOGLE_API_KEY) {
     provider = 'gemini';
+    authMethod = 'api_key';
     model = 'gemini-2.0-flash';
   }
 
   // Override from env vars
-  if (process.env.GENCODE_PROVIDER) {
-    provider = process.env.GENCODE_PROVIDER as ProviderName;
+  if (process.env.GEN_PROVIDER) {
+    provider = process.env.GEN_PROVIDER as Provider;
   }
-  if (process.env.GENCODE_MODEL) {
-    model = process.env.GENCODE_MODEL;
+  if (process.env.GEN_MODEL) {
+    model = process.env.GEN_MODEL;
   }
 
   // Override from saved settings (highest priority)
@@ -66,17 +79,23 @@ function detectConfig(settings: Settings, providersConfig: ProvidersConfigManage
   }
   if (settings.model) {
     model = settings.model;
-    // Auto-infer provider from model using providers.json (if not explicitly set)
+    // Try to infer provider and authMethod from cached models first
     if (!settings.provider) {
-      const inferredProvider = providersConfig.inferProvider(model);
-      if (inferredProvider) {
-        provider = inferredProvider;
+      const cached = providersConfig.inferProviderFromCache(model);
+      if (cached) {
+        provider = cached.provider;
+        authMethod = cached.authMethod;
+      } else {
+        // Fall back to model name inference
+        provider = inferProvider(model);
+        authMethod = inferAuthMethod(model);
       }
     }
   }
 
   return {
     provider,
+    authMethod,
     model,
     cwd: process.cwd(),
     maxTurns: 20,

package/src/config/index.ts

@@ -12,6 +12,8 @@
 export type {
   Settings,
   SettingsManagerOptions,
+  Provider,
+  AuthMethod,
   ProviderName,
   PermissionRules,
   ConfigLevelType,
@@ -34,11 +36,11 @@ export {
   SETTINGS_LOCAL_FILE_NAME,
   MANAGED_SETTINGS_FILE_NAME,
   PROVIDERS_FILE_NAME,
-  GENCODE_DIR,
+  GEN_DIR,
   CLAUDE_DIR,
-  USER_GENCODE_DIR,
+  USER_GEN_DIR,
   USER_CLAUDE_DIR,
-  GENCODE_CONFIG_DIRS_ENV,
+  GEN_CONFIG_ENV,
   getManagedPaths,
 } from './types.js';
 

package/src/config/levels.test.ts

@@ -31,10 +31,10 @@ describe('findProjectRoot', () => {
     expect(await findProjectRoot(subDir)).toBe(test.projectDir);
   });
 
-  it('should find .gencode directory as project root', async () => {
-    // Remove .git, add .gencode
+  it('should find .gen directory as project root', async () => {
+    // Remove .git, add .gen
     await fs.rm(path.join(test.projectDir, '.git'), { recursive: true });
-    await fs.mkdir(path.join(test.projectDir, '.gencode'));
+    await fs.mkdir(path.join(test.projectDir, '.gen'));
     const subDir = path.join(test.projectDir, 'src');
     await fs.mkdir(subDir, { recursive: true });
 
@@ -59,38 +59,38 @@ describe('findProjectRoot', () => {
 });
 
 describe('parseExtraConfigDirs', () => {
-  const originalEnv = process.env.GENCODE_CONFIG_DIRS;
+  const originalEnv = process.env.GEN_CONFIG;
 
   afterEach(() => {
     if (originalEnv === undefined) {
-      delete process.env.GENCODE_CONFIG_DIRS;
+      delete process.env.GEN_CONFIG;
     } else {
-      process.env.GENCODE_CONFIG_DIRS = originalEnv;
+      process.env.GEN_CONFIG = originalEnv;
     }
   });
 
   it('should return empty array when env var not set', () => {
-    delete process.env.GENCODE_CONFIG_DIRS;
+    delete process.env.GEN_CONFIG;
     expect(parseExtraConfigDirs()).toEqual([]);
   });
 
   it('should parse single directory', () => {
-    process.env.GENCODE_CONFIG_DIRS = '/team/config';
+    process.env.GEN_CONFIG = '/team/config';
     expect(parseExtraConfigDirs()).toEqual(['/team/config']);
   });
 
   it('should parse multiple directories', () => {
-    process.env.GENCODE_CONFIG_DIRS = '/team/config:/shared/rules';
+    process.env.GEN_CONFIG = '/team/config:/shared/rules';
     expect(parseExtraConfigDirs()).toEqual(['/team/config', '/shared/rules']);
   });
 
   it('should expand tilde to home directory', () => {
-    process.env.GENCODE_CONFIG_DIRS = '~/my-config';
+    process.env.GEN_CONFIG = '~/my-config';
     expect(parseExtraConfigDirs()[0]).toBe(path.join(os.homedir(), 'my-config'));
   });
 
   it('should trim whitespace and filter empty strings', () => {
-    process.env.GENCODE_CONFIG_DIRS = '  /path/one  : : /path/two  ';
+    process.env.GEN_CONFIG = '  /path/one  : : /path/two  ';
     expect(parseExtraConfigDirs()).toEqual(['/path/one', '/path/two']);
   });
 });
@@ -117,11 +117,11 @@ describe('getConfigLevels', () => {
 
     expect(userLevel?.paths.length).toBe(2);
     expect(userLevel?.paths.some((p) => p.namespace === 'claude')).toBe(true);
-    expect(userLevel?.paths.some((p) => p.namespace === 'gencode')).toBe(true);
+    expect(userLevel?.paths.some((p) => p.namespace === 'gen')).toBe(true);
   });
 
   it('should include extra dirs when env var is set', async () => {
-    process.env.GENCODE_CONFIG_DIRS = '/team/config';
+    process.env.GEN_CONFIG = '/team/config';
     const extraLevels = (await getConfigLevels(test.projectDir)).filter((l) => l.type === 'extra');
 
     expect(extraLevels.length).toBeGreaterThan(0);
@@ -131,7 +131,7 @@ describe('getConfigLevels', () => {
     for (const level of await getConfigLevels(test.projectDir)) {
       if (level.paths.length >= 2) {
         const claudeIdx = level.paths.findIndex((p) => p.namespace === 'claude');
-        const gencodeIdx = level.paths.findIndex((p) => p.namespace === 'gencode');
+        const gencodeIdx = level.paths.findIndex((p) => p.namespace === 'gen');
         if (claudeIdx !== -1 && gencodeIdx !== -1) {
           expect(claudeIdx).toBeLessThan(gencodeIdx);
         }
@@ -141,23 +141,23 @@ describe('getConfigLevels', () => {
 });
 
 describe('getPrimarySettingsDir', () => {
-  it('should return ~/.gencode for user level', () => {
-    expect(getPrimarySettingsDir('user', '/project')).toBe(path.join(os.homedir(), '.gencode'));
+  it('should return ~/.gen for user level', () => {
+    expect(getPrimarySettingsDir('user', '/project')).toBe(path.join(os.homedir(), '.gen'));
   });
 
-  it('should return project/.gencode for project and local levels', () => {
-    expect(getPrimarySettingsDir('project', '/my/project')).toBe('/my/project/.gencode');
-    expect(getPrimarySettingsDir('local', '/my/project')).toBe('/my/project/.gencode');
+  it('should return project/.gen for project and local levels', () => {
+    expect(getPrimarySettingsDir('project', '/my/project')).toBe('/my/project/.gen');
+    expect(getPrimarySettingsDir('local', '/my/project')).toBe('/my/project/.gen');
   });
 });
 
 describe('getSettingsFilePath', () => {
   it('should return correct paths for each level', () => {
     expect(getSettingsFilePath('user', '/project'))
-      .toBe(path.join(os.homedir(), '.gencode', 'settings.json'));
+      .toBe(path.join(os.homedir(), '.gen', 'settings.json'));
     expect(getSettingsFilePath('project', '/my/project'))
-      .toBe('/my/project/.gencode/settings.json');
+      .toBe('/my/project/.gen/settings.json');
     expect(getSettingsFilePath('local', '/my/project'))
-      .toBe('/my/project/.gencode/settings.local.json');
+      .toBe('/my/project/.gen/settings.local.json');
   });
 });

package/src/config/levels.ts

@@ -2,8 +2,8 @@
  * Configuration Levels - Path resolution for multi-level config
  *
  * Defines the configuration hierarchy and resolves paths for each level.
- * At each level, both .gencode and .claude directories are loaded and merged,
- * with .gencode taking higher priority.
+ * At each level, both .gen and .claude directories are loaded and merged,
+ * with .gen taking higher priority.
  */
 
 import * as path from 'path';
@@ -11,12 +11,12 @@ import * as os from 'os';
 import * as fs from 'fs/promises';
 import {
   ConfigLevelType,
-  GENCODE_DIR,
+  GEN_DIR,
   CLAUDE_DIR,
   SETTINGS_FILE_NAME,
   SETTINGS_LOCAL_FILE_NAME,
   MANAGED_SETTINGS_FILE_NAME,
-  GENCODE_CONFIG_DIRS_ENV,
+  GEN_CONFIG_ENV,
   getManagedPaths,
 } from './types.js';
 
@@ -27,7 +27,7 @@ export interface ConfigPathInfo {
   settingsPath: string;
   localSettingsPath?: string;
   dir: string;
-  namespace: 'gencode' | 'claude' | 'extra';
+  namespace: 'gen' | 'claude' | 'extra';
   exists: boolean;
 }
 
@@ -57,9 +57,9 @@ export async function findProjectRoot(cwd: string): Promise<string> {
       // Not a git root, continue
     }
 
-    // Check for .gencode or .claude directories
+    // Check for .gen or .claude directories
     try {
-      await fs.access(path.join(current, GENCODE_DIR));
+      await fs.access(path.join(current, GEN_DIR));
       return current;
     } catch {
       // Continue
@@ -93,10 +93,10 @@ async function pathExists(filePath: string): Promise<boolean> {
 }
 
 /**
- * Parse GENCODE_CONFIG_DIRS environment variable
+ * Parse GEN_CONFIG environment variable
  */
 export function parseExtraConfigDirs(): string[] {
-  const value = process.env[GENCODE_CONFIG_DIRS_ENV];
+  const value = process.env[GEN_CONFIG_ENV];
   if (!value) return [];
 
   return value
@@ -130,11 +130,11 @@ export async function getConfigLevels(cwd: string): Promise<ResolvedLevel[]> {
   });
 
   // GenCode second (higher priority within level)
-  const userGencodeDir = path.join(home, GENCODE_DIR);
+  const userGencodeDir = path.join(home, GEN_DIR);
   userPaths.push({
     settingsPath: path.join(userGencodeDir, SETTINGS_FILE_NAME),
     dir: userGencodeDir,
-    namespace: 'gencode',
+    namespace: 'gen',
     exists: await pathExists(path.join(userGencodeDir, SETTINGS_FILE_NAME)),
   });
 
@@ -180,11 +180,11 @@ export async function getConfigLevels(cwd: string): Promise<ResolvedLevel[]> {
   });
 
   // GenCode second (higher priority within level)
-  const projectGencodeDir = path.join(projectRoot, GENCODE_DIR);
+  const projectGencodeDir = path.join(projectRoot, GEN_DIR);
   projectPaths.push({
     settingsPath: path.join(projectGencodeDir, SETTINGS_FILE_NAME),
     dir: projectGencodeDir,
-    namespace: 'gencode',
+    namespace: 'gen',
     exists: await pathExists(path.join(projectGencodeDir, SETTINGS_FILE_NAME)),
   });
 
@@ -210,7 +210,7 @@ export async function getConfigLevels(cwd: string): Promise<ResolvedLevel[]> {
   localPaths.push({
     settingsPath: path.join(projectGencodeDir, SETTINGS_LOCAL_FILE_NAME),
     dir: projectGencodeDir,
-    namespace: 'gencode',
+    namespace: 'gen',
     exists: await pathExists(path.join(projectGencodeDir, SETTINGS_LOCAL_FILE_NAME)),
   });
 
@@ -234,10 +234,10 @@ export async function getConfigLevels(cwd: string): Promise<ResolvedLevel[]> {
 
   // GenCode second (higher priority within level)
   managedPathsList.push({
-    settingsPath: path.join(managedPaths.gencode, MANAGED_SETTINGS_FILE_NAME),
-    dir: managedPaths.gencode,
-    namespace: 'gencode',
-    exists: await pathExists(path.join(managedPaths.gencode, MANAGED_SETTINGS_FILE_NAME)),
+    settingsPath: path.join(managedPaths.gen, MANAGED_SETTINGS_FILE_NAME),
+    dir: managedPaths.gen,
+    namespace: 'gen',
+    exists: await pathExists(path.join(managedPaths.gen, MANAGED_SETTINGS_FILE_NAME)),
   });
 
   levels.push({
@@ -253,7 +253,7 @@ export async function getConfigLevels(cwd: string): Promise<ResolvedLevel[]> {
 
 /**
  * Get the primary settings directory for saving
- * Prefers .gencode if it exists, otherwise creates it
+ * Prefers .gen if it exists, otherwise creates it
  */
 export function getPrimarySettingsDir(
   level: 'user' | 'project' | 'local',
@@ -263,12 +263,12 @@ export function getPrimarySettingsDir(
 
   switch (level) {
     case 'user':
-      return path.join(home, GENCODE_DIR);
+      return path.join(home, GEN_DIR);
     case 'project':
     case 'local':
-      return path.join(projectRoot, GENCODE_DIR);
+      return path.join(projectRoot, GEN_DIR);
     default:
-      return path.join(home, GENCODE_DIR);
+      return path.join(home, GEN_DIR);
   }
 }
 

package/src/config/loader.test.ts

@@ -31,28 +31,28 @@ describe('Config Loader', () => {
       expect(source?.settings.provider).toBe('openai');
     });
 
-    it('should load settings from project .gencode directory', async () => {
-      await writeSettings(test.projectDir, 'gencode', { provider: 'anthropic' });
+    it('should load settings from project .gen directory', async () => {
+      await writeSettings(test.projectDir, 'gen', { provider: 'anthropic' });
       const sources = await loadAllSources(test.projectDir);
 
-      const source = sources.find((s) => s.level === 'project' && s.namespace === 'gencode');
+      const source = sources.find((s) => s.level === 'project' && s.namespace === 'gen');
       expect(source?.settings.provider).toBe('anthropic');
     });
 
-    it('should load both .claude and .gencode settings at same level', async () => {
+    it('should load both .claude and .gen settings at same level', async () => {
       await writeSettings(test.projectDir, 'claude', { provider: 'openai', model: 'gpt-4' });
-      await writeSettings(test.projectDir, 'gencode', { provider: 'anthropic' });
+      await writeSettings(test.projectDir, 'gen', { provider: 'anthropic' });
 
       const sources = await loadAllSources(test.projectDir);
       const claude = sources.find((s) => s.level === 'project' && s.namespace === 'claude');
-      const gencode = sources.find((s) => s.level === 'project' && s.namespace === 'gencode');
+      const gencode = sources.find((s) => s.level === 'project' && s.namespace === 'gen');
 
       expect(claude?.settings.provider).toBe('openai');
       expect(gencode?.settings.provider).toBe('anthropic');
     });
 
     it('should load local settings', async () => {
-      await writeSettings(test.projectDir, 'gencode', { alwaysThinkingEnabled: true }, true);
+      await writeSettings(test.projectDir, 'gen', { alwaysThinkingEnabled: true }, true);
       const sources = await loadAllSources(test.projectDir);
 
       const local = sources.find((s) => s.level === 'local');
@@ -63,7 +63,7 @@ describe('Config Loader', () => {
       const extraDir = path.join(test.tempDir, 'extra-config');
       await fs.mkdir(extraDir, { recursive: true });
       await fs.writeFile(path.join(extraDir, 'settings.json'), JSON.stringify({ theme: 'dark' }));
-      process.env.GENCODE_CONFIG_DIRS = extraDir;
+      process.env.GEN_CONFIG = extraDir;
 
       const sources = await loadAllSources(test.projectDir);
       const extra = sources.find((s) => s.level === 'extra');
@@ -74,7 +74,7 @@ describe('Config Loader', () => {
   describe('loadSourcesByLevel', () => {
     it('should group sources by level', async () => {
       await writeSettings(test.projectDir, 'claude', { model: 'gpt-4' });
-      await writeSettings(test.projectDir, 'gencode', { model: 'claude-sonnet' });
+      await writeSettings(test.projectDir, 'gen', { model: 'claude-sonnet' });
 
       const sourcesByLevel = await loadSourcesByLevel(test.projectDir);
 
@@ -85,8 +85,8 @@ describe('Config Loader', () => {
 
   describe('loadProjectSettings', () => {
     it('should only load project-level settings', async () => {
-      await writeSettings(test.projectDir, 'gencode', { model: 'claude-sonnet' });
-      await writeSettings(test.projectDir, 'gencode', { theme: 'dark' }, true);
+      await writeSettings(test.projectDir, 'gen', { model: 'claude-sonnet' });
+      await writeSettings(test.projectDir, 'gen', { theme: 'dark' }, true);
 
       const sources = await loadProjectSettings(test.projectDir);
 
@@ -99,14 +99,14 @@ describe('Config Loader', () => {
   describe('getExistingConfigFiles', () => {
     it('should list all existing config files', async () => {
       await writeSettings(test.projectDir, 'claude', {});
-      await writeSettings(test.projectDir, 'gencode', {});
-      await writeSettings(test.projectDir, 'gencode', {}, true);
+      await writeSettings(test.projectDir, 'gen', {});
+      await writeSettings(test.projectDir, 'gen', {}, true);
 
       const files = await getExistingConfigFiles(test.projectDir);
 
       expect(files.length).toBeGreaterThanOrEqual(3);
       expect(files.some((f) => f.includes('.claude/settings.json'))).toBe(true);
-      expect(files.some((f) => f.includes('.gencode/settings.json'))).toBe(true);
+      expect(files.some((f) => f.includes('.gen/settings.json'))).toBe(true);
       expect(files.some((f) => f.includes('settings.local.json'))).toBe(true);
     });
 

package/src/config/manager.test.ts

@@ -18,8 +18,8 @@ describe('ConfigManager', () => {
   afterEach(() => test.cleanup());
 
   describe('load', () => {
-    it('should load settings from .gencode directory', async () => {
-      await writeSettings(test.projectDir, 'gencode', { provider: 'anthropic', model: 'claude-sonnet' });
+    it('should load settings from .gen directory', async () => {
+      await writeSettings(test.projectDir, 'gen', { provider: 'anthropic', model: 'claude-sonnet' });
 
       const config = await new ConfigManager({ cwd: test.projectDir }).load();
 
@@ -36,9 +36,9 @@ describe('ConfigManager', () => {
       expect(config.settings.model).toBe('gpt-4');
     });
 
-    it('should merge both .claude and .gencode with gencode winning', async () => {
+    it('should merge both .claude and .gen with gencode winning', async () => {
       await writeSettings(test.projectDir, 'claude', { provider: 'openai', model: 'gpt-4', theme: 'dark' });
-      await writeSettings(test.projectDir, 'gencode', { provider: 'anthropic' });
+      await writeSettings(test.projectDir, 'gen', { provider: 'anthropic' });
 
       const config = await new ConfigManager({ cwd: test.projectDir }).load();
 
@@ -51,7 +51,7 @@ describe('ConfigManager', () => {
       await writeSettings(test.projectDir, 'claude', {
         permissions: { allow: ['Bash(git:*)'], deny: ['WebFetch'] },
       });
-      await writeSettings(test.projectDir, 'gencode', {
+      await writeSettings(test.projectDir, 'gen', {
         permissions: { allow: ['Bash(npm:*)'], deny: ['Bash(rm -rf:*)'] },
       });
 
@@ -64,8 +64,8 @@ describe('ConfigManager', () => {
     });
 
     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);
+      await writeSettings(test.projectDir, 'gen', { model: 'claude-sonnet', theme: 'light' });
+      await writeSettings(test.projectDir, 'gen', { model: 'claude-opus' }, true);
 
       const { settings } = await new ConfigManager({ cwd: test.projectDir }).load();
 
@@ -77,7 +77,7 @@ describe('ConfigManager', () => {
       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;
+      process.env.GEN_CONFIG = extraDir;
 
       const { settings } = await new ConfigManager({ cwd: test.projectDir }).load();
 
@@ -87,7 +87,7 @@ describe('ConfigManager', () => {
 
   describe('setCliArgs', () => {
     it('should apply CLI args with highest priority', async () => {
-      await writeSettings(test.projectDir, 'gencode', { model: 'claude-sonnet', provider: 'anthropic' });
+      await writeSettings(test.projectDir, 'gen', { model: 'claude-sonnet', provider: 'anthropic' });
 
       const manager = new ConfigManager({ cwd: test.projectDir });
       manager.setCliArgs({ model: 'gpt-4o' });
@@ -107,10 +107,10 @@ describe('ConfigManager', () => {
       await manager.saveToLevel({ debug: true }, 'local');
 
       const projectContent = JSON.parse(await fs.readFile(
-        path.join(test.projectDir, '.gencode', 'settings.json'), 'utf-8'
+        path.join(test.projectDir, '.gen', 'settings.json'), 'utf-8'
       ));
       const localContent = JSON.parse(await fs.readFile(
-        path.join(test.projectDir, '.gencode', 'settings.local.json'), 'utf-8'
+        path.join(test.projectDir, '.gen', 'settings.local.json'), 'utf-8'
       ));
 
       expect(projectContent.model).toBe('project-model');
@@ -118,14 +118,14 @@ describe('ConfigManager', () => {
     });
 
     it('should merge with existing settings', async () => {
-      await writeSettings(test.projectDir, 'gencode', { model: 'old', theme: 'dark' });
+      await writeSettings(test.projectDir, 'gen', { 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'
+        path.join(test.projectDir, '.gen', 'settings.json'), 'utf-8'
       ));
 
       expect(saved.model).toBe('new');
@@ -142,7 +142,7 @@ describe('ConfigManager', () => {
       await manager.addPermissionRule('Bash(rm:*)', 'deny', 'project');
 
       const saved = JSON.parse(await fs.readFile(
-        path.join(test.projectDir, '.gencode', 'settings.json'), 'utf-8'
+        path.join(test.projectDir, '.gen', 'settings.json'), 'utf-8'
       ));
 
       expect(saved.permissions?.allow).toContain('Bash(npm:*)');
@@ -152,7 +152,7 @@ describe('ConfigManager', () => {
 
   describe('getEffectivePermissions', () => {
     it('should return all permission lists', async () => {
-      await writeSettings(test.projectDir, 'gencode', {
+      await writeSettings(test.projectDir, 'gen', {
         permissions: { allow: ['A'], ask: ['B'], deny: ['C'] },
       });
 
@@ -168,7 +168,7 @@ describe('ConfigManager', () => {
 
   describe('isAllowed and shouldAsk', () => {
     it('should check permissions correctly', async () => {
-      await writeSettings(test.projectDir, 'gencode', {
+      await writeSettings(test.projectDir, 'gen', {
         permissions: { allow: ['Bash(git:*)'], deny: ['Bash(rm:*)'], ask: ['WebFetch'] },
       });
 
@@ -189,14 +189,14 @@ describe('ConfigManager', () => {
   describe('getSources', () => {
     it('should return all loaded sources', async () => {
       await writeSettings(test.projectDir, 'claude', { model: 'gpt-4' });
-      await writeSettings(test.projectDir, 'gencode', { provider: 'anthropic' });
+      await writeSettings(test.projectDir, 'gen', { 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();
+      expect(sources.find((s) => s.namespace === 'gen')).toBeDefined();
     });
   });
 
@@ -206,7 +206,7 @@ describe('ConfigManager', () => {
 
       expect(manager.getDebugSummary()).toBe('Configuration not loaded');
 
-      await writeSettings(test.projectDir, 'gencode', { model: 'test' });
+      await writeSettings(test.projectDir, 'gen', { model: 'test' });
       await manager.load();
 
       expect(manager.getDebugSummary()).toContain('Configuration Sources');