k0ntext 3.3.0 → 3.3.1

package/src/cli/repl/tui/panels/config.ts

@@ -0,0 +1,457 @@
+/**
+ * Configuration UI Panel
+ *
+ * Visual configuration management for k0ntext settings
+ */
+
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { K0NTEXT_THEME } from '../theme.js';
+import { input, confirm, select, checkbox } from '@inquirer/prompts';
+
+/**
+ * Config category
+ */
+interface ConfigCategory {
+  name: string;
+  description: string;
+  keys: ConfigKey[];
+}
+
+/**
+ * Config key definition
+ */
+interface ConfigKey {
+  name: string;
+  type: 'string' | 'number' | 'boolean' | 'array';
+  description: string;
+  options?: string[];
+  validate?: (value: string) => boolean | string;
+  defaultValue?: unknown;
+}
+
+/**
+ * All configuration definitions
+ */
+const CONFIG_DEFINITIONS: Record<string, ConfigCategory> = {
+  'Project': {
+    name: 'Project',
+    description: 'Project-specific settings',
+    keys: [
+      {
+        name: 'projectType',
+        type: 'string',
+        description: 'Type of project (monorepo, webapp, library, api, cli)',
+        options: ['monorepo', 'webapp', 'library', 'api', 'cli', 'unknown'],
+        defaultValue: 'unknown'
+      },
+      {
+        name: 'maxFilesPerIndex',
+        type: 'number',
+        description: 'Maximum code files to index per module (batch indexing)',
+        defaultValue: 500
+      },
+      {
+        name: 'indexBatchSize',
+        type: 'number',
+        description: 'Files per batch during indexing',
+        defaultValue: 100
+      }
+    ]
+  },
+  'AI Tools': {
+    name: 'AI Tools',
+    description: 'AI coding assistant configuration',
+    keys: [
+      {
+        name: 'aiTools',
+        type: 'array',
+        description: 'Enabled AI tools',
+        options: ['claude', 'copilot', 'cline', 'cursor', 'windsurf', 'aider', 'continue', 'gemini'],
+        defaultValue: ['claude']
+      },
+      {
+        name: 'openrouterKey',
+        type: 'string',
+        description: 'OpenRouter API key for intelligent analysis',
+        validate: (value) => value.startsWith('sk-or-v1-') || value === '',
+        defaultValue: ''
+      },
+      {
+        name: 'generateEmbeddings',
+        type: 'boolean',
+        description: 'Automatically generate embeddings during indexing',
+        defaultValue: true
+      }
+    ]
+  },
+  'Features': {
+    name: 'Features',
+    description: 'Enabled k0ntext features',
+    keys: [
+      {
+        name: 'features',
+        type: 'array',
+        description: 'Enabled features',
+        options: ['stats', 'search', 'docs', 'drift', 'workflows', 'mcp'],
+        defaultValue: ['stats', 'search']
+      },
+      {
+        name: 'autoUpdate',
+        type: 'boolean',
+        description: 'Check for updates on startup',
+        defaultValue: true
+      },
+      {
+        name: 'updateCheckInterval',
+        type: 'number',
+        description: 'Update check interval (hours)',
+        defaultValue: 24
+      }
+    ]
+  },
+  'Display': {
+    name: 'Display',
+    description: 'UI and theme settings',
+    keys: [
+      {
+        name: 'theme',
+        type: 'string',
+        description: 'Color theme',
+        options: ['default', 'dark', 'light', 'high-contrast'],
+        defaultValue: 'default'
+      },
+      {
+        name: 'showTimestamps',
+        type: 'boolean',
+        description: 'Show timestamps in command output',
+        defaultValue: true
+      },
+      {
+        name: 'compactMode',
+        type: 'boolean',
+        description: 'Use compact output for large result sets',
+        defaultValue: false
+      }
+    ]
+  }
+};
+
+/**
+ * Configuration UI Panel
+ */
+export class ConfigPanel {
+  private projectRoot: string;
+  private configPath: string;
+  private sessionConfig: Record<string, unknown>;
+
+  constructor(projectRoot: string, sessionConfig: Record<string, unknown>) {
+    this.projectRoot = projectRoot;
+    this.configPath = path.join(projectRoot, '.k0ntext', 'config.json');
+    this.sessionConfig = sessionConfig;
+  }
+
+  /**
+   * Display current configuration
+   */
+  displayConfig(): string {
+    const lines: string[] = [];
+
+    lines.push('');
+    lines.push(K0NTEXT_THEME.header('━━━ Configuration ━━━'));
+    lines.push('');
+
+    // Group by category
+    for (const [categoryId, category] of Object.entries(CONFIG_DEFINITIONS)) {
+      lines.push(`  ${K0NTEXT_THEME.header(category.name)} - ${K0NTEXT_THEME.dim(category.description)}`);
+      lines.push('');
+
+      for (const key of category.keys) {
+        const value = this.getValue(key.name);
+        const displayValue = this.formatValue(value, key);
+
+        lines.push(`    ${K0NTEXT_THEME.cyan(key.name.padEnd(25))} ${displayValue}`);
+        lines.push(`    ${K0NTEXT_THEME.dim(key.description)}`);
+        lines.push('');
+      }
+    }
+
+    lines.push(`  ${K0NTEXT_THEME.dim('Config file:')} ${this.configPath}`);
+    lines.push('');
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Interactive configuration editor
+   */
+  async interactiveConfig(category?: string): Promise<void> {
+    const targetCategory = category || await this.selectCategory();
+
+    if (!targetCategory) {
+      return; // User cancelled
+    }
+
+    const configDef = CONFIG_DEFINITIONS[targetCategory];
+    if (!configDef) {
+      return;
+    }
+
+    console.log('');
+    console.log(K0NTEXT_THEME.info(`Editing ${configDef.name} settings...`));
+    console.log('');
+
+    for (const key of configDef.keys) {
+      const newValue = await this.promptForKey(key);
+      if (newValue !== undefined) {
+        this.setValue(key.name, newValue);
+        console.log(K0NTEXT_THEME.success(`✓ Set ${key.name} = ${this.formatValue(newValue, key)}`));
+      }
+    }
+
+    await this.saveConfig();
+    console.log('');
+    console.log(K0NTEXT_THEME.success('✓ Configuration saved'));
+  }
+
+  /**
+   * Select a category to edit
+   */
+  private async selectCategory(): Promise<string | undefined> {
+    const choices = Object.entries(CONFIG_DEFINITIONS).map(([id, cat]) => ({
+      name: `${cat.name} - ${cat.description}`,
+      value: id
+    }));
+
+    const { configCategory } = this.sessionConfig as any;
+
+    const result = await select({
+      message: 'Select configuration category:',
+      choices: [
+        ...choices,
+        { name: 'Cancel', value: 'cancel' }
+      ],
+      default: configCategory || choices[0]?.value
+    });
+
+    return result === 'cancel' ? undefined : result;
+  }
+
+  /**
+   * Prompt user for a configuration value
+   */
+  private async promptForKey(key: ConfigKey): Promise<unknown> {
+    const currentValue = this.getValue(key.name);
+
+    switch (key.type) {
+      case 'boolean':
+        return await confirm({
+          message: key.description,
+          default: Boolean(currentValue || key.defaultValue)
+        });
+
+      case 'array':
+        if (key.options) {
+          const selected = await checkbox({
+            message: key.description,
+            choices: key.options.map(opt => ({
+              name: opt,
+              value: opt,
+              checked: Array.isArray(currentValue) ? currentValue.includes(opt) : false
+            }))
+          });
+          return selected.length > 0 ? selected : key.defaultValue;
+        }
+        return currentValue || key.defaultValue;
+
+      case 'string':
+        if (key.options) {
+          return await select({
+            message: key.description,
+            choices: key.options.map(opt => ({ name: opt, value: opt })),
+            default: currentValue || key.defaultValue
+          });
+        }
+
+        if (key.name === 'openrouterKey') {
+          const result = await input({
+            message: key.description,
+            default: String(currentValue || ''),
+            validate: key.validate
+          });
+          return result;
+        }
+
+        return await input({
+          message: key.description,
+          default: String(currentValue || key.defaultValue || '')
+        });
+
+      case 'number':
+        const inputResult = await input({
+          message: key.description,
+          default: String(currentValue || key.defaultValue || ''),
+          validate: (value) => {
+            const num = Number(value);
+            return !isNaN(num) && num >= 0;
+          }
+        });
+        return Number(inputResult);
+
+      default:
+        return currentValue;
+    }
+  }
+
+  /**
+   * Get a configuration value
+   */
+  getValue(name: string): unknown {
+    // Check session config first
+    if (name in this.sessionConfig) {
+      return this.sessionConfig[name];
+    }
+
+    // Check file config
+    if (fs.existsSync(this.configPath)) {
+      try {
+        const fileConfig = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+        return fileConfig[name];
+      } catch {
+        // Invalid JSON, ignore
+      }
+    }
+
+    // Return default
+    for (const category of Object.values(CONFIG_DEFINITIONS)) {
+      for (const key of category.keys) {
+        if (key.name === name) {
+          return key.defaultValue;
+        }
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Set a configuration value
+   */
+  setValue(name: string, value: unknown): void {
+    // Update session config
+    this.sessionConfig[name] = value;
+  }
+
+  /**
+   * Save configuration to file
+   */
+  async saveConfig(): Promise<void> {
+    const configDir = path.dirname(this.configPath);
+
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+
+    // Merge with existing config
+    let existingConfig = {};
+    if (fs.existsSync(this.configPath)) {
+      try {
+        existingConfig = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+      } catch {
+        // Invalid JSON, start fresh
+      }
+    }
+
+    const mergedConfig = { ...existingConfig, ...this.sessionConfig };
+    fs.writeFileSync(this.configPath, JSON.stringify(mergedConfig, null, 2));
+  }
+
+  /**
+   * Format a value for display
+   */
+  formatValue(value: unknown, key: ConfigKey): string {
+    if (value === undefined || value === null) {
+      return K0NTEXT_THEME.dim('(not set)');
+    }
+
+    switch (key.type) {
+      case 'boolean':
+        return value ? K0NTEXT_THEME.success('✓ enabled') : K0NTEXT_THEME.dim('○ disabled');
+      case 'array':
+        if (!Array.isArray(value)) return K0NTEXT_THEME.dim('(invalid)');
+        if (value.length === 0) return K0NTEXT_THEME.dim('(none)');
+        return K0NTEXT_THEME.cyan(value.join(', '));
+      case 'number':
+        return K0NTEXT_THEME.highlight(String(value));
+      case 'string':
+        if (key.name === 'openrouterKey' && value) {
+          return String(value).slice(0, 8) + '...' + K0NTEXT_THEME.success('(set)');
+        }
+        return K0NTEXT_THEME.cyan(String(value));
+      default:
+        return String(value);
+    }
+  }
+
+  /**
+   * Show configuration help
+   */
+  showConfigHelp(): string {
+    const lines = [
+      '',
+      K0NTEXT_THEME.header('━━━ Configuration Help ━━━'),
+      '',
+      '  Commands:',
+      '    config                 Show all configuration',
+      '    config list            Show all configuration (alias)',
+      '    config get <key>       Get a specific value',
+      '    config set <key> <val>  Set a value',
+      '    config edit            Interactive configuration editor',
+      '',
+      '  Categories:',
+      ...Object.entries(CONFIG_DEFINITIONS).map(([id, cat]) => `    ${id.padEnd(15)} - ${cat.description}`),
+      '',
+      '  Examples:',
+      '    config get projectType',
+      '    config set projectType monorepo',
+      '    config edit Project',
+      ''
+    ];
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Validate configuration
+   */
+  validateConfig(): { valid: boolean; errors: string[]; warnings: string[] } {
+    const errors: string[] = [];
+    const warnings: string[] = [];
+
+    // Check API key if embeddings are enabled
+    const generateEmbeddings = this.getValue('generateEmbeddings') === true;
+    const apiKey = this.getValue('openrouterKey') || process.env.OPENROUTER_API_KEY;
+
+    if (generateEmbeddings && !apiKey) {
+      warnings.push('Embeddings are enabled but no API key is set');
+    }
+
+    // Validate numeric ranges
+    const maxFiles = this.getValue('maxFilesPerIndex');
+    if (typeof maxFiles === 'number' && (maxFiles < 100 || maxFiles > 10000)) {
+      errors.push('maxFilesPerIndex should be between 100 and 10000');
+    }
+
+    const batchSize = this.getValue('indexBatchSize');
+    if (typeof batchSize === 'number' && (batchSize < 10 || batchSize > 1000)) {
+      errors.push('indexBatchSize should be between 10 and 1000');
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+}