zrb 1.17.3__py3-none-any.whl → 1.18.0__py3-none-any.whl

zrb/builtin/llm/chat_session.py

@@ -32,7 +32,7 @@ async def read_user_prompt(ctx: AnyContext) -> str:
     reader: PromptSession[Any] | StreamReader = await _setup_input_reader(is_tty)
     multiline_mode = False
     is_first_time = True
-    current_modes: str = ctx.input.modes
+    current_workflows: str = ctx.input.workflows
     current_yolo_mode: bool | str = ctx.input.yolo
     user_inputs: list[str] = []
     final_result: str = ""
@@ -59,7 +59,7 @@ async def read_user_prompt(ctx: AnyContext) -> str:
             result = await _trigger_ask_and_wait_for_result(
                 ctx=ctx,
                 user_prompt=user_prompt,
-                modes=current_modes,
+                workflows=current_workflows,
                 yolo_mode=current_yolo_mode,
                 previous_session_name=previous_session_name,
                 start_new=start_new,
@@ -77,7 +77,7 @@ async def read_user_prompt(ctx: AnyContext) -> str:
             result = await _trigger_ask_and_wait_for_result(
                 ctx=ctx,
                 user_prompt=user_prompt,
-                modes=current_modes,
+                workflows=current_workflows,
                 yolo_mode=current_yolo_mode,
                 previous_session_name=previous_session_name,
                 start_new=start_new,
@@ -86,18 +86,18 @@ async def read_user_prompt(ctx: AnyContext) -> str:
                 final_result = result
                 if ctx.is_web_mode or not is_tty:
                     return final_result
-        elif user_input.strip().lower().startswith("/mode"):
-            mode_parts = user_input.split(" ", maxsplit=2)
-            if len(mode_parts) > 1:
-                current_modes = mode_parts[1]
-            ctx.print(f"Current mode: {current_modes}", plain=True)
+        elif user_input.strip().lower().startswith("/workflow"):
+            workflow_parts = user_input.split(" ", maxsplit=2)
+            if len(workflow_parts) > 1:
+                current_workflows = workflow_parts[1]
+            ctx.print(f"Current workflows: {current_workflows}", plain=True)
             ctx.print("", plain=True)
             continue
         elif user_input.strip().lower().startswith("/yolo"):
             yolo_mode_parts = user_input.split(" ", maxsplit=2)
             if len(yolo_mode_parts) > 1:
                 current_yolo_mode = to_boolean(yolo_mode_parts[1])
-            ctx.print(f"Current_yolo mode: {current_yolo_mode}", plain=True)
+            ctx.print(f"Current YOLO mode: {current_yolo_mode}", plain=True)
             ctx.print("", plain=True)
             continue
         elif user_input.strip().lower() in ("/help", "/info"):
@@ -112,7 +112,7 @@ async def read_user_prompt(ctx: AnyContext) -> str:
             result = await _trigger_ask_and_wait_for_result(
                 ctx=ctx,
                 user_prompt=user_prompt,
-                modes=current_modes,
+                workflows=current_workflows,
                 yolo_mode=current_yolo_mode,
                 previous_session_name=previous_session_name,
                 start_new=start_new,
@@ -136,8 +136,8 @@ def _show_info(ctx: AnyContext):
                 _show_command("/bye", "Quit from chat session"),
                 _show_command("/multi", "Start multiline input"),
                 _show_command("/end", "End multiline input"),
-                _show_command("/modes", "Show current modes"),
-                _show_subcommand("<mode1,mode2,..>", "Set current modes"),
+                _show_command("/workflows", "Show current workflows"),
+                _show_subcommand("<wf1,wf2,..>", "Set current workflows"),
                 _show_command("/yolo", "Get current YOLO mode"),
                 _show_subcommand("<true|false|list-of-tools>", "Set YOLO mode"),
                 _show_command("/help", "Show this message"),
@@ -179,7 +179,7 @@ async def _setup_input_reader(
 async def _trigger_ask_and_wait_for_result(
     ctx: AnyContext,
     user_prompt: str,
-    modes: str,
+    workflows: str,
     yolo_mode: bool | str,
     previous_session_name: str | None = None,
     start_new: bool = False,
@@ -199,7 +199,7 @@ async def _trigger_ask_and_wait_for_result(
     if user_prompt.strip() == "":
         return None
     await _trigger_ask(
-        ctx, user_prompt, modes, yolo_mode, previous_session_name, start_new
+        ctx, user_prompt, workflows, yolo_mode, previous_session_name, start_new
     )
     result = await _wait_ask_result(ctx)
     md_result = render_markdown(result) if result is not None else ""
@@ -231,7 +231,7 @@ def get_llm_ask_input_mapping(callback_ctx: AnyContext):
         "start-new": data.get("start_new"),
         "previous-session": data.get("previous_session_name"),
         "message": data.get("message"),
-        "modes": data.get("modes"),
+        "workflows": data.get("workflows"),
         "yolo": data.get("yolo"),
     }
 
@@ -239,7 +239,7 @@ def get_llm_ask_input_mapping(callback_ctx: AnyContext):
 async def _trigger_ask(
     ctx: AnyContext,
     user_prompt: str,
-    modes: str,
+    workflows: str,
     yolo_mode: bool | str,
     previous_session_name: str | None = None,
     start_new: bool = False,
@@ -260,7 +260,7 @@ async def _trigger_ask(
             "previous_session_name": previous_session_name,
             "start_new": start_new,
             "message": user_prompt,
-            "modes": modes,
+            "workflows": workflows,
             "yolo": yolo_mode,
         }
     )

zrb/builtin/llm/llm_ask.py

@@ -152,10 +152,10 @@ def _get_inputs(require_message: bool = True) -> list[AnyInput | None]:
             always_prompt=False,
         ),
         TextInput(
-            "modes",
-            description="Modes",
-            prompt="Modes",
-            default=lambda ctx: ",".join(llm_config.default_modes),
+            "workflows",
+            description="Workflows",
+            prompt="Workflows",
+            default=lambda ctx: ",".join(llm_config.default_workflows),
             allow_positional_parsing=False,
             always_prompt=False,
         ),
@@ -210,8 +210,10 @@ llm_ask: LLMTask = llm_group.add_task(
         system_prompt=lambda ctx: (
             None if ctx.input.system_prompt.strip() == "" else ctx.input.system_prompt
         ),
-        modes=lambda ctx: (
-            None if ctx.input.modes.strip() == "" else ctx.input.modes.split(",")
+        workflows=lambda ctx: (
+            None
+            if ctx.input.workflows.strip() == ""
+            else ctx.input.workflows.split(",")
         ),
         message="{ctx.input.message}",
         tools=_get_tool,

zrb/builtin/llm/tool/web.py

@@ -52,18 +52,41 @@ def create_search_internet_tool() -> Callable:
         """
         import requests
 
-        if CFG.SEARCH_INTERNET_METHOD.strip() == "serpapi" and CFG.SERPAPI_KEY != "":
+        if (
+            CFG.SEARCH_INTERNET_METHOD.strip().lower() == "serpapi"
+            and CFG.SERPAPI_KEY != ""
+        ):
             response = requests.get(
                 "https://serpapi.com/search",
                 headers={"User-Agent": _DEFAULT_USER_AGENT},
                 params={
                     "q": query,
                     "start": (page - 1) * 10,
-                    "hl": "en",
-                    "safe": "off",
+                    "hl": CFG.SERPAPI_LANG,
+                    "safe": CFG.SERPAPI_SAFE,
                     "api_key": CFG.SERPAPI_KEY,
                 },
             )
+        elif (
+            CFG.SEARCH_INTERNET_METHOD.strip().lower() == "brave"
+            and CFG.BRAVE_API_KEY != ""
+        ):
+            response = requests.get(
+                "https://api.search.brave.com/res/v1/web/search",
+                headers={
+                    "User-Agent": _DEFAULT_USER_AGENT,
+                    "Accept": "application/json",
+                    "x-subscription-token": CFG.BRAVE_API_KEY,
+                },
+                params={
+                    "q": query,
+                    "count": "10",
+                    "offset": (page - 1) * 10,
+                    "safesearch": CFG.BRAVE_API_SAFE,
+                    "search_lang": CFG.BRAVE_API_LANG,
+                    "summary": "true",
+                },
+            )
         else:
             response = requests.get(
                 url=f"{CFG.SEARXNG_BASE_URL}/search",
@@ -72,7 +95,8 @@ def create_search_internet_tool() -> Callable:
                     "q": query,
                     "format": "json",
                     "pageno": page,
-                    "safesearch": 0,
+                    "safesearch": CFG.SEARXNG_SAFE,
+                    "language": CFG.SEARXNG_LANG,
                 },
             )
         if response.status_code != 200:

zrb/config/config.py

@@ -275,12 +275,26 @@ class Config:
         return None if value == "" else value
 
     @property
-    def LLM_MODES(self) -> list[str]:
-        return [
-            mode.strip()
-            for mode in self._getenv("LLM_MODES", "coding").split(",")
-            if mode.strip() != ""
-        ]
+    def LLM_WORKFLOWS(self) -> list[str]:
+        """Get a list of LLM workflows from environment variables."""
+        workflows = []
+        for workflow in self._getenv("LLM_WORKFLOWS", "coding").split(","):
+            workflow = workflow.strip()
+            if workflow != "":
+                workflows.append(workflow)
+        return workflows
+
+    @property
+    def LLM_BUILTIN_WORKFLOW_PATHS(self) -> list[str]:
+        """Get a list of additional builtin workflow paths from environment variables."""
+        builtin_workflow_paths_str = self._getenv("LLM_BUILTIN_WORKFLOW_PATHS", "")
+        if builtin_workflow_paths_str != "":
+            return [
+                path.strip()
+                for path in builtin_workflow_paths_str.split(":")
+                if path.strip() != ""
+            ]
+        return []
 
     @property
     def LLM_SPECIAL_INSTRUCTION_PROMPT(self) -> str | None:
@@ -442,10 +456,30 @@ class Config:
         """Either serpapi or searxng"""
         return self._getenv("SEARCH_INTERNET_METHOD", "serpapi")
 
+    @property
+    def BRAVE_API_KEY(self) -> str:
+        return os.getenv("BRAVE_API_KEY", "")
+
+    @property
+    def BRAVE_API_SAFE(self) -> str:
+        return self._getenv("BRAVE_API_SAFE", "off")
+
+    @property
+    def BRAVE_API_LANG(self) -> str:
+        return self._getenv("BRAVE_API_LANG", "en")
+
     @property
     def SERPAPI_KEY(self) -> str:
         return os.getenv("SERPAPI_KEY", "")
 
+    @property
+    def SERPAPI_SAFE(self) -> str:
+        return self._getenv("SERPAPI_SAFE", "off")
+
+    @property
+    def SERPAPI_LANG(self) -> str:
+        return self._getenv("SERPAPI_LANG", "en")
+
     @property
     def SEARXNG_PORT(self) -> int:
         return int(self._getenv("SEARXNG_PORT", "8080"))
@@ -454,6 +488,14 @@ class Config:
     def SEARXNG_BASE_URL(self) -> str:
         return self._getenv("SEARXNG_BASE_URL", f"http://localhost:{self.SEARXNG_PORT}")
 
+    @property
+    def SEARXNG_SAFE(self) -> int:
+        return int(self._getenv("SEARXNG_SAFE", "0"))
+
+    @property
+    def SEARXNG_LANG(self) -> str:
+        return self._getenv("SEARXNG_LANG", "en")
+
     @property
     def BANNER(self) -> str:
         return fstring_format(

zrb/config/default_prompt/interactive_system_prompt.md

@@ -20,7 +20,7 @@ You are an expert interactive AI agent. You MUST follow this workflow for this i
 
 3. **Execute and Verify (The E+V Loop):**
     * Execute the action.
-    * **CRITICAL:** After each step, you MUST use a tool to verify the outcome (e.g., check command exit codes, read back file contents, list files).
+    * **CRITICAL:** After each step, you MUST use a tool to verify the outcome (e.g., check command exit codes, verify changes has been applied, or new files has been created).
 
 4. **Handle Errors (The Debugging Loop):**
     * If an action fails, you MUST NOT give up. You MUST enter a persistent debugging loop until the error is resolved.

zrb/config/default_prompt/system_prompt.md

@@ -16,7 +16,7 @@ You are an expert AI agent fulfilling a single request. You must provide a compl
 
 3. **Execute and Verify (The E+V Loop):**
     * Execute each step of your plan.
-    * **CRITICAL:** After each step, you MUST use a tool to verify the outcome (e.g., check command exit codes, read back file contents, list files).
+    * **CRITICAL:** After each step, you MUST use a tool to verify the outcome (e.g., check command exit codes, verify changes has been applied, or new files has been created).
 
 4. **Handle Errors (The Debugging Loop):**
     * If an action fails, you MUST NOT give up. You MUST enter a persistent debugging loop until the error is resolved.

zrb/config/llm_config.py

@@ -25,7 +25,7 @@ class LLMConfig:
         default_summarization_prompt: str | None = None,
         default_summarize_history: bool | None = None,
         default_history_summarization_token_threshold: int | None = None,
-        default_modes: list[str] | None = None,
+        default_workflows: list[str] | None = None,
         default_model: "Model | None" = None,
         default_model_settings: "ModelSettings | None" = None,
         default_model_provider: "Provider | None" = None,
@@ -53,7 +53,7 @@ class LLMConfig:
         self._default_history_summarization_token_threshold = (
             default_history_summarization_token_threshold
         )
-        self._default_modes = default_modes
+        self._default_workflows = default_workflows
         self._default_model = default_model
         self._default_model_settings = default_model_settings
         self._default_model_provider = default_model_provider
@@ -191,9 +191,9 @@ class LLMConfig:
         )
 
     @property
-    def default_modes(self) -> list[str]:
+    def default_workflows(self) -> list[str]:
         return self._get_property(
-            self._default_modes, CFG.LLM_MODES, lambda: ["coding"]
+            self._default_workflows, CFG.LLM_WORKFLOWS, lambda: ["coding"]
         )
 
     @property
@@ -279,18 +279,18 @@ class LLMConfig:
     def set_default_special_instruction_prompt(self, special_instruction_prompt: str):
         self._default_special_instruction_prompt = special_instruction_prompt
 
-    def set_default_modes(self, modes: list[str]):
-        self._default_modes = modes
+    def set_default_workflows(self, workflows: list[str]):
+        self._default_workflows = workflows
 
-    def add_default_mode(self, mode: str):
-        if self._default_modes is None:
-            self._default_modes = []
-        self._default_modes.append(mode)
+    def add_default_workflow(self, workflow: str):
+        if self._default_workflows is None:
+            self._default_workflows = []
+        self._default_workflows.append(workflow)
 
-    def remove_default_mode(self, mode: str):
-        if self._default_modes is None:
-            self._default_modes = []
-        self._default_modes.remove(mode)
+    def remove_default_workflow(self, workflow: str):
+        if self._default_workflows is None:
+            self._default_workflows = []
+        self._default_workflows.remove(workflow)
 
     def set_default_summarization_prompt(self, summarization_prompt: str):
         self._default_summarization_prompt = summarization_prompt

zrb/config/llm_context/config.py

@@ -5,6 +5,25 @@ from zrb.config.llm_context.config_parser import markdown_to_dict
 from zrb.util.llm.prompt import demote_markdown_headers
 
 
+class LLMWorkflow:
+    def __init__(self, name: str, path: str, content: str):
+        self._name = name
+        self._path = path
+        self._content = content
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def path(self) -> str:
+        return self._path
+
+    @property
+    def content(self) -> str:
+        return self._content
+
+
 class LLMContextConfig:
     """High-level API for interacting with cascaded configurations."""
 
@@ -75,20 +94,24 @@ class LLMContextConfig:
                     notes[abs_context_path] = value
         return notes
 
-    def get_workflows(self, cwd: str | None = None) -> dict[str, str]:
+    def get_workflows(self, cwd: str | None = None) -> dict[str, LLMWorkflow]:
         """Gathers all relevant workflows for a given path."""
         if cwd is None:
             cwd = os.getcwd()
         all_sections = self._get_all_sections(cwd)
-        workflows: dict[str, str] = {}
+        workflows: dict[str, LLMWorkflow] = {}
         # Iterate from closest to farthest
-        for _, sections in all_sections:
+        for config_dir, sections in all_sections:
             for key, value in sections.items():
                 if key.lower().startswith("workflow:"):
                     workflow_name = key[len("workflow:") :].strip().lower()
                     # First one found wins
                     if workflow_name not in workflows:
-                        workflows[workflow_name] = value
+                        workflows[workflow_name] = LLMWorkflow(
+                            name=workflow_name,
+                            content=value,
+                            path=config_dir,
+                        )
         return workflows
 
     def get_contexts(self, cwd: str | None = None) -> dict[str, str]:

zrb/task/llm/agent.py

@@ -106,7 +106,7 @@ def create_agent_instance(
     return Agent[None, Any](
         model=model,
         output_type=output_type,
-        system_prompt=system_prompt,
+        instructions=system_prompt,
         tools=tool_list,
         toolsets=wrapped_toolsets,
         model_settings=model_settings,

zrb/task/llm/default_workflow/coding/git.md

@@ -0,0 +1,142 @@
+# Git Command Guidelines
+
+## Core Principles
+
+- **Safety First:** Always verify current branch and status before destructive operations
+- **Atomic Commits:** Each commit should represent a single logical change
+- **Descriptive Messages:** Write clear, concise commit messages that explain "why" not just "what"
+- **Interactive Mode:** Use interactive rebase and staging for precise control
+
+## Essential Commands
+
+### Repository Status
+```bash
+# Check current status and branch
+git status
+git branch -v
+
+# See uncommitted changes
+git diff
+git diff --staged
+```
+
+### Safe Branch Operations
+```bash
+# Create and switch to new branch
+git checkout -b feature/new-feature
+
+# Switch branches safely
+git switch main
+git switch feature/branch-name
+
+# List all branches
+git branch -a
+```
+
+### Staging and Committing
+```bash
+# Stage specific files
+git add path/to/file.py
+git add src/
+
+# Stage interactively
+git add -p
+
+# Commit with descriptive message
+git commit -m "feat: add user authentication
+
+- Implement JWT token generation
+- Add login/logout endpoints
+- Add password hashing"
+
+# Amend last commit (use carefully)
+git commit --amend
+```
+
+### History and Logs
+```bash
+# View commit history
+git log --oneline --graph -10
+git log --stat
+
+# See who changed what
+git blame file.py
+```
+
+## Advanced Operations
+
+### Rebasing and Merging
+```bash
+# Update feature branch from main
+git switch feature/branch
+git rebase main
+
+# Interactive rebase for cleanup
+git rebase -i HEAD~5
+
+# Safe merge
+git merge --no-ff feature/branch
+```
+
+### Stashing
+```bash
+# Save uncommitted changes temporarily
+git stash push -m "WIP: feature implementation"
+
+# List stashes
+git stash list
+
+# Apply and keep stash
+git stash apply stash@{0}
+
+# Apply and drop stash
+git stash pop
+```
+
+### Remote Operations
+```bash
+# Fetch and check before pulling
+git fetch origin
+git log origin/main..main
+
+# Push safely
+git push origin feature/branch
+git push --force-with-lease  # Safer than --force
+```
+
+## Safety Checklist
+
+1. **Before destructive operations:** Always run `git status` and `git branch -v`
+2. **Before force push:** Use `--force-with-lease` instead of `--force`
+3. **Before rebase:** Ensure working directory is clean
+4. **Before merge:** Resolve conflicts immediately
+5. **Regularly:** Fetch and integrate upstream changes
+
+## Common Patterns
+
+### Feature Development
+```bash
+git checkout -b feature/new-feature
+# ... make changes ...
+git add .
+git commit -m "feat: implement new feature"
+git push origin feature/new-feature
+```
+
+### Hotfix Workflow
+```bash
+git checkout -b hotfix/critical-bug main
+# ... fix the bug ...
+git add .
+git commit -m "fix: resolve critical issue"
+git push origin hotfix/critical-bug
+```
+
+### Cleanup
+```bash
+# Delete merged branches locally
+git branch --merged main | grep -v "main" | xargs git branch -d
+
+# Delete remote branches
+git push origin --delete old-branch
+```

zrb/task/llm/default_workflow/coding/golang.md

@@ -0,0 +1,23 @@
+# Go Development Guide
+
+## Core Principles
+- **Follow Go conventions** and effective Go patterns
+- **Use `go fmt`** for consistent formatting
+- **Follow project's package structure** and naming
+
+## Project Analysis
+- Check for: `go.mod`, `go.sum`, `Makefile`
+- Look for project-specific patterns in existing code
+- Identify testing approach: table tests, integration tests
+
+## Implementation Patterns
+- **Error Handling:** Follow project's error wrapping and handling style
+- **Package Organization:** Match existing package boundaries and dependencies
+- **Naming:** Follow Go conventions (camelCase, short names)
+- **Testing:** Use same test organization and helper patterns
+
+## Common Commands
+- Formatting: `go fmt`
+- Testing: `go test`
+- Linting: `golangci-lint`, `staticcheck`
+- Building: `go build`

zrb/task/llm/default_workflow/coding/javascript.md

@@ -0,0 +1,24 @@
+# JavaScript/TypeScript Development Guide
+
+## Core Principles
+- **Follow project's style guide** (ESLint, Prettier, etc.)
+- **Use TypeScript** if the project uses it
+- **Match module system** (CommonJS, ES modules)
+
+## Project Analysis
+- Check for: `package.json`, `tsconfig.json`, `jsconfig.json`
+- Look for style guides: `.eslintrc`, `.prettierrc`, `.editorconfig`
+- Identify testing framework: `jest`, `mocha`, `vitest`
+- Check build tools: `webpack`, `vite`, `rollup`
+
+## Implementation Patterns
+- **Module System:** Follow project's import/export patterns
+- **Error Handling:** Match promise/async patterns and error types
+- **TypeScript:** Use same strictness level and type patterns
+- **Testing:** Use project's test utilities and mocking patterns
+
+## Common Commands
+- Package management: `npm`, `yarn`, `pnpm`
+- Testing: `npm test`, `npm run test`
+- Linting: `npm run lint`, `eslint`
+- Building: `npm run build`, `tsc`

zrb/task/llm/default_workflow/coding/python.md

@@ -0,0 +1,23 @@
+# Python Development Guide
+
+## Core Principles
+- **Follow PEP 8** unless project has specific style guides
+- **Use type hints** if the project uses them
+- **Match existing patterns** for imports, docstrings, and error handling
+
+## Project Analysis
+- Check for: `pyproject.toml`, `requirements.txt`, `setup.py`, `.python-version`
+- Look for style guides: `.flake8`, `.pylintrc`, `ruff.toml`, `mypy.ini`
+- Identify testing framework: `pytest`, `unittest`, `nose`
+
+## Implementation Patterns
+- **Imports:** Follow project's import organization (stdlib, third-party, local)
+- **Error Handling:** Match existing exception patterns and logging
+- **Documentation:** Use same docstring format (Google, NumPy, reStructuredText)
+- **Testing:** Use project's test organization and fixtures
+
+## Common Commands
+- Formatting: `black`, `autopep8`, `yapf`
+- Linting: `flake8`, `pylint`, `ruff`
+- Testing: `pytest`, `python -m unittest`
+- Type checking: `mypy`, `pyright`

zrb/task/llm/default_workflow/coding/rust.md

@@ -0,0 +1,23 @@
+# Rust Development Guide
+
+## Core Principles
+- **Follow Rust conventions** and idiomatic patterns
+- **Use `rustfmt`** for consistent formatting
+- **Follow ownership and borrowing** patterns in existing code
+
+## Project Analysis
+- Check for: `Cargo.toml`, `Cargo.lock`
+- Look for: `rustfmt.toml`, `clippy.toml`
+- Identify testing approach: unit tests, integration tests
+
+## Implementation Patterns
+- **Error Handling:** Follow project's `Result` and `Option` patterns
+- **Crate Organization:** Match existing module structure
+- **Ownership:** Follow existing borrowing and lifetime patterns
+- **Testing:** Use same test organization and attribute patterns
+
+## Common Commands
+- Formatting: `cargo fmt`
+- Testing: `cargo test`
+- Linting: `cargo clippy`
+- Building: `cargo build`