just-bash 0.1.5__py3-none-any.whl

just_bash/commands/tree/tree.py

@@ -0,0 +1,139 @@
+"""Tree command implementation."""
+
+from ...types import CommandContext, ExecResult
+
+
+class TreeCommand:
+    """The tree command - display directory tree."""
+
+    name = "tree"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the tree command."""
+        show_all = False
+        dirs_only = False
+        max_depth = None
+        show_full_path = False
+        paths: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "-a":
+                show_all = True
+            elif arg == "-d":
+                dirs_only = True
+            elif arg == "-L" and i + 1 < len(args):
+                i += 1
+                try:
+                    max_depth = int(args[i])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"tree: Invalid level: {args[i]}\n",
+                        exit_code=1,
+                    )
+            elif arg == "-f":
+                show_full_path = True
+            elif arg == "--help":
+                return ExecResult(
+                    stdout="Usage: tree [OPTIONS] [directory...]\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_dirs = 0
+        total_files = 0
+
+        for path in paths:
+            try:
+                resolved = ctx.fs.resolve_path(ctx.cwd, path)
+                stat = await ctx.fs.stat(resolved)
+
+                if not stat.is_directory:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"tree: {path}: Not a directory\n",
+                        exit_code=1,
+                    )
+
+                output_lines.append(path)
+                dirs, files = await self._tree(
+                    ctx, resolved, "", show_all, dirs_only,
+                    max_depth, 0, show_full_path, output_lines
+                )
+                total_dirs += dirs
+                total_files += files
+
+            except FileNotFoundError:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"tree: {path}: No such file or directory\n",
+                    exit_code=1,
+                )
+
+        output_lines.append("")
+        output_lines.append(f"{total_dirs} directories, {total_files} files")
+
+        return ExecResult(
+            stdout="\n".join(output_lines) + "\n",
+            stderr="",
+            exit_code=0,
+        )
+
+    async def _tree(
+        self, ctx: CommandContext, path: str, prefix: str,
+        show_all: bool, dirs_only: bool, max_depth: int | None,
+        current_depth: int, show_full_path: bool, output_lines: list[str]
+    ) -> tuple[int, int]:
+        """Recursively build tree output."""
+        if max_depth is not None and current_depth >= max_depth:
+            return 0, 0
+
+        entries = await ctx.fs.readdir(path)
+        entries = sorted(entries)
+
+        if not show_all:
+            entries = [e for e in entries if not e.startswith(".")]
+
+        dirs = 0
+        files = 0
+
+        for idx, entry in enumerate(entries):
+            is_last = idx == len(entries) - 1
+            connector = "└── " if is_last else "├── "
+            entry_path = f"{path}/{entry}"
+
+            try:
+                stat = await ctx.fs.stat(entry_path)
+
+                if dirs_only and not stat.is_directory:
+                    continue
+
+                display_name = entry_path if show_full_path else entry
+                output_lines.append(f"{prefix}{connector}{display_name}")
+
+                if stat.is_directory:
+                    dirs += 1
+                    new_prefix = prefix + ("    " if is_last else "│   ")
+                    sub_dirs, sub_files = await self._tree(
+                        ctx, entry_path, new_prefix, show_all, dirs_only,
+                        max_depth, current_depth + 1, show_full_path, output_lines
+                    )
+                    dirs += sub_dirs
+                    files += sub_files
+                else:
+                    files += 1
+            except Exception:
+                pass
+
+        return dirs, files

just_bash/commands/true/__init__.py

@@ -0,0 +1,5 @@
+"""True and false command implementations."""
+
+from .true import TrueCommand, FalseCommand
+
+__all__ = ["TrueCommand", "FalseCommand"]

just_bash/commands/true/true.py

@@ -0,0 +1,32 @@
+"""True and false command implementations.
+
+Usage: true
+       false
+
+true - do nothing, successfully
+false - do nothing, unsuccessfully
+
+Exit with a status code indicating success (true) or failure (false).
+"""
+
+from ...types import Command, CommandContext, ExecResult
+
+
+class TrueCommand:
+    """The true command - always succeeds."""
+
+    name = "true"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the true command."""
+        return ExecResult(stdout="", stderr="", exit_code=0)
+
+
+class FalseCommand:
+    """The false command - always fails."""
+
+    name = "false"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the false command."""
+        return ExecResult(stdout="", stderr="", exit_code=1)

just_bash/commands/uniq/__init__.py

@@ -0,0 +1,5 @@
+"""Uniq command implementation."""
+
+from .uniq import UniqCommand
+
+__all__ = ["UniqCommand"]

just_bash/commands/uniq/uniq.py

@@ -0,0 +1,323 @@
+"""Uniq command implementation.
+
+Usage: uniq [OPTION]... [INPUT [OUTPUT]]
+
+Filter adjacent matching lines from INPUT (or standard input),
+writing to OUTPUT (or standard output).
+
+Options:
+  -c, --count           prefix lines by the number of occurrences
+  -d, --repeated        only print duplicate lines, one for each group
+  -D                    print all duplicate lines
+  -i, --ignore-case     ignore differences in case when comparing
+  -u, --unique          only print unique lines
+  -s, --skip-chars=N    avoid comparing the first N characters
+  -w, --check-chars=N   compare no more than N characters in lines
+  -f, --skip-fields=N   avoid comparing the first N fields
+"""
+
+from ...types import CommandContext, ExecResult
+
+
+class UniqCommand:
+    """The uniq command."""
+
+    name = "uniq"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the uniq command."""
+        count = False
+        repeated = False
+        all_repeated = False
+        ignore_case = False
+        unique = False
+        skip_chars = 0
+        check_chars = 0  # 0 means no limit
+        skip_fields = 0
+        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 == "--count":
+                    count = True
+                elif arg == "--repeated":
+                    repeated = True
+                elif arg == "--ignore-case":
+                    ignore_case = True
+                elif arg == "--unique":
+                    unique = True
+                elif arg.startswith("--skip-chars="):
+                    try:
+                        skip_chars = int(arg[13:])
+                    except ValueError:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"uniq: invalid number of bytes to skip: '{arg[13:]}'\n",
+                            exit_code=1,
+                        )
+                elif arg.startswith("--check-chars="):
+                    try:
+                        check_chars = int(arg[14:])
+                    except ValueError:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"uniq: invalid number of bytes to compare: '{arg[14:]}'\n",
+                            exit_code=1,
+                        )
+                elif arg.startswith("--skip-fields="):
+                    try:
+                        skip_fields = int(arg[14:])
+                    except ValueError:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"uniq: invalid number of fields to skip: '{arg[14:]}'\n",
+                            exit_code=1,
+                        )
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"uniq: unrecognized option '{arg}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-") and arg != "-":
+                j = 1
+                while j < len(arg):
+                    c = arg[j]
+                    if c == "c":
+                        count = True
+                    elif c == "d":
+                        repeated = True
+                    elif c == "D":
+                        all_repeated = True
+                    elif c == "i":
+                        ignore_case = True
+                    elif c == "u":
+                        unique = True
+                    elif c == "s":
+                        # -s requires a value
+                        if j + 1 < len(arg):
+                            try:
+                                skip_chars = int(arg[j + 1:])
+                            except ValueError:
+                                return ExecResult(
+                                    stdout="",
+                                    stderr=f"uniq: invalid number of bytes to skip\n",
+                                    exit_code=1,
+                                )
+                            break
+                        elif i + 1 < len(args):
+                            i += 1
+                            try:
+                                skip_chars = int(args[i])
+                            except ValueError:
+                                return ExecResult(
+                                    stdout="",
+                                    stderr=f"uniq: invalid number of bytes to skip: '{args[i]}'\n",
+                                    exit_code=1,
+                                )
+                            break
+                        else:
+                            return ExecResult(
+                                stdout="",
+                                stderr="uniq: option requires an argument -- 's'\n",
+                                exit_code=1,
+                            )
+                    elif c == "w":
+                        # -w requires a value
+                        if j + 1 < len(arg):
+                            try:
+                                check_chars = int(arg[j + 1:])
+                            except ValueError:
+                                return ExecResult(
+                                    stdout="",
+                                    stderr=f"uniq: invalid number of bytes to compare\n",
+                                    exit_code=1,
+                                )
+                            break
+                        elif i + 1 < len(args):
+                            i += 1
+                            try:
+                                check_chars = int(args[i])
+                            except ValueError:
+                                return ExecResult(
+                                    stdout="",
+                                    stderr=f"uniq: invalid number of bytes to compare: '{args[i]}'\n",
+                                    exit_code=1,
+                                )
+                            break
+                        else:
+                            return ExecResult(
+                                stdout="",
+                                stderr="uniq: option requires an argument -- 'w'\n",
+                                exit_code=1,
+                            )
+                    elif c == "f":
+                        # -f requires a value
+                        if j + 1 < len(arg):
+                            try:
+                                skip_fields = int(arg[j + 1:])
+                            except ValueError:
+                                return ExecResult(
+                                    stdout="",
+                                    stderr=f"uniq: invalid number of fields to skip\n",
+                                    exit_code=1,
+                                )
+                            break
+                        elif i + 1 < len(args):
+                            i += 1
+                            try:
+                                skip_fields = int(args[i])
+                            except ValueError:
+                                return ExecResult(
+                                    stdout="",
+                                    stderr=f"uniq: invalid number of fields to skip: '{args[i]}'\n",
+                                    exit_code=1,
+                                )
+                            break
+                        else:
+                            return ExecResult(
+                                stdout="",
+                                stderr="uniq: option requires an argument -- 'f'\n",
+                                exit_code=1,
+                            )
+                    else:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"uniq: invalid option -- '{c}'\n",
+                            exit_code=1,
+                        )
+                    j += 1
+            else:
+                files.append(arg)
+            i += 1
+
+        # Get input
+        if len(files) == 0:
+            content = ctx.stdin
+        elif files[0] == "-":
+            content = ctx.stdin
+        else:
+            try:
+                path = ctx.fs.resolve_path(ctx.cwd, files[0])
+                content = await ctx.fs.read_file(path)
+            except FileNotFoundError:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"uniq: {files[0]}: No such file or directory\n",
+                    exit_code=1,
+                )
+
+        # Process lines
+        lines = content.split("\n")
+        # Remove trailing empty line if present
+        if lines and lines[-1] == "":
+            lines = lines[:-1]
+
+        def get_compare_key(line: str) -> str:
+            """Get the comparison key for a line."""
+            # Skip fields first
+            if skip_fields > 0:
+                parts = line.split()
+                line = " ".join(parts[skip_fields:]) if len(parts) > skip_fields else ""
+
+            # Skip characters
+            if skip_chars > 0:
+                line = line[skip_chars:]
+
+            # Limit check chars
+            if check_chars > 0:
+                line = line[:check_chars]
+
+            if ignore_case:
+                line = line.lower()
+
+            return line
+
+        # Group adjacent lines
+        groups: list[tuple[int, str]] = []  # (count, original_line)
+        prev_key = None
+        prev_line = None
+        count_val = 0
+
+        for line in lines:
+            key = get_compare_key(line)
+            if key == prev_key:
+                count_val += 1
+                if all_repeated:
+                    groups.append((1, line))
+            else:
+                if prev_line is not None:
+                    if not all_repeated:
+                        groups.append((count_val, prev_line))
+                prev_key = key
+                prev_line = line
+                count_val = 1
+                if all_repeated:
+                    # We'll add it later if it has duplicates
+                    pass
+
+        # Don't forget the last group
+        if prev_line is not None and not all_repeated:
+            groups.append((count_val, prev_line))
+
+        # For all_repeated (-D), we need to rebuild groups differently
+        if all_repeated:
+            groups = []
+            prev_key = None
+            current_group: list[str] = []
+
+            for line in lines:
+                key = get_compare_key(line)
+                if key == prev_key:
+                    current_group.append(line)
+                else:
+                    # Output previous group if it had duplicates
+                    if len(current_group) > 1:
+                        for l in current_group:
+                            groups.append((1, l))
+                    current_group = [line]
+                    prev_key = key
+
+            # Last group
+            if len(current_group) > 1:
+                for l in current_group:
+                    groups.append((1, l))
+
+        # Filter based on options
+        output_lines: list[str] = []
+        for cnt, line in groups:
+            if repeated and cnt < 2:
+                continue
+            if unique and cnt > 1:
+                continue
+
+            if count:
+                output_lines.append(f"{cnt:7d} {line}")
+            else:
+                output_lines.append(line)
+
+        # Generate output
+        stdout = "\n".join(output_lines)
+        if output_lines:
+            stdout += "\n"
+
+        # Write to output file if specified
+        if len(files) > 1 and files[1] != "-":
+            try:
+                path = ctx.fs.resolve_path(ctx.cwd, files[1])
+                await ctx.fs.write_file(path, stdout)
+                return ExecResult(stdout="", stderr="", exit_code=0)
+            except Exception as e:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"uniq: {files[1]}: {e}\n",
+                    exit_code=1,
+                )
+
+        return ExecResult(stdout=stdout, stderr="", exit_code=0)

just_bash/commands/wc/__init__.py

@@ -0,0 +1,5 @@
+"""Wc command implementation."""
+
+from .wc import WcCommand
+
+__all__ = ["WcCommand"]

just_bash/commands/wc/wc.py

@@ -0,0 +1,169 @@
+"""Wc command implementation.
+
+Usage: wc [OPTION]... [FILE]...
+
+Print newline, word, and byte counts for each FILE.
+With no FILE, or when FILE is -, read standard input.
+
+Options:
+  -c, --bytes      print the byte counts
+  -m, --chars      print the character counts
+  -l, --lines      print the newline counts
+  -w, --words      print the word counts
+  -L, --max-line-length  print the length of the longest line
+"""
+
+from ...types import CommandContext, ExecResult
+
+
+class WcCommand:
+    """The wc command."""
+
+    name = "wc"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the wc command."""
+        show_lines = False
+        show_words = False
+        show_bytes = False
+        show_chars = False
+        show_max_line = 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 == "--lines":
+                    show_lines = True
+                elif arg == "--words":
+                    show_words = True
+                elif arg == "--bytes":
+                    show_bytes = True
+                elif arg == "--chars":
+                    show_chars = True
+                elif arg == "--max-line-length":
+                    show_max_line = True
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"wc: unrecognized option '{arg}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-") and arg != "-":
+                for c in arg[1:]:
+                    if c == 'l':
+                        show_lines = True
+                    elif c == 'w':
+                        show_words = True
+                    elif c == 'c':
+                        show_bytes = True
+                    elif c == 'm':
+                        show_chars = True
+                    elif c == 'L':
+                        show_max_line = True
+                    else:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"wc: invalid option -- '{c}'\n",
+                            exit_code=1,
+                        )
+            else:
+                files.append(arg)
+            i += 1
+
+        # Default to all three counts if none specified
+        if not (show_lines or show_words or show_bytes or show_chars or show_max_line):
+            show_lines = True
+            show_words = True
+            show_bytes = True
+
+        # Default to stdin
+        if not files:
+            files = ["-"]
+
+        stdout = ""
+        stderr = ""
+        exit_code = 0
+
+        total_lines = 0
+        total_words = 0
+        total_bytes = 0
+        total_chars = 0
+        total_max_line = 0
+
+        for file in files:
+            try:
+                if file == "-":
+                    content = ctx.stdin
+                else:
+                    path = ctx.fs.resolve_path(ctx.cwd, file)
+                    content = await ctx.fs.read_file(path)
+
+                # Count lines (number of newlines)
+                lines = content.count("\n")
+                # Count words
+                words = len(content.split())
+                # Count bytes
+                bytes_count = len(content.encode("utf-8"))
+                # Count chars
+                chars = len(content)
+                # Max line length
+                max_line = max((len(line) for line in content.split("\n")), default=0)
+
+                total_lines += lines
+                total_words += words
+                total_bytes += bytes_count
+                total_chars += chars
+                total_max_line = max(total_max_line, max_line)
+
+                # Build output
+                # Use minimal formatting when only one counter is shown
+                num_counters = sum([show_lines, show_words, show_bytes, show_chars, show_max_line])
+                use_padding = num_counters > 1 or len(files) > 1
+
+                parts = []
+                if show_lines:
+                    parts.append(f"{lines:7d}" if use_padding else str(lines))
+                if show_words:
+                    parts.append(f"{words:7d}" if use_padding else str(words))
+                if show_bytes:
+                    parts.append(f"{bytes_count:7d}" if use_padding else str(bytes_count))
+                if show_chars:
+                    parts.append(f"{chars:7d}" if use_padding else str(chars))
+                if show_max_line:
+                    parts.append(f"{max_line:7d}" if use_padding else str(max_line))
+
+                # Don't show filename for stdin when it's the only file
+                if file == "-" and len(files) == 1:
+                    stdout += " ".join(parts) + "\n"
+                else:
+                    stdout += " ".join(parts) + f" {file}\n"
+
+            except FileNotFoundError:
+                stderr += f"wc: {file}: No such file or directory\n"
+                exit_code = 1
+            except IsADirectoryError:
+                stderr += f"wc: {file}: Is a directory\n"
+                exit_code = 1
+
+        # Print total if multiple files
+        if len(files) > 1:
+            parts = []
+            if show_lines:
+                parts.append(f"{total_lines:7d}")
+            if show_words:
+                parts.append(f"{total_words:7d}")
+            if show_bytes:
+                parts.append(f"{total_bytes:7d}")
+            if show_chars:
+                parts.append(f"{total_chars:7d}")
+            if show_max_line:
+                parts.append(f"{total_max_line:7d}")
+            stdout += " ".join(parts) + " total\n"
+
+        return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)

just_bash/commands/which/__init__.py

@@ -0,0 +1,5 @@
+"""Which command."""
+
+from .which import WhichCommand
+
+__all__ = ["WhichCommand"]