zrb 1.21.29__py3-none-any.whl → 2.0.0a4__py3-none-any.whl

zrb/util/ascii_art/banner.py

@@ -0,0 +1,92 @@
+import os
+import random
+
+
+def create_banner(art: str | None = None, text: str | None = None) -> str:
+    # First get art using _get_art_only
+    art_content = _get_art_only(art)
+
+    # If no text provided, just return the art
+    if text is None or text.strip() == "":
+        return art_content
+
+    # Find the longest line in the art, make every line has the same length
+    art_lines = art_content.splitlines()
+    if not art_lines:
+        return text
+
+    # Find the maximum line length in the art
+    max_art_length = max(len(line) for line in art_lines)
+
+    # Pad all art lines to the same length
+    padded_art_lines = [line.ljust(max_art_length) for line in art_lines]
+
+    # Split text into lines
+    text_lines = text.splitlines()
+
+    # Combine art and text lines
+    combined_lines = []
+
+    # Determine the maximum number of lines we need
+    max_lines = max(len(padded_art_lines), len(text_lines))
+
+    # Calculate vertical offsets for centering
+    art_offset = (max_lines - len(padded_art_lines)) // 2
+    text_offset = (max_lines - len(text_lines)) // 2
+
+    for i in range(max_lines):
+        # Get art line (or empty string if we've run out of art lines)
+        art_index = i - art_offset
+        if 0 <= art_index < len(padded_art_lines):
+            art_line = padded_art_lines[art_index]
+        else:
+            art_line = " " * max_art_length
+
+        # Get text line (or empty string if we've run out of text lines)
+        text_index = i - text_offset
+        if 0 <= text_index < len(text_lines):
+            text_line = text_lines[text_index]
+        else:
+            text_line = ""
+
+        # Combine art and text lines
+        combined_line = art_line + "  " + text_line
+        combined_lines.append(combined_line)
+
+    # Return the combined result
+    return "\n".join(combined_lines)
+
+
+def _get_art_only(art: str | None = None) -> str:
+    # If name is provided
+    if art is not None:
+        # 1) name is a file, load the content of the file, return
+        expanded_name = os.path.expanduser(art)
+        if os.path.isfile(expanded_name):
+            with open(expanded_name, "r") as f:
+                return f.read()
+
+        # 2) name is a string, but not a file
+        # Check if art/name.txt exists in the script directory
+        cwd = os.path.dirname(__file__)
+        art_path = os.path.join(cwd, "art", f"{art}.txt")
+        if os.path.isfile(art_path):
+            with open(art_path, "r") as f:
+                return f.read()
+
+    # 3) otherwise load random file from art/ directory
+    cwd = os.path.dirname(__file__)
+    art_dir = os.path.join(cwd, "art")
+    # Get all .txt files in the art directory
+    try:
+        art_files = [f for f in os.listdir(art_dir) if f.endswith(".txt")]
+    except FileNotFoundError:
+        # If art directory doesn't exist, return empty string
+        return ""
+    if not art_files:
+        return ""
+    # Select a random file
+    random_file = random.choice(art_files)
+    random_file_path = os.path.join(art_dir, random_file)
+    with open(random_file_path, "r") as f:
+        return f.read()

zrb/util/cli/markdown.py

@@ -1,11 +1,31 @@
-def render_markdown(markdown_text: str) -> str:
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from rich.theme import Theme
+
+
+def render_markdown(
+    markdown_text: str, width: int | None = None, theme: "Theme | None" = None
+) -> str:
     """
     Renders Markdown to a string, ensuring link URLs are visible.
     """
     from rich.console import Console
     from rich.markdown import Markdown
+    from rich.theme import Theme
+
+    if theme is None:
+        theme = Theme(
+            {
+                "markdown.link": "bold bright_cyan underline",
+                "markdown.link_url": "italic bright_cyan underline",
+                # Optional: You can customize headers or code blocks here too
+                "markdown.h1": "bold magenta",
+                "markdown.code": "bold white on #333333",
+            }
+        )
 
-    console = Console()
+    console = Console(width=width, theme=theme, force_terminal=True)
     markdown = Markdown(markdown_text, hyperlinks=False)
     with console.capture() as capture:
         console.print(markdown)

zrb/util/cmd/command.py

@@ -5,7 +5,7 @@ import signal
 import sys
 from collections import deque
 from collections.abc import Callable
-from typing import TextIO
+from typing import Any, TextIO
 
 import psutil
 
@@ -62,6 +62,8 @@ async def run_command(
     register_pid_method: Callable[[int], None] | None = None,
     max_output_line: int = 1000,
     max_error_line: int = 1000,
+    max_display_line: int | None = None,
+    timeout: int = 3600,
     is_interactive: bool = False,
 ) -> tuple[CmdResult, int]:
     """
@@ -77,6 +79,8 @@ async def run_command(
     actual_print_method = print_method if print_method is not None else print
     if cwd is None:
         cwd = os.getcwd()
+    if max_display_line is None:
+        max_display_line = max(max_output_line, max_error_line)
     # While environment variables alone weren't the fix, they are still
     # good practice for encouraging simpler output from tools.
     child_env = (env_map or os.environ).copy()
@@ -95,17 +99,33 @@ async def run_command(
     if register_pid_method is not None:
         register_pid_method(cmd_process.pid)
     # Use the new, simple, and correct stream reader.
+    display_lines = deque(maxlen=max_display_line if max_display_line > 0 else 0)
     stdout_task = asyncio.create_task(
-        __read_stream(cmd_process.stdout, actual_print_method, max_output_line)
+        __read_stream(
+            cmd_process.stdout, actual_print_method, max_output_line, display_lines
+        )
     )
     stderr_task = asyncio.create_task(
-        __read_stream(cmd_process.stderr, actual_print_method, max_error_line)
+        __read_stream(
+            cmd_process.stderr, actual_print_method, max_error_line, display_lines
+        )
+    )
+    timeout_task = (
+        asyncio.create_task(asyncio.sleep(timeout)) if timeout and timeout > 0 else None
     )
     try:
-        return_code = await cmd_process.wait()
+        wait_task = asyncio.create_task(cmd_process.wait())
+        done, pending = await asyncio.wait(
+            {wait_task, timeout_task} if timeout_task else {wait_task},
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+        if timeout_task and timeout_task in done:
+            raise asyncio.TimeoutError()
+        return_code = wait_task.result()
         stdout, stderr = await asyncio.gather(stdout_task, stderr_task)
-        return CmdResult(stdout, stderr), return_code
-    except (KeyboardInterrupt, asyncio.CancelledError):
+        display = "\r\n".join(display_lines)
+        return CmdResult(stdout, stderr, display=display), return_code
+    except (KeyboardInterrupt, asyncio.CancelledError, asyncio.TimeoutError):
         try:
             os.killpg(cmd_process.pid, signal.SIGINT)
             await asyncio.wait_for(cmd_process.wait(), timeout=2.0)
@@ -133,13 +153,14 @@ def __get_cmd_stdin(is_interactive: bool) -> int | TextIO:
 async def __read_stream(
     stream: asyncio.StreamReader,
     print_method: Callable[..., None],
-    max_lines: int,
+    max_line: int,
+    display_queue: deque[Any],
 ) -> str:
     """
     Reads from the stream using the robust `readline()` and correctly
     interprets carriage returns (`\r`) as distinct print events.
     """
-    captured_lines = deque(maxlen=max_lines if max_lines > 0 else 0)
+    captured_lines = deque(maxlen=max_line if max_line > 0 else 0)
     while True:
         try:
             line_bytes = await stream.readline()
@@ -149,8 +170,9 @@ async def __read_stream(
             # Safety valve for the memory limit.
             error_msg = "[ERROR] A single line of output was too long to process."
             print_method(error_msg)
-            if max_lines > 0:
+            if max_line > 0:
                 captured_lines.append(error_msg)
+                display_queue.append(error_msg)
             break
         except (KeyboardInterrupt, asyncio.CancelledError):
             raise
@@ -165,8 +187,9 @@ async def __read_stream(
                     print_method(clean_part, end="\r\n")
                 except Exception:
                     print_method(clean_part)
-                if max_lines > 0:
+                if max_line > 0:
                     captured_lines.append(clean_part)
+                    display_queue.append(clean_part)
     return "\r\n".join(captured_lines)
 
 

zrb/util/file.py

@@ -1,3 +1,4 @@
+import fnmatch
 import os
 import re
 from typing import Literal
@@ -49,38 +50,6 @@ def _read_pdf_file_content(file_path: str) -> str:
         )
 
 
-def read_file_with_line_numbers(
-    file_path: str, replace_map: dict[str, str] = {}
-) -> str:
-    """Reads a file and returns content with line numbers.
-
-    Args:
-        file_path: The path to the file.
-        replace_map: A dictionary of strings to replace.
-
-    Returns:
-        The content of the file with line numbers and replacements applied.
-    """
-    content = read_file(file_path, replace_map)
-    if not content:
-        return ""
-    lines = content.splitlines()
-    numbered_lines = [f"{i + 1} | {line}" for i, line in enumerate(lines)]
-    return "\n".join(numbered_lines)
-
-
-def read_dir(dir_path: str) -> list[str]:
-    """Reads a directory and returns a list of file names.
-
-    Args:
-        dir_path: The path to the directory.
-
-    Returns:
-        A list of file names in the directory.
-    """
-    return [f for f in os.listdir(os.path.abspath(os.path.expanduser(dir_path)))]
-
-
 def write_file(
     file_path: str,
     content: str | list[str],
@@ -106,3 +75,53 @@ def write_file(
         content += "\n"
     with open(abs_file_path, mode) as f:
         f.write(content)
+
+
+def list_files(
+    path: str = ".",
+    include_hidden: bool = False,
+    depth: int = 3,
+    excluded_patterns: list[str] = [],
+) -> list[str]:
+    all_files: list[str] = []
+    abs_path = os.path.abspath(os.path.expanduser(path))
+    if not os.path.exists(abs_path):
+        raise FileNotFoundError(f"Path does not exist: {path}")
+
+    patterns_to_exclude = excluded_patterns
+    if depth <= 0:
+        depth = 1
+
+    initial_depth = abs_path.rstrip(os.sep).count(os.sep)
+    for root, dirs, files in os.walk(abs_path, topdown=True):
+        current_depth = root.rstrip(os.sep).count(os.sep) - initial_depth
+        if current_depth >= depth - 1:
+            del dirs[:]
+
+        dirs[:] = [
+            d
+            for d in dirs
+            if (include_hidden or not d.startswith("."))
+            and not _is_excluded(d, patterns_to_exclude)
+        ]
+
+        for filename in files:
+            if (include_hidden or not filename.startswith(".")) and not _is_excluded(
+                filename, patterns_to_exclude
+            ):
+                full_path = os.path.join(root, filename)
+                rel_full_path = os.path.relpath(full_path, abs_path)
+                if not _is_excluded(rel_full_path, patterns_to_exclude):
+                    all_files.append(rel_full_path)
+    return sorted(all_files)
+
+
+def _is_excluded(name: str, patterns: list[str]) -> bool:
+    for pattern in patterns:
+        if fnmatch.fnmatch(name, pattern):
+            return True
+        parts = name.split(os.path.sep)
+        for part in parts:
+            if fnmatch.fnmatch(part, pattern):
+                return True
+    return False

zrb/util/match.py

@@ -0,0 +1,78 @@
+import os
+import re
+
+
+def fuzzy_match(text: str, pattern: str) -> tuple[bool, float]:
+    """
+    Match text against a pattern using a fuzzy search algorithm similar to VSCode's Ctrl+P.
+
+    The pattern is split into tokens by whitespace and path separators.
+    Each token must be found in the text (in order).
+
+    Args:
+        text: The string to search in.
+        pattern: The search pattern (e.g., "src main" or "util/io").
+
+    Returns:
+        A tuple (matched, score).
+        - matched: True if the pattern matches the text.
+        - score: A float representing the match quality (lower is better).
+    """
+    text_cmp = text.lower()
+    # Normalize pattern -> tokens split on path separators or whitespace
+    search_pattern = pattern.strip()
+    tokens = (
+        [t for t in re.split(rf"[{re.escape(os.path.sep)}\s]+", search_pattern) if t]
+        if search_pattern
+        else []
+    )
+    tokens = [t.lower() for t in tokens]
+    if not tokens:
+        return True, 0.0
+    last_pos = 0
+    score = 0.0
+    for token in tokens:
+        # try contiguous substring search first
+        idx = text_cmp.find(token, last_pos)
+        if idx != -1:
+            # good match: reward contiguous early matches
+            score += idx  # smaller idx preferred
+            last_pos = idx + len(token)
+        else:
+            # fallback to subsequence matching
+            res = _find_subsequence_range(text_cmp, token, last_pos)
+            if res is None:
+                return False, 0.0
+
+            pos, end_pos = res
+
+            # subsequence match is less preferred than contiguous substring
+            score += pos + 0.5 * len(token)
+            last_pos = end_pos
+    # prefer shorter texts when score ties, so include length as tiebreaker
+    score += 0.01 * len(text)
+    return True, score
+
+
+def _find_subsequence_range(
+    hay: str, needle: str, start: int = 0
+) -> tuple[int, int] | None:
+    """
+    Try to locate needle in hay as a subsequence starting at `start`.
+    Returns (start_index, end_index) where end_index is the index AFTER the last matched character.
+    """
+    if not needle:
+        return start, start
+    i = start
+    j = 0
+    first_pos = None
+    while i < len(hay) and j < len(needle):
+        if hay[i] == needle[j]:
+            if first_pos is None:
+                first_pos = i
+            j += 1
+        i += 1
+
+    if j == len(needle):
+        return first_pos, i
+    return None

zrb/util/run.py

@@ -5,7 +5,7 @@ from typing import Any
 
 async def run_async(value: Any) -> Any:
     """
-    Run a value asynchronously, awaiting if it's awaitable or running in a thread if not.
+    Run a value asynchronously, awaiting if it's awaitable or returning it directly.
 
     Args:
         value (Any): The value to run. Can be awaitable or not.
@@ -14,7 +14,7 @@ async def run_async(value: Any) -> Any:
         Any: The result of the awaited value or the value itself if not awaitable.
     """
     if isinstance(value, asyncio.Task):
-        return value
+        return await value
     if inspect.isawaitable(value):
         return await value
-    return await asyncio.to_thread(lambda: value)
+    return value

{zrb-1.21.29.dist-info → zrb-2.0.0a4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zrb
-Version: 1.21.29
+Version: 2.0.0a4
 Summary: Your Automation Powerhouse
 License: AGPL-3.0-or-later
 Keywords: Automation,Task Runner,Code Generator,Monorepo,Low Code
@@ -24,28 +24,28 @@ Provides-Extra: mistral
 Provides-Extra: playwright
 Provides-Extra: rag
 Provides-Extra: vertexai
-Requires-Dist: anthropic (>=0.70.0) ; extra == "anthropic" or extra == "all"
+Requires-Dist: anthropic (>=0.75.0) ; extra == "anthropic" or extra == "all"
 Requires-Dist: beautifulsoup4 (>=4.14.2,<5.0.0)
 Requires-Dist: black (>=25.11.0,<26.0.0)
-Requires-Dist: boto3 (>=1.40.14) ; extra == "bedrock"
+Requires-Dist: boto3 (>=1.42.14) ; extra == "bedrock"
 Requires-Dist: chromadb (>=1.3.5,<2.0.0) ; extra == "rag" or extra == "all"
 Requires-Dist: cohere (>=5.18.0) ; extra == "cohere" or extra == "all"
 Requires-Dist: fastapi[standard] (>=0.123.9,<0.124.0)
 Requires-Dist: google-auth (>=2.36.0) ; extra == "vertexai" or extra == "all"
-Requires-Dist: google-genai (>=1.51.0) ; extra == "google" or extra == "all"
+Requires-Dist: google-genai (>=1.56.0) ; extra == "google" or extra == "all"
 Requires-Dist: groq (>=0.25.0) ; extra == "groq" or extra == "all"
 Requires-Dist: huggingface-hub[inference] (>=0.33.5,<1.0.0) ; extra == "huggingface"
 Requires-Dist: isort (>=7.0.0,<8.0.0)
 Requires-Dist: libcst (>=1.8.6,<2.0.0)
 Requires-Dist: markdownify (>=1.2.2,<2.0.0)
 Requires-Dist: mcp (>1.18.0)
-Requires-Dist: mistralai (>=1.9.10) ; extra == "mistral"
+Requires-Dist: mistralai (>=1.9.11) ; extra == "mistral"
 Requires-Dist: openai (>=2.11.0)
 Requires-Dist: pdfplumber (>=0.11.7,<0.12.0)
 Requires-Dist: playwright (>=1.56.0,<2.0.0) ; extra == "playwright" or extra == "all"
 Requires-Dist: prompt-toolkit (>=3)
 Requires-Dist: psutil (>=7.0.0,<8.0.0)
-Requires-Dist: pydantic-ai-slim (>=1.32.0,<1.33.0)
+Requires-Dist: pydantic-ai-slim (>=1.42.0,<1.43.0)
 Requires-Dist: pyjwt (>=2.10.1,<3.0.0)
 Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
 Requires-Dist: python-jose[cryptography] (>=3.5.0,<4.0.0)
@@ -131,8 +131,8 @@ Add the following Python code to your `zrb_init.py`:
 
 ```python
 from zrb import cli, LLMTask, CmdTask, StrInput, Group
-from zrb.builtin.llm.tool.code import analyze_repo
-from zrb.builtin.llm.tool.file import write_to_file
+from zrb.llm.tool.code import analyze_code
+from zrb.llm.tool.file import write_file
 
 
 # Create a group for Mermaid-related tasks
@@ -156,7 +156,7 @@ make_mermaid_script = mermaid_group.add_task(
             "Write the script into `{ctx.input.dir}/{ctx.input.diagram}.mmd`"
         ),
         tools=[
-            analyze_repo, write_to_file
+            analyze_code, write_file
         ],
     )
 )
@@ -232,13 +232,7 @@ Start a chat session with an LLM to ask questions, brainstorm ideas, or get codi
 zrb llm chat
 ```
 
-### Quick Questions
 
-For a single question, use the `ask` command for a fast response.
-
-```bash
-zrb llm ask "What is the capital of Indonesia?"
-```
 
 ---