@fermindi/pwn-cli 0.1.0

package/src/patterns/triggers.js

@@ -0,0 +1,423 @@
+/**
+ * Trigger Evaluation Engine
+ *
+ * Evaluates triggers against file paths, content, and commands
+ * to determine which patterns should be auto-loaded.
+ *
+ * Trigger Types:
+ * - fileExt: Match file extensions (*.tsx, *.py)
+ * - path: Match directory paths (src/components/*)
+ * - import: Match import statements (import.*react)
+ * - keyword: Match code keywords (interface, class)
+ * - command: Match CLI commands (npm test, pnpm dev)
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, extname, relative, basename, dirname } from 'path';
+import { minimatch } from './matcher.js';
+
+/**
+ * Trigger definition
+ * @typedef {Object} Trigger
+ * @property {string} id - Unique identifier
+ * @property {string} name - Human-readable name
+ * @property {string} type - Trigger type (fileExt, path, import, keyword, command)
+ * @property {string|string[]} value - Pattern(s) to match
+ * @property {string[]} patterns - Pattern IDs to load when triggered
+ * @property {string} description - Trigger description
+ * @property {number} priority - Evaluation priority (higher = first)
+ * @property {boolean} enabled - Whether trigger is active
+ */
+
+/**
+ * Trigger type priorities (higher = evaluated first)
+ */
+const TYPE_PRIORITY = {
+  fileExt: 100,
+  path: 80,
+  import: 60,
+  keyword: 40,
+  command: 20
+};
+
+/**
+ * TriggerEngine - Evaluates triggers against context
+ */
+export class TriggerEngine {
+  constructor(workspacePath) {
+    this.workspacePath = workspacePath;
+    this.aiPath = join(workspacePath, '.ai');
+    this.triggersPath = join(this.aiPath, 'patterns', 'triggers.json');
+    this.triggers = new Map();
+    this.loaded = false;
+  }
+
+  /**
+   * Load triggers from configuration
+   */
+  async load() {
+    if (this.loaded) return;
+
+    if (existsSync(this.triggersPath)) {
+      try {
+        const data = JSON.parse(readFileSync(this.triggersPath, 'utf8'));
+        for (const trigger of data.triggers || []) {
+          this.triggers.set(trigger.id, trigger);
+        }
+      } catch (error) {
+        console.warn('⚠️  Could not load triggers:', error.message);
+      }
+    }
+
+    this.loaded = true;
+  }
+
+  /**
+   * Save triggers to configuration
+   */
+  async save() {
+    const dir = dirname(this.triggersPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+
+    const data = {
+      version: '1.0.0',
+      lastUpdated: new Date().toISOString(),
+      triggers: Array.from(this.triggers.values())
+    };
+
+    writeFileSync(this.triggersPath, JSON.stringify(data, null, 2));
+  }
+
+  /**
+   * Register a new trigger
+   * @param {Trigger} trigger
+   */
+  async register(trigger) {
+    // Generate ID if not provided
+    if (!trigger.id) {
+      trigger.id = `${trigger.type}-${Date.now()}`;
+    }
+
+    // Set defaults
+    trigger.priority = trigger.priority ?? TYPE_PRIORITY[trigger.type] ?? 0;
+    trigger.enabled = trigger.enabled ?? true;
+    trigger.patterns = trigger.patterns || [];
+
+    this.triggers.set(trigger.id, trigger);
+    await this.save();
+  }
+
+  /**
+   * Remove a trigger
+   * @param {string} id
+   */
+  async remove(id) {
+    this.triggers.delete(id);
+    await this.save();
+  }
+
+  /**
+   * Enable/disable a trigger
+   * @param {string} id
+   * @param {boolean} enabled
+   */
+  async setEnabled(id, enabled) {
+    const trigger = this.triggers.get(id);
+    if (trigger) {
+      trigger.enabled = enabled;
+      await this.save();
+    }
+  }
+
+  /**
+   * Get all triggers sorted by priority
+   * @returns {Trigger[]}
+   */
+  getAll() {
+    return Array.from(this.triggers.values())
+      .filter(t => t.enabled)
+      .sort((a, b) => b.priority - a.priority);
+  }
+
+  /**
+   * Get triggers by type
+   * @param {string} type
+   * @returns {Trigger[]}
+   */
+  getByType(type) {
+    return this.getAll().filter(t => t.type === type);
+  }
+
+  /**
+   * Evaluate all triggers against a file path
+   * @param {string} filePath - Absolute or relative file path
+   * @returns {EvaluationResult}
+   */
+  evaluateFile(filePath) {
+    const relPath = relative(this.workspacePath, filePath);
+    const ext = extname(filePath);
+    const name = basename(filePath);
+
+    const matched = [];
+    const patterns = new Set();
+
+    for (const trigger of this.getAll()) {
+      if (trigger.type === 'fileExt') {
+        if (this.matchFileExt(ext, name, trigger.value)) {
+          matched.push({ trigger, reason: `File extension matches ${trigger.value}` });
+          trigger.patterns.forEach(p => patterns.add(p));
+        }
+      } else if (trigger.type === 'path') {
+        if (this.matchPath(relPath, trigger.value)) {
+          matched.push({ trigger, reason: `Path matches ${trigger.value}` });
+          trigger.patterns.forEach(p => patterns.add(p));
+        }
+      }
+    }
+
+    return {
+      filePath: relPath,
+      matchedTriggers: matched,
+      patterns: Array.from(patterns)
+    };
+  }
+
+  /**
+   * Evaluate triggers against file content
+   * @param {string} content - File content
+   * @param {string} [filePath] - Optional file path for context
+   * @returns {EvaluationResult}
+   */
+  evaluateContent(content, filePath = null) {
+    const matched = [];
+    const patterns = new Set();
+
+    // Start with file-based evaluation if path provided
+    if (filePath) {
+      const fileResult = this.evaluateFile(filePath);
+      fileResult.matchedTriggers.forEach(m => matched.push(m));
+      fileResult.patterns.forEach(p => patterns.add(p));
+    }
+
+    // Evaluate import triggers
+    for (const trigger of this.getByType('import')) {
+      if (this.matchImport(content, trigger.value)) {
+        matched.push({ trigger, reason: `Import matches ${trigger.value}` });
+        trigger.patterns.forEach(p => patterns.add(p));
+      }
+    }
+
+    // Evaluate keyword triggers
+    for (const trigger of this.getByType('keyword')) {
+      if (this.matchKeyword(content, trigger.value)) {
+        matched.push({ trigger, reason: `Keyword matches ${trigger.value}` });
+        trigger.patterns.forEach(p => patterns.add(p));
+      }
+    }
+
+    return {
+      filePath: filePath ? relative(this.workspacePath, filePath) : null,
+      matchedTriggers: matched,
+      patterns: Array.from(patterns)
+    };
+  }
+
+  /**
+   * Evaluate triggers against a command
+   * @param {string} command - CLI command
+   * @returns {EvaluationResult}
+   */
+  evaluateCommand(command) {
+    const matched = [];
+    const patterns = new Set();
+
+    for (const trigger of this.getByType('command')) {
+      if (this.matchCommand(command, trigger.value)) {
+        matched.push({ trigger, reason: `Command matches ${trigger.value}` });
+        trigger.patterns.forEach(p => patterns.add(p));
+      }
+    }
+
+    return {
+      command,
+      matchedTriggers: matched,
+      patterns: Array.from(patterns)
+    };
+  }
+
+  /**
+   * Match file extension pattern
+   * @private
+   */
+  matchFileExt(ext, fileName, patterns) {
+    const values = Array.isArray(patterns) ? patterns : [patterns];
+
+    for (const pattern of values) {
+      // Handle *.ext patterns
+      if (pattern.startsWith('*.')) {
+        const targetExt = '.' + pattern.slice(2);
+        if (ext === targetExt) return true;
+      }
+      // Handle exact file name patterns
+      else if (fileName === pattern) {
+        return true;
+      }
+      // Handle glob patterns
+      else if (minimatch(fileName, pattern)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Match path pattern
+   * @private
+   */
+  matchPath(filePath, patterns) {
+    const values = Array.isArray(patterns) ? patterns : [patterns];
+    const normalizedPath = filePath.replace(/\\/g, '/');
+
+    for (const pattern of values) {
+      const normalizedPattern = pattern.replace(/\\/g, '/');
+
+      // Exact path match
+      if (normalizedPath === normalizedPattern) return true;
+
+      // Glob pattern match
+      if (minimatch(normalizedPath, normalizedPattern)) return true;
+
+      // Prefix match for directory patterns
+      if (normalizedPattern.endsWith('/') &&
+          normalizedPath.startsWith(normalizedPattern.slice(0, -1))) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Match import pattern (regex)
+   * @private
+   */
+  matchImport(content, patterns) {
+    const values = Array.isArray(patterns) ? patterns : [patterns];
+
+    for (const pattern of values) {
+      try {
+        const regex = new RegExp(pattern, 'm');
+        if (regex.test(content)) return true;
+      } catch {
+        // Invalid regex, try literal match
+        if (content.includes(pattern)) return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Match keyword pattern
+   * @private
+   */
+  matchKeyword(content, patterns) {
+    const values = Array.isArray(patterns) ? patterns : [patterns];
+
+    for (const pattern of values) {
+      try {
+        // Create word boundary regex
+        const regex = new RegExp(`\\b${pattern}\\b`, 'm');
+        if (regex.test(content)) return true;
+      } catch {
+        // Invalid regex, try literal match
+        if (content.includes(pattern)) return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Match command pattern
+   * @private
+   */
+  matchCommand(command, patterns) {
+    const values = Array.isArray(patterns) ? patterns : [patterns];
+    const normalizedCmd = command.toLowerCase().trim();
+
+    for (const pattern of values) {
+      const normalizedPattern = pattern.toLowerCase();
+
+      // Exact match
+      if (normalizedCmd === normalizedPattern) return true;
+
+      // Starts with match (for commands with args)
+      if (normalizedCmd.startsWith(normalizedPattern)) return true;
+
+      // Contains match
+      if (normalizedCmd.includes(normalizedPattern)) return true;
+
+      // Regex match
+      try {
+        const regex = new RegExp(normalizedPattern);
+        if (regex.test(normalizedCmd)) return true;
+      } catch {
+        // Not a valid regex, skip
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Get evaluation summary
+   * @returns {Object}
+   */
+  getSummary() {
+    const triggers = this.getAll();
+    const byType = {};
+
+    for (const trigger of triggers) {
+      byType[trigger.type] = (byType[trigger.type] || 0) + 1;
+    }
+
+    return {
+      totalTriggers: triggers.length,
+      byType,
+      enabledCount: triggers.length,
+      disabledCount: Array.from(this.triggers.values()).filter(t => !t.enabled).length
+    };
+  }
+}
+
+/**
+ * Evaluation result
+ * @typedef {Object} EvaluationResult
+ * @property {string|null} filePath - File path if evaluated
+ * @property {string|null} command - Command if evaluated
+ * @property {Array<{trigger: Trigger, reason: string}>} matchedTriggers
+ * @property {string[]} patterns - Pattern IDs to load
+ */
+
+/**
+ * Create a new TriggerEngine instance
+ * @param {string} workspacePath
+ * @returns {TriggerEngine}
+ */
+export function createTriggerEngine(workspacePath) {
+  return new TriggerEngine(workspacePath);
+}
+
+/**
+ * Get trigger engine for current working directory
+ * @returns {TriggerEngine}
+ */
+export function getTriggerEngine() {
+  return createTriggerEngine(process.cwd());
+}
+
+export default { TriggerEngine, createTriggerEngine, getTriggerEngine };