hybard-agent 0.1.0

package/lib/analyzer.js

@@ -0,0 +1,330 @@
+/**
+ * Hybard Project Analyzer — Scans and understands project structure.
+ *
+ * Features:
+ *   - Detects project type (Node, Python, React, Flutter, Django, etc.)
+ *   - Reads key files (package.json, requirements.txt, etc.)
+ *   - Analyzes code patterns and conventions
+ *   - Generates context-aware code suggestions
+ *
+ * Usage:
+ *   const analyzer = new ProjectAnalyzer();
+ *   const context = analyzer.analyze('/path/to/project');
+ *   const suggestion = await analyzer.suggest('add user authentication');
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const IGNORE_DIRS = [
+  'node_modules', '.git', '__pycache__', '.venv', 'venv', 'env',
+  '.idea', '.vscode', 'dist', 'build', '.next', '.nuxt',
+  'coverage', '.mypy_cache', '.pytest_cache', 'dart_tool',
+  '.gradle', 'android/.gradle', 'Pods', '.pub-cache',
+  '.dart_tool', '.packages', 'ios/Pods',
+  '.fvm', 'flutter-plugins', 'flutter-plugins-dependencies',
+];
+
+const IGNORE_FILES = [
+  '.gitignore', '.env', '.env.local', 'package-lock.json',
+  'yarn.lock', 'pnpm-lock.yaml', '*.pyc', '*.pyo',
+  'hybard_model.pth', 'dataset.txt', 'db.sqlite3',
+  '*.lock', '*.lockfile', 'pubspec.lock',
+  'build.gradle', 'settings.gradle', 'gradle.properties',
+  'Podfile.lock', '*.g.dart', '*.freezed.dart',
+];
+
+// Source file extensions to prioritize
+const SOURCE_EXTENSIONS = [
+  '.dart', '.py', '.js', '.ts', '.jsx', '.tsx',
+  '.html', '.css', '.scss', '.json', '.yaml', '.yml',
+  '.go', '.rs', '.java', '.kt', '.swift',
+  '.sql', '.sh', '.md',
+];
+
+const CONFIG_FILES = [
+  'pubspec.yaml', 'package.json', 'requirements.txt', 'pyproject.toml',
+  'setup.py', 'Pipfile', 'Cargo.toml', 'go.mod', 'pom.xml',
+  'build.gradle', 'settings.gradle', 'Makefile', 'Dockerfile',
+  'docker-compose.yml', 'docker-compose.yaml',
+  'tsconfig.json', 'vite.config.js', 'vite.config.ts',
+  'next.config.js', 'next.config.ts', 'nuxt.config.js',
+  'tailwind.config.js', 'postcss.config.js',
+  'app.json', 'app.config.js', 'eas.json',
+  'README.md',
+];
+
+const PROJECT_MARKERS = {
+  node: ['package.json'],
+  python: ['requirements.txt', 'pyproject.toml', 'setup.py', 'Pipfile'],
+  django: ['manage.py'],
+  react: ['next.config.js', 'vite.config.js', 'vite.config.ts'],
+  flutter: ['pubspec.yaml'],
+  rust: ['Cargo.toml'],
+  go: ['go.mod'],
+  java: ['pom.xml', 'build.gradle'],
+};
+
+class ProjectAnalyzer {
+  constructor(rootDir = process.cwd()) {
+    this.rootDir = rootDir;
+    this.projectType = null;
+    this.files = [];
+    this.keyFiles = {};
+    this.structure = {};
+  }
+
+  /**
+   * Full project analysis — scans files, detects type, reads key configs.
+   */
+  analyze() {
+    this.files = this._scanFiles(this.rootDir);
+    this.projectType = this._detectProjectType();
+    this.keyFiles = this._readKeyFiles();
+    this.structure = this._buildStructure();
+
+    return {
+      rootDir: this.rootDir,
+      projectType: this.projectType,
+      fileCount: this.files.length,
+      structure: this.structure,
+      keyFiles: this.keyFiles,
+      languages: this._detectLanguages(),
+      frameworks: this._detectFrameworks(),
+      summary: this._generateSummary(),
+    };
+  }
+
+  /**
+   * Get context string for AI — includes project structure and key file contents.
+   */
+  getContextForAI(maxTokens = 1000) {
+    const analysis = this.analyze();
+    let context = `Project: ${path.basename(this.rootDir)}\n`;
+    context += `Type: ${analysis.projectType}\n`;
+    context += `Files: ${analysis.fileCount}\n`;
+    context += `Languages: ${analysis.languages.join(', ')}\n\n`;
+
+    // Only include first 3 source files
+    const files = Object.entries(analysis.keyFiles).slice(0, 3);
+    for (const [name, content] of files) {
+      const truncated = content.slice(0, 200);
+      context += `--- ${name} ---\n${truncated}\n\n`;
+    }
+
+    return context;
+  }
+
+  /**
+   * Generate a code suggestion that fits the existing project.
+   */
+  async suggest(feature, modelRouter = null) {
+    const context = this.getContextForAI();
+    const prompt = `Based on this project context, ${feature}.
+
+Project Context:
+${context}
+
+Generate code that:
+1. Follows the existing code style and patterns
+2. Uses the same frameworks and libraries
+3. Fits naturally into the project structure
+4. Includes proper imports and dependencies`;
+
+    if (modelRouter) {
+      return modelRouter.chat(prompt, {
+        system: 'You are a coding assistant that generates code fitting the user\'s existing project. Analyze the project context carefully and produce code that matches the style, patterns, and frameworks used.',
+      });
+    }
+
+    return prompt; // Return the prompt if no model router
+  }
+
+  // ─── Internal Methods ───────────────────────────────
+
+  _scanFiles(dir, root = dir, depth = 0) {
+    const files = [];
+    if (depth > 10) return files; // prevent infinite recursion
+
+    try {
+      for (const name of fs.readdirSync(dir)) {
+        if (IGNORE_DIRS.includes(name) || name.startsWith('.')) continue;
+
+        const fullPath = path.join(dir, name);
+        const stat = fs.statSync(fullPath);
+
+        if (stat.isDirectory()) {
+          files.push(...this._scanFiles(fullPath, root, depth + 1));
+        } else {
+          const relative = path.relative(root, fullPath);
+          if (!IGNORE_FILES.some(pattern => {
+            if (pattern.startsWith('*')) return relative.endsWith(pattern.slice(1));
+            return relative === pattern;
+          })) {
+            files.push(relative);
+          }
+        }
+      }
+    } catch (e) {}
+    return files.sort();
+  }
+
+  _detectProjectType() {
+    for (const [type, markers] of Object.entries(PROJECT_MARKERS)) {
+      for (const marker of markers) {
+        if (this.files.some(f => f === marker || f.endsWith('/' + marker))) {
+          return type;
+        }
+      }
+    }
+    return 'unknown';
+  }
+
+  _readKeyFiles() {
+    const keyFiles = {};
+
+    // Read config files
+    for (const file of CONFIG_FILES) {
+      const filePath = path.join(this.rootDir, file);
+      if (fs.existsSync(filePath)) {
+        try {
+          keyFiles[file] = fs.readFileSync(filePath, 'utf8').slice(0, 1500);
+        } catch (e) {}
+      }
+    }
+
+    // Read source files (prioritize .dart, .py, .js, .ts, .tsx)
+    const sourceFiles = this.files
+      .filter(f => SOURCE_EXTENSIONS.some(ext => f.endsWith(ext)))
+      .sort((a, b) => {
+        // Prioritize main entry files
+        const aMain = a.includes('main.dart') || a.includes('main.py') || a.includes('index.js') || a.includes('App.');
+        const bMain = b.includes('main.dart') || b.includes('main.py') || b.includes('index.js') || b.includes('App.');
+        if (aMain && !bMain) return -1;
+        if (!aMain && bMain) return 1;
+        return 0;
+      })
+      .slice(0, 20); // Read up to 20 source files
+
+    for (const file of sourceFiles) {
+      const filePath = path.join(this.rootDir, file);
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        keyFiles[file] = content.slice(0, 2000); // Up to 2000 chars per file
+      } catch (e) {}
+    }
+
+    return keyFiles;
+  }
+
+  _buildStructure() {
+    const tree = this._buildTree(this.files);
+    return { tree, flat: this.files };
+  }
+
+  _buildTree(files) {
+    const lines = [];
+    const dirs = new Set();
+
+    for (const file of files) {
+      const parts = file.split(path.sep);
+      // Show directory structure
+      for (let i = 1; i < parts.length; i++) {
+        const dir = parts.slice(0, i).join('/');
+        if (!dirs.has(dir)) {
+          dirs.add(dir);
+          const indent = '  '.repeat(i - 1);
+          lines.push(`${indent}${parts[i - 1]}/`);
+        }
+      }
+      // Show file
+      const indent = '  '.repeat(Math.max(0, parts.length - 1));
+      lines.push(`${indent}${parts[parts.length - 1]}`);
+    }
+
+    return lines.slice(0, 100).join('\n');
+  }
+
+  _detectLanguages() {
+    const langMap = {
+      '.js': 'JavaScript', '.jsx': 'React JSX', '.ts': 'TypeScript', '.tsx': 'React TSX',
+      '.py': 'Python', '.dart': 'Dart', '.rs': 'Rust', '.go': 'Go',
+      '.java': 'Java', '.kt': 'Kotlin', '.swift': 'Swift',
+      '.html': 'HTML', '.css': 'CSS', '.scss': 'SCSS',
+      '.json': 'JSON', '.yaml': 'YAML', '.yml': 'YAML',
+      '.sql': 'SQL', '.sh': 'Shell', '.bash': 'Shell',
+    };
+
+    const counts = {};
+    for (const file of this.files) {
+      const ext = path.extname(file).toLowerCase();
+      if (langMap[ext]) {
+        counts[langMap[ext]] = (counts[langMap[ext]] || 0) + 1;
+      }
+    }
+
+    return Object.entries(counts)
+      .sort((a, b) => b[1] - a[1])
+      .map(([lang]) => lang);
+  }
+
+  _detectFrameworks() {
+    const frameworks = [];
+
+    // Check package.json — read full file for JSON parsing
+    const pkgPath = path.join(this.rootDir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps.react) frameworks.push('React');
+        if (deps.vue) frameworks.push('Vue');
+        if (deps.angular || deps['@angular/core']) frameworks.push('Angular');
+        if (deps.svelte) frameworks.push('Svelte');
+        if (deps.next) frameworks.push('Next.js');
+        if (deps.nuxt) frameworks.push('Nuxt');
+        if (deps.express) frameworks.push('Express');
+        if (deps.fastify) frameworks.push('Fastify');
+        if (deps.tailwindcss) frameworks.push('Tailwind CSS');
+        if (deps.typescript) frameworks.push('TypeScript');
+      } catch (e) {}
+    }
+
+    // Check requirements.txt
+    if (this.keyFiles['requirements.txt']) {
+      const req = this.keyFiles['requirements.txt'];
+      if (req.includes('Django')) frameworks.push('Django');
+      if (req.includes('flask') || req.includes('Flask')) frameworks.push('Flask');
+      if (req.includes('fastapi') || req.includes('FastAPI')) frameworks.push('FastAPI');
+      if (req.includes('torch')) frameworks.push('PyTorch');
+      if (req.includes('tensorflow')) frameworks.push('TensorFlow');
+    }
+
+    // Check pubspec.yaml
+    if (this.keyFiles['pubspec.yaml']) {
+      frameworks.push('Flutter');
+    }
+
+    // Check manage.py
+    if (this.files.includes('manage.py')) {
+      if (!frameworks.includes('Django')) frameworks.push('Django');
+    }
+
+    return frameworks;
+  }
+
+  _generateSummary() {
+    const langs = this._detectLanguages();
+    const frameworks = this._detectFrameworks();
+    const type = this.projectType;
+
+    let summary = `${type.charAt(0).toUpperCase() + type.slice(1)} project`;
+    if (langs.length > 0) summary += ` using ${langs.slice(0, 3).join(', ')}`;
+    if (frameworks.length > 0) summary += ` with ${frameworks.join(', ')}`;
+    summary += ` (${this.files.length} files)`;
+
+    return summary;
+  }
+}
+
+module.exports = { ProjectAnalyzer };

package/lib/coding-agent.js

@@ -0,0 +1,87 @@
+/**
+ * Hybard Coding Agent — Simple, fast AI coding assistant.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { HybardAI } = require('./online');
+
+class CodingAgent {
+  constructor(options = {}) {
+    this.ai = new HybardAI(options);
+    this.configDir = options.configDir || path.join(require('os').homedir(), '.hybard');
+    this.configFile = path.join(this.configDir, 'agent.json');
+    this.config = this._loadConfig();
+  }
+
+  _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',
+    };
+  }
+
+  init() {
+    return { projectType: 'unknown', summary: 'Project loaded' };
+  }
+
+  async chat(message, options = {}) {
+    const provider = options.provider || this.config.defaultProvider;
+    const model = options.model || this.config.defaultModel;
+    const system = 'You are Hybard AI, an expert coding assistant. Generate complete, working code.';
+    return this.ai.chat(message, { system, provider, model, ...options });
+  }
+
+  extractCodeBlocks(response) {
+    const blocks = [];
+    const regex = /```(\w*)\n([\s\S]*?)```/g;
+    let match;
+    while ((match = regex.exec(response)) !== null) {
+      const ext = { python: 'py', javascript: 'js', typescript: 'ts', html: 'html', css: 'css' };
+      blocks.push({ filename: `code.${ext[match[1]] || 'txt'}`, code: match[2].trim() });
+    }
+    return blocks;
+  }
+
+  writeCodeBlocks(blocks, targetDir = null) {
+    const dir = targetDir || process.cwd();
+    const written = [];
+    for (const block of blocks) {
+      const filePath = path.join(dir, block.filename);
+      const fileDir = path.dirname(filePath);
+      if (!fs.existsSync(fileDir)) fs.mkdirSync(fileDir, { recursive: true });
+      fs.writeFileSync(filePath, block.code, 'utf8');
+      written.push(filePath);
+    }
+    return written;
+  }
+
+  getModels() {
+    const { ModelRouter } = require('./models');
+    return new ModelRouter().listModels();
+  }
+
+  setModel(provider, model) {
+    this.config.defaultProvider = provider;
+    this.config.defaultModel = model;
+    if (!fs.existsSync(this.configDir)) fs.mkdirSync(this.configDir, { recursive: true });
+    fs.writeFileSync(this.configFile, JSON.stringify(this.config, null, 2));
+  }
+
+  clearHistory() {}
+
+  getModelInfo() {
+    return {
+      provider: this.config.defaultProvider,
+      model: this.config.defaultModel,
+      projectSummary: 'Project loaded',
+    };
+  }
+}
+
+module.exports = { CodingAgent };