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

just_bash/commands/awk/awk.py

@@ -22,6 +22,8 @@ Variables:
   FS            field separator
   OFS           output field separator
   ORS           output record separator
+  RSTART        start of match (set by match())
+  RLENGTH       length of match (set by match())
 
 Built-in functions:
   length(s)     string length
@@ -30,13 +32,35 @@ Built-in functions:
   split(s,a,fs) split s into array a
   sub(r,s)      substitute first match
   gsub(r,s)     substitute all matches
+  match(s,r)    find regex r in s, set RSTART/RLENGTH
   tolower(s)    convert to lowercase
   toupper(s)    convert to uppercase
-  printf(fmt,args...)  formatted print
+  sprintf(fmt,args...)  return formatted string
+  printf(fmt,args...)   formatted print
   print         print current line
+
+Math functions:
+  int(x)        truncate to integer
+  sqrt(x)       square root
+  sin(x)        sine
+  cos(x)        cosine
+  log(x)        natural logarithm
+  exp(x)        exponential
+  atan2(y,x)    arctangent of y/x
+
+Random functions:
+  rand()        random number 0 <= n < 1
+  srand([seed]) seed random generator
+
+Time functions:
+  systime()     current epoch timestamp
+  strftime(fmt,ts)  format timestamp
 """
 
+import math
+import random
 import re
+import time
 from dataclasses import dataclass, field
 from typing import Any
 from ...types import CommandContext, ExecResult
@@ -60,6 +84,7 @@ class AwkState:
     output: str = ""
     next_record: bool = False
     exit_program: bool = False
+    rng: random.Random = field(default_factory=random.Random)
 
 
 class AwkCommand:
@@ -596,6 +621,17 @@ class AwkCommand:
                         pass
             return
 
+        # Handle match() as a statement (for side effects on RSTART/RLENGTH)
+        if stmt.startswith("match("):
+            # Just evaluate it - _eval_expr will set RSTART/RLENGTH
+            self._eval_expr(stmt, state, line, fields)
+            return
+
+        # Handle srand() as a statement
+        if stmt.startswith("srand(") or stmt == "srand()":
+            self._eval_expr(stmt, state, line, fields)
+            return
+
         # Handle assignment
         if "=" in stmt and not stmt.startswith("if") and "==" not in stmt and "!=" not in stmt:
             # Handle += -= *= /=
@@ -773,7 +809,6 @@ class AwkCommand:
         if expr.startswith("sqrt("):
             match = re.match(r"sqrt\((.+)\)", expr)
             if match:
-                import math
                 arg = self._eval_expr(match.group(1), state, line, fields)
                 try:
                     return math.sqrt(float(arg))
@@ -784,7 +819,6 @@ class AwkCommand:
         if expr.startswith("sin("):
             match = re.match(r"sin\((.+)\)", expr)
             if match:
-                import math
                 arg = self._eval_expr(match.group(1), state, line, fields)
                 try:
                     return math.sin(float(arg))
@@ -795,7 +829,6 @@ class AwkCommand:
         if expr.startswith("cos("):
             match = re.match(r"cos\((.+)\)", expr)
             if match:
-                import math
                 arg = self._eval_expr(match.group(1), state, line, fields)
                 try:
                     return math.cos(float(arg))
@@ -806,7 +839,6 @@ class AwkCommand:
         if expr.startswith("log("):
             match = re.match(r"log\((.+)\)", expr)
             if match:
-                import math
                 arg = self._eval_expr(match.group(1), state, line, fields)
                 try:
                     return math.log(float(arg))
@@ -817,7 +849,6 @@ class AwkCommand:
         if expr.startswith("exp("):
             match = re.match(r"exp\((.+)\)", expr)
             if match:
-                import math
                 arg = self._eval_expr(match.group(1), state, line, fields)
                 try:
                     return math.exp(float(arg))
@@ -845,6 +876,104 @@ class AwkCommand:
                     return len(parts)
             return 0
 
+        # rand() - return random number 0 <= n < 1
+        if expr == "rand()":
+            return state.rng.random()
+
+        # srand([seed]) - seed the random number generator
+        if expr.startswith("srand(") or expr == "srand()":
+            match = re.match(r"srand\(([^)]*)\)", expr)
+            if match:
+                seed_str = match.group(1).strip()
+                if seed_str:
+                    seed = self._eval_expr(seed_str, state, line, fields)
+                    try:
+                        state.rng.seed(int(float(seed)))
+                    except (ValueError, TypeError):
+                        state.rng.seed(int(time.time()))
+                else:
+                    state.rng.seed(int(time.time()))
+                return 0  # srand returns previous seed, but we just return 0
+
+        # sprintf(fmt, args...) - return formatted string
+        if expr.startswith("sprintf("):
+            match = re.match(r"sprintf\((.+)\)", expr)
+            if match:
+                args = self._split_args(match.group(1))
+                if args:
+                    fmt = str(self._eval_expr(args[0], state, line, fields))
+                    values = [self._eval_expr(a, state, line, fields) for a in args[1:]]
+                    return self._format_string(fmt, values)
+            return ""
+
+        # match(s, r) - return position of regex match, set RSTART and RLENGTH
+        if expr.startswith("match("):
+            match_call = re.match(r"match\((.+)\)", expr)
+            if match_call:
+                args = self._split_args(match_call.group(1))
+                if len(args) >= 2:
+                    s = str(self._eval_expr(args[0], state, line, fields))
+                    pattern = args[1].strip()
+                    # Handle /regex/ syntax
+                    if pattern.startswith("/") and pattern.endswith("/"):
+                        pattern = pattern[1:-1]
+                    try:
+                        regex_match = re.search(pattern, s)
+                        if regex_match:
+                            pos = regex_match.start() + 1  # 1-based
+                            length = regex_match.end() - regex_match.start()
+                            state.variables["RSTART"] = pos
+                            state.variables["RLENGTH"] = length
+                            return pos
+                        else:
+                            state.variables["RSTART"] = 0
+                            state.variables["RLENGTH"] = -1
+                            return 0
+                    except re.error:
+                        state.variables["RSTART"] = 0
+                        state.variables["RLENGTH"] = -1
+                        return 0
+            return 0
+
+        # atan2(y, x) - arctangent of y/x
+        if expr.startswith("atan2("):
+            match = re.match(r"atan2\((.+)\)", expr)
+            if match:
+                args = self._split_args(match.group(1))
+                if len(args) >= 2:
+                    y = self._eval_expr(args[0], state, line, fields)
+                    x = self._eval_expr(args[1], state, line, fields)
+                    try:
+                        return math.atan2(float(y), float(x))
+                    except (ValueError, TypeError):
+                        return 0
+            return 0
+
+        # systime() - return current epoch timestamp
+        if expr == "systime()":
+            return int(time.time())
+
+        # strftime(fmt, timestamp) - format timestamp as string
+        if expr.startswith("strftime("):
+            match = re.match(r"strftime\((.+)\)", expr)
+            if match:
+                args = self._split_args(match.group(1))
+                if args:
+                    fmt = str(self._eval_expr(args[0], state, line, fields))
+                    if len(args) >= 2:
+                        timestamp = self._eval_expr(args[1], state, line, fields)
+                        try:
+                            timestamp = int(float(timestamp))
+                        except (ValueError, TypeError):
+                            timestamp = int(time.time())
+                    else:
+                        timestamp = int(time.time())
+                    try:
+                        return time.strftime(fmt, time.localtime(timestamp))
+                    except (ValueError, OSError):
+                        return ""
+            return ""
+
         # Arithmetic - check for operators (including with spaces like "2 + 3")
         for op in ["+", "-", "*", "/", "%"]:
             if op in expr:
@@ -1010,17 +1139,70 @@ class AwkCommand:
         self, stmt: str, state: AwkState, fields: list[str], line: str
     ) -> None:
         """Execute an if statement."""
-        # Parse: if (condition) { action } [else { action }]
-        match = re.match(r"if\s*\((.+?)\)\s*\{(.+?)\}(?:\s*else\s*\{(.+?)\})?", stmt, re.DOTALL)
-        if match:
-            condition = match.group(1)
-            then_action = match.group(2)
-            else_action = match.group(3)
+        # Find the condition by matching balanced parentheses
+        if not stmt.startswith("if"):
+            return
+
+        # Find opening paren
+        paren_start = stmt.find("(")
+        if paren_start == -1:
+            return
+
+        # Find matching closing paren
+        depth = 1
+        pos = paren_start + 1
+        while pos < len(stmt) and depth > 0:
+            if stmt[pos] == "(":
+                depth += 1
+            elif stmt[pos] == ")":
+                depth -= 1
+            pos += 1
+
+        if depth != 0:
+            return
+
+        condition = stmt[paren_start + 1:pos - 1]
+        rest = stmt[pos:].strip()
+
+        # Check for braced then-action
+        if rest.startswith("{"):
+            # Find matching closing brace
+            brace_depth = 1
+            brace_pos = 1
+            while brace_pos < len(rest) and brace_depth > 0:
+                if rest[brace_pos] == "{":
+                    brace_depth += 1
+                elif rest[brace_pos] == "}":
+                    brace_depth -= 1
+                brace_pos += 1
+
+            then_action = rest[1:brace_pos - 1]
+            after_then = rest[brace_pos:].strip()
+
+            # Check for else
+            else_action = None
+            if after_then.startswith("else"):
+                else_rest = after_then[4:].strip()
+                if else_rest.startswith("{"):
+                    # Find matching brace for else
+                    brace_depth = 1
+                    brace_pos = 1
+                    while brace_pos < len(else_rest) and brace_depth > 0:
+                        if else_rest[brace_pos] == "{":
+                            brace_depth += 1
+                        elif else_rest[brace_pos] == "}":
+                            brace_depth -= 1
+                        brace_pos += 1
+                    else_action = else_rest[1:brace_pos - 1]
 
             if self._eval_condition(condition, state, fields, line):
                 self._execute_action(then_action, state, fields, line)
             elif else_action:
                 self._execute_action(else_action, state, fields, line)
+        else:
+            # No braces - rest is the statement
+            if self._eval_condition(condition, state, fields, line):
+                self._execute_statement(rest, state, fields, line)
 
     def _execute_for(
         self, stmt: str, state: AwkState, fields: list[str], line: str
@@ -1166,3 +1348,61 @@ class AwkCommand:
                 return str(int(n))
             return str(n)
         return str(n)
+
+    def _format_string(self, fmt: str, values: list[Any]) -> str:
+        """Format a string using printf-style format specifiers."""
+        result = ""
+        i = 0
+        val_idx = 0
+
+        while i < len(fmt):
+            if fmt[i] == "\\" and i + 1 < len(fmt):
+                c = fmt[i + 1]
+                if c == "n":
+                    result += "\n"
+                elif c == "t":
+                    result += "\t"
+                elif c == "\\":
+                    result += "\\"
+                else:
+                    result += c
+                i += 2
+            elif fmt[i] == "%" and i + 1 < len(fmt):
+                # Parse format spec
+                j = i + 1
+                while j < len(fmt) and fmt[j] in "-+0 #":
+                    j += 1
+                while j < len(fmt) and fmt[j].isdigit():
+                    j += 1
+                if j < len(fmt) and fmt[j] == ".":
+                    j += 1
+                    while j < len(fmt) and fmt[j].isdigit():
+                        j += 1
+                if j < len(fmt):
+                    spec = fmt[i:j + 1]
+                    conv = fmt[j]
+                    if conv == "%":
+                        result += "%"
+                    elif val_idx < len(values):
+                        val = values[val_idx]
+                        val_idx += 1
+                        try:
+                            if conv in "diouxX":
+                                result += spec % int(float(val))
+                            elif conv in "eEfFgG":
+                                result += spec % float(val)
+                            elif conv == "s":
+                                result += spec % str(val)
+                            else:
+                                result += spec % val
+                        except (ValueError, TypeError):
+                            result += str(val)
+                    i = j + 1
+                else:
+                    result += fmt[i]
+                    i += 1
+            else:
+                result += fmt[i]
+                i += 1
+
+        return result

just_bash/commands/grep/grep.py

@@ -203,8 +203,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 +230,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 +396,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/registry.py

@@ -113,6 +113,7 @@ COMMAND_NAMES = [
     "timeout",
     "seq",
     "expr",
+    "shuf",
     # Checksums
     "md5sum",
     "sha1sum",
@@ -186,6 +187,7 @@ _command_loaders: list[LazyCommandDef] = [
     LazyCommandDef(name="date", load=lambda: _load_date()),
     LazyCommandDef(name="seq", load=lambda: _load_seq()),
     LazyCommandDef(name="expr", load=lambda: _load_expr()),
+    LazyCommandDef(name="shuf", load=lambda: _load_shuf()),
     # JSON processing
     LazyCommandDef(name="jq", load=lambda: _load_jq()),
     # High priority commands
@@ -389,6 +391,12 @@ async def _load_expr() -> Command:
     return ExprCommand()
 
 
+async def _load_shuf() -> Command:
+    """Load the shuf command."""
+    from .shuf.shuf import ShufCommand
+    return ShufCommand()
+
+
 async def _load_uniq() -> Command:
     """Load the uniq command."""
     from .uniq.uniq import UniqCommand

just_bash/commands/shuf/__init__.py

@@ -0,0 +1,5 @@
+"""Shuf command."""
+
+from .shuf import ShufCommand
+
+__all__ = ["ShufCommand"]

just_bash/commands/shuf/shuf.py

@@ -0,0 +1,242 @@
+"""Shuf command implementation.
+
+Usage: shuf [OPTION]... [FILE]
+   or: shuf -e [OPTION]... [ARG]...
+   or: shuf -i LO-HI [OPTION]...
+
+Write a random permutation of the input lines to standard output.
+
+Options:
+  -e, --echo              treat each ARG as an input line
+  -i, --input-range=LO-HI treat each number LO through HI as an input line
+  -n, --head-count=COUNT  output at most COUNT lines
+  -o, --output=FILE       write result to FILE instead of standard output
+  -r, --repeat            output lines can be repeated (requires -n)
+  --random-source=FILE    get random bytes from FILE
+"""
+
+import random
+from ...types import CommandContext, ExecResult
+
+
+class ShufCommand:
+    """The shuf command."""
+
+    name = "shuf"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the shuf command."""
+        # Parse arguments
+        echo_mode = False
+        input_range = None
+        head_count = None
+        output_file = None
+        repeat = False
+        random_source = None
+        input_args: list[str] = []
+        input_file = None
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+
+            if arg in ("-e", "--echo"):
+                echo_mode = True
+            elif arg in ("-r", "--repeat"):
+                repeat = True
+            elif arg == "-n":
+                if i + 1 >= len(args):
+                    return ExecResult(
+                        stdout="",
+                        stderr="shuf: option requires an argument -- 'n'\n",
+                        exit_code=1,
+                    )
+                i += 1
+                try:
+                    head_count = int(args[i])
+                    if head_count < 0:
+                        raise ValueError()
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"shuf: invalid line count: '{args[i]}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-n"):
+                try:
+                    head_count = int(arg[2:])
+                    if head_count < 0:
+                        raise ValueError()
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"shuf: invalid line count: '{arg[2:]}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("--head-count="):
+                try:
+                    head_count = int(arg[13:])
+                    if head_count < 0:
+                        raise ValueError()
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"shuf: invalid line count: '{arg[13:]}'\n",
+                        exit_code=1,
+                    )
+            elif arg == "-i":
+                if i + 1 >= len(args):
+                    return ExecResult(
+                        stdout="",
+                        stderr="shuf: option requires an argument -- 'i'\n",
+                        exit_code=1,
+                    )
+                i += 1
+                input_range = args[i]
+            elif arg.startswith("-i"):
+                input_range = arg[2:]
+            elif arg.startswith("--input-range="):
+                input_range = arg[14:]
+            elif arg == "-o":
+                if i + 1 >= len(args):
+                    return ExecResult(
+                        stdout="",
+                        stderr="shuf: option requires an argument -- 'o'\n",
+                        exit_code=1,
+                    )
+                i += 1
+                output_file = args[i]
+            elif arg.startswith("-o"):
+                output_file = arg[2:]
+            elif arg.startswith("--output="):
+                output_file = arg[9:]
+            elif arg.startswith("--random-source="):
+                random_source = arg[16:]
+            elif arg == "--random-source":
+                if i + 1 >= len(args):
+                    return ExecResult(
+                        stdout="",
+                        stderr="shuf: option requires an argument -- 'random-source'\n",
+                        exit_code=1,
+                    )
+                i += 1
+                random_source = args[i]
+            elif arg.startswith("-") and len(arg) > 1 and arg != "-":
+                return ExecResult(
+                    stdout="",
+                    stderr=f"shuf: invalid option -- '{arg[1]}'\n",
+                    exit_code=1,
+                )
+            else:
+                if echo_mode:
+                    input_args.append(arg)
+                elif input_file is None:
+                    input_file = arg
+                else:
+                    input_args.append(arg)
+
+            i += 1
+
+        # Set up random generator
+        rng = random.Random()
+        if random_source:
+            try:
+                path = ctx.fs.resolve_path(ctx.cwd, random_source)
+                seed_data = await ctx.fs.read_file(path)
+                # Use hash of file content as seed
+                rng.seed(hash(seed_data))
+            except FileNotFoundError:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"shuf: {random_source}: No such file or directory\n",
+                    exit_code=1,
+                )
+
+        # Get input lines
+        lines: list[str] = []
+
+        if input_range:
+            # Parse range LO-HI
+            if "-" not in input_range:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"shuf: invalid input range: '{input_range}'\n",
+                    exit_code=1,
+                )
+            parts = input_range.split("-", 1)
+            try:
+                lo = int(parts[0])
+                hi = int(parts[1])
+            except ValueError:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"shuf: invalid input range: '{input_range}'\n",
+                    exit_code=1,
+                )
+            if lo > hi:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"shuf: invalid input range: '{input_range}'\n",
+                    exit_code=1,
+                )
+            lines = [str(n) for n in range(lo, hi + 1)]
+        elif echo_mode:
+            lines = input_args
+        else:
+            # Read from file or stdin
+            if input_file:
+                try:
+                    path = ctx.fs.resolve_path(ctx.cwd, input_file)
+                    content = await ctx.fs.read_file(path)
+                except FileNotFoundError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"shuf: {input_file}: No such file or directory\n",
+                        exit_code=1,
+                    )
+            else:
+                content = ctx.stdin
+
+            if content:
+                # Split into lines, preserving empty lines but removing final newline
+                if content.endswith("\n"):
+                    content = content[:-1]
+                if content:
+                    lines = content.split("\n")
+
+        # Handle empty input
+        if not lines:
+            if output_file:
+                path = ctx.fs.resolve_path(ctx.cwd, output_file)
+                await ctx.fs.write_file(path, "")
+            return ExecResult(stdout="", stderr="", exit_code=0)
+
+        # Generate output
+        output_lines: list[str] = []
+
+        if repeat:
+            # With repeat, we can output more lines than input
+            count = head_count if head_count is not None else len(lines)
+            for _ in range(count):
+                output_lines.append(rng.choice(lines))
+        else:
+            # Shuffle and optionally limit
+            shuffled = lines.copy()
+            rng.shuffle(shuffled)
+            if head_count is not None:
+                output_lines = shuffled[:head_count]
+            else:
+                output_lines = shuffled
+
+        # Build output
+        output = "\n".join(output_lines)
+        if output:
+            output += "\n"
+
+        # Write to file or stdout
+        if output_file:
+            path = ctx.fs.resolve_path(ctx.cwd, output_file)
+            await ctx.fs.write_file(path, output)
+            return ExecResult(stdout="", stderr="", exit_code=0)
+
+        return ExecResult(stdout=output, stderr="", exit_code=0)

just_bash/fs/overlay_fs.py

@@ -155,6 +155,9 @@ class OverlayFs:
 
     def _is_under_mount(self, path: str) -> bool:
         """Check if a normalized path is under the mount point."""
+        # Special case: root mount point means all paths are under it
+        if self._mount_point == "/":
+            return True
         return path == self._mount_point or path.startswith(self._mount_point + "/")
 
     def _to_real_path(self, virtual_path: str) -> Path | None:
@@ -172,7 +175,11 @@ class OverlayFs:
             return self._root
 
         # Strip mount point prefix
-        relative = normalized[len(self._mount_point) + 1:]  # +1 for the /
+        # Special case: when mount_point is "/", just strip the leading "/"
+        if self._mount_point == "/":
+            relative = normalized[1:]  # Just strip the leading /
+        else:
+            relative = normalized[len(self._mount_point) + 1:]  # +1 for the /
         return self._root / relative
 
     def _is_deleted(self, path: str) -> bool:

just_bash/interpreter/interpreter.py

@@ -543,7 +543,9 @@ class Interpreter:
         if node.name is None:
             return _ok()
 
-        # Process redirections for heredocs
+        # Process redirections for heredocs and input redirections
+        from ..ast.types import WordNode
+
         for redir in node.redirections:
             if redir.operator in ("<<", "<<-"):
                 # Here-document: the target should be a HereDocNode
@@ -557,6 +559,17 @@ class Interpreter:
                         lines = heredoc_content.split("\n")
                         heredoc_content = "\n".join(line.lstrip("\t") for line in lines)
                     stdin = heredoc_content
+            elif redir.operator == "<":
+                # Input redirection: read file content into stdin
+                if redir.target is not None and isinstance(redir.target, WordNode):
+                    target_path = await expand_word_async(self._ctx, redir.target)
+                    target_path = self._fs.resolve_path(self._state.cwd, target_path)
+                    try:
+                        stdin = await self._fs.read_file(target_path)
+                    except FileNotFoundError:
+                        return _failure(f"bash: {target_path}: No such file or directory\n")
+                    except IsADirectoryError:
+                        return _failure(f"bash: {target_path}: Is a directory\n")
 
         try:
             # Expand command name

{just_bash-0.1.5.dist-info → just_bash-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: just-bash
-Version: 0.1.5
+Version: 0.1.8
 Summary: A pure Python bash interpreter with in-memory virtual filesystem
 Project-URL: Homepage, https://github.com/dbreunig/just-bash-py
 Project-URL: Repository, https://github.com/dbreunig/just-bash-py

{just_bash-0.1.5.dist-info → just_bash-0.1.8.dist-info}/RECORD

@@ -6,11 +6,11 @@ just_bash/ast/__init__.py,sha256=yItXk_RIPHj3Op6JKBKjxdyZaxW_1lTg5d-L-KHgDLc,457
 just_bash/ast/factory.py,sha256=TPlE5uT2XAqViKiHtJILw5vpeqrAKRUfzLQAwIb19y4,8268
 just_bash/ast/types.py,sha256=o8MdwIirjAcA1HgvQaOmrK5iwSWpYOlvvnRdkbvTBck,26574
 just_bash/commands/__init__.py,sha256=sKNb1FjmMY56svg4BJuVgm0ljhbpVl_tMKcx3jFNdE8,523
-just_bash/commands/registry.py,sha256=djwBIfuPqU7OK5JX6dzYG-bJHuVLBStH9b8K-hKzFHk,21962
+just_bash/commands/registry.py,sha256=luqpSlvVD4TxhoG1sqEVKzCdt0sez8qYH6-Cb5KreqU,22168
 just_bash/commands/argv/__init__.py,sha256=QrGig0hlCcxkOYGzqWsw_bWVOFwxxLLeukU7wAiGDp4,85
 just_bash/commands/argv/argv.py,sha256=Qbn7gIjplMA3HSB7scnLd0wOerjcwuTfg_m5HmyTYIE,560
 just_bash/commands/awk/__init__.py,sha256=ZpgMK6A0QsApd3GyCIvpkmL3iPf7FaUPav13bdUsZhk,89
-just_bash/commands/awk/awk.py,sha256=Rzi14vZ36K2SIdTvIl_T7Nf0OxEumZ_x86vSZAMnnCg,40913
+just_bash/commands/awk/awk.py,sha256=_xA7b2eKvAaxF6VXdkc1gni4nMLWwGWSJ-ScFdKUO10,50164
 just_bash/commands/base64/__init__.py,sha256=0hKkKgCi7m_TDz83hd3KaFJgjmBDjIqfLx7bctx98xA,101
 just_bash/commands/base64/base64.py,sha256=UtzE0e-3MAYm_61anfI3Vxm36UlOB4X9fobl9ySV8s0,4927
 just_bash/commands/basename/__init__.py,sha256=mEapj7eo70RrVGjwhVj9S9idWrBxptOPu6uV6z_cteo,94
@@ -58,7 +58,7 @@ just_bash/commands/find/find.py,sha256=I2Qmn3cSUvyiVfdh2XIYJqACpe2ggiPdxnNhPlN2d
 just_bash/commands/fold/__init__.py,sha256=R0PCq0oBJ5PWEXIeRz-M1vuNkoRdvWLaSSiXyEx9nKQ,78
 just_bash/commands/fold/fold.py,sha256=QWGehi7vdVhcAGxaAZ4lWYHAuWquduhFb515zpKL09M,5417
 just_bash/commands/grep/__init__.py,sha256=Ho400PkJRLXBf5Rt7tYF4uiS8Dbv4VhWcfkQNzqgxB4,153
-just_bash/commands/grep/grep.py,sha256=AaA99kpS8Kel9v_M-liLL2I1RRVIe4zowg351VopFck,16607
+just_bash/commands/grep/grep.py,sha256=GKmcSSKAjNnwwuAaNEBYPQsjTp_Rj1rB3g6mffQS5Uc,20599
 just_bash/commands/head/__init__.py,sha256=UTgOtL29ZxbqIKjEXC0EjaxmlnWD8dYFFbW4YruJCDI,93
 just_bash/commands/head/head.py,sha256=41Ib8Z5uIBiiISWB-My9CAK7nDfpQJnnS7vkRwkA2yo,6083
 just_bash/commands/help/__init__.py,sha256=F-NY6nt_1vpSm4qPDd93-muE6Pz_K68wy3-_PpMNvlE,78
@@ -108,6 +108,8 @@ just_bash/commands/seq/__init__.py,sha256=WoS9bcCPBCi4kEAwqmUSyxo-1ekumaJ-QFJYLN
 just_bash/commands/seq/seq.py,sha256=cBfVJqbZMmXXXUA2FcXDJk8H2yZpTXqKLgy6-f5vciE,6485
 just_bash/commands/shell/__init__.py,sha256=7FUmyHPZv-ujikzHzks8SRTPYScfs9vr_9KJ8Ny72XM,189
 just_bash/commands/shell/shell.py,sha256=NEuSVfXz-L-0L2ev6M5ir4S9z6TvEN8-mIJgSlV1wjg,6753
+just_bash/commands/shuf/__init__.py,sha256=0xLdf5wRMK4vfOoCwDWdOisHy09PGuJnkIp0oRnBhjM,78
+just_bash/commands/shuf/shuf.py,sha256=BDGkvKqYvAq1I6ZGetBfvOzsaSjznwfIc2vPZ4yhoSs,8523
 just_bash/commands/sleep/__init__.py,sha256=c2BuhU78G38aj6zOZwplWhtqmbf0ydfv8y_cIdc9N3I,82
 just_bash/commands/sleep/sleep.py,sha256=tKXLGndy43nDgT-gO5jLnclkmMY_k2mU7cZh3Hxcb2M,1710
 just_bash/commands/sort/__init__.py,sha256=97Zp6z7YGf6HLvhVYsN9atRXUDfCTxr7GrfsQmY0fBY,93
@@ -153,14 +155,14 @@ just_bash/commands/yq/yq.py,sha256=Av6QQSHOvV5pp11lgvK22bJR0SEzQNuNkVvXbznc5a0,2
 just_bash/fs/__init__.py,sha256=hEDypfPi7T7tHOIyf97JOcoryKjd9fF_XAShDUyGj58,636
 just_bash/fs/in_memory_fs.py,sha256=I7pnAYyrZVTEBr05XV3cbetENAUgnqW7D-rt93RFmQQ,21347
 just_bash/fs/mountable_fs.py,sha256=xhYLRllN1mCScL4tG8q0JXyanEntyZLxMYK6hvc3Pg4,17774
-just_bash/fs/overlay_fs.py,sha256=WHbefQBVlIYVTKlJ7s_qdoVE2qYib1Y99bTcaHKDFxE,30405
+just_bash/fs/overlay_fs.py,sha256=9ZKCw_xtH8EFXvrs1kz2sDtyf73HoVJYLgSdKGyxEIQ,30733
 just_bash/fs/read_write_fs.py,sha256=7auXvArIuKlmbQGxPNSpV8tR48tJp4mfqUhrBNEpbXc,14813
 just_bash/interpreter/__init__.py,sha256=ud2zeA0Ly0rMjhzY9zEOnLzukUi7FnJYJ0ZCMnTEuhA,790
 just_bash/interpreter/conditionals.py,sha256=wRMRiEMevhJom6KJbYC8Rxb7mfQdOmUG3cOJk8iQXDk,11169
 just_bash/interpreter/control_flow.py,sha256=k-ZDCXslQ4EJc9N1GbvDmfzPNoavpL36qZFgifLJ6A4,11997
 just_bash/interpreter/errors.py,sha256=Nz_dbvGxCybfnxFSTxKD5QIEQBz0Y6SrRA4KDhq2n20,3585
 just_bash/interpreter/expansion.py,sha256=Yc-yKt16MjsjFrdYNJ-e1JdN_B1jS5G85JvRmv6TuIM,41584
-just_bash/interpreter/interpreter.py,sha256=nAv9WQvGnEy-h9Si6f_Uo2TZ4f2e0o8ows1WW1E3Je8,29933
+just_bash/interpreter/interpreter.py,sha256=LnQEuSHJoCY1B5hdp8WzQkh_vfjsVw04xyfNwwaObHE,30719
 just_bash/interpreter/types.py,sha256=t8v7sRSVf0_sVmXWKxAV3x1pi2vzun3yi97qtq8wanY,3992
 just_bash/interpreter/builtins/__init__.py,sha256=uGh2b8ij3DQ4oxYodRyfMhOWTFdRHPa3wuqMfOBw_ms,2461
 just_bash/interpreter/builtins/alias.py,sha256=b575DQKcNbT2uNK-7YBsPEyNZ54-YjjduUaoQ6-z150,4017
@@ -188,6 +190,6 @@ just_bash/query_engine/parser.py,sha256=pHw-il3AoaIbuvL9MBuxgv4BVsPCJjTl3OHEZmqe
 just_bash/query_engine/tokenizer.py,sha256=PfaHJ8Y8N_KkFCiti7iGP4Le4A2JjAhg3OtAMJuNIBo,10161
 just_bash/query_engine/types.py,sha256=zhUj2FvClAANpWvcvXSyvWBxT-g2jAczCiE7kNQzHrM,7272
 just_bash/query_engine/builtins/__init__.py,sha256=Rs7TjJ0rjFmL9GyQXBbU4H0k9WLbgDlT31_mhpd-1aw,40315
-just_bash-0.1.5.dist-info/METADATA,sha256=xWtbxsqvTCCCk1AZR-K8n81mxinzYx3hPL8VXZBieZQ,12809
-just_bash-0.1.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-just_bash-0.1.5.dist-info/RECORD,,
+just_bash-0.1.8.dist-info/METADATA,sha256=wItRiamHJQtxPWo9XJqw5AnxLaba052xs-ORi-YuKQM,12809
+just_bash-0.1.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+just_bash-0.1.8.dist-info/RECORD,,