awesome-slash 2.4.2

package/lib/platform/detect-platform.js

@@ -0,0 +1,535 @@
+#!/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 { execSync, exec } = require('child_process');
+const { promisify } = require('util');
+
+const execAsync = promisify(exec);
+const fsPromises = fs.promises;
+
+// Detection cache for performance (platform rarely changes during session)
+let _cachedDetection = null;
+let _cacheExpiry = 0;
+const CACHE_TTL_MS = 60000; // 1 minute cache
+
+// File read cache to avoid reading the same file multiple times (#17)
+// Limited to prevent unbounded memory growth in long-running processes
+const MAX_CACHE_SIZE = 100;
+const _fileCache = new Map();
+const _existsCache = new Map();
+
+/**
+ * Enforce cache size limits using FIFO eviction
+ * @param {Map} cache - Cache to limit
+ * @param {number} maxSize - Maximum entries
+ */
+function enforceMaxCacheSize(cache, maxSize = MAX_CACHE_SIZE) {
+  if (cache.size > maxSize) {
+    const keysToDelete = Array.from(cache.keys()).slice(0, cache.size - maxSize);
+    keysToDelete.forEach(key => cache.delete(key));
+  }
+}
+
+/**
+ * Check if a file exists (cached)
+ * @param {string} filepath - Path to check
+ * @returns {boolean}
+ */
+function existsCached(filepath) {
+  if (_existsCache.has(filepath)) {
+    return _existsCache.get(filepath);
+  }
+  const exists = fs.existsSync(filepath);
+  _existsCache.set(filepath, exists);
+  enforceMaxCacheSize(_existsCache);
+  return exists;
+}
+
+/**
+ * Check if a file exists (cached, async)
+ * @param {string} filepath - Path to check
+ * @returns {Promise<boolean>}
+ */
+async function existsCachedAsync(filepath) {
+  if (_existsCache.has(filepath)) {
+    return _existsCache.get(filepath);
+  }
+  try {
+    await fsPromises.access(filepath);
+    _existsCache.set(filepath, true);
+    enforceMaxCacheSize(_existsCache);
+    return true;
+  } catch {
+    _existsCache.set(filepath, false);
+    enforceMaxCacheSize(_existsCache);
+    return false;
+  }
+}
+
+/**
+ * Read file contents (cached)
+ * @param {string} filepath - Path to read
+ * @returns {string|null}
+ */
+function readFileCached(filepath) {
+  if (_fileCache.has(filepath)) {
+    return _fileCache.get(filepath);
+  }
+  try {
+    const content = fs.readFileSync(filepath, 'utf8');
+    _fileCache.set(filepath, content);
+    enforceMaxCacheSize(_fileCache);
+    return content;
+  } catch {
+    _fileCache.set(filepath, null);
+    enforceMaxCacheSize(_fileCache);
+    return null;
+  }
+}
+
+/**
+ * Read file contents (cached, async)
+ * @param {string} filepath - Path to read
+ * @returns {Promise<string|null>}
+ */
+async function readFileCachedAsync(filepath) {
+  if (_fileCache.has(filepath)) {
+    return _fileCache.get(filepath);
+  }
+  try {
+    const content = await fsPromises.readFile(filepath, 'utf8');
+    _fileCache.set(filepath, content);
+    enforceMaxCacheSize(_fileCache);
+    return content;
+  } catch {
+    _fileCache.set(filepath, null);
+    enforceMaxCacheSize(_fileCache);
+    return null;
+  }
+}
+
+/**
+ * Detects CI platform by scanning for configuration files
+ * @returns {string|null} CI platform name or null if not detected
+ */
+function detectCI() {
+  if (existsCached('.github/workflows')) return 'github-actions';
+  if (existsCached('.gitlab-ci.yml')) return 'gitlab-ci';
+  if (existsCached('.circleci/config.yml')) return 'circleci';
+  if (existsCached('Jenkinsfile')) return 'jenkins';
+  if (existsCached('.travis.yml')) return 'travis';
+  return null;
+}
+
+/**
+ * Detects CI platform by scanning for configuration files (async)
+ * @returns {Promise<string|null>} CI platform name or null if not detected
+ */
+async function detectCIAsync() {
+  const checks = await Promise.all([
+    existsCachedAsync('.github/workflows'),
+    existsCachedAsync('.gitlab-ci.yml'),
+    existsCachedAsync('.circleci/config.yml'),
+    existsCachedAsync('Jenkinsfile'),
+    existsCachedAsync('.travis.yml')
+  ]);
+
+  if (checks[0]) return 'github-actions';
+  if (checks[1]) return 'gitlab-ci';
+  if (checks[2]) return 'circleci';
+  if (checks[3]) return 'jenkins';
+  if (checks[4]) return 'travis';
+  return null;
+}
+
+/**
+ * Detects deployment platform by scanning for platform-specific files
+ * @returns {string|null} Deployment platform name or null if not detected
+ */
+function detectDeployment() {
+  if (existsCached('railway.json') || existsCached('railway.toml')) return 'railway';
+  if (existsCached('vercel.json')) return 'vercel';
+  if (existsCached('netlify.toml') || existsCached('.netlify')) return 'netlify';
+  if (existsCached('fly.toml')) return 'fly';
+  if (existsCached('.platform.sh')) return 'platform-sh';
+  if (existsCached('render.yaml')) return 'render';
+  return null;
+}
+
+/**
+ * Detects deployment platform by scanning for platform-specific files (async)
+ * @returns {Promise<string|null>} Deployment platform name or null if not detected
+ */
+async function detectDeploymentAsync() {
+  const checks = await Promise.all([
+    existsCachedAsync('railway.json'),
+    existsCachedAsync('railway.toml'),
+    existsCachedAsync('vercel.json'),
+    existsCachedAsync('netlify.toml'),
+    existsCachedAsync('.netlify'),
+    existsCachedAsync('fly.toml'),
+    existsCachedAsync('.platform.sh'),
+    existsCachedAsync('render.yaml')
+  ]);
+
+  if (checks[0] || checks[1]) return 'railway';
+  if (checks[2]) return 'vercel';
+  if (checks[3] || checks[4]) return 'netlify';
+  if (checks[5]) return 'fly';
+  if (checks[6]) return 'platform-sh';
+  if (checks[7]) return 'render';
+  return null;
+}
+
+/**
+ * Detects project type by scanning for language-specific files
+ * @returns {string} Project type identifier
+ */
+function detectProjectType() {
+  if (existsCached('package.json')) return 'nodejs';
+  if (existsCached('requirements.txt') || existsCached('pyproject.toml') || existsCached('setup.py')) return 'python';
+  if (existsCached('Cargo.toml')) return 'rust';
+  if (existsCached('go.mod')) return 'go';
+  if (existsCached('pom.xml') || existsCached('build.gradle')) return 'java';
+  return 'unknown';
+}
+
+/**
+ * Detects project type by scanning for language-specific files (async)
+ * @returns {Promise<string>} Project type identifier
+ */
+async function detectProjectTypeAsync() {
+  const checks = await Promise.all([
+    existsCachedAsync('package.json'),
+    existsCachedAsync('requirements.txt'),
+    existsCachedAsync('pyproject.toml'),
+    existsCachedAsync('setup.py'),
+    existsCachedAsync('Cargo.toml'),
+    existsCachedAsync('go.mod'),
+    existsCachedAsync('pom.xml'),
+    existsCachedAsync('build.gradle')
+  ]);
+
+  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';
+}
+
+/**
+ * Detects package manager by scanning for lockfiles
+ * @returns {string|null} Package manager name or null if not detected
+ */
+function detectPackageManager() {
+  if (existsCached('pnpm-lock.yaml')) return 'pnpm';
+  if (existsCached('yarn.lock')) return 'yarn';
+  if (existsCached('bun.lockb')) return 'bun';
+  if (existsCached('package-lock.json')) return 'npm';
+  if (existsCached('poetry.lock')) return 'poetry';
+  if (existsCached('Pipfile.lock')) return 'pipenv';
+  if (existsCached('Cargo.lock')) return 'cargo';
+  if (existsCached('go.sum')) return 'go';
+  return null;
+}
+
+/**
+ * Detects package manager by scanning for lockfiles (async)
+ * @returns {Promise<string|null>} Package manager name or null if not detected
+ */
+async function detectPackageManagerAsync() {
+  const checks = await Promise.all([
+    existsCachedAsync('pnpm-lock.yaml'),
+    existsCachedAsync('yarn.lock'),
+    existsCachedAsync('bun.lockb'),
+    existsCachedAsync('package-lock.json'),
+    existsCachedAsync('poetry.lock'),
+    existsCachedAsync('Pipfile.lock'),
+    existsCachedAsync('Cargo.lock'),
+    existsCachedAsync('go.sum')
+  ]);
+
+  if (checks[0]) return 'pnpm';
+  if (checks[1]) return 'yarn';
+  if (checks[2]) return 'bun';
+  if (checks[3]) return 'npm';
+  if (checks[4]) return 'poetry';
+  if (checks[5]) return 'pipenv';
+  if (checks[6]) return 'cargo';
+  if (checks[7]) return 'go';
+  return null;
+}
+
+/**
+ * Detects branch strategy (single-branch vs multi-branch with dev+prod)
+ * @returns {string} 'single-branch' or 'multi-branch'
+ */
+function detectBranchStrategy() {
+  try {
+    // Check both local and remote branches
+    const localBranches = execSync('git branch', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
+    let remoteBranches = '';
+    try {
+      remoteBranches = execSync('git branch -r', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
+    } catch {}
+
+    const allBranches = localBranches + remoteBranches;
+
+    const hasStable = allBranches.includes('stable');
+    const hasProduction = allBranches.includes('production') || allBranches.includes('prod');
+
+    if (hasStable || hasProduction) {
+      return 'multi-branch'; // dev + prod workflow
+    }
+
+    // Check deployment configs for multi-environment setup (uses cache)
+    if (existsCached('railway.json')) {
+      try {
+        const content = readFileCached('railway.json');
+        if (content) {
+          const config = JSON.parse(content);
+          // Validate JSON structure before accessing properties
+          if (config &&
+              typeof config === 'object' &&
+              typeof config.environments === 'object' &&
+              config.environments !== null &&
+              Object.keys(config.environments).length > 1) {
+            return 'multi-branch';
+          }
+        }
+      } catch {}
+    }
+
+    return 'single-branch'; // main only
+  } catch {
+    return 'single-branch';
+  }
+}
+
+/**
+ * Detects branch strategy (single-branch vs multi-branch with dev+prod) (async)
+ * @returns {Promise<string>} 'single-branch' or 'multi-branch'
+ */
+async function detectBranchStrategyAsync() {
+  try {
+    // Run git commands in parallel
+    const [localResult, remoteResult] = await Promise.all([
+      execAsync('git branch', { encoding: 'utf8' }).catch(() => ({ stdout: '' })),
+      execAsync('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';
+    }
+
+    // Check deployment configs for multi-environment setup (uses cache)
+    if (await existsCachedAsync('railway.json')) {
+      try {
+        const content = await readFileCachedAsync('railway.json');
+        if (content) {
+          const config = JSON.parse(content);
+          if (config &&
+              typeof config === 'object' &&
+              typeof config.environments === 'object' &&
+              config.environments !== null &&
+              Object.keys(config.environments).length > 1) {
+            return 'multi-branch';
+          }
+        }
+      } catch {}
+    }
+
+    return 'single-branch';
+  } catch {
+    return 'single-branch';
+  }
+}
+
+/**
+ * Detects the main branch name
+ * @returns {string} Main branch name ('main' or 'master')
+ */
+function detectMainBranch() {
+  try {
+    const defaultBranch = execSync('git symbolic-ref refs/remotes/origin/HEAD', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'ignore']
+    })
+      .trim()
+      .replace('refs/remotes/origin/', '');
+    return defaultBranch;
+  } catch {
+    // Fallback: check common names
+    try {
+      execSync('git rev-parse --verify main', {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'ignore']
+      });
+      return 'main';
+    } catch {
+      return 'master';
+    }
+  }
+}
+
+/**
+ * Detects the main branch name (async)
+ * @returns {Promise<string>} Main branch name ('main' or 'master')
+ */
+async function detectMainBranchAsync() {
+  try {
+    const { stdout } = await execAsync('git symbolic-ref refs/remotes/origin/HEAD', { encoding: 'utf8' });
+    return stdout.trim().replace('refs/remotes/origin/', '');
+  } catch {
+    // Fallback: check common names
+    try {
+      await execAsync('git rev-parse --verify main', { encoding: 'utf8' });
+      return 'main';
+    } catch {
+      return 'master';
+    }
+  }
+}
+
+/**
+ * Main detection function - aggregates all platform information (sync)
+ * Uses caching to avoid repeated filesystem/git operations
+ * @param {boolean} forceRefresh - Force cache refresh
+ * @returns {Object} Platform configuration object
+ */
+function detect(forceRefresh = false) {
+  const now = Date.now();
+
+  // Return cached result if still valid
+  if (!forceRefresh && _cachedDetection && now < _cacheExpiry) {
+    return _cachedDetection;
+  }
+
+  _cachedDetection = {
+    ci: detectCI(),
+    deployment: detectDeployment(),
+    projectType: detectProjectType(),
+    packageManager: detectPackageManager(),
+    branchStrategy: detectBranchStrategy(),
+    mainBranch: detectMainBranch(),
+    hasPlanFile: existsCached('PLAN.md'),
+    hasTechDebtFile: existsCached('TECHNICAL_DEBT.md'),
+    timestamp: new Date(now).toISOString()
+  };
+  _cacheExpiry = now + CACHE_TTL_MS;
+
+  return _cachedDetection;
+}
+
+/**
+ * Main detection function - aggregates all platform information (async)
+ * Uses Promise.all for parallel execution and caching
+ * @param {boolean} forceRefresh - Force cache refresh
+ * @returns {Promise<Object>} Platform configuration object
+ */
+async function detectAsync(forceRefresh = false) {
+  const now = Date.now();
+
+  // Return cached result if still valid
+  if (!forceRefresh && _cachedDetection && now < _cacheExpiry) {
+    return _cachedDetection;
+  }
+
+  // Run all detections in parallel
+  const [
+    ci,
+    deployment,
+    projectType,
+    packageManager,
+    branchStrategy,
+    mainBranch,
+    hasPlanFile,
+    hasTechDebtFile
+  ] = await Promise.all([
+    detectCIAsync(),
+    detectDeploymentAsync(),
+    detectProjectTypeAsync(),
+    detectPackageManagerAsync(),
+    detectBranchStrategyAsync(),
+    detectMainBranchAsync(),
+    existsCachedAsync('PLAN.md'),
+    existsCachedAsync('TECHNICAL_DEBT.md')
+  ]);
+
+  _cachedDetection = {
+    ci,
+    deployment,
+    projectType,
+    packageManager,
+    branchStrategy,
+    mainBranch,
+    hasPlanFile,
+    hasTechDebtFile,
+    timestamp: new Date(now).toISOString()
+  };
+  _cacheExpiry = now + CACHE_TTL_MS;
+
+  return _cachedDetection;
+}
+
+/**
+ * Invalidate the detection cache
+ * Call this after making changes that affect platform detection
+ */
+function invalidateCache() {
+  _cachedDetection = null;
+  _cacheExpiry = 0;
+  _fileCache.clear();
+  _existsCache.clear();
+}
+
+// When run directly, output JSON (uses async for better performance)
+if (require.main === module) {
+  (async () => {
+    try {
+      const result = await detectAsync();
+      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 = {
+  detect,
+  detectAsync,
+  invalidateCache,
+  detectCI,
+  detectCIAsync,
+  detectDeployment,
+  detectDeploymentAsync,
+  detectProjectType,
+  detectProjectTypeAsync,
+  detectPackageManager,
+  detectPackageManagerAsync,
+  detectBranchStrategy,
+  detectBranchStrategyAsync,
+  detectMainBranch,
+  detectMainBranchAsync
+};