gencode-ai 0.1.0 → 0.1.2

package/src/config/levels.test.ts

@@ -0,0 +1,163 @@
+/**
+ * Config Levels Tests
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import {
+  findProjectRoot,
+  parseExtraConfigDirs,
+  getConfigLevels,
+  getPrimarySettingsDir,
+  getSettingsFilePath,
+} from './levels.js';
+import { createTestProject, type TestProject } from './test-utils.js';
+
+describe('findProjectRoot', () => {
+  let test: TestProject;
+
+  beforeEach(async () => {
+    test = await createTestProject('gencode-levels-');
+  });
+
+  afterEach(() => test.cleanup());
+
+  it('should find git root', async () => {
+    const subDir = path.join(test.projectDir, 'src', 'components');
+    await fs.mkdir(subDir, { recursive: true });
+
+    expect(await findProjectRoot(subDir)).toBe(test.projectDir);
+  });
+
+  it('should find .gencode directory as project root', async () => {
+    // Remove .git, add .gencode
+    await fs.rm(path.join(test.projectDir, '.git'), { recursive: true });
+    await fs.mkdir(path.join(test.projectDir, '.gencode'));
+    const subDir = path.join(test.projectDir, 'src');
+    await fs.mkdir(subDir, { recursive: true });
+
+    expect(await findProjectRoot(subDir)).toBe(test.projectDir);
+  });
+
+  it('should find .claude directory as project root', async () => {
+    await fs.rm(path.join(test.projectDir, '.git'), { recursive: true });
+    await fs.mkdir(path.join(test.projectDir, '.claude'));
+    const subDir = path.join(test.projectDir, 'lib');
+    await fs.mkdir(subDir, { recursive: true });
+
+    expect(await findProjectRoot(subDir)).toBe(test.projectDir);
+  });
+
+  it('should return cwd if no project markers found', async () => {
+    const subDir = path.join(test.tempDir, 'random', 'path');
+    await fs.mkdir(subDir, { recursive: true });
+
+    expect(await findProjectRoot(subDir)).toBe(subDir);
+  });
+});
+
+describe('parseExtraConfigDirs', () => {
+  const originalEnv = process.env.GENCODE_CONFIG_DIRS;
+
+  afterEach(() => {
+    if (originalEnv === undefined) {
+      delete process.env.GENCODE_CONFIG_DIRS;
+    } else {
+      process.env.GENCODE_CONFIG_DIRS = originalEnv;
+    }
+  });
+
+  it('should return empty array when env var not set', () => {
+    delete process.env.GENCODE_CONFIG_DIRS;
+    expect(parseExtraConfigDirs()).toEqual([]);
+  });
+
+  it('should parse single directory', () => {
+    process.env.GENCODE_CONFIG_DIRS = '/team/config';
+    expect(parseExtraConfigDirs()).toEqual(['/team/config']);
+  });
+
+  it('should parse multiple directories', () => {
+    process.env.GENCODE_CONFIG_DIRS = '/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';
+    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  ';
+    expect(parseExtraConfigDirs()).toEqual(['/path/one', '/path/two']);
+  });
+});
+
+describe('getConfigLevels', () => {
+  let test: TestProject;
+
+  beforeEach(async () => {
+    test = await createTestProject('gencode-levels-');
+  });
+
+  afterEach(() => test.cleanup());
+
+  it('should return levels in priority order', async () => {
+    const types = (await getConfigLevels(test.projectDir)).map((l) => l.type);
+
+    expect(types.indexOf('user')).toBeLessThan(types.indexOf('project'));
+    expect(types.indexOf('project')).toBeLessThan(types.indexOf('local'));
+    expect(types.indexOf('local')).toBeLessThan(types.indexOf('managed'));
+  });
+
+  it('should include both claude and gencode paths at each level', async () => {
+    const userLevel = (await getConfigLevels(test.projectDir)).find((l) => l.type === 'user');
+
+    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);
+  });
+
+  it('should include extra dirs when env var is set', async () => {
+    process.env.GENCODE_CONFIG_DIRS = '/team/config';
+    const extraLevels = (await getConfigLevels(test.projectDir)).filter((l) => l.type === 'extra');
+
+    expect(extraLevels.length).toBeGreaterThan(0);
+  });
+
+  it('should have claude before gencode in each level (for merge order)', async () => {
+    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');
+        if (claudeIdx !== -1 && gencodeIdx !== -1) {
+          expect(claudeIdx).toBeLessThan(gencodeIdx);
+        }
+      }
+    }
+  });
+});
+
+describe('getPrimarySettingsDir', () => {
+  it('should return ~/.gencode for user level', () => {
+    expect(getPrimarySettingsDir('user', '/project')).toBe(path.join(os.homedir(), '.gencode'));
+  });
+
+  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');
+  });
+});
+
+describe('getSettingsFilePath', () => {
+  it('should return correct paths for each level', () => {
+    expect(getSettingsFilePath('user', '/project'))
+      .toBe(path.join(os.homedir(), '.gencode', 'settings.json'));
+    expect(getSettingsFilePath('project', '/my/project'))
+      .toBe('/my/project/.gencode/settings.json');
+    expect(getSettingsFilePath('local', '/my/project'))
+      .toBe('/my/project/.gencode/settings.local.json');
+  });
+});

package/src/config/levels.ts

@@ -0,0 +1,285 @@
+/**
+ * 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.
+ */
+
+import * as path from 'path';
+import * as os from 'os';
+import * as fs from 'fs/promises';
+import {
+  ConfigLevelType,
+  GENCODE_DIR,
+  CLAUDE_DIR,
+  SETTINGS_FILE_NAME,
+  SETTINGS_LOCAL_FILE_NAME,
+  MANAGED_SETTINGS_FILE_NAME,
+  GENCODE_CONFIG_DIRS_ENV,
+  getManagedPaths,
+} from './types.js';
+
+/**
+ * Configuration path info for a specific namespace
+ */
+export interface ConfigPathInfo {
+  settingsPath: string;
+  localSettingsPath?: string;
+  dir: string;
+  namespace: 'gencode' | 'claude' | 'extra';
+  exists: boolean;
+}
+
+/**
+ * Configuration level with resolved paths
+ */
+export interface ResolvedLevel {
+  type: ConfigLevelType;
+  priority: number;
+  paths: ConfigPathInfo[];
+  description: string;
+}
+
+/**
+ * Find the project root by walking up the directory tree
+ */
+export async function findProjectRoot(cwd: string): Promise<string> {
+  let current = path.resolve(cwd);
+  const root = path.parse(current).root;
+
+  while (current !== root) {
+    // Check for git directory
+    try {
+      await fs.access(path.join(current, '.git'));
+      return current;
+    } catch {
+      // Not a git root, continue
+    }
+
+    // Check for .gencode or .claude directories
+    try {
+      await fs.access(path.join(current, GENCODE_DIR));
+      return current;
+    } catch {
+      // Continue
+    }
+
+    try {
+      await fs.access(path.join(current, CLAUDE_DIR));
+      return current;
+    } catch {
+      // Continue
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+
+  return cwd;
+}
+
+/**
+ * Check if a path exists
+ */
+async function pathExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Parse GENCODE_CONFIG_DIRS environment variable
+ */
+export function parseExtraConfigDirs(): string[] {
+  const value = process.env[GENCODE_CONFIG_DIRS_ENV];
+  if (!value) return [];
+
+  return value
+    .split(':')
+    .map((dir) => dir.trim())
+    .filter((dir) => dir.length > 0)
+    .map((dir) => dir.replace(/^~/, os.homedir()));
+}
+
+/**
+ * Get all configuration levels with resolved paths
+ */
+export async function getConfigLevels(cwd: string): Promise<ResolvedLevel[]> {
+  const projectRoot = await findProjectRoot(cwd);
+  const home = os.homedir();
+  const managedPaths = getManagedPaths();
+  const extraDirs = parseExtraConfigDirs();
+
+  const levels: ResolvedLevel[] = [];
+
+  // Level 1: User (lowest priority for settings, loaded first)
+  const userPaths: ConfigPathInfo[] = [];
+
+  // Claude first (lower priority within level)
+  const userClaudeDir = path.join(home, CLAUDE_DIR);
+  userPaths.push({
+    settingsPath: path.join(userClaudeDir, SETTINGS_FILE_NAME),
+    dir: userClaudeDir,
+    namespace: 'claude',
+    exists: await pathExists(path.join(userClaudeDir, SETTINGS_FILE_NAME)),
+  });
+
+  // GenCode second (higher priority within level)
+  const userGencodeDir = path.join(home, GENCODE_DIR);
+  userPaths.push({
+    settingsPath: path.join(userGencodeDir, SETTINGS_FILE_NAME),
+    dir: userGencodeDir,
+    namespace: 'gencode',
+    exists: await pathExists(path.join(userGencodeDir, SETTINGS_FILE_NAME)),
+  });
+
+  levels.push({
+    type: 'user',
+    priority: 10,
+    paths: userPaths,
+    description: 'User global settings',
+  });
+
+  // Level 2: Extra config dirs from environment variable
+  if (extraDirs.length > 0) {
+    for (let i = 0; i < extraDirs.length; i++) {
+      const dir = extraDirs[i];
+      const extraPaths: ConfigPathInfo[] = [
+        {
+          settingsPath: path.join(dir, SETTINGS_FILE_NAME),
+          dir,
+          namespace: 'extra',
+          exists: await pathExists(path.join(dir, SETTINGS_FILE_NAME)),
+        },
+      ];
+
+      levels.push({
+        type: 'extra',
+        priority: 20 + i, // Each extra dir has slightly higher priority
+        paths: extraPaths,
+        description: `Extra config from ${dir}`,
+      });
+    }
+  }
+
+  // Level 3: Project (shared, committed to git)
+  const projectPaths: ConfigPathInfo[] = [];
+
+  // Claude first (lower priority within level)
+  const projectClaudeDir = path.join(projectRoot, CLAUDE_DIR);
+  projectPaths.push({
+    settingsPath: path.join(projectClaudeDir, SETTINGS_FILE_NAME),
+    dir: projectClaudeDir,
+    namespace: 'claude',
+    exists: await pathExists(path.join(projectClaudeDir, SETTINGS_FILE_NAME)),
+  });
+
+  // GenCode second (higher priority within level)
+  const projectGencodeDir = path.join(projectRoot, GENCODE_DIR);
+  projectPaths.push({
+    settingsPath: path.join(projectGencodeDir, SETTINGS_FILE_NAME),
+    dir: projectGencodeDir,
+    namespace: 'gencode',
+    exists: await pathExists(path.join(projectGencodeDir, SETTINGS_FILE_NAME)),
+  });
+
+  levels.push({
+    type: 'project',
+    priority: 30,
+    paths: projectPaths,
+    description: 'Project shared settings',
+  });
+
+  // Level 4: Local (personal, gitignored)
+  const localPaths: ConfigPathInfo[] = [];
+
+  // Claude first (lower priority within level)
+  localPaths.push({
+    settingsPath: path.join(projectClaudeDir, SETTINGS_LOCAL_FILE_NAME),
+    dir: projectClaudeDir,
+    namespace: 'claude',
+    exists: await pathExists(path.join(projectClaudeDir, SETTINGS_LOCAL_FILE_NAME)),
+  });
+
+  // GenCode second (higher priority within level)
+  localPaths.push({
+    settingsPath: path.join(projectGencodeDir, SETTINGS_LOCAL_FILE_NAME),
+    dir: projectGencodeDir,
+    namespace: 'gencode',
+    exists: await pathExists(path.join(projectGencodeDir, SETTINGS_LOCAL_FILE_NAME)),
+  });
+
+  levels.push({
+    type: 'local',
+    priority: 40,
+    paths: localPaths,
+    description: 'Local personal settings (gitignored)',
+  });
+
+  // Level 5: Managed (highest priority, enforced)
+  const managedPathsList: ConfigPathInfo[] = [];
+
+  // Claude first (lower priority within level)
+  managedPathsList.push({
+    settingsPath: path.join(managedPaths.claude, MANAGED_SETTINGS_FILE_NAME),
+    dir: managedPaths.claude,
+    namespace: 'claude',
+    exists: await pathExists(path.join(managedPaths.claude, MANAGED_SETTINGS_FILE_NAME)),
+  });
+
+  // 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)),
+  });
+
+  levels.push({
+    type: 'managed',
+    priority: 100, // Highest priority
+    paths: managedPathsList,
+    description: 'System-wide managed settings (enforced)',
+  });
+
+  // Sort by priority (ascending, so we merge from low to high)
+  return levels.sort((a, b) => a.priority - b.priority);
+}
+
+/**
+ * Get the primary settings directory for saving
+ * Prefers .gencode if it exists, otherwise creates it
+ */
+export function getPrimarySettingsDir(
+  level: 'user' | 'project' | 'local',
+  projectRoot: string
+): string {
+  const home = os.homedir();
+
+  switch (level) {
+    case 'user':
+      return path.join(home, GENCODE_DIR);
+    case 'project':
+    case 'local':
+      return path.join(projectRoot, GENCODE_DIR);
+    default:
+      return path.join(home, GENCODE_DIR);
+  }
+}
+
+/**
+ * Get the settings file path for a specific level
+ */
+export function getSettingsFilePath(
+  level: 'user' | 'project' | 'local',
+  projectRoot: string
+): string {
+  const dir = getPrimarySettingsDir(level, projectRoot);
+  const fileName = level === 'local' ? SETTINGS_LOCAL_FILE_NAME : SETTINGS_FILE_NAME;
+  return path.join(dir, fileName);
+}

package/src/config/loader.test.ts

@@ -0,0 +1,120 @@
+/**
+ * Config Loader Tests
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import {
+  loadAllSources,
+  loadSourcesByLevel,
+  loadProjectSettings,
+  getExistingConfigFiles,
+} from './loader.js';
+import { createTestProject, writeSettings, type TestProject } from './test-utils.js';
+
+describe('Config Loader', () => {
+  let test: TestProject;
+
+  beforeEach(async () => {
+    test = await createTestProject('gencode-loader-');
+  });
+
+  afterEach(() => test.cleanup());
+
+  describe('loadAllSources', () => {
+    it('should load settings from project .claude directory', async () => {
+      await writeSettings(test.projectDir, 'claude', { provider: 'openai' });
+      const sources = await loadAllSources(test.projectDir);
+
+      const source = sources.find((s) => s.level === 'project' && s.namespace === 'claude');
+      expect(source?.settings.provider).toBe('openai');
+    });
+
+    it('should load settings from project .gencode directory', async () => {
+      await writeSettings(test.projectDir, 'gencode', { provider: 'anthropic' });
+      const sources = await loadAllSources(test.projectDir);
+
+      const source = sources.find((s) => s.level === 'project' && s.namespace === 'gencode');
+      expect(source?.settings.provider).toBe('anthropic');
+    });
+
+    it('should load both .claude and .gencode settings at same level', async () => {
+      await writeSettings(test.projectDir, 'claude', { provider: 'openai', model: 'gpt-4' });
+      await writeSettings(test.projectDir, 'gencode', { 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');
+
+      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);
+      const sources = await loadAllSources(test.projectDir);
+
+      const local = sources.find((s) => s.level === 'local');
+      expect(local?.settings.alwaysThinkingEnabled).toBe(true);
+    });
+
+    it('should load from extra config dirs', async () => {
+      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;
+
+      const sources = await loadAllSources(test.projectDir);
+      const extra = sources.find((s) => s.level === 'extra');
+      expect(extra?.settings.theme).toBe('dark');
+    });
+  });
+
+  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' });
+
+      const sourcesByLevel = await loadSourcesByLevel(test.projectDir);
+
+      expect(sourcesByLevel.has('project')).toBe(true);
+      expect(sourcesByLevel.get('project')?.length).toBe(2);
+    });
+  });
+
+  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);
+
+      const sources = await loadProjectSettings(test.projectDir);
+
+      expect(sources.length).toBe(1);
+      expect(sources[0].level).toBe('project');
+      expect(sources[0].settings.model).toBe('claude-sonnet');
+    });
+  });
+
+  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);
+
+      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('settings.local.json'))).toBe(true);
+    });
+
+    it('should return array when no config files exist', async () => {
+      const emptyDir = path.join(test.tempDir, 'empty');
+      await fs.mkdir(emptyDir, { recursive: true });
+
+      expect(Array.isArray(await getExistingConfigFiles(emptyDir))).toBe(true);
+    });
+  });
+});