vigthoria-cli 1.0.0

package/src/utils/config.ts

@@ -0,0 +1,224 @@
+/**
+ * Configuration Manager for Vigthoria CLI
+ */
+
+import Conf from 'conf';
+import * as path from 'path';
+import * as os from 'os';
+
+export interface VigthoriaCLIConfig {
+  apiUrl: string;
+  wsUrl: string;
+  authToken: string | null;
+  refreshToken: string | null;
+  userId: string | null;
+  email: string | null;
+  subscription: {
+    plan: string | null;
+    status: string | null;
+    expiresAt: string | null;
+  };
+  preferences: {
+    defaultModel: string;
+    theme: 'dark' | 'light';
+    autoApplyFixes: boolean;
+    showDiffs: boolean;
+    contextLines: number;
+    maxTokens: number;
+  };
+  project: {
+    rootPath: string | null;
+    ignorePatterns: string[];
+  };
+}
+
+const defaultConfig: VigthoriaCLIConfig = {
+  apiUrl: 'https://coder.vigthoria.io',
+  wsUrl: 'wss://coder.vigthoria.io/ws',
+  authToken: null,
+  refreshToken: null,
+  userId: null,
+  email: null,
+  subscription: {
+    plan: null,
+    status: null,
+    expiresAt: null,
+  },
+  preferences: {
+    defaultModel: 'vigthoria-code',
+    theme: 'dark',
+    autoApplyFixes: false,
+    showDiffs: true,
+    contextLines: 3,
+    maxTokens: 4096,
+  },
+  project: {
+    rootPath: null,
+    ignorePatterns: [
+      'node_modules',
+      '.git',
+      'dist',
+      'build',
+      '__pycache__',
+      '.venv',
+      'venv',
+      '.env',
+      '*.log',
+    ],
+  },
+};
+
+export class Config {
+  private store: Conf<VigthoriaCLIConfig>;
+
+  constructor() {
+    this.store = new Conf<VigthoriaCLIConfig>({
+      projectName: 'vigthoria-cli',
+      defaults: defaultConfig,
+      schema: {
+        apiUrl: { type: 'string' },
+        wsUrl: { type: 'string' },
+        authToken: { type: ['string', 'null'] },
+        refreshToken: { type: ['string', 'null'] },
+        userId: { type: ['string', 'null'] },
+        email: { type: ['string', 'null'] },
+        subscription: {
+          type: 'object',
+          properties: {
+            plan: { type: ['string', 'null'] },
+            status: { type: ['string', 'null'] },
+            expiresAt: { type: ['string', 'null'] },
+          },
+        },
+        preferences: {
+          type: 'object',
+          properties: {
+            defaultModel: { type: 'string' },
+            theme: { type: 'string', enum: ['dark', 'light'] },
+            autoApplyFixes: { type: 'boolean' },
+            showDiffs: { type: 'boolean' },
+            contextLines: { type: 'number' },
+            maxTokens: { type: 'number' },
+          },
+        },
+        project: {
+          type: 'object',
+          properties: {
+            rootPath: { type: ['string', 'null'] },
+            ignorePatterns: { type: 'array', items: { type: 'string' } },
+          },
+        },
+      },
+    });
+  }
+
+  get<K extends keyof VigthoriaCLIConfig>(key: K): VigthoriaCLIConfig[K] {
+    return this.store.get(key);
+  }
+
+  set<K extends keyof VigthoriaCLIConfig>(key: K, value: VigthoriaCLIConfig[K]): void {
+    this.store.set(key, value);
+  }
+
+  getAll(): VigthoriaCLIConfig {
+    return this.store.store;
+  }
+
+  reset(): void {
+    this.store.clear();
+  }
+
+  isAuthenticated(): boolean {
+    return this.store.get('authToken') !== null;
+  }
+
+  hasValidSubscription(): boolean {
+    const sub = this.store.get('subscription');
+    if (!sub.status || sub.status !== 'active') return false;
+    if (sub.expiresAt) {
+      const expires = new Date(sub.expiresAt);
+      return expires > new Date();
+    }
+    return true;
+  }
+
+  getConfigPath(): string {
+    return this.store.path;
+  }
+
+  // Auth helpers
+  setAuth(data: {
+    token: string;
+    refreshToken?: string;
+    userId: string;
+    email: string;
+  }): void {
+    this.store.set('authToken', data.token);
+    if (data.refreshToken) {
+      this.store.set('refreshToken', data.refreshToken);
+    }
+    this.store.set('userId', data.userId);
+    this.store.set('email', data.email);
+  }
+
+  clearAuth(): void {
+    this.store.set('authToken', null);
+    this.store.set('refreshToken', null);
+    this.store.set('userId', null);
+    this.store.set('email', null);
+    this.store.set('subscription', {
+      plan: null,
+      status: null,
+      expiresAt: null,
+    });
+  }
+
+  setSubscription(data: {
+    plan: string;
+    status: string;
+    expiresAt?: string;
+  }): void {
+    this.store.set('subscription', {
+      plan: data.plan,
+      status: data.status,
+      expiresAt: data.expiresAt || null,
+    });
+  }
+
+  // Model selection - Native Vigthoria Models
+  getAvailableModels(): { id: string; name: string; description: string }[] {
+    const sub = this.store.get('subscription');
+    
+    // All users get access to fast models
+    const models = [
+      { id: 'mini', name: 'Vigthoria Mini 0.6B', description: 'Ultra-fast, simple tasks' },
+      { id: 'fast', name: 'Vigthoria Fast 1.7B', description: 'Quick responses, streaming' },
+    ];
+
+    // Developer+ plans get balanced model
+    if (sub.plan && sub.plan !== 'free') {
+      models.push(
+        { id: 'balanced', name: 'Vigthoria Balanced 4B', description: 'General purpose' },
+        { id: 'music', name: 'Vigthoria Music 4B', description: 'Music production & theory' },
+      );
+    }
+
+    // Pro plans get code and creative models
+    if (sub.plan === 'developer' || sub.plan === 'pro' || sub.plan === 'ultra' || sub.plan === 'enterprise') {
+      models.push(
+        { id: 'code', name: 'Vigthoria Code v2 8B', description: 'Code specialist (training)' },
+        { id: 'creative', name: 'Vigthoria Creative 9B v4', description: 'Creative writing, lyrics' },
+      );
+    }
+
+    // External model aliases
+    if (sub.plan === 'pro' || sub.plan === 'ultra' || sub.plan === 'enterprise') {
+      models.push(
+        { id: 'qwen-coder', name: 'Qwen 2.5 Coder 7B', description: 'External code model' },
+        { id: 'deepseek', name: 'DeepSeek Coder v2', description: 'External code model' },
+      );
+    }
+
+    return models;
+  }
+}

package/src/utils/files.ts

@@ -0,0 +1,212 @@
+/**
+ * File utilities for Vigthoria CLI
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { glob } from 'glob';
+
+export interface FileInfo {
+  path: string;
+  relativePath: string;
+  content: string;
+  language: string;
+  lines: number;
+}
+
+export class FileUtils {
+  private projectRoot: string;
+  private ignorePatterns: string[];
+
+  constructor(projectRoot: string, ignorePatterns: string[] = []) {
+    this.projectRoot = projectRoot;
+    this.ignorePatterns = ignorePatterns;
+  }
+
+  // Read file with metadata
+  readFile(filePath: string): FileInfo | null {
+    try {
+      const absolutePath = path.isAbsolute(filePath) 
+        ? filePath 
+        : path.join(this.projectRoot, filePath);
+      
+      const content = fs.readFileSync(absolutePath, 'utf-8');
+      const relativePath = path.relative(this.projectRoot, absolutePath);
+      
+      return {
+        path: absolutePath,
+        relativePath,
+        content,
+        language: this.detectLanguage(absolutePath),
+        lines: content.split('\n').length,
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+
+  // Read specific lines
+  readLines(filePath: string, start: number, end: number): string | null {
+    const file = this.readFile(filePath);
+    if (!file) return null;
+
+    const lines = file.content.split('\n');
+    return lines.slice(start - 1, end).join('\n');
+  }
+
+  // Write file
+  writeFile(filePath: string, content: string): boolean {
+    try {
+      const absolutePath = path.isAbsolute(filePath)
+        ? filePath
+        : path.join(this.projectRoot, filePath);
+      
+      // Create directory if needed
+      const dir = path.dirname(absolutePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+
+      fs.writeFileSync(absolutePath, content, 'utf-8');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // Backup file
+  backupFile(filePath: string): string | null {
+    const file = this.readFile(filePath);
+    if (!file) return null;
+
+    const backupPath = `${file.path}.bak.${Date.now()}`;
+    if (this.writeFile(backupPath, file.content)) {
+      return backupPath;
+    }
+    return null;
+  }
+
+  // List project files
+  async listFiles(pattern: string = '**/*'): Promise<string[]> {
+    const files = await glob(pattern, {
+      cwd: this.projectRoot,
+      ignore: this.ignorePatterns,
+      nodir: true,
+    });
+
+    return files;
+  }
+
+  // Detect language from file extension
+  detectLanguage(filePath: string): string {
+    const ext = path.extname(filePath).toLowerCase();
+    const languageMap: Record<string, string> = {
+      '.ts': 'typescript',
+      '.tsx': 'typescript',
+      '.js': 'javascript',
+      '.jsx': 'javascript',
+      '.py': 'python',
+      '.rs': 'rust',
+      '.go': 'go',
+      '.java': 'java',
+      '.c': 'c',
+      '.cpp': 'cpp',
+      '.h': 'c',
+      '.hpp': 'cpp',
+      '.cs': 'csharp',
+      '.rb': 'ruby',
+      '.php': 'php',
+      '.swift': 'swift',
+      '.kt': 'kotlin',
+      '.scala': 'scala',
+      '.sql': 'sql',
+      '.html': 'html',
+      '.css': 'css',
+      '.scss': 'scss',
+      '.less': 'less',
+      '.json': 'json',
+      '.yaml': 'yaml',
+      '.yml': 'yaml',
+      '.xml': 'xml',
+      '.md': 'markdown',
+      '.sh': 'bash',
+      '.bash': 'bash',
+      '.zsh': 'zsh',
+      '.dockerfile': 'dockerfile',
+      '.vue': 'vue',
+      '.svelte': 'svelte',
+    };
+
+    return languageMap[ext] || 'text';
+  }
+
+  // Get project context
+  async getProjectContext(maxFiles: number = 20): Promise<{
+    type: string;
+    files: string[];
+    dependencies: Record<string, string>;
+  }> {
+    const context = {
+      type: 'unknown',
+      files: [] as string[],
+      dependencies: {} as Record<string, string>,
+    };
+
+    // Detect project type
+    if (fs.existsSync(path.join(this.projectRoot, 'package.json'))) {
+      context.type = 'node';
+      const pkg = JSON.parse(fs.readFileSync(
+        path.join(this.projectRoot, 'package.json'),
+        'utf-8'
+      ));
+      context.dependencies = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+      };
+    } else if (fs.existsSync(path.join(this.projectRoot, 'requirements.txt'))) {
+      context.type = 'python';
+    } else if (fs.existsSync(path.join(this.projectRoot, 'Cargo.toml'))) {
+      context.type = 'rust';
+    } else if (fs.existsSync(path.join(this.projectRoot, 'go.mod'))) {
+      context.type = 'go';
+    } else if (fs.existsSync(path.join(this.projectRoot, 'pom.xml'))) {
+      context.type = 'java-maven';
+    } else if (fs.existsSync(path.join(this.projectRoot, 'build.gradle'))) {
+      context.type = 'java-gradle';
+    }
+
+    // Get relevant files
+    const allFiles = await this.listFiles();
+    context.files = allFiles.slice(0, maxFiles);
+
+    return context;
+  }
+
+  // Create diff
+  createDiff(original: string, modified: string): { added: string[]; removed: string[] } {
+    const originalLines = original.split('\n');
+    const modifiedLines = modified.split('\n');
+
+    const added: string[] = [];
+    const removed: string[] = [];
+
+    // Simple diff - for display purposes
+    const maxLen = Math.max(originalLines.length, modifiedLines.length);
+    
+    for (let i = 0; i < maxLen; i++) {
+      const origLine = originalLines[i];
+      const modLine = modifiedLines[i];
+
+      if (origLine !== modLine) {
+        if (origLine !== undefined) {
+          removed.push(`${i + 1}: ${origLine}`);
+        }
+        if (modLine !== undefined) {
+          added.push(`${i + 1}: ${modLine}`);
+        }
+      }
+    }
+
+    return { added, removed };
+  }
+}

package/src/utils/logger.ts

@@ -0,0 +1,125 @@
+/**
+ * Logger utility for Vigthoria CLI
+ */
+
+import chalk from 'chalk';
+
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'success';
+
+export class Logger {
+  private verbose: boolean = false;
+
+  setVerbose(verbose: boolean): void {
+    this.verbose = verbose;
+  }
+
+  debug(...args: unknown[]): void {
+    if (this.verbose) {
+      console.log(chalk.gray('[DEBUG]'), ...args);
+    }
+  }
+
+  info(...args: unknown[]): void {
+    console.log(chalk.blue('ℹ'), ...args);
+  }
+
+  warn(...args: unknown[]): void {
+    console.log(chalk.yellow('⚠'), ...args);
+  }
+
+  error(...args: unknown[]): void {
+    console.error(chalk.red('✗'), ...args);
+  }
+
+  success(...args: unknown[]): void {
+    console.log(chalk.green('✓'), ...args);
+  }
+
+  // AI response formatting
+  ai(message: string): void {
+    console.log(chalk.cyan('🤖'), message);
+  }
+
+  // User input formatting
+  user(message: string): void {
+    console.log(chalk.white('👤'), message);
+  }
+
+  // Code block
+  code(code: string, language?: string): void {
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.yellow(code));
+    console.log(chalk.gray('─'.repeat(60)));
+  }
+
+  // Diff output
+  diff(added: string[], removed: string[]): void {
+    removed.forEach(line => console.log(chalk.red(`- ${line}`)));
+    added.forEach(line => console.log(chalk.green(`+ ${line}`)));
+  }
+
+  // Section header
+  section(title: string): void {
+    console.log();
+    console.log(chalk.bold.cyan(`═══ ${title} ═══`));
+    console.log();
+  }
+
+  // Progress
+  progress(message: string): void {
+    process.stdout.write(chalk.gray(`${message}\r`));
+  }
+
+  // Clear line
+  clearLine(): void {
+    process.stdout.write('\r\x1b[K');
+  }
+
+  // Box output
+  box(content: string, title?: string): void {
+    const lines = content.split('\n');
+    const maxLen = Math.max(...lines.map(l => l.length), title?.length || 0);
+    const width = maxLen + 4;
+
+    console.log(chalk.cyan('┌' + '─'.repeat(width - 2) + '┐'));
+    if (title) {
+      console.log(chalk.cyan('│ ') + chalk.bold.white(title.padEnd(width - 4)) + chalk.cyan(' │'));
+      console.log(chalk.cyan('├' + '─'.repeat(width - 2) + '┤'));
+    }
+    lines.forEach(line => {
+      console.log(chalk.cyan('│ ') + line.padEnd(width - 4) + chalk.cyan(' │'));
+    });
+    console.log(chalk.cyan('└' + '─'.repeat(width - 2) + '┘'));
+  }
+
+  // Table output
+  table(headers: string[], rows: string[][]): void {
+    const colWidths = headers.map((h, i) => {
+      const maxData = Math.max(...rows.map(r => (r[i] || '').length));
+      return Math.max(h.length, maxData);
+    });
+
+    // Header
+    console.log(
+      chalk.gray('│ ') +
+      headers.map((h, i) => chalk.bold(h.padEnd(colWidths[i]))).join(chalk.gray(' │ ')) +
+      chalk.gray(' │')
+    );
+
+    // Separator
+    console.log(
+      chalk.gray('├─') +
+      colWidths.map(w => '─'.repeat(w)).join(chalk.gray('─┼─')) +
+      chalk.gray('─┤')
+    );
+
+    // Rows
+    rows.forEach(row => {
+      console.log(
+        chalk.gray('│ ') +
+        row.map((cell, i) => (cell || '').padEnd(colWidths[i])).join(chalk.gray(' │ ')) +
+        chalk.gray(' │')
+      );
+    });
+  }
+}