just-bash 0.1.5__py3-none-any.whl

just_bash/commands/tee/__init__.py

@@ -0,0 +1,5 @@
+"""Tee command."""
+
+from .tee import TeeCommand
+
+__all__ = ["TeeCommand"]

just_bash/commands/tee/tee.py

@@ -0,0 +1,63 @@
+"""Tee command implementation."""
+
+from ...types import CommandContext, ExecResult
+
+
+class TeeCommand:
+    """The tee command."""
+
+    name = "tee"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the tee command."""
+        append = False
+        files: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "--":
+                files.extend(args[i + 1:])
+                break
+            elif arg in ("-a", "--append"):
+                append = True
+            elif arg == "--help":
+                return ExecResult(
+                    stdout="Usage: tee [OPTION]... [FILE]...\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg.startswith("-") and len(arg) > 1:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"tee: invalid option -- '{arg[1]}'\n",
+                    exit_code=1,
+                )
+            else:
+                files.append(arg)
+            i += 1
+
+        # Read stdin
+        content = ctx.stdin
+
+        # Write to files
+        stderr = ""
+        exit_code = 0
+
+        for f in files:
+            try:
+                path = ctx.fs.resolve_path(ctx.cwd, f)
+                if append:
+                    try:
+                        existing = await ctx.fs.read_file(path)
+                        await ctx.fs.write_file(path, existing + content)
+                    except FileNotFoundError:
+                        await ctx.fs.write_file(path, content)
+                else:
+                    await ctx.fs.write_file(path, content)
+            except Exception as e:
+                stderr += f"tee: {f}: {e}\n"
+                exit_code = 1
+
+        # Output to stdout
+        return ExecResult(stdout=content, stderr=stderr, exit_code=exit_code)

just_bash/commands/timeout/__init__.py

@@ -0,0 +1,5 @@
+"""Timeout command."""
+
+from .timeout import TimeoutCommand
+
+__all__ = ["TimeoutCommand"]

just_bash/commands/timeout/timeout.py

@@ -0,0 +1,188 @@
+"""Timeout command implementation."""
+
+import asyncio
+import re
+from ...types import CommandContext, ExecResult
+
+
+class TimeoutCommand:
+    """The timeout command."""
+
+    name = "timeout"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the timeout command."""
+        duration = None
+        kill_after = None
+        signal = "TERM"
+        preserve_status = False
+        command: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "-k" and i + 1 < len(args):
+                i += 1
+                try:
+                    kill_after = self._parse_duration(args[i])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"timeout: invalid time interval '{args[i]}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-k"):
+                try:
+                    kill_after = self._parse_duration(arg[2:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"timeout: invalid time interval '{arg[2:]}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("--kill-after="):
+                try:
+                    kill_after = self._parse_duration(arg[13:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"timeout: invalid time interval '{arg[13:]}'\n",
+                        exit_code=1,
+                    )
+            elif arg == "--kill-after" and i + 1 < len(args):
+                i += 1
+                try:
+                    kill_after = self._parse_duration(args[i])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"timeout: invalid time interval '{args[i]}'\n",
+                        exit_code=1,
+                    )
+            elif arg == "-s" and i + 1 < len(args):
+                i += 1
+                signal = args[i]
+            elif arg.startswith("-s"):
+                signal = arg[2:]
+            elif arg.startswith("--signal="):
+                signal = arg[9:]
+            elif arg == "--signal" and i + 1 < len(args):
+                i += 1
+                signal = args[i]
+            elif arg == "--preserve-status":
+                preserve_status = True
+            elif arg == "--foreground":
+                pass  # Ignore
+            elif arg == "--help":
+                return ExecResult(
+                    stdout=(
+                        "Usage: timeout [OPTION] DURATION COMMAND [ARG]...\n"
+                        "Start COMMAND, and kill it if still running after DURATION.\n\n"
+                        "Options:\n"
+                        "  -k, --kill-after=DURATION  send KILL signal after DURATION\n"
+                        "  -s, --signal=SIGNAL        send this signal on timeout (default: TERM)\n"
+                        "      --preserve-status      exit with the same status as COMMAND\n"
+                        "      --foreground           run command in foreground\n"
+                        "      --help                 display this help and exit\n"
+                    ),
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg == "--":
+                # Rest are command args
+                if duration is None and i + 1 < len(args):
+                    i += 1
+                    try:
+                        duration = self._parse_duration(args[i])
+                    except ValueError:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"timeout: invalid duration '{args[i]}'\n",
+                            exit_code=1,
+                        )
+                if i + 1 < len(args):
+                    command = args[i + 1:]
+                break
+            elif arg.startswith("-") and len(arg) > 1 and not arg[1].isdigit():
+                return ExecResult(
+                    stdout="",
+                    stderr=f"timeout: invalid option -- '{arg[1]}'\n",
+                    exit_code=1,
+                )
+            elif duration is None:
+                try:
+                    duration = self._parse_duration(arg)
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"timeout: invalid duration '{arg}'\n",
+                        exit_code=1,
+                    )
+            else:
+                command = args[i:]
+                break
+            i += 1
+
+        if duration is None:
+            return ExecResult(
+                stdout="",
+                stderr="timeout: missing operand\n",
+                exit_code=1,
+            )
+
+        if not command:
+            return ExecResult(
+                stdout="",
+                stderr="timeout: missing command\n",
+                exit_code=1,
+            )
+
+        # Quote arguments properly for shell execution
+        def quote(s: str) -> str:
+            if not s or any(c in s for c in " \t\n'\"\\$`!"):
+                return "'" + s.replace("'", "'\"'\"'") + "'"
+            return s
+
+        cmd_str = " ".join(quote(c) for c in command)
+
+        # Execute command with timeout
+        if not ctx.exec:
+            return ExecResult(
+                stdout="",
+                stderr="timeout: cannot execute commands\n",
+                exit_code=126,
+            )
+
+        try:
+            result = await asyncio.wait_for(
+                ctx.exec(cmd_str, {"cwd": ctx.cwd}),
+                timeout=duration,
+            )
+            return result
+        except asyncio.TimeoutError:
+            # In a sandboxed environment, we can't actually send signals
+            # The -k and -s options are parsed but have limited effect
+            # Return 124 unless preserve_status is set (then we can't know the status)
+            if preserve_status:
+                # In real timeout, this would preserve the signal exit status
+                # We return 124 + signal number approximation
+                return ExecResult(stdout="", stderr="", exit_code=124)
+            return ExecResult(stdout="", stderr="", exit_code=124)
+
+    def _parse_duration(self, s: str) -> float:
+        """Parse a duration string."""
+        match = re.match(r"^(\d+(?:\.\d+)?)(s|m|h|d)?$", s)
+        if not match:
+            raise ValueError(f"Invalid duration: {s}")
+
+        value = float(match.group(1))
+        suffix = match.group(2)
+
+        if suffix == "m":
+            value *= 60
+        elif suffix == "h":
+            value *= 3600
+        elif suffix == "d":
+            value *= 86400
+
+        return value

just_bash/commands/touch/__init__.py

@@ -0,0 +1,5 @@
+"""Touch command implementation."""
+
+from .touch import TouchCommand
+
+__all__ = ["TouchCommand"]

just_bash/commands/touch/touch.py

@@ -0,0 +1,91 @@
+"""Touch command implementation.
+
+Usage: touch [OPTION]... FILE...
+
+Update the access and modification times of each FILE to the current time.
+A FILE argument that does not exist is created empty.
+
+Options:
+  -c, --no-create  do not create any files
+"""
+
+from ...types import CommandContext, ExecResult
+
+
+class TouchCommand:
+    """The touch command."""
+
+    name = "touch"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the touch command."""
+        no_create = False
+        files: list[str] = []
+
+        # Parse arguments
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "--":
+                files.extend(args[i + 1:])
+                break
+            elif arg.startswith("--"):
+                if arg == "--no-create":
+                    no_create = True
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"touch: unrecognized option '{arg}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-") and arg != "-":
+                for c in arg[1:]:
+                    if c == "c":
+                        no_create = True
+                    else:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"touch: invalid option -- '{c}'\n",
+                            exit_code=1,
+                        )
+            else:
+                files.append(arg)
+            i += 1
+
+        if not files:
+            return ExecResult(
+                stdout="",
+                stderr="touch: missing file operand\n",
+                exit_code=1,
+            )
+
+        stderr = ""
+        exit_code = 0
+
+        for f in files:
+            try:
+                path = ctx.fs.resolve_path(ctx.cwd, f)
+                # Check if file exists
+                try:
+                    stat = await ctx.fs.stat(path)
+                    if stat.is_directory:
+                        # Touching a directory - we can't easily update dir mtime
+                        # in current implementation, so just continue
+                        continue
+                    # File exists - read and re-write to update timestamp
+                    content = await ctx.fs.read_file(path)
+                    await ctx.fs.write_file(path, content)
+                except FileNotFoundError:
+                    # File doesn't exist
+                    if no_create:
+                        continue
+                    # Create empty file
+                    await ctx.fs.write_file(path, "")
+            except FileNotFoundError:
+                stderr += f"touch: cannot touch '{f}': No such file or directory\n"
+                exit_code = 1
+            except IsADirectoryError:
+                # Touching a directory is fine, just update timestamp (no-op)
+                pass
+
+        return ExecResult(stdout="", stderr=stderr, exit_code=exit_code)

just_bash/commands/tr/__init__.py

@@ -0,0 +1,5 @@
+"""Tr command implementation."""
+
+from .tr import TrCommand
+
+__all__ = ["TrCommand"]

just_bash/commands/tr/tr.py

@@ -0,0 +1,297 @@
+"""Tr command implementation.
+
+Usage: tr [OPTION]... SET1 [SET2]
+
+Translate, squeeze, and/or delete characters from standard input,
+writing to standard output.
+
+Options:
+  -c, -C, --complement   use the complement of SET1
+  -d, --delete           delete characters in SET1, do not translate
+  -s, --squeeze-repeats  replace each sequence of a repeated character
+                         that is listed in SET1 with a single occurrence
+
+SETs are specified as strings of characters. Interpreted sequences include:
+  \\NNN     character with octal value NNN (1 to 3 octal digits)
+  \\\\      backslash
+  \\a       audible BEL
+  \\b       backspace
+  \\f       form feed
+  \\n       newline
+  \\r       carriage return
+  \\t       horizontal tab
+  \\v       vertical tab
+  CHAR1-CHAR2  all characters from CHAR1 to CHAR2 in ascending order
+  [:alnum:]  all letters and digits
+  [:alpha:]  all letters
+  [:blank:]  all horizontal whitespace
+  [:cntrl:]  all control characters
+  [:digit:]  all digits
+  [:lower:]  all lowercase letters
+  [:print:]  all printable characters
+  [:punct:]  all punctuation characters
+  [:space:]  all horizontal or vertical whitespace
+  [:upper:]  all uppercase letters
+"""
+
+import string
+from ...types import CommandContext, ExecResult
+
+
+class TrCommand:
+    """The tr command."""
+
+    name = "tr"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the tr command."""
+        complement = False
+        delete = False
+        squeeze = False
+        sets: list[str] = []
+
+        # Parse arguments
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "--":
+                sets.extend(args[i + 1:])
+                break
+            elif arg.startswith("--"):
+                if arg == "--complement":
+                    complement = True
+                elif arg == "--delete":
+                    delete = True
+                elif arg == "--squeeze-repeats":
+                    squeeze = True
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"tr: unrecognized option '{arg}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-") and arg != "-":
+                j = 1
+                while j < len(arg):
+                    c = arg[j]
+                    if c == "c" or c == "C":
+                        complement = True
+                    elif c == "d":
+                        delete = True
+                    elif c == "s":
+                        squeeze = True
+                    else:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"tr: invalid option -- '{c}'\n",
+                            exit_code=1,
+                        )
+                    j += 1
+            else:
+                sets.append(arg)
+            i += 1
+
+        # Validate arguments
+        if delete:
+            if len(sets) < 1:
+                return ExecResult(
+                    stdout="",
+                    stderr="tr: missing operand\n",
+                    exit_code=1,
+                )
+            if len(sets) > 1 and not squeeze:
+                return ExecResult(
+                    stdout="",
+                    stderr="tr: extra operand\n",
+                    exit_code=1,
+                )
+        else:
+            if len(sets) < 2 and not squeeze:
+                return ExecResult(
+                    stdout="",
+                    stderr="tr: missing operand after SET1\n",
+                    exit_code=1,
+                )
+
+        # Expand sets
+        try:
+            set1 = self._expand_set(sets[0]) if sets else ""
+            set2 = self._expand_set(sets[1]) if len(sets) > 1 else ""
+        except ValueError as e:
+            return ExecResult(
+                stdout="",
+                stderr=f"tr: {e}\n",
+                exit_code=1,
+            )
+
+        # Apply complement
+        if complement:
+            # Create set of all characters not in set1
+            all_chars = set(chr(i) for i in range(256))
+            set1_chars = set(set1)
+            set1 = "".join(sorted(all_chars - set1_chars, key=ord))
+
+        # Process input
+        content = ctx.stdin
+        result = []
+
+        if delete and not squeeze:
+            # Delete characters in set1
+            delete_set = set(set1)
+            for c in content:
+                if c not in delete_set:
+                    result.append(c)
+        elif delete and squeeze:
+            # Delete set1, squeeze set2
+            delete_set = set(set1)
+            squeeze_set = set(set2)
+            prev_char = None
+            for c in content:
+                if c in delete_set:
+                    continue
+                if c in squeeze_set and c == prev_char:
+                    continue
+                result.append(c)
+                prev_char = c
+        elif squeeze and not set2:
+            # Squeeze only
+            squeeze_set = set(set1)
+            prev_char = None
+            for c in content:
+                if c in squeeze_set and c == prev_char:
+                    continue
+                result.append(c)
+                prev_char = c
+        else:
+            # Translate
+            trans_map = self._create_translation_map(set1, set2)
+
+            if squeeze:
+                squeeze_set = set(set2)
+                prev_char = None
+                for c in content:
+                    translated = trans_map.get(c, c)
+                    if translated in squeeze_set and translated == prev_char:
+                        continue
+                    result.append(translated)
+                    prev_char = translated
+            else:
+                for c in content:
+                    result.append(trans_map.get(c, c))
+
+        return ExecResult(stdout="".join(result), stderr="", exit_code=0)
+
+    def _expand_set(self, s: str) -> str:
+        """Expand a character set specification."""
+        result = []
+        i = 0
+
+        while i < len(s):
+            # Check for character classes like [:digit:]
+            if s[i:].startswith("[:") and ":]" in s[i + 2:]:
+                end = s.index(":]", i + 2)
+                class_name = s[i + 2:end]
+                result.extend(self._get_char_class(class_name))
+                i = end + 2
+                continue
+
+            # Check for escape sequences
+            if s[i] == "\\" and i + 1 < len(s):
+                c = s[i + 1]
+                if c == "a":
+                    result.append("\a")
+                elif c == "b":
+                    result.append("\b")
+                elif c == "f":
+                    result.append("\f")
+                elif c == "n":
+                    result.append("\n")
+                elif c == "r":
+                    result.append("\r")
+                elif c == "t":
+                    result.append("\t")
+                elif c == "v":
+                    result.append("\v")
+                elif c == "\\":
+                    result.append("\\")
+                elif c.isdigit():
+                    # Octal escape
+                    octal = ""
+                    j = i + 1
+                    while j < len(s) and s[j].isdigit() and len(octal) < 3:
+                        if s[j] in "01234567":
+                            octal += s[j]
+                            j += 1
+                        else:
+                            break
+                    if octal:
+                        result.append(chr(int(octal, 8)))
+                        i = j
+                        continue
+                    else:
+                        result.append(c)
+                else:
+                    result.append(c)
+                i += 2
+                continue
+
+            # Check for range
+            if i + 2 < len(s) and s[i + 1] == "-":
+                start = s[i]
+                end = s[i + 2]
+                if ord(start) <= ord(end):
+                    for c in range(ord(start), ord(end) + 1):
+                        result.append(chr(c))
+                    i += 3
+                    continue
+
+            result.append(s[i])
+            i += 1
+
+        return "".join(result)
+
+    def _get_char_class(self, name: str) -> list[str]:
+        """Get characters in a character class."""
+        if name == "alnum":
+            return list(string.ascii_letters + string.digits)
+        elif name == "alpha":
+            return list(string.ascii_letters)
+        elif name == "blank":
+            return [" ", "\t"]
+        elif name == "cntrl":
+            return [chr(i) for i in range(32)] + [chr(127)]
+        elif name == "digit":
+            return list(string.digits)
+        elif name == "graph":
+            return [chr(i) for i in range(33, 127)]
+        elif name == "lower":
+            return list(string.ascii_lowercase)
+        elif name == "print":
+            return [chr(i) for i in range(32, 127)]
+        elif name == "punct":
+            return list(string.punctuation)
+        elif name == "space":
+            return list(string.whitespace)
+        elif name == "upper":
+            return list(string.ascii_uppercase)
+        elif name == "xdigit":
+            return list(string.hexdigits)
+        else:
+            raise ValueError(f"invalid character class '{name}'")
+
+    def _create_translation_map(self, set1: str, set2: str) -> dict[str, str]:
+        """Create a translation map from set1 to set2."""
+        trans_map = {}
+
+        # If set2 is shorter, extend with its last character
+        if set2:
+            last_char = set2[-1]
+            set2_extended = set2 + last_char * (len(set1) - len(set2))
+        else:
+            set2_extended = ""
+
+        for i, c in enumerate(set1):
+            if i < len(set2_extended):
+                trans_map[c] = set2_extended[i]
+
+        return trans_map

just_bash/commands/tree/__init__.py

@@ -0,0 +1,5 @@
+"""Tree command."""
+
+from .tree import TreeCommand
+
+__all__ = ["TreeCommand"]