awesome-slash 2.4.4 → 2.5.1

package/plugins/deslop-around/lib/index.js

@@ -0,0 +1,170 @@
+/**
+ * Awesome-Slash Core Library
+ *
+ * Unified entry point for all core library modules.
+ * Provides platform detection, pattern matching, workflow state management,
+ * configuration management, and context optimization utilities.
+ *
+ * @module awesome-slash/lib
+ * @author Avi Fenesh
+ * @license MIT
+ */
+
+const detectPlatform = require('./platform/detect-platform');
+const verifyTools = require('./platform/verify-tools');
+const reviewPatterns = require('./patterns/review-patterns');
+const slopPatterns = require('./patterns/slop-patterns');
+const workflowState = require('./state/workflow-state');
+const contextOptimizer = require('./utils/context-optimizer');
+const shellEscape = require('./utils/shell-escape');
+const config = require('./config');
+const sourceCache = require('./sources/source-cache');
+const customHandler = require('./sources/custom-handler');
+const policyQuestions = require('./sources/policy-questions');
+
+/**
+ * Platform detection and verification utilities
+ */
+const platform = {
+  /**
+   * Detect project platform configuration
+   * @see module:platform/detect-platform
+   */
+  detect: detectPlatform.detect,
+  detectAsync: detectPlatform.detectAsync,
+  detectCI: detectPlatform.detectCI,
+  detectDeployment: detectPlatform.detectDeployment,
+  detectProjectType: detectPlatform.detectProjectType,
+  detectPackageManager: detectPlatform.detectPackageManager,
+  detectBranchStrategy: detectPlatform.detectBranchStrategy,
+  detectMainBranch: detectPlatform.detectMainBranch,
+  invalidateCache: detectPlatform.invalidateCache,
+
+  /**
+   * Verify tool availability
+   * @see module:platform/verify-tools
+   */
+  verifyTools: verifyTools.verify,
+  verifyToolsAsync: verifyTools.verifyAsync,
+  checkTool: verifyTools.checkTool,
+  checkToolAsync: verifyTools.checkToolAsync,
+  TOOL_DEFINITIONS: verifyTools.TOOL_DEFINITIONS
+};
+
+/**
+ * Code pattern matching utilities
+ */
+const patterns = {
+  /**
+   * Review patterns for code quality analysis
+   * @see module:patterns/review-patterns
+   */
+  review: reviewPatterns,
+
+  /**
+   * Slop patterns for AI-generated code detection
+   * @see module:patterns/slop-patterns
+   */
+  slop: slopPatterns
+};
+
+/**
+ * Workflow state management
+ * @see module:state/workflow-state
+ */
+const state = {
+  // Constants
+  SCHEMA_VERSION: workflowState.SCHEMA_VERSION,
+  PHASES: workflowState.PHASES,
+  DEFAULT_POLICY: workflowState.DEFAULT_POLICY,
+
+  // Core functions
+  generateWorkflowId: workflowState.generateWorkflowId,
+  getStatePath: workflowState.getStatePath,
+  ensureStateDir: workflowState.ensureStateDir,
+  validateStateSchema: workflowState.validateStateSchema,
+
+  // CRUD operations
+  createState: workflowState.createState,
+  readState: workflowState.readState,
+  writeState: workflowState.writeState,
+  updateState: workflowState.updateState,
+  deleteState: workflowState.deleteState,
+
+  // Phase management
+  startPhase: workflowState.startPhase,
+  completePhase: workflowState.completePhase,
+  failPhase: workflowState.failPhase,
+  skipToPhase: workflowState.skipToPhase,
+
+  // Workflow lifecycle
+  completeWorkflow: workflowState.completeWorkflow,
+  abortWorkflow: workflowState.abortWorkflow,
+  hasActiveWorkflow: workflowState.hasActiveWorkflow,
+  getWorkflowSummary: workflowState.getWorkflowSummary,
+
+  // Agent management
+  updateAgentResult: workflowState.updateAgentResult,
+  incrementIteration: workflowState.incrementIteration
+};
+
+/**
+ * Git command optimization and string escaping utilities
+ * @see module:utils/context-optimizer
+ * @see module:utils/shell-escape
+ */
+const utils = {
+  contextOptimizer,
+  shellEscape
+};
+
+/**
+ * Task source management
+ * @see module:sources/source-cache
+ * @see module:sources/custom-handler
+ * @see module:sources/policy-questions
+ */
+const sources = {
+  // Main entry point - returns ready-to-use question structure
+  getPolicyQuestions: policyQuestions.getPolicyQuestions,
+  getCustomTypeQuestions: policyQuestions.getCustomTypeQuestions,
+  getCustomNameQuestion: policyQuestions.getCustomNameQuestion,
+  parseAndCachePolicy: policyQuestions.parseAndCachePolicy,
+  isUsingCached: policyQuestions.isUsingCached,
+  needsCustomFollowUp: policyQuestions.needsCustomFollowUp,
+  needsOtherDescription: policyQuestions.needsOtherDescription,
+
+  // Cache operations (direct access if needed)
+  getPreference: sourceCache.getPreference,
+  savePreference: sourceCache.savePreference,
+  getToolCapabilities: sourceCache.getToolCapabilities,
+  saveToolCapabilities: sourceCache.saveToolCapabilities,
+  clearCache: sourceCache.clearCache,
+
+  // Custom source handling (direct access if needed)
+  SOURCE_TYPES: customHandler.SOURCE_TYPES,
+  probeCLI: customHandler.probeCLI,
+  buildCustomConfig: customHandler.buildCustomConfig
+};
+
+// Main exports
+module.exports = {
+  platform,
+  patterns,
+  state,
+  utils,
+  config,
+  sources,
+
+  // Direct module access for backward compatibility
+  detectPlatform,
+  verifyTools,
+  reviewPatterns,
+  slopPatterns,
+  workflowState,
+  contextOptimizer,
+  shellEscape,
+  sourceCache,
+  customHandler,
+  policyQuestions
+};

package/plugins/deslop-around/lib/patterns/review-patterns.js

@@ -328,8 +328,24 @@ const _patternCountByFramework = new Map();
  */
 const _flattenedPatterns = new Map();
 
-// Build indexes at module load time
-(function buildIndexes() {
+/**
+ * Track if indexes have been built (lazy initialization)
+ */
+let _indexesBuilt = false;
+
+/**
+ * Cached arrays for getAvailableFrameworks/Categories (computed once)
+ */
+let _cachedFrameworks = null;
+let _cachedCategories = null;
+
+/**
+ * Build indexes on first access (lazy initialization)
+ * This improves module load time by deferring work until needed
+ */
+function ensureIndexesBuilt() {
+  if (_indexesBuilt) return;
+
   for (const [framework, categories] of Object.entries(reviewPatterns)) {
     let totalPatterns = 0;
     const flattened = [];
@@ -355,11 +371,13 @@ const _flattenedPatterns = new Map();
     _patternCountByFramework.set(framework, totalPatterns);
     _flattenedPatterns.set(framework, flattened);
   }
-})();
 
-// Freeze the index Sets
-Object.freeze(_frameworksSet);
-Object.freeze(_categoriesSet);
+  // Cache the arrays (avoid repeated Array.from calls)
+  _cachedFrameworks = Array.from(_frameworksSet);
+  _cachedCategories = Array.from(_categoriesSet);
+
+  _indexesBuilt = true;
+}
 
 /**
  * Get review patterns for a detected framework (O(1) lookup)
@@ -377,6 +395,7 @@ function getPatternsForFramework(framework) {
  * @returns {Map<string, Array>} Map of framework -> patterns for that category
  */
 function getPatternsByCategory(category) {
+  ensureIndexesBuilt();
   return _patternsByCategory.get(category) || new Map();
 }
 
@@ -393,19 +412,23 @@ function getPatternsForFrameworkCategory(framework, category) {
 }
 
 /**
- * Get all available frameworks (O(1) via pre-computed Set)
+ * Get all available frameworks (O(1) via cached array)
+ * Optimized: returns cached array instead of Array.from() on every call
  * @returns {Array<string>} List of framework names
  */
 function getAvailableFrameworks() {
-  return Array.from(_frameworksSet);
+  ensureIndexesBuilt();
+  return _cachedFrameworks;
 }
 
 /**
- * Get all available categories across all frameworks
+ * Get all available categories across all frameworks (O(1) via cached array)
+ * Optimized: returns cached array instead of Array.from() on every call
  * @returns {Array<string>} List of category names
  */
 function getAvailableCategories() {
-  return Array.from(_categoriesSet);
+  ensureIndexesBuilt();
+  return _cachedCategories;
 }
 
 /**
@@ -435,6 +458,7 @@ function hasPatternsFor(framework) {
  * @returns {boolean} True if category exists
  */
 function hasCategory(category) {
+  ensureIndexesBuilt();
   return _categoriesSet.has(category);
 }
 
@@ -444,6 +468,7 @@ function hasCategory(category) {
  * @returns {number} Number of patterns
  */
 function getPatternCount(framework) {
+  ensureIndexesBuilt();
   return _patternCountByFramework.get(framework.toLowerCase()) || 0;
 }
 
@@ -452,6 +477,7 @@ function getPatternCount(framework) {
  * @returns {number} Total pattern count
  */
 function getTotalPatternCount() {
+  ensureIndexesBuilt();
   let total = 0;
   for (const count of _patternCountByFramework.values()) {
     total += count;
@@ -461,17 +487,37 @@ function getTotalPatternCount() {
 
 /**
  * Search patterns by keyword across all frameworks
+ * Optimized: supports pagination to avoid returning thousands of results
  * @param {string} keyword - Search term (case-insensitive)
+ * @param {Object} [options] - Search options
+ * @param {number} [options.limit] - Maximum number of results (default: unlimited)
+ * @param {number} [options.offset=0] - Number of results to skip
  * @returns {Array<{framework: string, category: string, pattern: string}>} Matching patterns
  */
-function searchPatterns(keyword) {
+function searchPatterns(keyword, options = {}) {
+  ensureIndexesBuilt();
   const lowerKeyword = keyword.toLowerCase();
+  const { limit, offset = 0 } = options;
   const results = [];
+  let skipped = 0;
+  let collected = 0;
 
   for (const [framework, patterns] of _flattenedPatterns) {
     for (const { category, pattern } of patterns) {
       if (pattern.toLowerCase().includes(lowerKeyword)) {
+        // Skip results until we reach offset
+        if (skipped < offset) {
+          skipped++;
+          continue;
+        }
+
         results.push({ framework, category, pattern });
+        collected++;
+
+        // Stop if we've collected enough results
+        if (limit && collected >= limit) {
+          return results;
+        }
       }
     }
   }
@@ -485,6 +531,7 @@ function searchPatterns(keyword) {
  * @returns {Array<string>} List of frameworks with this category
  */
 function getFrameworksWithCategory(category) {
+  ensureIndexesBuilt();
   const categoryMap = _patternsByCategory.get(category);
   if (!categoryMap) return [];
   return Array.from(categoryMap.keys());