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

just_bash/ast/factory.py

@@ -78,6 +78,7 @@ def simple_command(
     args: Sequence[WordNode] | None = None,
     assignments: Sequence[AssignmentNode] | None = None,
     redirections: Sequence[RedirectionNode] | None = None,
+    line: int | None = None,
 ) -> SimpleCommandNode:
     """Create a simple command node."""
     return SimpleCommandNode(
@@ -85,6 +86,7 @@ def simple_command(
         args=tuple(args) if args else (),
         assignments=tuple(assignments) if assignments else (),
         redirections=tuple(redirections) if redirections else (),
+        line=line,
     )
 
 
@@ -205,7 +207,7 @@ def for_node(
     """Create a for node."""
     return ForNode(
         variable=variable,
-        words=tuple(words) if words else None,
+        words=tuple(words) if words is not None else None,
         body=tuple(body),
         redirections=tuple(redirections) if redirections else (),
     )

just_bash/bash.py

@@ -28,8 +28,8 @@ import nest_asyncio  # type: ignore[import-untyped]
 
 from .commands import create_command_registry
 from .fs import InMemoryFs
-from .interpreter import Interpreter, InterpreterState, ShellOptions
-from .parser import parse
+from .interpreter import ExitError, Interpreter, InterpreterState, ShellOptions, VariableStore
+from .parser import parse, unescape_html_entities
 from .types import (
     Command,
     ExecResult,
@@ -59,6 +59,7 @@ class Bash:
         errexit: bool = False,
         pipefail: bool = False,
         nounset: bool = False,
+        unescape_html: bool = True,
     ):
         """Initialize the Bash interpreter.
 
@@ -73,6 +74,9 @@ class Bash:
             errexit: Enable errexit (set -e) mode.
             pipefail: Enable pipefail mode.
             nounset: Enable nounset (set -u) mode.
+            unescape_html: Unescape HTML entities in operator positions (default True).
+                This helps LLM-generated commands work correctly when they contain
+                &lt; instead of <, &gt; instead of >, etc.
         """
         # Set up filesystem
         if fs is not None:
@@ -89,15 +93,21 @@ class Bash:
         # Set up network config
         self._network = network
 
+        # Set up HTML unescaping
+        self._unescape_html = unescape_html
+
         # Set up initial state
-        default_env = {
+        default_env = VariableStore({
             "PATH": "/usr/local/bin:/usr/bin:/bin",
             "HOME": "/home/user",
             "USER": "user",
             "SHELL": "/bin/bash",
             "PWD": cwd,
             "?": "0",
-        }
+            "SHLVL": "1",
+            "BASH_VERSION": "5.0.0(1)-release",
+            "OPTIND": "1",
+        })
         if env:
             default_env.update(env)
 
@@ -152,6 +162,10 @@ class Bash:
         Returns:
             ExecResult with stdout, stderr, exit_code, and final env.
         """
+        # Preprocess HTML entities if enabled
+        if self._unescape_html:
+            script = unescape_html_entities(script)
+
         # Parse the script
         ast = parse(script)
 
@@ -163,7 +177,15 @@ class Bash:
             self._interpreter.state.env["PWD"] = cwd
 
         # Execute
-        return await self._interpreter.execute_script(ast)
+        try:
+            return await self._interpreter.execute_script(ast)
+        except ExitError as error:
+            return ExecResult(
+                stdout=error.stdout,
+                stderr=error.stderr,
+                exit_code=error.exit_code,
+                env=dict(self._interpreter.state.env),
+            )
 
     def run(
         self,
@@ -208,7 +230,7 @@ class Bash:
             commands=self._commands,
             limits=self._limits,
             state=InterpreterState(
-                env=dict(self._initial_state.env),
+                env=self._initial_state.env.copy() if isinstance(self._initial_state.env, VariableStore) else VariableStore(self._initial_state.env),
                 cwd=self._initial_state.cwd,
                 previous_dir=self._initial_state.previous_dir,
                 options=ShellOptions(

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
@@ -50,6 +74,7 @@ class AwkRule:
     action: str
     is_regex: bool = False
     regex: re.Pattern | None = None
+    negate: bool = False  # ! pattern negation
 
 
 @dataclass
@@ -60,6 +85,7 @@ class AwkState:
     output: str = ""
     next_record: bool = False
     exit_program: bool = False
+    rng: random.Random = field(default_factory=random.Random)
 
 
 class AwkCommand:
@@ -262,12 +288,27 @@ class AwkCommand:
             is_regex = False
             regex = None
 
+            negate_pattern = False
+
             if program[pos:].startswith("BEGIN"):
                 pattern = "BEGIN"
                 pos += 5
             elif program[pos:].startswith("END"):
                 pattern = "END"
                 pos += 3
+            elif program[pos] == "!" and pos + 1 < len(program) and program[pos + 1] == "/":
+                # Negated regex pattern
+                negate_pattern = True
+                pos += 1  # skip '!', now pos is at '/'
+                end = self._find_regex_end(program, pos + 1)
+                if end != -1:
+                    pattern = program[pos + 1:end]
+                    is_regex = True
+                    try:
+                        regex = re.compile(pattern)
+                    except re.error as e:
+                        raise ValueError(f"invalid regex: {e}")
+                    pos = end + 1
             elif program[pos] == "/":
                 # Regex pattern
                 end = self._find_regex_end(program, pos + 1)
@@ -324,10 +365,10 @@ class AwkCommand:
                     pos += 1
 
                 action = program[start:pos - 1].strip()
-                rules.append(AwkRule(pattern=pattern, action=action, is_regex=is_regex, regex=regex))
+                rules.append(AwkRule(pattern=pattern, action=action, is_regex=is_regex, regex=regex, negate=negate_pattern))
             else:
                 # Default action is print $0
-                rules.append(AwkRule(pattern=pattern, action="print", is_regex=is_regex, regex=regex))
+                rules.append(AwkRule(pattern=pattern, action="print", is_regex=is_regex, regex=regex, negate=negate_pattern))
 
         return rules
 
@@ -349,7 +390,8 @@ class AwkCommand:
             return True
 
         if rule.is_regex and rule.regex:
-            return bool(rule.regex.search(line))
+            result = bool(rule.regex.search(line))
+            return not result if rule.negate else result
 
         # Expression pattern
         pattern = rule.pattern
@@ -468,7 +510,15 @@ class AwkCommand:
         if current.strip():
             statements.append(current.strip())
 
-        return statements
+        # Merge 'else' parts back into their preceding 'if' statement
+        merged = []
+        for stmt in statements:
+            if stmt.startswith("else") and merged and merged[-1].lstrip().startswith("if"):
+                merged[-1] = merged[-1] + "; " + stmt
+            else:
+                merged.append(stmt)
+
+        return merged
 
     def _execute_statement(
         self, stmt: str, state: AwkState, fields: list[str], line: str
@@ -596,6 +646,28 @@ class AwkCommand:
                         pass
             return
 
+        # Handle delete statement
+        if stmt.startswith("delete "):
+            target = stmt[7:].strip()
+            match = re.match(r"(\w+)\[(.+)\]", target)
+            if match:
+                arr_name = match.group(1)
+                idx = self._eval_expr(match.group(2).strip(), state, line, fields)
+                key = f"{arr_name}[{idx}]"
+                state.variables.pop(key, None)
+            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 += -= *= /=
@@ -621,6 +693,16 @@ class AwkCommand:
                         state.variables[var] = current / val if val != 0 else 0
                     return
 
+            # Array element assignment: arr[idx] = val
+            match = re.match(r"(\w+)\[(.+?)\]\s*=\s*(.+)", stmt)
+            if match:
+                arr_name = match.group(1)
+                idx = self._eval_expr(match.group(2).strip(), state, line, fields)
+                val = self._eval_expr(match.group(3).strip(), state, line, fields)
+                key = f"{arr_name}[{idx}]"
+                state.variables[key] = val
+                return
+
             # Simple assignment
             match = re.match(r"(\w+)\s*=\s*(.+)", stmt)
             if match:
@@ -639,6 +721,10 @@ class AwkCommand:
                     fields.append("")
                 if field_num > 0:
                     fields[field_num - 1] = str(val)
+                # Reconstruct $0 from modified fields
+                ofs = state.variables.get("OFS", " ")
+                state.variables["__line__"] = ofs.join(fields)
+                state.variables["NF"] = len(fields)
                 return
 
         # Handle increment/decrement
@@ -773,7 +859,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 +869,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 +879,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 +889,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 +899,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 +926,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,29 +1189,137 @@ 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 - check for else clause separated by ;
+            then_action = rest
+            else_action = None
+
+            # Look for "; else" pattern (not inside strings)
+            else_idx = -1
+            in_str = False
+            esc = False
+            for ci in range(len(rest)):
+                if esc:
+                    esc = False
+                    continue
+                if rest[ci] == "\\":
+                    esc = True
+                    continue
+                if rest[ci] == '"':
+                    in_str = not in_str
+                    continue
+                if not in_str and rest[ci] == ";" and rest[ci + 1:].lstrip().startswith("else"):
+                    else_idx = ci
+                    break
+
+            if else_idx != -1:
+                then_action = rest[:else_idx].strip()
+                else_part = rest[else_idx + 1:].strip()
+                if else_part.startswith("else"):
+                    else_action = else_part[4:].strip()
+
+            if self._eval_condition(condition, state, fields, line):
+                self._execute_statement(then_action, state, fields, line)
+            elif else_action:
+                self._execute_statement(else_action, state, fields, line)
 
     def _execute_for(
         self, stmt: str, state: AwkState, fields: list[str], line: str
     ) -> None:
         """Execute a for statement."""
+        # Parse: for (var in array) body
+        match = re.match(r"for\s*\(\s*(\w+)\s+in\s+(\w+)\s*\)\s*(.*)", stmt, re.DOTALL)
+        if match:
+            var = match.group(1)
+            arr_name = match.group(2)
+            body = match.group(3).strip()
+            if body.startswith("{") and body.endswith("}"):
+                body = body[1:-1]
+
+            # Find all keys for this array
+            keys = []
+            prefix = f"{arr_name}["
+            for k in state.variables:
+                if isinstance(k, str) and k.startswith(prefix) and k.endswith("]"):
+                    keys.append(k[len(prefix):-1])
+
+            for key in keys:
+                state.variables[var] = key
+                self._execute_action(body, state, fields, line)
+            return
+
         # Parse: for (init; condition; update) { action }
         match = re.match(r"for\s*\((.+?);(.+?);(.+?)\)\s*\{(.+?)\}", stmt, re.DOTALL)
+        if not match:
+            # Try without braces: for (init; condition; update) statement
+            match = re.match(r"for\s*\((.+?);(.+?);(.+?)\)\s*(.*)", stmt, re.DOTALL)
         if match:
             init = match.group(1).strip()
             condition = match.group(2).strip()
             update = match.group(3).strip()
-            action = match.group(4)
+            action = match.group(4).strip()
+            if action.startswith("{") and action.endswith("}"):
+                action = action[1:-1]
 
             # Execute init
             self._execute_statement(init, state, fields, line)
@@ -1166,3 +1453,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/cat/cat.py

@@ -117,8 +117,12 @@ class CatCommand:
 
         for file in files:
             try:
-                if file == "-":
+                if file == "-" or file == "/dev/stdin":
                     content = ctx.stdin
+                elif file == "/dev/stdout":
+                    content = ""
+                elif file == "/dev/stderr":
+                    content = ""
                 else:
                     # Resolve path
                     path = ctx.fs.resolve_path(ctx.cwd, file)