agentsys 5.0.1 → 5.0.3

package/lib/collectors/github.js

@@ -14,6 +14,7 @@ const { execFileSync } = require('child_process');
 const DEFAULT_OPTIONS = {
   issueLimit: 100,
   prLimit: 50,
+  milestoneLimit: 100,
   timeout: 10000,
   cwd: process.cwd()
 };
@@ -25,16 +26,41 @@ const DEFAULT_OPTIONS = {
  * @returns {Object|null} Parsed JSON result or null
  */
 function execGh(args, options = {}) {
+  const result = execGhWithResult(args, options);
+  return result.ok ? result.data : null;
+}
+
+function execGhWithResult(args, options = {}) {
   try {
-    const result = execFileSync('gh', args, {
+    const output = execFileSync('gh', args, {
       encoding: 'utf8',
       stdio: 'pipe',
       timeout: options.timeout || DEFAULT_OPTIONS.timeout,
       cwd: options.cwd || DEFAULT_OPTIONS.cwd
     });
-    return JSON.parse(result);
-  } catch {
-    return null;
+
+    try {
+      return { ok: true, data: JSON.parse(output) };
+    } catch (error) {
+      return {
+        ok: false,
+        error: {
+          type: 'parse',
+          message: `Failed to parse gh output as JSON: ${error.message}`,
+          raw: output.slice(0, 500)
+        }
+      };
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      error: {
+        type: error.killed ? 'timeout' : 'process',
+        message: error.message,
+        exitCode: error.status ?? null,
+        stderr: error.stderr ? String(error.stderr).trim() : ''
+      }
+    };
   }
 }
 
@@ -192,10 +218,18 @@ function scanGitHubState(options = {}) {
 
   const result = {
     available: false,
+    partial: false,
+    errors: [],
     summary: { issueCount: 0, prCount: 0, milestoneCount: 0 },
     issues: [],
     prs: [],
     milestones: [],
+    overdueMilestones: [],
+    pagination: {
+      issues: { requestedLimit: opts.issueLimit, fetchedCount: 0, hasMore: false },
+      prs: { requestedLimit: opts.prLimit, fetchedCount: 0, hasMore: false },
+      milestones: { requestedLimit: opts.milestoneLimit, fetchedCount: 0, hasMore: false }
+    },
     categorized: { bugs: [], features: [], security: [], enhancements: [], other: [] },
     stale: [],
     themes: []
@@ -209,44 +243,74 @@ function scanGitHubState(options = {}) {
   result.available = true;
 
   // Fetch open issues
-  const issues = execGh([
+  const issuesResult = execGhWithResult([
     'issue', 'list',
     '--state', 'open',
     '--json', 'number,title,labels,milestone,createdAt,updatedAt,body',
     '--limit', String(opts.issueLimit)
   ], opts);
 
-  if (issues) {
+  if (issuesResult.ok && Array.isArray(issuesResult.data)) {
+    const issues = issuesResult.data;
     result.issues = issues.map(summarizeIssue);
     result.summary.issueCount = issues.length;
+    result.pagination.issues.fetchedCount = issues.length;
+    result.pagination.issues.hasMore = opts.issueLimit > 0 && issues.length >= opts.issueLimit;
     categorizeIssues(result, issues);
     findStaleItems(result, issues, 90);
     extractThemes(result, issues);
+  } else if (!issuesResult.ok) {
+    result.errors.push({ source: 'issues', ...issuesResult.error });
   }
 
   // Fetch open PRs with files changed
-  const prs = execGh([
+  const prsResult = execGhWithResult([
     'pr', 'list',
     '--state', 'open',
     '--json', 'number,title,labels,isDraft,createdAt,updatedAt,body,files',
     '--limit', String(opts.prLimit)
   ], opts);
 
-  if (prs) {
+  if (prsResult.ok && Array.isArray(prsResult.data)) {
+    const prs = prsResult.data;
     result.prs = prs.map(summarizePR);
     result.summary.prCount = prs.length;
+    result.pagination.prs.fetchedCount = prs.length;
+    result.pagination.prs.hasMore = opts.prLimit > 0 && prs.length >= opts.prLimit;
+  } else if (!prsResult.ok) {
+    result.errors.push({ source: 'prs', ...prsResult.error });
   }
 
   // Fetch milestones
-  const milestones = execGh([
+  const milestonesResult = execGhWithResult([
     'api', 'repos/{owner}/{repo}/milestones',
-    '--jq', '.[].{title,state,due_on,open_issues,closed_issues}'
+    '--paginate',
+    '--slurp'
   ], opts);
 
-  if (milestones) {
-    result.milestones = Array.isArray(milestones) ? milestones : [milestones];
+  if (milestonesResult.ok && Array.isArray(milestonesResult.data)) {
+    const pages = milestonesResult.data;
+    const allMilestones = pages.flatMap(page => Array.isArray(page) ? page : []);
+    const mappedMilestones = allMilestones.map((milestone) => ({
+      title: milestone.title,
+      state: milestone.state,
+      due_on: milestone.due_on,
+      open_issues: milestone.open_issues,
+      closed_issues: milestone.closed_issues
+    }));
+
+    result.pagination.milestones.fetchedCount = mappedMilestones.length;
+    result.pagination.milestones.hasMore = opts.milestoneLimit > 0 && mappedMilestones.length > opts.milestoneLimit;
+    result.milestones = mappedMilestones.slice(0, opts.milestoneLimit);
     result.summary.milestoneCount = result.milestones.length;
     findOverdueMilestones(result);
+  } else if (!milestonesResult.ok) {
+    result.errors.push({ source: 'milestones', ...milestonesResult.error });
+  }
+
+  result.partial = result.errors.length > 0;
+  if (result.partial && !result.error) {
+    result.error = 'Partial GitHub data collected';
   }
 
   return result;

package/lib/perf/benchmark-runner.js

@@ -4,8 +4,9 @@
  * @module lib/perf/benchmark-runner
  */
 
-const { execSync } = require('child_process');
+const { execFileSync } = require('child_process');
 const { validateBaseline } = require('./schemas');
+const { parseCommand, resolveExecutableForPlatform } = require('../utils/command-parser');
 
 const DEFAULT_MIN_DURATION = 60;
 const BINARY_SEARCH_MIN_DURATION = 30;
@@ -55,6 +56,8 @@ function runBenchmark(command, options = {}) {
     throw new Error('Benchmark command must be a non-empty string');
   }
 
+  const parsedCommand = parseCommand(command, 'Benchmark command');
+  const executable = resolveExecutableForPlatform(parsedCommand.executable);
   const normalized = normalizeBenchmarkOptions(options);
   const setDurationEnv = options.setDurationEnv !== false;
   const env = {
@@ -71,18 +74,20 @@ function runBenchmark(command, options = {}) {
   const start = Date.now();
   let output;
   try {
-    output = execSync(command, {
+    output = execFileSync(executable, parsedCommand.args, {
       stdio: 'pipe',
       encoding: 'utf8',
-      env
+      env,
+      windowsHide: true,
+      cwd: options.cwd || process.cwd()
     });
   } catch (error) {
-    const stderr = error.stderr ? error.stderr.toString().trim() : '';
-    const stdout = error.stdout ? error.stdout.toString().trim() : '';
+    const stderr = error.stderr ? String(error.stderr).trim() : '';
+    const stdout = error.stdout ? String(error.stdout).trim() : '';
     const exitCode = error.status ?? 'unknown';
     const details = stderr || stdout || error.message || 'No error details available';
     throw new Error(
-      `Benchmark command failed (exit code ${exitCode}): ${command}\n` +
+      `Benchmark command failed (exit code ${exitCode}): ${parsedCommand.display}\n` +
       `Details: ${details}`
     );
   }

package/lib/perf/investigation-state.js

@@ -14,12 +14,12 @@ const crypto = require('crypto');
 const { getStateDir } = require('../platform/state-dir');
 const { validateInvestigationState, assertValid } = require('./schemas');
 const { writeJsonAtomic, writeFileAtomic } = require('../utils/atomic-write');
+const { isPlainObject, updatesApplied, sleepForRetry } = require('../utils/state-helpers');
 
 const SCHEMA_VERSION = 1;
 const INVESTIGATION_FILE = 'investigation.json';
 const LOG_DIR = 'investigations';
 const BASELINE_DIR = 'baselines';
-
 const PHASES = [
   'setup',
   'baseline',
@@ -196,10 +196,12 @@ function writeInvestigation(state, basePath = process.cwd()) {
  * @returns {object|null}
  */
 function updateInvestigation(updates, basePath = process.cwd()) {
-  const MAX_RETRIES = 3;
+  const MAX_RETRIES = 5;
+  let fallbackState = null;
 
   for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
     const current = readInvestigation(basePath) || {};
+    fallbackState = current;
     const initialVersion = current._version || 0;
     const nextState = { ...current };
 
@@ -209,10 +211,7 @@ function updateInvestigation(updates, basePath = process.cwd()) {
 
       if (value === null) {
         nextState[key] = null;
-      } else if (
-        value && typeof value === 'object' && !Array.isArray(value) &&
-        nextState[key] && typeof nextState[key] === 'object' && !Array.isArray(nextState[key])
-      ) {
+      } else if (isPlainObject(value) && isPlainObject(nextState[key])) {
         nextState[key] = { ...nextState[key], ...value };
       } else {
         nextState[key] = value;
@@ -226,23 +225,23 @@ function updateInvestigation(updates, basePath = process.cwd()) {
 
     // Re-read to verify our write succeeded
     const afterWrite = readInvestigation(basePath);
-    if (afterWrite && afterWrite._version === initialVersion + 1) {
+    if (afterWrite) {
+      fallbackState = afterWrite;
+    }
+    if (afterWrite && afterWrite._version >= initialVersion + 1 && updatesApplied(afterWrite, updates)) {
       return afterWrite; // Success
     }
 
     // Version conflict - retry after brief delay
     if (attempt < MAX_RETRIES - 1) {
       const delay = Math.floor(Math.random() * 50) + 10;
-      const start = Date.now();
-      while (Date.now() - start < delay) {
-        // Busy wait (synchronous delay)
-      }
+      sleepForRetry(delay);
     }
   }
 
   // All retries exhausted
-  console.error('[WARN] updateInvestigation: max retries exceeded, possible version conflict');
-  return readInvestigation(basePath);
+  console.error('[ERROR] updateInvestigation: failed to apply updates after max retries');
+  return readInvestigation(basePath) || fallbackState || { ...updates };
 }
 
 /**

package/lib/perf/profiling-runner.js

@@ -4,8 +4,9 @@
  * @module lib/perf/profiling-runner
  */
 
-const { execSync } = require('child_process');
+const { execFileSync } = require('child_process');
 const profilers = require('./profilers');
+const { parseCommand, resolveExecutableForPlatform } = require('../utils/command-parser');
 
 /**
  * Run a profiling command and return artifacts/hotspots metadata.
@@ -16,6 +17,9 @@ const profilers = require('./profilers');
  */
 function runProfiling(options = {}) {
   const repoPath = options.repoPath || process.cwd();
+  const timeoutMs = Number.isFinite(options.timeoutMs)
+    ? Math.max(1, Math.floor(options.timeoutMs))
+    : null;
   const profiler = profilers.selectProfiler(repoPath);
 
   if (!profiler || typeof profiler.buildCommand !== 'function') {
@@ -27,14 +31,29 @@ function runProfiling(options = {}) {
     output: options.output,
     ...(options.profileOptions || {})
   });
+  const parsedCommand = parseCommand(command, 'Profiling command');
+  const executable = resolveExecutableForPlatform(parsedCommand.executable);
   const env = {
     ...process.env,
     ...(options.env || {})
   };
   try {
-    execSync(command, { stdio: 'pipe', env });
+    const execOptions = {
+      stdio: 'pipe',
+      env,
+      cwd: repoPath,
+      windowsHide: true
+    };
+    if (timeoutMs !== null) {
+      execOptions.timeout = timeoutMs;
+    }
+
+    execFileSync(executable, parsedCommand.args, execOptions);
   } catch (error) {
-    return { ok: false, error: error.message };
+    const stderr = error.stderr ? String(error.stderr).trim() : '';
+    const stdout = error.stdout ? String(error.stdout).trim() : '';
+    const details = stderr || stdout || error.message;
+    return { ok: false, error: `Profiling command failed: ${details}` };
   }
 
   const parsed = typeof profiler.parseOutput === 'function'
@@ -43,7 +62,7 @@ function runProfiling(options = {}) {
 
   const result = {
     tool: profiler.id,
-    command,
+    command: parsedCommand.display,
     hotspots: parsed.hotspots || [],
     artifacts: parsed.artifacts || []
   };

package/lib/repo-map/concurrency.js

@@ -0,0 +1,29 @@
+'use strict';
+
+async function runWithConcurrency(items, limit, worker) {
+  if (!Array.isArray(items) || items.length === 0) {
+    return [];
+  }
+
+  const maxConcurrency = Math.max(1, Math.min(items.length, Math.floor(limit) || 1));
+  const results = new Array(items.length);
+  let cursor = 0;
+
+  async function runWorker() {
+    while (true) {
+      const index = cursor;
+      cursor += 1;
+      if (index >= items.length) {
+        return;
+      }
+      results[index] = await worker(items[index], index);
+    }
+  }
+
+  await Promise.all(Array.from({ length: maxConcurrency }, () => runWorker()));
+  return results;
+}
+
+module.exports = {
+  runWithConcurrency
+};