vigthoria-cli 1.0.0

package/src/types/marked-terminal.d.ts

@@ -0,0 +1,31 @@
+declare module 'marked-terminal' {
+  import { MarkedExtension } from 'marked';
+  
+  interface MarkedTerminalOptions {
+    code?: (code: string) => string;
+    blockquote?: (text: string) => string;
+    html?: (html: string) => string;
+    heading?: (text: string, level: number) => string;
+    firstHeading?: (text: string) => string;
+    hr?: () => string;
+    listitem?: (text: string) => string;
+    list?: (body: string, ordered: boolean) => string;
+    paragraph?: (text: string) => string;
+    table?: (header: string, body: string) => string;
+    tablerow?: (content: string) => string;
+    tablecell?: (content: string, flags: { header: boolean; align: string }) => string;
+    strong?: (text: string) => string;
+    em?: (text: string) => string;
+    codespan?: (text: string) => string;
+    br?: () => string;
+    del?: (text: string) => string;
+    link?: (href: string, title: string, text: string) => string;
+    image?: (href: string, title: string, text: string) => string;
+    reflowText?: boolean;
+    width?: number;
+    showSectionPrefix?: boolean;
+    tab?: number;
+  }
+
+  export function markedTerminal(options?: MarkedTerminalOptions): MarkedExtension;
+}

package/src/utils/api.ts

@@ -0,0 +1,531 @@
+/**
+ * API Client for Vigthoria Backend
+ * Connects to coder.vigthoria.io API endpoints
+ */
+
+import axios, { AxiosInstance, AxiosError } from 'axios';
+import WebSocket from 'ws';
+import { Config } from './config.js';
+import { Logger } from './logger.js';
+
+export interface ChatMessage {
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+}
+
+export interface ChatResponse {
+  id: string;
+  message: string;
+  model: string;
+  usage?: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+export interface StreamChunk {
+  type: 'content' | 'done' | 'error';
+  content?: string;
+  error?: string;
+}
+
+export interface VigthoriUser {
+  id: string;
+  username: string;
+  email: string;
+  isAdmin: boolean;
+  subscription: {
+    plan: string;
+    projectLimit: number;
+    storageLimit: number;
+    viagen6Access: boolean;
+    aiModelsLimit: number;
+    prioritySupport: boolean;
+    teamCollaboration: boolean;
+    adminAccess: boolean;
+  };
+}
+
+export class APIClient {
+  private client: AxiosInstance;
+  private modelRouterClient: AxiosInstance;
+  private config: Config;
+  private logger: Logger;
+  private ws: WebSocket | null = null;
+
+  constructor(config: Config, logger: Logger) {
+    this.config = config;
+    this.logger = logger;
+
+    // Main Vigthoria Coder API (coder.vigthoria.io)
+    this.client = axios.create({
+      baseURL: config.get('apiUrl'),
+      timeout: 120000,
+      headers: {
+        'Content-Type': 'application/json',
+        'User-Agent': 'Vigthoria-CLI/1.0.0',
+      },
+    });
+
+    // Model Router API for AI operations
+    this.modelRouterClient = axios.create({
+      baseURL: 'https://coder.vigthoria.io',
+      timeout: 120000,
+      headers: {
+        'Content-Type': 'application/json',
+        'User-Agent': 'Vigthoria-CLI/1.0.0',
+      },
+    });
+
+    // Add auth interceptor
+    this.client.interceptors.request.use((req) => {
+      const token = this.config.get('authToken');
+      if (token) {
+        req.headers.Authorization = `Bearer ${token}`;
+        req.headers.Cookie = `vigthoria-auth-token=${token}`;
+      }
+      return req;
+    });
+
+    this.modelRouterClient.interceptors.request.use((req) => {
+      const token = this.config.get('authToken');
+      if (token) {
+        req.headers.Authorization = `Bearer ${token}`;
+        req.headers.Cookie = `vigthoria-auth-token=${token}`;
+      }
+      return req;
+    });
+
+    // Add response interceptor for token refresh
+    this.client.interceptors.response.use(
+      (res) => res,
+      async (error: AxiosError) => {
+        if (error.response?.status === 401) {
+          const refreshed = await this.refreshToken();
+          if (refreshed && error.config) {
+            return this.client.request(error.config);
+          }
+        }
+        throw error;
+      }
+    );
+  }
+
+  // Authentication - Uses Vigthoria Coder /api/login endpoint
+  async login(email: string, password: string): Promise<boolean> {
+    try {
+      const response = await this.client.post('/api/login', { email, password });
+      
+      if (!response.data.success) {
+        throw new Error(response.data.error || 'Login failed');
+      }
+
+      const { token, user } = response.data as { token: string; user: VigthoriUser };
+      
+      this.config.setAuth({
+        token,
+        userId: user.id,
+        email: user.email,
+      });
+
+      // Set subscription from user data
+      this.config.setSubscription({
+        plan: user.subscription?.plan || 'developer',
+        status: 'active',
+        expiresAt: undefined,
+      });
+      
+      return true;
+    } catch (error) {
+      const axiosError = error as AxiosError;
+      const message = (axiosError.response?.data as { error?: string })?.error || (error as Error).message;
+      this.logger.error('Login failed:', message);
+      return false;
+    }
+  }
+
+  async loginWithToken(token: string): Promise<boolean> {
+    try {
+      // Validate token by making a request to user info endpoint
+      this.config.set('authToken', token);
+      
+      const response = await this.client.get('/api/user/profile', {
+        headers: { 
+          Authorization: `Bearer ${token}`,
+          Cookie: `vigthoria-auth-token=${token}`,
+        },
+      });
+
+      if (response.data && response.data.user) {
+        const user = response.data.user;
+        
+        this.config.setAuth({
+          token,
+          userId: user.id,
+          email: user.email,
+        });
+
+        this.config.setSubscription({
+          plan: user.subscription?.plan || user.subscription_plan || 'developer',
+          status: 'active',
+          expiresAt: undefined,
+        });
+        
+        return true;
+      }
+      
+      return false;
+    } catch (error) {
+      this.config.clearAuth();
+      this.logger.error('Token validation failed:', (error as Error).message);
+      return false;
+    }
+  }
+
+  private async refreshToken(): Promise<boolean> {
+    const refreshToken = this.config.get('refreshToken');
+    if (!refreshToken) return false;
+
+    try {
+      const response = await this.client.post('/api/token/refresh', { 
+        refresh_token: refreshToken 
+      });
+      const { token, access_token, refresh_token } = response.data;
+      
+      this.config.set('authToken', token || access_token);
+      if (refresh_token) {
+        this.config.set('refreshToken', refresh_token);
+      }
+      
+      return true;
+    } catch {
+      this.config.clearAuth();
+      return false;
+    }
+  }
+
+  async getSubscriptionStatus(): Promise<void> {
+    try {
+      const response = await this.client.get('/api/user/subscription');
+      const data = response.data;
+      
+      this.config.setSubscription({ 
+        plan: data.plan || data.subscription_plan || 'developer', 
+        status: data.status || 'active', 
+        expiresAt: data.expiresAt || data.expires_at 
+      });
+    } catch (error) {
+      this.logger.debug('Failed to get subscription status:', (error as Error).message);
+    }
+  }
+
+  /**
+   * Chat API - Supports multiple inference strategies
+   * 
+   * For authenticated users: Uses Vigthoria Cloud API
+   * For local users: Uses local Ollama or Model Router
+   */
+  async chat(messages: ChatMessage[], model: string, useLocal: boolean = false): Promise<ChatResponse> {
+    const resolvedModel = this.resolveModelId(model);
+    
+    // If authenticated and not forcing local, use Vigthoria Cloud API
+    if (!useLocal && this.config.isAuthenticated()) {
+      try {
+        const response = await this.client.post('/api/ai/chat', {
+          messages,
+          model: resolvedModel,
+          maxTokens: this.config.get('preferences').maxTokens,
+          temperature: 0.7,
+        });
+
+        if (response.data.success !== false) {
+          return {
+            id: response.data.id || `vigthoria-${Date.now()}`,
+            message: response.data.response || response.data.message || response.data.content,
+            model: response.data.model || model,
+            usage: response.data.usage,
+          };
+        }
+      } catch (error) {
+        this.logger.debug('Vigthoria Cloud API failed, trying fallbacks...');
+      }
+    }
+
+    // Strategy 1: Try local Model Router's Vigthoria chat endpoint
+    try {
+      const response = await axios.post('http://localhost:4009/api/vigthoria/chat', {
+        messages,
+        model: resolvedModel,
+        maxTokens: this.config.get('preferences').maxTokens,
+        temperature: 0.7,
+        stream: false,
+      }, { timeout: 120000 });
+
+      if (response.data.success !== false) {
+        return {
+          id: response.data.id || `router-${Date.now()}`,
+          message: response.data.response || response.data.message || response.data.content,
+          model: response.data.model || model,
+          usage: response.data.usage,
+        };
+      }
+    } catch (error) {
+      this.logger.debug('Model router failed, trying Ollama directly...');
+    }
+
+    // Strategy 2: Try Ollama directly (for local development/testing)
+    try {
+      const ollamaModel = this.resolveToOllamaModel(model);
+      const prompt = this.formatMessagesForOllama(messages);
+      
+      const response = await axios.post('http://localhost:11434/api/generate', {
+        model: ollamaModel,
+        prompt,
+        stream: false,
+      }, { timeout: 120000 });
+
+      return {
+        id: `ollama-${Date.now()}`,
+        message: response.data.response,
+        model: ollamaModel,
+        usage: {
+          prompt_tokens: response.data.prompt_eval_count || 0,
+          completion_tokens: response.data.eval_count || 0,
+          total_tokens: (response.data.prompt_eval_count || 0) + (response.data.eval_count || 0),
+        },
+      };
+    } catch (error) {
+      this.logger.debug('Ollama failed...');
+    }
+
+    // Strategy 3: Try ViAgen6 AI endpoint (authenticated fallback)
+    if (this.config.isAuthenticated()) {
+      try {
+        const response = await this.client.post('/viagen6/api/ai/generate', {
+          prompt: messages.map(m => `${m.role}: ${m.content}`).join('\n'),
+          model: resolvedModel,
+          max_tokens: this.config.get('preferences').maxTokens,
+        });
+
+        return {
+          id: `viagen6-${Date.now()}`,
+          message: response.data.code || response.data.response || response.data.content,
+          model: model,
+        };
+      } catch (fallbackError) {
+        // Continue to error
+      }
+    }
+
+    throw new Error('All AI backends unavailable. Please check your connection or authentication.');
+  }
+
+  // Map CLI model names to Ollama model names (for local fallback)
+  private resolveToOllamaModel(model: string): string {
+    const ollamaMap: Record<string, string> = {
+      'fast': 'qwen3:0.6b',
+      'mini': 'smollm2:135m',
+      'code': 'qwen2.5-coder:7b',
+      'balanced': 'phi3:mini',
+      'creative': 'gemma3:latest',
+      'vigthoria-fast-1.7b': 'qwen3:0.6b',
+      'vigthoria-mini-0.6b': 'smollm2:135m',
+      'vigthoria-v2-code-8b': 'qwen2.5-coder:7b',
+      'vigthoria-balanced-4b': 'phi3:mini',
+      'vigthoria-creative-9b-v4': 'gemma3:latest',
+    };
+    return ollamaMap[model] || model;
+  }
+
+  // Format messages for Ollama's generate API
+  private formatMessagesForOllama(messages: ChatMessage[]): string {
+    return messages
+      .filter(m => m.role !== 'system' || messages.indexOf(m) === 0)
+      .map(m => {
+        if (m.role === 'system') return `System: ${m.content}\n\n`;
+        if (m.role === 'user') return `User: ${m.content}\n`;
+        return `Assistant: ${m.content}\n`;
+      })
+      .join('') + 'Assistant:';
+  }
+
+  // Streaming chat
+  async *chatStream(
+    messages: ChatMessage[],
+    model: string
+  ): AsyncGenerator<StreamChunk> {
+    const wsUrl = this.config.get('wsUrl');
+    const token = this.config.get('authToken');
+
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(`${wsUrl}/chat`, {
+        headers: { Authorization: `Bearer ${token}` },
+      });
+
+      ws.on('open', () => {
+        ws.send(JSON.stringify({
+          type: 'chat',
+          messages,
+          model: this.resolveModelId(model),
+          stream: true,
+        }));
+      });
+
+      ws.on('message', (data) => {
+        const chunk = JSON.parse(data.toString());
+        // Yield chunk - but this pattern won't work directly
+        // Need to use event emitter pattern instead
+      });
+
+      ws.on('error', (error) => {
+        reject(error);
+      });
+
+      ws.on('close', () => {
+        resolve(undefined);
+      });
+    });
+  }
+
+  // Non-streaming alternative with callback
+  async chatWithCallback(
+    messages: ChatMessage[],
+    model: string,
+    onChunk: (chunk: string) => void,
+    onDone: () => void,
+    onError: (error: Error) => void
+  ): Promise<void> {
+    const wsUrl = this.config.get('wsUrl');
+    const token = this.config.get('authToken');
+
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(`${wsUrl}/chat`, {
+        headers: { Authorization: `Bearer ${token}` },
+      });
+
+      ws.on('open', () => {
+        ws.send(JSON.stringify({
+          type: 'chat',
+          messages,
+          model: this.resolveModelId(model),
+          stream: true,
+        }));
+      });
+
+      ws.on('message', (data) => {
+        try {
+          const chunk = JSON.parse(data.toString());
+          if (chunk.type === 'content') {
+            onChunk(chunk.content);
+          } else if (chunk.type === 'done') {
+            onDone();
+            ws.close();
+            resolve();
+          } else if (chunk.type === 'error') {
+            onError(new Error(chunk.error));
+            ws.close();
+            reject(new Error(chunk.error));
+          }
+        } catch (e) {
+          // Raw text chunk
+          onChunk(data.toString());
+        }
+      });
+
+      ws.on('error', (error) => {
+        onError(error as Error);
+        reject(error);
+      });
+
+      ws.on('close', () => {
+        resolve();
+      });
+    });
+  }
+
+  // Code operations
+  async generateCode(prompt: string, language: string, model: string): Promise<string> {
+    const response = await this.client.post('/ai/generate', {
+      prompt,
+      language,
+      model: this.resolveModelId(model),
+    });
+
+    return response.data.code;
+  }
+
+  async explainCode(code: string, language: string): Promise<string> {
+    const response = await this.client.post('/ai/explain', {
+      code,
+      language,
+    });
+
+    return response.data.explanation;
+  }
+
+  async reviewCode(code: string, language: string): Promise<{
+    score: number;
+    issues: { type: string; line: number; message: string; severity: string }[];
+    suggestions: string[];
+  }> {
+    const response = await this.client.post('/ai/review', {
+      code,
+      language,
+    });
+
+    return response.data;
+  }
+
+  async fixCode(code: string, language: string, fixType: string): Promise<{
+    fixed: string;
+    changes: { line: number; before: string; after: string; reason: string }[];
+  }> {
+    const response = await this.client.post('/ai/fix', {
+      code,
+      language,
+      fixType,
+    });
+
+    return response.data;
+  }
+
+  // Model resolution - maps short names to actual Vigthoria model IDs
+  private resolveModelId(shortName: string): string {
+    const modelMap: Record<string, string> = {
+      // Vigthoria Native Models
+      'fast': 'vigthoria-fast-1.7b',
+      'mini': 'vigthoria-mini-0.6b',
+      'code': 'vigthoria-v2-code-8b',
+      'balanced': 'vigthoria-balanced-4b',
+      'creative': 'vigthoria-creative-9b-v4',
+      'music': 'vigthoria-music-master-4b',
+      // Aliases
+      'pro': 'vigthoria-balanced-4b',
+      'ultra': 'vigthoria-creative-9b-v4',
+      // Legacy Vigthoria models
+      'master': 'vigthoria_master:latest',
+      'c1': 'vigthoria_c1_m:latest',
+      'm1': 'vigthoria_m1_m:latest',
+      // External models
+      'qwen-coder': 'qwen2.5-coder:7b',
+      'qwen-coder-32b': 'qwen2.5-coder:32b',
+      'deepseek': 'deepseek-coder-v2:latest',
+      'deepseek-r1': 'deepseek-r1:8b',
+      'llama3': 'llama3:8b-instruct-q4_0',
+      'mixtral': 'mixtral:8x7b-instruct-v0.1-q4_K_M',
+    };
+
+    return modelMap[shortName] || shortName;
+  }
+
+  // Health check
+  async healthCheck(): Promise<boolean> {
+    try {
+      await this.client.get('/health');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}