just-bash 0.1.5__py3-none-any.whl

just_bash/commands/head/head.py

@@ -0,0 +1,167 @@
+"""Head command implementation.
+
+Usage: head [OPTION]... [FILE]...
+
+Print the first 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      print the first NUM lines instead of the first 10
+  -c, --bytes=NUM      print the first NUM bytes
+  -q, --quiet          never print headers giving file names
+  -v, --verbose        always print headers giving file names
+"""
+
+from ...types import CommandContext, ExecResult
+
+
+class HeadCommand:
+    """The head command."""
+
+    name = "head"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the head command."""
+        num_lines = 10
+        num_bytes = None
+        quiet = False
+        verbose = 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("--lines="):
+                try:
+                    num_lines = int(arg[8:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"head: 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"head: 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:
+                    try:
+                        num_lines = int(arg[2:])
+                    except ValueError:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"head: invalid number of lines: '{arg[2:]}'\n",
+                            exit_code=1,
+                        )
+                else:
+                    i += 1
+                    if i >= len(args):
+                        return ExecResult(
+                            stdout="",
+                            stderr="head: option requires an argument -- 'n'\n",
+                            exit_code=1,
+                        )
+                    try:
+                        num_lines = int(args[i])
+                    except ValueError:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"head: invalid number of lines: '{args[i]}'\n",
+                            exit_code=1,
+                        )
+            elif arg.startswith("-c"):
+                if len(arg) > 2:
+                    try:
+                        num_bytes = int(arg[2:])
+                    except ValueError:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"head: invalid number of bytes: '{arg[2:]}'\n",
+                            exit_code=1,
+                        )
+                else:
+                    i += 1
+                    if i >= len(args):
+                        return ExecResult(
+                            stdout="",
+                            stderr="head: option requires an argument -- 'c'\n",
+                            exit_code=1,
+                        )
+                    try:
+                        num_bytes = int(args[i])
+                    except ValueError:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"head: invalid number of bytes: '{args[i]}'\n",
+                            exit_code=1,
+                        )
+            elif arg.startswith("-") and len(arg) > 1:
+                # Check for -NUM shorthand
+                try:
+                    num_lines = int(arg[1:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"head: 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:
+                    stdout += content[:num_bytes]
+                else:
+                    lines = content.split("\n")
+                    # Handle the case where content ends with newline
+                    if lines and lines[-1] == "":
+                        lines = lines[:-1]
+                    stdout += "\n".join(lines[:num_lines])
+                    if lines[:num_lines]:
+                        stdout += "\n"
+
+            except FileNotFoundError:
+                stderr += f"head: cannot open '{file}' for reading: No such file or directory\n"
+                exit_code = 1
+            except IsADirectoryError:
+                stderr += f"head: error reading '{file}': Is a directory\n"
+                exit_code = 1
+
+        return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)

just_bash/commands/help/__init__.py

@@ -0,0 +1,5 @@
+"""Help command."""
+
+from .help import HelpCommand
+
+__all__ = ["HelpCommand"]

just_bash/commands/help/help.py

@@ -0,0 +1,67 @@
+"""Help command implementation."""
+
+from ..registry import COMMAND_NAMES
+from ...types import CommandContext, ExecResult
+
+
+class HelpCommand:
+    """The help command - display help for commands."""
+
+    name = "help"
+
+    # Command categories
+    CATEGORIES = {
+        "File operations": ["ls", "cat", "cp", "mv", "rm", "mkdir", "touch", "chmod", "ln", "readlink", "stat", "file"],
+        "Text processing": ["grep", "sed", "awk", "cut", "tr", "sort", "uniq", "head", "tail", "wc", "nl", "rev", "tac", "paste"],
+        "Search": ["find", "rg"],
+        "Data processing": ["jq", "base64", "diff"],
+        "Utilities": ["echo", "printf", "date", "sleep", "timeout", "seq", "expr", "xargs", "tee"],
+        "Path utilities": ["basename", "dirname", "pwd"],
+        "Directory info": ["tree", "du"],
+        "Environment": ["env", "printenv", "hostname"],
+        "Shell": ["true", "false", "which", "help"],
+    }
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the help command."""
+        if "--help" in args or "-h" in args:
+            return ExecResult(
+                stdout="Usage: help [COMMAND]\n\nShow help for commands.\n",
+                stderr="",
+                exit_code=0,
+            )
+
+        # Check for specific command
+        for arg in args:
+            if not arg.startswith("-"):
+                return self._help_for_command(arg)
+
+        # Show general help
+        lines = ["Available commands:", ""]
+
+        for category, cmds in self.CATEGORIES.items():
+            available = [c for c in cmds if c in COMMAND_NAMES]
+            if available:
+                lines.append(f"{category}:")
+                lines.append(f"  {', '.join(available)}")
+                lines.append("")
+
+        lines.append("Use 'COMMAND --help' for more information about a command.")
+
+        return ExecResult(stdout="\n".join(lines) + "\n", stderr="", exit_code=0)
+
+    def _help_for_command(self, cmd: str) -> ExecResult:
+        """Show help for a specific command."""
+        if cmd not in COMMAND_NAMES:
+            return ExecResult(
+                stdout="",
+                stderr=f"help: no help topics match '{cmd}'.\n",
+                exit_code=127,
+            )
+
+        # Basic help - suggest using --help
+        return ExecResult(
+            stdout=f"{cmd}: Use '{cmd} --help' for detailed usage information.\n",
+            stderr="",
+            exit_code=0,
+        )

just_bash/commands/hostname/__init__.py

@@ -0,0 +1,5 @@
+"""Hostname command."""
+
+from .hostname import HostnameCommand
+
+__all__ = ["HostnameCommand"]

just_bash/commands/hostname/hostname.py

@@ -0,0 +1,21 @@
+"""Hostname command implementation."""
+
+from ...types import CommandContext, ExecResult
+
+
+class HostnameCommand:
+    """The hostname command."""
+
+    name = "hostname"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the hostname command."""
+        if "--help" in args:
+            return ExecResult(
+                stdout="Usage: hostname [OPTION]...\n",
+                stderr="",
+                exit_code=0,
+            )
+
+        # Return localhost in sandboxed environment
+        return ExecResult(stdout="localhost\n", stderr="", exit_code=0)

just_bash/commands/html_to_markdown/__init__.py

@@ -0,0 +1,5 @@
+"""HTML to Markdown conversion command."""
+
+from .html_to_markdown import HtmlToMarkdownCommand
+
+__all__ = ["HtmlToMarkdownCommand"]

just_bash/commands/html_to_markdown/html_to_markdown.py

@@ -0,0 +1,191 @@
+"""HTML to Markdown conversion command implementation."""
+
+import re
+
+from ...types import CommandContext, ExecResult
+
+
+class HtmlToMarkdownCommand:
+    """The html-to-markdown command - convert HTML to Markdown."""
+
+    name = "html-to-markdown"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the html-to-markdown command."""
+        try:
+            from markdownify import markdownify
+        except ImportError:
+            return ExecResult(
+                stdout="",
+                stderr="html-to-markdown: markdownify package not installed\n",
+                exit_code=1,
+            )
+
+        # Parse options
+        bullet_char = "-"
+        code_fence = "```"
+        hr_style = "---"
+        heading_style = "atx"
+        file_path = None
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+
+            if arg == "--help" or arg == "-h":
+                return ExecResult(
+                    stdout=self._get_help(),
+                    stderr="",
+                    exit_code=0,
+                )
+
+            # Handle -b/--bullet
+            if arg == "-b" and i + 1 < len(args):
+                bullet_char = args[i + 1]
+                i += 2
+                continue
+            if arg.startswith("--bullet="):
+                bullet_char = arg[9:]
+                i += 1
+                continue
+
+            # Handle -c/--code
+            if arg == "-c" and i + 1 < len(args):
+                code_fence = args[i + 1]
+                i += 2
+                continue
+            if arg.startswith("--code="):
+                code_fence = arg[7:]
+                i += 1
+                continue
+
+            # Handle -r/--hr
+            if arg == "-r" and i + 1 < len(args):
+                hr_style = args[i + 1]
+                i += 2
+                continue
+            if arg.startswith("--hr="):
+                hr_style = arg[5:]
+                i += 1
+                continue
+
+            # Handle --heading-style
+            if arg.startswith("--heading-style="):
+                heading_style = arg[16:]
+                i += 1
+                continue
+
+            # Non-option argument is the file path
+            if not arg.startswith("-") or arg == "-":
+                file_path = arg
+                i += 1
+                continue
+
+            i += 1
+
+        # Get input content
+        if file_path is None or file_path == "-":
+            # Read from stdin
+            html_content = ctx.stdin or ""
+        else:
+            # Read from file
+            abs_path = self._resolve_path(file_path, ctx.cwd)
+            if not await ctx.fs.exists(abs_path):
+                return ExecResult(
+                    stdout="",
+                    stderr=f"html-to-markdown: {file_path}: No such file or directory\n",
+                    exit_code=1,
+                )
+            stat = await ctx.fs.stat(abs_path)
+            if stat and stat.is_directory:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"html-to-markdown: {file_path}: Is a directory\n",
+                    exit_code=1,
+                )
+            html_content = await ctx.fs.read_file(abs_path)
+
+        # Strip script, style, and footer elements before conversion
+        html_content = self._strip_elements(html_content)
+
+        # Convert HTML to Markdown
+        try:
+            # Configure markdownify options
+            markdown = markdownify(
+                html_content,
+                bullets=bullet_char,
+                code_language_callback=None,
+                heading_style=heading_style.upper() if heading_style == "atx" else heading_style,
+                strip=["script", "style", "footer"],
+            )
+
+            # Post-process: apply code fence style and hr style
+            markdown = self._apply_code_fence(markdown, code_fence)
+            markdown = self._apply_hr_style(markdown, hr_style)
+
+            # Trim and ensure trailing newline
+            result = markdown.strip()
+            if result:
+                result += "\n"
+
+            return ExecResult(stdout=result, stderr="", exit_code=0)
+
+        except Exception as e:
+            return ExecResult(
+                stdout="",
+                stderr=f"html-to-markdown: conversion error: {e}\n",
+                exit_code=1,
+            )
+
+    def _resolve_path(self, path: str, cwd: str) -> str:
+        """Resolve a path relative to cwd."""
+        if path.startswith("/"):
+            return path
+        if cwd.endswith("/"):
+            return cwd + path
+        return cwd + "/" + path
+
+    def _strip_elements(self, html: str) -> str:
+        """Strip script, style, and footer elements from HTML."""
+        # Remove script tags and their content
+        html = re.sub(r"<script[^>]*>.*?</script>", "", html, flags=re.DOTALL | re.IGNORECASE)
+        # Remove style tags and their content
+        html = re.sub(r"<style[^>]*>.*?</style>", "", html, flags=re.DOTALL | re.IGNORECASE)
+        # Remove footer tags and their content
+        html = re.sub(r"<footer[^>]*>.*?</footer>", "", html, flags=re.DOTALL | re.IGNORECASE)
+        return html
+
+    def _apply_code_fence(self, markdown: str, fence: str) -> str:
+        """Replace default code fences with the specified style."""
+        # Replace ``` with the specified fence
+        if fence != "```":
+            # Only replace fences that are on their own line
+            markdown = re.sub(r"^```", fence, markdown, flags=re.MULTILINE)
+        return markdown
+
+    def _apply_hr_style(self, markdown: str, hr_style: str) -> str:
+        """Replace default horizontal rules with the specified style."""
+        # Markdownify uses ___ or --- or *** for hr
+        # Replace common patterns
+        markdown = re.sub(r"^___$", hr_style, markdown, flags=re.MULTILINE)
+        markdown = re.sub(r"^\*\*\*$", hr_style, markdown, flags=re.MULTILINE)
+        # Don't replace --- if it's already the style
+        if hr_style != "---":
+            markdown = re.sub(r"^---$", hr_style, markdown, flags=re.MULTILINE)
+        return markdown
+
+    def _get_help(self) -> str:
+        """Return help text."""
+        return """Usage: html-to-markdown [OPTIONS] [FILE]
+
+Convert HTML to Markdown.
+
+Options:
+  -b, --bullet=CHAR     Bullet character for unordered lists (default: -)
+  -c, --code=FENCE      Code fence style (default: ```)
+  -r, --hr=STRING       Horizontal rule string (default: ---)
+  --heading-style=STYLE Heading style: atx or setext (default: atx)
+  -h, --help            Show this help message
+
+If FILE is omitted or is -, read from standard input.
+"""

just_bash/commands/join/__init__.py

@@ -0,0 +1,5 @@
+"""Join command."""
+
+from .join import JoinCommand
+
+__all__ = ["JoinCommand"]