hybard-agent 0.1.0

package/lib/online.js

@@ -0,0 +1,654 @@
+/**
+ * Hybard AI Online Client — Connects to AI APIs (OpenAI-compatible).
+ *
+ * Supports:
+ *   - OpenAI API (GPT-4, GPT-3.5)
+ *   - Groq (free, fast inference — llama, mixtral)
+ *   - OpenRouter (many models — Claude, Gemini, Llama, etc.)
+ *   - Ollama (local models — llama3.2, codellama, etc.)
+ *   - Any OpenAI-compatible endpoint (LM Studio, etc.)
+ *
+ * Provider presets (auto-configured):
+ *   groq       — api.groq.com/openai/v1 (free tier available)
+ *   openrouter — openrouter.ai/api/v1
+ *   ollama     — localhost:11434/v1 (local)
+ *   openai     — api.openai.com/v1
+ *
+ * Usage:
+ *   node -e "const {HybardAI} = require('./lib/online'); const ai = new HybardAI(); ai.chat('hello').then(console.log)"
+ */
+
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+
+// Load .env file if present
+const envPath = path.join(__dirname, '..', '.env');
+if (fs.existsSync(envPath)) {
+  const envContent = fs.readFileSync(envPath, 'utf8');
+  for (const line of envContent.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eqIdx = trimmed.indexOf('=');
+    if (eqIdx > 0) {
+      const key = trimmed.slice(0, eqIdx).trim();
+      const val = trimmed.slice(eqIdx + 1).trim();
+      if (!process.env[key]) process.env[key] = val;
+    }
+  }
+}
+
+const os = require('os');
+const CONFIG_DIR = path.join(os.homedir(), '.hybard');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const NETWORK_FILE = path.join(CONFIG_DIR, 'network.json');
+
+// ─── Auto-detect local Wi-Fi/LAN IP ─────────────────────
+function detectLocalIP() {
+  try {
+    const interfaces = os.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+      for (const iface of interfaces[name]) {
+        if (iface.family === 'IPv4' && !iface.internal) {
+          return iface.address;
+        }
+      }
+    }
+  } catch (e) {}
+  return '127.0.0.1';
+}
+
+// ─── Probe a URL to see if it's reachable ────────────────
+function probeUrl(url, timeoutMs = 2000) {
+  return new Promise((resolve) => {
+    const mod = url.startsWith('https') ? https : http;
+    const req = mod.get(url, { timeout: timeoutMs }, (res) => {
+      let data = '';
+      res.on('data', (c) => (data += c));
+      res.on('end', () => resolve({ ok: true, data }));
+    });
+    req.on('error', () => resolve({ ok: false }));
+    req.on('timeout', () => { req.destroy(); resolve({ ok: false }); });
+  });
+}
+
+// ─── Find the Hybard server on the network ──────────────
+async function discoverHybardServer() {
+  const localIP = detectLocalIP();
+  const candidates = [
+    `http://127.0.0.1:8000/health`,
+    `http://localhost:8000/health`,
+    `http://${localIP}:8000/health`,
+  ];
+  for (const url of candidates) {
+    const result = await probeUrl(url, 1500);
+    if (result.ok) {
+      const base = url.replace('/health', '');
+      return { url: base, ip: new URL(base).hostname };
+    }
+  }
+  return null;
+}
+
+// Provider presets — auto-configure baseUrl and default model
+const PROVIDER_PRESETS = {
+  hybard: {
+    baseUrl: 'http://localhost:8000/v1',
+    defaultModel: 'hybard-custom-llm',
+    defaultApiKey: 'hybard-local',
+    local: true,
+  },
+  groq: {
+    baseUrl: 'https://api.groq.com/openai/v1',
+    defaultModel: 'llama-3.3-70b-versatile',
+    defaultApiKey: process.env.GROQ_API_KEY || '',
+  },
+  openrouter: {
+    baseUrl: 'https://openrouter.ai/api/v1',
+    defaultModel: 'google/gemma-2-9b-it:free',
+    defaultApiKey: process.env.OPENROUTER_API_KEY || '',
+  },
+  ollama: {
+    baseUrl: 'http://localhost:11434/v1',
+    defaultModel: 'llama3.2',
+    defaultApiKey: 'ollama',
+  },
+  openai: {
+    baseUrl: 'https://api.openai.com/v1',
+    defaultModel: 'gpt-4o',
+    defaultApiKey: process.env.OPENAI_API_KEY || '',
+  },
+};
+
+const DEFAULT_CONFIG = {
+  provider: 'hybard',
+  apiKey: 'hybard-local',
+  baseUrl: 'http://localhost:8000/v1',
+  model: 'hybard-custom-llm',
+  maxTokens: 2048,
+  temperature: 0.7,
+};
+
+class HybardAI {
+  constructor(options = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...this._loadConfig(), ...options };
+    this.localServerUrl = null;
+    this.systemPrompt = `You are Hybard AI, an expert coding assistant. You help with:
+- Writing code in any programming language
+- Explaining code and concepts
+- Debugging and fixing errors
+- Creating project scaffolds
+- Best practices and architecture advice
+
+Always respond with clear, helpful code and explanations. When writing code, use proper formatting with markdown code blocks.`;
+
+    // Auto-discover local server in background
+    this._discoverLocalServer();
+  }
+
+  async _discoverLocalServer() {
+    try {
+      const server = await discoverHybardServer();
+      if (server) {
+        this.localServerUrl = server.url;
+        PROVIDER_PRESETS.hybard.baseUrl = server.url + '/v1';
+        console.log(`[HybardAI] Local LLM server found at ${server.url}`);
+      }
+    } catch (e) {}
+  }
+
+  _loadConfig() {
+    try {
+      if (fs.existsSync(CONFIG_FILE)) {
+        return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+      }
+    } catch (e) {}
+    return {};
+  }
+
+  saveConfig(updates = {}) {
+    this.config = { ...this.config, ...updates };
+    if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(this.config, null, 2));
+    return this.config;
+  }
+
+  getApiKey() {
+    return this.config.apiKey || process.env.HYBARD_API_KEY || process.env.OPENAI_API_KEY || '';
+  }
+
+  getBaseUrl() {
+    return this.config.baseUrl || 'https://api.openai.com/v1';
+  }
+
+  /**
+   * Switch to a preset provider (groq, openrouter, ollama, openai).
+   * Automatically sets baseUrl, model, and apiKey.
+   */
+  setProvider(providerName) {
+    const preset = PROVIDER_PRESETS[providerName];
+    if (!preset) {
+      throw new Error(`Unknown provider: ${providerName}. Available: ${Object.keys(PROVIDER_PRESETS).join(', ')}`);
+    }
+    this.config.provider = providerName;
+    this.config.baseUrl = preset.baseUrl;
+    this.config.model = preset.defaultModel;
+    if (preset.defaultApiKey) {
+      this.config.apiKey = preset.defaultApiKey;
+    }
+    this.saveConfig(this.config);
+    return this.config;
+  }
+
+  /**
+   * List available providers and their status.
+   */
+  listProviders() {
+    return Object.entries(PROVIDER_PRESETS).map(([name, preset]) => ({
+      name,
+      baseUrl: preset.baseUrl,
+      model: preset.defaultModel,
+      hasApiKey: !!(preset.defaultApiKey || this.getApiKey()),
+      isCurrent: this.config.provider === name,
+    }));
+  }
+
+  /**
+   * Send a chat completion request to the AI API with automatic fallback.
+   * Tries current provider first, then falls back to others on failure.
+   */
+  async chat(message, options = {}) {
+    const apiKey = this.getApiKey();
+    if (!apiKey) {
+      return this._fallbackResponse(message);
+    }
+
+    // Try current provider first
+    try {
+      return await this._chatProvider(this.config.provider, message, options);
+    } catch (err) {
+      console.log(`[Fallback] ${this.config.provider} failed: ${err.message}`);
+      
+      // Try fallback providers: hybard local first, then others
+      const fallbacks = ['hybard', 'groq', 'ollama', 'openrouter', 'openai'].filter(p => p !== this.config.provider);
+      
+      for (const provider of fallbacks) {
+        try {
+          const preset = PROVIDER_PRESETS[provider];
+          if (!preset) continue;
+          if (!preset.local && !preset.defaultApiKey && provider !== 'ollama') continue;
+          
+          console.log(`[Fallback] Trying ${provider}...`);
+          return await this._chatProvider(provider, message, options);
+        } catch (e2) {
+          console.log(`[Fallback] ${provider} also failed: ${e2.message}`);
+          continue;
+        }
+      }
+      
+      throw err;
+    }
+  }
+
+  /**
+   * Chat with a specific provider.
+   */
+  async _chatProvider(provider, message, options = {}) {
+    const preset = PROVIDER_PRESETS[provider];
+    if (!preset) throw new Error(`Unknown provider: ${provider}`);
+    
+    // Local providers don't need API keys
+    const isLocal = preset.local || provider === 'ollama' || provider === 'hybard';
+    const apiKey = isLocal ? (preset.defaultApiKey || 'local') : (preset.defaultApiKey || this.getApiKey());
+    
+    if (!isLocal && !apiKey) {
+      throw new Error(`No API key for ${provider}`);
+    }
+
+    // Use Ollama native API for better reliability
+    if (provider === 'ollama') {
+      return this._chatOllama(message, options);
+    }
+
+    const messages = [
+      { role: 'system', content: options.system || this.systemPrompt },
+      { role: 'user', content: message },
+    ];
+
+    const body = JSON.stringify({
+      model: options.model || preset.defaultModel,
+      messages,
+      max_tokens: options.maxTokens || this.config.maxTokens,
+      temperature: options.temperature ?? this.config.temperature,
+      stream: false,
+    });
+
+    const baseUrl = new URL(preset.baseUrl);
+    const isHttps = baseUrl.protocol === 'https:';
+    const transport = isHttps ? https : http;
+
+    return new Promise((resolve, reject) => {
+      const req = transport.request(
+        {
+          hostname: baseUrl.hostname,
+          port: baseUrl.port || (isHttps ? 443 : 80),
+          path: `${baseUrl.pathname}/chat/completions`.replace(/\/+/g, '/'),
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Length': Buffer.byteLength(body),
+          },
+          timeout: 60000,
+        },
+        (res) => {
+          let data = '';
+          res.on('data', (chunk) => (data += chunk));
+          res.on('end', () => {
+            try {
+              const json = JSON.parse(data);
+              if (json.error) {
+                reject(new Error(json.error.message || JSON.stringify(json.error)));
+                return;
+              }
+              const content = json.choices?.[0]?.message?.content || '';
+              resolve(content);
+            } catch (e) {
+              reject(new Error(`Failed to parse response: ${data.slice(0, 200)}`));
+            }
+          });
+        }
+      );
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('Request timed out'));
+      });
+      req.write(body);
+      req.end();
+    });
+  }
+
+  /**
+   * Chat using Ollama's native /api/generate endpoint (more reliable).
+   */
+  async _chatOllama(message, options = {}) {
+    const baseUrl = new URL(this.getBaseUrl());
+    // Ollama native endpoint: /api/generate (not /v1/chat/completions)
+    const ollamaUrl = `http://${baseUrl.hostname}:${baseUrl.port || 11434}`;
+
+    const body = JSON.stringify({
+      model: options.model || this.config.model,
+      prompt: message,
+      stream: false,
+      options: {
+        num_predict: options.maxTokens || this.config.maxTokens,
+        temperature: options.temperature ?? this.config.temperature,
+      },
+    });
+
+    return new Promise((resolve, reject) => {
+      const req = http.request(
+        {
+          hostname: baseUrl.hostname,
+          port: baseUrl.port || 11434,
+          path: '/api/generate',
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength(body),
+          },
+          timeout: 300000, // 5 minutes for local model
+        },
+        (res) => {
+          let data = '';
+          res.on('data', (chunk) => (data += chunk));
+          res.on('end', () => {
+            try {
+              const json = JSON.parse(data);
+              if (json.error) {
+                reject(new Error(json.error));
+                return;
+              }
+              resolve(json.response || '');
+            } catch (e) {
+              reject(new Error(`Failed to parse Ollama response: ${data.slice(0, 200)}`));
+            }
+          });
+        }
+      );
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('Ollama request timed out. The model may be loading — this can take 1-5 minutes for the first request. Try again and wait longer.'));
+      });
+      req.write(body);
+      req.end();
+    });
+  }
+
+  /**
+   * Stream chat completion (yields chunks).
+   */
+  async *chatStream(message, options = {}) {
+    const apiKey = this.getApiKey();
+    if (!apiKey) {
+      yield this._fallbackResponse(message);
+      return;
+    }
+
+    const messages = [
+      { role: 'system', content: options.system || this.systemPrompt },
+      { role: 'user', content: message },
+    ];
+
+    const body = JSON.stringify({
+      model: options.model || this.config.model,
+      messages,
+      max_tokens: options.maxTokens || this.config.maxTokens,
+      temperature: options.temperature ?? this.config.temperature,
+      stream: true,
+    });
+
+    const baseUrl = new URL(options.baseUrl || this.getBaseUrl());
+    const isHttps = baseUrl.protocol === 'https:';
+    const transport = isHttps ? https : http;
+
+    yield* new Promise((resolve, reject) => {
+      const chunks = [];
+      const req = transport.request(
+        {
+          hostname: baseUrl.hostname,
+          port: baseUrl.port || (isHttps ? 443 : 80),
+          path: `${baseUrl.pathname}/chat/completions`.replace(/\/+/g, '/'),
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${apiKey}`,
+          },
+        },
+        (res) => {
+          let buffer = '';
+          res.on('data', (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+              if (line.startsWith('data: ')) {
+                const data = line.slice(6).trim();
+                if (data === '[DONE]') continue;
+                try {
+                  const json = JSON.parse(data);
+                  const delta = json.choices?.[0]?.delta?.content;
+                  if (delta) chunks.push(delta);
+                } catch (e) {}
+              }
+            }
+          });
+          res.on('end', () => resolve(chunks));
+        }
+      );
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('Request timed out'));
+      });
+      req.write(body);
+      req.end();
+    });
+
+    for (const chunk of chunks) yield chunk;
+  }
+
+  /**
+   * Generate code from a prompt.
+   */
+  async generateCode(prompt, language = 'python') {
+    const sysPrompt = `You are an expert ${language} programmer. Generate clean, working code.
+Respond ONLY with the code in a markdown code block. No explanations unless asked.`;
+    return this.chat(prompt, { system: sysPrompt });
+  }
+
+  /**
+   * Explain code.
+   */
+  async explainCode(code) {
+    const sysPrompt = `You are a code analysis expert. Explain the given code clearly and concisely.
+Cover: what it does, how it works, key patterns, and any potential issues.`;
+    return this.chat(`Explain this code:\n\n\`\`\`\n${code}\n\`\`\``, { system: sysPrompt });
+  }
+
+  /**
+   * Fix code with an error.
+   */
+  async fixCode(code, error = '') {
+    const sysPrompt = `You are a debugging expert. Fix the given code.
+Return ONLY the corrected code in a markdown code block.`;
+    const msg = error
+      ? `Fix this code. Error: ${error}\n\n\`\`\`\n${code}\n\`\`\``
+      : `Fix any issues in this code:\n\n\`\`\`\n${code}\n\`\`\``;
+    return this.chat(msg, { system: sysPrompt });
+  }
+
+  /**
+   * Create project scaffold.
+   */
+  async scaffold(goal) {
+    const sysPrompt = `You are a project scaffolding expert. Create project files for the given goal.
+Return each file in this format:
+## filename.ext
+\`\`\`language
+file content here
+\`\`\`
+Include all necessary files (main code, config, tests, README).`;
+    return this.chat(`Create a project scaffold for: ${goal}`, { system: sysPrompt });
+  }
+
+  /**
+   * Fallback when no API key is configured.
+   */
+  _fallbackResponse(message) {
+    return `[Hybard AI — Offline Mode]
+
+No API key configured. To enable online AI:
+  1. hybard config set apiKey YOUR_API_KEY
+  2. hybard config set model gpt-4
+
+Or set environment variable:
+  set HYBARD_API_KEY=your-key
+
+Current config:
+  Provider: ${this.config.provider}
+  Model: ${this.config.model}
+  Base URL: ${this.config.baseUrl}
+
+You can still use offline features:
+  hybard create <project>     — scaffold projects
+  hybard fix <file>           — repair syntax errors
+  hybard inspect              — scan workspace
+  hybard help                 — show all commands
+
+Message received: "${message.slice(0, 100)}"`;
+  }
+}
+
+/**
+ * Interactive chat REPL with streaming output.
+ */
+async function startChat(options = {}) {
+  const readline = require('readline');
+  const ai = new HybardAI(options);
+
+  console.log('\n╔════════════════════════════════════════════════════════════╗');
+  console.log('║              Hybard AI — Online Coding Assistant          ║');
+  console.log('║                                                          ║');
+  console.log('║  Commands:                                               ║');
+  console.log('║    /config    — Show/set API configuration               ║');
+  console.log('║    /model     — Change AI model                          ║');
+  console.log('║    /clear     — Clear chat history                       ║');
+  console.log('║    /help      — Show help                                ║');
+  console.log('║    exit       — Exit                                     ║');
+  console.log('╚════════════════════════════════════════════════════════════╝\n');
+
+  if (!ai.getApiKey()) {
+    console.log('⚠  No API key detected. Running in offline mode.');
+    console.log('   Set your key: hybard config set apiKey YOUR_KEY\n');
+  } else {
+    console.log(`✓  Connected to ${ai.config.provider} (${ai.config.model})\n`);
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: 'You > ',
+  });
+
+  rl.prompt();
+
+  rl.on('line', async (line) => {
+    const text = line.trim();
+    if (!text) { rl.prompt(); return; }
+
+    if (text.toLowerCase() === 'exit' || text.toLowerCase() === 'quit') {
+      console.log('\nGoodbye! 👋\n');
+      rl.close();
+      return;
+    }
+
+    if (text === '/config') {
+      console.log('\nCurrent configuration:');
+      console.log(`  Provider: ${ai.config.provider}`);
+      console.log(`  Model:    ${ai.config.model}`);
+      console.log(`  Base URL: ${ai.config.baseUrl}`);
+      console.log(`  API Key:  ${ai.getApiKey() ? '***' + ai.getApiKey().slice(-4) : '(not set)'}`);
+      console.log(`  Max Tokens: ${ai.config.maxTokens}`);
+      console.log(`  Temperature: ${ai.config.temperature}`);
+      console.log('\nSet a value: /config set <key> <value>');
+      rl.prompt();
+      return;
+    }
+
+    if (text.startsWith('/config set ')) {
+      const parts = text.slice(12).split(' ');
+      const key = parts[0];
+      const value = parts.slice(1).join(' ');
+      if (key && value) {
+        const numVal = parseFloat(value);
+        ai.saveConfig({ [key]: isNaN(numVal) ? value : numVal });
+        console.log(`✓ Set ${key} = ${value}`);
+      } else {
+        console.log('Usage: /config set <key> <value>');
+      }
+      rl.prompt();
+      return;
+    }
+
+    if (text === '/model' || text.startsWith('/model ')) {
+      if (text.startsWith('/model ')) {
+        const model = text.slice(7).trim();
+        ai.saveConfig({ model });
+        console.log(`✓ Model changed to: ${model}`);
+      } else {
+        console.log(`Current model: ${ai.config.model}`);
+        console.log('Change: /model gpt-4, /model gpt-3.5-turbo, /model claude-3-opus');
+      }
+      rl.prompt();
+      return;
+    }
+
+    if (text === '/clear') {
+      console.clear();
+      rl.prompt();
+      return;
+    }
+
+    if (text === '/help') {
+      console.log('\nHybard AI Chat Commands:');
+      console.log('  /config           — Show configuration');
+      console.log('  /config set X Y   — Set a config value');
+      console.log('  /model <name>     — Change AI model');
+      console.log('  /clear            — Clear screen');
+      console.log('  exit              — Exit chat');
+      console.log('\nJust type your coding question or request!\n');
+      rl.prompt();
+      return;
+    }
+
+    // Normal message — send to AI
+    process.stdout.write('\nHybard > ');
+    try {
+      const response = await ai.chat(text);
+      console.log('\n' + response + '\n');
+    } catch (err) {
+      console.error(`\n[Error] ${err.message}\n`);
+    }
+    rl.prompt();
+  });
+
+  rl.on('close', () => process.exit(0));
+}
+
+module.exports = { HybardAI, startChat, discoverHybardServer, detectLocalIP };