zrb 1.21.17__py3-none-any.whl → 1.21.33__py3-none-any.whl

zrb/attr/type.py

@@ -1,12 +1,15 @@
 from typing import Any, Callable
 
 from zrb.context.any_context import AnyContext
+from zrb.context.any_shared_context import AnySharedContext
 
 fstring = str
-AnyAttr = Any | fstring | Callable[[AnyContext], Any]
-StrAttr = str | fstring | Callable[[AnyContext], str | None]
-BoolAttr = bool | fstring | Callable[[AnyContext], bool | None]
-IntAttr = int | fstring | Callable[[AnyContext], int | None]
-FloatAttr = float | fstring | Callable[[AnyContext], float | None]
-StrDictAttr = dict[str, StrAttr] | Callable[[AnyContext], dict[str, Any]]
-StrListAttr = list[StrAttr] | Callable[[AnyContext], list[str]]
+AnyAttr = Any | fstring | Callable[[AnyContext | AnySharedContext], Any]
+StrAttr = str | fstring | Callable[[AnyContext | AnySharedContext], str | None]
+BoolAttr = bool | fstring | Callable[[AnyContext | AnySharedContext], bool | None]
+IntAttr = int | fstring | Callable[[AnyContext | AnySharedContext], int | None]
+FloatAttr = float | fstring | Callable[[AnyContext | AnySharedContext], float | None]
+StrDictAttr = (
+    dict[str, StrAttr] | Callable[[AnyContext | AnySharedContext], dict[str, Any]]
+)
+StrListAttr = list[StrAttr] | Callable[[AnyContext | AnySharedContext], list[str]]

zrb/builtin/git.py

@@ -82,6 +82,12 @@ async def get_git_diff(ctx: AnyContext):
 
 @make_task(
     name="prune-local-git-branches",
+    input=StrInput(
+        name="preserved-branch",
+        description="Branches to be preserved",
+        prompt="Branches to be preserved, comma separated",
+        default="master,main,dev,develop",
+    ),
     description="🧹 Prune local branches",
     group=git_branch_group,
     alias="prune",
@@ -93,8 +99,13 @@ async def prune_local_branches(ctx: AnyContext):
     branches = await get_branches(repo_dir, print_method=ctx.print)
     ctx.print(stylize_faint("Get current branch"))
     current_branch = await get_current_branch(repo_dir, print_method=ctx.print)
+    preserved_branches = [
+        branch.strip()
+        for branch in ctx.input.preserved_branch.split(",")
+        if branch.strip() != ""
+    ]
     for branch in branches:
-        if branch == current_branch or branch == "main" or branch == "master":
+        if branch == current_branch or branch in preserved_branches:
             continue
         ctx.print(stylize_faint(f"Removing local branch: {branch}"))
         try:

zrb/builtin/llm/chat_completion.py

@@ -0,0 +1,287 @@
+import os
+from typing import TYPE_CHECKING
+
+from zrb.builtin.llm.chat_session_cmd import (
+    ADD_SUB_CMD,
+    ATTACHMENT_ADD_SUB_CMD_DESC,
+    ATTACHMENT_CLEAR_SUB_CMD_DESC,
+    ATTACHMENT_CMD,
+    ATTACHMENT_CMD_DESC,
+    ATTACHMENT_SET_SUB_CMD_DESC,
+    CLEAR_SUB_CMD,
+    HELP_CMD,
+    HELP_CMD_DESC,
+    MULTILINE_END_CMD,
+    MULTILINE_END_CMD_DESC,
+    MULTILINE_START_CMD,
+    MULTILINE_START_CMD_DESC,
+    QUIT_CMD,
+    QUIT_CMD_DESC,
+    RUN_CLI_CMD,
+    RUN_CLI_CMD_DESC,
+    SAVE_CMD,
+    SAVE_CMD_DESC,
+    SET_SUB_CMD,
+    WORKFLOW_ADD_SUB_CMD_DESC,
+    WORKFLOW_CLEAR_SUB_CMD_DESC,
+    WORKFLOW_CMD,
+    WORKFLOW_CMD_DESC,
+    WORKFLOW_SET_SUB_CMD_DESC,
+    YOLO_CMD,
+    YOLO_CMD_DESC,
+    YOLO_SET_CMD_DESC,
+    YOLO_SET_FALSE_CMD_DESC,
+    YOLO_SET_TRUE_CMD_DESC,
+)
+
+if TYPE_CHECKING:
+    from prompt_toolkit.completion import Completer
+
+
+def get_chat_completer() -> "Completer":
+
+    from prompt_toolkit.completion import CompleteEvent, Completer, Completion
+    from prompt_toolkit.document import Document
+
+    class ChatCompleter(Completer):
+
+        def get_completions(self, document: Document, complete_event: CompleteEvent):
+            # Slash command
+            for completion in self._complete_slash_command(document):
+                yield completion
+            for completion in self._complete_slash_file_command(document):
+                yield completion
+            # Appendix
+            for completion in self._complete_appendix(document):
+                yield completion
+
+        def _complete_slash_file_command(self, document: Document):
+            text = document.text_before_cursor
+            prefixes = []
+            for cmd in ATTACHMENT_CMD:
+                for subcmd in ADD_SUB_CMD:
+                    prefixes.append(f"{cmd} {subcmd} ")
+            for prefix in prefixes:
+                if text.startswith(prefix):
+                    pattern = text[len(prefix) :]
+                    potential_options = self._fuzzy_path_search(pattern, dirs=False)
+                    for prefixed_option in [
+                        f"{prefix}{option}" for option in potential_options
+                    ]:
+                        yield Completion(
+                            prefixed_option,
+                            start_position=-len(text),
+                        )
+
+        def _complete_slash_command(self, document: Document):
+            text = document.text_before_cursor
+            if not text.startswith("/"):
+                return
+            for command, description in self._get_cmd_options().items():
+                if command.lower().startswith(text.lower()):
+                    yield Completion(
+                        command,
+                        start_position=-len(text),
+                        display_meta=description,
+                    )
+
+        def _complete_appendix(self, document: Document):
+            token = document.get_word_before_cursor(WORD=True)
+            prefix = "@"
+            if not token.startswith(prefix):
+                return
+            pattern = token[len(prefix) :]
+            potential_options = self._fuzzy_path_search(pattern, dirs=False)
+            for prefixed_option in [
+                f"{prefix}{option}" for option in potential_options
+            ]:
+                yield Completion(
+                    prefixed_option,
+                    start_position=-len(token),
+                )
+
+        def _get_cmd_options(self):
+            cmd_options = {}
+            # Add all commands with their descriptions
+            for cmd in MULTILINE_START_CMD:
+                cmd_options[cmd] = MULTILINE_START_CMD_DESC
+            for cmd in MULTILINE_END_CMD:
+                cmd_options[cmd] = MULTILINE_END_CMD_DESC
+            for cmd in QUIT_CMD:
+                cmd_options[cmd] = QUIT_CMD_DESC
+            for cmd in WORKFLOW_CMD:
+                cmd_options[cmd] = WORKFLOW_CMD_DESC
+                for subcmd in ADD_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = WORKFLOW_ADD_SUB_CMD_DESC
+                for subcmd in CLEAR_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = WORKFLOW_CLEAR_SUB_CMD_DESC
+                for subcmd in SET_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = WORKFLOW_SET_SUB_CMD_DESC
+            for cmd in SAVE_CMD:
+                cmd_options[cmd] = SAVE_CMD_DESC
+            for cmd in ATTACHMENT_CMD:
+                cmd_options[cmd] = ATTACHMENT_CMD_DESC
+                for subcmd in ADD_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = ATTACHMENT_ADD_SUB_CMD_DESC
+                for subcmd in CLEAR_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = ATTACHMENT_CLEAR_SUB_CMD_DESC
+                for subcmd in SET_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = ATTACHMENT_SET_SUB_CMD_DESC
+            for cmd in YOLO_CMD:
+                cmd_options[cmd] = YOLO_CMD_DESC
+                for subcmd in SET_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd} true"] = YOLO_SET_TRUE_CMD_DESC
+                    cmd_options[f"{cmd} {subcmd} false"] = YOLO_SET_FALSE_CMD_DESC
+                    cmd_options[f"{cmd} {subcmd}"] = YOLO_SET_CMD_DESC
+            for cmd in HELP_CMD:
+                cmd_options[cmd] = HELP_CMD_DESC
+            for cmd in RUN_CLI_CMD:
+                cmd_options[cmd] = RUN_CLI_CMD_DESC
+            return dict(sorted(cmd_options.items()))
+
+        def _fuzzy_path_search(
+            self,
+            pattern: str,
+            root: str | None = None,
+            max_results: int = 20,
+            include_hidden: bool = False,
+            case_sensitive: bool = False,
+            dirs: bool = True,
+            files: bool = True,
+        ) -> list[str]:
+            """
+            Return a list of filesystem paths under `root` that fuzzy-match `pattern`.
+            - pattern: e.g. "./some/x" or "proj util/io"
+            - include_hidden: if False skip files/dirs starting with '.'
+            - dirs/files booleans let you restrict results
+            - returns list of relative paths (from root), sorted best-first
+            """
+            search_pattern = pattern
+            if root is None:
+                # Determine root and adjust pattern if necessary
+                expanded_pattern = os.path.expanduser(pattern)
+                if os.path.isabs(expanded_pattern) or pattern.startswith("~"):
+                    # For absolute paths, find the deepest existing directory
+                    if os.path.isdir(expanded_pattern):
+                        root = expanded_pattern
+                        search_pattern = ""
+                    else:
+                        root = os.path.dirname(expanded_pattern)
+                        while root and not os.path.isdir(root) and len(root) > 1:
+                            root = os.path.dirname(root)
+                        if not os.path.isdir(root):
+                            root = "."  # Fallback
+                            search_pattern = pattern
+                        else:
+                            try:
+                                search_pattern = os.path.relpath(expanded_pattern, root)
+                                if search_pattern == ".":
+                                    search_pattern = ""
+                            except ValueError:
+                                search_pattern = os.path.basename(pattern)
+                else:
+                    root = "."
+                    search_pattern = pattern
+            # Normalize pattern -> tokens split on path separators or whitespace
+            search_pattern = search_pattern.strip()
+            if search_pattern:
+                raw_tokens = [t for t in search_pattern.split(os.path.sep) if t]
+            else:
+                raw_tokens = []
+            # prepare tokens (case)
+            if not case_sensitive:
+                tokens = [t.lower() for t in raw_tokens]
+            else:
+                tokens = raw_tokens
+            # specific ignore list
+            try:
+                is_recursive = os.path.abspath(os.path.expanduser(root)).startswith(
+                    os.path.abspath(os.getcwd())
+                )
+            except Exception:
+                is_recursive = False
+            # walk filesystem
+            candidates: list[tuple[float, str]] = []
+            for dirpath, dirnames, filenames in os.walk(root):
+                # Filter directories
+                if not include_hidden:
+                    dirnames[:] = [d for d in dirnames if not d.startswith(".")]
+                rel_dir = os.path.relpath(dirpath, root)
+                # treat '.' as empty prefix
+                if rel_dir == ".":
+                    rel_dir = ""
+                # build list of entries to test depending on files/dirs flags
+                entries = []
+                if dirs:
+                    entries.extend([os.path.join(rel_dir, d) for d in dirnames])
+                if files:
+                    entries.extend([os.path.join(rel_dir, f) for f in filenames])
+                if not is_recursive:
+                    dirnames[:] = []
+                for ent in entries:
+                    # Normalize presentation: use ./ prefix for relative paths
+                    display_path = ent if ent else "."
+                    # Skip hidden entries unless requested (double check for rel path segments)
+                    if not include_hidden:
+                        if any(
+                            seg.startswith(".")
+                            for seg in display_path.split(os.sep)
+                            if seg
+                        ):
+                            continue
+                    cand = display_path.replace(os.sep, "/")  # unify separator
+                    cand_cmp = cand if case_sensitive else cand.lower()
+                    last_pos = 0
+                    score = 0.0
+                    matched_all = True
+                    for token in tokens:
+                        # try contiguous substring search first
+                        idx = cand_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
+                            pos = self._find_subsequence_pos(cand_cmp, token, last_pos)
+                            if pos is None:
+                                matched_all = False
+                                break
+                            # subsequence match is less preferred than contiguous substring
+                            score += pos + 0.5 * len(token)
+                            last_pos = pos + len(token)
+                    if matched_all:
+                        # prefer shorter paths when score ties, so include length as tiebreaker
+                        score += 0.01 * len(cand)
+                        out = (
+                            cand
+                            if os.path.abspath(cand) == cand
+                            else os.path.join(root, cand)
+                        )
+                        candidates.append((score, out))
+            # sort by score then lexicographically and return top results
+            candidates.sort(key=lambda x: (x[0], x[1]))
+            return [p for _, p in candidates[:max_results]]
+
+        def _find_subsequence_pos(
+            self, hay: str, needle: str, start: int = 0
+        ) -> int | None:
+            """
+            Try to locate needle in hay as a subsequence starting at `start`.
+            Returns the index of the first matched character of the subsequence or None if not
+            match.
+            """
+            if not needle:
+                return 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
+            return first_pos if j == len(needle) else None
+
+    return ChatCompleter()

zrb/builtin/llm/chat_session_cmd.py

@@ -12,13 +12,14 @@ from zrb.util.cli.style import (
 )
 from zrb.util.file import write_file
 from zrb.util.markdown import make_markdown_section
+from zrb.util.string.conversion import FALSE_STRS, TRUE_STRS, to_boolean
 
 MULTILINE_START_CMD = ["/multi", "/multiline"]
 MULTILINE_END_CMD = ["/end"]
 QUIT_CMD = ["/bye", "/quit", "/q", "/exit"]
 WORKFLOW_CMD = ["/workflow", "/workflows", "/skill", "/skills", "/w"]
 SAVE_CMD = ["/save", "/s"]
-ATTACHMENT_CMD = ["/attach", "/attachment", "/attachments"]
+ATTACHMENT_CMD = ["/attachment", "/attachments", "/attach"]
 YOLO_CMD = ["/yolo"]
 HELP_CMD = ["/help", "/info"]
 ADD_SUB_CMD = ["add"]
@@ -26,6 +27,39 @@ SET_SUB_CMD = ["set"]
 CLEAR_SUB_CMD = ["clear"]
 RUN_CLI_CMD = ["/run", "/exec", "/execute", "/cmd", "/cli", "!"]
 
+# Command display constants
+MULTILINE_START_CMD_DESC = "Start multiline input"
+MULTILINE_END_CMD_DESC = "End multiline input"
+QUIT_CMD_DESC = "Quit from chat session"
+WORKFLOW_CMD_DESC = "Show active workflows"
+WORKFLOW_ADD_SUB_CMD_DESC = (
+    "Add active workflow "
+    f"(e.g., `{WORKFLOW_CMD[0]} {ADD_SUB_CMD[0]} coding,researching`)"
+)
+WORKFLOW_SET_SUB_CMD_DESC = (
+    "Set active workflows " f"(e.g., `{WORKFLOW_CMD[0]} {SET_SUB_CMD[0]} coding,`)"
+)
+WORKFLOW_CLEAR_SUB_CMD_DESC = "Deactivate all workflows"
+SAVE_CMD_DESC = f"Save last response to a file (e.g., `{SAVE_CMD[0]} conclusion.md`)"
+ATTACHMENT_CMD_DESC = "Show current attachment"
+ATTACHMENT_ADD_SUB_CMD_DESC = (
+    "Attach a file " f"(e.g., `{ATTACHMENT_CMD[0]} {ADD_SUB_CMD[0]} ./logo.png`)"
+)
+ATTACHMENT_SET_SUB_CMD_DESC = (
+    "Set attachments "
+    f"(e.g., `{ATTACHMENT_CMD[0]} {SET_SUB_CMD[0]} ./logo.png,./diagram.png`)"
+)
+ATTACHMENT_CLEAR_SUB_CMD_DESC = "Clear attachment"
+YOLO_CMD_DESC = "Show/manipulate current YOLO mode"
+YOLO_SET_CMD_DESC = (
+    "Assign YOLO tools "
+    f"(e.g., `{YOLO_CMD[0]} {SET_SUB_CMD[0]} read_from_file,analyze_file`)"
+)
+YOLO_SET_TRUE_CMD_DESC = "Activate YOLO mode for all tools"
+YOLO_SET_FALSE_CMD_DESC = "Deactivate YOLO mode for all tools"
+RUN_CLI_CMD_DESC = "Run a non-interactive CLI command"
+HELP_CMD_DESC = "Show info/help"
+
 
 def print_current_yolo_mode(
     ctx: AnyContext, current_yolo_mode_value: str | bool
@@ -115,34 +149,54 @@ def run_cli_command(ctx: AnyContext, user_input: str) -> None:
 def get_new_yolo_mode(old_yolo_mode: str | bool, user_input: str) -> str | bool:
     new_yolo_mode = get_command_param(user_input, YOLO_CMD)
     if new_yolo_mode != "":
+        if new_yolo_mode in TRUE_STRS or new_yolo_mode in FALSE_STRS:
+            return to_boolean(new_yolo_mode)
         return new_yolo_mode
-    return old_yolo_mode
+    if isinstance(old_yolo_mode, bool):
+        return old_yolo_mode
+    return _normalize_comma_separated_str(old_yolo_mode)
 
 
 def get_new_attachments(old_attachment: str, user_input: str) -> str:
     if not is_command_match(user_input, ATTACHMENT_CMD):
-        return old_attachment
+        return _normalize_comma_separated_str(old_attachment)
     if is_command_match(user_input, ATTACHMENT_CMD, SET_SUB_CMD):
-        return get_command_param(user_input, ATTACHMENT_CMD, SET_SUB_CMD)
+        return _normalize_comma_separated_str(
+            get_command_param(user_input, ATTACHMENT_CMD, SET_SUB_CMD)
+        )
     if is_command_match(user_input, ATTACHMENT_CMD, CLEAR_SUB_CMD):
         return ""
     if is_command_match(user_input, ATTACHMENT_CMD, ADD_SUB_CMD):
         new_attachment = get_command_param(user_input, ATTACHMENT_CMD, ADD_SUB_CMD)
-        return ",".join([old_attachment, new_attachment])
+        return _normalize_comma_separated_str(
+            ",".join([old_attachment, new_attachment])
+        )
     return old_attachment
 
 
 def get_new_workflows(old_workflow: str, user_input: str) -> str:
     if not is_command_match(user_input, WORKFLOW_CMD):
-        return old_workflow
+        return _normalize_comma_separated_str(old_workflow)
     if is_command_match(user_input, WORKFLOW_CMD, SET_SUB_CMD):
-        return get_command_param(user_input, WORKFLOW_CMD, SET_SUB_CMD)
+        return _normalize_comma_separated_str(
+            get_command_param(user_input, WORKFLOW_CMD, SET_SUB_CMD)
+        )
     if is_command_match(user_input, WORKFLOW_CMD, CLEAR_SUB_CMD):
         return ""
     if is_command_match(user_input, WORKFLOW_CMD, ADD_SUB_CMD):
         new_workflow = get_command_param(user_input, WORKFLOW_CMD, ADD_SUB_CMD)
-        return ",".join([old_workflow, new_workflow])
-    return old_workflow
+        return _normalize_comma_separated_str(",".join([old_workflow, new_workflow]))
+    return _normalize_comma_separated_str(old_workflow)
+
+
+def _normalize_comma_separated_str(comma_separated_str: str) -> str:
+    return ",".join(
+        [
+            workflow_name.strip()
+            for workflow_name in comma_separated_str.split(",")
+            if workflow_name.strip() != ""
+        ]
+    )
 
 
 def get_command_param(user_input: str, *cmd_patterns: list[str]) -> str:
@@ -175,31 +229,39 @@ def print_commands(ctx: AnyContext):
     ctx.print(
         "\n".join(
             [
-                _show_command("/bye", "Quit from chat session"),
-                _show_command("/multi", "Start multiline input"),
-                _show_command("/end", "End multiline input"),
-                _show_command("/attachment", "Show current attachment"),
-                _show_subcommand("add", "<new-attachment>", "Attach a file"),
+                _show_command(QUIT_CMD[0], QUIT_CMD_DESC),
+                _show_command(MULTILINE_START_CMD[0], MULTILINE_START_CMD_DESC),
+                _show_command(MULTILINE_END_CMD[0], MULTILINE_END_CMD_DESC),
+                _show_command(ATTACHMENT_CMD[0], ATTACHMENT_CMD_DESC),
                 _show_subcommand(
-                    "set", "<attachment1,attachment2,...>", "Attach a file"
+                    ADD_SUB_CMD[0], "<file-path>", ATTACHMENT_ADD_SUB_CMD_DESC
                 ),
-                _show_subcommand("clear", "", "Clear attachment"),
-                _show_command("/workflow", "Show active workflows"),
-                _show_subcommand("add", "<workflow>", "Add active workflow"),
                 _show_subcommand(
-                    "set", "<workflow1,workflow2,..>", "Set active workflows"
+                    SET_SUB_CMD[0],
+                    "<file1-path,file2-path,...>",
+                    ATTACHMENT_SET_SUB_CMD_DESC,
                 ),
-                _show_subcommand("clear", "", "Deactivate all workflows"),
-                _show_command("/save <file-path>", "Save last response to a file"),
-                _show_command("/yolo", "Show current YOLO mode"),
-                _show_command_param(
-                    "<true | false | tool1,tool2,...>", "Set YOLO mode"
+                _show_subcommand(CLEAR_SUB_CMD[0], "", ATTACHMENT_CLEAR_SUB_CMD_DESC),
+                _show_command(WORKFLOW_CMD[0], WORKFLOW_CMD_DESC),
+                _show_subcommand(
+                    ADD_SUB_CMD[0], "<workflow>", WORKFLOW_ADD_SUB_CMD_DESC
+                ),
+                _show_subcommand(
+                    SET_SUB_CMD[0],
+                    "<workflow1,workflow2,..>",
+                    WORKFLOW_SET_SUB_CMD_DESC,
                 ),
-                _show_command("/run", ""),
-                _show_command_param(
-                    "<cli-command>", "Run a non-interactive CLI command"
+                _show_subcommand(CLEAR_SUB_CMD[0], "", WORKFLOW_CLEAR_SUB_CMD_DESC),
+                _show_command(f"{SAVE_CMD[0]}", SAVE_CMD_DESC),
+                _show_command(YOLO_CMD[0], YOLO_CMD_DESC),
+                _show_subcommand(SET_SUB_CMD[0], "true", YOLO_SET_TRUE_CMD_DESC),
+                _show_subcommand(SET_SUB_CMD[0], "false", YOLO_SET_FALSE_CMD_DESC),
+                _show_subcommand(
+                    SET_SUB_CMD[0], "<tool1,tool2,tool2>", YOLO_SET_CMD_DESC
                 ),
-                _show_command("/help", "Show this message"),
+                _show_command(RUN_CLI_CMD[0], ""),
+                _show_command_param("<cli-command>", RUN_CLI_CMD_DESC),
+                _show_command(HELP_CMD[0], HELP_CMD_DESC),
             ]
         ),
         plain=True,

zrb/builtin/llm/chat_trigger.py

@@ -1,7 +1,9 @@
 import asyncio
+import os
 from asyncio import StreamReader
 from typing import TYPE_CHECKING, Any, Callable, Coroutine
 
+from zrb.builtin.llm.chat_completion import get_chat_completer
 from zrb.context.any_context import AnyContext
 from zrb.util.run import run_async
 
@@ -58,7 +60,10 @@ class LLMChatTrigger:
 
         try:
             if isinstance(reader, PromptSession):
-                return await reader.prompt_async()
+                bottom_toolbar = f"📁 Current directory: {os.getcwd()}"
+                return await reader.prompt_async(
+                    completer=get_chat_completer(), bottom_toolbar=bottom_toolbar
+                )
             line_bytes = await reader.readline()
             if not line_bytes:
                 return "/bye"  # Signal to exit

zrb/builtin/llm/tool/cli.py

@@ -22,31 +22,47 @@ class ShellCommandResult(TypedDict):
     stderr: str
 
 
-def run_shell_command(command: str) -> ShellCommandResult:
+def run_shell_command(command: str, timeout: int = 30) -> ShellCommandResult:
     """
     Executes a non-interactive shell command on the user's machine.
 
+    **EFFICIENCY TIP:**
+    Combine multiple shell commands into a single call using `&&` or `;` to save steps.
+    Example: `mkdir new_dir && cd new_dir && touch file.txt`
+
     CRITICAL: This tool runs with user-level permissions. Explain commands that modify
         the system (e.g., `git`, `pip`) and ask for confirmation.
     IMPORTANT: Long-running processes should be run in the background (e.g., `command &`).
 
     Example:
-    run_shell_command(command='ls -l')
+    run_shell_command(command='ls -l', timeout=30)
 
     Args:
         command (str): The exact shell command to be executed.
+        timeout (int): The maximum time in seconds to wait for the command to finish.
+            Defaults to 30.
 
     Returns:
         dict: return_code, stdout, and stderr.
     """
-    result = subprocess.run(
-        command,
-        shell=True,
-        capture_output=True,
-        text=True,
-    )
-    return {
-        "return_code": result.returncode,
-        "stdout": result.stdout,
-        "stderr": result.stderr,
-    }
+    try:
+        result = subprocess.run(
+            command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+        return {
+            "return_code": int(result.returncode),
+            "stdout": str(result.stdout or ""),
+            "stderr": str(result.stderr or ""),
+        }
+    except subprocess.TimeoutExpired as e:
+        stdout = e.stdout.decode() if isinstance(e.stdout, bytes) else (e.stdout or "")
+        stderr = e.stderr.decode() if isinstance(e.stderr, bytes) else (e.stderr or "")
+        return {
+            "return_code": 124,
+            "stdout": str(stdout),
+            "stderr": f"{stderr}\nError: Command timed out after {timeout} seconds".strip(),
+        }

zrb/builtin/llm/tool/code.py

@@ -59,8 +59,12 @@ async def analyze_repo(
     """
     Analyzes a code repository or directory to answer a specific query.
 
-    CRITICAL: The quality of analysis depends entirely on the query. Vague queries yield poor
+    CRITICAL: The query must contain ALL necessary context, instructions, and information.
+        The sub-agent performing the analysis does NOT share your current conversation
+        history, memory, or global context.
+        The quality of analysis depends entirely on the query. Vague queries yield poor
         results.
+
     IMPORTANT: This tool can be slow and expensive on large repositories. Use judiciously.
 
     Example:
@@ -149,6 +153,8 @@ async def _extract_info(
         tool_name="extract",
         tool_description="extract",
         system_prompt=CFG.LLM_REPO_EXTRACTOR_SYSTEM_PROMPT,
+        auto_summarize=False,
+        remember_history=False,
     )
     extracted_infos = []
     content_buffer = []
@@ -197,6 +203,8 @@ async def _summarize_info(
         tool_name="extract",
         tool_description="extract",
         system_prompt=CFG.LLM_REPO_SUMMARIZER_SYSTEM_PROMPT,
+        auto_summarize=False,
+        remember_history=False,
     )
     summarized_infos = []
     content_buffer = ""