agentsys 5.5.0 → 5.7.0

package/lib/repo-map/index.js

@@ -1,74 +1,90 @@
+'use strict';
+
 /**
- * Repo Map - AST-based repository symbol mapping
+ * Repo Map - repository symbol mapping via agent-analyzer
  *
- * Uses ast-grep (sg) for accurate symbol extraction across multiple languages.
- * Generates a cached map of exports, functions, classes, and imports.
+ * Uses agent-analyzer for symbol extraction. The binary is auto-downloaded
+ * on first use - no external tool installation required.
  *
  * @module lib/repo-map
  */
 
-'use strict';
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
 
 const installer = require('./installer');
-const runner = require('./runner');
 const cache = require('./cache');
 const updater = require('./updater');
-const usageAnalyzer = require('./usage-analyzer');
+const converter = require('./converter');
+const binary = require('../binary');
+const { getStateDirPath } = require('../platform/state-dir');
+const { writeJsonAtomic } = require('../utils/atomic-write');
+
+const REPO_INTEL_FILENAME = 'repo-intel.json';
+
+function getIntelMapPath(basePath) {
+  return path.join(getStateDirPath(basePath), REPO_INTEL_FILENAME);
+}
 
 /**
  * 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',
+      error: 'agent-analyzer binary unavailable: ' + (installed.error || 'unknown error'),
       installSuggestion: installer.getInstallInstructions()
     };
   }
 
-  if (!installer.meetsMinimumVersion(installed.version)) {
+  const existing = cache.load(basePath);
+  if (existing && !options.force) {
     return {
       success: false,
-      error: `ast-grep version ${installed.version || 'unknown'} is too old. Minimum required: ${installer.getMinimumVersion()}`,
-      installSuggestion: installer.getInstallInstructions()
+      error: 'Repo map already exists. Use --force to rebuild or /repo-map update to refresh.',
+      existing: cache.getStatus(basePath)
     };
   }
 
-  // Check if map already exists
-  const existing = cache.load(basePath);
-  if (existing && !options.force) {
+  const startTime = Date.now();
+
+  let intelJson;
+  try {
+    intelJson = await binary.runAnalyzerAsync(['repo-intel', 'init', basePath]);
+  } catch (e) {
     return {
       success: false,
-      error: 'Repo map already exists. Use --force to rebuild or /repo-map update to refresh.',
-      existing: cache.getStatus(basePath)
+      error: 'agent-analyzer repo-intel init failed: ' + e.message
     };
   }
 
-  // Detect languages in the project
-  const languages = options.languages || await runner.detectLanguages(basePath);
-  if (languages.length === 0) {
+  let intel;
+  try {
+    intel = JSON.parse(intelJson);
+  } catch (e) {
     return {
       success: false,
-      error: 'No supported languages detected in repository'
+      error: 'Failed to parse repo-intel output: ' + e.message
     };
   }
 
-  // Run full scan
-  const startTime = Date.now();
-  const map = await runner.fullScan(basePath, languages, {
-    fileLimit: options.fileLimit
-  });
-  map.stats.scanDurationMs = Date.now() - startTime;
+  // Persist repo-intel.json for future incremental updates
+  const intelPath = getIntelMapPath(basePath);
+  try {
+    writeJsonAtomic(intelPath, intel);
+  } catch {
+    // Non-fatal: update() will fall back to full init
+  }
 
-  // Save map
+  const map = converter.convertIntelToRepoMap(intel);
+  map.stats.scanDurationMs = Date.now() - startTime;
   cache.save(basePath, map);
 
   return {
@@ -84,53 +100,83 @@ async function init(basePath, options = {}) {
 }
 
 /**
- * Update an existing repo map (incremental)
+ * Update an existing repo map (incremental via agent-analyzer)
  * @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}>}
+ * @returns {Promise<{success: boolean, summary?: 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',
+      error: 'agent-analyzer binary unavailable: ' + (installed.error || 'unknown error'),
       installSuggestion: installer.getInstallInstructions()
     };
   }
 
-  if (!installer.meetsMinimumVersion(installed.version)) {
+  if (!cache.exists(basePath)) {
     return {
       success: false,
-      error: `ast-grep version ${installed.version || 'unknown'} is too old. Minimum required: ${installer.getMinimumVersion()}`,
-      installSuggestion: installer.getInstallInstructions()
+      error: 'No repo map found. Run /repo-map init first.'
     };
   }
 
-  // Load existing map
-  const existing = cache.load(basePath);
-  if (!existing) {
+  if (options.full) {
+    return init(basePath, { force: true });
+  }
+
+  const intelPath = getIntelMapPath(basePath);
+  if (!fs.existsSync(intelPath)) {
+    return init(basePath, { force: true });
+  }
+
+  const startTime = Date.now();
+
+  let intelJson;
+  try {
+    intelJson = await binary.runAnalyzerAsync([
+      'repo-intel', 'update',
+      '--map-file', intelPath,
+      basePath
+    ]);
+  } catch (e) {
     return {
       success: false,
-      error: 'No repo map found. Run /repo-map init first.'
+      error: 'agent-analyzer repo-intel update failed: ' + e.message
     };
   }
 
-  // Force full rebuild if requested
-  if (options.full) {
-    return init(basePath, { force: true });
+  let intel;
+  try {
+    intel = JSON.parse(intelJson);
+  } catch (e) {
+    return {
+      success: false,
+      error: 'Failed to parse repo-intel update output: ' + e.message
+    };
   }
 
-  // Incremental update
-  const result = await updater.incrementalUpdate(basePath, existing);
-
-  if (result.success) {
-    cache.save(basePath, result.map);
+  try {
+    writeJsonAtomic(intelPath, intel);
+  } catch {
+    // Non-fatal
   }
 
-  return result;
+  const map = converter.convertIntelToRepoMap(intel);
+  map.stats.scanDurationMs = Date.now() - startTime;
+  cache.save(basePath, map);
+
+  return {
+    success: true,
+    map,
+    summary: {
+      files: Object.keys(map.files).length,
+      symbols: map.stats.totalSymbols,
+      duration: map.stats.scanDurationMs
+    }
+  };
 }
 
 /**
@@ -146,13 +192,20 @@ function status(basePath) {
 
   const staleness = updater.checkStaleness(basePath, map);
 
+  let branch;
+  try {
+    branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: basePath, encoding: 'utf8' }).trim();
+  } catch {
+    // Non-fatal
+  }
+
   return {
     exists: true,
     status: {
       generated: map.generated,
       updated: map.updated,
       commit: map.git?.commit,
-      branch: map.git?.branch,
+      branch,
       files: Object.keys(map.files).length,
       symbols: map.stats?.totalSymbols || 0,
       languages: map.project?.languages || [],
@@ -164,37 +217,38 @@ function status(basePath) {
 /**
  * Load repo map (if exists)
  * @param {string} basePath - Repository root path
- * @returns {Object|null} - The map or null if not found
+ * @returns {Object|null}
  */
 function load(basePath) {
   return cache.load(basePath);
 }
 
 /**
- * Check if ast-grep is installed
- * @returns {Promise<{found: boolean, version?: string, path?: string}>}
+ * Check if repo map exists
+ * @param {string} basePath - Repository root path
+ * @returns {boolean}
+ */
+function exists(basePath) {
+  return cache.exists(basePath);
+}
+
+/**
+ * Check if agent-analyzer is available (compat alias for checkInstalled).
+ * Previously checked ast-grep; now checks agent-analyzer.
+ * @returns {Promise<{found: boolean, version?: string, tool: string}>}
  */
 async function checkAstGrepInstalled() {
   return installer.checkInstalled();
 }
 
 /**
- * Get install instructions for ast-grep
+ * Get install instructions (compat alias).
  * @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,
@@ -204,19 +258,8 @@ module.exports = {
   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
+  updater
 };

package/lib/repo-map/installer.js

@@ -1,212 +1,78 @@
+'use strict';
+
 /**
- * ast-grep installation detection and helpers
+ * agent-analyzer binary availability check.
+ *
+ * Replaces the former ast-grep installer. The agent-analyzer binary is
+ * auto-downloaded by agent-core on first use - no manual install required.
  *
  * @module lib/repo-map/installer
  */
 
-'use strict';
-
-const { execSync, execFileSync, execFile } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const { promisify } = require('util');
-
-const execFileAsync = promisify(execFile);
-
-// Commands to try (sg is the common alias)
-const AST_GREP_COMMANDS = ['sg', 'ast-grep'];
-
-function pickCommandPath(pathOutput) {
-  if (!pathOutput) return null;
-  const candidates = pathOutput.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
-  if (candidates.length === 0) return null;
-
-  if (process.platform !== 'win32') {
-    return candidates[0];
-  }
-
-  const exe = candidates.find(candidate => candidate.toLowerCase().endsWith('.exe'));
-  if (exe) return exe;
-
-  const primary = candidates[0];
-  if (!primary) return null;
-
-  const baseDir = path.dirname(primary);
-  const npmExe = path.join(baseDir, 'node_modules', '@ast-grep', 'cli', 'sg.exe');
-  if (fs.existsSync(npmExe)) return npmExe;
-
-  return primary;
-}
+const binary = require('../binary');
 
 /**
- * Check if ast-grep is installed
- * @returns {Promise<{found: boolean, version?: string, path?: string, command?: string}>}
+ * Check if agent-analyzer is available (async). Downloads if missing.
+ * @returns {Promise<{found: boolean, version?: string, tool: string}>}
  */
 async function checkInstalled() {
-  for (const cmd of AST_GREP_COMMANDS) {
-    try {
-      // Try to get version using execFileAsync (no shell, safe from injection)
-      const { stdout } = await execFileAsync(cmd, ['--version'], {
-        timeout: 5000,
-        windowsHide: true,
-        shell: process.platform === 'win32' // Windows needs shell for PATH lookup
-      });
-
-      const version = stdout.trim().replace(/^ast-grep\s*/i, '');
-
-      // Try to get path
-      let cmdPath = null;
-      try {
-        const whereCmd = process.platform === 'win32' ? 'where' : 'which';
-        // Use execFileAsync with args array (no shell interpolation)
-        const { stdout: pathOut } = await execFileAsync(whereCmd, [cmd], {
-          timeout: 5000,
-          windowsHide: true,
-          shell: process.platform === 'win32'
-        });
-        cmdPath = pickCommandPath(pathOut);
-      } catch {
-        // Path lookup failed, but command works
-      }
-
-      return {
-        found: true,
-        version,
-        path: cmdPath,
-        command: cmdPath || cmd
-      };
-    } catch {
-      // This command not found, try next
-      continue;
-    }
+  if (binary.isAvailable()) {
+    return { found: true, version: binary.getVersion(), tool: 'agent-analyzer' };
+  }
+  try {
+    await binary.ensureBinary();
+    return { found: true, version: binary.getVersion(), tool: 'agent-analyzer' };
+  } catch (e) {
+    return { found: false, error: e.message, tool: 'agent-analyzer' };
   }
-
-  return { found: false };
 }
 
 /**
- * Check if ast-grep is installed (sync version)
- * @returns {{found: boolean, version?: string, command?: string, path?: string}}
+ * Check if agent-analyzer is available (sync). Downloads if missing.
+ * @returns {{found: boolean, version?: string, tool: string}}
  */
 function checkInstalledSync() {
-  for (const cmd of AST_GREP_COMMANDS) {
-    try {
-      // Use execFileSync with args array (no shell interpolation, safe from injection)
-      const stdout = execFileSync(cmd, ['--version'], {
-        timeout: 5000,
-        windowsHide: true,
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-        shell: process.platform === 'win32' // Windows needs shell for PATH lookup
-      });
-
-      const version = stdout.trim().replace(/^ast-grep\s*/i, '');
-      let cmdPath = null;
-
-      try {
-        const whereCmd = process.platform === 'win32' ? 'where' : 'which';
-        // Use execFileSync with args array (no shell interpolation)
-        const pathOut = execFileSync(whereCmd, [cmd], {
-          timeout: 5000,
-          windowsHide: true,
-          encoding: 'utf8',
-          stdio: ['pipe', 'pipe', 'pipe'],
-          shell: process.platform === 'win32'
-        });
-        cmdPath = pickCommandPath(pathOut);
-      } catch {
-        // Path lookup failed, but command works
-      }
-
-      return { found: true, version, command: cmdPath || cmd, path: cmdPath };
-    } catch {
-      continue;
-    }
+  if (binary.isAvailable()) {
+    return { found: true, version: binary.getVersion(), tool: 'agent-analyzer' };
+  }
+  try {
+    binary.ensureBinarySync();
+    return { found: true, version: binary.getVersion(), tool: 'agent-analyzer' };
+  } catch (e) {
+    return { found: false, error: e.message, tool: 'agent-analyzer' };
   }
-
-  return { found: false };
 }
 
 /**
- * Get the working ast-grep command
- * @returns {string|null}
+ * Version check is handled by the binary module - always true when found.
+ * @returns {boolean}
  */
-function getCommand() {
-  const result = checkInstalledSync();
-  return result.found ? result.command : null;
+function meetsMinimumVersion() {
+  return true;
 }
 
 /**
- * Get installation instructions for ast-grep
+ * Get install instructions (binary is auto-downloaded, but here for compat).
  * @returns {string}
  */
 function getInstallInstructions() {
-  return `ast-grep (sg) is required for repo-map functionality.
-
-Install using one of these methods:
-
-  npm:      npm install -g @ast-grep/cli
-  pip:      pip install ast-grep-cli
-  brew:     brew install ast-grep
-  cargo:    cargo install ast-grep --locked
-  scoop:    scoop install main/ast-grep
-
-After installation, verify with: sg --version
-
-Documentation: https://ast-grep.github.io/`;
+  return 'agent-analyzer is downloaded automatically on first use from https://github.com/agent-sh/agent-analyzer/releases';
 }
 
 /**
- * Get a short install suggestion (one line)
- * @returns {string}
- */
-function getShortInstallSuggestion() {
-  if (process.platform === 'win32') {
-    return 'Install ast-grep: npm i -g @ast-grep/cli (or scoop install ast-grep)';
-  } else if (process.platform === 'darwin') {
-    return 'Install ast-grep: brew install ast-grep (or npm i -g @ast-grep/cli)';
-  } else {
-    return 'Install ast-grep: npm i -g @ast-grep/cli (or pip install ast-grep-cli)';
-  }
-}
-
-/**
- * Get minimum required version
+ * Get minimum version string.
  * @returns {string}
  */
 function getMinimumVersion() {
-  return '0.20.0'; // Require at least this version for JSON output support
-}
-
-/**
- * Check if installed version meets minimum requirements
- * @param {string} version - Installed version
- * @returns {boolean}
- */
-function meetsMinimumVersion(version) {
-  if (!version) return false;
-
-  // Parse version (e.g., "0.25.0" or "0.25.0-beta.1")
-  const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
-  if (!match) return false;
-
-  const [, major, minor, patch] = match.map(Number);
-  const [reqMajor, reqMinor, reqPatch] = getMinimumVersion().split('.').map(Number);
-
-  if (major > reqMajor) return true;
-  if (major < reqMajor) return false;
-  if (minor > reqMinor) return true;
-  if (minor < reqMinor) return false;
-  return patch >= reqPatch;
+  return '0.3.0';
 }
 
 module.exports = {
   checkInstalled,
   checkInstalledSync,
-  getCommand,
+  meetsMinimumVersion,
   getInstallInstructions,
-  getShortInstallSuggestion,
   getMinimumVersion,
-  meetsMinimumVersion,
-  AST_GREP_COMMANDS
+  // Stub: runner.js references this but is no longer the scan path
+  getCommand: () => null
 };