beast-agent 2.6.1 → 2.6.3

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "beast-agent",
     "productName": "Beast Agent",
-    "version": "2.6.1",
+    "version": "2.6.3",
     "description": "Ultra-fast local agent shell for Windows.",
     "author": "algokodcom (AlgoKod)",
     "license": "MIT",

package/src/agent/engine.js

@@ -126,6 +126,7 @@ const PERM_TOOL_SETS = {
     'web_search', 'http_fetch', 'webfetch', 'deep_search',
     'browser_open', 'browser_read', 'browser_snapshot',
     'list_dir', 'read_file', 'grep', 'glob',
+    'git_diff_review', 'repo_map', 'repo_symbols', 'xlsx_read',
   ]),
   chat: new Set([]), // sadece sohbet
 };
@@ -138,6 +139,7 @@ const PLAN_ALLOW_TOOLS = new Set([
   'web_search', 'http_fetch', 'webfetch', 'deep_search',
   'browser_open', 'browser_read', 'browser_snapshot',
   'todo_write', 'memory_search', 'kb_search', 'ocr_read',
+  'git_diff_review', 'repo_map', 'repo_symbols', 'xlsx_read',
 ]);
 
 /* İzin değerini normalize eder: 'all' → ['all'], 'web' → ['web'],
@@ -4021,6 +4023,9 @@ const skills = require('./skills');
       /* opencode general-agent portu: alt-ajan da edit/grep/glob kullanır */
       if (!(name === 'run_command' || name === 'read_file' || name === 'write_file' || name === 'edit_file' ||
             name === 'list_dir' || name === 'grep' || name === 'glob' ||
+            name === 'git_commit' || name === 'git_diff_review' || name === 'git_pr_create' ||
+            name === 'repo_map' || name === 'repo_symbols' ||
+            name === 'xlsx_read' || name === 'xlsx_write' || name === 'xlsx_edit' ||
             name === 'web_search' || name === 'http_fetch' || name === 'webfetch' || name === 'python_run')) {
         return JSON.stringify({ ok: false, error: `unknown tool ${name}` });
       }
@@ -4034,7 +4039,7 @@ const skills = require('./skills');
 
   /* Onay gerektiren araçlar — tepkiyle onay kapısına takılır.
      opencode'da edit+write aynı "edit" iznine takılır — burada da ikisi birlikte */
-  static RISKY_TOOLS = new Set(['run_command', 'write_file', 'edit_file', 'python_run', 'email_send', 'watcher_add']);
+  static RISKY_TOOLS = new Set(['run_command', 'write_file', 'edit_file', 'python_run', 'email_send', 'watcher_add', 'git_commit', 'git_pr_create', 'xlsx_write', 'xlsx_edit']);
 
   /* ANA KOD KİLİDİ: yıkıcı işlem desenleri (korumalı yol + bu desen = engel) */
   static DESTRUCTIVE_RE =

package/src/agent/gittools.js

@@ -0,0 +1,276 @@
+'use strict';
+
+/* Yerleşik git araçları — ajan commit/diff/PR işlerini kabuk komutu yazmadan
+   yapar. execFile arg-dizisiyle çağrılır (quoting/enjeksiyon riski yok).
+   gh CLI yoksa git_pr_create net yönlendirmeyle hata döner.
+   Bildirim: tüm sonuçlar JSON'a çevrilerek tools.exec'ten döner. */
+
+const { execFile } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const MAX_DIFF_CHARS = 30000;
+const GIT_TIMEOUT = 60000;
+const NET_TIMEOUT = 120000;
+
+/* git/gh çağrısı: { ok, code, out, err, missing } döner — missing = binary yok */
+function run(bin, args, cwd, timeoutMs = GIT_TIMEOUT) {
+  return new Promise((resolve) => {
+    execFile(
+      bin,
+      args,
+      {
+        cwd: cwd || process.cwd(),
+        timeout: timeoutMs,
+        windowsHide: true,
+        maxBuffer: 32 * 1024 * 1024,
+        env: process.env,
+      },
+      (err, stdout, stderr) => {
+        if (err && err.code === 'ENOENT') {
+          resolve({ ok: false, code: null, out: '', err: '', missing: true });
+          return;
+        }
+        const code = err ? (typeof err.code === 'number' ? err.code : null) : 0;
+        const killed = !!(err && err.killed);
+        resolve({
+          ok: !err,
+          code,
+          killed,
+          out: String(stdout || ''),
+          err: String(stderr || (err && err.message) || ''),
+        });
+      }
+    );
+  });
+}
+
+async function insideWorkTree(cwd) {
+  const r = await run('git', ['rev-parse', '--is-inside-work-tree'], cwd);
+  return r.ok && r.out.trim() === 'true';
+}
+
+async function branchName(cwd) {
+  const r = await run('git', ['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+  return r.ok ? r.out.trim() : '';
+}
+
+function cleanRef(ref) {
+  return /^[\w./\-~^+]{1,120}$/.test(String(ref || '')) ? String(ref) : null;
+}
+
+/* ---------- git_commit ---------- */
+async function gitCommit(args, ctx) {
+  const cwd = ctx && ctx.cwd;
+  if (!(await insideWorkTree(cwd))) {
+    return { ok: false, error: 'git deposu değil: ' + (cwd || '.') };
+  }
+  const message = String(args.message || '').trim();
+  if (!message) return { ok: false, error: 'commit mesajı boş olamaz' };
+  if (message.length > 2000) return { ok: false, error: 'commit mesajı çok uzun (max 2000 karakter)' };
+
+  /* 1) stage: paths > add_all > (yoksa mevcut staged hali commit'lenir) */
+  let staged = false;
+  if (Array.isArray(args.paths) && args.paths.length) {
+    const paths = args.paths.map((p) => path.resolve(String(cwd || '.'), String(p))).slice(0, 100);
+    const r = await run('git', ['add', '--', ...paths], cwd);
+    if (!r.ok) return { ok: false, error: 'git add başarısız: ' + (r.err || r.out).trim() };
+    staged = true;
+  } else if (args.add_all) {
+    const r = await run('git', ['add', '-A'], cwd);
+    if (!r.ok) return { ok: false, error: 'git add -A başarısız: ' + (r.err || r.out).trim() };
+    staged = true;
+  }
+
+  /* 2) staged değişiklik var mı? (diff --cached --quiet: 0=yok, 1=var) */
+  const q = await run('git', ['diff', '--cached', '--quiet'], cwd);
+  if (q.ok) {
+    return { ok: false, error: 'commit\'lenecek değişiklik yok — paths/add_all ver ya da önce değişiklik yap' };
+  }
+
+  /* 3) commit */
+  const c = await run('git', ['commit', '-m', message], cwd);
+  if (!c.ok) {
+    return { ok: false, error: ('git commit başarısız: ' + (c.err || c.out)).trim() };
+  }
+  const hash = (await run('git', ['rev-parse', 'HEAD'], cwd)).out.trim();
+  const branch = await branchName(cwd);
+  const stat = (await run('git', ['show', '--stat', '--oneline', '-s'], cwd)).out.trim();
+
+  /* 4) opsiyonel push */
+  let pushResult = null;
+  if (args.push) {
+    const p = await run('git', ['push'], cwd, NET_TIMEOUT);
+    if (!p.ok) {
+      const p2 = await run('git', ['push', '-u', 'origin', branch || 'HEAD'], cwd, NET_TIMEOUT);
+      pushResult = p2.ok
+        ? { ok: true, note: 'upstream ayarlanarak push edildi' }
+        : { ok: false, error: (p2.err || p2.out).trim() };
+    } else pushResult = { ok: true };
+  }
+
+  return { ok: true, hash, branch, stat, ...(pushResult ? { push: pushResult } : {}) };
+}
+
+/* ---------- git_diff_review ---------- */
+async function gitDiffReview(args, ctx) {
+  const cwd = ctx && ctx.cwd;
+  if (!(await insideWorkTree(cwd))) {
+    return { ok: false, error: 'git deposu değil: ' + (cwd || '.') };
+  }
+  const staged = !!args.staged;
+  const ref = args.ref ? cleanRef(args.ref) : null;
+  if (args.ref && !ref) return { ok: false, error: 'geçersiz ref: ' + String(args.ref).slice(0, 60) };
+  const ctxN = Math.min(20, Math.max(0, Math.floor(Number(args.context) || 3)));
+  const maxChars = Math.min(60000, Math.max(500, Math.floor(Number(args.max_chars) || MAX_DIFF_CHARS)));
+
+  const branch = await branchName(cwd);
+  const status = (await run('git', ['status', '--porcelain=v1'], cwd)).out
+    .split('\n')
+    .filter(Boolean)
+    .slice(0, 60);
+
+  const statArgs = ['diff', '--stat'];
+  const diffArgs = ['diff', '--unified=' + ctxN];
+  if (staged) {
+    statArgs.splice(1, 0, '--staged');
+    diffArgs.splice(1, 0, '--staged');
+  }
+  if (ref) {
+    statArgs.push(ref);
+    diffArgs.push(ref);
+  }
+  const stat = (await run('git', statArgs, cwd)).out.trim();
+  const dr = await run('git', diffArgs, cwd);
+  let diff = (dr.out || '').trim();
+  let truncated = false;
+  if (diff.length > maxChars) {
+    diff = diff.slice(0, maxChars);
+    truncated = true;
+  }
+  return {
+    ok: true,
+    branch,
+    staged,
+    ...(ref ? { ref } : {}),
+    status,
+    stat: stat || '(fark yok)',
+    diff: diff || '(fark yok)',
+    ...(truncated ? { truncated: true, note: `çıktı ${maxChars} karakterde kesildi — max_chars'i artır ya da ref daralt` } : {}),
+  };
+}
+
+/* ---------- git_pr_create ---------- */
+async function gitPrCreate(args, ctx) {
+  const cwd = ctx && ctx.cwd;
+  if (!(await insideWorkTree(cwd))) {
+    return { ok: false, error: 'git deposu değil: ' + (cwd || '.') };
+  }
+  const title = String(args.title || '').trim();
+  if (!title) return { ok: false, error: 'PR başlığı boş olamaz' };
+  const branch = await branchName(cwd);
+  if (!branch || branch === 'HEAD') {
+    return { ok: false, error: 'dal okunamadı — depo boş olabilir (önce bir commit yap)' };
+  }
+  if (/^(main|master)$/i.test(branch)) {
+    return { ok: false, error: `şu an '${branch}' dalındasın — önce bir özellik dalı aç (git switch -c feature/...), sonra PR oluştur` };
+  }
+  const base = args.base ? cleanRef(args.base) : null;
+  if (args.base && !base) return { ok: false, error: 'geçersiz base: ' + String(args.base).slice(0, 60) };
+
+  /* gh var mı? */
+  const v = await run('gh', ['--version'], cwd, 15000);
+  if (v.missing) {
+    return { ok: false, error: 'gh CLI bulunamadı — kur: winget install GitHub.cli (sonra: gh auth login)' };
+  }
+
+  /* dal uzakta yoksa push et — PR için şart */
+  const push = await run('git', ['push', '-u', 'origin', branch], cwd, NET_TIMEOUT);
+  if (!push.ok && !/up.to.date|everything.up.to.date/i.test(push.err + push.out)) {
+    return { ok: false, error: 'dal push edilemedi: ' + (push.err || push.out).trim() };
+  }
+
+  const prArgs = ['pr', 'create', '--title', title.slice(0, 300), '--body', String(args.body || '').slice(0, 8000)];
+  if (base) prArgs.push('--base', base);
+  if (args.draft) prArgs.push('--draft');
+  const r = await run('gh', prArgs, cwd, NET_TIMEOUT);
+  if (!r.ok) {
+    const e = (r.err || r.out).trim();
+    if (/already exists/i.test(e)) return { ok: false, error: 'bu dal için PR zaten açık: ' + e };
+    return { ok: false, error: 'gh pr create başarısız: ' + e };
+  }
+  const url = (r.out.match(/https?:\/\/\S+/) || [null])[0];
+  return { ok: true, branch, ...(url ? { url } : { output: r.out.trim() }) };
+}
+
+const definitions = [
+  {
+    type: 'function',
+    function: {
+      name: 'git_commit',
+      description:
+        'Commit staged or specified changes to the local git repository. Optionally pushes. Returns commit hash, branch and a stat summary. Prefer this over raw `git` shell commands. Usage:\n' +
+        '- Provide `message` (required). Stage with `paths` (array of files) or `add_all: true` (everything, including untracked); if neither is given, whatever is already staged is committed.\n' +
+        '- The tool refuses when there is nothing staged to commit.\n' +
+        '- Set `push: true` to push the branch after committing.',
+      parameters: {
+        type: 'object',
+        properties: {
+          message: { type: 'string', description: 'Commit message (concise, matches repo style)' },
+          paths: { type: 'array', items: { type: 'string' }, description: 'Specific files/dirs to stage before committing' },
+          add_all: { type: 'boolean', description: 'Stage all changes (git add -A) before committing' },
+          push: { type: 'boolean', description: 'Push the branch to its remote after committing' },
+        },
+        required: ['message'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'git_diff_review',
+      description:
+        'Review git changes: returns status, --stat summary and the unified diff of unstaged, staged (--staged) or ref-compared (ref: "HEAD~1", "main...", "a..b") changes. Use to self-review edits before committing or to summarize what changed.',
+      parameters: {
+        type: 'object',
+        properties: {
+          staged: { type: 'boolean', description: 'Diff the index (staged) instead of the working tree' },
+          ref: { type: 'string', description: 'Compare against a ref, e.g. "HEAD~1", "main", "v1.2.0"' },
+          context: { type: 'number', description: 'Unified context lines (default 3, max 20)' },
+          max_chars: { type: 'number', description: 'Cap diff output length (default 30000)' },
+        },
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'git_pr_create',
+      description:
+        'Create a GitHub pull request from the current branch via the gh CLI. Pushes the branch first (git push -u origin <branch>). Refuses on main/master — switch to a feature branch first. Returns the PR URL.',
+      parameters: {
+        type: 'object',
+        properties: {
+          title: { type: 'string', description: 'PR title' },
+          body: { type: 'string', description: 'PR description (markdown)' },
+          base: { type: 'string', description: 'Target branch (default: repo default branch)' },
+          draft: { type: 'boolean', description: 'Create as draft PR' },
+        },
+        required: ['title'],
+      },
+    },
+  },
+];
+
+module.exports = {
+  definitions,
+  handlers: {
+    git_commit: gitCommit,
+    git_diff_review: gitDiffReview,
+    git_pr_create: gitPrCreate,
+  },
+  /* test + dış kullanım */
+  run,
+  insideWorkTree,
+  branchName,
+};

package/src/agent/perception.js

@@ -584,6 +584,10 @@ async function runCycle({ cfg, signals, llmFilter, now = new Date(), log = () =>
   }
   counts.queued = kept.length;
 
+  /* 'yok sayıldı' olaylar depoda TUTULMAZ — son olaylar listesi temiz kalır
+     (eski depoda kalan ignored'lar da bu filtreyle bir temizlikte silinir) */
+  st.events = st.events.filter((e) => e.status !== 'ignored');
+
   /* depo tavanı */
   if (st.events.length > EVENT_CAP) st.events = st.events.slice(st.events.length - EVENT_CAP);
 

package/src/agent/repomap.js

@@ -0,0 +1,265 @@
+'use strict';
+
+/* Hafif repo haritası / sembol arama — "hangi fonksiyon nerede" sorusuna
+   LSP kurmadan cevap verir. Satır-bazlı regex çıkarımı: js/ts/jsx/tsx,
+   python, go, rust, c/cpp, c#/java/kt, php, ruby, swift.
+   Ağır klasörler (node_modules, .git, dist…) tools.js SKIP_DIRS ile aynı
+   mantıkta burada da atlanır. */
+
+const path = require('path');
+const fs = require('fs');
+
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', '__pycache__', '.venv', 'venv', 'env',
+  'dist', 'build', 'out', 'coverage', '.next', '.turbo', '.cache',
+  'vendor', 'target', 'bin', 'obj', '.idea', '.vscode',
+]);
+
+const MAX_FILE_BYTES = 600 * 1024;
+
+/* satır → { kind, name } listesi; kind: function | class | method */
+const RULES = [
+  {
+    ext: /\.(m?js|cjs|jsx|tsx?|mts|cts)$/i,
+    lines: [
+      [/^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)/, 'function'],
+      [/^\s*(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/, 'class'],
+      [/^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?(?:function\b|\([^)]*\)\s*=>|[A-Za-z_$][\w$]*\s*=>)/, 'function'],
+      [/^\s+(?:static\s+)?(?:async\s+)?(?:get\s+|set\s+)?([A-Za-z_$][\w$]*)\s*\([^()]*\)\s*\{/, 'method'],
+    ],
+    methodKw: /^(if|for|while|switch|catch|function|return|else|do|new|typeof|delete|void|await|yield|super|try)$/,
+  },
+  {
+    ext: /\.py$/i,
+    lines: [
+      [/^\s*(?:async\s+)?def\s+([A-Za-z_]\w*)/, 'function'],
+      [/^\s*class\s+([A-Za-z_]\w*)/, 'class'],
+    ],
+  },
+  {
+    ext: /\.go$/i,
+    lines: [
+      [/^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)/, 'function'],
+      [/^type\s+([A-Za-z_]\w*)\s+(?:struct|interface)\b/, 'class'],
+    ],
+  },
+  {
+    ext: /\.rs$/i,
+    lines: [
+      [/^\s*(?:pub\s+)?(?:async\s+)?fn\s+([A-Za-z_]\w*)/, 'function'],
+      [/^\s*(?:pub\s+)?(?:struct|enum|trait)\s+([A-Za-z_]\w*)/, 'class'],
+    ],
+  },
+  {
+    ext: /\.(c|h|cpp|hpp|cc|hh)$/i,
+    lines: [
+      [/^[A-Za-z_][\w\s\*&:<>]*?\b([A-Za-z_]\w*)\s*\([^;]*\)\s*\{\s*$/, 'function'],
+      [/^\s*(?:class|struct)\s+([A-Za-z_]\w*)/, 'class'],
+    ],
+  },
+  {
+    ext: /\.(cs|java|kt|kts|swift|scala)$/i,
+    lines: [
+      [/^\s*(?:(?:public|private|protected|internal|static|final|abstract|sealed|override|data|open|case)\s+)*(?:class|interface|enum|record|object)\s+([A-Za-z_]\w*)/, 'class'],
+      [/^\s*(?:(?:public|private|protected|internal|static|async|override)\s+)+[\w<>\[\],\s]+\s+([A-Za-z_]\w*)\s*\([^;]*\)\s*\{/, 'method'],
+    ],
+  },
+  {
+    ext: /\.php$/i,
+    lines: [
+      [/^\s*(?:abstract\s+)?class\s+([A-Za-z_]\w*)/i, 'class'],
+      [/^\s*(?:(?:public|private|protected|static)\s+)*function\s+([A-Za-z_]\w*)/i, 'function'],
+    ],
+  },
+  {
+    ext: /\.rb$/i,
+    lines: [
+      [/^\s*def\s+(?:self\.)?([A-Za-z_]\w*[?!]?)/, 'function'],
+      [/^\s*(?:class|module)\s+([A-Z]\w*)/, 'class'],
+    ],
+  },
+];
+
+function rulesFor(file) {
+  for (const r of RULES) if (r.ext.test(file)) return r;
+  return null;
+}
+
+/* tek dosyadan sembolleri çıkar: [{ line, kind, name }] */
+function extractSymbols(file, src) {
+  const rule = rulesFor(file);
+  if (!rule) return [];
+  const out = [];
+  const lines = src.split('\n');
+  for (let i = 0; i < lines.length && i < 20000; i++) {
+    const line = lines[i];
+    if (line.length > 500) continue;
+    for (const [re, kind] of rule.lines) {
+      const m = line.match(re);
+      if (!m) continue;
+      const name = m[1];
+      if (rule.methodKw && rule.methodKw.test(name)) break; /* if/for/while... yakalama */
+      out.push({ line: i + 1, kind: kind === 'method' ? 'method' : kind, name });
+      break;
+    }
+  }
+  return out;
+}
+
+/* dizin yürüyüşü (kod dosyaları) — walkFiles'tan bağımsız: SKIP_DIRS +
+   gizli klasör atlar, dosya sayısı tavanlı */
+function walk(root, cb, state, depth = 0) {
+  if (depth > 20) return;
+  let entries = [];
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    if (state.files >= state.maxFiles) return;
+    const full = path.join(root, e.name);
+    if (e.isDirectory()) {
+      if (SKIP_DIRS.has(e.name) || (e.name.startsWith('.') && e.name !== '.github')) continue;
+      walk(full, cb, state, depth + 1);
+    } else if (e.isFile()) {
+      if (!rulesFor(e.name)) continue;
+      state.files++;
+      cb(full);
+    }
+  }
+}
+
+function readSymbols(full) {
+  try {
+    const st = fs.statSync(full);
+    if (st.size > MAX_FILE_BYTES) return [];
+    return extractSymbols(full, fs.readFileSync(full, 'utf8'));
+  } catch {
+    return [];
+  }
+}
+
+/* ---------- repo_symbols ---------- */
+async function repoSymbols(args, ctx) {
+  const root = path.resolve(String((ctx && ctx.cwd) || '.'), String(args.path || '.'));
+  if (!fs.existsSync(root)) return { ok: false, error: 'yol bulunamadı: ' + root };
+  const query = String(args.query || '').trim();
+  let re = null;
+  if (/^\/.+\/[a-z]*$/i.test(query)) {
+    try { re = new RegExp(query.slice(1, query.lastIndexOf('/')), query.slice(query.lastIndexOf('/') + 1)); } catch {}
+  }
+  const needle = query.toLowerCase();
+  const kindF = ['function', 'class', 'method'].includes(String(args.kind)) ? String(args.kind) : null;
+  const limit = Math.min(500, Math.max(1, Math.floor(Number(args.limit) || 100)));
+
+  const state = { files: 0, maxFiles: 4000 };
+  const hits = [];
+  let scanned = 0;
+  walk(root, (full) => {
+    scanned++;
+    const syms = readSymbols(full);
+    for (const s of syms) {
+      if (kindF && s.kind !== kindF) continue;
+      if (query) {
+        const match = re ? re.test(s.name) : s.name.toLowerCase().includes(needle);
+        if (!match) continue;
+      }
+      hits.push({ file: path.relative(root, full).replace(/\\/g, '/'), line: s.line, kind: s.kind, name: s.name });
+    }
+  }, state);
+  hits.sort((a, b) => (a.file < b.file ? -1 : a.file > b.file ? 1 : a.line - b.line));
+  return {
+    ok: true,
+    ...(query ? { query } : {}),
+    root: path.basename(root) || root,
+    scannedFiles: scanned,
+    total: hits.length,
+    results: hits.slice(0, limit),
+    ...(hits.length > limit ? { note: `ilk ${limit} sonuç — limit'i artır ya da query daralt` } : {}),
+    ...(!hits.length && !query ? { note: 'query ver: fonksiyon/sınıf adı, "login" gibi ya da /regex/ biçiminde' } : {}),
+  };
+}
+
+/* ---------- repo_map ---------- */
+async function repoMap(args, ctx) {
+  const root = path.resolve(String((ctx && ctx.cwd) || '.'), String(args.path || '.'));
+  if (!fs.existsSync(root)) return { ok: false, error: 'yol bulunamadı: ' + root };
+  const maxFiles = Math.min(2000, Math.max(10, Math.floor(Number(args.max_files) || 300)));
+  const perFile = Math.min(30, Math.max(1, Math.floor(Number(args.max_symbols_per_file) || 10)));
+
+  const state = { files: 0, maxFiles };
+  const entries = [];
+  let truncated = false;
+  walk(root, (full) => {
+    if (entries.length >= maxFiles) {
+      truncated = true;
+      return;
+    }
+    const syms = readSymbols(full);
+    const rel = path.relative(root, full).replace(/\\/g, '/');
+    if (!syms.length) {
+      entries.push({ file: rel, symbols: [] });
+      return;
+    }
+    const groups = { class: [], function: [], method: [] };
+    for (const s of syms) {
+      if (groups[s.kind] && groups[s.kind].length < perFile) groups[s.kind].push(s.name);
+    }
+    entries.push({
+      file: rel,
+      symbols: [
+        ...groups.class.map((n) => 'class ' + n),
+        ...groups.function.map((n) => n + '()'),
+        ...(groups.method.length ? [groups.method.length + ' method'] : []),
+      ],
+      ...(syms.length > perFile * 2 ? { more: syms.length - perFile } : {}),
+    });
+  }, state);
+  entries.sort((a, b) => (a.file < b.file ? -1 : 1));
+  return {
+    ok: true,
+    root: path.basename(root) || root,
+    totalFiles: entries.length,
+    ...(truncated ? { truncated: true, note: `max_files=${maxFiles} — daha büyük harita için artır` } : {}),
+    files: entries,
+  };
+}
+
+const definitions = [
+  {
+    type: 'function',
+    function: {
+      name: 'repo_map',
+      description:
+        'Lightweight repo overview (no LSP): walks code files and lists each file with its top-level symbols (classes, functions). Use to orient yourself in an unfamiliar project or to pick the right file before reading it. Heavy dirs (node_modules, dist, .git…) are skipped.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Repo/subdirectory root (default: workspace)' },
+          max_files: { type: 'number', description: 'Max files in the map (default 300, max 2000)' },
+          max_symbols_per_file: { type: 'number', description: 'Max symbols listed per file (default 10)' },
+        },
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'repo_symbols',
+      description:
+        'Find where a function/class/method is DEFINED across the repo (lightweight LSP). Query matches symbol names case-insensitively; "/regex/" form is also accepted. Returns file:line locations. Much cheaper than grep when looking for definitions.',
+      parameters: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'Symbol name substring, or /regex/ — empty lists everything (capped)' },
+          kind: { type: 'string', enum: ['function', 'class', 'method'], description: 'Filter by symbol kind' },
+          path: { type: 'string', description: 'Repo/subdirectory root (default: workspace)' },
+          limit: { type: 'number', description: 'Max results (default 100, max 500)' },
+        },
+      },
+    },
+  },
+];
+
+module.exports = { definitions, handlers: { repo_map: repoMap, repo_symbols: repoSymbols }, extractSymbols, rulesFor };

package/src/agent/tools.js

@@ -8,6 +8,9 @@ const { execFile } = require('child_process');
 const { spawn } = require('child_process');
 const research = require('./research');
 const searxng = require('./searxng');
+const gittools = require('./gittools');
+const repomap = require('./repomap');
+const xlsxtools = require('./xlsxtools');
 
 const MAX_CMD_OUTPUT = 16000;
 const MAX_FILE_CHARS = 200000;
@@ -1465,6 +1468,10 @@ function readCacheDrop(abs) {
 }
 
 const definitions = [
+  /* yerleşik modül araçları: git, repo haritası, excel */
+  ...gittools.definitions,
+  ...repomap.definitions,
+  ...xlsxtools.definitions,
   {
     type: 'function',
     function: {
@@ -1714,6 +1721,15 @@ const definitions = [
 
 async function exec(name, args, ctx) {
   const cwd = ctx.cwd;
+  /* modül araçları: gittools / repomap / xlsxtools — kendi handler'larında */
+  const modHandler = gittools.handlers[name] || repomap.handlers[name] || xlsxtools.handlers[name];
+  if (modHandler) {
+    try {
+      return JSON.stringify(await modHandler(args, ctx));
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: String((e && e.message) || e) });
+    }
+  }
   try {
     switch (name) {
       case 'run_command': {