gencode-ai 0.1.1 → 0.1.2

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);
+    });
+  });
+});

package/src/config/loader.ts

@@ -0,0 +1,178 @@
+/**
+ * Configuration Loader - Load settings from various sources
+ *
+ * Loads configuration files from all levels and namespaces.
+ * Each level loads both .gencode and .claude directories.
+ */
+
+import * as fs from 'fs/promises';
+import type { Settings, ConfigSource, ConfigLevelType } from './types.js';
+import { getConfigLevels, type ResolvedLevel, type ConfigPathInfo } from './levels.js';
+
+/**
+ * Load a single JSON settings file
+ */
+async function loadJsonFile(filePath: string): Promise<Settings | null> {
+  try {
+    const content = await fs.readFile(filePath, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load settings from a specific path info
+ */
+async function loadFromPathInfo(
+  pathInfo: ConfigPathInfo,
+  levelType: ConfigLevelType
+): Promise<ConfigSource | null> {
+  const settings = await loadJsonFile(pathInfo.settingsPath);
+  if (!settings) return null;
+
+  return {
+    level: levelType,
+    path: pathInfo.settingsPath,
+    namespace: pathInfo.namespace,
+    settings,
+  };
+}
+
+/**
+ * Load all configuration sources in order
+ *
+ * Returns an array of ConfigSource in priority order (lowest first).
+ * Within each level:
+ * - .claude is loaded first (lower priority)
+ * - .gencode is loaded second (higher priority)
+ *
+ * This allows proper merging where:
+ * - Later sources override earlier ones
+ * - GenCode settings override Claude settings at the same level
+ */
+export async function loadAllSources(cwd: string): Promise<ConfigSource[]> {
+  const levels = await getConfigLevels(cwd);
+  const sources: ConfigSource[] = [];
+
+  for (const level of levels) {
+    // Load from each path in the level (claude first, then gencode)
+    for (const pathInfo of level.paths) {
+      const source = await loadFromPathInfo(pathInfo, level.type);
+      if (source) {
+        sources.push(source);
+      }
+    }
+  }
+
+  return sources;
+}
+
+/**
+ * Load configuration sources grouped by level
+ */
+export async function loadSourcesByLevel(
+  cwd: string
+): Promise<Map<ConfigLevelType, ConfigSource[]>> {
+  const levels = await getConfigLevels(cwd);
+  const sourcesByLevel = new Map<ConfigLevelType, ConfigSource[]>();
+
+  for (const level of levels) {
+    const levelSources: ConfigSource[] = [];
+
+    for (const pathInfo of level.paths) {
+      const source = await loadFromPathInfo(pathInfo, level.type);
+      if (source) {
+        levelSources.push(source);
+      }
+    }
+
+    if (levelSources.length > 0) {
+      sourcesByLevel.set(level.type, levelSources);
+    }
+  }
+
+  return sourcesByLevel;
+}
+
+/**
+ * Load only user-level settings
+ */
+export async function loadUserSettings(cwd: string): Promise<ConfigSource[]> {
+  const levels = await getConfigLevels(cwd);
+  const userLevel = levels.find((l) => l.type === 'user');
+  if (!userLevel) return [];
+
+  const sources: ConfigSource[] = [];
+  for (const pathInfo of userLevel.paths) {
+    const source = await loadFromPathInfo(pathInfo, 'user');
+    if (source) {
+      sources.push(source);
+    }
+  }
+
+  return sources;
+}
+
+/**
+ * Load only project-level settings
+ */
+export async function loadProjectSettings(cwd: string): Promise<ConfigSource[]> {
+  const levels = await getConfigLevels(cwd);
+  const projectLevel = levels.find((l) => l.type === 'project');
+  if (!projectLevel) return [];
+
+  const sources: ConfigSource[] = [];
+  for (const pathInfo of projectLevel.paths) {
+    const source = await loadFromPathInfo(pathInfo, 'project');
+    if (source) {
+      sources.push(source);
+    }
+  }
+
+  return sources;
+}
+
+/**
+ * Load only managed settings
+ */
+export async function loadManagedSettings(cwd: string): Promise<ConfigSource[]> {
+  const levels = await getConfigLevels(cwd);
+  const managedLevel = levels.find((l) => l.type === 'managed');
+  if (!managedLevel) return [];
+
+  const sources: ConfigSource[] = [];
+  for (const pathInfo of managedLevel.paths) {
+    const source = await loadFromPathInfo(pathInfo, 'managed');
+    if (source) {
+      sources.push(source);
+    }
+  }
+
+  return sources;
+}
+
+/**
+ * Get information about all configuration levels
+ */
+export async function getConfigInfo(cwd: string): Promise<ResolvedLevel[]> {
+  return getConfigLevels(cwd);
+}
+
+/**
+ * Check which config files exist
+ */
+export async function getExistingConfigFiles(cwd: string): Promise<string[]> {
+  const levels = await getConfigLevels(cwd);
+  const existingFiles: string[] = [];
+
+  for (const level of levels) {
+    for (const pathInfo of level.paths) {
+      if (pathInfo.exists) {
+        existingFiles.push(pathInfo.settingsPath);
+      }
+    }
+  }
+
+  return existingFiles;
+}