agentsys 5.1.0 → 5.2.0

package/plugins/drift-detect/lib/platform/verify-tools.js

@@ -1,182 +0,0 @@
-#!/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/drift-detect/lib/repo-map/cache.js

@@ -1,152 +0,0 @@
-/**
- * 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/drift-detect/lib/repo-map/concurrency.js

@@ -1,29 +0,0 @@
-'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/drift-detect/lib/repo-map/index.js

@@ -1,222 +0,0 @@
-/**
- * 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
-};