just-bash 0.1.5__py3-none-any.whl

just_bash/commands/diff/diff.py

@@ -0,0 +1,118 @@
+"""Diff command implementation."""
+
+import difflib
+from ...types import CommandContext, ExecResult
+
+
+class DiffCommand:
+    """The diff command."""
+
+    name = "diff"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the diff command."""
+        brief = False
+        report_identical = False
+        ignore_case = False
+        files: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg in ("-q", "--brief"):
+                brief = True
+            elif arg in ("-s", "--report-identical-files"):
+                report_identical = True
+            elif arg in ("-i", "--ignore-case"):
+                ignore_case = True
+            elif arg == "--help":
+                return ExecResult(
+                    stdout="Usage: diff [OPTION]... FILES\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg == "--":
+                files.extend(args[i + 1:])
+                break
+            elif arg.startswith("-") and len(arg) > 1 and arg != "-":
+                return ExecResult(
+                    stdout="",
+                    stderr=f"diff: invalid option -- '{arg[1]}'\n",
+                    exit_code=1,
+                )
+            else:
+                files.append(arg)
+            i += 1
+
+        if len(files) < 2:
+            return ExecResult(
+                stdout="",
+                stderr="diff: missing operand\n",
+                exit_code=2,
+            )
+
+        file1, file2 = files[0], files[1]
+
+        # Read files
+        try:
+            if file1 == "-":
+                content1 = ctx.stdin
+            else:
+                path1 = ctx.fs.resolve_path(ctx.cwd, file1)
+                content1 = await ctx.fs.read_file(path1)
+        except FileNotFoundError:
+            return ExecResult(
+                stdout="",
+                stderr=f"diff: {file1}: No such file or directory\n",
+                exit_code=2,
+            )
+
+        try:
+            if file2 == "-":
+                content2 = ctx.stdin
+            else:
+                path2 = ctx.fs.resolve_path(ctx.cwd, file2)
+                content2 = await ctx.fs.read_file(path2)
+        except FileNotFoundError:
+            return ExecResult(
+                stdout="",
+                stderr=f"diff: {file2}: No such file or directory\n",
+                exit_code=2,
+            )
+
+        # Compare
+        if ignore_case:
+            compare1 = content1.lower()
+            compare2 = content2.lower()
+        else:
+            compare1 = content1
+            compare2 = content2
+
+        if compare1 == compare2:
+            if report_identical:
+                return ExecResult(
+                    stdout=f"Files {file1} and {file2} are identical\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            return ExecResult(stdout="", stderr="", exit_code=0)
+
+        # Files differ
+        if brief:
+            return ExecResult(
+                stdout=f"Files {file1} and {file2} differ\n",
+                stderr="",
+                exit_code=1,
+            )
+
+        # Generate unified diff
+        lines1 = content1.splitlines(keepends=True)
+        lines2 = content2.splitlines(keepends=True)
+
+        diff = difflib.unified_diff(
+            lines1, lines2,
+            fromfile=file1, tofile=file2,
+        )
+
+        output = "".join(diff)
+        return ExecResult(stdout=output, stderr="", exit_code=1)

just_bash/commands/dirname/__init__.py

@@ -0,0 +1,5 @@
+"""Dirname command."""
+
+from .dirname import DirnameCommand
+
+__all__ = ["DirnameCommand"]

just_bash/commands/dirname/dirname.py

@@ -0,0 +1,56 @@
+"""Dirname command implementation."""
+
+import os
+from ...types import CommandContext, ExecResult
+
+
+class DirnameCommand:
+    """The dirname command."""
+
+    name = "dirname"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the dirname command."""
+        paths: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "--help":
+                return ExecResult(
+                    stdout="Usage: dirname [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"dirname: invalid option -- '{arg[1]}'\n",
+                    exit_code=1,
+                )
+            else:
+                paths.append(arg)
+            i += 1
+
+        if not paths:
+            return ExecResult(
+                stdout="",
+                stderr="dirname: missing operand\n",
+                exit_code=1,
+            )
+
+        results = []
+        for path in paths:
+            dirname = os.path.dirname(path.rstrip("/"))
+            if not dirname:
+                dirname = "."
+            results.append(dirname)
+
+        return ExecResult(
+            stdout="\n".join(results) + "\n",
+            stderr="",
+            exit_code=0,
+        )

just_bash/commands/du/__init__.py

@@ -0,0 +1,5 @@
+"""Du command."""
+
+from .du import DuCommand
+
+__all__ = ["DuCommand"]

just_bash/commands/du/du.py

@@ -0,0 +1,150 @@
+"""Du command implementation - disk usage."""
+
+from ...types import CommandContext, ExecResult
+
+
+class DuCommand:
+    """The du command - disk usage."""
+
+    name = "du"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the du command."""
+        show_all = False
+        summary_only = False
+        human_readable = False
+        show_total = False
+        max_depth = None
+        paths: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "-a" or arg == "--all":
+                show_all = True
+            elif arg == "-s" or arg == "--summarize":
+                summary_only = True
+            elif arg == "-h" or arg == "--human-readable":
+                human_readable = True
+            elif arg == "-c" or arg == "--total":
+                show_total = True
+            elif arg.startswith("--max-depth="):
+                try:
+                    max_depth = int(arg[12:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"du: invalid maximum depth '{arg[12:]}'\n",
+                        exit_code=1,
+                    )
+            elif arg == "--help":
+                return ExecResult(
+                    stdout="Usage: du [OPTION]... [FILE]...\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg.startswith("-"):
+                pass  # Ignore unknown options
+            else:
+                paths.append(arg)
+            i += 1
+
+        if not paths:
+            paths = ["."]
+
+        output_lines = []
+        total_size = 0
+
+        for path in paths:
+            try:
+                resolved = ctx.fs.resolve_path(ctx.cwd, path)
+                stat = await ctx.fs.stat(resolved)
+
+                if stat.is_directory:
+                    size = await self._get_dir_size(
+                        ctx, resolved, path, show_all, summary_only,
+                        max_depth, 0, output_lines, human_readable
+                    )
+                else:
+                    size = stat.size
+                    size_str = self._format_size(size, human_readable)
+                    output_lines.append(f"{size_str}\t{path}")
+
+                total_size += size
+
+            except FileNotFoundError:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"du: cannot access '{path}': No such file or directory\n",
+                    exit_code=1,
+                )
+
+        if show_total:
+            size_str = self._format_size(total_size, human_readable)
+            output_lines.append(f"{size_str}\ttotal")
+
+        return ExecResult(
+            stdout="\n".join(output_lines) + "\n" if output_lines else "",
+            stderr="",
+            exit_code=0,
+        )
+
+    async def _get_dir_size(
+        self, ctx: CommandContext, path: str, display_path: str,
+        show_all: bool, summary_only: bool, max_depth: int | None,
+        current_depth: int, output_lines: list[str], human_readable: bool
+    ) -> int:
+        """Get directory size recursively."""
+        total = 0
+
+        try:
+            entries = await ctx.fs.readdir(path)
+
+            for entry in entries:
+                entry_path = f"{path}/{entry}"
+                entry_display = f"{display_path}/{entry}"
+
+                try:
+                    stat = await ctx.fs.stat(entry_path)
+
+                    if stat.is_directory:
+                        size = await self._get_dir_size(
+                            ctx, entry_path, entry_display, show_all,
+                            summary_only, max_depth, current_depth + 1,
+                            output_lines, human_readable
+                        )
+                    else:
+                        size = stat.size
+                        if show_all and not summary_only:
+                            if max_depth is None or current_depth < max_depth:
+                                size_str = self._format_size(size, human_readable)
+                                output_lines.append(f"{size_str}\t{entry_display}")
+
+                    total += size
+                except Exception:
+                    pass
+
+        except Exception:
+            pass
+
+        # Output this directory
+        if not summary_only or current_depth == 0:
+            if max_depth is None or current_depth <= max_depth:
+                size_str = self._format_size(total, human_readable)
+                output_lines.append(f"{size_str}\t{display_path}")
+
+        return total
+
+    def _format_size(self, size: int, human_readable: bool) -> str:
+        """Format size for display."""
+        if not human_readable:
+            return str(size // 1024 or 1)  # Return in KB, minimum 1
+
+        if size < 1024:
+            return f"{size}B"
+        elif size < 1024 * 1024:
+            return f"{size // 1024}K"
+        elif size < 1024 * 1024 * 1024:
+            return f"{size // (1024 * 1024)}M"
+        else:
+            return f"{size // (1024 * 1024 * 1024)}G"

just_bash/commands/echo/__init__.py

@@ -0,0 +1,5 @@
+"""Echo command implementation."""
+
+from .echo import EchoCommand
+
+__all__ = ["EchoCommand"]

just_bash/commands/echo/echo.py

@@ -0,0 +1,125 @@
+"""Echo command implementation.
+
+Usage: echo [-neE] [string ...]
+
+Options:
+  -n    Do not output the trailing newline
+  -e    Enable interpretation of backslash escapes
+  -E    Disable interpretation of backslash escapes (default)
+"""
+
+from ...types import Command, CommandContext, ExecResult
+
+
+def _process_escapes(s: str) -> str:
+    """Process backslash escape sequences in a string."""
+    result = []
+    i = 0
+    while i < len(s):
+        if s[i] == "\\" and i + 1 < len(s):
+            next_char = s[i + 1]
+            if next_char == "n":
+                result.append("\n")
+                i += 2
+            elif next_char == "t":
+                result.append("\t")
+                i += 2
+            elif next_char == "r":
+                result.append("\r")
+                i += 2
+            elif next_char == "\\":
+                result.append("\\")
+                i += 2
+            elif next_char == "a":
+                result.append("\a")
+                i += 2
+            elif next_char == "b":
+                result.append("\b")
+                i += 2
+            elif next_char == "f":
+                result.append("\f")
+                i += 2
+            elif next_char == "v":
+                result.append("\v")
+                i += 2
+            elif next_char == "e":
+                result.append("\x1b")
+                i += 2
+            elif next_char == "0":
+                # Octal escape: \0nnn
+                octal = ""
+                j = i + 2
+                while j < len(s) and len(octal) < 3 and s[j] in "01234567":
+                    octal += s[j]
+                    j += 1
+                if octal:
+                    result.append(chr(int(octal, 8)))
+                else:
+                    result.append("\0")
+                i = j
+            elif next_char == "x":
+                # Hex escape: \xHH
+                hex_digits = ""
+                j = i + 2
+                while j < len(s) and len(hex_digits) < 2 and s[j] in "0123456789abcdefABCDEF":
+                    hex_digits += s[j]
+                    j += 1
+                if hex_digits:
+                    result.append(chr(int(hex_digits, 16)))
+                    i = j
+                else:
+                    result.append(s[i])
+                    i += 1
+            elif next_char == "c":
+                # \c stops output
+                return "".join(result)
+            else:
+                result.append(s[i])
+                i += 1
+        else:
+            result.append(s[i])
+            i += 1
+    return "".join(result)
+
+
+class EchoCommand:
+    """The echo command."""
+
+    name = "echo"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the echo command."""
+        newline = True
+        enable_escapes = False
+
+        # Parse options
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg.startswith("-") and len(arg) > 1 and all(c in "neE" for c in arg[1:]):
+                for c in arg[1:]:
+                    if c == "n":
+                        newline = False
+                    elif c == "e":
+                        enable_escapes = True
+                    elif c == "E":
+                        enable_escapes = False
+                i += 1
+            else:
+                break
+
+        # Get remaining arguments
+        text_args = args[i:]
+
+        # Build output
+        output = " ".join(text_args)
+
+        # Process escape sequences if enabled
+        if enable_escapes:
+            output = _process_escapes(output)
+
+        # Add newline if needed
+        if newline:
+            output += "\n"
+
+        return ExecResult(stdout=output, stderr="", exit_code=0)

just_bash/commands/env/__init__.py

@@ -0,0 +1,5 @@
+"""Env and printenv commands."""
+
+from .env import EnvCommand, PrintenvCommand
+
+__all__ = ["EnvCommand", "PrintenvCommand"]

just_bash/commands/env/env.py

@@ -0,0 +1,163 @@
+"""Env and printenv command implementations."""
+
+from ...types import CommandContext, ExecResult
+
+
+class EnvCommand:
+    """The env command - run a command with modified environment."""
+
+    name = "env"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the env command."""
+        ignore_environment = False
+        unset_vars: list[str] = []
+        set_vars: dict[str, str] = {}
+        command: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+
+            if arg == "--help":
+                return ExecResult(
+                    stdout=(
+                        "Usage: env [OPTION]... [NAME=VALUE]... [COMMAND [ARG]...]\n"
+                        "Set each NAME to VALUE in the environment and run COMMAND.\n\n"
+                        "Options:\n"
+                        "  -i, --ignore-environment  start with an empty environment\n"
+                        "  -u, --unset=NAME          remove variable from the environment\n"
+                        "      --help                display this help and exit\n"
+                    ),
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg in ("-i", "--ignore-environment"):
+                ignore_environment = True
+            elif arg == "-u" and i + 1 < len(args):
+                i += 1
+                unset_vars.append(args[i])
+            elif arg.startswith("-u"):
+                unset_vars.append(arg[2:])
+            elif arg.startswith("--unset="):
+                unset_vars.append(arg[8:])
+            elif arg == "--unset" and i + 1 < len(args):
+                i += 1
+                unset_vars.append(args[i])
+            elif arg == "--":
+                # Everything after -- is the command
+                command = args[i + 1:]
+                break
+            elif "=" in arg and not arg.startswith("-"):
+                # NAME=VALUE assignment
+                eq_idx = arg.index("=")
+                name = arg[:eq_idx]
+                value = arg[eq_idx + 1:]
+                set_vars[name] = value
+            elif arg.startswith("-"):
+                # Unknown option
+                return ExecResult(
+                    stdout="",
+                    stderr=f"env: invalid option -- '{arg[1:]}'\n",
+                    exit_code=1,
+                )
+            else:
+                # Start of command
+                command = args[i:]
+                break
+            i += 1
+
+        # Build the environment
+        if ignore_environment:
+            new_env = {}
+        else:
+            new_env = dict(ctx.env)
+
+        # Remove unset variables
+        for var in unset_vars:
+            new_env.pop(var, None)
+
+        # Add new variables
+        new_env.update(set_vars)
+
+        # If no command, print the environment
+        if not command:
+            lines = [f"{k}={v}" for k, v in sorted(new_env.items())]
+            return ExecResult(
+                stdout="\n".join(lines) + "\n" if lines else "",
+                stderr="",
+                exit_code=0,
+            )
+
+        # Execute the command with the new environment
+        if not ctx.exec:
+            return ExecResult(
+                stdout="",
+                stderr="env: cannot execute commands\n",
+                exit_code=126,
+            )
+
+        # 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)
+
+        try:
+            result = await ctx.exec(cmd_str, {"cwd": ctx.cwd, "env": new_env})
+            return result
+        except Exception as e:
+            return ExecResult(
+                stdout="",
+                stderr=f"env: {e}\n",
+                exit_code=1,
+            )
+
+
+class PrintenvCommand:
+    """The printenv command - print environment variables."""
+
+    name = "printenv"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the printenv command."""
+        var_names: list[str] = []
+
+        for arg in args:
+            if arg == "--help":
+                return ExecResult(
+                    stdout="Usage: printenv [OPTION]... [VARIABLE]...\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg.startswith("-"):
+                pass  # Ignore options
+            else:
+                var_names.append(arg)
+
+        if not var_names:
+            # Print all
+            lines = [f"{k}={v}" for k, v in sorted(ctx.env.items())]
+            return ExecResult(
+                stdout="\n".join(lines) + "\n" if lines else "",
+                stderr="",
+                exit_code=0,
+            )
+
+        # Print specific variables
+        output_lines = []
+        exit_code = 0
+
+        for name in var_names:
+            if name in ctx.env:
+                output_lines.append(ctx.env[name])
+            else:
+                exit_code = 1
+
+        output = "\n".join(output_lines)
+        if output:
+            output += "\n"
+
+        return ExecResult(stdout=output, stderr="", exit_code=exit_code)

just_bash/commands/expand/__init__.py

@@ -0,0 +1,5 @@
+"""Expand and unexpand commands."""
+
+from .expand import ExpandCommand, UnexpandCommand
+
+__all__ = ["ExpandCommand", "UnexpandCommand"]