feat(review): 5-file batching, BulkRead tool, label/timeout fixes

Align the headless agent review with the backend's pragent-based
flow (which now batches up to 5 files per session and exposes
Read/Grep/Glob/LS/BulkRead).

- splitIntoPerFileRequests: group files in chunks of 5 per agent
  session instead of 1, matching pragent's MAX_FILES_PER_BATCH.
  Concatenate diffs + merge file_contents per batch.
- reviewHeadless: per-batch loop; pass file_path/file_content only
  on single-file batches (multi-file batches let the agent gather
  per-file context via tools). Progress messages report actual file
  counts, not batch counts.
- Preserve generator labels through the reflector by matching
  reflector issue_content to generator one_sentence_summary
  (pragent's primary smart_match_feedback strategy).
- BulkRead tool handler (mirrors backend pragent llm_tools), plus
  /workspace/ prefix stripping in the dispatcher so the agent's
  absolute-path tool calls resolve to the CLI's relative-cwd model.
- fetchApi: undici Agent with 60s connect timeout + transient-error
  retry. Default 10s connect timeout caused UND_ERR_CONNECT_TIMEOUT
  during cold-start TLS handshakes under burst review load.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Chhinna

changelog.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## [0.5.1] - 31/05/2026
+- AI code review increasing coverage
+
 ## [0.4.12] - 19/05/2026
 - Settings added
 

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "codeant-cli",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Code review CLI tool",
   "type": "module",
   "bin": {
@@ -52,6 +52,7 @@
     "posthog-node": "^5.28.5",
     "react": "^18.3.1",
     "smol-toml": "^1.6.1",
+    "undici": "^6.26.0",
     "zod": "^3.25.76"
   },
   "devDependencies": {

package.json

@@ -125,27 +125,34 @@ export async function runReviewHeadless(options = {}) {
     // ── Split into per-file requests ────────────────────────────────────
     const perFileRequests = ReviewApiHelper.splitIntoPerFileRequests(requestBody);
 
-    onProgress(`Analyzing ${perFileRequests.length} file${perFileRequests.length !== 1 ? 's' : ''} in parallel...`);
+    const totalFiles = perFileRequests.reduce((n, r) => n + (r._filenames?.length || 0), 0);
+    onProgress(`Analyzing ${totalFiles} file${totalFiles !== 1 ? 's' : ''}...`);
 
-    // ── Per-file agent turn loops (parallel, fault-tolerant) ─────────────
+    // ── Per-batch agent turn loops (parallel, fault-tolerant) ────────────
+    // Each batch covers up to 5 files; backend reviews the multi-file diff
+    // in a single session (matches pragent's FileBatcher).
     const perFileResults = await Promise.all(
       perFileRequests.map(async (fileReq) => {
-        const filename = fileReq._filename;
-        delete fileReq._filename;
-
-        if (fileReq.file_contents?.[filename]) {
-          fileReq.file_content = fileReq.file_contents[filename];
-          fileReq.file_path = filename;
+        const filenames = fileReq._filenames || [];
+        delete fileReq._filenames;
+        const label = filenames.join(', ');
+
+        // Single-file batch: still pass file_content/file_path so backend can
+        // build head_file_str. Multi-file batches drop these (head_file_str
+        // becomes empty; agent gathers context via tools instead).
+        if (filenames.length === 1 && fileReq.file_contents?.[filenames[0]]) {
+          fileReq.file_content = fileReq.file_contents[filenames[0]];
+          fileReq.file_path = filenames[0];
         }
         delete fileReq.file_contents;
 
         try {
-          onProgress(`Reviewing ${filename}...`);
+          onProgress(`Reviewing ${label}...`);
           const result = await runTurnLoop(fileReq, gitRoot, false);
-          onProgress(`Done reviewing ${filename}`);
+          onProgress(`Done reviewing ${label}`);
           return result;
         } catch (err) {
-          console.error(`[error] Failed to review ${filename}: ${err.message}`);
+          console.error(`[error] Failed to review ${label}: ${err.message}`);
           return { finalMessage: null, finalOutput: null };
         }
       })
@@ -158,7 +165,12 @@ export async function runReviewHeadless(options = {}) {
       output: perFileResults[i].finalOutput,
     })).filter(r => r.output?.code_suggestions?.length > 0);
 
-    onProgress(`${perFileWithSuggestions.length} file(s) have suggestions, running reflector...`);
+    const filesWithSuggestions = new Set(
+      perFileWithSuggestions.flatMap(r =>
+        (r.output?.code_suggestions || []).map(s => (s.relevant_file || '').trim()).filter(Boolean)
+      )
+    ).size;
+    onProgress(`${filesWithSuggestions} file${filesWithSuggestions !== 1 ? 's' : ''} have suggestions, running reflector...`);
 
     // ── Per-file reflector loops (parallel, fault-tolerant) ──────────────
     const reflectorResults = await Promise.all(
@@ -180,15 +192,34 @@ export async function runReviewHeadless(options = {}) {
       })
     );
 
-    // ── Parse results ───────────────────────────────────────────────────
-    const issues = reflectorResults.flatMap(r =>
-      (r.finalOutput?.code_suggestions || []).map((issue) => ({
+    // ── Parse results, carrying generator labels through reflector ──────
+    // Pragent's rejector schema drops `label`; preserve it by matching the
+    // reflector's per-issue (file, start_line) back to the generator's output.
+    const issues = reflectorResults.flatMap((r, i) => {
+      const genSuggestions = perFileWithSuggestions[i]?.output?.code_suggestions || [];
+      const norm = (v) => (typeof v === 'string' ? v.trim() : v);
+      const labelFor = (issue) => {
+        if (norm(issue.label)) return norm(issue.label);
+        // Match by summary (pragent's primary strategy): rejector's
+        // suggestion_summary (renamed to issue_content server-side) is
+        // "Repeated from the input" — i.e. the generator's one_sentence_summary.
+        const summary = norm(issue.issue_content);
+        if (summary) {
+          const exact = genSuggestions.find(g => norm(g.one_sentence_summary) === summary);
+          if (norm(exact?.label)) return norm(exact.label);
+        }
+        // Fallback: first generator suggestion in the same file with a label.
+        const file = norm(issue.relevant_file);
+        const sameFile = genSuggestions.find(g => norm(g.relevant_file) === file && norm(g.label));
+        return norm(sameFile?.label) || 'Code Quality';
+      };
+      return (r.finalOutput?.code_suggestions || []).map((issue) => ({
         issue_content: issue.issue_content || '',
         relevant_file: issue.relevant_file || 'Unknown',
         start_line: issue.start_line || 0,
-        label: issue.label || 'Code Quality',
-      }))
-    );
+        label: labelFor(issue),
+      }));
+    });
 
     const labelCounts = {};
     for (const i of issues) { labelCounts[i.label] = (labelCounts[i.label] || 0) + 1; }

src/reviewHeadless.js

@@ -0,0 +1,20 @@
+import { readTool } from './readTool.js';
+
+const MAX_FILES = 10;
+
+export async function bulkReadTool(args, cwd) {
+  const files = Array.isArray(args.files) ? args.files.slice(0, MAX_FILES) : [];
+  if (!files.length) return 'Error: BulkRead requires a non-empty `files` array';
+
+  const parts = await Promise.all(
+    files.map(async (f) => {
+      try {
+        const content = await readTool(f, cwd);
+        return `===== ${f.file_path} =====\n${content}`;
+      } catch (err) {
+        return `===== ${f.file_path} =====\nError: ${err.message}`;
+      }
+    })
+  );
+  return parts.join('\n\n');
+}

src/tools/bulkReadTool.js

@@ -2,28 +2,41 @@ import { readTool } from './readTool.js';
 import { globTool } from './globTool.js';
 import { grepTool } from './grepTool.js';
 import { lsTool } from './lsTool.js';
+import { bulkReadTool } from './bulkReadTool.js';
 
-export async function executeTool(toolCall, cwd) {
-  const { name, args } = toolCall;
-
-  try {
-    if (name === 'Read') {
-      return await readTool(args, cwd);
-    }
+// Pragent prompts instruct the model to use absolute paths rooted at /workspace.
+// The CLI works relative to the user's cwd, so strip that prefix (and any other
+// leading slash) before handing off to the tool implementations.
+function stripWorkspace(p) {
+  if (typeof p !== 'string') return p;
+  return p.replace(/^\/workspace\/?/, '').replace(/^\/+/, '');
+}
 
-    if (name === 'Glob') {
-      return await globTool(args, cwd);
-    }
+function normalizeArgs(args) {
+  if (!args || typeof args !== 'object') return args;
+  const out = { ...args };
+  if ('file_path' in out) out.file_path = stripWorkspace(out.file_path);
+  if ('path' in out) out.path = stripWorkspace(out.path);
+  if (Array.isArray(out.files)) {
+    out.files = out.files.map((f) =>
+      f && typeof f === 'object' ? { ...f, file_path: stripWorkspace(f.file_path) } : f
+    );
+  }
+  return out;
+}
 
-    if (name === 'Grep') {
-      return await grepTool(args, cwd);
-    }
+export async function executeTool(toolCall, cwd) {
+  const { name } = toolCall;
+  const args = normalizeArgs(toolCall.args);
 
-    if (name === 'LS') {
-      return await lsTool(args, cwd);
-    }
+  try {
+    if (name === 'Read') return await readTool(args, cwd);
+    if (name === 'Glob') return await globTool(args, cwd);
+    if (name === 'Grep') return await grepTool(args, cwd);
+    if (name === 'LS') return await lsTool(args, cwd);
+    if (name === 'BulkRead') return await bulkReadTool(args, cwd);
 
-    // Bash tool intentionally removed to prevent arbitrary command execution
+    // Bash intentionally not supported — see Extension/AgenticReview/tools.py.
     return `Unknown tool: ${name}`;
   } catch (err) {
     return `Error: ${err.message}`;

src/tools/executeTool.js

@@ -1,6 +1,28 @@
+import { Agent, setGlobalDispatcher } from 'undici';
 import { getConfigValue } from './config.js';
 import { getBaseUrl } from './baseUrl.js';
 
+// Undici's default TCP connect timeout (10s) is too short for cold-start
+// Lambda / API-Gateway TLS handshakes under burst load (the headless review
+// fan-outs 8 requests at once). Bump to 60s globally + retry on transient
+// network errors so cold starts don't break the run.
+setGlobalDispatcher(
+  new Agent({
+    connect: { timeout: 60_000 },
+    connections: 32,
+  })
+);
+
+const RETRYABLE_CAUSES = new Set([
+  'UND_ERR_CONNECT_TIMEOUT',
+  'UND_ERR_SOCKET',
+  'ECONNRESET',
+  'ETIMEDOUT',
+  'ENOTFOUND',
+]);
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
 const fetchApi = async (endpoint, method = 'GET', body = null) => {
   const url = endpoint.startsWith('http') ? endpoint : `${getBaseUrl()}${endpoint}`;
 
@@ -21,25 +43,39 @@ const fetchApi = async (endpoint, method = 'GET', body = null) => {
     options.body = JSON.stringify(body);
   }
 
-  try {
-    const response = await fetch(url, options);
-    console.error('API Response Status:', response.status);
+  // Retry transient network/cold-start failures up to 2 times.
+  const MAX_ATTEMPTS = 3;
+  let lastErr;
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    try {
+      const response = await fetch(url, options);
+      console.error('API Response Status:', response.status);
 
-    if (response.status === 403) {
-      throw new Error('Access denied (403). Please run `codeant logout` and then `codeant login` to re-authenticate.');
-    }
+      if (response.status === 403) {
+        throw new Error('Access denied (403). Please run `codeant logout` and then `codeant login` to re-authenticate.');
+      }
 
-    const data = await response.json();
+      const data = await response.json();
 
-    if (!response.ok) {
-      throw new Error(data.message || `HTTP error ${response.status}`);
-    }
+      if (!response.ok) {
+        throw new Error(data.message || `HTTP error ${response.status}`);
+      }
 
-    return data;
-  } catch (err) {
-    console.error(`API Error: ${err.message}`);
-    throw err;
+      return data;
+    } catch (err) {
+      lastErr = err;
+      const cause = err?.cause?.code || err?.cause?.message || err?.cause || '';
+      const retryable = RETRYABLE_CAUSES.has(err?.cause?.code) && attempt < MAX_ATTEMPTS;
+      if (retryable) {
+        console.error(`API Retry ${attempt}/${MAX_ATTEMPTS - 1} after ${cause}`);
+        await sleep(1000 * attempt);
+        continue;
+      }
+      console.error(`API Error: ${err.message}${cause ? ` (cause: ${cause})` : ''}`);
+      throw err;
+    }
   }
+  throw lastErr;
 };
 
 export { fetchApi };

src/utils/fetchApi.js

@@ -265,33 +265,39 @@ class ReviewApiHelper extends CommonApiHelper {
   }
 
   /**
-   * Split a combined review request into per-file payloads.
-   * Each payload has a single file's diff and content.
+   * Split a combined review request into batched payloads.
+   * Files are grouped in chunks of up to FILES_PER_BATCH so each backend
+   * session reviews multiple files at once (matches pragent's batching).
    */
-  static splitIntoPerFileRequests(requestBody) {
+  static splitIntoPerFileRequests(requestBody, batchSize = 5) {
     if (!requestBody?.diff_content?.length) return [];
 
     const fileSections = requestBody.diff_content.split(/(?=^diff --git )/m).filter(Boolean);
-    const perFileRequests = [];
+    const perFile = [];
 
     for (const section of fileSections) {
       const nameMatch = section.match(/^diff --git a\/.+ b\/(.+)$/m);
       if (!nameMatch) continue;
-      const filename = nameMatch[1];
+      perFile.push({ section, filename: nameMatch[1] });
+    }
 
+    const batches = [];
+    for (let i = 0; i < perFile.length; i += batchSize) {
+      const slice = perFile.slice(i, i + batchSize);
       const fileContents = {};
-      if (requestBody.file_contents?.[filename]) {
-        fileContents[filename] = requestBody.file_contents[filename];
+      for (const { filename } of slice) {
+        if (requestBody.file_contents?.[filename]) {
+          fileContents[filename] = requestBody.file_contents[filename];
+        }
       }
-
-      perFileRequests.push({
-        diff_content: section,
+      batches.push({
+        diff_content: slice.map((f) => f.section).join(''),
         file_contents: fileContents,
-        _filename: filename,
+        _filenames: slice.map((f) => f.filename),
       });
     }
 
-    return perFileRequests;
+    return batches;
   }
 }