@aarushpandey/gitagent 1.0.0

package/src/cli/output.js

@@ -0,0 +1,137 @@
+const { computeCost } = require('../utils/cost');
+
+const c = {
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+  bold: '\x1b[1m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  magenta: '\x1b[35m',
+  blue: '\x1b[34m'
+};
+
+function banner() {
+  return `${c.cyan}${c.bold}
+   ╔════════════════════════════════════════════╗
+   ║   github-agent — autonomous PR engineer    ║
+   ║   engineering → self-review → ship         ║
+   ╚════════════════════════════════════════════╝${c.reset}`;
+}
+
+function step(label) {
+  return `\n${c.bold}${c.blue}▸ ${label}${c.reset}`;
+}
+
+function info(text) {
+  return `${c.dim}  ${text}${c.reset}`;
+}
+
+function ok(text) {
+  return `${c.green}  ✓ ${text}${c.reset}`;
+}
+
+function warn(text) {
+  return `${c.yellow}  ⚠ ${text}${c.reset}`;
+}
+
+function err(text) {
+  return `${c.red}  ✗ ${text}${c.reset}`;
+}
+
+function tool(name, preview) {
+  return `${c.dim}  🔧 ${c.reset}${c.magenta}${name}${c.reset}${c.dim}${preview ? '(' + preview + ')' : ''}${c.reset}`;
+}
+
+function thought(turn, text) {
+  const oneLine = text.replace(/\s+/g, ' ').trim();
+  const trimmed = oneLine.length > 200 ? oneLine.slice(0, 197) + '...' : oneLine;
+  return `${c.dim}  💭 [turn ${turn}] ${trimmed}${c.reset}`;
+}
+
+function usageSummary(label, usage) {
+  const cost = computeCost(usage);
+  return `${c.bold}${label}${c.reset}\n` +
+    `  input: ${usage.input_tokens.toLocaleString()} tok` +
+    `  · output: ${usage.output_tokens.toLocaleString()} tok` +
+    `  · cache_read: ${usage.cache_read_input_tokens.toLocaleString()} tok` +
+    `  · cache_create: ${(usage.cache_creation_input_tokens || 0).toLocaleString()} tok\n` +
+    `  ${c.green}cost: $${cost.total_usd.toFixed(4)}${c.reset}` +
+    ` ${c.dim}(in $${cost.input_usd.toFixed(4)} + out $${cost.output_usd.toFixed(4)} + cache_r $${cost.cache_read_usd.toFixed(4)} + cache_c $${cost.cache_creation_usd.toFixed(4)})${c.reset}`;
+}
+
+function makeAgentEventHandler(log) {
+  return (e) => {
+    if (e.type === 'turn_start') {
+      // Quiet — don't spam. The thoughts/tools will print.
+      return;
+    }
+    if (e.type === 'thought') {
+      log(thought(e.turn, e.text));
+      return;
+    }
+    if (e.type === 'tool_call') {
+      log(tool(e.name, e.preview));
+      return;
+    }
+    if (e.type === 'tool_result') {
+      if (e.ok) {
+        if (e.flaky) log(warn(`     → ok (flaky: passed after ${e.attempts} attempts)`));
+        else log(`${c.dim}     → ok${c.reset}`);
+      } else {
+        log(err(`     → ${e.error}`));
+      }
+      return;
+    }
+    if (e.type === 'finished') {
+      log(ok(`Agent finished after ${e.turn} turn(s)`));
+      return;
+    }
+    if (e.type === 'iteration_limit') {
+      log(warn(`Agent hit iteration limit (${e.turn})`));
+      return;
+    }
+    if (e.type === 'no_tools') {
+      log(warn(`Agent stopped without calling finish (stop_reason=${e.stop_reason})`));
+      return;
+    }
+    if (e.type === 'cost_limit_hit') {
+      log(err(`Cost limit hit at turn ${e.turn}: $${e.costUsd.toFixed(4)} > $${e.limit}`));
+      return;
+    }
+    if (e.type === 'api_retry') {
+      const reason = (e.error && (e.error.status || e.error.code)) || 'unknown';
+      log(warn(`API call failed (${reason}); retrying in ${e.delayMs}ms (attempt ${e.nextAttempt})`));
+      return;
+    }
+  };
+}
+
+function makeStageEventHandler(log) {
+  return (e) => {
+    if (e.stage === 'engineering_start') log(step('Engineering agent — autonomous fix loop'));
+    else if (e.stage === 'engineering_aborted') log(err('Engineering agent did not complete'));
+    else if (e.stage === 'no_diff') log(warn('Agent finished but produced no diff'));
+    else if (e.stage === 'self_review_start') log(step('Self-review — auditing the diff'));
+    else if (e.stage === 'self_review_done') log(ok(`Review verdict: ${e.verdict}`));
+    else if (e.stage === 'revision_start') log(step('Revision pass — addressing review feedback'));
+    else if (e.stage === 'revision_done') log(ok('Revision complete'));
+  };
+}
+
+module.exports = {
+  banner,
+  step,
+  info,
+  ok,
+  warn,
+  err,
+  tool,
+  thought,
+  usageSummary,
+  computeCost,
+  makeAgentEventHandler,
+  makeStageEventHandler,
+  c
+};

package/src/config.js

@@ -0,0 +1,22 @@
+module.exports = {
+  MODEL: 'claude-sonnet-4-6',
+  MAX_REVIEW_FILE_BYTES: 200_000,
+
+  MAX_AGENT_ITERATIONS: 18,
+  MAX_TURN_OUTPUT_TOKENS: 8192,
+  MAX_REVISION_PASSES: 1,
+
+  TEST_COMMAND_TIMEOUT_MS: 5 * 60 * 1000,
+  TOOL_OUTPUT_TRUNCATE: 8000,
+
+  // Cost per 1M tokens (USD) — Claude Sonnet pricing.
+  // Update here if Anthropic rates change.
+  COST_INPUT_PER_MTOK: 3.0,
+  COST_OUTPUT_PER_MTOK: 15.0,
+  COST_CACHE_READ_PER_MTOK: 0.30,
+  COST_CACHE_CREATION_PER_MTOK: 3.75,
+
+  // Hard kill switch — abort an agent loop if its cost crosses this many USD.
+  // Override per-run with --max-cost=X.XX
+  DEFAULT_MAX_USD_PER_RUN: 5.0
+};

package/src/mapper/fileRelevance.js

@@ -0,0 +1,113 @@
+// Lightweight keyword-based file relevance scorer.
+//
+// The engineering agent previously had to explore big repos by grep-and-read
+// alone, which wastes context and turns on Qiskit-class trees (thousands of
+// files across multiple sub-packages). This module picks a shortlist of
+// probably-relevant files given the issue text, using a fast local scorer —
+// no embeddings, no extra API call.
+//
+// It is intentionally simple:
+//  1. Tokenize the issue title + body (alphanumeric, lowercased, len >= 3,
+//     with a small stopword set).
+//  2. For every repo file, score:
+//       path_score    — how many issue tokens appear in the file path
+//                       (basename weighted 3x, dir components 1x)
+//       content_score — how many issue tokens appear in the first 2 KB
+//                       (weight 1 per occurrence, capped per token)
+//  3. Return the top-K files by total score, ties broken by shorter paths
+//     (so `src/auth/login.py` beats `tests/integration/auth/login_test.py`).
+//
+// This is a prefilter, not a selector: the agent is still free to explore.
+// We give it a starting hint so it doesn't burn turn 1-5 on directory walks.
+
+const fs = require('fs');
+const path = require('path');
+
+const STOPWORDS = new Set([
+  'the','a','an','and','or','but','not','to','of','in','on','for','with',
+  'is','was','were','be','been','being','are','am','do','does','did',
+  'this','that','these','those','it','its','as','if','then','else','when',
+  'at','by','from','into','out','up','down','over','under','than','so','too',
+  'very','can','cannot','should','would','could','may','might','must','will',
+  'shall','have','has','had','i','you','he','she','we','they','my','your',
+  'his','her','our','their','me','him','us','them','error','bug','issue',
+  'fix','fixes','fixed','broken','breaks','please','need','needs','want',
+  'wants','make','add','remove','support','feature','problem'
+]);
+
+function tokenize(text) {
+  if (!text) return new Set();
+  const toks = String(text)
+    .toLowerCase()
+    .split(/[^a-z0-9_]+/)
+    .filter(t => t.length >= 3 && !STOPWORDS.has(t));
+  return new Set(toks);
+}
+
+function scorePath(filePath, tokens) {
+  const lower = filePath.toLowerCase();
+  const base = path.basename(lower, path.extname(lower));
+  const baseTokens = new Set(base.split(/[^a-z0-9]+/).filter(Boolean));
+  const dirTokens = new Set(
+    path.dirname(lower).split(/[\\/]+/).flatMap(p => p.split(/[^a-z0-9]+/)).filter(Boolean)
+  );
+  let score = 0;
+  for (const tok of tokens) {
+    if (baseTokens.has(tok)) score += 3;
+    if (dirTokens.has(tok)) score += 1;
+  }
+  return score;
+}
+
+function scoreContent(absPath, tokens, budget = 2048) {
+  let buf = '';
+  try {
+    const fd = fs.openSync(absPath, 'r');
+    const b = Buffer.alloc(budget);
+    const n = fs.readSync(fd, b, 0, budget, 0);
+    fs.closeSync(fd);
+    buf = b.slice(0, n).toString('utf8').toLowerCase();
+  } catch {
+    return 0;
+  }
+  let score = 0;
+  for (const tok of tokens) {
+    // A token that appears at all counts once; bursts cap at 3 to avoid
+    // letting a doctest with the token 40 times dominate the ranking.
+    const occurrences = (buf.match(new RegExp(`\\b${escapeRegex(tok)}\\b`, 'g')) || []).length;
+    if (occurrences > 0) score += Math.min(3, occurrences);
+  }
+  return score;
+}
+
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function rankFiles({ repoPath, files, issueText, topK = 30 }) {
+  const tokens = tokenize(issueText);
+  if (tokens.size === 0) {
+    // Nothing to score against. Return a stable head slice.
+    return files.slice(0, topK).map(f => ({ path: f, score: 0, pathScore: 0, contentScore: 0 }));
+  }
+  const scored = [];
+  for (const rel of files) {
+    const abs = path.join(repoPath, rel);
+    const pScore = scorePath(rel, tokens);
+    // Only pay the file-read cost for files that already look plausible on
+    // path alone, or whose cheap path score is non-zero. This keeps the
+    // scorer fast on 10k-file repos.
+    const cScore = pScore > 0 ? scoreContent(abs, tokens) : 0;
+    const total = pScore * 2 + cScore;
+    if (total > 0) {
+      scored.push({ path: rel, score: total, pathScore: pScore, contentScore: cScore });
+    }
+  }
+  scored.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return a.path.length - b.path.length;
+  });
+  return scored.slice(0, topK);
+}
+
+module.exports = { rankFiles, tokenize, scorePath, scoreContent };

package/src/mapper/repoMap.js

@@ -0,0 +1,105 @@
+const fs = require('fs');
+const path = require('path');
+
+// Directories to skip when walking. Covers Node, Python, Rust, Go, Java,
+// common CI/IDE artefacts, and doc-build output — so the walker does not
+// explode on large real-world projects (TQEC-scale Python, Kubernetes,
+// Rust monorepos with vendored deps).
+const IGNORE_DIRS = new Set([
+  // Node
+  'node_modules', 'dist', 'build', '.next', 'coverage', '.turbo',
+  // VCS
+  '.git', '.hg', '.svn',
+  // Python
+  '__pycache__', '.venv', 'venv', 'env',
+  '.mypy_cache', '.pytest_cache', '.ruff_cache', '.pytype',
+  '.tox', '.nox', '.eggs', 'htmlcov',
+  // Rust / Go / Java / Gradle
+  'target', 'vendor', '.gradle', '.m2',
+  // Editor / OS
+  '.idea', '.vscode', '.DS_Store',
+  // Docs build
+  '_build', 'site',
+]);
+// Source files: the agent is expected to edit these.
+const SOURCE_EXTENSIONS = new Set([
+  // JS/TS
+  '.js', '.ts', '.tsx', '.jsx', '.mjs', '.cjs',
+  // Python (incl. Cython/typeshed)
+  '.py', '.pyx', '.pxd', '.pyi',
+  // Native / scientific Python dependencies
+  '.c', '.cpp', '.cc', '.cxx', '.h', '.hpp', '.hh',
+  // Other mainstream
+  '.rs', '.go', '.java', '.kt', '.rb', '.php', '.swift', '.scala',
+]);
+
+// Project/config files: the agent can READ these to orient itself (detect
+// test command, read CONTRIBUTING.md, read PR template, understand package
+// layout), but shouldn't treat them as normal source targets.
+const CONFIG_EXTENSIONS = new Set([
+  '.toml', '.cfg', '.ini', '.yaml', '.yml', '.json',
+  '.md', '.rst', '.txt',
+]);
+
+const SPECIAL_FILENAMES = new Set([
+  'Makefile', 'makefile', 'GNUmakefile',
+  'Dockerfile', 'dockerfile',
+  'tox.ini', 'noxfile.py', 'pyproject.toml', 'setup.py', 'setup.cfg',
+  'package.json', 'Cargo.toml', 'go.mod',
+  'CONTRIBUTING.md', 'CONTRIBUTING.rst',
+  'CODE_OF_CONDUCT.md',
+]);
+
+const ALLOWED_EXTENSIONS = new Set([...SOURCE_EXTENSIONS, ...CONFIG_EXTENSIONS]);
+
+// Hard cap so a single list_files call can't consume the agent's context.
+const DEFAULT_FILE_CAP = 2000;
+
+function buildRepoMap(rootPath, { prefix = '', maxFiles = DEFAULT_FILE_CAP } = {}) {
+  const files = [];
+  let total = 0;
+  let truncated = false;
+
+  function walk(dir, rel) {
+    if (truncated) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return; // unreadable dir — skip, don't crash the walk
+    }
+    for (const entry of entries) {
+      if (truncated) return;
+      if (IGNORE_DIRS.has(entry.name)) continue;
+      if (entry.name.startsWith('.') && IGNORE_DIRS.has(entry.name)) continue;
+      const full = path.join(dir, entry.name);
+      const next = rel ? `${rel}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        walk(full, next);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name);
+        const isRelevant = ALLOWED_EXTENSIONS.has(ext) || SPECIAL_FILENAMES.has(entry.name);
+        if (!isRelevant) continue;
+        total++;
+        if (files.length >= maxFiles) {
+          truncated = true;
+          return;
+        }
+        files.push(prefix ? `${prefix}/${next}` : next);
+      }
+    }
+  }
+
+  walk(rootPath, '');
+  return { files, total, truncated, cap: maxFiles };
+}
+
+module.exports = {
+  buildRepoMap,
+  IGNORE_DIRS,
+  ALLOWED_EXTENSIONS,
+  SOURCE_EXTENSIONS,
+  CONFIG_EXTENSIONS,
+  SPECIAL_FILENAMES,
+  DEFAULT_FILE_CAP
+};