vigthoria-cli 1.0.0

package/src/commands/config.ts

@@ -0,0 +1,297 @@
+/**
+ * Config Command - CLI configuration management
+ */
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import * as fs from 'fs';
+import * as path from 'path';
+import { Config, VigthoriaCLIConfig } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+
+interface ConfigOptions {
+  set?: string;
+  get?: string;
+  list?: boolean;
+  reset?: boolean;
+}
+
+export class ConfigCommand {
+  private config: Config;
+  private logger: Logger;
+
+  constructor(config: Config, logger: Logger) {
+    this.config = config;
+    this.logger = logger;
+  }
+
+  async run(options: ConfigOptions): Promise<void> {
+    if (options.reset) {
+      await this.resetConfig();
+      return;
+    }
+
+    if (options.set) {
+      this.setConfig(options.set);
+      return;
+    }
+
+    if (options.get) {
+      this.getConfig(options.get);
+      return;
+    }
+
+    if (options.list) {
+      this.listConfig();
+      return;
+    }
+
+    // Interactive mode
+    await this.interactiveConfig();
+  }
+
+  async init(): Promise<void> {
+    console.log();
+    console.log(chalk.cyan('═══ Initialize Vigthoria in Project ═══'));
+    console.log();
+
+    const cwd = process.cwd();
+    const configFile = path.join(cwd, '.vigthoria.json');
+
+    if (fs.existsSync(configFile)) {
+      const { overwrite } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'overwrite',
+          message: '.vigthoria.json already exists. Overwrite?',
+          default: false,
+        },
+      ]);
+
+      if (!overwrite) {
+        this.logger.info('Initialization cancelled');
+        return;
+      }
+    }
+
+    // Gather project settings
+    const settings = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'defaultModel',
+        message: 'Default AI model:',
+        choices: [
+          { name: 'Vigthoria Code (8B) - Best for coding', value: 'vigthoria-code' },
+          { name: 'Vigthoria Fast (1.1B) - Quick responses', value: 'vigthoria-fast' },
+          { name: 'Vigthoria Mini (3.8B) - Balanced', value: 'vigthoria-mini' },
+          { name: 'Vigthoria Creative (9B) - Creative tasks', value: 'vigthoria-creative' },
+        ],
+        default: 'vigthoria-code',
+      },
+      {
+        type: 'input',
+        name: 'ignorePatterns',
+        message: 'Additional ignore patterns (comma-separated):',
+        default: '',
+      },
+      {
+        type: 'confirm',
+        name: 'autoApplyFixes',
+        message: 'Auto-apply fixes without confirmation?',
+        default: false,
+      },
+    ]);
+
+    // Create project config
+    const projectConfig = {
+      defaultModel: settings.defaultModel,
+      ignorePatterns: settings.ignorePatterns
+        ? settings.ignorePatterns.split(',').map((p: string) => p.trim())
+        : [],
+      autoApplyFixes: settings.autoApplyFixes,
+      createdAt: new Date().toISOString(),
+    };
+
+    fs.writeFileSync(configFile, JSON.stringify(projectConfig, null, 2));
+    this.logger.success(`Created ${configFile}`);
+
+    // Add to .gitignore if exists
+    const gitignorePath = path.join(cwd, '.gitignore');
+    if (fs.existsSync(gitignorePath)) {
+      const gitignore = fs.readFileSync(gitignorePath, 'utf-8');
+      if (!gitignore.includes('.vigthoria.json')) {
+        fs.appendFileSync(gitignorePath, '\n# Vigthoria CLI\n.vigthoria.json\n');
+        this.logger.info('Added .vigthoria.json to .gitignore');
+      }
+    }
+
+    console.log();
+    console.log(chalk.gray('Project initialized! Run `vigthoria chat` to start.'));
+    console.log();
+  }
+
+  private setConfig(keyValue: string): void {
+    const [key, ...valueParts] = keyValue.split('=');
+    const value = valueParts.join('=');
+
+    if (!key || value === undefined) {
+      this.logger.error('Invalid format. Use: vigthoria config --set key=value');
+      return;
+    }
+
+    const configMap: Record<string, (v: string) => void> = {
+      'model': (v) => this.config.set('preferences', { ...this.config.get('preferences'), defaultModel: v }),
+      'theme': (v) => this.config.set('preferences', { ...this.config.get('preferences'), theme: v as 'dark' | 'light' }),
+      'autoApply': (v) => this.config.set('preferences', { ...this.config.get('preferences'), autoApplyFixes: v === 'true' }),
+      'showDiffs': (v) => this.config.set('preferences', { ...this.config.get('preferences'), showDiffs: v === 'true' }),
+      'maxTokens': (v) => this.config.set('preferences', { ...this.config.get('preferences'), maxTokens: parseInt(v, 10) }),
+      'apiUrl': (v) => this.config.set('apiUrl', v),
+    };
+
+    if (configMap[key]) {
+      configMap[key](value);
+      this.logger.success(`Set ${key} = ${value}`);
+    } else {
+      this.logger.error(`Unknown config key: ${key}`);
+      console.log(chalk.gray('Available keys: model, theme, autoApply, showDiffs, maxTokens, apiUrl'));
+    }
+  }
+
+  private getConfig(key: string): void {
+    const all = this.config.getAll();
+    
+    const flatConfig: Record<string, unknown> = {
+      apiUrl: all.apiUrl,
+      model: all.preferences.defaultModel,
+      theme: all.preferences.theme,
+      autoApply: all.preferences.autoApplyFixes,
+      showDiffs: all.preferences.showDiffs,
+      maxTokens: all.preferences.maxTokens,
+      email: all.email,
+      plan: all.subscription.plan,
+    };
+
+    if (key in flatConfig) {
+      console.log(flatConfig[key]);
+    } else {
+      this.logger.error(`Unknown config key: ${key}`);
+    }
+  }
+
+  private listConfig(): void {
+    const all = this.config.getAll();
+
+    console.log();
+    console.log(chalk.cyan('═══ Vigthoria CLI Configuration ═══'));
+    console.log();
+    
+    console.log(chalk.white('API:'));
+    console.log(chalk.gray('  URL: ') + chalk.cyan(all.apiUrl));
+    console.log(chalk.gray('  WebSocket: ') + chalk.cyan(all.wsUrl));
+    console.log();
+
+    console.log(chalk.white('Preferences:'));
+    console.log(chalk.gray('  Default Model: ') + chalk.cyan(all.preferences.defaultModel));
+    console.log(chalk.gray('  Theme: ') + chalk.cyan(all.preferences.theme));
+    console.log(chalk.gray('  Auto Apply Fixes: ') + chalk.cyan(all.preferences.autoApplyFixes));
+    console.log(chalk.gray('  Show Diffs: ') + chalk.cyan(all.preferences.showDiffs));
+    console.log(chalk.gray('  Max Tokens: ') + chalk.cyan(all.preferences.maxTokens));
+    console.log();
+
+    console.log(chalk.white('Project:'));
+    console.log(chalk.gray('  Ignore Patterns: ') + chalk.gray(all.project.ignorePatterns.join(', ')));
+    console.log();
+
+    console.log(chalk.gray(`Config file: ${this.config.getConfigPath()}`));
+    console.log();
+  }
+
+  private async resetConfig(): Promise<void> {
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Reset all settings to defaults? (This will not log you out)',
+        default: false,
+      },
+    ]);
+
+    if (confirm) {
+      // Save auth before reset
+      const authToken = this.config.get('authToken');
+      const refreshToken = this.config.get('refreshToken');
+      const userId = this.config.get('userId');
+      const email = this.config.get('email');
+      const subscription = this.config.get('subscription');
+
+      this.config.reset();
+
+      // Restore auth
+      if (authToken) {
+        this.config.set('authToken', authToken);
+        this.config.set('refreshToken', refreshToken);
+        this.config.set('userId', userId);
+        this.config.set('email', email);
+        this.config.set('subscription', subscription);
+      }
+
+      this.logger.success('Configuration reset to defaults');
+    }
+  }
+
+  private async interactiveConfig(): Promise<void> {
+    const current = this.config.getAll();
+
+    console.log();
+    console.log(chalk.cyan('═══ Configure Vigthoria CLI ═══'));
+    console.log();
+
+    const settings = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'defaultModel',
+        message: 'Default AI model:',
+        choices: [
+          { name: 'Vigthoria Code (8B)', value: 'vigthoria-code' },
+          { name: 'Vigthoria Fast (1.1B)', value: 'vigthoria-fast' },
+          { name: 'Vigthoria Mini (3.8B)', value: 'vigthoria-mini' },
+          { name: 'Vigthoria Creative (9B)', value: 'vigthoria-creative' },
+        ],
+        default: current.preferences.defaultModel,
+      },
+      {
+        type: 'list',
+        name: 'theme',
+        message: 'Color theme:',
+        choices: ['dark', 'light'],
+        default: current.preferences.theme,
+      },
+      {
+        type: 'confirm',
+        name: 'autoApplyFixes',
+        message: 'Auto-apply fixes without confirmation?',
+        default: current.preferences.autoApplyFixes,
+      },
+      {
+        type: 'confirm',
+        name: 'showDiffs',
+        message: 'Show diffs before applying changes?',
+        default: current.preferences.showDiffs,
+      },
+      {
+        type: 'number',
+        name: 'maxTokens',
+        message: 'Maximum tokens per response:',
+        default: current.preferences.maxTokens,
+      },
+    ]);
+
+    this.config.set('preferences', {
+      ...current.preferences,
+      ...settings,
+    });
+
+    this.logger.success('Configuration saved');
+    console.log();
+  }
+}

package/src/commands/edit.ts

@@ -0,0 +1,310 @@
+/**
+ * Edit Command - File editing with AI assistance
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import * as readline from 'readline';
+import inquirer from 'inquirer';
+import { Config } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+import { APIClient } from '../utils/api.js';
+import { FileUtils } from '../utils/files.js';
+
+interface EditOptions {
+  instruction?: string;
+  model: string;
+}
+
+interface FixOptions {
+  type: string;
+  apply: boolean;
+}
+
+export class EditCommand {
+  private config: Config;
+  private logger: Logger;
+  private api: APIClient;
+  private fileUtils: FileUtils;
+
+  constructor(config: Config, logger: Logger) {
+    this.config = config;
+    this.logger = logger;
+    this.api = new APIClient(config, logger);
+    this.fileUtils = new FileUtils(process.cwd(), config.get('project').ignorePatterns);
+  }
+
+  async run(filePath: string, options: EditOptions): Promise<void> {
+    // Check auth
+    if (!this.config.isAuthenticated()) {
+      this.logger.error('Not authenticated. Run: vigthoria login');
+      return;
+    }
+
+    // Read file
+    const file = this.fileUtils.readFile(filePath);
+    if (!file) {
+      this.logger.error(`File not found: ${filePath}`);
+      return;
+    }
+
+    this.logger.section(`Editing: ${file.relativePath}`);
+    console.log(chalk.gray(`Language: ${file.language} | Lines: ${file.lines}`));
+    console.log();
+
+    // Get instruction
+    let instruction = options.instruction;
+    if (!instruction) {
+      const answer = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'instruction',
+          message: 'What changes would you like to make?',
+          validate: (input) => input.length > 0 || 'Please provide an instruction',
+        },
+      ]);
+      instruction = answer.instruction;
+    }
+
+    // Generate edit
+    const spinner = ora({
+      text: 'Generating changes...',
+      spinner: 'dots',
+    }).start();
+
+    try {
+      const response = await this.api.chat([
+        {
+          role: 'system',
+          content: `You are a code editor. Edit the provided code according to the user's instruction.
+Return ONLY the complete modified code without any explanation or markdown formatting.
+Preserve the original formatting and style unless the instruction specifically asks to change it.`,
+        },
+        {
+          role: 'user',
+          content: `File: ${file.relativePath}
+Language: ${file.language}
+
+Original code:
+\`\`\`${file.language}
+${file.content}
+\`\`\`
+
+Instruction: ${instruction}
+
+Return the complete modified code:`,
+        },
+      ], options.model);
+
+      spinner.stop();
+
+      // Extract code from response
+      const modifiedCode = this.extractCode(response.message, file.language);
+      
+      if (!modifiedCode) {
+        this.logger.error('Failed to generate valid code changes');
+        return;
+      }
+
+      // Show diff
+      await this.showDiffAndConfirm(file.path, file.content, modifiedCode);
+
+    } catch (error) {
+      spinner.stop();
+      this.logger.error('Edit failed:', (error as Error).message);
+    }
+  }
+
+  async fix(filePath: string, options: FixOptions): Promise<void> {
+    // Check auth
+    if (!this.config.isAuthenticated()) {
+      this.logger.error('Not authenticated. Run: vigthoria login');
+      return;
+    }
+
+    // Read file
+    const file = this.fileUtils.readFile(filePath);
+    if (!file) {
+      this.logger.error(`File not found: ${filePath}`);
+      return;
+    }
+
+    this.logger.section(`Fixing: ${file.relativePath}`);
+    console.log(chalk.gray(`Fix type: ${options.type} | Language: ${file.language}`));
+    console.log();
+
+    const spinner = ora({
+      text: `Analyzing for ${options.type} issues...`,
+      spinner: 'dots',
+    }).start();
+
+    try {
+      const result = await this.api.fixCode(file.content, file.language, options.type);
+      
+      spinner.stop();
+
+      if (result.changes.length === 0) {
+        this.logger.success('No issues found!');
+        return;
+      }
+
+      // Show fixes
+      this.logger.section(`Found ${result.changes.length} issue(s)`);
+      
+      result.changes.forEach((change, i) => {
+        console.log(chalk.yellow(`${i + 1}. Line ${change.line}:`));
+        console.log(chalk.red(`   - ${change.before}`));
+        console.log(chalk.green(`   + ${change.after}`));
+        console.log(chalk.gray(`   Reason: ${change.reason}`));
+        console.log();
+      });
+
+      // Apply or confirm
+      if (options.apply) {
+        await this.applyFix(file.path, file.content, result.fixed);
+      } else {
+        await this.showDiffAndConfirm(file.path, file.content, result.fixed);
+      }
+
+    } catch (error) {
+      spinner.stop();
+      this.logger.error('Fix failed:', (error as Error).message);
+    }
+  }
+
+  private extractCode(response: string, language: string): string | null {
+    // Try to extract code block
+    const codeBlockRegex = new RegExp(`\`\`\`(?:${language})?\\n([\\s\\S]*?)\`\`\``, 'i');
+    const match = response.match(codeBlockRegex);
+    
+    if (match) {
+      return match[1].trim();
+    }
+
+    // If no code block, check if response looks like code
+    const trimmed = response.trim();
+    if (!trimmed.startsWith('```') && !trimmed.includes('Here') && !trimmed.includes('I ')) {
+      return trimmed;
+    }
+
+    return null;
+  }
+
+  private async showDiffAndConfirm(
+    filePath: string,
+    original: string,
+    modified: string
+  ): Promise<void> {
+    const diff = this.fileUtils.createDiff(original, modified);
+
+    if (diff.added.length === 0 && diff.removed.length === 0) {
+      this.logger.info('No changes detected');
+      return;
+    }
+
+    // Show diff
+    this.logger.section('Changes');
+    
+    diff.removed.forEach(line => {
+      console.log(chalk.red(line));
+    });
+    diff.added.forEach(line => {
+      console.log(chalk.green(line));
+    });
+    console.log();
+
+    // Confirm
+    const showDiffs = this.config.get('preferences').showDiffs;
+    const autoApply = this.config.get('preferences').autoApplyFixes;
+
+    if (autoApply) {
+      await this.applyFix(filePath, original, modified);
+      return;
+    }
+
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+          { name: 'Apply changes', value: 'apply' },
+          { name: 'View full diff', value: 'view' },
+          { name: 'Discard changes', value: 'discard' },
+        ],
+      },
+    ]);
+
+    switch (action) {
+      case 'apply':
+        await this.applyFix(filePath, original, modified);
+        break;
+      case 'view':
+        this.showFullDiff(original, modified);
+        const { confirm } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Apply these changes?',
+            default: true,
+          },
+        ]);
+        if (confirm) {
+          await this.applyFix(filePath, original, modified);
+        }
+        break;
+      case 'discard':
+        this.logger.info('Changes discarded');
+        break;
+    }
+  }
+
+  private showFullDiff(original: string, modified: string): void {
+    const originalLines = original.split('\n');
+    const modifiedLines = modified.split('\n');
+
+    console.log();
+    console.log(chalk.gray('─'.repeat(60)));
+    
+    const maxLen = Math.max(originalLines.length, modifiedLines.length);
+    
+    for (let i = 0; i < maxLen; i++) {
+      const orig = originalLines[i];
+      const mod = modifiedLines[i];
+      const lineNum = String(i + 1).padStart(4, ' ');
+
+      if (orig === mod) {
+        console.log(chalk.gray(`${lineNum} │ ${orig || ''}`));
+      } else {
+        if (orig !== undefined) {
+          console.log(chalk.red(`${lineNum} - ${orig}`));
+        }
+        if (mod !== undefined) {
+          console.log(chalk.green(`${lineNum} + ${mod}`));
+        }
+      }
+    }
+    
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log();
+  }
+
+  private async applyFix(
+    filePath: string,
+    original: string,
+    modified: string
+  ): Promise<void> {
+    // Create backup
+    const backup = this.fileUtils.backupFile(filePath);
+    if (backup) {
+      this.logger.info(`Backup: ${chalk.gray(backup)}`);
+    }
+
+    // Apply changes
+    if (this.fileUtils.writeFile(filePath, modified)) {
+      this.logger.success(`Changes applied to ${filePath}`);
+    } else {
+      this.logger.error('Failed to write changes');
+    }
+  }
+}