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

just_bash/interpreter/builtins/local.py

@@ -14,9 +14,34 @@ if TYPE_CHECKING:
     from ...types import ExecResult
 
 
+def _save_array_in_scope(ctx: "InterpreterContext", name: str, scope: dict) -> None:
+    """Save all array-related keys for a variable in the local scope."""
+    env = ctx.state.env
+    # Save the array marker
+    array_key = f"{name}__is_array"
+    if array_key not in scope:
+        scope[array_key] = env.get(array_key)
+
+    # Save all existing array element keys
+    prefix = f"{name}_"
+    for key in list(env.keys()):
+        if key.startswith(prefix) and not key.startswith(f"{name}__"):
+            if key not in scope:
+                scope[key] = env.get(key)
+
+
+def _clear_array_elements(ctx: "InterpreterContext", name: str) -> None:
+    """Remove all array element keys for a variable."""
+    prefix = f"{name}_"
+    to_remove = [k for k in ctx.state.env if k.startswith(prefix) and not k.startswith(f"{name}__")]
+    for k in to_remove:
+        del ctx.state.env[k]
+
+
 async def handle_local(ctx: "InterpreterContext", args: list[str]) -> "ExecResult":
     """Execute the local builtin."""
     from ...types import ExecResult
+    from .declare import _parse_array_assignment
 
     # Check if we're inside a function
     if not ctx.state.local_scopes:
@@ -28,11 +53,24 @@ async def handle_local(ctx: "InterpreterContext", args: list[str]) -> "ExecResul
 
     current_scope = ctx.state.local_scopes[-1]
 
+    # Parse flags
+    is_array = False
+    is_assoc = False
+    remaining_args = []
+
     for arg in args:
-        # Skip options
-        if arg.startswith("-"):
-            continue
+        if arg.startswith("-") and not ("=" in arg):
+            # Parse flag characters
+            for ch in arg[1:]:
+                if ch == "a":
+                    is_array = True
+                elif ch == "A":
+                    is_assoc = True
+                # Other flags like -i, -r, -x are ignored for now
+        else:
+            remaining_args.append(arg)
 
+    for arg in remaining_args:
         if "=" in arg:
             name, value = arg.split("=", 1)
         else:
@@ -51,7 +89,35 @@ async def handle_local(ctx: "InterpreterContext", args: list[str]) -> "ExecResul
         if name not in current_scope:
             current_scope[name] = ctx.state.env.get(name)
 
-        # Set the new value
-        ctx.state.env[name] = value
+        # Also save metadata
+        from ..types import VariableStore
+        if isinstance(ctx.state.env, VariableStore):
+            ctx.state.env.save_metadata_in_scope(name)
+
+        # Handle array initialization
+        if (is_array or is_assoc) and value.startswith("(") and value.endswith(")"):
+            # Save existing array keys before overwriting
+            _save_array_in_scope(ctx, name, current_scope)
+
+            # Set array type marker
+            array_key = f"{name}__is_array"
+            ctx.state.env[array_key] = "assoc" if is_assoc else "indexed"
+
+            # Clear existing elements and parse new ones
+            _clear_array_elements(ctx, name)
+            inner = value[1:-1].strip()
+            if inner:
+                _parse_array_assignment(ctx, name, inner, is_assoc)
+        elif is_array or is_assoc:
+            # Declare as array without initialization
+            _save_array_in_scope(ctx, name, current_scope)
+            array_key = f"{name}__is_array"
+            ctx.state.env[array_key] = "assoc" if is_assoc else "indexed"
+            if "=" in arg:
+                # Simple value assignment - set element 0
+                ctx.state.env[f"{name}_0"] = value
+        else:
+            # Simple variable
+            ctx.state.env[name] = value
 
     return ExecResult(stdout="", stderr="", exit_code=0)

just_bash/interpreter/builtins/misc.py

@@ -95,8 +95,15 @@ async def handle_type(
         "{", "}", "!", "[[", "]]"
     }
 
-    # Get builtins
+    # Get builtins (includes commands that bash treats as builtins)
     from . import BUILTINS
+    # Commands that are implemented externally but should be reported as builtins
+    _builtin_command_names = {
+        "echo", "printf", "read", "pwd", "test", "[", "kill", "enable",
+        "help", "hash", "ulimit", "umask", "jobs", "fg", "bg", "disown",
+        "suspend", "logout", "dirs", "pushd", "popd", "times", "trap",
+        "caller", "complete", "compgen", "compopt",
+    }
 
     # Get aliases
     aliases = get_aliases(ctx)
@@ -143,7 +150,7 @@ async def handle_type(
                 continue
 
         # Check builtin (unless -P)
-        if not force_path and name in BUILTINS:
+        if not force_path and (name in BUILTINS or name in _builtin_command_names):
             found = True
             if type_only:
                 output.append("builtin")
@@ -154,7 +161,7 @@ async def handle_type(
 
         # Check command registry
         from ...commands import COMMAND_NAMES
-        if name in COMMAND_NAMES:
+        if name in COMMAND_NAMES and name not in _builtin_command_names:
             found = True
             if type_only:
                 output.append("file")
@@ -167,7 +174,7 @@ async def handle_type(
 
         if not found:
             if type_only:
-                output.append("")
+                pass  # bash outputs nothing for type -t on not-found commands
             else:
                 output.append(f"bash: type: {name}: not found")
             exit_code = 1
@@ -228,7 +235,14 @@ async def handle_command(
         from . import BUILTINS
         from ...commands import COMMAND_NAMES
 
-        if cmd_name in BUILTINS:
+        functions = getattr(ctx.state, 'functions', {})
+
+        if cmd_name in functions:
+            if verbose:
+                return _result(f"{cmd_name} is a function\n", "", 0)
+            else:
+                return _result(f"{cmd_name}\n", "", 0)
+        elif cmd_name in BUILTINS:
             if verbose:
                 return _result(f"{cmd_name} is a shell builtin\n", "", 0)
             else:
@@ -332,8 +346,10 @@ async def handle_exec(
             break
         i += 1
 
-    # If no command, exec just affects redirections (which we don't handle here)
+    # If no command, exec affects persistent FD redirections
     if not cmd_args:
+        # Redirections are handled by the interpreter's redirect processing
+        # which now supports the FD table. Return success.
         return _result("", "", 0)
 
     # In sandboxed mode, just execute the command

just_bash/interpreter/builtins/readonly.py

@@ -26,6 +26,8 @@ async def handle_readonly(
     ctx: "InterpreterContext", args: list[str]
 ) -> "ExecResult":
     """Execute the readonly builtin."""
+    from ..types import VariableStore
+
     # Parse options
     show_all = False
     names = []
@@ -45,13 +47,26 @@ async def handle_readonly(
             names.append(arg)
         i += 1
 
+    env = ctx.state.env
+
     # If no names and -p or no args, show all readonly variables
     if not names or show_all:
         output = []
-        readonly_vars = ctx.state.env.get("__readonly__", "").split()
+        # Collect readonly vars from metadata and legacy __readonly__
+        readonly_vars: set[str] = set()
+        if isinstance(env, VariableStore):
+            for vname, meta in env._metadata.items():
+                if "r" in meta.attributes:
+                    readonly_vars.add(vname)
+        # Also check legacy __readonly__ key
+        legacy_readonly = env.get("__readonly__", "").split()
+        readonly_vars.update(v for v in legacy_readonly if v)
+        # Also check state.readonly_vars
+        readonly_vars.update(ctx.state.readonly_vars)
+
         for var in sorted(readonly_vars):
-            if var in ctx.state.env:
-                value = ctx.state.env[var]
+            if var in env:
+                value = env[var]
                 output.append(f"declare -r {var}=\"{value}\"")
             else:
                 output.append(f"declare -r {var}")
@@ -60,21 +75,34 @@ async def handle_readonly(
         return _result("", "", 0)
 
     # Mark variables as readonly
-    readonly_set = set(ctx.state.env.get("__readonly__", "").split())
-
     for name_value in names:
         if "=" in name_value:
             name, value = name_value.split("=", 1)
             # Check if already readonly
-            if name in readonly_set:
+            if _is_readonly(ctx, name):
                 return _result("", f"bash: readonly: {name}: readonly variable\n", 1)
-            ctx.state.env[name] = value
+            env[name] = value
         else:
             name = name_value
 
+        # Set readonly via metadata
+        if isinstance(env, VariableStore):
+            env.set_attribute(name, "r")
+        ctx.state.readonly_vars.add(name)
+        # Also update legacy __readonly__ for backwards compat
+        readonly_set = set(env.get("__readonly__", "").split())
         readonly_set.add(name)
-
-    # Store readonly set
-    ctx.state.env["__readonly__"] = " ".join(sorted(readonly_set))
+        env["__readonly__"] = " ".join(sorted(readonly_set))
 
     return _result("", "", 0)
+
+
+def _is_readonly(ctx: "InterpreterContext", name: str) -> bool:
+    """Check if a variable is readonly."""
+    from ..types import VariableStore
+    env = ctx.state.env
+    if isinstance(env, VariableStore) and env.is_readonly(name):
+        return True
+    if name in ctx.state.readonly_vars:
+        return True
+    return name in env.get("__readonly__", "").split()

just_bash/interpreter/builtins/set.py

@@ -79,17 +79,67 @@ async def handle_set(ctx: "InterpreterContext", args: list[str]) -> "ExecResult"
                 return ExecResult(stdout=stdout, stderr="", exit_code=0)
 
         # Handle short options like -e, -u, -x, -v
+        # Also handle -euo pipefail where 'o' consumes the next argument
         elif arg.startswith("-") and len(arg) > 1 and arg[1] != "-":
-            for c in arg[1:]:
-                result = _set_short_option(ctx, c, True)
-                if result:
-                    return result
+            chars = arg[1:]
+            j = 0
+            while j < len(chars):
+                c = chars[j]
+                if c == "o":
+                    # -o requires an option name: either remaining chars or next arg
+                    if j + 1 < len(chars):
+                        # Option name is rest of this arg (e.g., -opipefail)
+                        opt_name = chars[j + 1:]
+                        result = _set_option(ctx, opt_name, True)
+                        if result:
+                            return result
+                        break  # Done with this arg
+                    elif i + 1 < len(args):
+                        # Option name is next arg (e.g., -euo pipefail)
+                        i += 1
+                        opt_name = args[i]
+                        result = _set_option(ctx, opt_name, True)
+                        if result:
+                            return result
+                        break  # Done with this arg
+                    else:
+                        # No option name provided, list options
+                        stdout = _list_options(ctx)
+                        return ExecResult(stdout=stdout, stderr="", exit_code=0)
+                else:
+                    result = _set_short_option(ctx, c, True)
+                    if result:
+                        return result
+                j += 1
 
         elif arg.startswith("+") and len(arg) > 1:
-            for c in arg[1:]:
-                result = _set_short_option(ctx, c, False)
-                if result:
-                    return result
+            chars = arg[1:]
+            j = 0
+            while j < len(chars):
+                c = chars[j]
+                if c == "o":
+                    # +o requires an option name
+                    if j + 1 < len(chars):
+                        opt_name = chars[j + 1:]
+                        result = _set_option(ctx, opt_name, False)
+                        if result:
+                            return result
+                        break
+                    elif i + 1 < len(args):
+                        i += 1
+                        opt_name = args[i]
+                        result = _set_option(ctx, opt_name, False)
+                        if result:
+                            return result
+                        break
+                    else:
+                        stdout = _list_options_script(ctx)
+                        return ExecResult(stdout=stdout, stderr="", exit_code=0)
+                else:
+                    result = _set_short_option(ctx, c, False)
+                    if result:
+                        return result
+                j += 1
 
         # Treat as positional parameter
         else:

just_bash/interpreter/builtins/test.py

@@ -95,12 +95,17 @@ async def _evaluate(ctx: "InterpreterContext", args: list[str]) -> bool:
     if not args:
         return False
 
+    # Single argument: non-empty string is true (POSIX rule)
+    # Must come before operator checks since operators are valid strings
+    if len(args) == 1:
+        return args[0] != ""
+
     # Handle negation
-    if args[0] == "!":
+    if args[0] == "!" and len(args) > 1:
         return not await _evaluate(ctx, args[1:])
 
-    # Handle parentheses
-    if args[0] == "(":
+    # Handle parentheses (only when there are enough args)
+    if args[0] == "(" and len(args) > 1:
         # Find matching )
         depth = 1
         end_idx = 1
@@ -133,26 +138,30 @@ async def _evaluate(ctx: "InterpreterContext", args: list[str]) -> bool:
             right = await _evaluate(ctx, args[i + 1:])
             return left or right
 
-    # Single argument: non-empty string is true, but check for misused operators
-    if len(args) == 1:
-        arg = args[0]
-        # If it looks like an operator (starts with -) but isn't followed by
-        # an operand, it could be a misused unary operator
-        if arg.startswith("-") and len(arg) > 1:
-            # Check if this looks like an operator that needs an operand
-            if arg in _UNARY_OPS:
-                raise ValueError(f"{arg}: unary operator expected")
-        return arg != ""
-
     # Two arguments: unary operators
     if len(args) == 2:
         return await _unary_test(ctx, args[0], args[1])
 
     # Three arguments: binary operators
     if len(args) == 3:
-        return await _binary_test(ctx, args[0], args[1], args[2])
-
-    # More than 3 args should be handled by -a/-o above
+        # Special case: if middle arg is a known binary operator, use binary test
+        if args[1] in ("=", "==", "!=", "<", ">",
+                        "-eq", "-ne", "-lt", "-le", "-gt", "-ge",
+                        "-nt", "-ot", "-ef"):
+            return await _binary_test(ctx, args[0], args[1], args[2])
+        # Otherwise handle as compound (e.g., [ ! -f file ])
+        if args[0] == "!":
+            return not await _evaluate(ctx, args[1:])
+        raise ValueError(f"unknown binary operator '{args[1]}'")
+
+    # Four arguments: could be ! with 3-arg expression, or compound
+    if len(args) == 4:
+        if args[0] == "!":
+            return not await _evaluate(ctx, args[1:])
+        # Otherwise handled by -a/-o above
+        raise ValueError("too many arguments")
+
+    # More than 4 args should be handled by -a/-o above
     raise ValueError("too many arguments")
 
 
@@ -185,7 +194,7 @@ async def _unary_test(ctx: "InterpreterContext", op: str, arg: str) -> bool:
         return await _file_test(ctx, arg, "file")
     if op == "-d":
         return await _file_test(ctx, arg, "directory")
-    if op == "-e":
+    if op in ("-e", "-a"):
         return await _file_test(ctx, arg, "exists")
     if op == "-s":
         return await _file_test(ctx, arg, "size")
@@ -197,6 +206,26 @@ async def _unary_test(ctx: "InterpreterContext", op: str, arg: str) -> bool:
         return await _file_test(ctx, arg, "executable")
     if op in ("-h", "-L"):
         return await _file_test(ctx, arg, "symlink")
+    if op == "-b":
+        return False  # block special - not in virtual fs
+    if op == "-c":
+        return False  # character special - not in virtual fs
+    if op == "-p":
+        return False  # named pipe - not in virtual fs
+    if op == "-S":
+        return False  # socket - not in virtual fs
+    if op == "-g":
+        return False  # setgid - not in virtual fs
+    if op == "-G":
+        return await _file_test(ctx, arg, "exists")  # owned by effective group
+    if op == "-k":
+        return False  # sticky bit - not in virtual fs
+    if op == "-O":
+        return await _file_test(ctx, arg, "exists")  # owned by effective user
+    if op == "-u":
+        return False  # setuid - not in virtual fs
+    if op == "-N":
+        return await _file_test(ctx, arg, "exists")  # modified since last read
 
     # String tests
     if op == "-z":
@@ -204,7 +233,44 @@ async def _unary_test(ctx: "InterpreterContext", op: str, arg: str) -> bool:
     if op == "-n":
         return arg != ""
 
-    # Default: two non-operator args means binary comparison
+    # Variable test: -v checks if a variable is set
+    if op == "-v":
+        # Check if variable is set (even to empty string)
+        from ..types import VariableStore
+        env = ctx.state.env
+        # Handle array subscripts: var[idx]
+        if "[" in arg and arg.endswith("]"):
+            bracket_idx = arg.index("[")
+            base_name = arg[:bracket_idx]
+            subscript = arg[bracket_idx + 1:-1]
+            if subscript in ("@", "*"):
+                # Check if array has any elements
+                prefix = f"{base_name}_"
+                return any(k.startswith(prefix) and not k.startswith(f"{base_name}__")
+                          for k in env.keys())
+            key = f"{base_name}_{subscript}"
+            return key in env
+        return arg in env
+
+    # Shell option test: -o checks if an option is enabled
+    if op == "-o":
+        if arg == "errexit":
+            return getattr(ctx.state.options, 'errexit', False)
+        elif arg == "nounset":
+            return getattr(ctx.state.options, 'nounset', False)
+        elif arg == "xtrace":
+            return getattr(ctx.state.options, 'xtrace', False)
+        elif arg == "pipefail":
+            return getattr(ctx.state.options, 'pipefail', False)
+        return False
+
+    # Terminal test: -t checks if fd is a terminal (always false in virtual env)
+    if op == "-t":
+        return False
+
+    # If op is not a known operator, treat as 2-arg string test
+    # e.g., [ "str1" = "str2" ] should be handled by _binary_test,
+    # but [ "str1" "str2" ] is an error
     raise ValueError(f"unknown unary operator '{op}'")
 
 
@@ -245,9 +311,60 @@ async def _binary_test(
         if op == "-ge":
             return left_num >= right_num
 
+    # File comparison operators
+    if op == "-nt":
+        # FILE1 is newer than FILE2
+        return await _file_compare(ctx, left, right, "newer")
+    if op == "-ot":
+        # FILE1 is older than FILE2
+        return await _file_compare(ctx, left, right, "older")
+    if op == "-ef":
+        # FILE1 and FILE2 refer to same file (same device and inode)
+        full_left = ctx.fs.resolve_path(ctx.state.cwd, left)
+        full_right = ctx.fs.resolve_path(ctx.state.cwd, right)
+        try:
+            return (await ctx.fs.exists(full_left)
+                    and await ctx.fs.exists(full_right)
+                    and full_left == full_right)
+        except Exception:
+            return False
+
     raise ValueError(f"unknown binary operator '{op}'")
 
 
+async def _file_compare(ctx: "InterpreterContext", file1: str, file2: str, comparison: str) -> bool:
+    """Compare two files by modification time."""
+    full1 = ctx.fs.resolve_path(ctx.state.cwd, file1)
+    full2 = ctx.fs.resolve_path(ctx.state.cwd, file2)
+    try:
+        exists1 = await ctx.fs.exists(full1)
+        exists2 = await ctx.fs.exists(full2)
+
+        if not exists1 and not exists2:
+            return False
+        if not exists1:
+            return comparison == "older"
+        if not exists2:
+            return comparison == "newer"
+
+        # In virtual filesystem, try to get stat info
+        try:
+            stat1 = await ctx.fs.stat(full1)
+            stat2 = await ctx.fs.stat(full2)
+            if hasattr(stat1, 'mtime') and hasattr(stat2, 'mtime'):
+                if comparison == "newer":
+                    return stat1.mtime > stat2.mtime
+                else:
+                    return stat1.mtime < stat2.mtime
+        except (AttributeError, Exception):
+            pass
+
+        # Without mtime, files that exist are considered equal
+        return False
+    except Exception:
+        return False
+
+
 async def _file_test(ctx: "InterpreterContext", path: str, test_type: str) -> bool:
     """Perform a file test."""
     # Resolve path relative to cwd

just_bash/interpreter/builtins/unset.py

@@ -19,8 +19,10 @@ if TYPE_CHECKING:
 async def handle_unset(ctx: "InterpreterContext", args: list[str]) -> "ExecResult":
     """Execute the unset builtin."""
     from ...types import ExecResult
+    from ..types import VariableStore
 
     mode = "variable"
+    unset_nameref = False
     names = []
 
     for arg in args:
@@ -29,25 +31,75 @@ async def handle_unset(ctx: "InterpreterContext", args: list[str]) -> "ExecResul
         elif arg == "-f":
             mode = "function"
         elif arg == "-n":
-            # -n treats name as a nameref - we don't support this but ignore
-            pass
+            # -n: unset the nameref itself, not the target
+            unset_nameref = True
         elif arg.startswith("-"):
             # Skip unknown options
             pass
         else:
             names.append(arg)
 
+    import re
+    env = ctx.state.env
+
     for name in names:
         if mode == "function":
             ctx.state.functions.pop(name, None)
         else:
-            # Check if variable is readonly
-            if name in ctx.state.readonly_vars:
-                return ExecResult(
-                    stdout="",
-                    stderr=f"bash: unset: {name}: cannot unset: readonly variable\n",
-                    exit_code=1,
-                )
-            ctx.state.env.pop(name, None)
+            # Handle -n flag: unset the nameref variable itself
+            if unset_nameref and isinstance(env, VariableStore):
+                env.clear_nameref(name)
+                env.pop(name, None)
+                continue
+
+            # Resolve nameref for unset target
+            resolved_name = name
+            if isinstance(env, VariableStore) and env.is_nameref(name):
+                try:
+                    resolved_name = env.resolve_nameref(name)
+                except ValueError:
+                    resolved_name = name
+
+            # Check for array element syntax: a[idx]
+            array_match = re.match(r'^([a-zA-Z_][a-zA-Z0-9_]*)\[(.+)\]$', resolved_name)
+            if array_match:
+                arr_name = array_match.group(1)
+                subscript = array_match.group(2)
+                # Check if variable is readonly
+                if _is_readonly(ctx, arr_name):
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"bash: unset: {arr_name}: cannot unset: readonly variable\n",
+                        exit_code=1,
+                    )
+                # Remove specific array element
+                env.pop(f"{arr_name}_{subscript}", None)
+            else:
+                # Check if variable is readonly
+                if _is_readonly(ctx, resolved_name):
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"bash: unset: {resolved_name}: cannot unset: readonly variable\n",
+                        exit_code=1,
+                    )
+                # Remove the variable
+                env.pop(resolved_name, None)
+                # Also remove all array elements if this is an array
+                prefix = f"{resolved_name}_"
+                to_remove = [k for k in env if k.startswith(prefix)]
+                for k in to_remove:
+                    del env[k]
+                # Clean up metadata
+                if isinstance(env, VariableStore):
+                    env._metadata.pop(resolved_name, None)
 
     return ExecResult(stdout="", stderr="", exit_code=0)
+
+
+def _is_readonly(ctx: "InterpreterContext", name: str) -> bool:
+    """Check if a variable is readonly."""
+    from ..types import VariableStore
+    env = ctx.state.env
+    if isinstance(env, VariableStore) and env.is_readonly(name):
+        return True
+    return name in ctx.state.readonly_vars