just-bash 0.1.5__py3-none-any.whl

just_bash/commands/seq/__init__.py

@@ -0,0 +1,5 @@
+"""Seq command implementation."""
+
+from .seq import SeqCommand
+
+__all__ = ["SeqCommand"]

just_bash/commands/seq/seq.py

@@ -0,0 +1,190 @@
+"""Seq command implementation.
+
+Usage: seq [OPTION]... LAST
+  or:  seq [OPTION]... FIRST LAST
+  or:  seq [OPTION]... FIRST INCREMENT LAST
+
+Print numbers from FIRST to LAST, in steps of INCREMENT.
+
+Options:
+  -s, --separator=STRING  use STRING to separate numbers (default: newline)
+  -w, --equal-width       equalize width by padding with leading zeroes
+"""
+
+from ...types import CommandContext, ExecResult
+
+
+class SeqCommand:
+    """The seq command."""
+
+    name = "seq"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the seq command."""
+        separator = "\n"
+        equal_width = False
+        numbers: list[str] = []
+
+        # Parse arguments
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg.startswith("--"):
+                if arg.startswith("--separator="):
+                    separator = arg[12:]
+                elif arg == "--equal-width":
+                    equal_width = True
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"seq: unrecognized option '{arg}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-") and arg != "-" and not self._is_number(arg):
+                j = 1
+                while j < len(arg):
+                    c = arg[j]
+                    if c == "s":
+                        # -s requires a value
+                        if j + 1 < len(arg):
+                            separator = arg[j + 1:]
+                            break
+                        elif i + 1 < len(args):
+                            i += 1
+                            separator = args[i]
+                            break
+                        else:
+                            return ExecResult(
+                                stdout="",
+                                stderr="seq: option requires an argument -- 's'\n",
+                                exit_code=1,
+                            )
+                    elif c == "w":
+                        equal_width = True
+                    else:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"seq: invalid option -- '{c}'\n",
+                            exit_code=1,
+                        )
+                    j += 1
+            else:
+                numbers.append(arg)
+            i += 1
+
+        # Parse FIRST, INCREMENT, LAST
+        if len(numbers) == 0:
+            return ExecResult(
+                stdout="",
+                stderr="seq: missing operand\n",
+                exit_code=1,
+            )
+        elif len(numbers) == 1:
+            first = 1.0
+            increment = 1.0
+            try:
+                last = float(numbers[0])
+            except ValueError:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"seq: invalid floating point argument: '{numbers[0]}'\n",
+                    exit_code=1,
+                )
+        elif len(numbers) == 2:
+            try:
+                first = float(numbers[0])
+                last = float(numbers[1])
+                increment = 1.0 if first <= last else -1.0
+            except ValueError as e:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"seq: invalid floating point argument\n",
+                    exit_code=1,
+                )
+        elif len(numbers) == 3:
+            try:
+                first = float(numbers[0])
+                increment = float(numbers[1])
+                last = float(numbers[2])
+            except ValueError:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"seq: invalid floating point argument\n",
+                    exit_code=1,
+                )
+        else:
+            return ExecResult(
+                stdout="",
+                stderr="seq: extra operand\n",
+                exit_code=1,
+            )
+
+        # Validate increment
+        if increment == 0:
+            return ExecResult(
+                stdout="",
+                stderr="seq: zero increment\n",
+                exit_code=1,
+            )
+
+        # Generate sequence
+        result_nums: list[str] = []
+        current = first
+        max_iterations = 100000  # Prevent infinite loops
+
+        # Determine decimal places for formatting
+        def get_decimal_places(n: float, s: str) -> int:
+            if "." in s:
+                return len(s.split(".")[1])
+            return 0
+
+        first_decimals = get_decimal_places(first, numbers[0] if numbers else "1")
+        incr_decimals = get_decimal_places(increment, numbers[1] if len(numbers) > 2 else "1")
+        last_decimals = get_decimal_places(last, numbers[-1] if numbers else "1")
+        decimals = max(first_decimals, incr_decimals, last_decimals)
+
+        iterations = 0
+        while iterations < max_iterations:
+            iterations += 1
+
+            if increment > 0 and current > last + 1e-10:
+                break
+            if increment < 0 and current < last - 1e-10:
+                break
+
+            if decimals == 0 and current == int(current):
+                result_nums.append(str(int(current)))
+            else:
+                result_nums.append(f"{current:.{decimals}f}")
+
+            current += increment
+
+        # Apply equal width padding
+        if equal_width and result_nums:
+            max_width = max(len(n.split(".")[0].lstrip("-")) for n in result_nums)
+            padded = []
+            for n in result_nums:
+                if n.startswith("-"):
+                    padded.append("-" + n[1:].zfill(max_width + (len(n) - len(n.lstrip("-0123456789")) if "." in n else 0)))
+                else:
+                    if "." in n:
+                        int_part, dec_part = n.split(".")
+                        padded.append(int_part.zfill(max_width) + "." + dec_part)
+                    else:
+                        padded.append(n.zfill(max_width))
+            result_nums = padded
+
+        if result_nums:
+            output = separator.join(result_nums) + "\n"
+        else:
+            output = ""
+
+        return ExecResult(stdout=output, stderr="", exit_code=0)
+
+    def _is_number(self, s: str) -> bool:
+        """Check if string is a number (including negative)."""
+        try:
+            float(s)
+            return True
+        except ValueError:
+            return False

just_bash/commands/shell/__init__.py

@@ -0,0 +1,5 @@
+"""Shell utility commands."""
+
+from .shell import ClearCommand, AliasCommand, UnaliasCommand, HistoryCommand
+
+__all__ = ["ClearCommand", "AliasCommand", "UnaliasCommand", "HistoryCommand"]

just_bash/commands/shell/shell.py

@@ -0,0 +1,206 @@
+"""Shell utility command implementations (clear, alias, unalias, history)."""
+
+from ...types import CommandContext, ExecResult
+
+
+class ClearCommand:
+    """The clear command - clear the terminal screen."""
+
+    name = "clear"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the clear command."""
+        if "--help" in args or "-h" in args:
+            return ExecResult(
+                stdout="Usage: clear\nClear the terminal screen.\n",
+                stderr="",
+                exit_code=0,
+            )
+
+        # Output ANSI escape sequence to clear screen
+        # ESC[2J clears the screen, ESC[H moves cursor to home
+        return ExecResult(stdout="\033[2J\033[H", stderr="", exit_code=0)
+
+
+class AliasCommand:
+    """The alias command - define or display aliases."""
+
+    name = "alias"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the alias command."""
+        if "--help" in args:
+            return ExecResult(
+                stdout="Usage: alias [name[=value] ...]\nDefine or display aliases.\n",
+                stderr="",
+                exit_code=0,
+            )
+
+        # Get existing aliases from environment (stored as BASH_ALIAS_name)
+        aliases = {}
+        for key, value in ctx.env.items():
+            if key.startswith("BASH_ALIAS_"):
+                alias_name = key[11:]  # Remove prefix
+                aliases[alias_name] = value
+
+        if not args:
+            # Display all aliases
+            if not aliases:
+                return ExecResult(stdout="", stderr="", exit_code=0)
+
+            lines = []
+            for name, value in sorted(aliases.items()):
+                lines.append(f"alias {name}='{value}'")
+            return ExecResult(stdout="\n".join(lines) + "\n", stderr="", exit_code=0)
+
+        stdout_parts = []
+        stderr = ""
+        exit_code = 0
+
+        for arg in args:
+            if "=" in arg:
+                # Define alias: alias name=value
+                name, value = arg.split("=", 1)
+                # Remove surrounding quotes if present
+                if (value.startswith("'") and value.endswith("'")) or \
+                   (value.startswith('"') and value.endswith('"')):
+                    value = value[1:-1]
+                ctx.env[f"BASH_ALIAS_{name}"] = value
+            else:
+                # Display specific alias
+                if arg in aliases:
+                    stdout_parts.append(f"alias {arg}='{aliases[arg]}'")
+                else:
+                    stderr += f"alias: {arg}: not found\n"
+                    exit_code = 1
+
+        stdout = "\n".join(stdout_parts)
+        if stdout:
+            stdout += "\n"
+        return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)
+
+
+class UnaliasCommand:
+    """The unalias command - remove aliases."""
+
+    name = "unalias"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the unalias command."""
+        if "--help" in args:
+            return ExecResult(
+                stdout="Usage: unalias [-a] name [name ...]\nRemove aliases.\n",
+                stderr="",
+                exit_code=0,
+            )
+
+        remove_all = False
+        names: list[str] = []
+
+        for arg in args:
+            if arg == "-a":
+                remove_all = True
+            elif arg.startswith("-"):
+                return ExecResult(
+                    stdout="",
+                    stderr=f"unalias: invalid option -- '{arg[1]}'\n",
+                    exit_code=1,
+                )
+            else:
+                names.append(arg)
+
+        if remove_all:
+            # Remove all aliases
+            to_remove = [k for k in ctx.env if k.startswith("BASH_ALIAS_")]
+            for key in to_remove:
+                del ctx.env[key]
+            return ExecResult(stdout="", stderr="", exit_code=0)
+
+        if not names:
+            return ExecResult(
+                stdout="",
+                stderr="unalias: usage: unalias [-a] name [name ...]\n",
+                exit_code=1,
+            )
+
+        stderr = ""
+        exit_code = 0
+
+        for name in names:
+            key = f"BASH_ALIAS_{name}"
+            if key in ctx.env:
+                del ctx.env[key]
+            else:
+                stderr += f"unalias: {name}: not found\n"
+                exit_code = 1
+
+        return ExecResult(stdout="", stderr=stderr, exit_code=exit_code)
+
+
+class HistoryCommand:
+    """The history command - display command history."""
+
+    name = "history"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the history command."""
+        import json
+
+        if "--help" in args:
+            return ExecResult(
+                stdout="Usage: history [-c] [n]\nDisplay or clear command history.\n",
+                stderr="",
+                exit_code=0,
+            )
+
+        # Handle -c flag to clear history
+        if "-c" in args:
+            ctx.env["BASH_HISTORY"] = "[]"
+            return ExecResult(stdout="", stderr="", exit_code=0)
+
+        # Parse numeric argument for limiting output
+        limit = None
+        for arg in args:
+            if arg.isdigit():
+                limit = int(arg)
+                break
+
+        # No history available
+        if "BASH_HISTORY" not in ctx.env:
+            return ExecResult(stdout="", stderr="", exit_code=0)
+
+        history_value = ctx.env["BASH_HISTORY"]
+
+        # Try to parse as JSON array first
+        try:
+            history = json.loads(history_value)
+            if not isinstance(history, list):
+                # Fallback to newline-separated
+                history = [cmd for cmd in history_value.split("\n") if cmd]
+        except json.JSONDecodeError:
+            # Fallback to newline-separated format for backward compatibility
+            history = [cmd for cmd in history_value.split("\n") if cmd]
+
+        if not history:
+            return ExecResult(stdout="", stderr="", exit_code=0)
+
+        # Apply limit if specified
+        total = len(history)
+        if limit is not None:
+            if limit == 0:
+                return ExecResult(stdout="", stderr="", exit_code=0)
+            # Show last N entries with their original line numbers
+            start_idx = max(0, total - limit)
+        else:
+            start_idx = 0
+
+        # Format output with 5-character right-justified line numbers
+        lines = []
+        for i, cmd in enumerate(history[start_idx:], start_idx + 1):
+            lines.append(f"{str(i).rjust(5)}  {cmd}")
+
+        return ExecResult(
+            stdout="\n".join(lines) + "\n" if lines else "",
+            stderr="",
+            exit_code=0,
+        )

just_bash/commands/sleep/__init__.py

@@ -0,0 +1,5 @@
+"""Sleep command."""
+
+from .sleep import SleepCommand
+
+__all__ = ["SleepCommand"]

just_bash/commands/sleep/sleep.py

@@ -0,0 +1,62 @@
+"""Sleep command implementation."""
+
+import asyncio
+import re
+from ...types import CommandContext, ExecResult
+
+
+class SleepCommand:
+    """The sleep command."""
+
+    name = "sleep"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the sleep command."""
+        if not args:
+            return ExecResult(
+                stdout="",
+                stderr="sleep: missing operand\n",
+                exit_code=1,
+            )
+
+        if "--help" in args:
+            return ExecResult(
+                stdout="Usage: sleep NUMBER[SUFFIX]...\n",
+                stderr="",
+                exit_code=0,
+            )
+
+        total_seconds = 0.0
+
+        for arg in args:
+            try:
+                seconds = self._parse_duration(arg)
+                total_seconds += seconds
+            except ValueError as e:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"sleep: invalid time interval '{arg}'\n",
+                    exit_code=1,
+                )
+
+        await asyncio.sleep(total_seconds)
+        return ExecResult(stdout="", stderr="", exit_code=0)
+
+    def _parse_duration(self, s: str) -> float:
+        """Parse a duration string like '1.5', '2s', '1m', '1h', '1d'."""
+        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
+        # 's' or no suffix = seconds
+
+        return value

just_bash/commands/sort/__init__.py

@@ -0,0 +1,5 @@
+"""Sort command implementation."""
+
+from .sort import SortCommand
+
+__all__ = ["SortCommand"]