hybard-agent 0.1.0

package/lib/main.dart

@@ -0,0 +1,32 @@
+import 'package:flutter/material.dart';
+
+void main() {
+  runApp(const MyApp());
+}
+
+class MyApp extends StatelessWidget {
+  const MyApp({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return MaterialApp(
+      title: 'hybard-agent',
+      theme: ThemeData(primarySwatch: Colors.blue),
+      home: const HomeScreen(),
+    );
+  }
+}
+
+class HomeScreen extends StatelessWidget {
+  const HomeScreen({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(title: const Text('Hybard Flutter App')),
+      body: const Center(
+        child: Text('Generated app for: flutter mobile app --port 7862'),
+      ),
+    );
+  }
+}

package/lib/models.js

@@ -0,0 +1,357 @@
+/**
+ * Hybard Model Router — Multi-provider, multi-model AI routing.
+ *
+ * Supports:
+ *   - Groq (free, fast — llama, mixtral, gemma)
+ *   - Ollama (local — llama3.2, codellama, deepseek-coder, etc.)
+ *   - OpenRouter (many models — Claude, Gemini, Llama, etc.)
+ *   - OpenAI (GPT-4, GPT-3.5)
+ *   - Custom endpoints (any OpenAI-compatible)
+ *
+ * Features:
+ *   - Per-user model selection
+ *   - Fallback chain (if one provider fails, try next)
+ *   - Token counting & usage tracking
+ *   - Model capabilities detection
+ *
+ * Usage:
+ *   const router = new ModelRouter();
+ *   const response = await router.chat('write fibonacci', { provider: 'groq' });
+ */
+
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+
+// ─── Provider Definitions ────────────────────────────────
+
+const PROVIDERS = {
+  groq: {
+    name: 'Groq',
+    baseUrl: 'https://api.groq.com/openai/v1',
+    apiKey: process.env.GROQ_API_KEY || '',
+    models: {
+      'llama-3.3-70b-versatile': { name: 'Llama 3.3 70B', size: '70B', coding: true, speed: 'fast' },
+      'llama-3.1-8b-instant': { name: 'Llama 3.1 8B Instant', size: '8B', coding: true, speed: 'very-fast' },
+      'mixtral-8x7b-32768': { name: 'Mixtral 8x7B', size: '8x7B', coding: true, speed: 'fast' },
+      'gemma2-9b-it': { name: 'Gemma 2 9B', size: '9B', coding: false, speed: 'fast' },
+    },
+    defaultModel: 'llama-3.3-70b-versatile',
+    free: true,
+  },
+  ollama: {
+    name: 'Ollama (Local)',
+    baseUrl: 'http://localhost:11434',
+    apiKey: 'ollama',
+    models: {
+      'llama3.2': { name: 'Llama 3.2', size: '3.2B', coding: true, speed: 'very-fast' },
+      'codellama': { name: 'Code Llama', size: '7B', coding: true, speed: 'fast', codingSpecialist: true },
+      'deepseek-coder': { name: 'DeepSeek Coder', size: '7B', coding: true, speed: 'fast', codingSpecialist: true },
+      'llama3.1:8b': { name: 'Llama 3.1 8B', size: '8B', coding: true, speed: 'fast' },
+      'qwen2.5-coder': { name: 'Qwen 2.5 Coder', size: '7B', coding: true, speed: 'fast', codingSpecialist: true },
+      'phi3': { name: 'Phi-3', size: '3.8B', coding: true, speed: 'very-fast' },
+      'mistral': { name: 'Mistral', size: '7B', coding: true, speed: 'fast' },
+    },
+    defaultModel: 'llama3.2',
+    free: true,
+    local: true,
+  },
+  openrouter: {
+    name: 'OpenRouter',
+    baseUrl: 'https://openrouter.ai/api/v1',
+    apiKey: process.env.OPENROUTER_API_KEY || '',
+    models: {
+      'meta-llama/llama-3.3-70b-instruct': { name: 'Llama 3.3 70B', size: '70B', coding: true },
+      'anthropic/claude-3.5-sonnet': { name: 'Claude 3.5 Sonnet', size: 'large', coding: true },
+      'google/gemini-pro-1.5': { name: 'Gemini Pro 1.5', size: 'large', coding: true },
+      'deepseek/deepseek-chat': { name: 'DeepSeek Chat', size: 'large', coding: true },
+    },
+    defaultModel: 'meta-llama/llama-3.3-70b-instruct',
+    free: false,
+  },
+  openai: {
+    name: 'OpenAI',
+    baseUrl: 'https://api.openai.com/v1',
+    apiKey: process.env.OPENAI_API_KEY || '',
+    models: {
+      'gpt-4o': { name: 'GPT-4o', size: 'large', coding: true },
+      'gpt-4o-mini': { name: 'GPT-4o Mini', size: 'medium', coding: true },
+      'gpt-3.5-turbo': { name: 'GPT-3.5 Turbo', size: 'small', coding: true },
+    },
+    defaultModel: 'gpt-4o',
+    free: false,
+  },
+};
+
+// ─── Model Router Class ──────────────────────────────────
+
+class ModelRouter {
+  constructor(options = {}) {
+    this.configDir = options.configDir || path.join(require('os').homedir(), '.hybard');
+    this.configFile = path.join(this.configDir, 'models.json');
+    this.config = this._loadConfig();
+    this.providers = { ...PROVIDERS };
+
+    // Load .env
+    this._loadEnv();
+  }
+
+  _loadEnv() {
+    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;
+        }
+      }
+      // Update provider API keys from env
+      if (process.env.GROQ_API_KEY) this.providers.groq.apiKey = process.env.GROQ_API_KEY;
+      if (process.env.OPENROUTER_API_KEY) this.providers.openrouter.apiKey = process.env.OPENROUTER_API_KEY;
+      if (process.env.OPENAI_API_KEY) this.providers.openai.apiKey = process.env.OPENAI_API_KEY;
+    }
+  }
+
+  _loadConfig() {
+    try {
+      if (fs.existsSync(this.configFile)) {
+        return JSON.parse(fs.readFileSync(this.configFile, 'utf8'));
+      }
+    } catch (e) {}
+    return {
+      defaultProvider: 'groq',
+      defaultModel: 'llama-3.3-70b-versatile',
+      fallbackChain: ['groq', 'ollama'],
+      maxTokens: 2048,
+      temperature: 0.7,
+    };
+  }
+
+  saveConfig(updates = {}) {
+    this.config = { ...this.config, ...updates };
+    if (!fs.existsSync(this.configDir)) fs.mkdirSync(this.configDir, { recursive: true });
+    fs.writeFileSync(this.configFile, JSON.stringify(this.config, null, 2));
+    return this.config;
+  }
+
+  // ─── Provider Info ──────────────────────────────────
+
+  listProviders() {
+    return Object.entries(this.providers).map(([key, prov]) => ({
+      id: key,
+      name: prov.name,
+      free: prov.free || false,
+      local: prov.local || false,
+      hasApiKey: !!(prov.apiKey),
+      modelCount: Object.keys(prov.models).length,
+      isDefault: this.config.defaultProvider === key,
+    }));
+  }
+
+  listModels(provider = null) {
+    const results = [];
+    const providers = provider ? { [provider]: this.providers[provider] } : this.providers;
+
+    for (const [provId, prov] of Object.entries(providers)) {
+      if (!prov) continue;
+      for (const [modelId, model] of Object.entries(prov.models)) {
+        results.push({
+          provider: provId,
+          providerName: prov.name,
+          modelId,
+          ...model,
+          isDefault: this.config.defaultModel === modelId,
+        });
+      }
+    }
+    return results;
+  }
+
+  getCodingModels() {
+    return this.listModels().filter(m => m.coding);
+  }
+
+  getCodingSpecialists() {
+    return this.listModels().filter(m => m.codingSpecialist);
+  }
+
+  // ─── Chat ───────────────────────────────────────────
+
+  async chat(message, options = {}) {
+    const provider = options.provider || this.config.defaultProvider;
+    const model = options.model || this.config.defaultModel;
+    const prov = this.providers[provider];
+
+    if (!prov) throw new Error(`Unknown provider: ${provider}`);
+    if (!prov.apiKey && provider !== 'ollama') {
+      throw new Error(`No API key for ${provider}. Set it in .env or config.`);
+    }
+
+    // Try primary provider
+    try {
+      return await this._callProvider(provider, message, options);
+    } catch (err) {
+      // Fallback chain
+      const fallbacks = this.config.fallbackChain.filter(p => p !== provider);
+      for (const fb of fallbacks) {
+        try {
+          console.log(`[Fallback] ${provider} failed, trying ${fb}...`);
+          return await this._callProvider(fb, message, options);
+        } catch (e2) {
+          continue;
+        }
+      }
+      throw err;
+    }
+  }
+
+  async _callProvider(provider, message, options = {}) {
+    const prov = this.providers[provider];
+    const model = options.model || prov.defaultModel;
+
+    // Use native API for Ollama
+    if (provider === 'ollama') {
+      return this._callOllama(message, model, options);
+    }
+
+    // OpenAI-compatible API for others
+    return this._callOpenAICompatible(prov, model, message, options);
+  }
+
+  async _callOllama(message, model, options = {}) {
+    const body = JSON.stringify({
+      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: 'localhost',
+          port: 11434,
+          path: '/api/generate',
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+          timeout: 300000,
+        },
+        (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));
+              else resolve(json.response || '');
+            } catch (e) {
+              reject(new Error(`Ollama parse error: ${data.slice(0, 200)}`));
+            }
+          });
+        }
+      );
+      req.on('error', reject);
+      req.on('timeout', () => { req.destroy(); reject(new Error('Ollama timeout — model may be loading. Try again in a moment.')); });
+      req.write(body);
+      req.end();
+    });
+  }
+
+  async _callOpenAICompatible(prov, model, message, options = {}) {
+    const messages = [
+      { role: 'system', content: options.system || 'You are a coding assistant.' },
+      { role: 'user', content: message },
+    ];
+
+    const body = JSON.stringify({
+      model,
+      messages,
+      max_tokens: options.maxTokens || this.config.maxTokens,
+      temperature: options.temperature ?? this.config.temperature,
+      stream: false,
+    });
+
+    const baseUrl = new URL(prov.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 ${prov.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)));
+              else resolve(json.choices?.[0]?.message?.content || '');
+            } catch (e) {
+              reject(new Error(`Parse error: ${data.slice(0, 200)}`));
+            }
+          });
+        }
+      );
+      req.on('error', reject);
+      req.on('timeout', () => { req.destroy(); reject(new Error('Request timeout')); });
+      req.write(body);
+      req.end();
+    });
+  }
+
+  // ─── Quick helpers ──────────────────────────────────
+
+  async generateCode(prompt, language = 'python', options = {}) {
+    const system = `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, { ...options, system });
+  }
+
+  async explainCode(code, options = {}) {
+    const system = `You are a code analysis expert. Explain the given code clearly and concisely.
+Cover: what it does, how it works, key patterns, and potential issues.`;
+    return this.chat(`Explain this code:\n\n\`\`\`\n${code}\n\`\`\``, { ...options, system });
+  }
+
+  async fixCode(code, error = '', options = {}) {
+    const system = `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, { ...options, system });
+  }
+
+  async scaffold(goal, options = {}) {
+    const system = `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}`, { ...options, system });
+  }
+}
+
+module.exports = { ModelRouter, PROVIDERS };