just-bash 0.1.5__py3-none-any.whl → 0.1.10__py3-none-any.whl

just_bash/commands/echo/echo.py

@@ -53,7 +53,7 @@ def _process_escapes(s: str) -> str:
                     octal += s[j]
                     j += 1
                 if octal:
-                    result.append(chr(int(octal, 8)))
+                    result.append(chr(int(octal, 8) & 0xFF))
                 else:
                     result.append("\0")
                 i = j
@@ -70,6 +70,38 @@ def _process_escapes(s: str) -> str:
                 else:
                     result.append(s[i])
                     i += 1
+            elif next_char == "u":
+                # Unicode escape: \uHHHH (4 hex digits)
+                hex_digits = ""
+                j = i + 2
+                while j < len(s) and len(hex_digits) < 4 and s[j] in "0123456789abcdefABCDEF":
+                    hex_digits += s[j]
+                    j += 1
+                if hex_digits:
+                    try:
+                        result.append(chr(int(hex_digits, 16)))
+                    except (ValueError, OverflowError):
+                        result.append("\\u" + hex_digits)
+                    i = j
+                else:
+                    result.append("\\u")
+                    i += 2
+            elif next_char == "U":
+                # Unicode escape: \UHHHHHHHH (8 hex digits)
+                hex_digits = ""
+                j = i + 2
+                while j < len(s) and len(hex_digits) < 8 and s[j] in "0123456789abcdefABCDEF":
+                    hex_digits += s[j]
+                    j += 1
+                if hex_digits:
+                    try:
+                        result.append(chr(int(hex_digits, 16)))
+                    except (ValueError, OverflowError):
+                        result.append("\\U" + hex_digits)
+                    i = j
+                else:
+                    result.append("\\U")
+                    i += 2
             elif next_char == "c":
                 # \c stops output
                 return "".join(result)

just_bash/commands/grep/grep.py

@@ -152,7 +152,10 @@ class GrepCommand:
                     elif arg == "-e":
                         patterns.append(val)
                 else:
-                    for c in arg[1:]:
+                    chars = arg[1:]
+                    ci = 0
+                    while ci < len(chars):
+                        c = chars[ci]
                         if c == 'i':
                             ignore_case = True
                         elif c == 'v':
@@ -186,12 +189,38 @@ class GrepCommand:
                             word_regexp = True
                         elif c == 'x':
                             line_regexp = True
+                        elif c in ('A', 'B', 'C', 'm', 'e'):
+                            # These flags take a value: rest of string or next arg
+                            rest = chars[ci + 1:]
+                            if rest:
+                                val = rest
+                            elif i + 1 < len(args):
+                                i += 1
+                                val = args[i]
+                            else:
+                                return ExecResult(
+                                    stdout="",
+                                    stderr=f"grep: option requires an argument -- '{c}'\n",
+                                    exit_code=2,
+                                )
+                            if c == 'A':
+                                after_context = int(val)
+                            elif c == 'B':
+                                before_context = int(val)
+                            elif c == 'C':
+                                before_context = after_context = int(val)
+                            elif c == 'm':
+                                max_count = int(val)
+                            elif c == 'e':
+                                patterns.append(val)
+                            break  # Rest of chars consumed as value
                         else:
                             return ExecResult(
                                 stdout="",
                                 stderr=f"grep: invalid option -- '{c}'\n",
                                 exit_code=2,
                             )
+                        ci += 1
             elif pattern is None and not patterns:
                 pattern = arg
             else:
@@ -203,8 +232,18 @@ class GrepCommand:
             if pattern:
                 # If pattern was set, it's actually a file
                 files.insert(0, pattern)
-            pattern = "|".join(f"({p})" for p in patterns)
-        elif pattern is None:
+            # Convert each pattern from BRE before combining (if not ERE mode)
+            if not extended_regexp and not fixed_strings:
+                converted = [self._bre_to_python_regex(p) for p in patterns]
+                pattern = "|".join(f"({p})" for p in converted)
+            else:
+                pattern = "|".join(f"({p})" for p in patterns)
+            # Mark as already converted
+            patterns_already_converted = True
+        else:
+            patterns_already_converted = False
+
+        if pattern is None and not patterns:
             return ExecResult(
                 stdout="",
                 stderr="grep: pattern not specified\n",
@@ -220,6 +259,10 @@ class GrepCommand:
             if fixed_strings:
                 # Escape all regex metacharacters
                 pattern = re.escape(pattern)
+            elif not extended_regexp and not patterns_already_converted:
+                # Convert BRE (Basic Regular Expression) to Python regex
+                pattern = self._bre_to_python_regex(pattern)
+
             if word_regexp:
                 pattern = r'\b' + pattern + r'\b'
             if line_regexp:
@@ -382,6 +425,101 @@ class GrepCommand:
         exit_code = 0 if found_match else 1
         return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)
 
+    def _bre_to_python_regex(self, pattern: str) -> str:
+        """Convert BRE (Basic Regular Expression) to Python regex.
+
+        In BRE:
+        - \\| is alternation, | is literal
+        - \\+ is one-or-more, + is literal
+        - \\? is zero-or-one, ? is literal
+        - \\( \\) is grouping, ( ) are literal
+        - \\{ \\} is repetition, { } are literal
+        - \\< \\> is word boundary
+
+        In Python regex (like ERE):
+        - | is alternation, \\| is literal
+        - + is one-or-more, \\+ is literal
+        - etc.
+        """
+        result = []
+        i = 0
+        while i < len(pattern):
+            if pattern[i] == '\\' and i + 1 < len(pattern):
+                next_char = pattern[i + 1]
+                if next_char == '|':
+                    # BRE \| -> Python |
+                    result.append('|')
+                    i += 2
+                elif next_char == '+':
+                    # BRE \+ -> Python +
+                    result.append('+')
+                    i += 2
+                elif next_char == '?':
+                    # BRE \? -> Python ?
+                    result.append('?')
+                    i += 2
+                elif next_char == '(':
+                    # BRE \( -> Python (
+                    result.append('(')
+                    i += 2
+                elif next_char == ')':
+                    # BRE \) -> Python )
+                    result.append(')')
+                    i += 2
+                elif next_char == '{':
+                    # BRE \{ -> Python {
+                    result.append('{')
+                    i += 2
+                elif next_char == '}':
+                    # BRE \} -> Python }
+                    result.append('}')
+                    i += 2
+                elif next_char == '<':
+                    # BRE \< (word start) -> Python \b
+                    result.append(r'\b')
+                    i += 2
+                elif next_char == '>':
+                    # BRE \> (word end) -> Python \b
+                    result.append(r'\b')
+                    i += 2
+                else:
+                    # Other escapes pass through as-is
+                    result.append(pattern[i:i + 2])
+                    i += 2
+            elif pattern[i] == '|':
+                # BRE literal | -> Python \|
+                result.append(r'\|')
+                i += 1
+            elif pattern[i] == '+':
+                # BRE literal + -> Python \+
+                result.append(r'\+')
+                i += 1
+            elif pattern[i] == '?':
+                # BRE literal ? -> Python \?
+                result.append(r'\?')
+                i += 1
+            elif pattern[i] == '(':
+                # BRE literal ( -> Python \(
+                result.append(r'\(')
+                i += 1
+            elif pattern[i] == ')':
+                # BRE literal ) -> Python \)
+                result.append(r'\)')
+                i += 1
+            elif pattern[i] == '{':
+                # BRE literal { -> Python \{
+                result.append(r'\{')
+                i += 1
+            elif pattern[i] == '}':
+                # BRE literal } -> Python \}
+                result.append(r'\}')
+                i += 1
+            else:
+                result.append(pattern[i])
+                i += 1
+
+        return ''.join(result)
+
     async def _get_files_recursive(self, ctx: CommandContext, path: str) -> list[str]:
         """Get all files in a directory recursively."""
         files = []

just_bash/commands/od/od.py

@@ -13,6 +13,8 @@ class OdCommand:
         format_type = "o"  # octal (default)
         address_format = "o"  # octal addresses
         suppress_address = False
+        skip_bytes = 0
+        read_count = -1  # -1 means read all
         files: list[str] = []
 
         i = 0
@@ -34,12 +36,97 @@ class OdCommand:
                 format_type = "d"  # decimal
             elif arg == "-An":
                 suppress_address = True
-            elif arg == "-Ad":
-                address_format = "d"
-            elif arg == "-Ao":
-                address_format = "o"
-            elif arg == "-Ax":
-                address_format = "x"
+            elif arg == "-A":
+                # -A RADIX: address radix
+                if i + 1 < len(args):
+                    i += 1
+                    radix = args[i]
+                    if radix == "n":
+                        suppress_address = True
+                    elif radix in ("d", "o", "x"):
+                        address_format = radix
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr="od: option requires an argument -- 'A'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-A") and len(arg) == 3:
+                radix = arg[2]
+                if radix == "n":
+                    suppress_address = True
+                elif radix in ("d", "o", "x"):
+                    address_format = radix
+            elif arg == "-j":
+                # -j BYTES: skip bytes
+                if i + 1 < len(args):
+                    i += 1
+                    try:
+                        skip_bytes = int(args[i])
+                    except ValueError:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"od: invalid argument '{args[i]}' for skip\n",
+                            exit_code=1,
+                        )
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr="od: option requires an argument -- 'j'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-j") and len(arg) > 2:
+                try:
+                    skip_bytes = int(arg[2:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"od: invalid argument '{arg[2:]}' for skip\n",
+                        exit_code=1,
+                    )
+            elif arg == "-N":
+                # -N BYTES: read count
+                if i + 1 < len(args):
+                    i += 1
+                    try:
+                        read_count = int(args[i])
+                    except ValueError:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"od: invalid argument '{args[i]}' for count\n",
+                            exit_code=1,
+                        )
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr="od: option requires an argument -- 'N'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-N") and len(arg) > 2:
+                try:
+                    read_count = int(arg[2:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"od: invalid argument '{arg[2:]}' for count\n",
+                        exit_code=1,
+                    )
+            elif arg == "-t":
+                # -t TYPE: type specifier follows
+                if i + 1 < len(args):
+                    i += 1
+                    type_spec = args[i]
+                    format_type = self._parse_type_spec(type_spec)
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr="od: option requires an argument -- 't'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-t"):
+                # -tTYPE: type specifier attached
+                type_spec = arg[2:]
+                format_type = self._parse_type_spec(type_spec)
             elif arg == "--":
                 files.extend(args[i + 1:])
                 break
@@ -55,7 +142,12 @@ class OdCommand:
 
         # Read from stdin if no files
         if not files:
-            content = ctx.stdin.encode("utf-8", errors="replace")
+            content = ctx.stdin.encode("latin-1", errors="replace")
+            # Apply skip and count
+            if skip_bytes > 0:
+                content = content[skip_bytes:]
+            if read_count >= 0:
+                content = content[:read_count]
             result = self._dump(content, format_type, address_format, suppress_address)
             return ExecResult(stdout=result, stderr="", exit_code=0)
 
@@ -66,11 +158,17 @@ class OdCommand:
         for file in files:
             try:
                 if file == "-":
-                    content = ctx.stdin.encode("utf-8", errors="replace")
+                    content = ctx.stdin.encode("latin-1", errors="replace")
                 else:
                     path = ctx.fs.resolve_path(ctx.cwd, file)
                     content = await ctx.fs.read_file_bytes(path)
 
+                # Apply skip and count
+                if skip_bytes > 0:
+                    content = content[skip_bytes:]
+                if read_count >= 0:
+                    content = content[:read_count]
+
                 result = self._dump(content, format_type, address_format, suppress_address)
                 stdout_parts.append(result)
 
@@ -80,6 +178,22 @@ class OdCommand:
 
         return ExecResult(stdout="".join(stdout_parts), stderr=stderr, exit_code=exit_code)
 
+    def _parse_type_spec(self, spec: str) -> str:
+        """Parse a -t type specifier."""
+        if not spec:
+            return "o"
+        first_char = spec[0].lower()
+        if first_char == "c":
+            return "c"
+        elif first_char == "x":
+            return "x"
+        elif first_char == "o":
+            return "o"
+        elif first_char == "d" or first_char == "u":
+            return "d"
+        else:
+            return "o"
+
     def _dump(
         self, data: bytes, format_type: str, address_format: str, suppress_address: bool
     ) -> str:
@@ -101,44 +215,44 @@ class OdCommand:
                 else:
                     parts.append(f"{offset:07o}")
 
-            # Add data
+            # Add data with proper 4-char field formatting
             if format_type == "c":
-                # Character format
+                # Character format: each char in 4-char field
                 chars = []
                 for byte in line_data:
                     if byte == 0:
-                        chars.append("\\0")
+                        chars.append("  \\0")
                     elif byte == 7:
-                        chars.append("\\a")
+                        chars.append("  \\a")
                     elif byte == 8:
-                        chars.append("\\b")
+                        chars.append("  \\b")
                     elif byte == 9:
-                        chars.append("\\t")
+                        chars.append("  \\t")
                     elif byte == 10:
-                        chars.append("\\n")
+                        chars.append("  \\n")
                     elif byte == 11:
-                        chars.append("\\v")
+                        chars.append("  \\v")
                     elif byte == 12:
-                        chars.append("\\f")
+                        chars.append("  \\f")
                     elif byte == 13:
-                        chars.append("\\r")
+                        chars.append("  \\r")
                     elif 32 <= byte <= 126:
-                        chars.append(f"  {chr(byte)}")
+                        chars.append(f"   {chr(byte)}")
                     else:
-                        chars.append(f"{byte:03o}")
-                parts.append(" ".join(chars))
+                        chars.append(f" {byte:03o}")
+                parts.append("".join(chars))
             elif format_type == "x":
-                # Hexadecimal format
-                hex_vals = [f"{byte:02x}" for byte in line_data]
-                parts.append(" ".join(hex_vals))
+                # Hexadecimal format: 4-char fields
+                hex_vals = [f"  {byte:02x}" for byte in line_data]
+                parts.append("".join(hex_vals))
             elif format_type == "d":
-                # Decimal format
-                dec_vals = [f"{byte:3d}" for byte in line_data]
-                parts.append(" ".join(dec_vals))
+                # Decimal format: 4-char fields
+                dec_vals = [f" {byte:3d}" for byte in line_data]
+                parts.append("".join(dec_vals))
             else:
-                # Octal format (default)
-                oct_vals = [f"{byte:03o}" for byte in line_data]
-                parts.append(" ".join(oct_vals))
+                # Octal format (default): 4-char fields
+                oct_vals = [f" {byte:03o}" for byte in line_data]
+                parts.append("".join(oct_vals))
 
             result_lines.append(" ".join(parts))
             offset += bytes_per_line