vigthoria-cli 1.0.0

package/src/commands/explain.ts

@@ -0,0 +1,115 @@
+/**
+ * Explain Command - Explain code in files
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import { Marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+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 ExplainOptions {
+  lines?: string;
+  detail: 'brief' | 'normal' | 'detailed';
+}
+
+export class ExplainCommand {
+  private config: Config;
+  private logger: Logger;
+  private api: APIClient;
+  private fileUtils: FileUtils;
+  private marked: Marked;
+
+  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);
+    
+    this.marked = new Marked();
+    this.marked.use(markedTerminal() as any);
+  }
+
+  async run(filePath: string, options: ExplainOptions): 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;
+    }
+
+    // Get code to explain
+    let codeToExplain = file.content;
+    let lineInfo = '';
+
+    if (options.lines) {
+      const [start, end] = options.lines.split('-').map(Number);
+      const lines = this.fileUtils.readLines(filePath, start, end || start);
+      if (lines) {
+        codeToExplain = lines;
+        lineInfo = ` (lines ${start}-${end || start})`;
+      }
+    }
+
+    this.logger.section(`Explaining: ${file.relativePath}${lineInfo}`);
+    console.log(chalk.gray(`Language: ${file.language} | Detail: ${options.detail}`));
+    console.log();
+
+    // Show the code being explained
+    console.log(chalk.gray('─'.repeat(60)));
+    codeToExplain.split('\n').forEach((line, i) => {
+      const lineNum = chalk.gray(String(i + 1).padStart(4, ' ') + ' │ ');
+      console.log(lineNum + line);
+    });
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log();
+
+    const spinner = ora({
+      text: 'Analyzing code...',
+      spinner: 'dots',
+    }).start();
+
+    try {
+      const explanation = await this.api.explainCode(codeToExplain, file.language);
+      
+      spinner.stop();
+
+      // Format based on detail level
+      const formattedExplanation = this.formatExplanation(explanation, options.detail);
+
+      this.logger.section('Explanation');
+      console.log(this.marked.parse(formattedExplanation));
+
+    } catch (error) {
+      spinner.stop();
+      this.logger.error('Explanation failed:', (error as Error).message);
+    }
+  }
+
+  private formatExplanation(explanation: string, detail: string): string {
+    switch (detail) {
+      case 'brief':
+        // Extract just the summary
+        const lines = explanation.split('\n');
+        const summaryLines = lines.slice(0, Math.min(lines.length, 5));
+        return summaryLines.join('\n');
+        
+      case 'detailed':
+        // Add extra formatting
+        return explanation + '\n\n---\n*Detailed analysis by Vigthoria*';
+        
+      case 'normal':
+      default:
+        return explanation;
+    }
+  }
+}

package/src/commands/generate.ts

@@ -0,0 +1,177 @@
+/**
+ * Generate Command - Generate code from description
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+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 GenerateOptions {
+  language: string;
+  output?: string;
+  model: string;
+}
+
+export class GenerateCommand {
+  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(description: string, options: GenerateOptions): Promise<void> {
+    // Check auth
+    if (!this.config.isAuthenticated()) {
+      this.logger.error('Not authenticated. Run: vigthoria login');
+      return;
+    }
+
+    this.logger.section('Code Generation');
+    console.log(chalk.gray(`Language: ${options.language}`));
+    console.log(chalk.gray(`Description: ${description}`));
+    console.log();
+
+    const spinner = ora({
+      text: 'Generating code...',
+      spinner: 'dots',
+    }).start();
+
+    try {
+      const code = await this.api.generateCode(description, options.language, options.model);
+      
+      spinner.stop();
+
+      // Display generated code
+      this.logger.section('Generated Code');
+      console.log(chalk.gray('─'.repeat(60)));
+      console.log(this.highlightCode(code, options.language));
+      console.log(chalk.gray('─'.repeat(60)));
+      console.log();
+
+      // Save options
+      if (options.output) {
+        await this.saveToFile(options.output, code);
+      } else {
+        await this.promptForAction(code, options.language);
+      }
+
+    } catch (error) {
+      spinner.stop();
+      this.logger.error('Generation failed:', (error as Error).message);
+    }
+  }
+
+  private highlightCode(code: string, language: string): string {
+    // Basic syntax highlighting
+    // In production, use a proper library like highlight.js
+    const lines = code.split('\n');
+    
+    return lines.map((line, i) => {
+      const lineNum = chalk.gray(String(i + 1).padStart(4, ' ') + ' │ ');
+      return lineNum + this.highlightLine(line, language);
+    }).join('\n');
+  }
+
+  private highlightLine(line: string, language: string): string {
+    // Simple keyword highlighting
+    const keywords: Record<string, string[]> = {
+      typescript: ['const', 'let', 'var', 'function', 'class', 'interface', 'type', 'export', 'import', 'from', 'async', 'await', 'return', 'if', 'else', 'for', 'while', 'try', 'catch', 'throw', 'new'],
+      javascript: ['const', 'let', 'var', 'function', 'class', 'export', 'import', 'from', 'async', 'await', 'return', 'if', 'else', 'for', 'while', 'try', 'catch', 'throw', 'new'],
+      python: ['def', 'class', 'import', 'from', 'return', 'if', 'elif', 'else', 'for', 'while', 'try', 'except', 'raise', 'with', 'as', 'async', 'await', 'yield', 'lambda'],
+      rust: ['fn', 'let', 'mut', 'const', 'struct', 'enum', 'impl', 'trait', 'pub', 'use', 'mod', 'return', 'if', 'else', 'match', 'for', 'while', 'loop', 'async', 'await'],
+      go: ['func', 'var', 'const', 'type', 'struct', 'interface', 'package', 'import', 'return', 'if', 'else', 'for', 'range', 'switch', 'case', 'go', 'defer', 'chan'],
+    };
+
+    const langKeywords = keywords[language] || keywords['typescript'];
+    let highlighted = line;
+
+    // Highlight keywords
+    langKeywords.forEach(kw => {
+      const regex = new RegExp(`\\b${kw}\\b`, 'g');
+      highlighted = highlighted.replace(regex, chalk.magenta(kw));
+    });
+
+    // Highlight strings
+    highlighted = highlighted.replace(/(["'`])(?:(?!\1)[^\\]|\\.)*\1/g, (match) => chalk.green(match));
+
+    // Highlight comments
+    highlighted = highlighted.replace(/(\/\/.*$|#.*$)/g, (match) => chalk.gray(match));
+
+    // Highlight numbers
+    highlighted = highlighted.replace(/\b(\d+)\b/g, (match) => chalk.yellow(match));
+
+    return highlighted;
+  }
+
+  private async saveToFile(filePath: string, code: string): Promise<void> {
+    if (this.fileUtils.writeFile(filePath, code)) {
+      this.logger.success(`Code saved to ${filePath}`);
+    } else {
+      this.logger.error('Failed to save file');
+    }
+  }
+
+  private async promptForAction(code: string, language: string): Promise<void> {
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do with this code?',
+        choices: [
+          { name: 'Copy to clipboard', value: 'copy' },
+          { name: 'Save to file', value: 'save' },
+          { name: 'Regenerate', value: 'regenerate' },
+          { name: 'Done', value: 'done' },
+        ],
+      },
+    ]);
+
+    switch (action) {
+      case 'copy':
+        // Note: Clipboard access requires additional setup
+        this.logger.info('Code copied to clipboard');
+        console.log(chalk.gray('(Note: Clipboard access may require additional permissions)'));
+        break;
+      case 'save':
+        const { filename } = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'filename',
+            message: 'Enter filename:',
+            default: this.suggestFilename(language),
+          },
+        ]);
+        await this.saveToFile(filename, code);
+        break;
+      case 'regenerate':
+        this.logger.info('Use the generate command again with different parameters');
+        break;
+      case 'done':
+        break;
+    }
+  }
+
+  private suggestFilename(language: string): string {
+    const extensions: Record<string, string> = {
+      typescript: 'generated.ts',
+      javascript: 'generated.js',
+      python: 'generated.py',
+      rust: 'generated.rs',
+      go: 'generated.go',
+      java: 'Generated.java',
+      csharp: 'Generated.cs',
+    };
+
+    return extensions[language] || 'generated.txt';
+  }
+}

package/src/commands/review.ts

@@ -0,0 +1,186 @@
+/**
+ * Review Command - Code review with AI
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import { Marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+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 ReviewOptions {
+  format: 'text' | 'json' | 'markdown';
+}
+
+export class ReviewCommand {
+  private config: Config;
+  private logger: Logger;
+  private api: APIClient;
+  private fileUtils: FileUtils;
+  private marked: Marked;
+
+  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);
+    
+    this.marked = new Marked();
+    this.marked.use(markedTerminal() as any);
+  }
+
+  async run(filePath: string, options: ReviewOptions): 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(`Reviewing: ${file.relativePath}`);
+    console.log(chalk.gray(`Language: ${file.language} | Lines: ${file.lines}`));
+    console.log();
+
+    const spinner = ora({
+      text: 'Analyzing code quality...',
+      spinner: 'dots',
+    }).start();
+
+    try {
+      const review = await this.api.reviewCode(file.content, file.language);
+      
+      spinner.stop();
+
+      // Format output
+      switch (options.format) {
+        case 'json':
+          console.log(JSON.stringify(review, null, 2));
+          break;
+        case 'markdown':
+          this.printMarkdownReview(review, file.relativePath);
+          break;
+        case 'text':
+        default:
+          this.printTextReview(review);
+          break;
+      }
+
+    } catch (error) {
+      spinner.stop();
+      this.logger.error('Review failed:', (error as Error).message);
+    }
+  }
+
+  private printTextReview(review: {
+    score: number;
+    issues: { type: string; line: number; message: string; severity: string }[];
+    suggestions: string[];
+  }): void {
+    // Score
+    const scoreColor = review.score >= 80 ? chalk.green : review.score >= 60 ? chalk.yellow : chalk.red;
+    console.log();
+    console.log(chalk.bold('Quality Score: ') + scoreColor(`${review.score}/100`));
+    console.log(this.renderScoreBar(review.score));
+    console.log();
+
+    // Issues
+    if (review.issues.length > 0) {
+      this.logger.section(`Issues (${review.issues.length})`);
+      
+      review.issues.forEach((issue, i) => {
+        const severityIcon = this.getSeverityIcon(issue.severity);
+        const severityColor = this.getSeverityColor(issue.severity);
+        
+        console.log(
+          severityColor(`${severityIcon} [${issue.type}]`) +
+          chalk.gray(` Line ${issue.line}:`) +
+          ` ${issue.message}`
+        );
+      });
+      console.log();
+    } else {
+      this.logger.success('No issues found!');
+    }
+
+    // Suggestions
+    if (review.suggestions.length > 0) {
+      this.logger.section('Suggestions');
+      
+      review.suggestions.forEach((suggestion, i) => {
+        console.log(chalk.cyan(`${i + 1}.`) + ` ${suggestion}`);
+      });
+      console.log();
+    }
+  }
+
+  private printMarkdownReview(review: {
+    score: number;
+    issues: { type: string; line: number; message: string; severity: string }[];
+    suggestions: string[];
+  }, filePath: string): void {
+    let markdown = `# Code Review: ${filePath}\n\n`;
+    markdown += `## Score: ${review.score}/100\n\n`;
+    
+    if (review.issues.length > 0) {
+      markdown += `## Issues\n\n`;
+      review.issues.forEach(issue => {
+        markdown += `- **[${issue.severity.toUpperCase()}]** Line ${issue.line}: ${issue.message} (${issue.type})\n`;
+      });
+      markdown += '\n';
+    }
+    
+    if (review.suggestions.length > 0) {
+      markdown += `## Suggestions\n\n`;
+      review.suggestions.forEach((s, i) => {
+        markdown += `${i + 1}. ${s}\n`;
+      });
+    }
+
+    console.log(this.marked.parse(markdown));
+  }
+
+  private renderScoreBar(score: number): string {
+    const width = 30;
+    const filled = Math.round((score / 100) * width);
+    const empty = width - filled;
+    
+    const color = score >= 80 ? chalk.green : score >= 60 ? chalk.yellow : chalk.red;
+    
+    return color('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+  }
+
+  private getSeverityIcon(severity: string): string {
+    switch (severity.toLowerCase()) {
+      case 'error':
+        return '✗';
+      case 'warning':
+        return '⚠';
+      case 'info':
+        return 'ℹ';
+      default:
+        return '•';
+    }
+  }
+
+  private getSeverityColor(severity: string): typeof chalk {
+    switch (severity.toLowerCase()) {
+      case 'error':
+        return chalk.red;
+      case 'warning':
+        return chalk.yellow;
+      case 'info':
+        return chalk.blue;
+      default:
+        return chalk.white;
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+/**
+ * Vigthoria CLI - AI-Powered Terminal Coding Assistant
+ * 
+ * Usage:
+ *   vigthoria chat              - Start interactive chat
+ *   vigthoria edit <file>       - Edit a file with AI assistance
+ *   vigthoria generate <desc>   - Generate code from description
+ *   vigthoria explain <file>    - Explain code in a file
+ *   vigthoria fix <file>        - Fix issues in a file
+ *   vigthoria review <file>     - Review code quality
+ *   vigthoria login             - Authenticate with Vigthoria
+ *   vigthoria config            - Configure settings
+ */
+
+import { Command } from 'commander';
+import { ChatCommand } from './commands/chat.js';
+import { EditCommand } from './commands/edit.js';
+import { GenerateCommand } from './commands/generate.js';
+import { ExplainCommand } from './commands/explain.js';
+import { AuthCommand } from './commands/auth.js';
+import { ConfigCommand } from './commands/config.js';
+import { ReviewCommand } from './commands/review.js';
+import { Config } from './utils/config.js';
+import { Logger } from './utils/logger.js';
+import chalk from 'chalk';
+
+const VERSION = '1.0.0';
+
+async function main() {
+  const program = new Command();
+  const config = new Config();
+  const logger = new Logger();
+
+  // Banner - Fixed alignment with proper padding
+  const boxWidth = 61; // Inner content width
+  const titleText = 'VIGTHORIA CLI - AI-Powered Coding Assistant';
+  const versionText = `Version ${VERSION}`;
+  
+  // Calculate padding for centering
+  const titlePad = Math.floor((boxWidth - 4 - titleText.length) / 2);
+  const versionPad = Math.floor((boxWidth - 4 - versionText.length) / 2);
+  
+  console.log(chalk.cyan('╔' + '═'.repeat(boxWidth) + '╗'));
+  console.log(chalk.cyan('║' + ' '.repeat(boxWidth) + '║'));
+  console.log(chalk.cyan('║') + ' '.repeat(titlePad) + chalk.bold.white('VIGTHORIA CLI') + chalk.cyan(' - AI-Powered Coding Assistant') + ' '.repeat(boxWidth - titlePad - titleText.length) + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + ' '.repeat(versionPad) + chalk.gray(versionText) + ' '.repeat(boxWidth - versionPad - versionText.length) + chalk.cyan('║'));
+  console.log(chalk.cyan('║' + ' '.repeat(boxWidth) + '║'));
+  console.log(chalk.cyan('╚' + '═'.repeat(boxWidth) + '╝'));
+  console.log();
+
+  program
+    .name('vigthoria')
+    .description('AI-powered terminal coding assistant for Vigthoria Coder subscribers')
+    .version(VERSION);
+
+  // Chat command - Interactive mode
+  program
+    .command('chat')
+    .alias('c')
+    .description('Start interactive chat with Vigthoria AI')
+    .option('-m, --model <model>', 'Select AI model (fast, balanced, code, creative)', 'balanced')
+    .option('-p, --project <path>', 'Set project context path', process.cwd())
+    .option('-a, --agent', 'Enable agentic mode (Claude Code-like autonomous actions)', false)
+    .option('-r, --resume', 'Resume last session for this project', false)
+    .option('-l, --local', 'Local mode: use Ollama directly without auth', false)
+    .option('--auto-approve', 'Auto-approve agent actions (dangerous!)', false)
+    .action(async (options) => {
+      const chat = new ChatCommand(config, logger);
+      await chat.run({
+        model: options.model,
+        project: options.project,
+        agent: options.agent,
+        autoApprove: options.autoApprove,
+        resume: options.resume,
+        local: options.local,
+      });
+    });
+
+  // Agent command - Agentic mode (Claude Code-like)
+  program
+    .command('agent')
+    .alias('a')
+    .description('Start agentic mode - AI can read/write files, run commands')
+    .option('-m, --model <model>', 'Select AI model', 'code')
+    .option('-p, --project <path>', 'Set project context path', process.cwd())
+    .option('-l, --local', 'Local mode: use Ollama directly without auth', false)
+    .option('--auto-approve', 'Auto-approve all actions (dangerous!)', false)
+    .action(async (options) => {
+      const chat = new ChatCommand(config, logger);
+      await chat.run({
+        model: options.model,
+        project: options.project,
+        agent: true,
+        autoApprove: options.autoApprove,
+        local: options.local,
+      });
+    });
+
+  // Edit command - Edit files with AI
+  program
+    .command('edit <file>')
+    .alias('e')
+    .description('Edit a file with AI assistance')
+    .option('-i, --instruction <text>', 'Editing instruction')
+    .option('-m, --model <model>', 'Select AI model', 'code')
+    .action(async (file, options) => {
+      const edit = new EditCommand(config, logger);
+      await edit.run(file, options);
+    });
+
+  // Generate command - Generate code
+  program
+    .command('generate <description>')
+    .alias('g')
+    .description('Generate code from description')
+    .option('-l, --language <lang>', 'Target language', 'typescript')
+    .option('-o, --output <file>', 'Output file path')
+    .option('-m, --model <model>', 'Select AI model', 'code')
+    .action(async (description, options) => {
+      const generate = new GenerateCommand(config, logger);
+      await generate.run(description, options);
+    });
+
+  // Explain command - Explain code
+  program
+    .command('explain <file>')
+    .alias('x')
+    .description('Explain code in a file')
+    .option('-l, --lines <range>', 'Line range (e.g., 1-50)')
+    .option('-d, --detail <level>', 'Detail level (brief, normal, detailed)', 'normal')
+    .action(async (file, options) => {
+      const explain = new ExplainCommand(config, logger);
+      await explain.run(file, options);
+    });
+
+  // Fix command - Fix code issues
+  program
+    .command('fix <file>')
+    .alias('f')
+    .description('Fix issues in a file')
+    .option('-t, --type <type>', 'Fix type (bugs, style, security, performance)', 'bugs')
+    .option('--apply', 'Automatically apply fixes', false)
+    .action(async (file, options) => {
+      const edit = new EditCommand(config, logger);
+      await edit.fix(file, options);
+    });
+
+  // Review command - Code review
+  program
+    .command('review <file>')
+    .alias('r')
+    .description('Review code quality')
+    .option('-f, --format <format>', 'Output format (text, json, markdown)', 'text')
+    .action(async (file, options) => {
+      const review = new ReviewCommand(config, logger);
+      await review.run(file, options);
+    });
+
+  // Auth commands
+  program
+    .command('login')
+    .description('Login to Vigthoria Coder')
+    .option('-t, --token <token>', 'API token')
+    .action(async (options) => {
+      const auth = new AuthCommand(config, logger);
+      await auth.login(options);
+    });
+
+  program
+    .command('logout')
+    .description('Logout from Vigthoria Coder')
+    .action(async () => {
+      const auth = new AuthCommand(config, logger);
+      await auth.logout();
+    });
+
+  program
+    .command('status')
+    .description('Show authentication and subscription status')
+    .action(async () => {
+      const auth = new AuthCommand(config, logger);
+      await auth.status();
+    });
+
+  // Config command
+  program
+    .command('config')
+    .description('Configure Vigthoria CLI settings')
+    .option('-s, --set <key=value>', 'Set a configuration value')
+    .option('-g, --get <key>', 'Get a configuration value')
+    .option('-l, --list', 'List all settings')
+    .option('-r, --reset', 'Reset to defaults')
+    .action(async (options) => {
+      const configCmd = new ConfigCommand(config, logger);
+      await configCmd.run(options);
+    });
+
+  // Init command - Initialize project
+  program
+    .command('init')
+    .description('Initialize Vigthoria in current project')
+    .action(async () => {
+      const configCmd = new ConfigCommand(config, logger);
+      await configCmd.init();
+    });
+
+  // Default to chat if no command
+  if (process.argv.length === 2) {
+    const chat = new ChatCommand(config, logger);
+    await chat.run({ model: 'code', project: process.cwd() });
+    return;
+  }
+
+  await program.parseAsync(process.argv);
+}
+
+main().catch((err) => {
+  console.error(chalk.red('Error:'), err.message);
+  process.exit(1);
+});