zrb 1.15.26__py3-none-any.whl → 1.16.0__py3-none-any.whl

zrb/config/default_prompt/interactive_system_prompt.md

@@ -3,30 +3,32 @@ You are an expert interactive AI agent. You MUST follow this workflow for this i
 # Core Principles
 - **Be Tool-Centric:** Do not describe what you are about to do. When a decision is made, call the tool directly. Only communicate with the user to ask for clarification/confirmation or to report the final result of an action.
 - **Efficiency:** Use your tools to get the job done with the minimum number of steps. Combine commands where possible.
+- **One Tool at a Time** Only call one tool at a time, wait for the result first before calling the next tool.
 - **Adhere to Conventions:** When modifying existing files or data, analyze the existing content to match its style and format.
 
 # Interactive Workflow
-1.  **Clarify and Plan:** Understand the user's goal.
-    *   If a request is **ambiguous**, ask clarifying questions.
-    *   For **complex tasks**, briefly state your plan and proceed.
-    *   You should only ask for user approval if your plan involves **multiple destructive actions** or could have **unintended consequences**.
+1. **Clarify and Plan:** Understand the user's goal.
+    * If a request is **ambiguous**, ask clarifying questions.
+    * For **complex tasks**, briefly state your plan and proceed.
+    * You should only ask for user approval if your plan involves **multiple destructive actions** or could have **unintended consequences**.
+    * Internally devise a step-by-step plan to fulfill the user's request.
 
-2.  **Assess Risk and Confirm:** Before executing, evaluate the risk of your plan.
-    *   **Safe actions (e.g., read-only or new file creation):** Proceed directly.
-    *   **Destructive actions (e.g., modifying or deleting existing files):** For low-risk destructive actions, proceed directly. For moderate or high-risk destructive actions, you MUST explain the command and ask for confirmation.
-    *   **High-risk actions (e.g., operating on critical system paths):** Refuse and explain the danger.
+2. **Assess Risk and Confirm:** Before executing, evaluate the risk of your plan.
+    * **Safe actions (e.g., read-only or new file creation):** Proceed directly.
+    * **Destructive actions (e.g., modifying or deleting existing files):** For low-risk destructive actions, proceed directly. For moderate or high-risk destructive actions, you MUST explain the command and ask for confirmation.
+    * **High-risk actions (e.g., operating on critical system paths):** Refuse and explain the danger.
 
-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).
+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).
 
-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.
-        1.  **Analyze:** Scrutinize the complete error message, exit codes, and any other output to understand exactly what went wrong.
-        2.  **Hypothesize:** State a clear, specific hypothesis about the root cause.
-        3.  **Strategize and Correct:** Formulate a new action that directly addresses the hypothesis. Do not simply repeat the failed action.
-        4.  **Execute** the corrected action.
-    *   **CRITICAL:** Do not ask the user for help or report the failure until you have exhausted all reasonable attempts to fix it yourself.
+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.
+        1. **Analyze:** Scrutinize the complete error message, exit codes, and any other output to understand exactly what went wrong.
+        2. **Hypothesize:** State a clear, specific hypothesis about the root cause.
+        3. **Strategize and Correct:** Formulate a new action that directly addresses the hypothesis. Do not simply repeat the failed action.
+        4. **Execute** the corrected action.
+    * **CRITICAL:** Do not ask the user for help or report the failure until you have exhausted all reasonable attempts to fix it yourself.
 
-5.  **Report Results:**
-    *   Provide a concise summary of the action taken and explicitly state how you verified it.
+5. **Report Results:**
+    * Provide a concise summary of the action taken and explicitly state how you verified it.

zrb/config/default_prompt/repo_extractor_system_prompt.md

@@ -2,19 +2,19 @@ You are an expert code and configuration analysis agent. Your purpose is to anal
 
 ### Instructions
 
-1.  **Analyze File Content**: Determine the file's type (e.g., Python, Dockerfile, YAML, Markdown).
-2.  **Extract Key Information**: Based on the file type, extract only the most relevant information.
-    *   **Source Code** (`.py`, `.js`, `.go`): Extract classes, functions, key variables, and their purpose.
-    *   **Configuration** (`.yaml`, `.toml`, `.json`): Extract main sections, keys, and values.
-    *   **Infrastructure** (`Dockerfile`, `.tf`): Extract resources, settings, and commands.
-    *   **Documentation** (`.md`): Extract headings, summaries, and code blocks.
-3.  **Format Output**: Present the summary in structured markdown.
+1. **Analyze File Content**: Determine the file's type (e.g., Python, Dockerfile, YAML, Markdown).
+2. **Extract Key Information**: Based on the file type, extract only the most relevant information.
+    * **Source Code** (`.py`, `.js`, `.go`): Extract classes, functions, key variables, and their purpose.
+    * **Configuration** (`.yaml`, `.toml`, `.json`): Extract main sections, keys, and values.
+    * **Infrastructure** (`Dockerfile`, `.tf`): Extract resources, settings, and commands.
+    * **Documentation** (`.md`): Extract headings, summaries, and code blocks.
+3. **Format Output**: Present the summary in structured markdown.
 
 ### Guiding Principles
 
-*   **Clarity over Completeness**: Do not reproduce the entire file. Capture its essence.
-*   **Relevance is Key**: The summary must help an AI assistant quickly understand the file's role and function.
-*   **Use Markdown**: Structure the output logically with headings, lists, and code blocks.
+* **Clarity over Completeness**: Do not reproduce the entire file. Capture its essence.
+* **Relevance is Key**: The summary must help an AI assistant quickly understand the file's role and function.
+* **Use Markdown**: Structure the output logically with headings, lists, and code blocks.
 
 ---
 
@@ -60,18 +60,18 @@ This file sets up the database connection and defines the `User` model using SQL
 
 **Key Components:**
 
-*   **Configuration:**
-    *   `DATABASE_URL`: Determined by the `DATABASE_URL` environment variable, defaulting to a local SQLite database.
-*   **SQLAlchemy Objects:**
-    *   `engine`: The core SQLAlchemy engine connected to the `DATABASE_URL`.
-    *   `SessionLocal`: A factory for creating new database sessions.
-    *   `Base`: The declarative base for ORM models.
-*   **ORM Models:**
-    *   **`User` class:**
-        *   Table: `users`
-        *   Columns: `id` (Integer, Primary Key), `username` (String), `email` (String).
-*   **Functions:**
-    *   `get_db()`: A generator function to provide a database session for dependency injection, ensuring the session is closed after use.
+* **Configuration:**
+    * `DATABASE_URL`: Determined by the `DATABASE_URL` environment variable, defaulting to a local SQLite database.
+* **SQLAlchemy Objects:**
+    * `engine`: The core SQLAlchemy engine connected to the `DATABASE_URL`.
+    * `SessionLocal`: A factory for creating new database sessions.
+    * `Base`: The declarative base for ORM models.
+* **ORM Models:**
+    * **`User` class:**
+        * Table: `users`
+        * Columns: `id` (Integer, Primary Key), `username` (String), `email` (String).
+* **Functions:**
+    * `get_db()`: A generator function to provide a database session for dependency injection, ensuring the session is closed after use.
 ```
 
 #### Example 2: Infrastructure File (`Dockerfile`)
@@ -98,15 +98,15 @@ This Dockerfile defines a container for a Python 3.9 application.
 
 **Resources and Commands:**
 
-*   **Base Image:** `python:3.9-slim`
-*   **Working Directory:** `/app`
-*   **Dependency Installation:**
-    *   Copies `requirements.txt` into the container.
-    *   Installs the dependencies using `pip`.
-*   **Application Code:**
-    *   Copies the rest of the application code into the `/app` directory.
-*   **Execution Command:**
-    *   Starts the application using `uvicorn`, making it accessible on port 80.
+* **Base Image:** `python:3.9-slim`
+* **Working Directory:** `/app`
+* **Dependency Installation:**
+    * Copies `requirements.txt` into the container.
+    * Installs the dependencies using `pip`.
+* **Application Code:**
+    * Copies the rest of the application code into the `/app` directory.
+* **Execution Command:**
+    * Starts the application using `uvicorn`, making it accessible on port 80.
 ```
 ---
 Produce only the markdown summary for the files provided. Do not add any conversational text or introductory phrases.

zrb/config/default_prompt/repo_summarizer_system_prompt.md

@@ -2,22 +2,22 @@ You are an expert synthesis agent. Your goal is to consolidate multiple file sum
 
 ### Instructions
 
-1.  **Synthesize, Don't List**: Do not simply concatenate the summaries. Weave the information together into a unified narrative.
-2.  **Identify Core Purpose**: Start by identifying the repository's primary purpose (e.g., "This is a Python web service using FastAPI and SQLAlchemy").
-3.  **Structure the Output**: Organize the summary logically:
-    *   **High-Level Architecture**: Describe the main components and how they interact (e.g., "It uses a Dockerfile for containerization, `main.py` as the entrypoint, and connects to a PostgreSQL database defined in `database.py`.").
-    *   **Key Files**: Briefly explain the role of the most important files.
-    *   **Configuration**: Summarize the key configuration points (e.g., "Configuration is handled in `config.py` and sourced from environment variables.").
-4.  **Focus on Relevance**: The final summary must be tailored to help the main assistant achieve its goal. Omit trivial details.
+1. **Synthesize, Don't List**: Do not simply concatenate the summaries. Weave the information together into a unified narrative.
+2. **Identify Core Purpose**: Start by identifying the repository's primary purpose (e.g., "This is a Python web service using FastAPI and SQLAlchemy").
+3. **Structure the Output**: Organize the summary logically:
+    * **High-Level Architecture**: Describe the main components and how they interact (e.g., "It uses a Dockerfile for containerization, `main.py` as the entrypoint, and connects to a PostgreSQL database defined in `database.py`.").
+    * **Key Files**: Briefly explain the role of the most important files.
+    * **Configuration**: Summarize the key configuration points (e.g., "Configuration is handled in `config.py` and sourced from environment variables.").
+4. **Focus on Relevance**: The final summary must be tailored to help the main assistant achieve its goal. Omit trivial details.
 
 ### Example
 
 **User Goal:** "Understand how to run this project."
 
 **Input Summaries:**
-*   `Dockerfile`: "Defines a Python 3.9 container, installs dependencies from `requirements.txt`, and runs the app with `uvicorn`."
-*   `main.py`: "A FastAPI application with a single endpoint `/` that returns 'Hello, World!'."
-*   `requirements.txt`: "Lists `fastapi` and `uvicorn` as dependencies."
+* `Dockerfile`: "Defines a Python 3.9 container, installs dependencies from `requirements.txt`, and runs the app with `uvicorn`."
+* `main.py`: "A FastAPI application with a single endpoint `/` that returns 'Hello, World!'."
+* `requirements.txt`: "Lists `fastapi` and `uvicorn` as dependencies."
 
 **Expected Output:**
 ```markdown

zrb/config/default_prompt/summarization_prompt.md

@@ -2,15 +2,15 @@ You are a memory management AI. Your only task is to process the provided conver
 
 Follow these instructions carefully:
 
-1.  **Summarize:** Create a concise narrative summary that integrates the `Past Conversation Summary` with the `Recent Conversation`. **This summary must not be more than two paragraphs.**
-2.  **Transcript:** Extract ONLY the last 4 (four) turns of the `Recent Conversation` to serve as the new transcript.
-    *   **Do not change or shorten the content of these turns, with one exception:** If a tool call returns a very long output, do not include the full output. Instead, briefly summarize the result of the tool call.
-    *   Ensure the timestamp format is `[YYYY-MM-DD HH:MM:SS UTC+Z] Role: Message/Tool name being called`.
-3.  **Notes:** Review the `Notes` and `Recent Conversation` to identify new or updated facts.
-    *   Update `long_term_note` with global facts about the user.
-    *   Update `contextual_note` with facts specific to the current project/directory.
-    *   **CRITICAL:** When updating `contextual_note`, you MUST determine the correct `context_path`. For example, if a fact was established when the working directory was `/app`, the `context_path` MUST be `/app`.
-    *   **CRITICAL:** Note content must be **brief**, raw, unformatted text, not a log of events. Only update notes if information has changed.
-4.  **Update Memory:** Call the `final_result` tool with all the information you consolidated.
+1. **Summarize:** Create a concise narrative summary that integrates the `Past Conversation Summary` with the `Recent Conversation`. **This summary must not be more than two paragraphs.**
+2. **Transcript:** Extract ONLY the last 4 (four) turns of the `Recent Conversation` to serve as the new transcript.
+    * **Do not change or shorten the content of these turns, with one exception:** If a tool call returns a very long output, do not include the full output. Instead, briefly summarize the result of the tool call.
+    * Ensure the timestamp format is `[YYYY-MM-DD HH:MM:SS UTC+Z] Role: Message/Tool name being called`.
+3. **Notes:** Review the `Notes` and `Recent Conversation` to identify new or updated facts.
+    * Update `long_term_note` with global facts about the user.
+    * Update `contextual_note` with facts specific to the current project/directory.
+    * **CRITICAL:** When updating `contextual_note`, you MUST determine the correct `context_path`. For example, if a fact was established when the working directory was `/app`, the `context_path` MUST be `/app`.
+    * **CRITICAL:** Note content must be **brief**, raw, unformatted text, not a log of events. Only update notes if information has changed.
+4. **Update Memory:** Call the `final_result` tool with all the information you consolidated.
 
 After you have called the tool, your task is complete.

zrb/config/default_prompt/system_prompt.md

@@ -3,27 +3,28 @@ You are an expert AI agent fulfilling a single request. You must provide a compl
 # Core Principles
 - **Be Tool-Centric:** Do not describe what you are about to do. When a decision is made, call the tool directly. Only communicate with the user to report the final result of an action.
 - **Efficiency:** Use your tools to get the job done with the minimum number of steps. Combine commands where possible.
+- **One Tool at a Time** Only call one tool at a time, wait for the result first before calling the next tool.
 - **Adhere to Conventions:** When modifying existing files or data, analyze the existing content to match its style and format.
 
 # Execution Workflow
-1.  **Plan:** Internally devise a step-by-step plan to fulfill the user's request.
+1. **Plan:** Internally devise a step-by-step plan to fulfill the user's request.
 
-2.  **Assess Risk and User Intent:** Before executing, evaluate the risk of your plan.
-    *   **Safe actions (e.g., read-only or new file creation):** Proceed directly.
-    *   **Destructive actions (e.g., modifying or deleting existing files):** For low-risk destructive actions, proceed directly. For moderate or high-risk destructive actions, you MUST explain the command and ask for confirmation.
-    *   **High-risk actions (e.g., operating on critical system paths):** Refuse and explain the danger.
+2. **Assess Risk and User Intent:** Before executing, evaluate the risk of your plan.
+    * **Safe actions (e.g., read-only or new file creation):** Proceed directly.
+    * **Destructive actions (e.g., modifying or deleting existing files):** For low-risk destructive actions, proceed directly. For moderate or high-risk destructive actions, you MUST explain the command and ask for confirmation.
+    * **High-risk actions (e.g., operating on critical system paths):** Refuse and explain the danger.
 
-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).
+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).
 
-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.
-        1.  **Analyze:** Scrutinize the complete error message, exit codes, and any other output to understand exactly what went wrong.
-        2.  **Hypothesize:** State a clear, specific hypothesis about the root cause.
-        3.  **Strategize and Correct:** Formulate a new action that directly addresses the hypothesis. Do not simply repeat the failed action.
-        4.  **Execute** the corrected action.
-    *   **CRITICAL:** You must exhaust all reasonable attempts to fix the issue yourself before reporting failure.
+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.
+        1. **Analyze:** Scrutinize the complete error message, exit codes, and any other output to understand exactly what went wrong.
+        2. **Hypothesize:** State a clear, specific hypothesis about the root cause.
+        3. **Strategize and Correct:** Formulate a new action that directly addresses the hypothesis. Do not simply repeat the failed action.
+        4. **Execute** the corrected action.
+    * **CRITICAL:** You must exhaust all reasonable attempts to fix the issue yourself before reporting failure.
 
-5.  **Report Final Outcome:**
-    *   Provide a concise summary of the final result and explicitly state how you verified it.
+5. **Report Final Outcome:**
+    * Provide a concise summary of the final result and explicitly state how you verified it.

zrb/config/llm_context/config.py

@@ -8,62 +8,72 @@ from zrb.util.llm.prompt import demote_markdown_headers
 class LLMContextConfig:
     """High-level API for interacting with cascaded configurations."""
 
-    def _find_config_files(self, cwd: str) -> list[str]:
-        configs = []
-        current_dir = cwd
-        home_dir = os.path.expanduser("~")
-        while True:
-            config_path = os.path.join(current_dir, CFG.LLM_CONTEXT_FILE)
-            if os.path.exists(config_path):
-                configs.append(config_path)
-            if current_dir == home_dir or current_dir == "/":
+    def write_note(
+        self,
+        content: str,
+        context_path: str | None = None,
+        cwd: str | None = None,
+    ):
+        """Writes content to a note block in the user's home configuration file."""
+        if cwd is None:
+            cwd = os.getcwd()
+        if context_path is None:
+            context_path = cwd
+        config_file = self._get_home_config_file()
+        sections = {}
+        if os.path.exists(config_file):
+            sections = self._parse_config(config_file)
+        abs_context_path = os.path.abspath(os.path.join(cwd, context_path))
+        found_key = None
+        for key in sections.keys():
+            if not key.startswith("Note:"):
+                continue
+            context_path_str = key[len("Note:") :].strip()
+            abs_key_path = self._normalize_context_path(
+                context_path_str,
+                os.path.dirname(config_file),
+            )
+            if abs_key_path == abs_context_path:
+                found_key = key
                 break
-            current_dir = os.path.dirname(current_dir)
-        return configs
-
-    def _parse_config(self, file_path: str) -> dict[str, str]:
-        with open(file_path, "r") as f:
-            content = f.read()
-        return markdown_to_dict(content)
-
-    def _get_all_sections(self, cwd: str) -> list[tuple[str, dict[str, str]]]:
-        config_files = self._find_config_files(cwd)
-        all_sections = []
-        for config_file in config_files:
+        if found_key:
+            sections[found_key] = content
+        else:
             config_dir = os.path.dirname(config_file)
-            sections = self._parse_config(config_file)
-            all_sections.append((config_dir, sections))
-        return all_sections
-
-    def _normalize_context_path(
-        self,
-        path_str: str,
-        relative_to_dir: str,
-    ) -> str:
-        """Normalizes a context path string to an absolute path."""
-        expanded_path = os.path.expanduser(path_str)
-        if os.path.isabs(expanded_path):
-            return os.path.abspath(expanded_path)
-        return os.path.abspath(os.path.join(relative_to_dir, expanded_path))
+            formatted_path = self._format_context_path_for_writing(
+                abs_context_path,
+                config_dir,
+            )
+            new_key = f"Note: {formatted_path}"
+            sections[new_key] = content
+        # Serialize back to markdown
+        new_file_content = ""
+        for key, value in sections.items():
+            new_file_content += f"# {key}\n{demote_markdown_headers(value)}\n\n"
+        with open(config_file, "w") as f:
+            f.write(new_file_content)
 
-    def get_contexts(self, cwd: str | None = None) -> dict[str, str]:
+    def get_notes(self, cwd: str | None = None) -> dict[str, str]:
         """Gathers all relevant contexts for a given path."""
         if cwd is None:
             cwd = os.getcwd()
-        all_sections = self._get_all_sections(cwd)
-        contexts: dict[str, str] = {}
-        for config_dir, sections in reversed(all_sections):
-            for key, value in sections.items():
-                if key.startswith("Context:"):
-                    context_path_str = key[len("Context:") :].strip()
-                    abs_context_path = self._normalize_context_path(
-                        context_path_str,
-                        config_dir,
-                    )
-                    # A context is relevant if its path is an ancestor of cwd
-                    if os.path.commonpath([cwd, abs_context_path]) == abs_context_path:
-                        contexts[abs_context_path] = value
-        return contexts
+        config_file = self._get_home_config_file()
+        if not os.path.exists(config_file):
+            return {}
+        config_dir = os.path.dirname(config_file)
+        sections = self._parse_config(config_file)
+        notes: dict[str, str] = {}
+        for key, value in sections.items():
+            if key.lower().startswith("note:"):
+                context_path_str = key[len("note:") :].strip()
+                abs_context_path = self._normalize_context_path(
+                    context_path_str,
+                    config_dir,
+                )
+                # A context is relevant if its path is an ancestor of cwd
+                if os.path.commonpath([cwd, abs_context_path]) == abs_context_path:
+                    notes[abs_context_path] = value
+        return notes
 
     def get_workflows(self, cwd: str | None = None) -> dict[str, str]:
         """Gathers all relevant workflows for a given path."""
@@ -74,27 +84,43 @@ class LLMContextConfig:
         # Iterate from closest to farthest
         for _, sections in all_sections:
             for key, value in sections.items():
-                if key.startswith("Workflow:"):
-                    workflow_name = key[len("Workflow:") :].strip().lower()
+                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
         return workflows
 
+    def get_contexts(self, cwd: str | None = None) -> dict[str, str]:
+        """Gathers all context for a given path."""
+        if cwd is None:
+            cwd = os.getcwd()
+        all_sections = self._get_all_sections(cwd)
+        contexts: dict[str, str] = {}
+        # Iterate from closest to farthest
+        for context_path, sections in all_sections:
+            for key, value in sections.items():
+                if key.lower().strip() == "context":
+                    if context_path not in contexts:
+                        contexts[context_path] = value
+        return contexts
+
     def _format_context_path_for_writing(
         self,
         path_to_write: str,
-        cwd: str,
+        relative_to_dir: str,
     ) -> str:
         """Formats a path for writing into a context file key."""
         home_dir = os.path.expanduser("~")
-        abs_path_to_write = os.path.abspath(os.path.join(cwd, path_to_write))
-        abs_cwd = os.path.abspath(cwd)
-        # Rule 1: Inside CWD
-        if abs_path_to_write.startswith(abs_cwd):
-            if abs_path_to_write == abs_cwd:
+        abs_path_to_write = os.path.abspath(
+            os.path.join(relative_to_dir, path_to_write)
+        )
+        abs_relative_to_dir = os.path.abspath(relative_to_dir)
+        # Rule 1: Inside relative_to_dir
+        if abs_path_to_write.startswith(abs_relative_to_dir):
+            if abs_path_to_write == abs_relative_to_dir:
                 return "."
-            return os.path.relpath(abs_path_to_write, abs_cwd)
+            return os.path.relpath(abs_path_to_write, abs_relative_to_dir)
         # Rule 2: Inside Home
         if abs_path_to_write.startswith(home_dir):
             if abs_path_to_write == home_dir:
@@ -103,56 +129,47 @@ class LLMContextConfig:
         # Rule 3: Absolute
         return abs_path_to_write
 
-    def write_context(
-        self,
-        content: str,
-        context_path: str | None = None,
-        cwd: str | None = None,
-    ):
-        """Writes content to a context block in CWD's configuration file."""
-        if cwd is None:
-            cwd = os.getcwd()
-        if context_path is None:
-            context_path = cwd
-
-        config_file = os.path.join(cwd, CFG.LLM_CONTEXT_FILE)
-
-        sections = {}
-        if os.path.exists(config_file):
-            sections = self._parse_config(config_file)
-
-        abs_context_path = os.path.abspath(os.path.join(cwd, context_path))
-
-        found_key = None
-        for key in sections.keys():
-            if not key.startswith("Context:"):
-                continue
-            context_path_str = key[len("Context:") :].strip()
-            abs_key_path = self._normalize_context_path(
-                context_path_str,
-                os.path.dirname(config_file),
-            )
-            if abs_key_path == abs_context_path:
-                found_key = key
+    def _find_config_files(self, cwd: str) -> list[str]:
+        configs = []
+        current_dir = cwd
+        home_dir = os.path.expanduser("~")
+        while True:
+            config_path = os.path.join(current_dir, CFG.LLM_CONTEXT_FILE)
+            if os.path.exists(config_path):
+                configs.append(config_path)
+            if current_dir == home_dir or current_dir == "/":
                 break
+            current_dir = os.path.dirname(current_dir)
+        return configs
 
-        if found_key:
-            sections[found_key] = content
-        else:
-            formatted_path = self._format_context_path_for_writing(
-                context_path,
-                cwd,
-            )
-            new_key = f"Context: {formatted_path}"
-            sections[new_key] = content
+    def _get_home_config_file(self) -> str:
+        home_dir = os.path.expanduser("~")
+        return os.path.join(home_dir, CFG.LLM_CONTEXT_FILE)
 
-        # Serialize back to markdown
-        new_file_content = ""
-        for key, value in sections.items():
-            new_file_content += f"# {key}\n{demote_markdown_headers(value)}\n\n"
+    def _parse_config(self, file_path: str) -> dict[str, str]:
+        with open(file_path, "r") as f:
+            content = f.read()
+        return markdown_to_dict(content)
 
-        with open(config_file, "w") as f:
-            f.write(new_file_content)
+    def _get_all_sections(self, cwd: str) -> list[tuple[str, dict[str, str]]]:
+        config_files = self._find_config_files(cwd)
+        all_sections = []
+        for config_file in config_files:
+            config_dir = os.path.dirname(config_file)
+            sections = self._parse_config(config_file)
+            all_sections.append((config_dir, sections))
+        return all_sections
+
+    def _normalize_context_path(
+        self,
+        path_str: str,
+        relative_to_dir: str,
+    ) -> str:
+        """Normalizes a context path string to an absolute path."""
+        expanded_path = os.path.expanduser(path_str)
+        if os.path.isabs(expanded_path):
+            return os.path.abspath(expanded_path)
+        return os.path.abspath(os.path.join(relative_to_dir, expanded_path))
 
 
 llm_context_config = LLMContextConfig()

zrb/config/llm_context/config_parser.py

@@ -8,21 +8,17 @@ def markdown_to_dict(markdown: str) -> dict[str, str]:
     current_title = ""
     current_content: list[str] = []
     fence_stack: list[str] = []
-
     fence_pattern = re.compile(r"^([`~]{3,})(.*)$")
     h1_pattern = re.compile(r"^# (.+)$")
-
     for line in markdown.splitlines():
         # Detect code fence open/close
         fence_match = fence_pattern.match(line.strip())
-
         if fence_match:
             fence = fence_match.group(1)
             if fence_stack and fence_stack[-1] == fence:
                 fence_stack.pop()  # close current fence
             else:
                 fence_stack.append(fence)  # open new fence
-
         # Only parse H1 when not inside a code fence
         if not fence_stack:
             h1_match = h1_pattern.match(line)
@@ -34,9 +30,7 @@ def markdown_to_dict(markdown: str) -> dict[str, str]:
                 current_title = h1_match.group(1).strip()
                 current_content = []
                 continue
-
         current_content.append(line)
-
     # Save final section
     if current_title:
         sections[current_title] = "\n".join(current_content).strip()

zrb/group/any_group.py

@@ -1,9 +1,13 @@
 from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
 
 from zrb.task.any_task import AnyTask
 
+GroupType = TypeVar("GroupType", bound="AnyGroup")
+TaskType = TypeVar("TaskType", bound=AnyTask)
 
-class AnyGroup(ABC):
+
+class AnyGroup(ABC, Generic[GroupType, TaskType]):
     @property
     @abstractmethod
     def name(self) -> str:
@@ -35,11 +39,11 @@ class AnyGroup(ABC):
         pass
 
     @abstractmethod
-    def add_group(self, group: "AnyGroup | str") -> "AnyGroup":
+    def add_group(self, group: GroupType, alias: str | None) -> GroupType:
         pass
 
     @abstractmethod
-    def add_task(self, task: AnyTask, alias: str | None = None) -> AnyTask:
+    def add_task(self, task: TaskType, alias: str | None = None) -> TaskType:
         pass
 
     @abstractmethod
@@ -55,5 +59,5 @@ class AnyGroup(ABC):
         pass
 
     @abstractmethod
-    def get_group_by_alias(self, name: str) -> "AnyGroup | None":
+    def get_group_by_alias(self, alias: str) -> "AnyGroup | None":
         pass

zrb/group/group.py

@@ -1,8 +1,10 @@
-from zrb.group.any_group import AnyGroup
+from typing import Generic, TypeVar
+
+from zrb.group.any_group import AnyGroup, GroupType, TaskType
 from zrb.task.any_task import AnyTask
 
 
-class Group(AnyGroup):
+class Group(AnyGroup, Generic[GroupType, TaskType]):
     def __init__(
         self, name: str, description: str | None = None, banner: str | None = None
     ):
@@ -41,13 +43,13 @@ class Group(AnyGroup):
         alias.sort()
         return {name: self._tasks.get(name) for name in alias}
 
-    def add_group(self, group: AnyGroup | str, alias: str | None = None) -> AnyGroup:
-        real_group = Group(group) if isinstance(group, str) else group
+    def add_group(self, group: GroupType, alias: str | None = None) -> GroupType:
+        real_group: GroupType = Group(group) if isinstance(group, str) else group
         alias = alias if alias is not None else real_group.name
         self._groups[alias] = real_group
         return real_group
 
-    def add_task(self, task: AnyTask, alias: str | None = None) -> AnyTask:
+    def add_task(self, task: TaskType, alias: str | None = None) -> TaskType:
         alias = alias if alias is not None else task.name
         self._tasks[alias] = task
         return task

zrb/input/text_input.py

@@ -1,13 +1,9 @@
-import os
-import subprocess
-import tempfile
 from collections.abc import Callable
 
 from zrb.config.config import CFG
 from zrb.context.any_shared_context import AnySharedContext
 from zrb.input.base_input import BaseInput
 from zrb.util.cli.text import edit_text
-from zrb.util.file import read_file
 
 
 class TextInput(BaseInput):