command-stream 0.9.0 → 0.9.2

package/js/src/shell-parser.mjs

@@ -22,6 +22,119 @@ const TokenType = {
   EOF: 'eof',
 };
 
+/**
+ * Parse a word token from the command string, handling quotes and escapes
+ * @param {string} command - The command string
+ * @param {number} startIndex - Starting position
+ * @returns {{word: string, endIndex: number}} Parsed word and end position
+ */
+function parseWord(command, startIndex) {
+  let word = '';
+  let i = startIndex;
+  let inQuote = false;
+  let quoteChar = '';
+
+  while (i < command.length) {
+    const char = command[i];
+
+    if (!inQuote) {
+      const result = parseUnquotedChar(command, i, char, word);
+      if (result.done) {
+        return { word: result.word, endIndex: i };
+      }
+      word = result.word;
+      i = result.index;
+      if (result.startQuote) {
+        inQuote = true;
+        quoteChar = result.startQuote;
+      }
+    } else {
+      const result = parseQuotedChar(command, i, char, word, quoteChar);
+      word = result.word;
+      i = result.index;
+      if (result.endQuote) {
+        inQuote = false;
+        quoteChar = '';
+      }
+    }
+  }
+
+  return { word, endIndex: i };
+}
+
+/**
+ * Parse a character when not inside quotes
+ */
+function parseUnquotedChar(command, i, char, word) {
+  if (char === '"' || char === "'") {
+    return { word: word + char, index: i + 1, startQuote: char };
+  }
+  if (/\s/.test(char) || '&|;()<>'.includes(char)) {
+    return { word, done: true };
+  }
+  if (char === '\\' && i + 1 < command.length) {
+    const escaped = command[i + 1];
+    return { word: word + char + escaped, index: i + 2 };
+  }
+  return { word: word + char, index: i + 1 };
+}
+
+/**
+ * Parse a character when inside quotes
+ */
+function parseQuotedChar(command, i, char, word, quoteChar) {
+  if (char === quoteChar && command[i - 1] !== '\\') {
+    return { word: word + char, index: i + 1, endQuote: true };
+  }
+  if (
+    char === '\\' &&
+    i + 1 < command.length &&
+    (command[i + 1] === quoteChar || command[i + 1] === '\\')
+  ) {
+    const escaped = command[i + 1];
+    return { word: word + char + escaped, index: i + 2 };
+  }
+  return { word: word + char, index: i + 1 };
+}
+
+/**
+ * Try to match an operator at the current position
+ * @returns {{type: string, value: string, length: number} | null}
+ */
+function matchOperator(command, i) {
+  const twoChar = command.slice(i, i + 2);
+  const oneChar = command[i];
+
+  if (twoChar === '&&') {
+    return { type: TokenType.AND, value: '&&', length: 2 };
+  }
+  if (twoChar === '||') {
+    return { type: TokenType.OR, value: '||', length: 2 };
+  }
+  if (twoChar === '>>') {
+    return { type: TokenType.REDIRECT_APPEND, value: '>>', length: 2 };
+  }
+  if (oneChar === '|') {
+    return { type: TokenType.PIPE, value: '|', length: 1 };
+  }
+  if (oneChar === ';') {
+    return { type: TokenType.SEMICOLON, value: ';', length: 1 };
+  }
+  if (oneChar === '(') {
+    return { type: TokenType.LPAREN, value: '(', length: 1 };
+  }
+  if (oneChar === ')') {
+    return { type: TokenType.RPAREN, value: ')', length: 1 };
+  }
+  if (oneChar === '>') {
+    return { type: TokenType.REDIRECT_OUT, value: '>', length: 1 };
+  }
+  if (oneChar === '<') {
+    return { type: TokenType.REDIRECT_IN, value: '<', length: 1 };
+  }
+  return null;
+}
+
 /**
  * Tokenize a shell command string
  */
@@ -40,90 +153,19 @@ function tokenize(command) {
     }
 
     // Check for operators
-    if (command[i] === '&' && command[i + 1] === '&') {
-      tokens.push({ type: TokenType.AND, value: '&&' });
-      i += 2;
-    } else if (command[i] === '|' && command[i + 1] === '|') {
-      tokens.push({ type: TokenType.OR, value: '||' });
-      i += 2;
-    } else if (command[i] === '|') {
-      tokens.push({ type: TokenType.PIPE, value: '|' });
-      i++;
-    } else if (command[i] === ';') {
-      tokens.push({ type: TokenType.SEMICOLON, value: ';' });
-      i++;
-    } else if (command[i] === '(') {
-      tokens.push({ type: TokenType.LPAREN, value: '(' });
-      i++;
-    } else if (command[i] === ')') {
-      tokens.push({ type: TokenType.RPAREN, value: ')' });
-      i++;
-    } else if (command[i] === '>' && command[i + 1] === '>') {
-      tokens.push({ type: TokenType.REDIRECT_APPEND, value: '>>' });
-      i += 2;
-    } else if (command[i] === '>') {
-      tokens.push({ type: TokenType.REDIRECT_OUT, value: '>' });
-      i++;
-    } else if (command[i] === '<') {
-      tokens.push({ type: TokenType.REDIRECT_IN, value: '<' });
-      i++;
-    } else {
-      // Parse word (respecting quotes)
-      let word = '';
-      let inQuote = false;
-      let quoteChar = '';
-
-      while (i < command.length) {
-        const char = command[i];
-
-        if (!inQuote) {
-          if (char === '"' || char === "'") {
-            inQuote = true;
-            quoteChar = char;
-            word += char;
-            i++;
-          } else if (/\s/.test(char) || '&|;()<>'.includes(char)) {
-            break;
-          } else if (char === '\\' && i + 1 < command.length) {
-            // Handle escape sequences
-            word += char;
-            i++;
-            if (i < command.length) {
-              word += command[i];
-              i++;
-            }
-          } else {
-            word += char;
-            i++;
-          }
-        } else {
-          if (char === quoteChar && command[i - 1] !== '\\') {
-            inQuote = false;
-            quoteChar = '';
-            word += char;
-            i++;
-          } else if (
-            char === '\\' &&
-            i + 1 < command.length &&
-            (command[i + 1] === quoteChar || command[i + 1] === '\\')
-          ) {
-            // Handle escaped quotes and backslashes inside quotes
-            word += char;
-            i++;
-            if (i < command.length) {
-              word += command[i];
-              i++;
-            }
-          } else {
-            word += char;
-            i++;
-          }
-        }
-      }
+    const operator = matchOperator(command, i);
+    if (operator) {
+      tokens.push({ type: operator.type, value: operator.value });
+      i += operator.length;
+      continue;
+    }
 
-      if (word) {
-        tokens.push({ type: TokenType.WORD, value: word });
-      }
+    // Parse word (respecting quotes)
+    const { word, endIndex } = parseWord(command, i);
+    i = endIndex;
+
+    if (word) {
+      tokens.push({ type: TokenType.WORD, value: word });
     }
   }
 

package/js/tests/resource-cleanup-internals.test.mjs

@@ -8,19 +8,27 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+// Helper to check if a listener is a command-stream SIGINT handler
+function isCommandStreamListener(l) {
+  const str = l.toString();
+  return (
+    str.includes('findActiveRunners') ||
+    str.includes('forwardSigintToRunners') ||
+    str.includes('handleSigintExit') ||
+    str.includes('activeProcessRunners') ||
+    str.includes('ProcessRunner') ||
+    str.includes('activeChildren')
+  );
+}
+
 // Helper to access internal state for testing
 // This is a testing-only approach to verify cleanup
 function getInternalState() {
   // We'll use process listeners as a proxy for internal state
   const sigintListeners = process.listeners('SIGINT');
-  const commandStreamListeners = sigintListeners.filter((l) => {
-    const str = l.toString();
-    return (
-      str.includes('activeProcessRunners') ||
-      str.includes('ProcessRunner') ||
-      str.includes('activeChildren')
-    );
-  });
+  const commandStreamListeners = sigintListeners.filter(
+    isCommandStreamListener
+  );
 
   return {
     sigintHandlerCount: commandStreamListeners.length,
@@ -50,14 +58,9 @@ describe('Resource Cleanup Internal Verification', () => {
 
       // Force remove any command-stream SIGINT listeners
       const sigintListeners = process.listeners('SIGINT');
-      const commandStreamListeners = sigintListeners.filter((l) => {
-        const str = l.toString();
-        return (
-          str.includes('activeProcessRunners') ||
-          str.includes('ProcessRunner') ||
-          str.includes('activeChildren')
-        );
-      });
+      const commandStreamListeners = sigintListeners.filter(
+        isCommandStreamListener
+      );
 
       commandStreamListeners.forEach((listener) => {
         process.removeListener('SIGINT', listener);
@@ -431,14 +434,9 @@ describe('Resource Cleanup Internal Verification', () => {
           `Pipeline error test left behind ${state.sigintHandlerCount - initialState.sigintHandlerCount} handlers, forcing cleanup...`
         );
         const sigintListeners = process.listeners('SIGINT');
-        const commandStreamListeners = sigintListeners.filter((l) => {
-          const str = l.toString();
-          return (
-            str.includes('activeProcessRunners') ||
-            str.includes('ProcessRunner') ||
-            str.includes('activeChildren')
-          );
-        });
+        const commandStreamListeners = sigintListeners.filter(
+          isCommandStreamListener
+        );
 
         commandStreamListeners.forEach((listener) => {
           process.removeListener('SIGINT', listener);

package/js/tests/sigint-cleanup.test.mjs

@@ -82,6 +82,9 @@ describe.skipIf(isWindows)('SIGINT Handler Cleanup Tests', () => {
       const ourListeners = process.listeners('SIGINT').filter((l) => {
         const str = l.toString();
         return (
+          str.includes('findActiveRunners') ||
+          str.includes('forwardSigintToRunners') ||
+          str.includes('handleSigintExit') ||
           str.includes('activeProcessRunners') ||
           str.includes('ProcessRunner') ||
           str.includes('activeChildren')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "command-stream",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Modern $ shell utility library with streaming, async iteration, and EventEmitter support, optimized for Bun runtime",
   "type": "module",
   "main": "js/src/$.mjs",

package/rust/src/ansi.rs

@@ -0,0 +1,194 @@
+//! ANSI control character utilities for command-stream
+//!
+//! This module handles stripping and processing of ANSI escape codes
+//! and control characters from text output.
+
+/// ANSI control character utilities
+pub struct AnsiUtils;
+
+impl AnsiUtils {
+    /// Strip ANSI escape sequences from text
+    ///
+    /// Removes color codes, cursor movement, and other ANSI escape sequences
+    /// while preserving the actual text content.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use command_stream::ansi::AnsiUtils;
+    ///
+    /// let text = "\x1b[31mRed text\x1b[0m";
+    /// assert_eq!(AnsiUtils::strip_ansi(text), "Red text");
+    /// ```
+    pub fn strip_ansi(text: &str) -> String {
+        let re = regex::Regex::new(r"\x1b\[[0-9;]*[mGKHFJ]").unwrap();
+        re.replace_all(text, "").to_string()
+    }
+
+    /// Strip control characters from text, preserving newlines, carriage returns, and tabs
+    ///
+    /// Removes control characters (ASCII 0x00-0x1F and 0x7F) except:
+    /// - Newlines (\n = 0x0A)
+    /// - Carriage returns (\r = 0x0D)
+    /// - Tabs (\t = 0x09)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use command_stream::ansi::AnsiUtils;
+    ///
+    /// let text = "Hello\x00World\nNew line\tTab";
+    /// assert_eq!(AnsiUtils::strip_control_chars(text), "HelloWorld\nNew line\tTab");
+    /// ```
+    pub fn strip_control_chars(text: &str) -> String {
+        text.chars()
+            .filter(|c| {
+                // Preserve newlines (\n = \x0A), carriage returns (\r = \x0D), and tabs (\t = \x09)
+                !matches!(*c as u32,
+                    0x00..=0x08 | 0x0B | 0x0C | 0x0E..=0x1F | 0x7F
+                )
+            })
+            .collect()
+    }
+
+    /// Strip both ANSI sequences and control characters
+    ///
+    /// Combines `strip_ansi` and `strip_control_chars` for complete text cleaning.
+    pub fn strip_all(text: &str) -> String {
+        Self::strip_control_chars(&Self::strip_ansi(text))
+    }
+
+    /// Clean data for processing (strips ANSI and control chars)
+    ///
+    /// Alias for `strip_all` - provides semantic clarity when processing
+    /// data that needs to be cleaned for further processing.
+    pub fn clean_for_processing(data: &str) -> String {
+        Self::strip_all(data)
+    }
+}
+
+/// Configuration for ANSI handling
+///
+/// Controls how ANSI escape codes and control characters are processed
+/// in command output.
+#[derive(Debug, Clone)]
+pub struct AnsiConfig {
+    /// Whether to preserve ANSI escape sequences in output
+    pub preserve_ansi: bool,
+    /// Whether to preserve control characters in output
+    pub preserve_control_chars: bool,
+}
+
+impl Default for AnsiConfig {
+    fn default() -> Self {
+        AnsiConfig {
+            preserve_ansi: true,
+            preserve_control_chars: true,
+        }
+    }
+}
+
+impl AnsiConfig {
+    /// Create a new AnsiConfig that preserves everything (default)
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Create a config that strips all ANSI and control characters
+    pub fn strip_all() -> Self {
+        AnsiConfig {
+            preserve_ansi: false,
+            preserve_control_chars: false,
+        }
+    }
+
+    /// Process output according to config settings
+    ///
+    /// Applies the configured stripping rules to the input data.
+    pub fn process_output(&self, data: &str) -> String {
+        if !self.preserve_ansi && !self.preserve_control_chars {
+            AnsiUtils::clean_for_processing(data)
+        } else if !self.preserve_ansi {
+            AnsiUtils::strip_ansi(data)
+        } else if !self.preserve_control_chars {
+            AnsiUtils::strip_control_chars(data)
+        } else {
+            data.to_string()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_strip_ansi() {
+        let text = "\x1b[31mRed text\x1b[0m";
+        assert_eq!(AnsiUtils::strip_ansi(text), "Red text");
+    }
+
+    #[test]
+    fn test_strip_ansi_multiple_codes() {
+        let text = "\x1b[1m\x1b[32mBold Green\x1b[0m Normal";
+        assert_eq!(AnsiUtils::strip_ansi(text), "Bold Green Normal");
+    }
+
+    #[test]
+    fn test_strip_control_chars() {
+        let text = "Hello\x00World\nNew line\tTab";
+        assert_eq!(
+            AnsiUtils::strip_control_chars(text),
+            "HelloWorld\nNew line\tTab"
+        );
+    }
+
+    #[test]
+    fn test_strip_control_chars_preserves_whitespace() {
+        let text = "Line1\nLine2\r\nLine3\tTabbed";
+        assert_eq!(
+            AnsiUtils::strip_control_chars(text),
+            "Line1\nLine2\r\nLine3\tTabbed"
+        );
+    }
+
+    #[test]
+    fn test_strip_all() {
+        let text = "\x1b[31mRed\x00text\x1b[0m";
+        assert_eq!(AnsiUtils::strip_all(text), "Redtext");
+    }
+
+    #[test]
+    fn test_ansi_config_default() {
+        let config = AnsiConfig::default();
+        let text = "\x1b[31mRed\x00text\x1b[0m";
+        assert_eq!(config.process_output(text), text);
+    }
+
+    #[test]
+    fn test_ansi_config_strip_all() {
+        let config = AnsiConfig::strip_all();
+        let text = "\x1b[31mRed\x00text\x1b[0m";
+        assert_eq!(config.process_output(text), "Redtext");
+    }
+
+    #[test]
+    fn test_ansi_config_strip_ansi_only() {
+        let config = AnsiConfig {
+            preserve_ansi: false,
+            preserve_control_chars: true,
+        };
+        let text = "\x1b[31mRed text\x1b[0m";
+        assert_eq!(config.process_output(text), "Red text");
+    }
+
+    #[test]
+    fn test_ansi_config_strip_control_only() {
+        let config = AnsiConfig {
+            preserve_ansi: true,
+            preserve_control_chars: false,
+        };
+        let text = "Hello\x00World";
+        assert_eq!(config.process_output(text), "HelloWorld");
+    }
+}