ctxman 3.0.0 → 3.1.0

package/lib/parsers/gitignore-parser.js

@@ -6,122 +6,128 @@
 import fs from 'fs';
 
 class GitIgnoreParser {
-    constructor(gitignorePath, contextIgnorePath, contextIncludePath) {
-        this.patterns = [];
-        this.contextPatterns = [];
-        this.hasIncludeFile = false;
-        this._lastIgnoreReason = null;
-
-        this.loadPatterns(gitignorePath, contextIgnorePath, contextIncludePath);
+  constructor(gitignorePath, contextIgnorePath, contextIncludePath) {
+    this.patterns = [];
+    this.contextPatterns = [];
+    this.hasIncludeFile = false;
+    this._lastIgnoreReason = null;
+
+    this.loadPatterns(gitignorePath, contextIgnorePath, contextIncludePath);
+  }
+
+  loadPatterns(gitignorePath, contextIgnorePath, contextIncludePath) {
+    // Load .gitignore
+    if (gitignorePath && fs.existsSync(gitignorePath)) {
+      this.patterns = this.parsePatternFile(gitignorePath);
     }
 
-    loadPatterns(gitignorePath, contextIgnorePath, contextIncludePath) {
-        // Load .gitignore
-        if (fs.existsSync(gitignorePath)) {
-            this.patterns = this.parsePatternFile(gitignorePath);
-        }
-
-        // Load context patterns (include takes priority)
-        if (contextIncludePath && fs.existsSync(contextIncludePath)) {
-            this.contextPatterns = this.parsePatternFile(contextIncludePath);
-            this.hasIncludeFile = true;
-            console.log(`📅 Context include rules loaded: ${this.contextPatterns.length} patterns`);
-        } else if (contextIgnorePath && fs.existsSync(contextIgnorePath)) {
-            this.contextPatterns = this.parsePatternFile(contextIgnorePath);
-            console.log(`📋 Context ignore rules loaded: ${this.contextPatterns.length} patterns`);
-        }
+    // Load context patterns (include takes priority)
+    if (contextIncludePath && fs.existsSync(contextIncludePath)) {
+      this.contextPatterns = this.parsePatternFile(contextIncludePath);
+      this.hasIncludeFile = true;
+      console.log(`📅 Context include rules loaded: ${this.contextPatterns.length} patterns`);
+    } else if (contextIgnorePath && fs.existsSync(contextIgnorePath)) {
+      this.contextPatterns = this.parsePatternFile(contextIgnorePath);
+      console.log(`📋 Context ignore rules loaded: ${this.contextPatterns.length} patterns`);
     }
-
-    parsePatternFile(filePath) {
-        try {
-            // Check if path is actually a file (not a directory)
-            const stats = fs.statSync(filePath);
-            if (stats.isDirectory()) {
-                console.warn(`Warning: ${filePath} is a directory, expected a file`);
-                return [];
-            }
-
-            return fs.readFileSync(filePath, 'utf8')
-                .split('\n')
-                .map(line => line.trim())
-                .filter(line => line && !line.startsWith('#'))
-                .map(pattern => this.convertToRegex(pattern));
-        } catch (error) {
-            // File doesn't exist or can't be read
-            return [];
-        }
+  }
+
+  parsePatternFile(filePath) {
+    try {
+      return fs
+        .readFileSync(filePath, 'utf8')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('#'))
+        .map((pattern) => this.convertToRegex(pattern));
+    } catch (error) {
+      // A directory, or a file that doesn't exist or can't be read
+      if (error.code === 'EISDIR') {
+        console.warn(`Warning: ${filePath} is a directory, expected a file`);
+      }
+      return [];
     }
-
-    convertToRegex(pattern) {
-        const isDirectory = pattern.endsWith('/');
-        const isNegation = pattern.startsWith('!');
-        const original = pattern;
-
-        pattern = pattern.replace(/^[!/]/, '').replace(/\/$/, '');
-
-        let regexPattern = pattern
-            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-            .replace(/\*\*/g, '.*')
-            .replace(/\*/g, '[^/]*')
-            .replace(/\?/g, '[^/]');
-
-        regexPattern = original.startsWith('/')
-            ? `^${regexPattern}`
-            : `(^|/)${regexPattern}`;
-
-        regexPattern += isDirectory ? '(/.*)?$' : '$';
-
-        return { regex: new RegExp(regexPattern), isNegation, original, isDirectory };
+  }
+
+  convertToRegex(pattern) {
+    const isDirectory = pattern.endsWith('/');
+    const isNegation = pattern.startsWith('!');
+    const original = pattern;
+
+    pattern = pattern.replace(/^[!/]/, '').replace(/\/$/, '');
+
+    // Placeholders keep the `*` inside `.*` from being rewritten by the single-star rule
+    let regexPattern = pattern
+      .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+      .replace(/\*\*\//g, '\u0001') // `**/`: zero or more directories
+      .replace(/\*\*/g, '\u0002') // any other `**`: anything, across directories
+      .replace(/\*/g, '[^/]*')
+      .replace(/\?/g, '[^/]')
+      .replace(/\u0001/g, '(?:.*/)?')
+      .replace(/\u0002/g, '.*');
+
+    regexPattern = original.startsWith('/') ? `^${regexPattern}` : `(^|/)${regexPattern}`;
+
+    regexPattern += isDirectory ? '(/.*)?$' : '$';
+
+    return { regex: new RegExp(regexPattern), isNegation, original, isDirectory };
+  }
+
+  isIgnored(filePath, relativePath) {
+    let ignored = this.testPatterns(this.patterns, relativePath, 'gitignore');
+
+    if (this.hasIncludeFile) {
+      if (ignored) return true; // Keep gitignore exclusions
+
+      if (this.isDirectory(filePath)) {
+        const shouldTraverse = this.contextPatterns.some(
+          (p) =>
+            p.original.startsWith(relativePath) || p.original.includes('**') || relativePath === ''
+        );
+        ignored = !shouldTraverse;
+      } else {
+        const included = this.testPatternsWithNegation(this.contextPatterns, relativePath);
+        ignored = !included;
+      }
+
+      if (ignored) this._lastIgnoreReason = 'context-include';
+    } else if (!ignored) {
+      ignored = this.testPatterns(this.contextPatterns, relativePath, 'context');
     }
 
-    isIgnored(filePath, relativePath) {
-        let ignored = this.testPatterns(this.patterns, relativePath, 'gitignore');
-
-        if (this.hasIncludeFile) {
-            if (ignored) return true; // Keep gitignore exclusions
-
-            const stat = fs.statSync(filePath);
-            if (stat.isDirectory()) {
-                const shouldTraverse = this.contextPatterns.some(p =>
-                    p.original.startsWith(relativePath) ||
-                    p.original.includes('**') ||
-                    relativePath === ''
-                );
-                ignored = !shouldTraverse;
-            } else {
-                const included = this.testPatternsWithNegation(this.contextPatterns, relativePath);
-                ignored = !included;
-            }
-
-            if (ignored) this._lastIgnoreReason = 'context-include';
-        } else if (!ignored) {
-            ignored = this.testPatterns(this.contextPatterns, relativePath, 'context');
-        }
-
-        return ignored;
-    }
+    return ignored;
+  }
 
-    testPatterns(patterns, relativePath, reason) {
-        let ignored = false;
-        for (const pattern of patterns) {
-            if (pattern.regex.test(relativePath)) {
-                ignored = !pattern.isNegation;
-                if (ignored) this._lastIgnoreReason = reason;
-            }
-        }
-        return ignored;
+  isDirectory(filePath) {
+    try {
+      return fs.statSync(filePath).isDirectory();
+    } catch (_error) {
+      // Deleted (e.g. a watch-mode "rename" event) or unreadable: treat it as a file
+      return false;
     }
-
-    testPatternsWithNegation(patterns, relativePath) {
-        let included = false;
-        for (const pattern of patterns) {
-            if (pattern.regex.test(relativePath)) {
-                included = pattern.isNegation ? false : true;
-                if (pattern.isNegation) break;
-            }
-        }
-        return included;
+  }
+
+  testPatterns(patterns, relativePath, reason) {
+    let ignored = false;
+    for (const pattern of patterns) {
+      if (pattern.regex.test(relativePath)) {
+        ignored = !pattern.isNegation;
+        if (ignored) this._lastIgnoreReason = reason;
+      }
+    }
+    return ignored;
+  }
+
+  testPatternsWithNegation(patterns, relativePath) {
+    let included = false;
+    for (const pattern of patterns) {
+      if (pattern.regex.test(relativePath)) {
+        included = pattern.isNegation ? false : true;
+        if (pattern.isNegation) break;
+      }
     }
+    return included;
+  }
 }
 
 export default GitIgnoreParser;

package/lib/parsers/method-filter-parser.js

@@ -6,45 +6,62 @@
 import fs from 'fs';
 
 class MethodFilterParser {
-    constructor(methodIncludePath, methodIgnorePath) {
-        this.includePatterns = [];
-        this.ignorePatterns = [];
-        this.hasIncludeFile = false;
-
-        if (methodIncludePath && fs.existsSync(methodIncludePath)) {
-            this.includePatterns = this.parseMethodFile(methodIncludePath);
-            this.hasIncludeFile = true;
-            console.log(`🔧 Method include rules loaded: ${this.includePatterns.length} patterns`);
-        }
-
-        if (methodIgnorePath && fs.existsSync(methodIgnorePath)) {
-            this.ignorePatterns = this.parseMethodFile(methodIgnorePath);
-            console.log(`🚫 Method ignore rules loaded: ${this.ignorePatterns.length} patterns`);
-        }
+  constructor(methodIncludePath, methodIgnorePath) {
+    this.includePatterns = [];
+    this.ignorePatterns = [];
+    this.hasIncludeFile = false;
+
+    if (methodIncludePath && fs.existsSync(methodIncludePath)) {
+      this.includePatterns = this.parseMethodFile(methodIncludePath);
+      this.hasIncludeFile = true;
+      console.log(`🔧 Method include rules loaded: ${this.includePatterns.length} patterns`);
     }
 
-    parseMethodFile(filePath) {
-        return fs.readFileSync(filePath, 'utf8')
-            .split('\n')
-            .map(line => line.trim())
-            .filter(line => line && !line.startsWith('#'))
-            .map(pattern => ({
-                pattern: pattern,
-                regex: new RegExp(pattern.replace(/\*/g, '.*'), 'i')
-            }));
+    if (methodIgnorePath && fs.existsSync(methodIgnorePath)) {
+      this.ignorePatterns = this.parseMethodFile(methodIgnorePath);
+      console.log(`🚫 Method ignore rules loaded: ${this.ignorePatterns.length} patterns`);
     }
+  }
+
+  parseMethodFile(filePath) {
+    return (
+      fs
+        .readFileSync(filePath, 'utf8')
+        .split('\n')
+        // Trailing comments (`*Handler   # all handlers`) as in the documented examples
+        .map((line) => line.replace(/\s+#.*$/, '').trim())
+        .filter((line) => line && !line.startsWith('#'))
+        .map((line) => {
+          const negated = line.startsWith('!');
+          const pattern = negated ? line.slice(1) : line;
+          return {
+            pattern: line,
+            negated,
+            // Anchored so a plain name is an exact match and `*Handler` / `handle*` are suffix /
+            // prefix matches, as documented. `*` is the wildcard; other regex characters are
+            // literal (Ruby's `valid?`, `$emit`). `.` stays a regex dot: it still matches the
+            // `file.method` separator, and patterns such as `get.*Data` rely on it.
+            regex: new RegExp(
+              `^${pattern.replace(/[+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')}$`,
+              'i'
+            ),
+          };
+        })
+    );
+  }
 
-    shouldIncludeMethod(methodName, fileName) {
-        if (this.hasIncludeFile) {
-            return this.includePatterns.some(p =>
-                p.regex.test(methodName) || p.regex.test(`${fileName}.${methodName}`)
-            );
-        }
+  shouldIncludeMethod(methodName, fileName) {
+    const matches = (p) => p.regex.test(methodName) || p.regex.test(`${fileName}.${methodName}`);
 
-        return !this.ignorePatterns.some(p =>
-            p.regex.test(methodName) || p.regex.test(`${fileName}.${methodName}`)
-        );
+    // The last matching pattern decides, so a later `!pattern` overrides a broader one
+    if (this.hasIncludeFile) {
+      const match = this.includePatterns.findLast(matches);
+      return Boolean(match) && !match.negated;
     }
+
+    const match = this.ignorePatterns.findLast(matches);
+    return !match || match.negated;
+  }
 }
 
 export default MethodFilterParser;

package/lib/plugins/ExporterPlugin.js

@@ -24,7 +24,7 @@ export class ExporterPlugin {
       extension: this.extension,
       mimeType: this.mimeType,
       supportsChunking: this.supportsChunking(),
-      supportsCompression: this.supportsCompression()
+      supportsCompression: this.supportsCompression(),
     };
   }
 
@@ -50,7 +50,7 @@ export class ExporterPlugin {
    * @param {object} options
    * @returns {string}
    */
-  encode(context, options = {}) {
+  encode(context, _options = {}) {
     throw new Error('encode() must be implemented by subclass');
   }
 
@@ -59,7 +59,7 @@ export class ExporterPlugin {
    * @param {string} content
    * @returns {Context}
    */
-  decode(content) {
+  decode(_content) {
     throw new Error('decode() not supported for this format');
   }
 

package/lib/plugins/LanguagePlugin.js

@@ -23,7 +23,7 @@ export class LanguagePlugin {
       extensions: this.extensions,
       supportsAST: this.supportsAST(),
       supportsMethodExtraction: this.supportsMethodExtraction(),
-      supportsFrameworkDetection: this.supportsFrameworkDetection()
+      supportsFrameworkDetection: this.supportsFrameworkDetection(),
     };
   }
 
@@ -57,7 +57,7 @@ export class LanguagePlugin {
    * @param {string} filePath - File path
    * @returns {Array<Method>}
    */
-  extractMethods(content, filePath) {
+  extractMethods(_content, _filePath) {
     throw new Error('extractMethods() must be implemented by subclass');
   }
 
@@ -66,7 +66,7 @@ export class LanguagePlugin {
    * @param {string} content - File content
    * @returns {string|null} Framework name or null
    */
-  detectFramework(content) {
+  detectFramework(_content) {
     return null;
   }
 

package/lib/plugins/PluginManager.js

@@ -21,14 +21,10 @@ export class PluginManager extends EventEmitter {
     super();
 
     this.options = {
-      pluginPaths: [
-        './lib/languages',
-        './lib/exporters',
-        './plugins'
-      ],
+      pluginPaths: ['./lib/languages', './lib/exporters', './plugins'],
       autoLoad: true,
       lazy: true, // Lazy load plugins
-      ...options
+      ...options,
     };
 
     this.plugins = new Map();
@@ -36,7 +32,7 @@ export class PluginManager extends EventEmitter {
     this.stats = {
       registered: 0,
       loaded: 0,
-      errors: 0
+      errors: 0,
     };
   }
 
@@ -103,12 +99,11 @@ export class PluginManager extends EventEmitter {
         name: pluginName,
         path: pluginPath,
         loaded: false,
-        instance: null
+        instance: null,
       });
 
       this.stats.registered++;
       logger.debug(`Registered plugin: ${pluginName}`);
-
     } catch (error) {
       logger.error(`Failed to register plugin ${pluginPath}: ${error.message}`);
       this.stats.errors++;
@@ -158,7 +153,6 @@ export class PluginManager extends EventEmitter {
       this.emit('plugin:loaded', { name: pluginName, elapsed });
 
       return instance;
-
     } catch (error) {
       logger.error(`Failed to load plugin ${pluginName}: ${error.message}`);
       this.stats.errors++;
@@ -173,7 +167,7 @@ export class PluginManager extends EventEmitter {
    * @returns {Promise<Array<Plugin>>}
    */
   async loadMultiple(pluginNames) {
-    const promises = pluginNames.map(name => this.load(name));
+    const promises = pluginNames.map((name) => this.load(name));
     return Promise.all(promises);
   }
 
@@ -266,7 +260,7 @@ export class PluginManager extends EventEmitter {
       name: plugin.name,
       loaded: plugin.loaded,
       path: plugin.path,
-      hasInstance: plugin.instance !== null
+      hasInstance: plugin.instance !== null,
     };
   }
 
@@ -288,7 +282,7 @@ export class PluginManager extends EventEmitter {
       name,
       path: null,
       loaded: true,
-      instance
+      instance,
     });
 
     this.stats.registered++;