just-bash 0.1.5__py3-none-any.whl

just_bash/commands/rm/__init__.py

@@ -0,0 +1,5 @@
+"""Rm command implementation."""
+
+from .rm import RmCommand
+
+__all__ = ["RmCommand"]

just_bash/commands/rm/rm.py

@@ -0,0 +1,106 @@
+"""Rm command implementation.
+
+Usage: rm [OPTION]... FILE...
+
+Remove (unlink) the FILE(s).
+
+Options:
+  -f, --force     ignore nonexistent files and arguments
+  -r, -R, --recursive  remove directories and their contents recursively
+  -v, --verbose   explain what is being done
+"""
+
+from ...types import CommandContext, ExecResult
+
+
+class RmCommand:
+    """The rm command."""
+
+    name = "rm"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the rm command."""
+        force = False
+        recursive = 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("--"):
+                if arg == "--force":
+                    force = True
+                elif arg == "--recursive":
+                    recursive = True
+                elif arg == "--verbose":
+                    verbose = True
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"rm: unrecognized option '{arg}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-") and arg != "-":
+                for c in arg[1:]:
+                    if c == "f":
+                        force = True
+                    elif c in ("r", "R"):
+                        recursive = True
+                    elif c == "v":
+                        verbose = True
+                    else:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"rm: invalid option -- '{c}'\n",
+                            exit_code=1,
+                        )
+            else:
+                files.append(arg)
+            i += 1
+
+        if not files:
+            return ExecResult(
+                stdout="",
+                stderr="rm: missing operand\n",
+                exit_code=1,
+            )
+
+        stdout = ""
+        stderr = ""
+        exit_code = 0
+
+        for f in files:
+            try:
+                path = ctx.fs.resolve_path(ctx.cwd, f)
+
+                # Check if it's a directory
+                try:
+                    st = await ctx.fs.stat(path)
+                    if st.is_directory and not recursive:
+                        stderr += f"rm: cannot remove '{f}': Is a directory\n"
+                        exit_code = 1
+                        continue
+                except FileNotFoundError:
+                    if force:
+                        continue
+                    stderr += f"rm: cannot remove '{f}': No such file or directory\n"
+                    exit_code = 1
+                    continue
+
+                await ctx.fs.rm(path, recursive=recursive, force=force)
+                if verbose:
+                    stdout += f"removed '{f}'\n"
+            except FileNotFoundError:
+                if not force:
+                    stderr += f"rm: cannot remove '{f}': No such file or directory\n"
+                    exit_code = 1
+            except OSError as e:
+                stderr += f"rm: cannot remove '{f}': {e}\n"
+                exit_code = 1
+
+        return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)

just_bash/commands/search_engine/__init__.py

@@ -0,0 +1,13 @@
+"""Search engine utility module for grep and rg commands."""
+
+from .matcher import SearchOptions, SearchResult, search_content
+from .regex import RegexMode, build_regex, convert_replacement
+
+__all__ = [
+    "RegexMode",
+    "build_regex",
+    "convert_replacement",
+    "SearchOptions",
+    "SearchResult",
+    "search_content",
+]

just_bash/commands/search_engine/matcher.py

@@ -0,0 +1,170 @@
+"""Content searching and matching utilities."""
+
+import re
+from dataclasses import dataclass
+
+
+@dataclass
+class SearchOptions:
+    """Options for content searching."""
+
+    invert_match: bool = False
+    show_line_numbers: bool = False
+    count_only: bool = False
+    only_matching: bool = False
+    filename: str | None = None
+    before_context: int = 0
+    after_context: int = 0
+    max_count: int | None = None
+    replace: str | None = None
+    multiline: bool = False
+
+
+@dataclass
+class SearchResult:
+    """Result of a content search."""
+
+    output: str
+    matched: bool
+    match_count: int
+
+
+def search_content(
+    content: str,
+    regex: re.Pattern,
+    options: SearchOptions = None,
+) -> SearchResult:
+    """Search content and return formatted output.
+
+    Args:
+        content: The text content to search
+        regex: Compiled regex pattern to search for
+        options: Search options (defaults to SearchOptions())
+
+    Returns:
+        SearchResult with output, matched flag, and match count
+    """
+    if options is None:
+        options = SearchOptions()
+
+    lines = content.split("\n")
+    # Handle trailing empty line from split
+    if lines and lines[-1] == "":
+        lines = lines[:-1]
+
+    # Track matches
+    matches: list[tuple[int, str, list[re.Match]]] = []
+    match_count = 0
+
+    # Find all matching lines
+    for line_num, line in enumerate(lines, 1):
+        line_matches = list(regex.finditer(line))
+        is_match = bool(line_matches)
+
+        if options.invert_match:
+            is_match = not is_match
+
+        if is_match:
+            if options.invert_match:
+                matches.append((line_num, line, []))
+            else:
+                matches.append((line_num, line, line_matches))
+                match_count += len(line_matches)
+
+            # Check max count
+            if options.max_count is not None and len(matches) >= options.max_count:
+                break
+
+    if not matches:
+        return SearchResult(output="", matched=False, match_count=0)
+
+    # For count_only, just return the count info
+    if options.count_only:
+        return SearchResult(
+            output=str(len(matches)),
+            matched=True,
+            match_count=match_count,
+        )
+
+    # Build output with context
+    output_lines: list[str] = []
+
+    if options.before_context > 0 or options.after_context > 0:
+        # Collect all lines to output (including context)
+        lines_to_show: dict[int, tuple[str, bool]] = {}  # line_num -> (content, is_match)
+
+        for line_num, line, line_matches in matches:
+            # Add context before
+            for ctx_num in range(max(1, line_num - options.before_context), line_num):
+                if ctx_num not in lines_to_show:
+                    lines_to_show[ctx_num] = (lines[ctx_num - 1], False)
+            # Add the match line
+            lines_to_show[line_num] = (line, True)
+            # Add context after
+            end_ctx = min(len(lines) + 1, line_num + options.after_context + 1)
+            for ctx_num in range(line_num + 1, end_ctx):
+                if ctx_num not in lines_to_show:
+                    lines_to_show[ctx_num] = (lines[ctx_num - 1], False)
+
+        # Output in order
+        for line_num in sorted(lines_to_show.keys()):
+            line_content, is_match = lines_to_show[line_num]
+            sep = ":" if is_match else "-"
+
+            if options.only_matching and is_match:
+                # For context lines with only_matching, we don't output them
+                # But for simplicity, include all for now
+                pass
+
+            output_line = _format_line(
+                line_num, line_content, options, sep=sep
+            )
+            output_lines.append(output_line)
+    else:
+        # Normal output without context
+        for line_num, line, line_matches in matches:
+            if options.only_matching and line_matches:
+                # Output each match separately
+                for m in line_matches:
+                    output_line = _format_line(
+                        line_num, m.group(0), options
+                    )
+                    output_lines.append(output_line)
+            else:
+                # Handle replacement
+                output_text = line
+                if options.replace is not None and line_matches:
+                    output_text = regex.sub(options.replace, line)
+
+                output_line = _format_line(line_num, output_text, options)
+                output_lines.append(output_line)
+
+    output = "\n".join(output_lines)
+    if output:
+        output += "\n"
+
+    return SearchResult(
+        output=output,
+        matched=True,
+        match_count=match_count,
+    )
+
+
+def _format_line(
+    line_num: int,
+    content: str,
+    options: SearchOptions,
+    sep: str = ":",
+) -> str:
+    """Format a single output line with optional prefix."""
+    parts = []
+
+    if options.filename:
+        parts.append(f"{options.filename}{sep}")
+
+    if options.show_line_numbers:
+        parts.append(f"{line_num}{sep}")
+
+    parts.append(content)
+
+    return "".join(parts)

just_bash/commands/search_engine/regex.py

@@ -0,0 +1,159 @@
+"""Regex pattern building utilities for search commands."""
+
+import re
+from enum import Enum
+
+
+class RegexMode(Enum):
+    """Regex interpretation modes."""
+
+    BASIC = "basic"       # BRE - escape +?|(){}
+    EXTENDED = "extended"  # ERE - standard regex
+    FIXED = "fixed"       # Literal string matching
+    PERL = "perl"         # PCRE (Python default)
+
+
+def build_regex(
+    pattern: str,
+    mode: RegexMode = RegexMode.EXTENDED,
+    ignore_case: bool = False,
+    whole_word: bool = False,
+    line_regexp: bool = False,
+    multiline: bool = False,
+) -> re.Pattern:
+    """Build a compiled regex from pattern with options.
+
+    Args:
+        pattern: The search pattern
+        mode: How to interpret the pattern (basic, extended, fixed, perl)
+        ignore_case: Case-insensitive matching
+        whole_word: Match whole words only (add word boundaries)
+        line_regexp: Match entire lines (anchor to line start/end)
+        multiline: Enable multiline mode for ^ and $
+
+    Returns:
+        Compiled regex pattern
+    """
+    # Process pattern based on mode
+    if mode == RegexMode.FIXED:
+        # Escape all regex metacharacters for literal matching
+        pattern = re.escape(pattern)
+    elif mode == RegexMode.BASIC:
+        # BRE mode: +?|(){} are literal unless escaped
+        # Convert BRE to ERE by escaping these chars
+        # In BRE, \+ means one-or-more, + means literal +
+        # We need to swap the meaning
+        pattern = _convert_bre_to_ere(pattern)
+    # EXTENDED and PERL modes use pattern as-is (Python re is PCRE-like)
+
+    # Apply word boundaries
+    if whole_word:
+        pattern = r"\b(?:" + pattern + r")\b"
+
+    # Apply line anchors
+    if line_regexp:
+        pattern = "^(?:" + pattern + ")$"
+
+    # Build flags
+    flags = 0
+    if ignore_case:
+        flags |= re.IGNORECASE
+    if multiline:
+        flags |= re.MULTILINE
+
+    return re.compile(pattern, flags)
+
+
+def _convert_bre_to_ere(pattern: str) -> str:
+    """Convert Basic Regular Expression to Extended Regular Expression.
+
+    In BRE, characters like +, ?, |, (, ), {, } are literal unless escaped.
+    In ERE (Python's default), they are special unless escaped.
+
+    This function escapes these characters so they're treated as literals.
+    """
+    # Characters that are special in ERE but literal in BRE
+    literal_chars = "+?|(){}[]"
+
+    result = []
+    i = 0
+    while i < len(pattern):
+        char = pattern[i]
+
+        if char == "\\" and i + 1 < len(pattern):
+            next_char = pattern[i + 1]
+            # In BRE, \+ means one-or-more (special)
+            # So we should NOT escape it (keep as +)
+            if next_char in literal_chars:
+                result.append(next_char)
+                i += 2
+                continue
+            else:
+                # Keep other escape sequences as-is
+                result.append(char)
+                result.append(next_char)
+                i += 2
+                continue
+        elif char in literal_chars:
+            # Literal in BRE, so escape for ERE
+            result.append("\\" + char)
+        else:
+            result.append(char)
+        i += 1
+
+    return "".join(result)
+
+
+def convert_replacement(replacement: str) -> str:
+    """Convert sed/ripgrep-style replacement to Python re.sub format.
+
+    Converts:
+        $0 -> \\g<0>  (full match)
+        $1, $2, ... -> \\1, \\2, ...  (numbered groups)
+        $name -> \\g<name>  (named groups)
+
+    Args:
+        replacement: The replacement string with $ references
+
+    Returns:
+        Replacement string with Python-style backreferences
+    """
+    result = []
+    i = 0
+    while i < len(replacement):
+        char = replacement[i]
+
+        if char == "$" and i + 1 < len(replacement):
+            next_char = replacement[i + 1]
+
+            # $0 - full match (needs \g<0> syntax)
+            if next_char == "0":
+                result.append(r"\g<0>")
+                i += 2
+                continue
+
+            # $1-9 - numbered groups
+            if next_char.isdigit():
+                # Collect all digits
+                j = i + 1
+                while j < len(replacement) and replacement[j].isdigit():
+                    j += 1
+                num = replacement[i + 1:j]
+                result.append("\\" + num)
+                i = j
+                continue
+
+            # $name - named groups
+            if next_char.isalpha() or next_char == "_":
+                j = i + 1
+                while j < len(replacement) and (replacement[j].isalnum() or replacement[j] == "_"):
+                    j += 1
+                name = replacement[i + 1:j]
+                result.append(r"\g<" + name + ">")
+                i = j
+                continue
+
+        result.append(char)
+        i += 1
+
+    return "".join(result)

just_bash/commands/sed/__init__.py

@@ -0,0 +1,5 @@
+"""Sed command implementation."""
+
+from .sed import SedCommand
+
+__all__ = ["SedCommand"]