@fermindi/pwn-cli 0.1.0

package/src/patterns/matcher.js

@@ -0,0 +1,218 @@
+/**
+ * Pattern Matcher - Glob and regex matching utilities
+ *
+ * Provides minimatch-like glob matching without external dependencies.
+ * Supports common glob patterns used in trigger evaluation.
+ */
+
+/**
+ * Convert glob pattern to regex
+ * @param {string} pattern - Glob pattern
+ * @returns {RegExp}
+ */
+export function globToRegex(pattern) {
+  // Escape special regex characters except glob wildcards
+  let regex = pattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    // ** matches any path segments
+    .replace(/\*\*/g, '{{GLOBSTAR}}')
+    // * matches any characters except path separator
+    .replace(/\*/g, '[^/\\\\]*')
+    // ? matches single character
+    .replace(/\?/g, '[^/\\\\]')
+    // Restore globstar
+    .replace(/\{\{GLOBSTAR\}\}/g, '.*');
+
+  // Handle brace expansion {a,b,c}
+  if (regex.includes('\\{') && regex.includes('\\}')) {
+    regex = regex.replace(/\\\{([^}]+)\\\}/g, (_, options) => {
+      const parts = options.split(',').map(p => p.trim());
+      return `(?:${parts.join('|')})`;
+    });
+  }
+
+  return new RegExp(`^${regex}$`, 'i');
+}
+
+/**
+ * Test if a string matches a glob pattern
+ * @param {string} str - String to test
+ * @param {string} pattern - Glob pattern
+ * @param {Object} [options] - Match options
+ * @param {boolean} [options.dot=false] - Match dotfiles
+ * @param {boolean} [options.nocase=true] - Case insensitive
+ * @returns {boolean}
+ */
+export function minimatch(str, pattern, options = {}) {
+  const { dot = false, nocase = true } = options;
+
+  // Normalize path separators
+  const normalizedStr = str.replace(/\\/g, '/');
+  const normalizedPattern = pattern.replace(/\\/g, '/');
+
+  // Handle negation
+  if (normalizedPattern.startsWith('!')) {
+    return !minimatch(normalizedStr, normalizedPattern.slice(1), options);
+  }
+
+  // Skip dotfiles unless dot option is true
+  if (!dot && normalizedStr.split('/').some(part => part.startsWith('.'))) {
+    // Allow if pattern explicitly matches dotfiles
+    if (!normalizedPattern.includes('/.') && !normalizedPattern.startsWith('.')) {
+      return false;
+    }
+  }
+
+  try {
+    const regex = globToRegex(normalizedPattern);
+    if (nocase) {
+      return new RegExp(regex.source, 'i').test(normalizedStr);
+    }
+    return regex.test(normalizedStr);
+  } catch {
+    // Fallback to simple string matching
+    return normalizedStr === normalizedPattern;
+  }
+}
+
+/**
+ * Find all matching items from a list
+ * @param {string[]} list - List of strings to match against
+ * @param {string} pattern - Glob pattern
+ * @param {Object} [options] - Match options
+ * @returns {string[]}
+ */
+export function minimatchFilter(list, pattern, options = {}) {
+  return list.filter(item => minimatch(item, pattern, options));
+}
+
+/**
+ * Test if string matches any of the patterns
+ * @param {string} str - String to test
+ * @param {string[]} patterns - Array of glob patterns
+ * @param {Object} [options] - Match options
+ * @returns {boolean}
+ */
+export function minimatchAny(str, patterns, options = {}) {
+  return patterns.some(pattern => minimatch(str, pattern, options));
+}
+
+/**
+ * Test if string matches all of the patterns
+ * @param {string} str - String to test
+ * @param {string[]} patterns - Array of glob patterns
+ * @param {Object} [options] - Match options
+ * @returns {boolean}
+ */
+export function minimatchAll(str, patterns, options = {}) {
+  return patterns.every(pattern => minimatch(str, pattern, options));
+}
+
+/**
+ * Create a matcher function for a pattern
+ * @param {string} pattern - Glob pattern
+ * @param {Object} [options] - Match options
+ * @returns {Function} Matcher function
+ */
+export function createMatcher(pattern, options = {}) {
+  return (str) => minimatch(str, pattern, options);
+}
+
+/**
+ * Match file extension
+ * @param {string} fileName - File name or path
+ * @param {string|string[]} extensions - Extension(s) to match (with or without dot)
+ * @returns {boolean}
+ */
+export function matchExtension(fileName, extensions) {
+  const exts = Array.isArray(extensions) ? extensions : [extensions];
+  const normalizedExts = exts.map(ext => ext.startsWith('.') ? ext : `.${ext}`);
+  const fileExt = fileName.includes('.') ? '.' + fileName.split('.').pop() : '';
+
+  return normalizedExts.some(ext => ext.toLowerCase() === fileExt.toLowerCase());
+}
+
+/**
+ * Match path prefix
+ * @param {string} filePath - File path
+ * @param {string|string[]} prefixes - Path prefix(es) to match
+ * @returns {boolean}
+ */
+export function matchPathPrefix(filePath, prefixes) {
+  const prfxs = Array.isArray(prefixes) ? prefixes : [prefixes];
+  const normalizedPath = filePath.replace(/\\/g, '/');
+
+  return prfxs.some(prefix => {
+    const normalizedPrefix = prefix.replace(/\\/g, '/');
+    return normalizedPath.startsWith(normalizedPrefix);
+  });
+}
+
+/**
+ * Extract file parts for matching
+ * @param {string} filePath - File path
+ * @returns {Object}
+ */
+export function parseFilePath(filePath) {
+  const normalized = filePath.replace(/\\/g, '/');
+  const parts = normalized.split('/');
+  const fileName = parts.pop() || '';
+  const dirPath = parts.join('/');
+  const extMatch = fileName.match(/\.([^.]+)$/);
+  const extension = extMatch ? extMatch[1] : '';
+  const baseName = extension ? fileName.slice(0, -(extension.length + 1)) : fileName;
+
+  return {
+    fullPath: normalized,
+    dirPath,
+    fileName,
+    baseName,
+    extension,
+    depth: parts.length
+  };
+}
+
+/**
+ * Score a match for prioritization
+ * Higher score = better match
+ * @param {string} str - String that matched
+ * @param {string} pattern - Pattern that matched
+ * @returns {number}
+ */
+export function scoreMatch(str, pattern) {
+  let score = 0;
+
+  // Exact match = highest score
+  if (str === pattern) {
+    score += 100;
+  }
+
+  // Shorter patterns = more specific = higher score
+  const patternComplexity = (pattern.match(/\*/g) || []).length;
+  score += 50 - patternComplexity * 10;
+
+  // File extension patterns are more specific
+  if (pattern.startsWith('*.') && !pattern.includes('/')) {
+    score += 20;
+  }
+
+  // Path patterns with specific directories
+  if (pattern.includes('/') && !pattern.startsWith('**/')) {
+    score += 15;
+  }
+
+  return Math.max(0, score);
+}
+
+export default {
+  globToRegex,
+  minimatch,
+  minimatchFilter,
+  minimatchAny,
+  minimatchAll,
+  createMatcher,
+  matchExtension,
+  matchPathPrefix,
+  parseFilePath,
+  scoreMatch
+};

package/src/patterns/registry.js

@@ -0,0 +1,375 @@
+/**
+ * Pattern Registry - Manages pattern storage and retrieval
+ *
+ * Patterns are organized in categories:
+ * - frontend/ (react, vue, svelte, styling, component-libs)
+ * - backend/ (express, fastapi, database, auth)
+ * - universal/ (typescript, testing, error-handling, git, build-tools)
+ */
+
+import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, statSync } from 'fs';
+import { join, relative, basename, dirname } from 'path';
+
+/**
+ * Pattern entry structure
+ * @typedef {Object} Pattern
+ * @property {string} id - Unique identifier (category/name)
+ * @property {string} name - Human-readable name
+ * @property {string} category - Pattern category (frontend, backend, universal)
+ * @property {string} path - Relative path to pattern directory
+ * @property {string} description - Pattern description
+ * @property {string[]} triggers - Associated trigger IDs
+ * @property {Object} metadata - Additional metadata
+ * @property {number} metadata.usageCount - How many times pattern was applied
+ * @property {string} metadata.lastUsed - ISO timestamp of last usage
+ * @property {string} metadata.createdAt - ISO timestamp of creation
+ */
+
+/**
+ * PatternRegistry - Singleton for managing patterns
+ */
+export class PatternRegistry {
+  constructor(workspacePath) {
+    this.workspacePath = workspacePath;
+    this.aiPath = join(workspacePath, '.ai');
+    this.patternsPath = join(this.aiPath, 'patterns');
+    this.registryPath = join(this.patternsPath, 'registry.json');
+    this.patterns = new Map();
+    this.loaded = false;
+  }
+
+  /**
+   * Initialize or load the registry
+   */
+  async load() {
+    if (this.loaded) return;
+
+    // Create patterns directory if it doesn't exist
+    if (!existsSync(this.patternsPath)) {
+      mkdirSync(this.patternsPath, { recursive: true });
+    }
+
+    // Load existing registry or scan for patterns
+    if (existsSync(this.registryPath)) {
+      try {
+        const data = JSON.parse(readFileSync(this.registryPath, 'utf8'));
+        for (const pattern of data.patterns || []) {
+          this.patterns.set(pattern.id, pattern);
+        }
+      } catch (error) {
+        console.warn('⚠️  Could not load registry, scanning patterns directory...');
+        await this.scan();
+      }
+    } else {
+      await this.scan();
+    }
+
+    this.loaded = true;
+  }
+
+  /**
+   * Scan patterns directory and build registry
+   */
+  async scan() {
+    this.patterns.clear();
+
+    const categories = ['frontend', 'backend', 'universal'];
+
+    for (const category of categories) {
+      const categoryPath = join(this.patternsPath, category);
+      if (!existsSync(categoryPath)) continue;
+
+      const entries = readdirSync(categoryPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+
+        const patternPath = join(categoryPath, entry.name);
+        const readmePath = join(patternPath, 'README.md');
+
+        const pattern = {
+          id: `${category}/${entry.name}`,
+          name: this.formatName(entry.name),
+          category,
+          path: relative(this.aiPath, patternPath),
+          description: this.extractDescription(readmePath),
+          triggers: [],
+          metadata: {
+            usageCount: 0,
+            lastUsed: null,
+            createdAt: new Date().toISOString()
+          }
+        };
+
+        this.patterns.set(pattern.id, pattern);
+      }
+    }
+
+    // Save the scanned registry
+    await this.save();
+  }
+
+  /**
+   * Extract description from README.md first line
+   */
+  extractDescription(readmePath) {
+    if (!existsSync(readmePath)) {
+      return 'No description available';
+    }
+
+    try {
+      const content = readFileSync(readmePath, 'utf8');
+      const lines = content.split('\n');
+
+      // Find first non-empty, non-heading line
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('---')) {
+          return trimmed.slice(0, 100) + (trimmed.length > 100 ? '...' : '');
+        }
+      }
+
+      return 'Pattern documentation available';
+    } catch {
+      return 'No description available';
+    }
+  }
+
+  /**
+   * Format pattern name from directory name
+   */
+  formatName(dirName) {
+    return dirName
+      .split(/[-_]/)
+      .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+  }
+
+  /**
+   * Save registry to disk
+   */
+  async save() {
+    const data = {
+      version: '1.0.0',
+      lastUpdated: new Date().toISOString(),
+      patterns: Array.from(this.patterns.values())
+    };
+
+    writeFileSync(this.registryPath, JSON.stringify(data, null, 2));
+  }
+
+  /**
+   * Get a pattern by ID
+   * @param {string} id - Pattern ID (e.g., 'frontend/react')
+   * @returns {Pattern|null}
+   */
+  get(id) {
+    return this.patterns.get(id) || null;
+  }
+
+  /**
+   * Get all patterns
+   * @returns {Pattern[]}
+   */
+  getAll() {
+    return Array.from(this.patterns.values());
+  }
+
+  /**
+   * Get patterns by category
+   * @param {string} category - Category name
+   * @returns {Pattern[]}
+   */
+  getByCategory(category) {
+    return this.getAll().filter(p => p.category === category);
+  }
+
+  /**
+   * Search patterns by name or description
+   * @param {string} query - Search query
+   * @returns {Pattern[]}
+   */
+  search(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.getAll().filter(p =>
+      p.name.toLowerCase().includes(lowerQuery) ||
+      p.description.toLowerCase().includes(lowerQuery) ||
+      p.id.toLowerCase().includes(lowerQuery)
+    );
+  }
+
+  /**
+   * Register a new pattern
+   * @param {Pattern} pattern - Pattern to register
+   */
+  async register(pattern) {
+    // Ensure required fields
+    if (!pattern.id || !pattern.name || !pattern.category) {
+      throw new Error('Pattern must have id, name, and category');
+    }
+
+    // Create pattern directory if it doesn't exist
+    const patternDir = join(this.patternsPath, pattern.path || pattern.id);
+    if (!existsSync(patternDir)) {
+      mkdirSync(patternDir, { recursive: true });
+
+      // Create README.md with description
+      const readmePath = join(patternDir, 'README.md');
+      writeFileSync(readmePath, `# ${pattern.name}\n\n${pattern.description || ''}\n`);
+    }
+
+    // Set metadata
+    pattern.metadata = pattern.metadata || {
+      usageCount: 0,
+      lastUsed: null,
+      createdAt: new Date().toISOString()
+    };
+
+    this.patterns.set(pattern.id, pattern);
+    await this.save();
+  }
+
+  /**
+   * Remove a pattern
+   * @param {string} id - Pattern ID
+   */
+  async remove(id) {
+    this.patterns.delete(id);
+    await this.save();
+  }
+
+  /**
+   * Record pattern usage
+   * @param {string} id - Pattern ID
+   */
+  async recordUsage(id) {
+    const pattern = this.patterns.get(id);
+    if (pattern) {
+      pattern.metadata.usageCount++;
+      pattern.metadata.lastUsed = new Date().toISOString();
+      await this.save();
+    }
+  }
+
+  /**
+   * Get pattern content (README.md)
+   * @param {string} id - Pattern ID
+   * @returns {string|null}
+   */
+  getContent(id) {
+    const pattern = this.patterns.get(id);
+    if (!pattern) return null;
+
+    // pattern.path is relative to aiPath (e.g., "patterns/frontend/react")
+    const readmePath = join(this.aiPath, pattern.path, 'README.md');
+    if (!existsSync(readmePath)) return null;
+
+    return readFileSync(readmePath, 'utf8');
+  }
+
+  /**
+   * Get all files in a pattern directory
+   * @param {string} id - Pattern ID
+   * @returns {Object[]} Array of {name, path, content}
+   */
+  getPatternFiles(id) {
+    const pattern = this.patterns.get(id);
+    if (!pattern) return [];
+
+    // pattern.path is relative to aiPath (e.g., "patterns/frontend/react")
+    const patternDir = join(this.aiPath, pattern.path);
+    if (!existsSync(patternDir)) return [];
+
+    const files = [];
+    const entries = readdirSync(patternDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        const filePath = join(patternDir, entry.name);
+        files.push({
+          name: entry.name,
+          path: relative(this.aiPath, filePath),
+          content: readFileSync(filePath, 'utf8')
+        });
+      }
+    }
+
+    return files;
+  }
+
+  /**
+   * Get usage statistics
+   * @returns {Object}
+   */
+  getStats() {
+    const patterns = this.getAll();
+    const byCategory = {};
+    let totalUsage = 0;
+    let mostUsed = null;
+
+    for (const pattern of patterns) {
+      // Count by category
+      byCategory[pattern.category] = (byCategory[pattern.category] || 0) + 1;
+
+      // Track total usage
+      totalUsage += pattern.metadata.usageCount;
+
+      // Track most used
+      if (!mostUsed || pattern.metadata.usageCount > mostUsed.metadata.usageCount) {
+        mostUsed = pattern;
+      }
+    }
+
+    return {
+      totalPatterns: patterns.length,
+      byCategory,
+      totalUsage,
+      mostUsed: mostUsed ? { id: mostUsed.id, count: mostUsed.metadata.usageCount } : null
+    };
+  }
+
+  /**
+   * Associate trigger with pattern
+   * @param {string} patternId - Pattern ID
+   * @param {string} triggerId - Trigger ID
+   */
+  async addTrigger(patternId, triggerId) {
+    const pattern = this.patterns.get(patternId);
+    if (pattern && !pattern.triggers.includes(triggerId)) {
+      pattern.triggers.push(triggerId);
+      await this.save();
+    }
+  }
+
+  /**
+   * Remove trigger from pattern
+   * @param {string} patternId - Pattern ID
+   * @param {string} triggerId - Trigger ID
+   */
+  async removeTrigger(patternId, triggerId) {
+    const pattern = this.patterns.get(patternId);
+    if (pattern) {
+      pattern.triggers = pattern.triggers.filter(t => t !== triggerId);
+      await this.save();
+    }
+  }
+}
+
+/**
+ * Create a new PatternRegistry instance for the given workspace
+ * @param {string} workspacePath - Path to workspace root
+ * @returns {PatternRegistry}
+ */
+export function createRegistry(workspacePath) {
+  return new PatternRegistry(workspacePath);
+}
+
+/**
+ * Get pattern registry for current working directory
+ * @returns {PatternRegistry}
+ */
+export function getRegistry() {
+  return createRegistry(process.cwd());
+}
+
+export default { PatternRegistry, createRegistry, getRegistry };