gencode-ai 0.1.1 → 0.1.3

package/src/cli/components/index.ts

@@ -19,3 +19,10 @@ export { PromptInput, ConfirmPrompt } from './Input.js';
 export { colors, icons } from './theme.js';
 export { ModelSelector } from './ModelSelector.js';
 export { CommandSuggestions, COMMANDS, getFilteredCommands } from './CommandSuggestions.js';
+export {
+  PermissionPrompt,
+  SimpleConfirmPrompt,
+  PermissionRulesDisplay,
+  PermissionAuditDisplay,
+} from './PermissionPrompt.js';
+export { QuestionPrompt, AnswerDisplay } from './QuestionPrompt.js';

package/src/cli/components/theme.ts

@@ -35,9 +35,19 @@ export const icons = {
   // UI
   thinking: '✱', // Star for thinking state
   cursor: '▋',
-  // Selection
+  // Selection (single-select)
   radio: '●', // Filled radio for selected
   radioEmpty: '○', // Empty radio for unselected
+  // Selection (multi-select)
+  checkbox: '☑', // Checked checkbox
+  checkboxEmpty: '☐', // Empty checkbox
+  // Chip/tag borders (Claude Code style headers)
+  chipLeft: '╭─',
+  chipRight: '─╮',
+  // Box drawing
+  boxTop: '╭',
+  boxBottom: '╰',
+  boxVertical: '│',
   // Tree connectors
   treeEnd: '└', // Tree end connector for tool results
 };

package/src/cli/index.tsx

@@ -88,10 +88,21 @@ function detectConfig(settings: Settings, providersConfig: ProvidersConfigManage
 // ============================================================================
 function parseArgs() {
   const args = process.argv.slice(2);
+
+  // Extract prompt value from -p "message" or --prompt "message"
+  let prompt: string | undefined;
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === '-p' || args[i] === '--prompt') && args[i + 1]) {
+      prompt = args[i + 1];
+      break;
+    }
+  }
+
   return {
     continue: args.includes('-c') || args.includes('--continue'),
     resume: args.includes('-r') || args.includes('--resume'),
     help: args.includes('-h') || args.includes('--help'),
+    prompt,
   };
 }
 
@@ -102,17 +113,47 @@ function printUsage(): void {
   console.log('  Usage: gencode [options]');
   console.log();
   console.log('  Options:');
-  console.log('    -c, --continue    Resume the most recent session');
-  console.log('    -r, --resume      Select a session interactively');
-  console.log('    -h, --help        Show this help');
+  console.log('    -c, --continue       Resume the most recent session');
+  console.log('    -r, --resume         Select a session interactively');
+  console.log('    -p, --prompt <msg>   Run a single prompt (non-interactive)');
+  console.log('    -h, --help           Show this help');
   console.log();
   console.log('  Examples:');
-  console.log('    gencode              Start new session');
-  console.log('    gencode -c           Continue last session');
-  console.log('    gencode -r           Pick a session');
+  console.log('    gencode                    Start new session');
+  console.log('    gencode -c                 Continue last session');
+  console.log('    gencode -r                 Pick a session');
+  console.log('    gencode -p "2+2"           Run single prompt');
   console.log();
 }
 
+// ============================================================================
+// Non-interactive mode
+// ============================================================================
+async function runNonInteractive(prompt: string, config: AgentConfig): Promise<void> {
+  const { Agent } = await import('../agent/agent.js');
+
+  const agent = new Agent(config);
+
+  let response = '';
+  for await (const event of agent.run(prompt)) {
+    switch (event.type) {
+      case 'text':
+        response += event.text;
+        break;
+      case 'tool_start':
+        console.error(`[tool] ${event.name}`);
+        break;
+      case 'error':
+        console.error(`[error] ${event.error.message}`);
+        break;
+      case 'done':
+        break;
+    }
+  }
+
+  console.log(response);
+}
+
 // ============================================================================
 // Main
 // ============================================================================
@@ -135,12 +176,19 @@ async function main() {
 
   const config = detectConfig(settings, providersConfig);
 
+  // Non-interactive mode with -p flag
+  if (args.prompt) {
+    await runNonInteractive(args.prompt, config);
+    return;
+  }
+
   // Render the Ink app
   render(
     <App
       config={config}
       settingsManager={settingsManager}
       resumeLatest={args.continue}
+      permissionSettings={settings.permissions}
     />
   );
 }

package/src/config/index.ts

@@ -1,8 +1,82 @@
 /**
- * Config Module Exports
+ * Configuration Module - Multi-level configuration system (Claude Code compatible)
+ *
+ * This module provides a hierarchical configuration system that:
+ * - Supports multiple levels: user, project, local, managed
+ * - Merges .gencode and .claude directories at each level (gencode wins)
+ * - Supports GENCODE_CONFIG_DIRS environment variable for extra config dirs
+ * - Enforces managed settings that cannot be overridden
  */
 
-export { SettingsManager } from './manager.js';
+// Core types
+export type {
+  Settings,
+  SettingsManagerOptions,
+  ProviderName,
+  PermissionRules,
+  ConfigLevelType,
+  ConfigLevel,
+  ConfigSource,
+  MergedConfig,
+  ProvidersConfig,
+  ProviderConnection,
+  CachedModel,
+  ProviderModels,
+} from './types.js';
+
+// Constants
+export {
+  DEFAULT_SETTINGS_DIR,
+  PROJECT_SETTINGS_DIR,
+  FALLBACK_SETTINGS_DIR,
+  FALLBACK_PROJECT_DIR,
+  SETTINGS_FILE_NAME,
+  SETTINGS_LOCAL_FILE_NAME,
+  MANAGED_SETTINGS_FILE_NAME,
+  PROVIDERS_FILE_NAME,
+  GENCODE_DIR,
+  CLAUDE_DIR,
+  USER_GENCODE_DIR,
+  USER_CLAUDE_DIR,
+  GENCODE_CONFIG_DIRS_ENV,
+  getManagedPaths,
+} from './types.js';
+
+// Configuration levels
+export {
+  findProjectRoot,
+  parseExtraConfigDirs,
+  getConfigLevels,
+  getPrimarySettingsDir,
+  getSettingsFilePath,
+  type ConfigPathInfo,
+  type ResolvedLevel,
+} from './levels.js';
+
+// Configuration loader
+export {
+  loadAllSources,
+  loadSourcesByLevel,
+  loadUserSettings,
+  loadProjectSettings,
+  loadManagedSettings,
+  getConfigInfo,
+  getExistingConfigFiles,
+} from './loader.js';
+
+// Configuration merger
+export {
+  deepMerge,
+  mergeSettings,
+  extractManagedDeny,
+  applyManagedRestrictions,
+  mergeAllSources,
+  mergeWithCliArgs,
+  createMergeSummary,
+} from './merger.js';
+
+// Configuration managers
+export { ConfigManager, SettingsManager } from './manager.js';
+
+// Providers configuration
 export { ProvidersConfigManager } from './providers-config.js';
-export type { Settings, SettingsManagerOptions, ProviderName, ProvidersConfig } from './types.js';
-export { DEFAULT_SETTINGS_DIR, SETTINGS_FILE_NAME, PROVIDERS_FILE_NAME } from './types.js';

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