hybard-agent 0.1.0

package/lib/hybard-agent.js

@@ -0,0 +1,1063 @@
+/**
+ * Hybard AI Agent — Complete working agent with real LLM integration.
+ * 
+ * Features:
+ *   - Real LLM Provider Connection (Groq → Ollama → OpenRouter → OpenAI)
+ *   - Codebase Understanding (search, find, understand code)
+ *   - Project Detection System (scan, detect framework/language/deps)
+ *   - Agent Loop (Think → Act → Observe → Evaluate → Fix)
+ *   - Tool Calling (file ops, terminal, code search)
+ *   - Knowledge Base awareness (35 domains)
+ *   - Memory system (short-term, long-term)
+ *   - Bengali + English multilingual support
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { HybardAI } = require('./online');
+const { ProjectAnalyzer } = require('./analyzer');
+
+// ─── Knowledge Base Loader ──────────────────────────────
+
+class KnowledgeBase {
+  constructor() {
+    this.kbPath = path.join(__dirname, '..', 'knowledge', 'KNOWLEDGE_BASE.md');
+    this.capabilitiesPath = path.join(__dirname, '..', 'knowledge', 'CAPABILITIES.md');
+    this.content = '';
+    this.capabilities = '';
+    this.load();
+  }
+
+  load() {
+    try {
+      if (fs.existsSync(this.kbPath)) {
+        this.content = fs.readFileSync(this.kbPath, 'utf8');
+      }
+      if (fs.existsSync(this.capabilitiesPath)) {
+        this.capabilities = fs.readFileSync(this.capabilitiesPath, 'utf8');
+      }
+    } catch (e) {
+      console.error('Failed to load knowledge base:', e.message);
+    }
+  }
+
+  getDomainKnowledge(domain) {
+    const regex = new RegExp(`## ${domain}[\\s\\S]*?(?=\\n## \\d|$)`, 'i');
+    const match = this.content.match(regex);
+    return match ? match[0] : null;
+  }
+
+  getCapabilitiesSummary() {
+    return this.capabilities.slice(0, 3000);
+  }
+}
+
+// ─── Memory System ──────────────────────────────────────
+
+class Memory {
+  constructor() {
+    this.shortTerm = [];
+    this.longTerm = [];
+    this.projectMemory = [];
+    this.memoryDir = path.join(require('os').homedir(), '.hybard', 'memory');
+    this.loadLongTerm();
+  }
+
+  loadLongTerm() {
+    try {
+      const memoryFile = path.join(this.memoryDir, 'long-term.json');
+      if (fs.existsSync(memoryFile)) {
+        this.longTerm = JSON.parse(fs.readFileSync(memoryFile, 'utf8'));
+      }
+    } catch (e) {}
+  }
+
+  saveLongTerm() {
+    try {
+      if (!fs.existsSync(this.memoryDir)) {
+        fs.mkdirSync(this.memoryDir, { recursive: true });
+      }
+      fs.writeFileSync(
+        path.join(this.memoryDir, 'long-term.json'),
+        JSON.stringify(this.longTerm, null, 2)
+      );
+    } catch (e) {}
+  }
+
+  addShortTerm(role, content) {
+    this.shortTerm.push({ role, content, timestamp: Date.now() });
+    if (this.shortTerm.length > 20) {
+      this.shortTerm = this.shortTerm.slice(-20);
+    }
+  }
+
+  addLongTerm(content, type = 'fact') {
+    this.longTerm.push({ content, type, timestamp: Date.now() });
+    this.saveLongTerm();
+  }
+
+  addProjectMemory(content) {
+    this.projectMemory.push({ content, timestamp: Date.now() });
+  }
+
+  getConversationContext() {
+    return this.shortTerm.map(m => `${m.role}: ${m.content}`).join('\n');
+  }
+
+  searchLongTerm(query) {
+    const lower = query.toLowerCase();
+    return this.longTerm.filter(m => m.content.toLowerCase().includes(lower));
+  }
+}
+
+// ─── Project Detection System ───────────────────────────
+
+class ProjectDetector {
+  constructor(rootDir = process.cwd()) {
+    this.rootDir = rootDir;
+    this.result = {
+      type: 'unknown',
+      languages: [],
+      frameworks: [],
+      dependencies: {},
+      configFiles: [],
+      entryPoints: [],
+      structure: {},
+    };
+  }
+
+  detect() {
+    this.scanConfigFiles();
+    this.detectLanguage();
+    this.detectFramework();
+    this.detectDependencies();
+    this.detectEntryPoints();
+    this.buildStructure();
+    return this.result;
+  }
+
+  scanConfigFiles() {
+    const configFiles = [
+      'package.json', 'tsconfig.json', 'vite.config.js', 'vite.config.ts',
+      'next.config.js', 'next.config.ts', 'nuxt.config.js',
+      'requirements.txt', 'pyproject.toml', 'setup.py', 'Pipfile',
+      'pubspec.yaml', 'Cargo.toml', 'go.mod', 'pom.xml', 'build.gradle',
+      'Makefile', 'Dockerfile', 'docker-compose.yml', 'docker-compose.yaml',
+      '.eslintrc.js', '.prettierrc', 'tailwind.config.js', 'postcss.config.js',
+      'manage.py', 'app.json', 'eas.json',
+    ];
+
+    for (const file of configFiles) {
+      const filePath = path.join(this.rootDir, file);
+      if (fs.existsSync(filePath)) {
+        this.result.configFiles.push(file);
+      }
+    }
+  }
+
+  detectLanguage() {
+    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',
+      '.sql': 'SQL', '.sh': 'Shell',
+    };
+
+    const counts = {};
+    const walk = (dir, depth = 0) => {
+      if (depth > 5) return;
+      try {
+        const items = fs.readdirSync(dir, { withFileTypes: true });
+        for (const item of items) {
+          if (item.isDirectory() && !item.name.startsWith('.') && 
+              item.name !== 'node_modules' && item.name !== '__pycache__') {
+            walk(path.join(dir, item.name), depth + 1);
+          } else if (item.isFile()) {
+            const ext = path.extname(item.name).toLowerCase();
+            if (langMap[ext]) {
+              counts[langMap[ext]] = (counts[langMap[ext]] || 0) + 1;
+            }
+          }
+        }
+      } catch (e) {}
+    };
+
+    walk(this.rootDir);
+    this.result.languages = Object.entries(counts)
+      .sort((a, b) => b[1] - a[1])
+      .map(([lang]) => lang);
+  }
+
+  detectFramework() {
+    const frameworks = [];
+
+    // Check package.json
+    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');
+        if (deps.fastapi || deps['fastapi']) frameworks.push('FastAPI');
+        if (deps.flutter || deps.flutter_test) frameworks.push('Flutter');
+      } catch (e) {}
+    }
+
+    // Check requirements.txt
+    const reqPath = path.join(this.rootDir, 'requirements.txt');
+    if (fs.existsSync(reqPath)) {
+      const req = fs.readFileSync(reqPath, 'utf8');
+      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 (fs.existsSync(path.join(this.rootDir, 'pubspec.yaml'))) {
+      frameworks.push('Flutter');
+    }
+
+    // Check manage.py
+    if (fs.existsSync(path.join(this.rootDir, 'manage.py'))) {
+      frameworks.push('Django');
+    }
+
+    this.result.frameworks = frameworks;
+  }
+
+  detectDependencies() {
+    const deps = {};
+
+    // Node.js dependencies
+    const pkgPath = path.join(this.rootDir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        deps.npm = {
+          dependencies: Object.keys(pkg.dependencies || {}),
+          devDependencies: Object.keys(pkg.devDependencies || {}),
+        };
+      } catch (e) {}
+    }
+
+    // Python dependencies
+    const reqPath = path.join(this.rootDir, 'requirements.txt');
+    if (fs.existsSync(reqPath)) {
+      const req = fs.readFileSync(reqPath, 'utf8');
+      deps.pip = req.split('\n').filter(l => l.trim() && !l.startsWith('#'));
+    }
+
+    this.result.dependencies = deps;
+  }
+
+  detectEntryPoints() {
+    const entryPoints = [];
+
+    // Common entry points
+    const commonEntries = [
+      'src/index.js', 'src/index.ts', 'src/main.js', 'src/main.ts',
+      'src/App.jsx', 'src/App.tsx', 'src/main.jsx', 'src/main.tsx',
+      'index.js', 'index.ts', 'main.js', 'main.ts',
+      'app.py', 'main.py', 'manage.py',
+      'lib/main.dart', 'lib/main.dart',
+      'server.js', 'server.ts',
+      'src/server.js', 'src/server.ts',
+    ];
+
+    for (const entry of commonEntries) {
+      if (fs.existsSync(path.join(this.rootDir, entry))) {
+        entryPoints.push(entry);
+      }
+    }
+
+    this.result.entryPoints = entryPoints;
+  }
+
+  buildStructure() {
+    const structure = { dirs: [], files: [] };
+    const walk = (dir, prefix = '', depth = 0) => {
+      if (depth > 3) return;
+      try {
+        const items = fs.readdirSync(dir, { withFileTypes: true }).slice(0, 50);
+        for (const item of items) {
+          if (item.isDirectory() && !item.name.startsWith('.') && 
+              item.name !== 'node_modules' && item.name !== '__pycache__') {
+            structure.dirs.push(`${prefix}${item.name}/`);
+            walk(path.join(dir, item.name), `${prefix}  `, depth + 1);
+          } else if (item.isFile()) {
+            structure.files.push(`${prefix}${item.name}`);
+          }
+        }
+      } catch (e) {}
+    };
+
+    walk(this.rootDir);
+    this.result.structure = structure;
+  }
+
+  getSummary() {
+    const r = this.result;
+    let summary = `Project Type: ${r.type}\n`;
+    summary += `Languages: ${r.languages.join(', ') || 'Unknown'}\n`;
+    summary += `Frameworks: ${r.frameworks.join(', ') || 'None detected'}\n`;
+    summary += `Config Files: ${r.configFiles.length}\n`;
+    summary += `Entry Points: ${r.entryPoints.join(', ') || 'None found'}\n`;
+    return summary;
+  }
+}
+
+// ─── Codebase Search Engine ─────────────────────────────
+
+class CodebaseSearch {
+  constructor(rootDir = process.cwd()) {
+    this.rootDir = rootDir;
+    this.ignoreDirs = ['node_modules', '.git', '__pycache__', '.venv', 'venv', 
+                        '.idea', '.vscode', 'dist', 'build', '.next', 'coverage'];
+    this.ignoreFiles = ['.gitignore', '.env', 'package-lock.json', 'yarn.lock', 
+                         '*.pyc', '*.pyo', 'db.sqlite3'];
+  }
+
+  searchCode(query) {
+    const results = [];
+    const walk = (dir, depth = 0) => {
+      if (depth > 8) return;
+      try {
+        const items = fs.readdirSync(dir, { withFileTypes: true });
+        for (const item of items) {
+          if (item.isDirectory() && !this.ignoreDirs.includes(item.name)) {
+            walk(path.join(dir, item.name), depth + 1);
+          } else if (item.isFile() && !this.shouldIgnore(item.name)) {
+            this.searchInFile(path.join(dir, item.name), query, results);
+          }
+        }
+      } catch (e) {}
+    };
+
+    walk(this.rootDir);
+    return results;
+  }
+
+  searchInFile(filePath, query, results) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const lines = content.split('\n');
+      const matches = [];
+
+      lines.forEach((line, index) => {
+        if (line.toLowerCase().includes(query.toLowerCase())) {
+          matches.push({
+            line: index + 1,
+            content: line.trim(),
+          });
+        }
+      });
+
+      if (matches.length > 0) {
+        results.push({
+          file: path.relative(this.rootDir, filePath),
+          matches,
+          score: matches.length,
+        });
+      }
+    } catch (e) {}
+  }
+
+  findFiles(pattern) {
+    const results = [];
+    const walk = (dir, depth = 0) => {
+      if (depth > 8) return;
+      try {
+        const items = fs.readdirSync(dir, { withFileTypes: true });
+        for (const item of items) {
+          if (item.isDirectory() && !this.ignoreDirs.includes(item.name)) {
+            walk(path.join(dir, item.name), depth + 1);
+          } else if (item.isFile() && item.name.includes(pattern)) {
+            results.push(path.relative(this.rootDir, path.join(dir, item.name)));
+          }
+        }
+      } catch (e) {}
+    };
+
+    walk(this.rootDir);
+    return results;
+  }
+
+  findFunctions(query) {
+    const results = [];
+    const functionPatterns = [
+      /function\s+(\w+)/g,
+      /const\s+(\w+)\s*=\s*(?:async\s+)?\(/g,
+      /def\s+(\w+)/g,
+      /class\s+(\w+)/g,
+      /export\s+(?:default\s+)?(?:function|const|class)\s+(\w+)/g,
+    ];
+
+    const walk = (dir, depth = 0) => {
+      if (depth > 8) return;
+      try {
+        const items = fs.readdirSync(dir, { withFileTypes: true });
+        for (const item of items) {
+          if (item.isDirectory() && !this.ignoreDirs.includes(item.name)) {
+            walk(path.join(dir, item.name), depth + 1);
+          } else if (item.isFile() && !this.shouldIgnore(item.name)) {
+            this.findInFile(path.join(dir, item.name), query, functionPatterns, results);
+          }
+        }
+      } catch (e) {}
+    };
+
+    walk(this.rootDir);
+    return results;
+  }
+
+  findInFile(filePath, query, patterns, results) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const lines = content.split('\n');
+
+      lines.forEach((line, index) => {
+        if (line.toLowerCase().includes(query.toLowerCase())) {
+          for (const pattern of patterns) {
+            const match = line.match(pattern);
+            if (match) {
+              results.push({
+                file: path.relative(this.rootDir, filePath),
+                line: index + 1,
+                name: match[1] || match[0],
+                content: line.trim(),
+              });
+            }
+          }
+        }
+      });
+    } catch (e) {}
+  }
+
+  shouldIgnore(filename) {
+    return this.ignoreFiles.some(pattern => {
+      if (pattern.startsWith('*')) return filename.endsWith(pattern.slice(1));
+      return filename === pattern;
+    });
+  }
+
+  getContextForQuery(query) {
+    const codeResults = this.searchCode(query);
+    const fileResults = this.findFiles(query);
+    const funcResults = this.findFunctions(query);
+
+    let context = `Search Results for "${query}":\n\n`;
+
+    if (codeResults.length > 0) {
+      context += `Code Matches (${codeResults.length} files):\n`;
+      for (const result of codeResults.slice(0, 5)) {
+        context += `  ${result.file}:\n`;
+        for (const match of result.matches.slice(0, 3)) {
+          context += `    Line ${match.line}: ${match.content}\n`;
+        }
+      }
+    }
+
+    if (fileResults.length > 0) {
+      context += `\nFiles Found (${fileResults.length}):\n`;
+      for (const file of fileResults.slice(0, 10)) {
+        context += `  ${file}\n`;
+      }
+    }
+
+    if (funcResults.length > 0) {
+      context += `\nFunctions Found (${funcResults.length}):\n`;
+      for (const func of funcResults.slice(0, 10)) {
+        context += `  ${func.name} in ${func.file}:${func.line}\n`;
+      }
+    }
+
+    return context;
+  }
+}
+
+// ─── Tool System ────────────────────────────────────────
+
+class ToolSystem {
+  constructor(rootDir = process.cwd()) {
+    this.rootDir = rootDir;
+    this.projectDetector = new ProjectDetector(rootDir);
+    this.codebaseSearch = new CodebaseSearch(rootDir);
+    this.projectInfo = null;
+
+    this.tools = {
+      read_file: this.readFile.bind(this),
+      write_file: this.writeFile.bind(this),
+      edit_file: this.editFile.bind(this),
+      delete_file: this.deleteFile.bind(this),
+      create_file: this.createFile.bind(this),
+      list_directory: this.listDirectory.bind(this),
+      search_files: this.searchFiles.bind(this),
+      search_text: this.searchText.bind(this),
+      search_code: this.searchCode.bind(this),
+      find_functions: this.findFunctions.bind(this),
+      run_command: this.runCommand.bind(this),
+      get_project_info: this.getProjectInfo.bind(this),
+      detect_project: this.detectProject.bind(this),
+    };
+  }
+
+  readFile(filePath) {
+    try {
+      const absPath = path.resolve(this.rootDir, filePath);
+      if (!fs.existsSync(absPath)) {
+        return { success: false, error: `File not found: ${filePath}` };
+      }
+      const content = fs.readFileSync(absPath, 'utf8');
+      return { success: true, content, path: absPath };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+
+  writeFile(filePath, content) {
+    try {
+      const absPath = path.resolve(this.rootDir, filePath);
+      const dir = path.dirname(absPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(absPath, content, 'utf8');
+      return { success: true, path: absPath };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+
+  createFile(filePath, content) {
+    const absPath = path.resolve(this.rootDir, filePath);
+    if (fs.existsSync(absPath)) {
+      return { success: false, error: `File already exists: ${filePath}` };
+    }
+    return this.writeFile(filePath, content);
+  }
+
+  editFile(filePath, oldContent, newContent) {
+    try {
+      const absPath = path.resolve(this.rootDir, filePath);
+      if (!fs.existsSync(absPath)) {
+        return { success: false, error: `File not found: ${filePath}` };
+      }
+      let content = fs.readFileSync(absPath, 'utf8');
+      if (!content.includes(oldContent)) {
+        return { success: false, error: 'Old content not found in file' };
+      }
+      content = content.replace(oldContent, newContent);
+      fs.writeFileSync(absPath, content, 'utf8');
+      return { success: true, path: absPath };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+
+  deleteFile(filePath) {
+    try {
+      const absPath = path.resolve(this.rootDir, filePath);
+      if (!fs.existsSync(absPath)) {
+        return { success: false, error: `File not found: ${filePath}` };
+      }
+      fs.unlinkSync(absPath);
+      return { success: true, path: absPath };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+
+  listDirectory(dirPath = '.') {
+    try {
+      const absPath = path.resolve(this.rootDir, dirPath);
+      const items = fs.readdirSync(absPath, { withFileTypes: true });
+      const result = items.map(item => ({
+        name: item.name,
+        type: item.isDirectory() ? 'directory' : 'file',
+        path: path.join(absPath, item.name),
+      }));
+      return { success: true, items: result, path: absPath };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+
+  searchFiles(pattern) {
+    try {
+      const results = this.codebaseSearch.findFiles(pattern);
+      return { success: true, results, count: results.length };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+
+  searchText(searchText, filePath) {
+    try {
+      const absPath = path.resolve(this.rootDir, filePath);
+      if (!fs.existsSync(absPath)) {
+        return { success: false, error: `File not found: ${filePath}` };
+      }
+      const content = fs.readFileSync(absPath, 'utf8');
+      const lines = content.split('\n');
+      const matches = [];
+
+      lines.forEach((line, index) => {
+        if (line.toLowerCase().includes(searchText.toLowerCase())) {
+          matches.push({ line: index + 1, content: line.trim() });
+        }
+      });
+
+      return { success: true, matches, count: matches.length };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+
+  searchCode(query) {
+    try {
+      const results = this.codebaseSearch.searchCode(query);
+      return { success: true, results, count: results.length };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+
+  findFunctions(query) {
+    try {
+      const results = this.codebaseSearch.findFunctions(query);
+      return { success: true, results, count: results.length };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+
+  runCommand(command, options = {}) {
+    try {
+      const result = spawnSync(command, {
+        shell: true,
+        encoding: 'utf8',
+        cwd: options.cwd || this.rootDir,
+        timeout: options.timeout || 30000,
+      });
+
+      return {
+        success: result.status === 0,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.status,
+      };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+
+  getProjectInfo() {
+    if (!this.projectInfo) {
+      this.projectInfo = this.projectDetector.detect();
+    }
+    return this.projectInfo;
+  }
+
+  detectProject() {
+    this.projectInfo = this.projectDetector.detect();
+    return this.projectInfo;
+  }
+}
+
+// ─── Main Agent ─────────────────────────────────────────
+
+class HybardAgent {
+  constructor(options = {}) {
+    this.ai = new HybardAI(options);
+    this.knowledge = new KnowledgeBase();
+    this.memory = new Memory();
+    this.tools = new ToolSystem(options.rootDir || process.cwd());
+    this.maxIterations = 10;
+    this.conversationHistory = [];
+
+    this.systemPrompt = this.buildSystemPrompt();
+  }
+
+  buildSystemPrompt() {
+    return `You are Hybard AI Agent — a full-stack AI coding assistant with real LLM integration.
+
+IDENTITY:
+- You are an expert coding agent with knowledge across 35 domains
+- You can write, read, edit, and delete files
+- You can execute terminal commands
+- You can search and understand codebases
+- You can build complete applications
+- You support Bengali (বাংলা) and English
+
+AGENT LOOP:
+When given a task, follow this loop:
+1. THINK — Understand the request, plan your approach
+2. ACT — Execute tools (read files, write code, run commands)
+3. OBSERVE — Check results, read errors
+4. EVALUATE — Did it work? If yes, done. If no, fix.
+5. FIX — Generate a fix and retry
+
+TOOL CALLING:
+You can use these tools by outputting JSON in your response:
+{"tool": "read_file", "path": "file.js"}
+{"tool": "write_file", "path": "file.js", "content": "..."}
+{"tool": "edit_file", "path": "file.js", "old": "...", "new": "..."}
+{"tool": "run_command", "command": "npm install"}
+{"tool": "list_directory", "path": "."}
+{"tool": "search_files", "pattern": ".js"}
+{"tool": "search_text", "text": "function", "file": "index.js"}
+{"tool": "search_code", "query": "login"}
+{"tool": "find_functions", "query": "authenticate"}
+{"tool": "get_project_info"}
+{"tool": "detect_project"}
+
+CODEBASE UNDERSTANDING:
+When asked about code, use these tools:
+- search_code: Find code by keyword
+- find_functions: Find function definitions
+- read_file: Read specific files
+- get_project_info: Understand project structure
+
+PROJECT DETECTION:
+Your agent automatically detects:
+- Project type (Node, Python, React, Flutter, etc.)
+- Languages used
+- Frameworks and libraries
+- Dependencies
+- Entry points
+- File structure
+
+RESPONSE FORMAT:
+- Always respond in the user's language
+- Keep code comments in English
+- Use markdown code blocks for code
+- Be concise but thorough
+- Always verify your work
+
+IMPORTANT:
+- Never hardcode secrets or API keys
+- Always handle errors gracefully
+- Write clean, readable code
+- Test your code when possible`;
+  }
+
+  async chat(message) {
+    // Add to memory
+    this.memory.addShortTerm('user', message);
+    this.conversationHistory.push({ role: 'user', content: message });
+
+    // Build context
+    const context = this.buildContext(message);
+
+    // Call AI with real LLM
+    let response;
+    try {
+      response = await this.ai.chat(message, {
+        system: this.systemPrompt + '\n\n' + context,
+      });
+    } catch (err) {
+      console.error(`[LLM Error] ${err.message}`);
+      response = `[Error] Failed to get response from AI: ${err.message}`;
+    }
+
+    // Process response and execute tools
+    const result = await this.processResponse(response);
+
+    // Add to memory
+    this.memory.addShortTerm('assistant', result);
+    this.conversationHistory.push({ role: 'assistant', content: result });
+
+    return result;
+  }
+
+  buildContext(message) {
+    let context = '';
+
+    // Add project info
+    try {
+      const projectInfo = this.tools.getProjectInfo();
+      context += `\n\nPROJECT CONTEXT:\n`;
+      context += `Type: ${projectInfo.type}\n`;
+      context += `Languages: ${projectInfo.languages.join(', ')}\n`;
+      context += `Frameworks: ${projectInfo.frameworks.join(', ')}\n`;
+      context += `Entry Points: ${projectInfo.entryPoints.join(', ')}\n`;
+      context += `Config Files: ${projectInfo.configFiles.join(', ')}`;
+    } catch (e) {}
+
+    // Add codebase search if query looks like code-related
+    if (this.isCodeRelated(message)) {
+      try {
+        const searchContext = this.tools.codebaseSearch.getContextForQuery(message);
+        if (searchContext.length > 50) {
+          context += `\n\nCODEBASE SEARCH:\n${searchContext}`;
+        }
+      } catch (e) {}
+    }
+
+    // Add conversation history
+    if (this.conversationHistory.length > 0) {
+      context += '\n\nCONVERSATION HISTORY:\n';
+      context += this.conversationHistory.slice(-5).map(m =>
+        `${m.role}: ${m.content.slice(0, 200)}`
+      ).join('\n');
+    }
+
+    return context;
+  }
+
+  isCodeRelated(message) {
+    const codeKeywords = [
+      'code', 'function', 'class', 'file', 'module', 'import', 'export',
+      'component', 'hook', 'api', 'endpoint', 'route', 'controller',
+      'model', 'view', 'service', 'auth', 'login', 'user', 'test',
+      'build', 'deploy', 'fix', 'bug', 'error', 'debug',
+    ];
+    const lower = message.toLowerCase();
+    return codeKeywords.some(kw => lower.includes(kw));
+  }
+
+  async processResponse(response) {
+    let finalResponse = response;
+    let iterations = 0;
+
+    // Check for tool calls in response
+    const toolCallRegex = /\{"tool":\s*"[^"]+?"[^}]*\}/g;
+    const toolCalls = response.match(toolCallRegex);
+
+    if (toolCalls && toolCalls.length > 0) {
+      for (const toolCallStr of toolCalls) {
+        try {
+          const toolCall = JSON.parse(toolCallStr);
+          console.log(`[Tool] Executing: ${toolCall.tool}...`);
+
+          const result = this.executeTool(toolCall);
+
+          // Add tool result to context
+          finalResponse += `\n\nTool Result (${toolCall.tool}):\n${JSON.stringify(result, null, 2)}`;
+
+          // If tool failed, ask AI to fix
+          if (!result.success && iterations < this.maxIterations) {
+            const fixPrompt = `The tool call failed. Error: ${result.error}\n\nPlease fix the issue and try again.`;
+            const fixResponse = await this.ai.chat(fixPrompt, {
+              system: this.systemPrompt,
+            });
+            finalResponse += '\n\n' + fixResponse;
+            iterations++;
+          }
+        } catch (e) {
+          finalResponse += `\n\nTool Error: ${e.message}`;
+        }
+      }
+    }
+
+    return finalResponse;
+  }
+
+  executeTool(toolCall) {
+    const { tool, ...params } = toolCall;
+
+    if (!this.tools.tools[tool]) {
+      return { success: false, error: `Unknown tool: ${tool}` };
+    }
+
+    return this.tools.tools[tool](...Object.values(params));
+  }
+
+  // ─── Quick Methods ──────────────────────────────────
+
+  async generateCode(prompt, language = 'python') {
+    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.ai.chat(prompt, { system });
+  }
+
+  async fixCode(code, error = '') {
+    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.ai.chat(msg, { system });
+  }
+
+  async explainCode(code) {
+    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.ai.chat(`Explain this code:\n\n\`\`\`\n${code}\n\`\`\``, { system });
+  }
+
+  async createProject(goal) {
+    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.ai.chat(`Create a project scaffold for: ${goal}`, { system });
+  }
+
+  async writeCodeToFile(code, filePath) {
+    const result = this.tools.writeFile(filePath, code);
+    if (result.success) {
+      return `File created successfully: ${filePath}`;
+    } else {
+      return `Failed to create file: ${result.error}`;
+    }
+  }
+
+  async runCommand(command) {
+    const result = this.tools.runCommand(command);
+    if (result.success) {
+      return `Command executed successfully:\n${result.stdout}`;
+    } else {
+      return `Command failed:\n${result.stderr || result.error}`;
+    }
+  }
+
+  // ─── Interactive Chat ──────────────────────────────
+
+  async startChat() {
+    const readline = require('readline');
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: 'Hybard > ',
+    });
+
+    console.log('\n╔════════════════════════════════════════════════════════════╗');
+    console.log('║              Hybard AI Agent — Full Stack                 ║');
+    console.log('║                                                          ║');
+    console.log('║  Connected to Real LLM Provider                          ║');
+    console.log('║  Codebase Understanding Active                           ║');
+    console.log('║  Project Detection Active                                ║');
+    console.log('║                                                          ║');
+    console.log('║  Commands:                                               ║');
+    console.log('║    /help      — Show capabilities                        ║');
+    console.log('║    /clear     — Clear conversation                       ║');
+    console.log('║    /memory    — Show memory                              ║');
+    console.log('║    /project   — Show project info                        ║');
+    console.log('║    /search    — Search codebase                          ║');
+    console.log('║    exit       — Exit                                     ║');
+    console.log('╚════════════════════════════════════════════════════════════╝\n');
+
+    // Show connection status
+    if (!this.ai.getApiKey()) {
+      console.log('⚠  No API key detected. Running in offline mode.');
+    } else {
+      console.log(`✓  Connected to ${this.ai.config.provider} (${this.ai.config.model})`);
+    }
+
+    // Show project info
+    try {
+      const info = this.tools.getProjectInfo();
+      console.log(`✓  Project detected: ${info.languages.join(', ')} with ${info.frameworks.join(', ')}`);
+    } catch (e) {
+      console.log('ℹ  No project detected in current directory');
+    }
+
+    console.log('');
+
+    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 === '/help') {
+        console.log('\n' + this.knowledge.getCapabilitiesSummary());
+        rl.prompt();
+        return;
+      }
+
+      if (text === '/clear') {
+        this.conversationHistory = [];
+        this.memory.shortTerm = [];
+        console.log('Conversation cleared.\n');
+        rl.prompt();
+        return;
+      }
+
+      if (text === '/memory') {
+        console.log('\nShort-term memory:');
+        this.memory.shortTerm.forEach(m => {
+          console.log(`  ${m.role}: ${m.content.slice(0, 100)}`);
+        });
+        console.log('\nLong-term memory:');
+        this.memory.longTerm.forEach(m => {
+          console.log(`  [${m.type}] ${m.content.slice(0, 100)}`);
+        });
+        rl.prompt();
+        return;
+      }
+
+      if (text === '/project') {
+        try {
+          const info = this.tools.detectProject();
+          console.log('\nProject Info:');
+          console.log(`  Type: ${info.type}`);
+          console.log(`  Languages: ${info.languages.join(', ')}`);
+          console.log(`  Frameworks: ${info.frameworks.join(', ')}`);
+          console.log(`  Entry Points: ${info.entryPoints.join(', ')}`);
+          console.log(`  Config Files: ${info.configFiles.join(', ')}`);
+        } catch (e) {
+          console.log('No project detected in current directory.');
+        }
+        rl.prompt();
+        return;
+      }
+
+      if (text.startsWith('/search ')) {
+        const query = text.slice(8);
+        console.log(`\nSearching codebase for "${query}"...`);
+        const results = this.tools.codebaseSearch.searchCode(query);
+        if (results.length === 0) {
+          console.log('No results found.');
+        } else {
+          console.log(`Found ${results.length} files:\n`);
+          for (const result of results.slice(0, 10)) {
+            console.log(`  ${result.file}:`);
+            for (const match of result.matches.slice(0, 3)) {
+              console.log(`    Line ${match.line}: ${match.content}`);
+            }
+          }
+        }
+        rl.prompt();
+        return;
+      }
+
+      // Normal message — send to AI
+      process.stdout.write('\nHybard > Thinking...\n');
+      try {
+        const response = await this.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 = { HybardAgent, KnowledgeBase, Memory, ToolSystem, ProjectDetector, CodebaseSearch };