awesome-slash 2.5.0 → 2.5.1

package/plugins/deslop-around/lib/platform/detect-platform.js

@@ -12,14 +12,13 @@
 
 const fs = require('fs');
 const path = require('path');
-const { execSync, exec } = require('child_process');
+const { exec } = require('child_process');
 const { promisify } = require('util');
 
 const execAsync = promisify(exec);
 const fsPromises = fs.promises;
 
 // Import shared utilities
-const { warnDeprecation, _resetDeprecationWarnings } = require('../utils/deprecation');
 const { CacheManager } = require('../utils/cache-manager');
 const {
   CI_CONFIGS,
@@ -48,7 +47,6 @@ function safeJSONParse(content, filename = 'unknown') {
     return null;
   }
   if (content.length > MAX_JSON_SIZE_BYTES) {
-    // File too large - skip parsing to prevent DoS
     return null;
   }
   try {
@@ -85,48 +83,29 @@ function withTimeout(promise, timeoutMs = DEFAULT_ASYNC_TIMEOUT_MS, operation =
  * @param {number} timeoutMs - Timeout in milliseconds
  * @returns {Promise<{stdout: string, stderr: string}>}
  */
-async function execAsyncWithTimeout(cmd, options = {}, timeoutMs = DEFAULT_ASYNC_TIMEOUT_MS) {
+async function execWithTimeout(cmd, options = {}, timeoutMs = DEFAULT_ASYNC_TIMEOUT_MS) {
   return withTimeout(execAsync(cmd, options), timeoutMs, `exec: ${cmd.substring(0, 50)}`);
 }
 
-// Maximum JSON file size and cached file size constants
+// 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 }); // Single detection result, 1 min TTL
+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 });
 
-// Note: enforceMaxCacheSize() removed - now handled by CacheManager internally
-
-/**
- * Generic file-based detector (synchronous)
- * @param {Array} configs - Array of {file, platform} objects
- * @param {Function} existsChecker - Function to check file existence
- * @returns {string|null} Detected platform or null
- */
-function detectFromFiles(configs, existsChecker) {
-  for (const { file, platform } of configs) {
-    if (existsChecker(file)) {
-      return platform;
-    }
-  }
-  return null;
-}
-
 /**
- * Generic file-based detector (asynchronous)
+ * 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 detectFromFilesAsync(configs, existsChecker) {
-  // Check all files in parallel for better performance
+async function detectFromFiles(configs, existsChecker) {
   const checks = await Promise.all(
     configs.map(({ file }) => existsChecker(file))
   );
 
-  // Return first match (maintains priority order)
   for (let i = 0; i < checks.length; i++) {
     if (checks[i]) {
       return configs[i].platform;
@@ -138,24 +117,9 @@ async function detectFromFilesAsync(configs, existsChecker) {
 /**
  * Check if a file exists (cached)
  * @param {string} filepath - Path to check
- * @returns {boolean}
- */
-function existsCached(filepath) {
-  const cached = _existsCache.get(filepath);
-  if (cached !== undefined) {
-    return cached;
-  }
-  const exists = fs.existsSync(filepath);
-  _existsCache.set(filepath, exists);
-  return exists;
-}
-
-/**
- * Check if a file exists (cached, async)
- * @param {string} filepath - Path to check
  * @returns {Promise<boolean>}
  */
-async function existsCachedAsync(filepath) {
+async function existsCached(filepath) {
   const cached = _existsCache.get(filepath);
   if (cached !== undefined) {
     return cached;
@@ -175,39 +139,9 @@ async function existsCachedAsync(filepath) {
  * 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 {string|null}
- */
-function readFileCached(filepath) {
-  // Normalize filepath to prevent cache pollution (./foo vs foo vs /abs/foo)
-  // This ensures that different representations of the same path use the same cache entry
-  const normalizedPath = path.resolve(filepath);
-
-  const cached = _fileCache.get(normalizedPath);
-  if (cached !== undefined) {
-    return cached;
-  }
-  try {
-    const content = fs.readFileSync(normalizedPath, 'utf8');
-    // CacheManager enforces maxValueSize, so small files are cached automatically
-    _fileCache.set(normalizedPath, content);
-    return content;
-  } catch {
-    // Cache null for missing files (small memory footprint)
-    _fileCache.set(normalizedPath, null);
-    return null;
-  }
-}
-
-/**
- * Read file contents (cached, async)
- * 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 readFileCachedAsync(filepath) {
-  // Normalize filepath to prevent cache pollution (./foo vs foo vs /abs/foo)
-  // This ensures that different representations of the same path use the same cache entry
+async function readFileCached(filepath) {
   const normalizedPath = path.resolve(filepath);
 
   const cached = _fileCache.get(normalizedPath);
@@ -216,11 +150,9 @@ async function readFileCachedAsync(filepath) {
   }
   try {
     const content = await fsPromises.readFile(normalizedPath, 'utf8');
-    // CacheManager enforces maxValueSize, so small files are cached automatically
     _fileCache.set(normalizedPath, content);
     return content;
   } catch {
-    // Cache null for missing files (small memory footprint)
     _fileCache.set(normalizedPath, null);
     return null;
   }
@@ -228,69 +160,34 @@ async function readFileCachedAsync(filepath) {
 
 /**
  * Detects CI platform by scanning for configuration files
- * @deprecated Use detectCIAsync() instead. Will be removed in v3.0.0.
- * @returns {string|null} CI platform name or null if not detected
- */
-function detectCI() {
-  warnDeprecation('detectCI', 'detectCIAsync');
-  return detectFromFiles(CI_CONFIGS, existsCached);
-}
-
-/**
- * Detects CI platform by scanning for configuration files (async)
  * @returns {Promise<string|null>} CI platform name or null if not detected
  */
-async function detectCIAsync() {
-  return detectFromFilesAsync(CI_CONFIGS, existsCachedAsync);
+async function detectCI() {
+  return detectFromFiles(CI_CONFIGS, existsCached);
 }
 
 /**
  * Detects deployment platform by scanning for platform-specific files
- * @deprecated Use detectDeploymentAsync() instead. Will be removed in v3.0.0.
- * @returns {string|null} Deployment platform name or null if not detected
- */
-function detectDeployment() {
-  warnDeprecation('detectDeployment', 'detectDeploymentAsync');
-  return detectFromFiles(DEPLOYMENT_CONFIGS, existsCached);
-}
-
-/**
- * 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() {
-  return detectFromFilesAsync(DEPLOYMENT_CONFIGS, existsCachedAsync);
+async function detectDeployment() {
+  return detectFromFiles(DEPLOYMENT_CONFIGS, existsCached);
 }
 
 /**
  * Detects project type by scanning for language-specific files
- * @deprecated Use detectProjectTypeAsync() instead. Will be removed in v3.0.0.
- * @returns {string} Project type identifier
- */
-function detectProjectType() {
-  warnDeprecation('detectProjectType', 'detectProjectTypeAsync');
-  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() {
+async function detectProjectType() {
   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')
+    existsCached('package.json'),
+    existsCached('requirements.txt'),
+    existsCached('pyproject.toml'),
+    existsCached('setup.py'),
+    existsCached('Cargo.toml'),
+    existsCached('go.mod'),
+    existsCached('pom.xml'),
+    existsCached('build.gradle')
   ]);
 
   if (checks[0]) return 'nodejs';
@@ -303,86 +200,24 @@ async function detectProjectTypeAsync() {
 
 /**
  * Detects package manager by scanning for lockfiles
- * @deprecated Use detectPackageManagerAsync() instead. Will be removed in v3.0.0.
- * @returns {string|null} Package manager name or null if not detected
+ * @returns {Promise<string|null>} Package manager name or null if not detected
  */
-function detectPackageManager() {
-  warnDeprecation('detectPackageManager', 'detectPackageManagerAsync');
+async function detectPackageManager() {
   return detectFromFiles(
     PACKAGE_MANAGER_CONFIGS.map(({ file, manager }) => ({ file, platform: manager })),
     existsCached
   );
 }
 
-/**
- * Detects package manager by scanning for lockfiles (async)
- * @returns {Promise<string|null>} Package manager name or null if not detected
- */
-async function detectPackageManagerAsync() {
-  return detectFromFilesAsync(
-    PACKAGE_MANAGER_CONFIGS.map(({ file, manager }) => ({ file, platform: manager })),
-    existsCachedAsync
-  );
-}
-
 /**
  * Detects branch strategy (single-branch vs multi-branch with dev+prod)
- * @deprecated Use detectBranchStrategyAsync() instead. Will be removed in v3.0.0.
- * @returns {string} 'single-branch' or 'multi-branch'
- */
-function detectBranchStrategy() {
-  warnDeprecation('detectBranchStrategy', 'detectBranchStrategyAsync');
-  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 = safeJSONParse(content, 'railway.json');
-          // 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() {
+async function detectBranchStrategy() {
   try {
-    // Run git commands in parallel with timeout protection
     const [localResult, remoteResult] = await Promise.all([
-      execAsyncWithTimeout('git branch', { encoding: 'utf8' }).catch(() => ({ stdout: '' })),
-      execAsyncWithTimeout('git branch -r', { encoding: 'utf8' }).catch(() => ({ stdout: '' }))
+      execWithTimeout('git branch', { encoding: 'utf8' }).catch(() => ({ stdout: '' })),
+      execWithTimeout('git branch -r', { encoding: 'utf8' }).catch(() => ({ stdout: '' }))
     ]);
 
     const allBranches = (localResult.stdout || '') + (remoteResult.stdout || '');
@@ -394,10 +229,9 @@ async function detectBranchStrategyAsync() {
       return 'multi-branch';
     }
 
-    // Check deployment configs for multi-environment setup (uses cache)
-    if (await existsCachedAsync('railway.json')) {
+    if (await existsCached('railway.json')) {
       try {
-        const content = await readFileCachedAsync('railway.json');
+        const content = await readFileCached('railway.json');
         if (content) {
           const config = safeJSONParse(content, 'railway.json');
           if (config &&
@@ -419,45 +253,15 @@ async function detectBranchStrategyAsync() {
 
 /**
  * Detects the main branch name
- * @deprecated Use detectMainBranchAsync() instead. Will be removed in v3.0.0.
- * @returns {string} Main branch name ('main' or 'master')
- */
-function detectMainBranch() {
-  warnDeprecation('detectMainBranch', 'detectMainBranchAsync');
-  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() {
+async function detectMainBranch() {
   try {
-    const { stdout } = await execAsyncWithTimeout('git symbolic-ref refs/remotes/origin/HEAD', { encoding: 'utf8' });
+    const { stdout } = await execWithTimeout('git symbolic-ref refs/remotes/origin/HEAD', { encoding: 'utf8' });
     return stdout.trim().replace('refs/remotes/origin/', '');
   } catch {
-    // Fallback: check common names
     try {
-      await execAsyncWithTimeout('git rev-parse --verify main', { encoding: 'utf8' });
+      await execWithTimeout('git rev-parse --verify main', { encoding: 'utf8' });
       return 'main';
     } catch {
       return 'master';
@@ -466,47 +270,12 @@ async function detectMainBranchAsync() {
 }
 
 /**
- * Main detection function - aggregates all platform information (sync)
- * Uses caching to avoid repeated filesystem/git operations
- * @deprecated Use detectAsync() instead. Will be removed in v3.0.0.
- * @param {boolean} forceRefresh - Force cache refresh
- * @returns {Object} Platform configuration object
- */
-function detect(forceRefresh = false) {
-  warnDeprecation('detect', 'detectAsync');
-
-  // Return cached result if still valid
-  if (!forceRefresh) {
-    const cached = _detectionCache.get('detection');
-    if (cached !== undefined) {
-      return cached;
-    }
-  }
-
-  const detection = {
-    ci: detectCI(),
-    deployment: detectDeployment(),
-    projectType: detectProjectType(),
-    packageManager: detectPackageManager(),
-    branchStrategy: detectBranchStrategy(),
-    mainBranch: detectMainBranch(),
-    hasPlanFile: existsCached('PLAN.md'),
-    hasTechDebtFile: existsCached('TECHNICAL_DEBT.md'),
-    timestamp: new Date().toISOString()
-  };
-
-  _detectionCache.set('detection', detection);
-  return detection;
-}
-
-/**
- * Main detection function - aggregates all platform information (async)
+ * 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 detectAsync(forceRefresh = false) {
-  // Return cached result if still valid
+async function detect(forceRefresh = false) {
   if (!forceRefresh) {
     const cached = _detectionCache.get('detection');
     if (cached !== undefined) {
@@ -514,7 +283,6 @@ async function detectAsync(forceRefresh = false) {
     }
   }
 
-  // Run all detections in parallel
   const [
     ci,
     deployment,
@@ -525,14 +293,14 @@ async function detectAsync(forceRefresh = false) {
     hasPlanFile,
     hasTechDebtFile
   ] = await Promise.all([
-    detectCIAsync(),
-    detectDeploymentAsync(),
-    detectProjectTypeAsync(),
-    detectPackageManagerAsync(),
-    detectBranchStrategyAsync(),
-    detectMainBranchAsync(),
-    existsCachedAsync('PLAN.md'),
-    existsCachedAsync('TECHNICAL_DEBT.md')
+    detectCI(),
+    detectDeployment(),
+    detectProjectType(),
+    detectPackageManager(),
+    detectBranchStrategy(),
+    detectMainBranch(),
+    existsCached('PLAN.md'),
+    existsCached('TECHNICAL_DEBT.md')
   ]);
 
   const detection = {
@@ -561,13 +329,11 @@ function invalidateCache() {
   _existsCache.clear();
 }
 
-// When run directly, output JSON (uses async for better performance)
+// When run directly, output JSON
 if (require.main === module) {
   (async () => {
     try {
-      const result = await detectAsync();
-      // Optimize: only use pretty-printing when output is to terminal (TTY)
-      // When piped to another program, use compact JSON for better performance
+      const result = await detect();
       const indent = process.stdout.isTTY ? 2 : 0;
       console.log(JSON.stringify(result, null, indent));
     } catch (error) {
@@ -584,20 +350,11 @@ if (require.main === module) {
 // Export for use as module
 module.exports = {
   detect,
-  detectAsync,
   invalidateCache,
   detectCI,
-  detectCIAsync,
   detectDeployment,
-  detectDeploymentAsync,
   detectProjectType,
-  detectProjectTypeAsync,
   detectPackageManager,
-  detectPackageManagerAsync,
   detectBranchStrategy,
-  detectBranchStrategyAsync,
-  detectMainBranch,
-  detectMainBranchAsync,
-  // Testing utilities (prefixed with _ to indicate internal use)
-  _resetDeprecationWarnings
+  detectMainBranch
 };

package/plugins/deslop-around/lib/platform/state-dir.js

@@ -0,0 +1,122 @@
+/**
+ * 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)
+ * @type {string|null}
+ */
+let _cachedStateDir = null;
+
+/**
+ * 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;
+  }
+
+  // Return cached value if available
+  if (_cachedStateDir) {
+    return _cachedStateDir;
+  }
+
+  // OpenCode detection
+  if (process.env.OPENCODE_CONFIG || process.env.OPENCODE_CONFIG_DIR) {
+    _cachedStateDir = '.opencode';
+    return _cachedStateDir;
+  }
+
+  // Check for .opencode directory in project
+  try {
+    const opencodePath = path.join(basePath, '.opencode');
+    if (fs.existsSync(opencodePath) && fs.statSync(opencodePath).isDirectory()) {
+      _cachedStateDir = '.opencode';
+      return _cachedStateDir;
+    }
+  } catch {
+    // Ignore errors, continue detection
+  }
+
+  // Codex detection
+  if (process.env.CODEX_HOME) {
+    _cachedStateDir = '.codex';
+    return _cachedStateDir;
+  }
+
+  // Check for .codex directory in project
+  try {
+    const codexPath = path.join(basePath, '.codex');
+    if (fs.existsSync(codexPath) && fs.statSync(codexPath).isDirectory()) {
+      _cachedStateDir = '.codex';
+      return _cachedStateDir;
+    }
+  } catch {
+    // Ignore errors, continue detection
+  }
+
+  // Default to Claude Code
+  _cachedStateDir = '.claude';
+  return _cachedStateDir;
+}
+
+/**
+ * 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() {
+  _cachedStateDir = null;
+}
+
+module.exports = {
+  getStateDir,
+  getStateDirPath,
+  getPlatformName,
+  clearCache
+};