hybard-agent 0.1.0

package/bin/agent.js

@@ -0,0 +1,673 @@
+#!/usr/bin/env node
+
+/**
+ * Hybard CLI — Professional autonomous coding assistant.
+ *
+ * Usage:
+ *   hybard                    Interactive chat
+ *   hybard "prompt"           Single message
+ *   hybard code "prompt"      Generate and optionally save code
+ *   hybard fix <file>         Fix a file
+ *   hybard explain <file>     Explain code
+ *   hybard search <query>     Search codebase
+ *   hybard project            Show project info
+ *   hybard network            Show network status
+ *   hybard help               Show help
+ */
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const readline = require('readline');
+const { Engine, Git, Security, Production, Evaluator } = require('../lib/engine');
+const { detectLocalIP, discoverHybardServer } = require('../lib/online');
+
+const engine = new Engine();
+
+// ─── Status Printer ──────────────────────────────────────
+
+function status(msg) {
+  process.stdout.write(`\x1b[90m  ${msg}\x1b[0m`);
+}
+
+function success(msg) {
+  console.log(`\x1b[32m  ${msg}\x1b[0m`);
+}
+
+function info(msg) {
+  console.log(`\x1b[36m  ${msg}\x1b[0m`);
+}
+
+function header(title) {
+  console.log();
+  console.log(`\x1b[1m${title}\x1b[0m`);
+}
+
+// ─── Interactive Chat ────────────────────────────────────
+
+async function interactiveChat() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: '\x1b[1mhybard\x1b[0m › ',
+  });
+
+  console.log();
+  console.log('\x1b[1m  Hybard\x1b[0m  \x1b[90mAutonomous Coding Assistant\x1b[0m');
+  console.log('\x1b[90m  Type your request, or /help for commands.\x1b[0m');
+  console.log();
+
+  rl.prompt();
+
+  rl.on('line', async (line) => {
+    const input = line.trim();
+    if (!input) { rl.prompt(); return; }
+
+    // Slash commands
+    if (input === '/quit' || input === '/exit') {
+      console.log('\n\x1b[90m  Goodbye.\x1b[0m\n');
+      rl.close();
+      return;
+    }
+
+    if (input === '/help') {
+      printChatHelp();
+      rl.prompt();
+      return;
+    }
+
+    if (input === '/clear') {
+      console.clear();
+      rl.prompt();
+      return;
+    }
+
+    if (input === '/project') {
+      printProjectInfo();
+      rl.prompt();
+      return;
+    }
+
+    if (input === '/network') {
+      await printNetworkInfo();
+      rl.prompt();
+      return;
+    }
+
+    if (input.startsWith('/search ')) {
+      const query = input.slice(8);
+      printSearchResults(query);
+      rl.prompt();
+      return;
+    }
+
+    // Normal message — autonomous processing
+    status('Thinking...');
+    try {
+      const response = await engine.process(input);
+      console.log();
+      console.log(response);
+      console.log();
+    } catch (err) {
+      console.log(`\n\x1b[31m  Error: ${err.message}\x1b[0m\n`);
+    }
+    rl.prompt();
+  });
+
+  rl.on('close', () => process.exit(0));
+}
+
+// ─── Single-Shot Commands ────────────────────────────────
+
+async function singleShot(prompt) {
+  status('Processing...');
+  try {
+    const response = await engine.process(prompt);
+    console.log();
+    console.log(response);
+    console.log();
+  } catch (err) {
+    console.error(`\n\x1b[31m  Error: ${err.message}\x1b[0m\n`);
+    process.exit(1);
+  }
+}
+
+async function generateCode(prompt) {
+  status('Generating code...');
+
+  const system = `You are an expert programmer. Generate clean, working code.
+Return ONLY the code in markdown code blocks with language tags.
+Include filename as a comment at the top of each file.`;
+
+  try {
+    const response = await engine.ai.chat(prompt, { system });
+    console.log();
+    console.log(response);
+    console.log();
+
+    // Extract code blocks and offer to save
+    const blocks = extractCodeBlocks(response);
+    if (blocks.length > 0) {
+      console.log(`\x1b[90m  Found ${blocks.length} code block(s)\x1b[0m`);
+      for (const b of blocks) {
+        console.log(`  → ${b.filename} (${b.language})`);
+      }
+
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      rl.question('\n  Save to files? (y/n) ', async (answer) => {
+        if (answer.toLowerCase() === 'y') {
+          for (const block of blocks) {
+            const abs = path.resolve(block.filename);
+            const dir = path.dirname(abs);
+            if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(abs, block.code, 'utf8');
+            success(`Created ${block.filename}`);
+          }
+          console.log();
+        }
+        rl.close();
+      });
+    }
+  } catch (err) {
+    console.error(`\n\x1b[31m  Error: ${err.message}\x1b[0m\n`);
+    process.exit(1);
+  }
+}
+
+async function fixFile(filePath) {
+  const abs = path.resolve(filePath);
+  if (!fs.existsSync(abs)) {
+    console.error(`\n\x1b[31m  File not found: ${filePath}\x1b[0m\n`);
+    process.exit(1);
+  }
+
+  const content = fs.readFileSync(abs, 'utf8');
+  status(`Fixing ${filePath}...`);
+
+  try {
+    const system = `You are a debugging expert. Fix the given code.
+Return ONLY the corrected code in a markdown code block.
+Do not include explanations.`;
+
+    const response = await engine.ai.chat(
+      `Fix any issues in this code:\n\n\`\`\`\n${content}\n\`\`\``,
+      { system }
+    );
+
+    const blocks = extractCodeBlocks(response);
+    if (blocks.length > 0) {
+      // Backup original
+      fs.writeFileSync(abs + '.bak', content, 'utf8');
+      fs.writeFileSync(abs, blocks[0].code, 'utf8');
+      success(`Fixed ${filePath} (backup: ${filePath}.bak)`);
+    } else {
+      console.log('\n\x1b[33m  No changes needed — file looks good.\x1b[0m\n');
+    }
+  } catch (err) {
+    console.error(`\n\x1b[31m  Error: ${err.message}\x1b[0m\n`);
+    process.exit(1);
+  }
+}
+
+async function explainFile(filePath) {
+  const abs = path.resolve(filePath);
+  if (!fs.existsSync(abs)) {
+    console.error(`\n\x1b[31m  File not found: ${filePath}\x1b[0m\n`);
+    process.exit(1);
+  }
+
+  const content = fs.readFileSync(abs, 'utf8');
+  status(`Analyzing ${filePath}...`);
+
+  try {
+    const system = `You are a code analyst. Explain the given code clearly.
+Cover: what it does, how it works, key patterns, and potential issues.
+Be concise but thorough.`;
+
+    const response = await engine.ai.chat(
+      `Explain this code:\n\n\`\`\`\n${content}\n\`\`\``,
+      { system }
+    );
+
+    console.log();
+    console.log(response);
+    console.log();
+  } catch (err) {
+    console.error(`\n\x1b[31m  Error: ${err.message}\x1b[0m\n`);
+    process.exit(1);
+  }
+}
+
+function searchCodebase(query) {
+  status(`Searching for "${query}"...`);
+  const result = engine.executeTool('search_code', { query });
+
+  if (!result.ok || result.count === 0) {
+    console.log('\n\x1b[90m  No results found.\x1b[0m\n');
+    return;
+  }
+
+  console.log();
+  console.log(`  Found ${result.count} match(es) in ${result.results.length} file(s):\n`);
+  for (const r of result.results.slice(0, 10)) {
+    console.log(`  \x1b[36m${r.file}\x1b[0m`);
+    for (const m of r.matches.slice(0, 3)) {
+      console.log(`    L${m.line}: ${m.content.slice(0, 100)}`);
+    }
+  }
+  console.log();
+}
+
+function printProjectInfo() {
+  const result = engine.executeTool('detect_project', {});
+  if (!result.ok) {
+    console.log('\n\x1b[90m  No project detected.\x1b[0m\n');
+    return;
+  }
+  console.log();
+  console.log('  \x1b[1mProject Info\x1b[0m');
+  console.log(`  Type:        ${result.type}`);
+  console.log(`  Languages:   ${result.languages.join(', ') || 'Unknown'}`);
+  console.log(`  Frameworks:  ${result.frameworks.join(', ') || 'None'}`);
+  console.log(`  Entry:       ${result.entryPoints.join(', ') || 'None'}`);
+  console.log(`  Config:      ${result.configFiles.join(', ') || 'None'}`);
+  console.log();
+}
+
+async function printNetworkInfo() {
+  const localIP = detectLocalIP();
+  console.log();
+  console.log('  \x1b[1mNetwork Status\x1b[0m');
+  console.log(`  Local IP:     ${localIP}`);
+  console.log(`  Server:       http://${localIP}:8000`);
+  console.log(`  Endpoint:     http://${localIP}:8000/v1/chat/completions`);
+  console.log(`  Health:       http://${localIP}:8000/health`);
+  console.log(`  Platform:     ${os.platform()} ${os.arch()}`);
+  console.log(`  CPU:          ${os.cpus().length} cores`);
+  console.log(`  RAM:          ${(os.totalmem() / (1024 ** 3)).toFixed(1)} GB`);
+  try {
+    const server = await discoverHybardServer();
+    console.log(`  Status:       ${server ? '\x1b[32mONLINE\x1b[0m' : '\x1b[31mOFFLINE\x1b[0m'}`);
+  } catch (e) {
+    console.log('  Status:       \x1b[33mUNKNOWN\x1b[0m');
+  }
+  console.log();
+}
+
+function printSearchResults(query) {
+  searchCodebase(query);
+}
+
+// ─── Helpers ─────────────────────────────────────────────
+
+function extractCodeBlocks(text) {
+  const blocks = [];
+  const regex = /```(\w*)\n([\s\S]*?)```/g;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    const lang = match[1] || 'txt';
+    const code = match[2].trim();
+    // Try to extract filename from code comment
+    const fileMatch = code.match(/(?:#|\/\/|\/\*+|<!--)\s*(?:filename|file|path)[:\s]+(.+\.\w+)/i);
+    const filename = fileMatch ? fileMatch[1].trim() : `generated.${extMap[lang] || 'txt'}`;
+    blocks.push({ language: lang, code, filename });
+  }
+  return blocks;
+}
+
+const extMap = {
+  python: 'py', javascript: 'js', typescript: 'ts', dart: 'dart',
+  html: 'html', css: 'css', sql: 'sql', bash: 'sh', json: 'json',
+};
+
+function printChatHelp() {
+  console.log(`
+  \x1b[1mCommands:\x1b[0m
+    /help        Show this help
+    /project     Show project info
+    /network     Show network status
+    /search <q>  Search codebase
+    /clear       Clear screen
+    /quit        Exit
+
+  \x1b[1mTips:\x1b[0m
+    Just type naturally — the agent understands context.
+    Example: "Add a login page to my React app"
+    Example: "একটা Python calculator বানাও"
+    Example: "Fix the bug in src/utils.js"
+  `);
+}
+
+// ─── Git Commands ─────────────────────────────────────────
+
+function printGitStatus() {
+  const s = Git.statusSummary();
+  if (!s.isRepo) {
+    console.log('\n\x1b[90m  Not a git repository.\x1b[0m\n');
+    return;
+  }
+  console.log();
+  console.log('  \x1b[1mGit Status\x1b[0m');
+  console.log(`  Branch:     ${s.branch}`);
+  console.log(`  Modified:   ${s.modified.length ? s.modified.join(', ') : 'none'}`);
+  console.log(`  Added:      ${s.added.length ? s.added.join(', ') : 'none'}`);
+  console.log(`  Deleted:    ${s.deleted.length ? s.deleted.join(', ') : 'none'}`);
+  console.log();
+}
+
+function printGitDiff(file) {
+  const result = file ? Git.diffFile(file) : Git.diff();
+  if (!result.ok || !result.stdout) {
+    console.log('\n\x1b[90m  No changes.\x1b[0m\n');
+    return;
+  }
+  console.log();
+  console.log(result.stdout);
+  console.log();
+}
+
+function printGitLog(n) {
+  const result = Git.log(n);
+  if (!result.ok) {
+    console.log('\n\x1b[90m  No git history.\x1b[0m\n');
+    return;
+  }
+  console.log();
+  console.log('  \x1b[1mRecent Commits\x1b[0m');
+  result.stdout.split('\n').forEach(line => console.log(`  ${line}`));
+  console.log();
+}
+
+function gitCommit(message) {
+  status('Committing...');
+  const result = Git.commit(message);
+  if (result.ok) {
+    success(`Committed: ${message}`);
+  } else {
+    console.log(`\n\x1b[31m  Commit failed: ${result.stderr}\x1b[0m\n`);
+  }
+}
+
+function printGitBranches() {
+  const result = Git.branches();
+  if (!result.ok) {
+    console.log('\n\x1b[90m  No branches.\x1b[0m\n');
+    return;
+  }
+  console.log();
+  result.stdout.split('\n').forEach(line => {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('*')) {
+      console.log(`  \x1b[32m${trimmed}\x1b[0m`);
+    } else if (trimmed) {
+      console.log(`  ${trimmed}`);
+    }
+  });
+  console.log();
+}
+
+function gitRollback(n) {
+  status(`Rolling back ${n} commit(s)...`);
+  const result = Git.rollback(n);
+  if (result.ok) {
+    success(`Rolled back ${n} commit(s)`);
+  } else {
+    console.log(`\n\x1b[31m  Rollback failed: ${result.stderr}\x1b[0m\n`);
+  }
+}
+
+// ─── Security Commands ───────────────────────────────────
+
+function securityScan(filePath) {
+  status(`Scanning ${filePath}...`);
+  const abs = path.resolve(filePath);
+  if (fs.existsSync(abs) && fs.statSync(abs).isFile()) {
+    const result = engine.executeTool('security_scan', { path: filePath });
+    console.log();
+    if (result.hasIssues) {
+      console.log('  \x1b[31mSecurity Issues Found:\x1b[0m');
+      result.secrets.forEach(s => console.log(`    ⚠ ${s}`));
+    } else {
+      console.log('  \x1b[32mNo security issues found.\x1b[0m');
+    }
+    console.log();
+  } else {
+    // Scan all files in directory
+    const searcher = new (require('../lib/hybard-agent').CodebaseSearch)(process.cwd());
+    const files = searcher.findFiles('.').slice(0, 20);
+    let totalIssues = 0;
+    console.log();
+    for (const f of files) {
+      const result = engine.executeTool('security_scan', { path: f });
+      if (result.hasIssues) {
+        console.log(`  \x1b[31m${f}:\x1b[0m`);
+        result.secrets.forEach(s => console.log(`    ⚠ ${s}`));
+        totalIssues += result.secrets.length;
+      }
+    }
+    if (totalIssues === 0) {
+      console.log('  \x1b[32mNo security issues found in project.\x1b[0m');
+    } else {
+      console.log(`\n  \x1b[31m${totalIssues} issue(s) found.\x1b[0m`);
+    }
+    console.log();
+  }
+}
+
+function securityValidate(input) {
+  const result = Security.validateInput(input);
+  console.log();
+  if (result.ok) {
+    console.log('  \x1b[32mInput is safe.\x1b[0m');
+  } else {
+    console.log(`  \x1b[31m${result.reason}\x1b[0m`);
+  }
+  console.log();
+}
+
+// ─── Production Commands ─────────────────────────────────
+
+function printSystemHealth() {
+  const health = Production.healthCheck();
+  const info = Production.getSystemInfo();
+  console.log();
+  console.log('  \x1b[1mSystem Health\x1b[0m');
+  const statusColor = health.status === 'healthy' ? '\x1b[32m' : health.status === 'warning' ? '\x1b[33m' : '\x1b[31m';
+  console.log(`  Status:     ${statusColor}${health.status.toUpperCase()}\x1b[0m`);
+  console.log(`  Memory:     ${health.memory}`);
+  console.log(`  CPU:        ${health.cpu}`);
+  console.log(`  Uptime:     ${health.uptime}`);
+  console.log(`  Platform:   ${info.platform} ${info.arch}`);
+  console.log(`  Node:       ${info.nodeVersion}`);
+  console.log(`  Hostname:   ${info.hostname}`);
+  console.log();
+}
+
+// ─── Evaluation Commands ─────────────────────────────────
+
+function evalCode(filePath) {
+  const abs = path.resolve(filePath);
+  if (!fs.existsSync(abs)) {
+    console.error(`\n\x1b[31m  File not found: ${filePath}\x1b[0m\n`);
+    process.exit(1);
+  }
+  const content = fs.readFileSync(abs, 'utf8');
+  const ext = path.extname(filePath).slice(1);
+  const langMap = { py: 'python', js: 'javascript', ts: 'typescript', dart: 'dart', sql: 'sql' };
+  const lang = langMap[ext] || 'python';
+
+  const result = Evaluator.evaluateCode(content, lang);
+  console.log();
+  console.log('  \x1b[1mCode Evaluation\x1b[0m');
+  const scoreColor = result.score >= 80 ? '\x1b[32m' : result.score >= 50 ? '\x1b[33m' : '\x1b[31m';
+  console.log(`  Score:      ${scoreColor}${result.score}/100\x1b[0m`);
+  console.log(`  Lines:      ${result.metrics.lines}`);
+  console.log(`  Comments:   ${result.metrics.commentRatio}`);
+  console.log(`  Docstring:  ${result.metrics.hasDocstring ? 'Yes' : 'No'}`);
+  console.log(`  Type Hints: ${result.metrics.hasTypeHints ? 'Yes' : 'No'}`);
+  if (result.issues.length > 0) {
+    console.log('  Issues:');
+    result.issues.forEach(i => console.log(`    ⚠ ${i}`));
+  } else {
+    console.log('  \x1b[32mNo issues found.\x1b[0m');
+  }
+  console.log();
+}
+
+// ─── Main ────────────────────────────────────────────────
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    await interactiveChat();
+    return;
+  }
+
+  const cmd = args[0].toLowerCase();
+  const rest = args.slice(1).join(' ');
+
+  switch (cmd) {
+    case 'help': case '--help': case '-h':
+      printFullHelp();
+      break;
+    case 'code': case 'generate':
+      if (!rest) { console.error('\n  Usage: hybard code "description"\n'); process.exit(1); }
+      await generateCode(rest);
+      break;
+    case 'fix':
+      if (!rest) { console.error('\n  Usage: hybard fix <file>\n'); process.exit(1); }
+      await fixFile(rest);
+      break;
+    case 'explain':
+      if (!rest) { console.error('\n  Usage: hybard explain <file>\n'); process.exit(1); }
+      await explainFile(rest);
+      break;
+    case 'search': case 'find':
+      if (!rest) { console.error('\n  Usage: hybard search <query>\n'); process.exit(1); }
+      searchCodebase(rest);
+      break;
+    case 'project': case 'info':
+      printProjectInfo();
+      break;
+    case 'network': case 'server': case 'status':
+      await printNetworkInfo();
+      break;
+    case 'run':
+      if (!rest) { console.error('\n  Usage: hybard run <command>\n'); process.exit(1); }
+      const result = engine.executeTool('run_command', { command: rest });
+      if (result.ok) console.log(result.stdout);
+      else console.error(result.stderr || result.error);
+      break;
+
+    case 'git':
+    case 'g':
+      {
+        const sub = (args[1] || 'status').toLowerCase();
+        switch (sub) {
+          case 'status': case 'st':
+            printGitStatus();
+            break;
+          case 'diff': case 'd':
+            printGitDiff(args[2]);
+            break;
+          case 'log':
+            printGitLog(parseInt(args[2]) || 10);
+            break;
+          case 'commit': case 'ci':
+            if (!args[2]) { console.error('\n  Usage: hybard git commit "message"\n'); process.exit(1); }
+            gitCommit(args.slice(2).join(' '));
+            break;
+          case 'branch': case 'b':
+            printGitBranches();
+            break;
+          case 'rollback': case 'rb':
+            gitRollback(parseInt(args[2]) || 1);
+            break;
+          default:
+            printGitStatus();
+        }
+      }
+      break;
+
+    case 'security': case 'sec':
+      {
+        const sub = (args[1] || 'scan').toLowerCase();
+        switch (sub) {
+          case 'scan':
+            if (!args[2]) { console.error('\n  Usage: hybard security scan <file>\n'); process.exit(1); }
+            securityScan(args[2]);
+            break;
+          case 'validate':
+            if (!args[2]) { console.error('\n  Usage: hybard security validate "input"\n'); process.exit(1); }
+            securityValidate(args.slice(2).join(' '));
+            break;
+          default:
+            securityScan(args[2] || '.');
+        }
+      }
+      break;
+
+    case 'health': case 'sys':
+      printSystemHealth();
+      break;
+
+    case 'eval':
+      if (!rest) { console.error('\n  Usage: hybard eval <file>\n'); process.exit(1); }
+      evalCode(rest);
+      break;
+
+    default:
+      await singleShot(args.join(' '));
+      break;
+  }
+}
+
+function printFullHelp() {
+  console.log(`
+  \x1b[1mHybard\x1b[0m  \x1b[90mAutonomous Coding Assistant\x1b[0m
+
+  \x1b[1mUsage:\x1b[0m
+    hybard                    Interactive chat
+    hybard "prompt"           Single message
+    hybard code "prompt"      Generate code
+    hybard fix <file>         Fix a file
+    hybard explain <file>     Explain code
+    hybard search <query>     Search codebase
+    hybard project            Project info
+    hybard network            Network status
+    hybard run <command>      Run shell command
+
+  \x1b[1mGit:\x1b[0m
+    hybard git status         Show git status
+    hybard git diff [file]    Show changes
+    hybard git log [n]        Show recent commits
+    hybard git commit "msg"   Stage all & commit
+    hybard git branch         List branches
+    hybard git rollback [n]   Rollback N commits
+
+  \x1b[1mSecurity:\x1b[0m
+    hybard security scan <f>  Scan for secrets/vulnerabilities
+    hybard security validate "input"  Check for prompt injection
+
+  \x1b[1mProduction:\x1b[0m
+    hybard health             System health check
+
+  \x1b[1mEvaluation:\x1b[0m
+    hybard eval <file>        Evaluate code quality
+
+  \x1b[1mExamples:\x1b[0m
+    hybard code "create a Python login page"
+    hybard code "একটা Flutter app বানাও"
+    hybard git status
+    hybard git commit "add login feature"
+    hybard security scan src/auth.py
+    hybard health
+    hybard eval lib/engine.js
+  `);
+}
+
+main().catch(err => {
+  console.error(`\n\x1b[31m  Fatal: ${err.message}\x1b[0m\n`);
+  process.exit(1);
+});