just-bash 0.1.5__py3-none-any.whl

just_bash/commands/base64/__init__.py

@@ -0,0 +1,5 @@
+"""Base64 command implementation."""
+
+from .base64 import Base64Command
+
+__all__ = ["Base64Command"]

just_bash/commands/base64/base64.py

@@ -0,0 +1,138 @@
+"""Base64 command implementation.
+
+Usage: base64 [OPTION]... [FILE]
+
+Base64 encode or decode FILE, or standard input.
+
+Options:
+  -d, --decode    decode data
+  -w, --wrap=COLS wrap encoded lines after COLS characters (default 76)
+"""
+
+import base64 as b64
+from ...types import CommandContext, ExecResult
+
+
+class Base64Command:
+    """The base64 command."""
+
+    name = "base64"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the base64 command."""
+        decode = False
+        wrap_cols = 76
+        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 == "--decode":
+                    decode = True
+                elif arg.startswith("--wrap="):
+                    try:
+                        wrap_cols = int(arg[7:])
+                    except ValueError:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"base64: invalid wrap size: '{arg[7:]}'\n",
+                            exit_code=1,
+                        )
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"base64: unrecognized option '{arg}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-") and arg != "-":
+                j = 1
+                while j < len(arg):
+                    c = arg[j]
+                    if c == "d":
+                        decode = True
+                    elif c == "w":
+                        # -w requires a value
+                        if j + 1 < len(arg):
+                            try:
+                                wrap_cols = int(arg[j + 1:])
+                            except ValueError:
+                                return ExecResult(
+                                    stdout="",
+                                    stderr=f"base64: invalid wrap size\n",
+                                    exit_code=1,
+                                )
+                            break
+                        elif i + 1 < len(args):
+                            i += 1
+                            try:
+                                wrap_cols = int(args[i])
+                            except ValueError:
+                                return ExecResult(
+                                    stdout="",
+                                    stderr=f"base64: invalid wrap size: '{args[i]}'\n",
+                                    exit_code=1,
+                                )
+                            break
+                        else:
+                            return ExecResult(
+                                stdout="",
+                                stderr="base64: option requires an argument -- 'w'\n",
+                                exit_code=1,
+                            )
+                    else:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"base64: invalid option -- '{c}'\n",
+                            exit_code=1,
+                        )
+                    j += 1
+            else:
+                files.append(arg)
+            i += 1
+
+        # Default to stdin
+        if not files:
+            files = ["-"]
+
+        stdout = ""
+        stderr = ""
+        exit_code = 0
+
+        for f in files:
+            try:
+                if f == "-":
+                    content = ctx.stdin
+                else:
+                    path = ctx.fs.resolve_path(ctx.cwd, f)
+                    content = await ctx.fs.read_file(path)
+
+                if decode:
+                    # Decode base64
+                    # Strip whitespace
+                    content = "".join(content.split())
+                    try:
+                        decoded = b64.b64decode(content)
+                        stdout += decoded.decode("utf-8", errors="replace")
+                    except Exception as e:
+                        stderr += f"base64: invalid input\n"
+                        exit_code = 1
+                else:
+                    # Encode to base64
+                    encoded = b64.b64encode(content.encode("utf-8")).decode("utf-8")
+                    # Wrap lines
+                    if wrap_cols > 0:
+                        lines = [encoded[i:i + wrap_cols] for i in range(0, len(encoded), wrap_cols)]
+                        stdout += "\n".join(lines) + "\n"
+                    else:
+                        stdout += encoded
+
+            except FileNotFoundError:
+                stderr += f"base64: {f}: No such file or directory\n"
+                exit_code = 1
+
+        return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)

just_bash/commands/basename/__init__.py

@@ -0,0 +1,5 @@
+"""Basename command."""
+
+from .basename import BasenameCommand
+
+__all__ = ["BasenameCommand"]

just_bash/commands/basename/basename.py

@@ -0,0 +1,72 @@
+"""Basename command implementation."""
+
+import os
+from ...types import CommandContext, ExecResult
+
+
+class BasenameCommand:
+    """The basename command."""
+
+    name = "basename"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the basename command."""
+        suffix = None
+        multiple = False
+        paths: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "-s" and i + 1 < len(args):
+                i += 1
+                suffix = args[i]
+            elif arg.startswith("--suffix="):
+                suffix = arg[9:]
+            elif arg == "-a" or arg == "--multiple":
+                multiple = True
+            elif arg == "--help":
+                return ExecResult(
+                    stdout="Usage: basename NAME [SUFFIX]\n       basename OPTION... NAME...\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg == "--":
+                paths.extend(args[i + 1:])
+                break
+            elif arg.startswith("-") and len(arg) > 1:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"basename: invalid option -- '{arg[1]}'\n",
+                    exit_code=1,
+                )
+            else:
+                paths.append(arg)
+            i += 1
+
+        if not paths:
+            return ExecResult(
+                stdout="",
+                stderr="basename: missing operand\n",
+                exit_code=1,
+            )
+
+        # If not multiple mode and exactly 2 args, second is suffix
+        if not multiple and not suffix and len(paths) == 2:
+            suffix = paths[1]
+            paths = [paths[0]]
+
+        results = []
+        for path in paths:
+            base = os.path.basename(path.rstrip("/"))
+            if not base:
+                base = "/"
+            if suffix and base.endswith(suffix):
+                base = base[:-len(suffix)]
+            results.append(base)
+
+        return ExecResult(
+            stdout="\n".join(results) + "\n",
+            stderr="",
+            exit_code=0,
+        )

just_bash/commands/bash/__init__.py

@@ -0,0 +1,5 @@
+"""Bash and sh commands."""
+
+from .bash import BashCommand, ShCommand
+
+__all__ = ["BashCommand", "ShCommand"]

just_bash/commands/bash/bash.py

@@ -0,0 +1,188 @@
+"""Bash and sh command implementations."""
+
+from ...types import CommandContext, ExecResult
+
+
+class BashCommand:
+    """The bash command - execute shell commands or scripts."""
+
+    name = "bash"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the bash command."""
+        if "--help" in args:
+            return ExecResult(
+                stdout=(
+                    "Usage: bash [OPTIONS] [SCRIPT_FILE] [ARGUMENTS...]\n"
+                    "Execute shell commands or scripts.\n\n"
+                    "Options:\n"
+                    "  -c COMMAND  execute COMMAND string\n"
+                    "      --help  display this help and exit\n\n"
+                    "Without -c, reads and executes commands from SCRIPT_FILE.\n"
+                ),
+                stderr="",
+                exit_code=0,
+            )
+
+        # Handle -c flag
+        # With -c: bash -c 'command' arg0 arg1 arg2
+        # arg0 becomes $0, arg1 becomes $1, arg2 becomes $2
+        if len(args) >= 2 and args[0] == "-c":
+            command = args[1]
+            script_name = args[2] if len(args) > 2 else "bash"
+            script_args = args[3:] if len(args) > 3 else []
+            return await self._execute_script(command, script_name, script_args, ctx)
+
+        # No arguments - in real bash this would be interactive mode
+        # In our implementation, we just return success
+        if not args:
+            return ExecResult(stdout="", stderr="", exit_code=0)
+
+        # Read and execute script file
+        script_path = args[0]
+        script_args = args[1:]
+
+        try:
+            full_path = ctx.fs.resolve_path(ctx.cwd, script_path)
+            script_content = await ctx.fs.read_file(full_path)
+            return await self._execute_script(script_content, script_path, script_args, ctx)
+        except FileNotFoundError:
+            return ExecResult(
+                stdout="",
+                stderr=f"bash: {script_path}: No such file or directory\n",
+                exit_code=127,
+            )
+
+    async def _execute_script(
+        self,
+        script: str,
+        script_name: str,
+        script_args: list[str],
+        ctx: CommandContext,
+    ) -> ExecResult:
+        """Execute a script with positional parameters."""
+        if not ctx.exec:
+            return ExecResult(
+                stdout="",
+                stderr="bash: internal error: exec function not available\n",
+                exit_code=1,
+            )
+
+        # Build positional parameters for the exec env option
+        positional_env: dict[str, str] = {
+            "0": script_name,
+            "#": str(len(script_args)),
+            "@": " ".join(script_args),
+            "*": " ".join(script_args),
+        }
+        for i, arg in enumerate(script_args):
+            positional_env[str(i + 1)] = arg
+
+        # Skip shebang line if present
+        script_to_run = script
+        if script_to_run.startswith("#!"):
+            first_newline = script_to_run.find("\n")
+            if first_newline != -1:
+                script_to_run = script_to_run[first_newline + 1:]
+
+        # Process the script line by line, filtering out comments and empty lines
+        lines = script_to_run.split("\n")
+        commands: list[str] = []
+        for line in lines:
+            trimmed = line.strip()
+            # Skip empty lines and comment lines
+            if trimmed and not trimmed.startswith("#"):
+                commands.append(trimmed)
+
+        # Execute all commands joined by semicolons
+        command_string = "; ".join(commands)
+        result = await ctx.exec(command_string, {"env": positional_env, "cwd": ctx.cwd})
+        return result
+
+
+class ShCommand:
+    """The sh command - execute shell commands or scripts (POSIX shell)."""
+
+    name = "sh"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the sh command."""
+        if "--help" in args:
+            return ExecResult(
+                stdout=(
+                    "Usage: sh [OPTIONS] [SCRIPT_FILE] [ARGUMENTS...]\n"
+                    "Execute shell commands or scripts (POSIX shell).\n\n"
+                    "Options:\n"
+                    "  -c COMMAND  execute COMMAND string\n"
+                    "      --help  display this help and exit\n\n"
+                    "Without -c, reads and executes commands from SCRIPT_FILE.\n"
+                ),
+                stderr="",
+                exit_code=0,
+            )
+
+        # Same implementation as bash
+        # Handle -c flag
+        if len(args) >= 2 and args[0] == "-c":
+            command = args[1]
+            script_name = args[2] if len(args) > 2 else "sh"
+            script_args = args[3:] if len(args) > 3 else []
+            return await self._execute_script(command, script_name, script_args, ctx)
+
+        if not args:
+            return ExecResult(stdout="", stderr="", exit_code=0)
+
+        script_path = args[0]
+        script_args = args[1:]
+
+        try:
+            full_path = ctx.fs.resolve_path(ctx.cwd, script_path)
+            script_content = await ctx.fs.read_file(full_path)
+            return await self._execute_script(script_content, script_path, script_args, ctx)
+        except FileNotFoundError:
+            return ExecResult(
+                stdout="",
+                stderr=f"sh: {script_path}: No such file or directory\n",
+                exit_code=127,
+            )
+
+    async def _execute_script(
+        self,
+        script: str,
+        script_name: str,
+        script_args: list[str],
+        ctx: CommandContext,
+    ) -> ExecResult:
+        """Execute a script with positional parameters."""
+        if not ctx.exec:
+            return ExecResult(
+                stdout="",
+                stderr="sh: internal error: exec function not available\n",
+                exit_code=1,
+            )
+
+        positional_env: dict[str, str] = {
+            "0": script_name,
+            "#": str(len(script_args)),
+            "@": " ".join(script_args),
+            "*": " ".join(script_args),
+        }
+        for i, arg in enumerate(script_args):
+            positional_env[str(i + 1)] = arg
+
+        script_to_run = script
+        if script_to_run.startswith("#!"):
+            first_newline = script_to_run.find("\n")
+            if first_newline != -1:
+                script_to_run = script_to_run[first_newline + 1:]
+
+        lines = script_to_run.split("\n")
+        commands: list[str] = []
+        for line in lines:
+            trimmed = line.strip()
+            if trimmed and not trimmed.startswith("#"):
+                commands.append(trimmed)
+
+        command_string = "; ".join(commands)
+        result = await ctx.exec(command_string, {"env": positional_env, "cwd": ctx.cwd})
+        return result

just_bash/commands/cat/__init__.py

@@ -0,0 +1,5 @@
+"""Cat command implementation."""
+
+from .cat import CatCommand
+
+__all__ = ["CatCommand"]

just_bash/commands/cat/cat.py

@@ -0,0 +1,173 @@
+"""Cat command implementation.
+
+Usage: cat [OPTION]... [FILE]...
+
+Concatenate FILE(s) to standard output.
+With no FILE, or when FILE is -, read standard input.
+
+Options:
+  -n, --number             number all output lines
+  -b, --number-nonblank    number nonempty output lines
+  -s, --squeeze-blank      suppress repeated empty output lines
+  -E, --show-ends          display $ at end of each line
+  -T, --show-tabs          display TAB characters as ^I
+  -v, --show-nonprinting   use ^ and M- notation, except for LFD and TAB
+  -A, --show-all           equivalent to -vET
+  -e                       equivalent to -vE
+  -t                       equivalent to -vT
+"""
+
+from ...types import Command, CommandContext, ExecResult
+
+
+class CatCommand:
+    """The cat command."""
+
+    name = "cat"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the cat command."""
+        # Options
+        number_lines = False
+        number_nonblank = False
+        squeeze_blank = False
+        show_ends = False
+        show_tabs = False
+        show_nonprinting = 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 == "--number":
+                    number_lines = True
+                elif arg == "--number-nonblank":
+                    number_nonblank = True
+                elif arg == "--squeeze-blank":
+                    squeeze_blank = True
+                elif arg == "--show-ends":
+                    show_ends = True
+                elif arg == "--show-tabs":
+                    show_tabs = True
+                elif arg == "--show-nonprinting":
+                    show_nonprinting = True
+                elif arg == "--show-all":
+                    show_nonprinting = True
+                    show_ends = True
+                    show_tabs = True
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"cat: unrecognized option '{arg}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-") and arg != "-":
+                for c in arg[1:]:
+                    if c == "n":
+                        number_lines = True
+                    elif c == "b":
+                        number_nonblank = True
+                    elif c == "s":
+                        squeeze_blank = True
+                    elif c == "E":
+                        show_ends = True
+                    elif c == "T":
+                        show_tabs = True
+                    elif c == "v":
+                        show_nonprinting = True
+                    elif c == "A":
+                        show_nonprinting = True
+                        show_ends = True
+                        show_tabs = True
+                    elif c == "e":
+                        show_nonprinting = True
+                        show_ends = True
+                    elif c == "t":
+                        show_nonprinting = True
+                        show_tabs = True
+                    else:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"cat: invalid option -- '{c}'\n",
+                            exit_code=1,
+                        )
+            else:
+                files.append(arg)
+            i += 1
+
+        # If number_nonblank is set, don't number all lines
+        if number_nonblank:
+            number_lines = False
+
+        # If no files, read from stdin
+        if not files:
+            files = ["-"]
+
+        stdout = ""
+        stderr = ""
+        exit_code = 0
+        line_number = 1
+        prev_blank = False
+
+        for file in files:
+            try:
+                if file == "-":
+                    content = ctx.stdin
+                else:
+                    # Resolve path
+                    path = ctx.fs.resolve_path(ctx.cwd, file)
+                    content = await ctx.fs.read_file(path)
+
+                lines = content.split("\n")
+
+                # Process each line
+                for j, line in enumerate(lines):
+                    # Don't output trailing empty string from split
+                    if j == len(lines) - 1 and line == "":
+                        break
+
+                    is_blank = line == ""
+
+                    # Squeeze blank lines
+                    if squeeze_blank and is_blank and prev_blank:
+                        continue
+                    prev_blank = is_blank
+
+                    # Process line
+                    output_line = line
+
+                    # Show tabs
+                    if show_tabs:
+                        output_line = output_line.replace("\t", "^I")
+
+                    # Show nonprinting (simplified - just shows tab replacement already done)
+                    # Full implementation would handle all non-printable chars
+
+                    # Show ends
+                    if show_ends:
+                        output_line += "$"
+
+                    # Number lines
+                    if number_lines or (number_nonblank and not is_blank):
+                        output_line = f"{line_number:6}\t{output_line}"
+                        line_number += 1
+
+                    stdout += output_line + "\n"
+
+            except FileNotFoundError:
+                stderr += f"cat: {file}: No such file or directory\n"
+                exit_code = 1
+            except IsADirectoryError:
+                stderr += f"cat: {file}: Is a directory\n"
+                exit_code = 1
+            except PermissionError:
+                stderr += f"cat: {file}: Permission denied\n"
+                exit_code = 1
+
+        return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)

just_bash/commands/checksum/__init__.py

@@ -0,0 +1,5 @@
+"""Checksum commands."""
+
+from .checksum import Md5sumCommand, Sha1sumCommand, Sha256sumCommand
+
+__all__ = ["Md5sumCommand", "Sha1sumCommand", "Sha256sumCommand"]