just-bash 0.1.5__py3-none-any.whl

just_bash/commands/strings/strings.py

@@ -0,0 +1,150 @@
+"""Strings command implementation."""
+
+from ...types import CommandContext, ExecResult
+
+
+class StringsCommand:
+    """The strings command - find printable strings in files."""
+
+    name = "strings"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the strings command."""
+        min_length = 4
+        show_offset = False
+        offset_format = "o"  # octal by default
+        files: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "--help":
+                return ExecResult(
+                    stdout="Usage: strings [OPTION]... [FILE]...\nFind printable strings in files.\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg == "-n" and i + 1 < len(args):
+                i += 1
+                try:
+                    min_length = int(args[i])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"strings: invalid minimum string length: '{args[i]}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-n"):
+                try:
+                    min_length = int(arg[2:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"strings: invalid minimum string length: '{arg[2:]}'\n",
+                        exit_code=1,
+                    )
+            elif arg == "-o":
+                show_offset = True
+                offset_format = "o"
+            elif arg == "-t" and i + 1 < len(args):
+                i += 1
+                show_offset = True
+                offset_format = args[i]
+            elif arg.startswith("-t"):
+                show_offset = True
+                offset_format = arg[2:]
+            elif arg.startswith("-") and len(arg) > 1:
+                # Could be -N for minimum length
+                try:
+                    min_length = int(arg[1:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"strings: invalid option -- '{arg[1]}'\n",
+                        exit_code=1,
+                    )
+            elif arg == "--":
+                files.extend(args[i + 1:])
+                break
+            else:
+                files.append(arg)
+            i += 1
+
+        if min_length <= 0:
+            return ExecResult(
+                stdout="",
+                stderr="strings: minimum string length must be greater than 0\n",
+                exit_code=1,
+            )
+
+        # Read from stdin if no files
+        if not files:
+            content = ctx.stdin.encode("utf-8", errors="replace")
+            result = self._find_strings(content, min_length, show_offset, offset_format)
+            return ExecResult(stdout=result, stderr="", exit_code=0)
+
+        stdout_parts = []
+        stderr = ""
+        exit_code = 0
+
+        for file in files:
+            try:
+                if file == "-":
+                    content = ctx.stdin.encode("utf-8", errors="replace")
+                else:
+                    path = ctx.fs.resolve_path(ctx.cwd, file)
+                    content = await ctx.fs.read_file_bytes(path)
+
+                result = self._find_strings(content, min_length, show_offset, offset_format)
+                stdout_parts.append(result)
+
+            except FileNotFoundError:
+                stderr += f"strings: {file}: No such file or directory\n"
+                exit_code = 1
+
+        return ExecResult(stdout="".join(stdout_parts), stderr=stderr, exit_code=exit_code)
+
+    def _find_strings(
+        self, data: bytes, min_length: int, show_offset: bool = False, offset_format: str = "o"
+    ) -> str:
+        """Find printable strings in binary data."""
+        result = []
+        current = []
+        start_offset = 0
+
+        for idx, byte in enumerate(data):
+            # Check if byte is printable ASCII (32-126) or tab/newline
+            if 32 <= byte <= 126 or byte in (9, 10, 13):
+                if not current:
+                    start_offset = idx
+                current.append(chr(byte))
+            else:
+                if len(current) >= min_length:
+                    s = "".join(current)
+                    if show_offset:
+                        if offset_format == "x":
+                            result.append(f"{start_offset:7x} {s}")
+                        elif offset_format == "d":
+                            result.append(f"{start_offset:7d} {s}")
+                        else:  # octal
+                            result.append(f"{start_offset:7o} {s}")
+                    else:
+                        result.append(s)
+                current = []
+
+        # Check final string
+        if len(current) >= min_length:
+            s = "".join(current)
+            if show_offset:
+                if offset_format == "x":
+                    result.append(f"{start_offset:7x} {s}")
+                elif offset_format == "d":
+                    result.append(f"{start_offset:7d} {s}")
+                else:  # octal
+                    result.append(f"{start_offset:7o} {s}")
+            else:
+                result.append(s)
+
+        if result:
+            return "\n".join(result) + "\n"
+        return ""

just_bash/commands/tac/__init__.py

@@ -0,0 +1,5 @@
+"""Tac command."""
+
+from .tac import TacCommand
+
+__all__ = ["TacCommand"]

just_bash/commands/tac/tac.py

@@ -0,0 +1,158 @@
+"""Tac command implementation.
+
+Usage: tac [OPTION]... [FILE]...
+
+Concatenate and print files in reverse.
+
+Options:
+  -b, --before             attach the separator before instead of after
+  -r, --regex              interpret the separator as a regular expression
+  -s, --separator=STRING   use STRING as the separator instead of newline
+"""
+
+import re
+from ...types import CommandContext, ExecResult
+
+
+class TacCommand:
+    """The tac command - reverse lines."""
+
+    name = "tac"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the tac command."""
+        files: list[str] = []
+        separator = "\n"
+        before = False
+        regex_mode = False
+
+        # Parse arguments
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "--help":
+                return ExecResult(
+                    stdout="Usage: tac [OPTION]... [FILE]...\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg == "--":
+                files.extend(args[i + 1:])
+                break
+            elif arg.startswith("--"):
+                if arg == "--before":
+                    before = True
+                elif arg == "--regex":
+                    regex_mode = True
+                elif arg.startswith("--separator="):
+                    separator = arg[12:]
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"tac: unrecognized option '{arg}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-") and len(arg) > 1:
+                j = 1
+                while j < len(arg):
+                    c = arg[j]
+                    if c == "b":
+                        before = True
+                    elif c == "r":
+                        regex_mode = True
+                    elif 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="tac: option requires an argument -- 's'\n",
+                                exit_code=1,
+                            )
+                    else:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"tac: invalid option -- '{c}'\n",
+                            exit_code=1,
+                        )
+                    j += 1
+            else:
+                files.append(arg)
+            i += 1
+
+        # Read content
+        if files:
+            content_parts = []
+            for f in files:
+                try:
+                    path = ctx.fs.resolve_path(ctx.cwd, f)
+                    content_parts.append(await ctx.fs.read_file(path))
+                except FileNotFoundError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"tac: {f}: No such file or directory\n",
+                        exit_code=1,
+                    )
+            content = "".join(content_parts)
+        else:
+            content = ctx.stdin
+
+        if not content:
+            return ExecResult(stdout="", stderr="", exit_code=0)
+
+        # Split content by separator
+        if regex_mode:
+            try:
+                pattern = re.compile(separator)
+                # Split and keep track of what separators were matched
+                records = pattern.split(content)
+                # Find all separator matches
+                separators = pattern.findall(content)
+            except re.error as e:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"tac: invalid regex: {e}\n",
+                    exit_code=1,
+                )
+        else:
+            # Literal separator split
+            records = content.split(separator)
+            # All separators are the same literal
+            separators = [separator] * (len(records) - 1) if len(records) > 1 else []
+
+        # Handle trailing empty record (from trailing separator)
+        trailing_empty = records and records[-1] == ""
+        if trailing_empty:
+            records = records[:-1]
+
+        # Reverse the records
+        records.reverse()
+
+        # Reconstruct output with separators
+        if not before:
+            # Normal mode: separator follows each record (except last)
+            output_parts = []
+            for i, record in enumerate(records):
+                output_parts.append(record)
+                if i < len(records) - 1:
+                    output_parts.append(separators[0] if separators else separator)
+            # Add trailing separator if original had one
+            if trailing_empty:
+                output_parts.append(separators[0] if separators else separator)
+            output = "".join(output_parts)
+        else:
+            # -b mode: separator precedes each record (except first)
+            output_parts = []
+            for i, record in enumerate(records):
+                if i > 0:
+                    output_parts.append(separators[0] if separators else separator)
+                output_parts.append(record)
+            output = "".join(output_parts)
+
+        return ExecResult(stdout=output, stderr="", exit_code=0)

just_bash/commands/tail/__init__.py

@@ -0,0 +1,5 @@
+"""Tail command implementation."""
+
+from .tail import TailCommand
+
+__all__ = ["TailCommand"]

just_bash/commands/tail/tail.py

@@ -0,0 +1,180 @@
+"""Tail command implementation.
+
+Usage: tail [OPTION]... [FILE]...
+
+Print the last 10 lines of each FILE to standard output.
+With more than one FILE, precede each with a header giving the file name.
+With no FILE, or when FILE is -, read standard input.
+
+Options:
+  -n, --lines=NUM      output the last NUM lines, instead of the last 10
+  -c, --bytes=NUM      output the last NUM bytes
+  -q, --quiet          never output headers giving file names
+  -v, --verbose        always output headers giving file names
+"""
+
+from ...types import CommandContext, ExecResult
+
+
+class TailCommand:
+    """The tail command."""
+
+    name = "tail"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the tail command."""
+        num_lines = 10
+        num_bytes = None
+        quiet = False
+        verbose = False
+        from_start = False  # +NUM means from line NUM
+        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("--lines="):
+                val = arg[8:]
+                if val.startswith("+"):
+                    from_start = True
+                    val = val[1:]
+                try:
+                    num_lines = int(val)
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"tail: invalid number of lines: '{arg[8:]}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("--bytes="):
+                try:
+                    num_bytes = int(arg[8:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"tail: invalid number of bytes: '{arg[8:]}'\n",
+                        exit_code=1,
+                    )
+            elif arg == "--quiet" or arg == "-q":
+                quiet = True
+            elif arg == "--verbose" or arg == "-v":
+                verbose = True
+            elif arg.startswith("-n"):
+                if len(arg) > 2:
+                    val = arg[2:]
+                else:
+                    i += 1
+                    if i >= len(args):
+                        return ExecResult(
+                            stdout="",
+                            stderr="tail: option requires an argument -- 'n'\n",
+                            exit_code=1,
+                        )
+                    val = args[i]
+                if val.startswith("+"):
+                    from_start = True
+                    val = val[1:]
+                try:
+                    num_lines = int(val)
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"tail: invalid number of lines: '{val}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-c"):
+                if len(arg) > 2:
+                    val = arg[2:]
+                else:
+                    i += 1
+                    if i >= len(args):
+                        return ExecResult(
+                            stdout="",
+                            stderr="tail: option requires an argument -- 'c'\n",
+                            exit_code=1,
+                        )
+                    val = args[i]
+                try:
+                    num_bytes = int(val)
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"tail: invalid number of bytes: '{val}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("+") and len(arg) > 1:
+                # +NUM means from line NUM
+                try:
+                    num_lines = int(arg[1:])
+                    from_start = True
+                except ValueError:
+                    files.append(arg)
+            elif arg.startswith("-") and len(arg) > 1:
+                # Check for -NUM shorthand
+                try:
+                    num_lines = int(arg[1:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"tail: invalid option -- '{arg[1]}'\n",
+                        exit_code=1,
+                    )
+            else:
+                files.append(arg)
+            i += 1
+
+        # Default to stdin
+        if not files:
+            files = ["-"]
+
+        stdout = ""
+        stderr = ""
+        exit_code = 0
+        show_headers = (len(files) > 1 and not quiet) or verbose
+
+        for file_idx, file in enumerate(files):
+            try:
+                if file == "-":
+                    content = ctx.stdin
+                else:
+                    path = ctx.fs.resolve_path(ctx.cwd, file)
+                    content = await ctx.fs.read_file(path)
+
+                if show_headers:
+                    if file_idx > 0:
+                        stdout += "\n"
+                    stdout += f"==> {file} <==\n"
+
+                if num_bytes is not None:
+                    if from_start:
+                        stdout += content[num_bytes - 1:]
+                    else:
+                        stdout += content[-num_bytes:] if num_bytes > 0 else ""
+                else:
+                    lines = content.split("\n")
+                    # Handle the case where content ends with newline
+                    if lines and lines[-1] == "":
+                        lines = lines[:-1]
+
+                    if from_start:
+                        # +NUM means starting from line NUM (1-indexed)
+                        selected = lines[num_lines - 1:]
+                    else:
+                        selected = lines[-num_lines:] if num_lines > 0 else []
+
+                    stdout += "\n".join(selected)
+                    if selected:
+                        stdout += "\n"
+
+            except FileNotFoundError:
+                stderr += f"tail: cannot open '{file}' for reading: No such file or directory\n"
+                exit_code = 1
+            except IsADirectoryError:
+                stderr += f"tail: error reading '{file}': Is a directory\n"
+                exit_code = 1
+
+        return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)

just_bash/commands/tar/__init__.py

@@ -0,0 +1,5 @@
+"""Tar command."""
+
+from .tar import TarCommand
+
+__all__ = ["TarCommand"]