legacyver 2.1.0 → 2.1.2

package/src/llm/index.js

@@ -1,49 +1,28 @@
-/**
- * LLM provider factory.
- * Reads provider from config/flags, returns correct provider instance.
- * Throws NoApiKeyError with per-provider instructions if key missing.
- */
-
-import Conf from 'conf';
-import { AnthropicProvider } from './providers/anthropic.js';
-import { OpenAIProvider } from './providers/openai.js';
-import { GoogleProvider } from './providers/google.js';
-import { GroqProvider } from './providers/groq.js';
-import { OllamaProvider } from './providers/ollama.js';
-import { LegacyverError } from '../utils/errors.js';
-
-const userConfig = new Conf({ projectName: 'legacyver' });
+'use strict';
 
-const PROVIDER_MAP = {
-  anthropic: AnthropicProvider,
-  openai: OpenAIProvider,
-  google: GoogleProvider,
-  groq: GroqProvider,
-  ollama: OllamaProvider,
-};
+const { OpenRouterProvider } = require('./providers/openrouter');
+const { OllamaProvider } = require('./providers/ollama');
+const { GroqProvider } = require('./providers/groq');
+const { GeminiProvider } = require('./providers/gemini');
 
 /**
- * Create an LLM engine instance for the given config.
- * @param {object} config - App configuration with provider, model, etc.
- * @returns {object} Provider instance with complete() method
+ * Provider factory — returns the appropriate LLM adapter.
+ * @param {Object} config
+ * @returns {OpenRouterProvider|OllamaProvider|GroqProvider|GeminiProvider}
  */
-export function createLLMEngine(config) {
-  const providerName = config.provider || 'anthropic';
-  const ProviderClass = PROVIDER_MAP[providerName];
-
-  if (!ProviderClass) {
-    throw new LegacyverError(
-      `Unknown provider "${providerName}". Supported: ${Object.keys(PROVIDER_MAP).join(', ')}`,
-      { exitCode: 1, suggestion: 'Run "legacyver providers" to see available providers' }
-    );
+function createProvider(config) {
+  const provider = (config.provider || 'openrouter').toLowerCase();
+  switch (provider) {
+    case 'ollama':
+      return new OllamaProvider(config);
+    case 'groq':
+      return new GroqProvider(config);
+    case 'gemini':
+      return new GeminiProvider(config);
+    case 'openrouter':
+    default:
+      return new OpenRouterProvider(config);
   }
-
-  // Try to get API key from user config if not in env
-  const savedKey = userConfig.get(`apiKeys.${providerName}`);
-  const providerConfig = {
-    model: config.model,
-    apiKey: savedKey || undefined,
-  };
-
-  return new ProviderClass(providerConfig);
 }
+
+module.exports = { createProvider };

package/src/llm/prompts.js

@@ -1,52 +1,64 @@
-/**
- * LLM Prompt definitions — SINGLE SOURCE OF TRUTH.
- * Do NOT modify prompts at call sites.
- */
+'use strict';
+
+const SYSTEM_PROMPT = `You are a technical documentation writer. You will be given:
+  1. Extracted structural facts about a source file (JSON)
+  2. The raw source code of that file
+
+Your job is to write clear, accurate Markdown documentation based ONLY on what is present in the code.
 
-export const SYSTEM_PROMPT = `Kamu adalah penulis dokumentasi teknis profesional. Kamu akan diberikan:
-  1. Fakta struktural yang diekstrak dari sebuah file sumber kode (format JSON)
-  2. Kode sumber mentah dari file tersebut
-
-Tugasmu adalah menulis dokumentasi Markdown yang jelas, akurat, dan DETAIL berdasarkan HANYA
-apa yang ada di dalam kode. Aturan:
-- JANGAN menyimpulkan perilaku yang tidak ditunjukkan secara eksplisit dalam kode
-- JANGAN menyebut sistem eksternal kecuali muncul di bagian import
-- JANGAN mengarang deskripsi fungsi
-- Jika tujuan suatu fungsi tidak jelas dari isinya, katakan dengan jujur
-- Tulis semua penjelasan, deskripsi, dan isi dokumentasi dalam Bahasa Indonesia
-- Istilah teknis umum (seperti middleware, router, endpoint, request, response, callback) boleh tetap dalam Bahasa Inggris
-- Berikan penjelasan yang DETAIL dan ELABORATIF — jangan hanya 1 kalimat singkat, jelaskan konteks, alur kerja, dan tujuannya
-
-Format output (Markdown ketat, ikuti persis):
+Rules:
+- Do NOT infer behavior not explicitly shown in the code
+- Do NOT mention external systems unless they appear in imports
+- Do NOT fabricate function descriptions
+- If a function's purpose is unclear from its body, say so honestly
+- Do not mention any function, class, parameter, or behavior that does not appear in the FileFacts JSON or bodySnippet above
+- For each function with complexityClass "moderate" or "complex", explain the logic described in the bodySnippet in plain language
+- For each function with detectedPatterns[] non-empty, explicitly describe what that pattern does in context
+
+Temperature: use 0.1 — factual output only.
+
+Output format (strict Markdown):
 ## Overview
-[2-4 kalimat yang menjelaskan apa yang dilakukan file ini, konteksnya dalam aplikasi, dan tanggung jawab utamanya]
+[1-2 sentences about what this file does]
 
 ## Functions
-[Satu subseksi ### per fungsi/method, berisi:
-- Paragraf deskripsi detail: apa yang dilakukan fungsi, alur kerjanya step-by-step, dan kapan digunakan
-- Tabel parameter: | Nama | Tipe | Deskripsi |
-- Keterangan nilai kembalian (return value) beserta penjelasannya]
+[One ### subsection per exported function with: description, params table, return value]
 
 ## Dependencies
-[Daftar bullet setiap import beserta penjelasan satu baris mengapa modul tersebut digunakan dalam file ini]
+[Bullet list of imports with one-line description of each]
 
 ## Usage Example
-[Hanya sertakan jika pola penggunaan yang jelas terlihat dalam kode itu sendiri]`;
+[Only include if a clear usage pattern is visible in the code itself]`;
 
 /**
- * Build the user message for a single file LLM request.
- * @param {object} fileFacts - FileFacts JSON
- * @param {string} rawSource - Raw file content
- * @returns {string} Formatted user message
+ * Build the user message for a single file.
+ * @param {Object} fileFacts
+ * @param {string} rawSource
+ * @returns {string}
  */
-export function buildUserMessage(fileFacts, rawSource) {
-  const factsJson = JSON.stringify(fileFacts, null, 2);
+function buildUserMessage(fileFacts, rawSource) {
+  // Include bodySnippets inline in the facts JSON for moderate/complex functions
+  const factsForPrompt = {
+    ...fileFacts,
+    functions: (fileFacts.functions || []).map(fn => {
+      const entry = { ...fn };
+      if (fn.complexityClass === 'moderate' || fn.complexityClass === 'complex') {
+        entry._promptHint = `Explain this function's logic in plain language based on its bodySnippet.`;
+      }
+      if (fn.detectedPatterns && fn.detectedPatterns.length > 0) {
+        entry._patternHint = `This function uses patterns: ${fn.detectedPatterns.join(', ')}. Describe what each does in context.`;
+      }
+      return entry;
+    }),
+  };
 
   return `FILE FACTS (extracted by static analysis):
-${factsJson}
+${JSON.stringify(factsForPrompt, null, 2)}
 
 SOURCE CODE:
 ${rawSource}
 
 Generate documentation for this file following the system instructions.`;
 }
+
+module.exports = { SYSTEM_PROMPT, buildUserMessage };

package/src/llm/providers/gemini.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const { NoApiKeyError } = require('../../utils/errors');
+
+const GEMINI_BASE = 'https://generativelanguage.googleapis.com/v1beta';
+const DEFAULT_MODEL = 'gemini-2.0-flash';
+
+class GeminiProvider {
+  constructor(config) {
+    this.apiKey = config.geminiApiKey || process.env.GEMINI_API_KEY;
+    if (!this.apiKey) throw new NoApiKeyError('gemini');
+    this.model = config.model || DEFAULT_MODEL;
+    this.name = 'gemini';
+    this.isFreeModel = true;
+  }
+
+  async complete(chunk) {
+    const url = `${GEMINI_BASE}/models/${this.model}:generateContent?key=${this.apiKey}`;
+
+    const body = {
+      contents: [
+        {
+          parts: [
+            { text: chunk.systemPrompt + '\n\n' + chunk.userMessage },
+          ],
+        },
+      ],
+      generationConfig: {
+        temperature: 0.3,
+        maxOutputTokens: 4096,
+      },
+    };
+
+    let response;
+    try {
+      response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+    } catch (e) {
+      throw new Error(`Could not connect to Gemini API: ${e.message}`);
+    }
+
+    if (response.status === 429) {
+      const body = await response.text();
+      const { RateLimitError } = require('../../utils/errors');
+      const headerVal = parseInt(response.headers.get('retry-after') || '0');
+      const retryAfter = Math.max(headerVal * 1000, 15000);
+      const err = new RateLimitError('gemini', retryAfter);
+      // Include Gemini's actual error detail so user can see what's wrong
+      try {
+        const parsed = JSON.parse(body);
+        const detail = parsed.error && parsed.error.message ? parsed.error.message : body.substring(0, 200);
+        err.message = `Rate limit exceeded for provider "gemini": ${detail}`;
+      } catch (_) {
+        err.message = `Rate limit exceeded for provider "gemini": ${body.substring(0, 200)}`;
+      }
+      throw err;
+    }
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Gemini API error ${response.status}: ${text.substring(0, 500)}`);
+    }
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Gemini API error ${response.status}: ${text}`);
+    }
+
+    const data = await response.json();
+
+    // Extract content from Gemini response format
+    let content = '';
+    if (data.candidates && data.candidates[0] && data.candidates[0].content) {
+      const parts = data.candidates[0].content.parts || [];
+      content = parts.map((p) => p.text || '').join('');
+    }
+
+    // Extract usage metadata
+    const usage = data.usageMetadata || {};
+    const tokensUsed = {
+      input: usage.promptTokenCount || 0,
+      output: usage.candidatesTokenCount || 0,
+    };
+
+    return { content, tokensUsed };
+  }
+
+  estimateCost() { return 0; }
+}
+
+module.exports = { GeminiProvider };

package/src/llm/providers/groq.js

@@ -1,52 +1,67 @@
-/**
- * Groq LLM provider adapter.
- * Uses groq-sdk.
- * Default model: llama-3.3-70b-versatile.
- */
+'use strict';
 
-import Groq from 'groq-sdk';
-import { NoApiKeyError, RateLimitError } from '../../utils/errors.js';
+const { NoApiKeyError } = require('../../utils/errors');
 
-export class GroqProvider {
-  constructor(config = {}) {
-    this.name = 'groq';
-    this.model = config.model || 'llama-3.3-70b-versatile';
-
-    const apiKey = config.apiKey || process.env.GROQ_API_KEY;
-    if (!apiKey) {
-      throw new NoApiKeyError('groq');
-    }
+const GROQ_BASE = 'https://api.groq.com/openai/v1';
+const DEFAULT_MODEL = 'llama-3.3-70b-versatile';
 
-    this.client = new Groq({ apiKey });
+class GroqProvider {
+  constructor(config) {
+    this.apiKey = config.groqApiKey || process.env.GROQ_API_KEY;
+    if (!this.apiKey) throw new NoApiKeyError('groq');
+    this.model = config.model || DEFAULT_MODEL;
+    this.name = 'groq';
+    this.isFreeModel = true; // Groq free tier
   }
 
-  async complete(request) {
+  async complete(chunk) {
+    const body = {
+      model: this.model,
+      messages: [
+        { role: 'system', content: chunk.systemPrompt },
+        { role: 'user', content: chunk.userMessage },
+      ],
+    };
+
+    let response;
     try {
-      const response = await this.client.chat.completions.create({
-        model: this.model,
-        max_tokens: 4096,
-        messages: [
-          { role: 'system', content: request.systemPrompt },
-          { role: 'user', content: request.userMessage },
-        ],
+      response = await fetch(`${GROQ_BASE}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`,
+        },
+        body: JSON.stringify(body),
       });
+    } catch (e) {
+      throw new Error(`Could not connect to Groq API: ${e.message}`);
+    }
 
-      return {
-        content: response.choices[0].message.content,
-        tokensUsed: {
-          input: response.usage?.prompt_tokens || 0,
-          output: response.usage?.completion_tokens || 0,
-        },
-      };
-    } catch (err) {
-      if (err.status === 429) {
-        throw new RateLimitError('groq');
-      }
-      throw err;
+    if (response.status === 429) {
+      const { RateLimitError } = require('../../utils/errors');
+      const headerVal = parseInt(response.headers.get('retry-after') || '0');
+      // Minimum 15s wait — Groq free tier needs breathing room
+      const retryAfter = Math.max(headerVal * 1000, 15000);
+      throw new RateLimitError('groq', retryAfter);
+    }
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Groq API error ${response.status}: ${text}`);
     }
-  }
 
-  estimateCost(inputTokens, outputTokens) {
-    return (inputTokens * 0.00059 + outputTokens * 0.00079) / 1000;
+    const data = await response.json();
+    const content = (data.choices && data.choices[0] && data.choices[0].message && data.choices[0].message.content) || '';
+    const usage = data.usage || {};
+    const tokensUsed = {
+      input: usage.prompt_tokens || 0,
+      output: usage.completion_tokens || 0,
+    };
+
+    return { content, tokensUsed };
   }
+
+  estimateCost() { return 0; }
 }
+
+module.exports = { GroqProvider };

package/src/llm/providers/ollama.js

@@ -1,85 +1,58 @@
-/**
- * Ollama LLM provider adapter.
- * HTTP client to local Ollama API (http://localhost:11434).
- * No API key required.
- * Default model: llama3.2.
- */
+'use strict';
 
-import { LegacyverError } from '../../utils/errors.js';
+const logger = require('../../utils/logger');
 
-const DEFAULT_BASE_URL = 'http://localhost:11434';
+const OLLAMA_BASE = 'http://localhost:11434';
+const DEFAULT_MODEL = 'llama3.2';
 
-export class OllamaProvider {
-  constructor(config = {}) {
+class OllamaProvider {
+  constructor(config) {
+    this.model = config.model || DEFAULT_MODEL;
     this.name = 'ollama';
-    this.model = config.model || 'llama3.2';
-    this.baseUrl = config.baseUrl || process.env.OLLAMA_HOST || DEFAULT_BASE_URL;
+    this.isFreeModel = true;
   }
 
-  async complete(request) {
-    const url = `${this.baseUrl}/api/chat`;
-    const timeoutMs = 300_000; // 5 minutes — local inference can be slow
+  async complete(chunk) {
+    const body = {
+      model: this.model,
+      stream: false,
+      messages: [
+        { role: 'system', content: chunk.systemPrompt },
+        { role: 'user', content: chunk.userMessage },
+      ],
+    };
 
     let response;
     try {
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), timeoutMs);
-      try {
-        response = await fetch(url, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          signal: controller.signal,
-          body: JSON.stringify({
-            model: this.model,
-            messages: [
-              { role: 'system', content: request.systemPrompt },
-              { role: 'user', content: request.userMessage },
-            ],
-            stream: false,
-            options: {
-              num_predict: 2048,
-            },
-          }),
-        });
-      } finally {
-        clearTimeout(timer);
-      }
-    } catch (err) {
-      if (err.name === 'AbortError') {
-        throw new LegacyverError(
-          `Ollama request timed out after ${timeoutMs / 1000}s. Try a smaller file or faster model.`,
-          { exitCode: 1, suggestion: 'Use --concurrency 1 to reduce load on Ollama' }
-        );
-      }
-      throw new LegacyverError(
-        `Cannot connect to Ollama at ${this.baseUrl}. Is Ollama running?`,
-        {
-          exitCode: 1,
-          suggestion: 'Start Ollama with "ollama serve" or install from https://ollama.ai',
-        }
+      response = await fetch(`${OLLAMA_BASE}/api/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+    } catch (e) {
+      throw new Error(
+        `Could not connect to Ollama at ${OLLAMA_BASE}. ` +
+          `Make sure Ollama is running: run \`ollama serve\` in a terminal, ` +
+          `then \`ollama pull ${this.model}\` to download the model.`
       );
     }
 
     if (!response.ok) {
-      const body = await response.text();
-      throw new LegacyverError(
-        `Ollama returned ${response.status}: ${body}`,
-        { exitCode: 1 }
-      );
+      const text = await response.text();
+      throw new Error(`Ollama API error ${response.status}: ${text}`);
     }
 
     const data = await response.json();
-
-    return {
-      content: data.message?.content || '',
-      tokensUsed: {
-        input: data.prompt_eval_count || 0,
-        output: data.eval_count || 0,
-      },
+    const content = data.message && data.message.content || '';
+    const tokensUsed = {
+      input: data.prompt_eval_count || 0,
+      output: data.eval_count || 0,
     };
-  }
 
-  estimateCost() {
-    return 0; // Local, free
+    return { content, tokensUsed };
   }
+
+  estimateCost() { return 0; }
 }
+
+module.exports = { OllamaProvider };

package/src/llm/providers/openrouter.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const { NoApiKeyError, RateLimitError } = require('../../utils/errors');
+const logger = require('../../utils/logger');
+
+const DEFAULT_MODEL = 'meta-llama/llama-3.3-70b-instruct:free';
+
+class OpenRouterProvider {
+  constructor(config) {
+    this.apiKey = config.apiKey || process.env.OPENROUTER_API_KEY;
+    if (!this.apiKey) {
+      throw new NoApiKeyError('openrouter');
+    }
+    this.model = config.model || DEFAULT_MODEL;
+    this.isFreeModel = this.model.endsWith(':free');
+    this.name = 'openrouter';
+  }
+
+  async complete(chunk) {
+    const body = {
+      model: this.model,
+      temperature: 0.1,
+      messages: [
+        { role: 'system', content: chunk.systemPrompt },
+        { role: 'user', content: chunk.userMessage },
+      ],
+    };
+
+    const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`,
+        'HTTP-Referer': 'https://github.com/user/legacyver',
+        'X-Title': 'Legacyver',
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (response.status === 429) {
+      const retryAfter = parseInt(response.headers.get('retry-after') || '1') * 1000;
+      throw new RateLimitError('openrouter', retryAfter);
+    }
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`OpenRouter API error ${response.status}: ${text}`);
+    }
+
+    const data = await response.json();
+    const content = data.choices && data.choices[0] && data.choices[0].message && data.choices[0].message.content || '';
+    const tokensUsed = {
+      input: data.usage && data.usage.prompt_tokens || 0,
+      output: data.usage && data.usage.completion_tokens || 0,
+    };
+
+    return { content, tokensUsed };
+  }
+
+  estimateCost(inputTokens, outputTokens) {
+    if (this.isFreeModel) return 0;
+    // Rough: use fallback rates
+    return 0;
+  }
+}
+
+module.exports = { OpenRouterProvider };