marmot-logger 1.0.7 → 1.0.10

package/bin/marmot.js

@@ -27,12 +27,12 @@ program
 
 program
   .command('enable <plugin>')
-  .description('Enable a plugin (file-monitor, terminal, git-hooks, makefile, claude-hooks, process-monitor)')
+  .description('Enable a plugin (file-monitor, terminal, git-hooks, makefile, claude-hooks, process-monitor, all)')
   .action(enable);
 
 program
   .command('disable <plugin>')
-  .description('Disable a plugin')
+  .description('Disable a plugin (or "all" to disable all)')
   .action(disable);
 
 program

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marmot-logger",
-  "version": "1.0.7",
+  "version": "1.0.10",
   "description": "Activity monitoring tool for developer workflows - tracks file changes, terminal commands, git operations, and Claude Code hooks",
   "main": "src/index.js",
   "bin": {

package/src/cli/disable.js

@@ -4,10 +4,21 @@ const plugins = require('../plugins');
 
 const VALID_PLUGINS = ['file-monitor', 'terminal', 'git-hooks', 'makefile', 'claude-hooks', 'process-monitor'];
 
-module.exports = async function disable(pluginName) {
+async function disable(pluginName) {
+  // Handle "all" - disable all plugins
+  if (pluginName === 'all') {
+    console.log(chalk.bold('Disabling all plugins...\n'));
+    for (const plugin of VALID_PLUGINS) {
+      await disable(plugin);
+      console.log('');
+    }
+    console.log(chalk.green('✓ All plugins disabled.'));
+    return;
+  }
+
   if (!VALID_PLUGINS.includes(pluginName)) {
     console.log(chalk.red(`Unknown plugin: ${pluginName}`));
-    console.log('Available plugins:', VALID_PLUGINS.join(', '));
+    console.log('Available plugins:', VALID_PLUGINS.join(', '), ', all');
     process.exit(1);
   }
 
@@ -37,4 +48,6 @@ module.exports = async function disable(pluginName) {
   config.saveConfig(projectConfig);
 
   console.log(chalk.green(`✓ Plugin '${pluginName}' disabled.`));
-};
+}
+
+module.exports = disable;

package/src/cli/enable.js

@@ -4,10 +4,21 @@ const plugins = require('../plugins');
 
 const VALID_PLUGINS = ['file-monitor', 'terminal', 'git-hooks', 'makefile', 'claude-hooks', 'process-monitor'];
 
-module.exports = async function enable(pluginName) {
+async function enable(pluginName) {
+  // Handle "all" - enable all plugins
+  if (pluginName === 'all') {
+    console.log(chalk.bold('Enabling all plugins...\n'));
+    for (const plugin of VALID_PLUGINS) {
+      await enable(plugin);
+      console.log('');
+    }
+    console.log(chalk.green('✓ All plugins enabled.'));
+    return;
+  }
+
   if (!VALID_PLUGINS.includes(pluginName)) {
     console.log(chalk.red(`Unknown plugin: ${pluginName}`));
-    console.log('Available plugins:', VALID_PLUGINS.join(', '));
+    console.log('Available plugins:', VALID_PLUGINS.join(', '), ', all');
     process.exit(1);
   }
 
@@ -37,4 +48,6 @@ module.exports = async function enable(pluginName) {
       console.log(chalk.red(`Setup error: ${err.message}`));
     }
   }
-};
+}
+
+module.exports = enable;

package/src/core/gitignore.js

@@ -4,6 +4,8 @@ const path = require('path');
 /**
  * Parse .gitignore file and return patterns
  * Skips comments, empty lines, and negation patterns (!)
+ * Preserves trailing spaces (significant in gitignore)
+ * Handles escaped # and ! at line start
  */
 function parseGitignore(projectDir) {
   const gitignorePath = path.join(projectDir, '.gitignore');
@@ -16,8 +18,15 @@ function parseGitignore(projectDir) {
     const content = fs.readFileSync(gitignorePath, 'utf8');
     return content
       .split('\n')
-      .map(line => line.trim())
-      .filter(line => line && !line.startsWith('#') && !line.startsWith('!'));
+      .map(line => line.replace(/^\s+/, ''))  // Only trim leading whitespace
+      .filter(line => {
+        if (!line) return false;
+        // Skip comments (but not escaped \#)
+        if (line.startsWith('#') && !line.startsWith('\\#')) return false;
+        // Skip negation patterns (but not escaped \!)
+        if (line.startsWith('!') && !line.startsWith('\\!')) return false;
+        return true;
+      });
   } catch (err) {
     return [];
   }
@@ -67,30 +76,107 @@ function shouldExclude(filePath, projectDir) {
 }
 
 /**
- * Simple pattern matching for gitignore-style patterns
- * Supports: wildcards (*), directory markers (/), character classes ([])
+ * Comprehensive gitignore-style pattern matching
+ * Supports:
+ * - Wildcards: * (single component), ** (any depth), ? (single char)
+ * - Directory markers: trailing / (directory only)
+ * - Root anchoring: leading / (match from root only)
+ * - Character classes: [abc], [0-9], [!abc] (negated)
+ * - Escape sequences: \#, \!, \ , \\
+ * - Globstar patterns: **\/foo, foo/**, a/**\/b
  */
 function matchPattern(filePath, pattern) {
-  // Handle trailing slash (directory pattern)
-  const isDir = pattern.endsWith('/');
-  let cleanPattern = isDir ? pattern.slice(0, -1) : pattern;
+  // Skip empty patterns
+  if (!pattern) return false;
 
-  // Check if pattern has path separators (anchored pattern)
-  const isAnchored = cleanPattern.includes('/');
+  // Handle escape sequences (\ followed by special char)
+  // \# -> #, \! -> !, \  -> space, \\ -> \
+  let cleanPattern = pattern.replace(/\\([#! \\])/g, '\x00ESC:$1\x00');
 
-  // Convert gitignore pattern to regex
+  // Handle trailing slash (directory pattern - matches dir and contents)
+  const isDir = cleanPattern.endsWith('/');
+  if (isDir) {
+    cleanPattern = cleanPattern.slice(0, -1);
+  }
+
+  // Handle leading slash (root-anchored)
+  const hasLeadingSlash = cleanPattern.startsWith('/');
+  if (hasLeadingSlash) {
+    cleanPattern = cleanPattern.slice(1);
+  }
+
+  // Handle **/ prefix (matches at any depth, including root)
+  const hasGlobstarPrefix = cleanPattern.startsWith('**/');
+  if (hasGlobstarPrefix) {
+    cleanPattern = cleanPattern.slice(3);
+  }
+
+  // Handle /** suffix (matches everything inside)
+  const hasGlobstarSuffix = cleanPattern.endsWith('/**');
+  if (hasGlobstarSuffix) {
+    cleanPattern = cleanPattern.slice(0, -3);
+  }
+
+  // Handle */ prefix (matches basename at any depth) - rsync style
+  const hasWildcardPrefix = cleanPattern.startsWith('*/');
+  if (hasWildcardPrefix) {
+    cleanPattern = cleanPattern.slice(2);
+  }
+
+  // Determine if pattern is anchored to root
+  // Anchored if: had leading slash, OR contains / in the middle (after processing prefixes)
+  const isAnchored = hasLeadingSlash || (cleanPattern.includes('/') && !hasGlobstarPrefix && !hasWildcardPrefix);
+
+  // Convert pattern to regex
   let regex = cleanPattern
-    .replace(/[.+^${}()|[\]\\]/g, '\\$&')  // Escape regex special chars except * and ?
-    .replace(/\*\*/g, '<<<GLOBSTAR>>>')     // Preserve **
-    .replace(/\*/g, '[^/]*')                // * matches anything except /
-    .replace(/<<<GLOBSTAR>>>/g, '.*')       // ** matches anything including /
-    .replace(/\?/g, '[^/]');                // ? matches single char except /
-
-  // Patterns without / match anywhere in path
-  if (!isAnchored) {
-    regex = `(^|/)${regex}($|/)`;
-  } else {
+    // First, protect character classes from escaping
+    .replace(/\[(!?)([^\]]+)\]/g, '\x00CHARCLASS:$1:$2\x00')
+    // Escape regex special chars (except * and ?)
+    .replace(/[.+^${}()|\\]/g, '\\$&')
+    // Restore character classes with proper regex syntax
+    .replace(/\x00CHARCLASS:(!?):([^\x00]+)\x00/g, (_, neg, chars) => {
+      return '[' + (neg === '!' ? '^' : '') + chars + ']';
+    })
+    // Handle **/ in middle of pattern (matches zero or more path components)
+    // a/**/b should match a/b, a/x/b, a/x/y/b
+    .replace(/\/\*\*\//g, '\x00MIDDLEGLOB\x00')
+    // Handle ** (globstar - matches anything including /)
+    .replace(/\*\*/g, '\x00GLOBSTAR\x00')
+    // Handle * (matches anything except /)
+    .replace(/\*/g, '[^/]*')
+    // Handle ? (matches single char except /)
+    .replace(/\?/g, '[^/]')
+    // Restore globstars with proper regex
+    .replace(/\x00MIDDLEGLOB\x00/g, '/(.*/)?')
+    .replace(/\x00GLOBSTAR\x00/g, '.*')
+    // Restore escaped characters
+    .replace(/\x00ESC:#\x00/g, '#')
+    .replace(/\x00ESC:!\x00/g, '!')
+    .replace(/\x00ESC: \x00/g, ' ')
+    .replace(/\x00ESC:\\\x00/g, '\\\\');
+
+  // Build final regex based on pattern type
+  if (hasGlobstarPrefix || hasWildcardPrefix) {
+    // Match at any depth (including root)
+    regex = `(^|/)${regex}`;
+  } else if (isAnchored) {
+    // Match from root only
     regex = `^${regex}`;
+  } else {
+    // Unanchored pattern: match as basename anywhere in path
+    regex = `(^|/)${regex}`;
+  }
+
+  // Handle suffix matching - what comes after the pattern
+  if (hasGlobstarSuffix) {
+    // foo/** matches foo and everything inside
+    regex = regex + '($|/)';
+  } else if (isDir) {
+    // Directory pattern (trailing /): match dir and its contents
+    regex = regex + '($|/)';
+  } else {
+    // Regular pattern: match as complete path component or with trailing content
+    regex = regex + '($|/)';
   }
 
   try {