agentsys 5.0.3 → 5.2.0

package/plugins/audit-project/lib/platform/detect-platform.js

@@ -1,413 +0,0 @@
-#!/usr/bin/env node
-/**
- * Platform Detection Infrastructure
- * Auto-detects project configuration for zero-config slash commands
- *
- * Usage: node lib/platform/detect-platform.js
- * Output: JSON with detected platform information
- *
- * @author Avi Fenesh
- * @license MIT
- */
-
-const fs = require('fs');
-const path = require('path');
-const { exec } = require('child_process');
-const { promisify } = require('util');
-
-const execAsync = promisify(exec);
-const fsPromises = fs.promises;
-
-// Import shared utilities
-const { CacheManager } = require('../utils/cache-manager');
-const {
-  CI_CONFIGS,
-  DEPLOYMENT_CONFIGS,
-  PACKAGE_MANAGER_CONFIGS
-} = require('./detection-configs');
-
-/**
- * Default timeout for async operations (5 seconds)
- */
-const DEFAULT_ASYNC_TIMEOUT_MS = 5000;
-
-/**
- * Maximum JSON file size to parse (1MB) - prevents DoS via large files
- */
-const MAX_JSON_SIZE_BYTES = 1024 * 1024;
-
-/**
- * Safely parse JSON content with size limit
- * @param {string} content - JSON string to parse
- * @param {string} filename - Filename for error messages
- * @returns {Object|null} Parsed object or null if invalid/too large
- */
-function safeJSONParse(content, filename = 'unknown') {
-  if (!content || typeof content !== 'string') {
-    return null;
-  }
-  if (content.length > MAX_JSON_SIZE_BYTES) {
-    return null;
-  }
-  try {
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Wrap a promise with a timeout
- * @param {Promise} promise - Promise to wrap
- * @param {number} timeoutMs - Timeout in milliseconds
- * @param {string} operation - Operation name for error message
- * @returns {Promise} Promise that rejects on timeout
- */
-function withTimeout(promise, timeoutMs = DEFAULT_ASYNC_TIMEOUT_MS, operation = 'operation') {
-  let timeoutId;
-  const timeoutPromise = new Promise((_, reject) => {
-    timeoutId = setTimeout(() => {
-      reject(new Error(`${operation} timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
-  });
-
-  return Promise.race([promise, timeoutPromise]).finally(() => {
-    clearTimeout(timeoutId);
-  });
-}
-
-/**
- * Execute a command with timeout protection
- * @param {string} cmd - Command to execute
- * @param {Object} options - exec options
- * @param {number} timeoutMs - Timeout in milliseconds
- * @returns {Promise<{stdout: string, stderr: string}>}
- */
-async function execWithTimeout(cmd, options = {}, timeoutMs = DEFAULT_ASYNC_TIMEOUT_MS) {
-  return withTimeout(execAsync(cmd, options), timeoutMs, `exec: ${cmd.substring(0, 50)}`);
-}
-
-// Maximum cached file size constant
-const MAX_CACHED_FILE_SIZE = 64 * 1024; // 64KB max per cached file
-
-// Cache instances using CacheManager abstraction
-const _detectionCache = new CacheManager({ maxSize: 1, ttl: 60000 });
-const _fileCache = new CacheManager({ maxSize: 100, ttl: 60000, maxValueSize: MAX_CACHED_FILE_SIZE });
-const _existsCache = new CacheManager({ maxSize: 100, ttl: 60000 });
-
-/**
- * Generic file-based detector
- * @param {Array} configs - Array of {file, platform} objects
- * @param {Function} existsChecker - Async function to check file existence
- * @returns {Promise<string|null>} Detected platform or null
- */
-async function detectFromFiles(configs, existsChecker) {
-  try {
-    const checks = await Promise.all(
-      configs.map(({ file }) => existsChecker(file).catch(() => false))
-    );
-
-    for (let i = 0; i < checks.length; i++) {
-      if (checks[i]) {
-        return configs[i].platform;
-      }
-    }
-    return null;
-  } catch (error) {
-    // Log unexpected errors but return null to allow detection to continue
-    if (process.env.DEBUG) {
-      console.error(`[detect-platform] detectFromFiles error: ${error.message}`);
-    }
-    return null;
-  }
-}
-
-/**
- * Check if a file exists (cached)
- * @param {string} filepath - Path to check
- * @returns {Promise<boolean>}
- */
-async function existsCached(filepath) {
-  const cached = _existsCache.get(filepath);
-  if (cached !== undefined) {
-    return cached;
-  }
-  try {
-    await fsPromises.access(filepath);
-    _existsCache.set(filepath, true);
-    return true;
-  } catch {
-    _existsCache.set(filepath, false);
-    return false;
-  }
-}
-
-/**
- * Read file contents (cached)
- * Only caches files smaller than MAX_CACHED_FILE_SIZE to prevent memory bloat
- * Optimized: normalizes filepath to prevent cache pollution from variant paths
- * @param {string} filepath - Path to read
- * @returns {Promise<string|null>}
- */
-async function readFileCached(filepath) {
-  const normalizedPath = path.resolve(filepath);
-
-  const cached = _fileCache.get(normalizedPath);
-  if (cached !== undefined) {
-    return cached;
-  }
-  try {
-    const content = await fsPromises.readFile(normalizedPath, 'utf8');
-    _fileCache.set(normalizedPath, content);
-    return content;
-  } catch {
-    _fileCache.set(normalizedPath, null);
-    return null;
-  }
-}
-
-/**
- * Detects CI platform by scanning for configuration files
- * @returns {Promise<string|null>} CI platform name or null if not detected
- */
-async function detectCI() {
-  return detectFromFiles(CI_CONFIGS, existsCached);
-}
-
-/**
- * Detects deployment platform by scanning for platform-specific files
- * @returns {Promise<string|null>} Deployment platform name or null if not detected
- */
-async function detectDeployment() {
-  return detectFromFiles(DEPLOYMENT_CONFIGS, existsCached);
-}
-
-/**
- * Detects project type by scanning for language-specific files
- * @returns {Promise<string>} Project type identifier
- */
-async function detectProjectType() {
-  try {
-    const checks = await Promise.all([
-      existsCached('package.json').catch(() => false),
-      existsCached('requirements.txt').catch(() => false),
-      existsCached('pyproject.toml').catch(() => false),
-      existsCached('setup.py').catch(() => false),
-      existsCached('Cargo.toml').catch(() => false),
-      existsCached('go.mod').catch(() => false),
-      existsCached('pom.xml').catch(() => false),
-      existsCached('build.gradle').catch(() => false)
-    ]);
-
-    if (checks[0]) return 'nodejs';
-    if (checks[1] || checks[2] || checks[3]) return 'python';
-    if (checks[4]) return 'rust';
-    if (checks[5]) return 'go';
-    if (checks[6] || checks[7]) return 'java';
-    return 'unknown';
-  } catch (error) {
-    if (process.env.DEBUG) {
-      console.error(`[detect-platform] detectProjectType error: ${error.message}`);
-    }
-    return 'unknown';
-  }
-}
-
-/**
- * Detects package manager by scanning for lockfiles
- * @returns {Promise<string|null>} Package manager name or null if not detected
- */
-async function detectPackageManager() {
-  return detectFromFiles(
-    PACKAGE_MANAGER_CONFIGS.map(({ file, manager }) => ({ file, platform: manager })),
-    existsCached
-  );
-}
-
-/**
- * Detects branch strategy (single-branch vs multi-branch with dev+prod)
- * @returns {Promise<string>} 'single-branch' or 'multi-branch'
- */
-async function detectBranchStrategy() {
-  try {
-    const [localResult, remoteResult] = await Promise.all([
-      execWithTimeout('git branch', { encoding: 'utf8' }).catch(() => ({ stdout: '' })),
-      execWithTimeout('git branch -r', { encoding: 'utf8' }).catch(() => ({ stdout: '' }))
-    ]);
-
-    const allBranches = (localResult.stdout || '') + (remoteResult.stdout || '');
-
-    const hasStable = allBranches.includes('stable');
-    const hasProduction = allBranches.includes('production') || allBranches.includes('prod');
-
-    if (hasStable || hasProduction) {
-      return 'multi-branch';
-    }
-
-    if (await existsCached('railway.json')) {
-      try {
-        const content = await readFileCached('railway.json');
-        if (content) {
-          const config = safeJSONParse(content, 'railway.json');
-          if (config &&
-              typeof config === 'object' &&
-              typeof config.environments === 'object' &&
-              config.environments !== null &&
-              Object.keys(config.environments).length > 1) {
-            return 'multi-branch';
-          }
-        }
-      } catch { /* config parse error - ignore */ }
-    }
-
-    return 'single-branch';
-  } catch {
-    return 'single-branch';
-  }
-}
-
-/**
- * Detects the main branch name
- * @returns {Promise<string>} Main branch name ('main' or 'master')
- */
-async function detectMainBranch() {
-  try {
-    const { stdout } = await execWithTimeout('git symbolic-ref refs/remotes/origin/HEAD', { encoding: 'utf8' });
-    return stdout.trim().replace('refs/remotes/origin/', '');
-  } catch {
-    try {
-      await execWithTimeout('git rev-parse --verify main', { encoding: 'utf8' });
-      return 'main';
-    } catch {
-      return 'master';
-    }
-  }
-}
-
-/**
- * Main detection function - aggregates all platform information
- * Uses Promise.all for parallel execution and caching
- * @param {boolean} forceRefresh - Force cache refresh
- * @returns {Promise<Object>} Platform configuration object
- */
-async function detect(forceRefresh = false) {
-  if (!forceRefresh) {
-    const cached = _detectionCache.get('detection');
-    if (cached !== undefined) {
-      return cached;
-    }
-  }
-
-  try {
-    const [
-      ci,
-      deployment,
-      projectType,
-      packageManager,
-      branchStrategy,
-      mainBranch,
-      hasPlanFile,
-      hasTechDebtFile
-    ] = await Promise.all([
-      detectCI().catch((err) => {
-        if (process.env.DEBUG) console.error(`[detect-platform] detectCI failed: ${err.message}`);
-        return null;
-      }),
-      detectDeployment().catch((err) => {
-        if (process.env.DEBUG) console.error(`[detect-platform] detectDeployment failed: ${err.message}`);
-        return null;
-      }),
-      detectProjectType().catch((err) => {
-        if (process.env.DEBUG) console.error(`[detect-platform] detectProjectType failed: ${err.message}`);
-        return 'unknown';
-      }),
-      detectPackageManager().catch((err) => {
-        if (process.env.DEBUG) console.error(`[detect-platform] detectPackageManager failed: ${err.message}`);
-        return null;
-      }),
-      detectBranchStrategy().catch((err) => {
-        if (process.env.DEBUG) console.error(`[detect-platform] detectBranchStrategy failed: ${err.message}`);
-        return 'single-branch';
-      }),
-      detectMainBranch().catch((err) => {
-        if (process.env.DEBUG) console.error(`[detect-platform] detectMainBranch failed: ${err.message}`);
-        return 'main';
-      }),
-      existsCached('PLAN.md').catch(() => false),
-      existsCached('TECHNICAL_DEBT.md').catch(() => false)
-    ]);
-
-    const detection = {
-      ci,
-      deployment,
-      projectType,
-      packageManager,
-      branchStrategy,
-      mainBranch,
-      hasPlanFile,
-      hasTechDebtFile,
-      timestamp: new Date().toISOString()
-    };
-
-    _detectionCache.set('detection', detection);
-    return detection;
-  } catch (error) {
-    // Return sensible defaults if detection fails entirely
-    const fallback = {
-      ci: null,
-      deployment: null,
-      projectType: 'unknown',
-      packageManager: null,
-      branchStrategy: 'single-branch',
-      mainBranch: 'main',
-      hasPlanFile: false,
-      hasTechDebtFile: false,
-      timestamp: new Date().toISOString(),
-      error: error.message
-    };
-    if (process.env.DEBUG) {
-      console.error(`[detect-platform] detect() failed, returning fallback: ${error.message}`);
-    }
-    return fallback;
-  }
-}
-
-/**
- * Invalidate all detection caches
- * Call this after making changes that affect platform detection
- */
-function invalidateCache() {
-  _detectionCache.clear();
-  _fileCache.clear();
-  _existsCache.clear();
-}
-
-// When run directly, output JSON
-if (require.main === module) {
-  (async () => {
-    try {
-      const result = await detect();
-      const indent = process.stdout.isTTY ? 2 : 0;
-      console.log(JSON.stringify(result, null, indent));
-    } catch (error) {
-      const indent = process.stderr.isTTY ? 2 : 0;
-      console.error(JSON.stringify({
-        error: error.message,
-        timestamp: new Date().toISOString()
-      }, null, indent));
-      process.exit(1);
-    }
-  })();
-}
-
-// Export for use as module
-module.exports = {
-  detect,
-  invalidateCache,
-  detectCI,
-  detectDeployment,
-  detectProjectType,
-  detectPackageManager,
-  detectBranchStrategy,
-  detectMainBranch
-};

package/plugins/audit-project/lib/platform/detection-configs.js

@@ -1,93 +0,0 @@
-/**
- * Detection Configurations
- * Centralized config for platform detection logic
- *
- * @module lib/platform/detection-configs
- * @author Avi Fenesh
- * @license MIT
- */
-
-/**
- * CI platform detection configuration
- * Order matters - first match wins
- */
-const CI_CONFIGS = [
-  { file: '.github/workflows', platform: 'github-actions' },
-  { file: '.gitlab-ci.yml', platform: 'gitlab-ci' },
-  { file: '.circleci/config.yml', platform: 'circleci' },
-  { file: 'Jenkinsfile', platform: 'jenkins' },
-  { file: '.travis.yml', platform: 'travis' }
-];
-
-/**
- * Deployment platform detection configuration
- * Order matters - first match wins
- */
-const DEPLOYMENT_CONFIGS = [
-  { file: 'railway.json', platform: 'railway' },
-  { file: 'railway.toml', platform: 'railway' },  // Legacy Railway marker
-  { file: 'vercel.json', platform: 'vercel' },
-  { file: 'netlify.toml', platform: 'netlify' },
-  { file: '.netlify', platform: 'netlify' },       // Legacy Netlify marker
-  { file: 'fly.toml', platform: 'fly' },
-  { file: '.platform.app.yaml', platform: 'platformsh' },
-  { file: 'render.yaml', platform: 'render' }
-];
-
-/**
- * Project type detection configuration
- * Checks package.json for framework indicators
- */
-const PROJECT_TYPE_CONFIGS = {
-  dependencies: [
-    { name: 'next', type: 'nextjs' },
-    { name: 'react', type: 'react' },
-    { name: 'vue', type: 'vue' },
-    { name: '@angular/core', type: 'angular' },
-    { name: 'svelte', type: 'svelte' },
-    { name: 'express', type: 'express' },
-    { name: '@nestjs/core', type: 'nestjs' },
-    { name: 'gatsby', type: 'gatsby' },
-    { name: '@remix-run/react', type: 'remix' },
-    { name: 'astro', type: 'astro' }
-  ]
-};
-
-/**
- * Package manager detection configuration
- * Lock files indicate package manager used
- * Order matters - first match wins (prioritize pnpm > yarn > bun > npm for Node.js)
- */
-const PACKAGE_MANAGER_CONFIGS = [
-  { file: 'pnpm-lock.yaml', manager: 'pnpm' },
-  { file: 'yarn.lock', manager: 'yarn' },
-  { file: 'bun.lockb', manager: 'bun' },
-  { file: 'package-lock.json', manager: 'npm' },
-  { file: 'poetry.lock', manager: 'poetry' },
-  { file: 'Pipfile.lock', manager: 'pipenv' },
-  { file: 'Cargo.lock', manager: 'cargo' },
-  { file: 'go.sum', manager: 'go' }
-];
-
-/**
- * Branch strategy patterns
- */
-const BRANCH_STRATEGIES = {
-  gitflow: ['develop', 'main', 'master'],
-  githubflow: ['main'],
-  trunkbased: ['main', 'trunk']
-};
-
-/**
- * Main branch candidates (in priority order)
- */
-const MAIN_BRANCH_CANDIDATES = ['main', 'master', 'trunk', 'develop'];
-
-module.exports = {
-  CI_CONFIGS,
-  DEPLOYMENT_CONFIGS,
-  PROJECT_TYPE_CONFIGS,
-  PACKAGE_MANAGER_CONFIGS,
-  BRANCH_STRATEGIES,
-  MAIN_BRANCH_CANDIDATES
-};

package/plugins/audit-project/lib/platform/state-dir.js

@@ -1,132 +0,0 @@
-/**
- * Platform-aware state directory detection
- *
- * Determines the appropriate state directory based on the AI coding assistant
- * being used (Claude Code, OpenCode, or Codex CLI).
- *
- * @module lib/platform/state-dir
- */
-
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Cached state directory name (relative, without leading dot handling),
- * scoped by resolved base path.
- * @type {Map<string, string>}
- */
-const _cachedStateDirs = new Map();
-
-function isDirectory(targetPath) {
-  try {
-    return fs.statSync(targetPath).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Detect which AI coding assistant is running and return appropriate state directory
- *
- * Detection order:
- * 1. AI_STATE_DIR env var (user override)
- * 2. OpenCode detection (OPENCODE_CONFIG env or .opencode/ exists)
- * 3. Codex detection (CODEX_HOME env or .codex/ exists)
- * 4. Default to .claude (Claude Code or unknown)
- *
- * @param {string} [basePath=process.cwd()] - Base path to check for project directories
- * @returns {string} State directory name (e.g., '.claude', '.opencode', '.codex')
- */
-function getStateDir(basePath = process.cwd()) {
-  // Check user override first
-  if (process.env.AI_STATE_DIR) {
-    return process.env.AI_STATE_DIR;
-  }
-
-  const cacheKey = path.resolve(basePath);
-  const cached = _cachedStateDirs.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-
-  // OpenCode detection
-  if (process.env.OPENCODE_CONFIG || process.env.OPENCODE_CONFIG_DIR) {
-    _cachedStateDirs.set(cacheKey, '.opencode');
-    return '.opencode';
-  }
-
-  // Check for .opencode directory in project
-  try {
-    const opencodePath = path.join(basePath, '.opencode');
-    if (isDirectory(opencodePath)) {
-      _cachedStateDirs.set(cacheKey, '.opencode');
-      return '.opencode';
-    }
-  } catch {
-    // Ignore errors, continue detection
-  }
-
-  // Codex detection
-  if (process.env.CODEX_HOME) {
-    _cachedStateDirs.set(cacheKey, '.codex');
-    return '.codex';
-  }
-
-  // Check for .codex directory in project
-  try {
-    const codexPath = path.join(basePath, '.codex');
-    if (isDirectory(codexPath)) {
-      _cachedStateDirs.set(cacheKey, '.codex');
-      return '.codex';
-    }
-  } catch {
-    // Ignore errors, continue detection
-  }
-
-  // Default to Claude Code
-  _cachedStateDirs.set(cacheKey, '.claude');
-  return '.claude';
-}
-
-/**
- * Get the full path to the state directory
- * @param {string} [basePath=process.cwd()] - Base path
- * @returns {string} Full path to state directory
- */
-function getStateDirPath(basePath = process.cwd()) {
-  return path.join(basePath, getStateDir(basePath));
-}
-
-/**
- * Get the detected platform name
- * @param {string} [basePath=process.cwd()] - Base path
- * @returns {string} Platform name ('claude', 'opencode', 'codex', or 'custom')
- */
-function getPlatformName(basePath = process.cwd()) {
-  const stateDir = getStateDir(basePath);
-
-  if (process.env.AI_STATE_DIR) {
-    return 'custom';
-  }
-
-  switch (stateDir) {
-    case '.opencode': return 'opencode';
-    case '.codex': return 'codex';
-    case '.claude': return 'claude';
-    default: return 'unknown';
-  }
-}
-
-/**
- * Clear the cached state directory (useful for testing)
- */
-function clearCache() {
-  _cachedStateDirs.clear();
-}
-
-module.exports = {
-  getStateDir,
-  getStateDirPath,
-  getPlatformName,
-  clearCache
-};