agentsys 5.0.3 → 5.1.0

package/plugins/debate/lib/platform/verify-tools.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+/**
+ * Tool Verification System
+ * Checks availability and versions of development tools for graceful degradation
+ *
+ * Usage: node lib/platform/verify-tools.js
+ * Output: JSON with tool availability and versions
+ *
+ * @author Avi Fenesh
+ * @license MIT
+ */
+
+const { spawn } = require('child_process');
+
+// Detect Windows platform
+const isWindows = process.platform === 'win32';
+
+/**
+ * Checks if a tool is available and returns its version
+ * Uses safe execution methods to avoid shell injection vulnerabilities
+ * @param {string} command - Command to check (e.g., 'git', 'node')
+ * @param {string} versionFlag - Flag to get version (default: '--version')
+ * @returns {Promise<Object>} { available: boolean, version: string|null }
+ */
+function checkTool(command, versionFlag = '--version') {
+  return new Promise((resolve) => {
+    // Validate command contains only safe characters (alphanumeric, underscore, hyphen)
+    if (!/^[a-zA-Z0-9_-]+$/.test(command)) {
+      return resolve({ available: false, version: null });
+    }
+    // Validate versionFlag contains only safe characters
+    if (!/^[a-zA-Z0-9_-]+$/.test(versionFlag)) {
+      return resolve({ available: false, version: null });
+    }
+
+    let child;
+
+    if (isWindows) {
+      // On Windows, spawn shell directly with command as single argument
+      child = spawn('cmd.exe', ['/c', command, versionFlag], {
+        stdio: ['pipe', 'pipe', 'ignore'],
+        windowsHide: true
+      });
+    } else {
+      // On Unix, spawn directly without shell
+      child = spawn(command, [versionFlag], {
+        stdio: ['pipe', 'pipe', 'ignore']
+      });
+    }
+
+    let stdout = '';
+
+    // Set timeout
+    const timeout = setTimeout(() => {
+      child.kill();
+      resolve({ available: false, version: null });
+    }, 5000);
+
+    child.stdout.on('data', (data) => {
+      try {
+        stdout += data.toString();
+      } catch {
+        // Ignore data conversion errors - will result in empty/partial version string
+      }
+    });
+
+    child.on('error', () => {
+      clearTimeout(timeout);
+      resolve({ available: false, version: null });
+    });
+
+    child.on('close', (code) => {
+      clearTimeout(timeout);
+      if (code !== 0) {
+        return resolve({ available: false, version: null });
+      }
+      const version = stdout.trim().split('\n')[0];
+      resolve({ available: true, version });
+    });
+  });
+}
+
+/**
+ * Tool definitions with their version flags
+ */
+const TOOL_DEFINITIONS = [
+  // Version control
+  { name: 'git', flag: '--version' },
+  { name: 'gh', flag: '--version' },
+
+  // Node.js ecosystem
+  { name: 'node', flag: '--version' },
+  { name: 'npm', flag: '--version' },
+  { name: 'pnpm', flag: '--version' },
+  { name: 'yarn', flag: '--version' },
+  { name: 'bun', flag: '--version' },
+
+  // Python ecosystem
+  { name: 'python', flag: '--version' },
+  { name: 'python3', flag: '--version' },
+  { name: 'pip', flag: '--version' },
+  { name: 'pip3', flag: '--version' },
+  { name: 'poetry', flag: '--version' },
+
+  // Rust ecosystem
+  { name: 'cargo', flag: '--version' },
+  { name: 'rustc', flag: '--version' },
+  { name: 'rustup', flag: '--version' },
+
+  // Go ecosystem
+  { name: 'go', flag: 'version' },
+
+  // Java ecosystem
+  { name: 'java', flag: '--version' },
+  { name: 'javac', flag: '--version' },
+  { name: 'mvn', flag: '--version' },
+  { name: 'gradle', flag: '--version' },
+
+  // Containerization
+  { name: 'docker', flag: '--version' },
+
+  // Deployment platforms
+  { name: 'railway', flag: '--version' },
+  { name: 'vercel', flag: '--version' },
+  { name: 'netlify', flag: '--version' },
+  { name: 'flyctl', flag: 'version' },
+
+  // CI/CD tools
+  { name: 'circleci', flag: 'version' }
+];
+
+/**
+ * Verifies all development tools (parallel execution)
+ * Runs all tool checks in parallel for fast execution
+ * @returns {Promise<Object>} Tool availability map
+ */
+async function verifyTools() {
+  try {
+    const results = await Promise.all(
+      TOOL_DEFINITIONS.map(tool => checkTool(tool.name, tool.flag))
+    );
+
+    const toolMap = {};
+    TOOL_DEFINITIONS.forEach((tool, index) => {
+      toolMap[tool.name] = results[index];
+    });
+
+    return toolMap;
+  } catch (error) {
+    // Log error for debugging but return empty map for graceful degradation
+    console.error(`[WARN] Tool verification failed: ${error.message}`);
+    // Return all tools as unavailable rather than throwing
+    const toolMap = {};
+    TOOL_DEFINITIONS.forEach((tool) => {
+      toolMap[tool.name] = { available: false, version: null };
+    });
+    return toolMap;
+  }
+}
+
+// When run directly, output JSON
+if (require.main === module) {
+  (async () => {
+    try {
+      const result = await verifyTools();
+      console.log(JSON.stringify(result, null, 2));
+    } catch (error) {
+      console.error(JSON.stringify({
+        error: error.message,
+        timestamp: new Date().toISOString()
+      }, null, 2));
+      process.exit(1);
+    }
+  })();
+}
+
+// Export for use as module
+module.exports = {
+  verifyTools,
+  checkTool,
+  TOOL_DEFINITIONS
+};

package/plugins/debate/lib/repo-map/cache.js

@@ -0,0 +1,152 @@
+/**
+ * Repo map cache management
+ *
+ * @module lib/repo-map/cache
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { getStateDirPath } = require('../platform/state-dir');
+const { writeJsonAtomic, writeFileAtomic } = require('../utils/atomic-write');
+
+const MAP_FILENAME = 'repo-map.json';
+const STALE_FILENAME = 'repo-map.stale';
+
+/**
+ * Get repo-map path
+ * @param {string} basePath - Repository root
+ * @returns {string}
+ */
+function getMapPath(basePath) {
+  return path.join(getStateDirPath(basePath), MAP_FILENAME);
+}
+
+/**
+ * Get stale marker path
+ * @param {string} basePath - Repository root
+ * @returns {string}
+ */
+function getStalePath(basePath) {
+  return path.join(getStateDirPath(basePath), STALE_FILENAME);
+}
+
+/**
+ * Ensure state directory exists
+ * @param {string} basePath - Repository root
+ * @returns {string}
+ */
+function ensureStateDir(basePath) {
+  const stateDir = getStateDirPath(basePath);
+  if (!fs.existsSync(stateDir)) {
+    fs.mkdirSync(stateDir, { recursive: true });
+  }
+  return stateDir;
+}
+
+/**
+ * Load repo-map from cache
+ * @param {string} basePath - Repository root
+ * @returns {Object|null}
+ */
+function load(basePath) {
+  const mapPath = getMapPath(basePath);
+  if (!fs.existsSync(mapPath)) return null;
+
+  try {
+    const raw = fs.readFileSync(mapPath, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Save repo-map to cache
+ * @param {string} basePath - Repository root
+ * @param {Object} map - Map object
+ */
+function save(basePath, map) {
+  ensureStateDir(basePath);
+  const mapPath = getMapPath(basePath);
+
+  const output = {
+    ...map,
+    updated: new Date().toISOString()
+  };
+
+  writeJsonAtomic(mapPath, output);
+
+  // Clear stale marker if present
+  clearStale(basePath);
+}
+
+/**
+ * Check if repo-map exists
+ * @param {string} basePath - Repository root
+ * @returns {boolean}
+ */
+function exists(basePath) {
+  return fs.existsSync(getMapPath(basePath));
+}
+
+/**
+ * Mark repo-map as stale
+ * @param {string} basePath - Repository root
+ */
+function markStale(basePath) {
+  ensureStateDir(basePath);
+  writeFileAtomic(getStalePath(basePath), new Date().toISOString());
+}
+
+/**
+ * Clear stale marker
+ * @param {string} basePath - Repository root
+ */
+function clearStale(basePath) {
+  const stalePath = getStalePath(basePath);
+  if (fs.existsSync(stalePath)) {
+    fs.unlinkSync(stalePath);
+  }
+}
+
+/**
+ * Check if stale marker exists
+ * @param {string} basePath - Repository root
+ * @returns {boolean}
+ */
+function isMarkedStale(basePath) {
+  return fs.existsSync(getStalePath(basePath));
+}
+
+/**
+ * Get basic status summary
+ * @param {string} basePath - Repository root
+ * @returns {Object|null}
+ */
+function getStatus(basePath) {
+  const map = load(basePath);
+  if (!map) return null;
+
+  return {
+    generated: map.generated,
+    updated: map.updated,
+    commit: map.git?.commit,
+    branch: map.git?.branch,
+    files: Object.keys(map.files || {}).length,
+    symbols: map.stats?.totalSymbols || 0,
+    languages: map.project?.languages || []
+  };
+}
+
+module.exports = {
+  load,
+  save,
+  exists,
+  getStatus,
+  getMapPath,
+  markStale,
+  clearStale,
+  isMarkedStale
+};

package/plugins/debate/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
+};

package/plugins/debate/lib/repo-map/index.js

@@ -0,0 +1,222 @@
+/**
+ * Repo Map - AST-based repository symbol mapping
+ *
+ * Uses ast-grep (sg) for accurate symbol extraction across multiple languages.
+ * Generates a cached map of exports, functions, classes, and imports.
+ *
+ * @module lib/repo-map
+ */
+
+'use strict';
+
+const installer = require('./installer');
+const runner = require('./runner');
+const cache = require('./cache');
+const updater = require('./updater');
+const usageAnalyzer = require('./usage-analyzer');
+
+/**
+ * Initialize a new repo map (full scan)
+ * @param {string} basePath - Repository root path
+ * @param {Object} options - Options
+ * @param {boolean} options.force - Force rebuild even if map exists
+ * @param {string[]} options.languages - Languages to scan (auto-detect if not specified)
+ * @returns {Promise<{success: boolean, map?: Object, error?: string}>}
+ */
+async function init(basePath, options = {}) {
+  // Check if ast-grep is installed
+  const installed = await installer.checkInstalled();
+  if (!installed.found) {
+    return {
+      success: false,
+      error: 'ast-grep not found',
+      installSuggestion: installer.getInstallInstructions()
+    };
+  }
+
+  if (!installer.meetsMinimumVersion(installed.version)) {
+    return {
+      success: false,
+      error: `ast-grep version ${installed.version || 'unknown'} is too old. Minimum required: ${installer.getMinimumVersion()}`,
+      installSuggestion: installer.getInstallInstructions()
+    };
+  }
+
+  // Check if map already exists
+  const existing = cache.load(basePath);
+  if (existing && !options.force) {
+    return {
+      success: false,
+      error: 'Repo map already exists. Use --force to rebuild or /repo-map update to refresh.',
+      existing: cache.getStatus(basePath)
+    };
+  }
+
+  // Detect languages in the project
+  const languages = options.languages || await runner.detectLanguages(basePath);
+  if (languages.length === 0) {
+    return {
+      success: false,
+      error: 'No supported languages detected in repository'
+    };
+  }
+
+  // Run full scan
+  const startTime = Date.now();
+  const map = await runner.fullScan(basePath, languages, {
+    fileLimit: options.fileLimit
+  });
+  map.stats.scanDurationMs = Date.now() - startTime;
+
+  // Save map
+  cache.save(basePath, map);
+
+  return {
+    success: true,
+    map,
+    summary: {
+      files: Object.keys(map.files).length,
+      symbols: map.stats.totalSymbols,
+      languages: map.project.languages,
+      duration: map.stats.scanDurationMs
+    }
+  };
+}
+
+/**
+ * Update an existing repo map (incremental)
+ * @param {string} basePath - Repository root path
+ * @param {Object} options - Options
+ * @param {boolean} options.full - Force full rebuild instead of incremental
+ * @returns {Promise<{success: boolean, changes?: Object, error?: string}>}
+ */
+async function update(basePath, options = {}) {
+  // Check if ast-grep is installed
+  const installed = await installer.checkInstalled();
+  if (!installed.found) {
+    return {
+      success: false,
+      error: 'ast-grep not found',
+      installSuggestion: installer.getInstallInstructions()
+    };
+  }
+
+  if (!installer.meetsMinimumVersion(installed.version)) {
+    return {
+      success: false,
+      error: `ast-grep version ${installed.version || 'unknown'} is too old. Minimum required: ${installer.getMinimumVersion()}`,
+      installSuggestion: installer.getInstallInstructions()
+    };
+  }
+
+  // Load existing map
+  const existing = cache.load(basePath);
+  if (!existing) {
+    return {
+      success: false,
+      error: 'No repo map found. Run /repo-map init first.'
+    };
+  }
+
+  // Force full rebuild if requested
+  if (options.full) {
+    return init(basePath, { force: true });
+  }
+
+  // Incremental update
+  const result = await updater.incrementalUpdate(basePath, existing);
+
+  if (result.success) {
+    cache.save(basePath, result.map);
+  }
+
+  return result;
+}
+
+/**
+ * Get repo map status
+ * @param {string} basePath - Repository root path
+ * @returns {{exists: boolean, status?: Object}}
+ */
+function status(basePath) {
+  const map = cache.load(basePath);
+  if (!map) {
+    return { exists: false };
+  }
+
+  const staleness = updater.checkStaleness(basePath, map);
+
+  return {
+    exists: true,
+    status: {
+      generated: map.generated,
+      updated: map.updated,
+      commit: map.git?.commit,
+      branch: map.git?.branch,
+      files: Object.keys(map.files).length,
+      symbols: map.stats?.totalSymbols || 0,
+      languages: map.project?.languages || [],
+      staleness
+    }
+  };
+}
+
+/**
+ * Load repo map (if exists)
+ * @param {string} basePath - Repository root path
+ * @returns {Object|null} - The map or null if not found
+ */
+function load(basePath) {
+  return cache.load(basePath);
+}
+
+/**
+ * Check if ast-grep is installed
+ * @returns {Promise<{found: boolean, version?: string, path?: string}>}
+ */
+async function checkAstGrepInstalled() {
+  return installer.checkInstalled();
+}
+
+/**
+ * Get install instructions for ast-grep
+ * @returns {string}
+ */
+function getInstallInstructions() {
+  return installer.getInstallInstructions();
+}
+
+/**
+ * Check if repo map exists
+ * @param {string} basePath - Repository root path
+ * @returns {boolean}
+ */
+function exists(basePath) {
+  return cache.exists(basePath);
+}
+
+module.exports = {
+  init,
+  update,
+  status,
+  load,
+  exists,
+  checkAstGrepInstalled,
+  getInstallInstructions,
+
+  // Usage analysis functions
+  buildUsageIndex: usageAnalyzer.buildUsageIndex,
+  findUsages: usageAnalyzer.findUsages,
+  findDependents: usageAnalyzer.findDependents,
+  findUnusedExports: usageAnalyzer.findUnusedExports,
+  findOrphanedInfrastructure: usageAnalyzer.findOrphanedInfrastructure,
+  getDependencyGraph: usageAnalyzer.getDependencyGraph,
+  findCircularDependencies: usageAnalyzer.findCircularDependencies,
+
+  // Re-export submodules for advanced usage
+  installer,
+  runner,
+  cache,
+  updater,
+  usageAnalyzer
+};