zrb 1.9.12__tar.gz → 1.9.14__tar.gz

{zrb-1.9.12 → zrb-1.9.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.9.12
+Version: 1.9.14
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later

{zrb-1.9.12 → zrb-1.9.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "1.9.12"
+version = "1.9.14"
 description = "Your Automation Powerhouse"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"

{zrb-1.9.12 → zrb-1.9.14}/src/zrb/builtin/llm/chat_session.py

@@ -6,6 +6,7 @@ conversation flow via XCom.
 """
 
 import asyncio
+import sys
 
 from zrb.config.llm_config import llm_config
 from zrb.context.any_context import AnyContext
@@ -15,45 +16,26 @@ from zrb.util.cli.style import stylize_bold_yellow, stylize_faint
 async def read_user_prompt(ctx: AnyContext) -> str:
     """
     Reads user input from the CLI for an interactive chat session.
-
-    Handles special commands like /bye, /multi, /end, and /help.
-    Triggers the LLM task and waits for the result.
-
-    Args:
-        ctx: The context object for the task.
-
-    Returns:
-        The final result from the LLM session.
+    Orchestrates the session by calling helper functions.
     """
-    from prompt_toolkit import PromptSession
-
     _show_info(ctx)
-    final_result = ""
-    ctx.print("💬 >>", plain=True)
-    ctx.print(ctx.input.message, plain=True)
-    ctx.print("", plain=True)
-    result = await _trigger_ask_and_wait_for_result(
-        ctx,
-        user_prompt=ctx.input.message,
-        previous_session_name=ctx.input.previous_session,
-        start_new=ctx.input.start_new,
-    )
-    if result is not None:
-        final_result = result
-    if ctx.env.get("_ZRB_WEB_ENV", "0") != "0":
-        # On web environment this won't be interactive
+    is_web = ctx.env.get("_ZRB_WEB_ENV", "0") == "1"
+    final_result = await _handle_initial_message(ctx)
+    if is_web:
         return final_result
+    is_interactive = sys.stdin.isatty()
+    reader = await _setup_input_reader(is_interactive)
     multiline_mode = False
     user_inputs = []
-    user_input_session = PromptSession()
     while True:
         await asyncio.sleep(0.01)
+        # Get user input based on mode
         if not multiline_mode:
             ctx.print("💬 >>", plain=True)
-        user_input = await user_input_session.prompt_async()
+        user_input = await _read_next_line(is_interactive, reader, ctx)
         if not multiline_mode:
             ctx.print("", plain=True)
-        # Handle special input
+        # Handle user input
         if user_input.strip().lower() in ("/bye", "/quit", "/q", "/exit"):
             user_prompt = "\n".join(user_inputs)
             user_inputs = []
@@ -86,6 +68,67 @@ async def read_user_prompt(ctx: AnyContext) -> str:
     return final_result
 
 
+def _show_info(ctx: AnyContext):
+    """
+    Displays the available chat session commands to the user.
+    Args:
+        ctx: The context object for the task.
+    """
+    ctx.print(
+        (
+            f"  {stylize_bold_yellow('/bye')}   {stylize_faint('Quit from chat session')}\n"
+            f"  {stylize_bold_yellow('/multi')} {stylize_faint('Start multiline input')}\n"
+            f"  {stylize_bold_yellow('/end')}   {stylize_faint('End multiline input')}\n"
+            f"  {stylize_bold_yellow('/help')}  {stylize_faint('Show this message')}\n"
+        ),
+        plain=True,
+    )
+
+
+async def _handle_initial_message(ctx: AnyContext) -> str:
+    """Processes the initial message from the command line."""
+    if not ctx.input.message or ctx.input.message.strip() == "":
+        return ""
+    ctx.print("💬 >>", plain=True)
+    ctx.print(ctx.input.message, plain=True)
+    ctx.print("", plain=True)
+    result = await _trigger_ask_and_wait_for_result(
+        ctx,
+        user_prompt=ctx.input.message,
+        previous_session_name=ctx.input.previous_session,
+        start_new=ctx.input.start_new,
+    )
+    return result if result is not None else ""
+
+
+async def _setup_input_reader(is_interactive: bool):
+    """Sets up and returns the appropriate asynchronous input reader."""
+    if is_interactive:
+        from prompt_toolkit import PromptSession
+
+        return PromptSession()
+
+    loop = asyncio.get_event_loop()
+    reader = asyncio.StreamReader(loop=loop)
+    protocol = asyncio.StreamReaderProtocol(reader)
+    await loop.connect_read_pipe(lambda: protocol, sys.stdin)
+    return reader
+
+
+async def _read_next_line(is_interactive: bool, reader, ctx: AnyContext) -> str:
+    """Reads one line of input using the provided reader."""
+    if is_interactive:
+        return await reader.prompt_async()
+
+    line_bytes = await reader.readline()
+    if not line_bytes:
+        return "/bye"  # Signal to exit
+
+    user_input = line_bytes.decode().strip()
+    ctx.print(user_input, plain=True)
+    return user_input
+
+
 async def _trigger_ask_and_wait_for_result(
     ctx: AnyContext,
     user_prompt: str,
@@ -211,21 +254,3 @@ async def _wait_ask_session_name(ctx: AnyContext) -> str:
     while "ask_session_name" not in ctx.xcom or len(ctx.xcom.ask_session_name) == 0:
         await asyncio.sleep(0.1)
     return ctx.xcom.ask_session_name.pop()
-
-
-def _show_info(ctx: AnyContext):
-    """
-    Displays the available chat session commands to the user.
-
-    Args:
-        ctx: The context object for the task.
-    """
-    ctx.print(
-        (
-            f"  {stylize_bold_yellow('/bye')}   {stylize_faint('Quit from chat session')}\n"
-            f"  {stylize_bold_yellow('/multi')} {stylize_faint('Start multiline input')}\n"
-            f"  {stylize_bold_yellow('/end')}   {stylize_faint('End multiline input')}\n"
-            f"  {stylize_bold_yellow('/help')}  {stylize_faint('Show this message')}\n"
-        ),
-        plain=True,
-    )

zrb-1.9.14/src/zrb/config/llm_config.py

@@ -0,0 +1,373 @@
+from typing import TYPE_CHECKING
+
+from zrb.config.config import CFG
+
+if TYPE_CHECKING:
+    from pydantic_ai.models import Model
+    from pydantic_ai.providers import Provider
+    from pydantic_ai.settings import ModelSettings
+
+
+_DEFAULT_PERSONA = "You are a helpful and efficient AI agent."
+
+_DEFAULT_INTERACTIVE_SYSTEM_PROMPT = (
+    "You are an expert AI agent in a CLI. You MUST follow this workflow for "
+    "this interactive session. Respond in GitHub-flavored Markdown.\n\n"
+    "1.  **Analyze and Clarify:** Understand the user's goal. If the request "
+    "is ambiguous, ask clarifying questions. Use your tools to gather "
+    "necessary information before proceeding.\n\n"
+    "2.  **Assess and Decide:**\n"
+    "    *   For **read-only** actions, proceed directly.\n"
+    "    *   For **destructive** actions (modifying or deleting data), you "
+    "MUST evaluate the risk. Consider the command's nature, the target's "
+    "importance (e.g., temp file vs. project file vs. system file), and the "
+    "user's specificity. Based on your assessment, decide the appropriate "
+    "course of action:\n"
+    "        *   **Low Risk:** Proceed directly.\n"
+    "        *   **Moderate Risk:** Proceed, but issue a warning.\n"
+    "        *   **High Risk or Vague Request:** Formulate a plan and ask "
+    "for approval.\n"
+    "        *   **Extreme Risk (e.g., operating on critical system "
+    "files):** Refuse and explain the danger.\n\n"
+    "3.  **Execute and Verify (The E+V Loop):**\n"
+    "    *   Execute the action.\n"
+    "    *   **CRITICAL:** Immediately after execution, you MUST use a tool "
+    "to verify the outcome (e.g., after `write_file`, use `read_file`; "
+    "after `rm`, use `ls` to confirm absence).\n\n"
+    "4.  **Report Results:**\n"
+    "    *   Provide a concise summary of the action taken.\n"
+    "    *   **You MUST explicitly state how you verified the action** (e.g., "
+    "'I have deleted the file and verified its removal by listing the "
+    "directory.').\n"
+    "    *   If an error occurs, report the error and the failed verification "
+    "step."
+).strip()
+
+_DEFAULT_SYSTEM_PROMPT = (
+    "You are an expert AI agent executing a one-shot CLI command. You MUST "
+    "follow this workflow. Your final output MUST be in GitHub-flavored "
+    "Markdown.\n\n"
+    "1.  **Plan:** Internally devise a step-by-step plan. This plan MUST "
+    "include verification steps for each action.\n\n"
+    "2.  **Execute and Verify (The E+V Loop):**\n"
+    "    *   Execute each step of your plan.\n"
+    "    *   **CRITICAL:** After each step, you MUST use a tool to verify "
+    "the outcome (e.g., check exit codes, read back file contents, check "
+    "system state).\n\n"
+    "3.  **Report Final Outcome:**\n"
+    "    *   Provide a concise summary of the result.\n"
+    "    *   **You MUST explicitly state how you verified the final state** "
+    "(e.g., 'The script was executed, and I verified its success by checking "
+    "for the presence of the output file `results.txt`.').\n"
+    "    *   If an error occurred, report the error and the failed "
+    "verification step."
+).strip()
+
+_DEFAULT_SPECIAL_INSTRUCTION_PROMPT = (
+    "## Guiding Principles\n"
+    "- **Safety First:** Never run commands that are destructive or could "
+    "compromise the system without explicit user confirmation. When in "
+    "doubt, ask.\n"
+    "- **Adhere to Conventions:** When working within a project, analyze "
+    "existing code, files, and configuration to match its style and "
+    "conventions.\n"
+    "- **Efficiency:** Use your tools to get the job done with the minimum "
+    "number of steps. Combine commands where possible.\n\n"
+    "## Common Task Workflows\n\n"
+    "**File System Operations:**\n"
+    "1.  **Analyze:** Before modifying, read the file or list the "
+    "directory.\n"
+    "2.  **Execute:** Perform the write, delete, or move operation.\n"
+    "3.  **Verify:** Check that the file/directory now exists (or doesn't) in "
+    "its expected state.\n\n"
+    "**Code & Software Development:**\n"
+    "1.  **Understand:** Use tools to analyze the codebase, dependencies, "
+    "and existing patterns.\n"
+    "2.  **Plan:** For non-trivial changes, formulate a plan.\n"
+    "3.  **Implement:** Make the changes, strictly adhering to project "
+    "conventions.\n"
+    "4.  **Verify:** Run all relevant tests, linters, and build commands to "
+    "ensure your changes are correct and meet quality standards.\n\n"
+    "**Research & Analysis:**\n"
+    "1.  **Clarify:** Understand the core question and the desired output "
+    "format.\n"
+    "2.  **Search:** Use web search tools to gather information from multiple "
+    "reputable sources.\n"
+    "3.  **Synthesize & Cite:** Present the information clearly. For factual "
+    "claims, cite the source URL."
+).strip()
+
+
+_DEFAULT_SUMMARIZATION_PROMPT = (
+    "You are a Conversation Historian. Your task is to create a dense, "
+    "structured snapshot of the conversation for the main assistant.\n\n"
+    "You will receive a `Previous Summary` and the `Recent Conversation "
+    "History`. Your goal is to produce an updated, rolling summary. Your "
+    "output MUST be a single block of text with two sections:\n\n"
+    "1.  `## Narrative Summary`\n"
+    "    - **Identify Key Information:** From the `Recent Conversation "
+    "History`, extract critical facts, user decisions, and final outcomes "
+    "of tasks.\n"
+    "    - **Integrate and Condense:** Integrate these key facts into the "
+    "`Previous Summary`. Discard conversational filler and intermediate "
+    "steps of completed tasks (e.g., 'User asked to see file X, I showed "
+    "them' can be discarded if the file was just a step towards a larger "
+    "goal). The summary should reflect the current state of the project or "
+    "conversation, not a log of every single turn.\n\n"
+    "2.  `## Transcript`\n"
+    "    - The Transcript is the assistant's working memory. It MUST "
+    "contain the last few turns of the conversation in full detail.\n"
+    "    - **CRITICAL REQUIREMENT:** The assistant's last response MUST be "
+    "COPIED VERBATIM into the Transcript. Do not alter it."
+).strip()
+
+
+_DEFAULT_CONTEXT_ENRICHMENT_PROMPT = (
+    "You are a Memory Curator. Your sole purpose is to produce a concise, "
+    "up-to-date Markdown block of long-term context.\n\n"
+    "You will be given the `Previous Long-Term Context` and the `Recent "
+    "Conversation History`. Your job is to return a NEW, UPDATED version of "
+    "the `Long-Term Context` by applying these rules:\n\n"
+    "**Curation Heuristics:**\n"
+    "- **Extract Stable Facts:** Identify durable information such as user "
+    "preferences (e.g., 'I prefer tabs over spaces'), project-level "
+    "decisions, or architectural choices.\n"
+    "- **Integrate, Don't Just Append:** Update existing facts if new "
+    "information overrides them. Merge related facts to keep the context "
+    "dense.\n"
+    "- **Discard Ephemeral Details:** Omit temporary states, resolved "
+    "errors, and one-off requests that do not reflect a permanent preference "
+    "or project state.\n"
+    "- **Mark Dynamic Info:** For temporary information that must be "
+    "retained (e.g., CWD, contents of a file being actively edited), you "
+    "MUST add a note: `(short-term, must be re-verified)`."
+).strip()
+
+
+class LLMConfig:
+
+    def __init__(
+        self,
+        default_model_name: str | None = None,
+        default_base_url: str | None = None,
+        default_api_key: str | None = None,
+        default_persona: str | None = None,
+        default_system_prompt: str | None = None,
+        default_interactive_system_prompt: str | None = None,
+        default_special_instruction_prompt: str | None = None,
+        default_summarization_prompt: str | None = None,
+        default_context_enrichment_prompt: str | None = None,
+        default_summarize_history: bool | None = None,
+        default_history_summarization_token_threshold: int | None = None,
+        default_enrich_context: bool | None = None,
+        default_context_enrichment_token_threshold: int | None = None,
+        default_model: "Model | None" = None,
+        default_model_settings: "ModelSettings | None" = None,
+        default_model_provider: "Provider | None" = None,
+    ):
+        self._default_model_name = default_model_name
+        self._default_model_base_url = default_base_url
+        self._default_model_api_key = default_api_key
+        self._default_persona = default_persona
+        self._default_system_prompt = default_system_prompt
+        self._default_interactive_system_prompt = default_interactive_system_prompt
+        self._default_special_instruction_prompt = default_special_instruction_prompt
+        self._default_summarization_prompt = default_summarization_prompt
+        self._default_context_enrichment_prompt = default_context_enrichment_prompt
+        self._default_summarize_history = default_summarize_history
+        self._default_history_summarization_token_threshold = (
+            default_history_summarization_token_threshold
+        )
+        self._default_enrich_context = default_enrich_context
+        self._default_context_enrichment_token_threshold = (
+            default_context_enrichment_token_threshold
+        )
+        self._default_model_settings = default_model_settings
+        self._default_model_provider = default_model_provider
+        self._default_model = default_model
+
+    @property
+    def default_model_name(self) -> str | None:
+        if self._default_model_name is not None:
+            return self._default_model_name
+        if CFG.LLM_MODEL is not None:
+            return CFG.LLM_MODEL
+        return None
+
+    @property
+    def default_model_base_url(self) -> str | None:
+        if self._default_model_base_url is not None:
+            return self._default_model_base_url
+        if CFG.LLM_BASE_URL is not None:
+            return CFG.LLM_BASE_URL
+        return None
+
+    @property
+    def default_model_api_key(self) -> str | None:
+        if self._default_model_api_key is not None:
+            return self._default_model_api_key
+        if CFG.LLM_API_KEY is not None:
+            return CFG.LLM_API_KEY
+
+    @property
+    def default_model_settings(self) -> "ModelSettings | None":
+        if self._default_model_settings is not None:
+            return self._default_model_settings
+        return None
+
+    @property
+    def default_model_provider(self) -> "Provider | str":
+        if self._default_model_provider is not None:
+            return self._default_model_provider
+        if self.default_model_base_url is None and self.default_model_api_key is None:
+            return "openai"
+        from pydantic_ai.providers.openai import OpenAIProvider
+
+        return OpenAIProvider(
+            base_url=self.default_model_base_url, api_key=self.default_model_api_key
+        )
+
+    @property
+    def default_system_prompt(self) -> str:
+        if self._default_system_prompt is not None:
+            return self._default_system_prompt
+        if CFG.LLM_SYSTEM_PROMPT is not None:
+            return CFG.LLM_SYSTEM_PROMPT
+        return _DEFAULT_SYSTEM_PROMPT
+
+    @property
+    def default_interactive_system_prompt(self) -> str:
+        if self._default_interactive_system_prompt is not None:
+            return self._default_interactive_system_prompt
+        if CFG.LLM_INTERACTIVE_SYSTEM_PROMPT is not None:
+            return CFG.LLM_INTERACTIVE_SYSTEM_PROMPT
+        return _DEFAULT_INTERACTIVE_SYSTEM_PROMPT
+
+    @property
+    def default_persona(self) -> str:
+        if self._default_persona is not None:
+            return self._default_persona
+        if CFG.LLM_PERSONA is not None:
+            return CFG.LLM_PERSONA
+        return _DEFAULT_PERSONA
+
+    @property
+    def default_special_instruction_prompt(self) -> str:
+        if self._default_special_instruction_prompt is not None:
+            return self._default_special_instruction_prompt
+        if CFG.LLM_SPECIAL_INSTRUCTION_PROMPT is not None:
+            return CFG.LLM_SPECIAL_INSTRUCTION_PROMPT
+        return _DEFAULT_SPECIAL_INSTRUCTION_PROMPT
+
+    @property
+    def default_summarization_prompt(self) -> str:
+        if self._default_summarization_prompt is not None:
+            return self._default_summarization_prompt
+        if CFG.LLM_SUMMARIZATION_PROMPT is not None:
+            return CFG.LLM_SUMMARIZATION_PROMPT
+        return _DEFAULT_SUMMARIZATION_PROMPT
+
+    @property
+    def default_context_enrichment_prompt(self) -> str:
+        if self._default_context_enrichment_prompt is not None:
+            return self._default_context_enrichment_prompt
+        if CFG.LLM_CONTEXT_ENRICHMENT_PROMPT is not None:
+            return CFG.LLM_CONTEXT_ENRICHMENT_PROMPT
+        return _DEFAULT_CONTEXT_ENRICHMENT_PROMPT
+
+    @property
+    def default_model(self) -> "Model | str | None":
+        if self._default_model is not None:
+            return self._default_model
+        model_name = self.default_model_name
+        if model_name is None:
+            return None
+        from pydantic_ai.models.openai import OpenAIModel
+
+        return OpenAIModel(
+            model_name=model_name,
+            provider=self.default_model_provider,
+        )
+
+    @property
+    def default_summarize_history(self) -> bool:
+        if self._default_summarize_history is not None:
+            return self._default_summarize_history
+        return CFG.LLM_SUMMARIZE_HISTORY
+
+    @property
+    def default_history_summarization_token_threshold(self) -> int:
+        if self._default_history_summarization_token_threshold is not None:
+            return self._default_history_summarization_token_threshold
+        return CFG.LLM_HISTORY_SUMMARIZATION_TOKEN_THRESHOLD
+
+    @property
+    def default_enrich_context(self) -> bool:
+        if self._default_enrich_context is not None:
+            return self._default_enrich_context
+        return CFG.LLM_ENRICH_CONTEXT
+
+    @property
+    def default_context_enrichment_token_threshold(self) -> int:
+        if self._default_context_enrichment_token_threshold is not None:
+            return self._default_context_enrichment_token_threshold
+        return CFG.LLM_CONTEXT_ENRICHMENT_TOKEN_THRESHOLD
+
+    def set_default_persona(self, persona: str):
+        self._default_persona = persona
+
+    def set_default_system_prompt(self, system_prompt: str):
+        self._default_system_prompt = system_prompt
+
+    def set_default_interactive_system_prompt(self, interactive_system_prompt: str):
+        self._default_interactive_system_prompt = interactive_system_prompt
+
+    def set_default_special_instruction_prompt(self, special_instruction_prompt: str):
+        self._default_special_instruction_prompt = special_instruction_prompt
+
+    def set_default_summarization_prompt(self, summarization_prompt: str):
+        self._default_summarization_prompt = summarization_prompt
+
+    def set_default_context_enrichment_prompt(self, context_enrichment_prompt: str):
+        self._default_context_enrichment_prompt = context_enrichment_prompt
+
+    def set_default_model_name(self, model_name: str):
+        self._default_model_name = model_name
+
+    def set_default_model_api_key(self, model_api_key: str):
+        self._default_model_api_key = model_api_key
+
+    def set_default_model_base_url(self, model_base_url: str):
+        self._default_model_base_url = model_base_url
+
+    def set_default_model_provider(self, provider: "Provider | str"):
+        self._default_model_provider = provider
+
+    def set_default_model(self, model: "Model | str"):
+        self._default_model = model
+
+    def set_default_summarize_history(self, summarize_history: bool):
+        self._default_summarize_history = summarize_history
+
+    def set_default_history_summarization_token_threshold(
+        self, history_summarization_token_threshold: int
+    ):
+        self._default_history_summarization_token_threshold = (
+            history_summarization_token_threshold
+        )
+
+    def set_default_enrich_context(self, enrich_context: bool):
+        self._default_enrich_context = enrich_context
+
+    def set_default_context_enrichment_token_threshold(
+        self, context_enrichment_token_threshold: int
+    ):
+        self._default_context_enrichment_token_threshold = (
+            context_enrichment_token_threshold
+        )
+
+    def set_default_model_settings(self, model_settings: "ModelSettings"):
+        self._default_model_settings = model_settings
+
+
+llm_config = LLMConfig()

{zrb-1.9.12 → zrb-1.9.14}/src/zrb/task/llm/error.py

@@ -1,18 +1,34 @@
 import json
-from typing import TYPE_CHECKING, Optional
-
-from pydantic import BaseModel
+from typing import TYPE_CHECKING, Any, Optional
 
 if TYPE_CHECKING:
     from openai import APIError
 
 
 # Define a structured error model for tool execution failures
-class ToolExecutionError(BaseModel):
-    tool_name: str
-    error_type: str
-    message: str
-    details: Optional[str] = None
+class ToolExecutionError:
+    def __init__(
+        self,
+        tool_name: str,
+        error_type: str,
+        message: str,
+        details: Optional[str] = None,
+    ):
+        self.tool_name = tool_name
+        self.error_type = error_type
+        self.message = message
+        self.details = details
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "tool_name": self.tool_name,
+            "error_type": self.error_type,
+            "message": self.message,
+            "details": self.details,
+        }
+
+    def model_dump_json(self, indent: int = 2) -> str:
+        return json.dumps(self.to_dict(), indent=indent)
 
 
 def extract_api_error_details(error: "APIError") -> str:

{zrb-1.9.12 → zrb-1.9.14}/src/zrb/task/rsync_task.py

@@ -65,7 +65,7 @@ class RsyncTask(CmdTask):
             remote_host=remote_host,
             render_remote_host=render_remote_host,
             remote_port=remote_port,
-            auto_render_remote_port=render_remote_port,
+            render_remote_port=render_remote_port,
             remote_user=remote_user,
             render_remote_user=render_remote_user,
             remote_password=remote_password,

zrb-1.9.14/src/zrb/util/git_diff_model.py

@@ -0,0 +1,10 @@
+class DiffResult:
+    def __init__(
+        self,
+        created: list[str] | None = None,
+        removed: list[str] | None = None,
+        updated: list[str] | None = None,
+    ):
+        self.created = created if created is not None else []
+        self.removed = removed if removed is not None else []
+        self.updated = updated if updated is not None else []

zrb-1.9.14/src/zrb/util/git_subtree_model.py

@@ -0,0 +1,32 @@
+import json
+from typing import Any
+
+
+class SingleSubTreeConfig:
+    def __init__(self, repo_url: str, branch: str, prefix: str):
+        self.repo_url = repo_url
+        self.branch = branch
+        self.prefix = prefix
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "repo_url": self.repo_url,
+            "branch": self.branch,
+            "prefix": self.prefix,
+        }
+
+    def model_dump_json(self, indent: int = 2) -> str:
+        return json.dumps(self.to_dict(), indent=indent)
+
+
+class SubTreeConfig:
+    def __init__(self, data: dict[str, SingleSubTreeConfig]):
+        self.data = data
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "data": {k: self.data[k].to_dict() for k in self.data},
+        }
+
+    def model_dump_json(self, indent: int = 2) -> str:
+        return json.dumps(self.to_dict(), indent=indent)

{zrb-1.9.12 → zrb-1.9.14}/src/zrb/util/string/conversion.py

@@ -178,7 +178,7 @@ def pluralize(noun: str) -> str:
     if noun.lower() in irregulars:
         return irregulars[noun.lower()]
     # Handle words ending in 'y' preceded by a consonant
-    if noun.endswith("y") and not re.match(r"[aeiou]y$", noun):
+    if noun.endswith("y") and not re.match(r".*[aeiou]y$", noun, re.IGNORECASE):
         return re.sub(r"y$", "ies", noun)
     # Handle words ending in 's', 'x', 'z', 'ch', or 'sh'
     if re.search(r"(s|x|z|ch|sh)$", noun):