just-bash 0.1.8__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

@@ -74,6 +74,7 @@ class AwkRule:
     action: str
     is_regex: bool = False
     regex: re.Pattern | None = None
+    negate: bool = False  # ! pattern negation
 
 
 @dataclass
@@ -287,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)
@@ -349,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
 
@@ -374,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
@@ -493,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
@@ -621,6 +646,17 @@ 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
@@ -657,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:
@@ -675,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
@@ -1200,21 +1250,76 @@ class AwkCommand:
             elif else_action:
                 self._execute_action(else_action, state, fields, line)
         else:
-            # No braces - rest is the statement
+            # 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(rest, 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)

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)

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:

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