zrb 1.11.0__py3-none-any.whl → 1.13.0__py3-none-any.whl

zrb/builtin/llm/chat_session.py

@@ -25,6 +25,7 @@ async def read_user_prompt(ctx: AnyContext) -> str:
     is_tty = ctx.is_tty
     reader = await _setup_input_reader(is_tty)
     multiline_mode = False
+    current_modes = ctx.input.modes
     user_inputs = []
     while True:
         await asyncio.sleep(0.01)
@@ -38,7 +39,9 @@ async def read_user_prompt(ctx: AnyContext) -> str:
         if user_input.strip().lower() in ("/bye", "/quit", "/q", "/exit"):
             user_prompt = "\n".join(user_inputs)
             user_inputs = []
-            result = await _trigger_ask_and_wait_for_result(ctx, user_prompt)
+            result = await _trigger_ask_and_wait_for_result(
+                ctx, user_prompt, current_modes
+            )
             if result is not None:
                 final_result = result
             break
@@ -49,9 +52,18 @@ async def read_user_prompt(ctx: AnyContext) -> str:
             multiline_mode = False
             user_prompt = "\n".join(user_inputs)
             user_inputs = []
-            result = await _trigger_ask_and_wait_for_result(ctx, user_prompt)
+            result = await _trigger_ask_and_wait_for_result(
+                ctx, user_prompt, current_modes
+            )
             if result is not None:
                 final_result = 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)
+            ctx.print("", plain=True)
+            continue
         elif user_input.strip().lower() in ("/help", "/info"):
             _show_info(ctx)
             continue
@@ -61,7 +73,9 @@ async def read_user_prompt(ctx: AnyContext) -> str:
                 continue
             user_prompt = "\n".join(user_inputs)
             user_inputs = []
-            result = await _trigger_ask_and_wait_for_result(ctx, user_prompt)
+            result = await _trigger_ask_and_wait_for_result(
+                ctx, user_prompt, current_modes
+            )
             if result is not None:
                 final_result = result
     return final_result
@@ -74,16 +88,26 @@ def _show_info(ctx: AnyContext):
         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"
+        "\n".join(
+            [
+                _format_info_line("/bye", "Quit from chat session"),
+                _format_info_line("/multi", "Start multiline input"),
+                _format_info_line("/end", "End multiline input"),
+                _format_info_line("/modes", "Show current modes"),
+                _format_info_line("/modes <mode1,mode2,..>", "Set current modes"),
+                _format_info_line("/help", "Show this message"),
+            ]
         ),
         plain=True,
     )
 
 
+def _format_info_line(command: str, description: str) -> str:
+    styled_command = stylize_bold_yellow(command.ljust(25))
+    styled_description = stylize_faint(description)
+    return f"  {styled_command} {styled_description}"
+
+
 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() == "":
@@ -94,6 +118,7 @@ async def _handle_initial_message(ctx: AnyContext) -> str:
     result = await _trigger_ask_and_wait_for_result(
         ctx,
         user_prompt=ctx.input.message,
+        modes=ctx.input.modes,
         previous_session_name=ctx.input.previous_session,
         start_new=ctx.input.start_new,
     )
@@ -131,6 +156,7 @@ async def _read_next_line(is_interactive: bool, reader, ctx: AnyContext) -> str:
 async def _trigger_ask_and_wait_for_result(
     ctx: AnyContext,
     user_prompt: str,
+    modes: str,
     previous_session_name: str | None = None,
     start_new: bool = False,
 ) -> str | None:
@@ -148,7 +174,7 @@ async def _trigger_ask_and_wait_for_result(
     """
     if user_prompt.strip() == "":
         return None
-    await _trigger_ask(ctx, user_prompt, previous_session_name, start_new)
+    await _trigger_ask(ctx, user_prompt, modes, previous_session_name, start_new)
     result = await _wait_ask_result(ctx)
     md_result = _render_markdown(result) if result is not None else ""
     ctx.print("\n🤖 >>", plain=True)
@@ -193,12 +219,14 @@ 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"),
     }
 
 
 async def _trigger_ask(
     ctx: AnyContext,
     user_prompt: str,
+    modes: str,
     previous_session_name: str | None = None,
     start_new: bool = False,
 ):
@@ -218,6 +246,7 @@ async def _trigger_ask(
             "previous_session_name": previous_session_name,
             "start_new": start_new,
             "message": user_prompt,
+            "modes": modes,
         }
     )
 

zrb/builtin/llm/llm_ask.py

@@ -65,6 +65,14 @@ _llm_ask_inputs = [
         allow_positional_parsing=False,
         always_prompt=False,
     ),
+    TextInput(
+        "modes",
+        description="Modes",
+        prompt="Modes",
+        default="coding",
+        allow_positional_parsing=False,
+        always_prompt=False,
+    ),
     BoolInput(
         "start-new",
         description="Start new conversation (LLM will forget everything)",
@@ -101,6 +109,9 @@ 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(",")
+        ),
         message="{ctx.input.message}",
         retries=0,
     ),

zrb/builtin/llm/tool/sub_agent.py

@@ -9,10 +9,10 @@ from zrb.task.llm.config import get_model, get_model_settings
 from zrb.task.llm.prompt import get_system_and_user_prompt
 
 if TYPE_CHECKING:
-    from pydantic_ai import Tool
-    from pydantic_ai.mcp import MCPServer
+    from pydantic_ai import Agent, Tool
     from pydantic_ai.models import Model
     from pydantic_ai.settings import ModelSettings
+    from pydantic_ai.toolsets import AbstractToolset
 
     ToolOrCallable = Tool | Callable
 else:
@@ -26,7 +26,7 @@ def create_sub_agent_tool(
     model: "str | Model | None" = None,
     model_settings: "ModelSettings | None" = None,
     tools: list[ToolOrCallable] = [],
-    mcp_servers: list["MCPServer"] = [],
+    toolsets: list["AbstractToolset[Agent]"] = [],
 ) -> Callable[[AnyContext, str], Coroutine[Any, Any, str]]:
     """
     Creates a "tool that is another AI agent," capable of handling complex, multi-step sub-tasks.
@@ -42,7 +42,7 @@ def create_sub_agent_tool(
         model (str | Model, optional): The language model the sub-agent will use.
         model_settings (ModelSettings, optional): Specific settings for the sub-agent's model.
         tools (list, optional): A list of tools that will be exclusively available to the sub-agent.
-        mcp_servers (list, optional): A list of MCP servers for the sub-agent.
+        toolsets (list, optional): A list of Toolset for the sub-agent.
 
     Returns:
         Callable: An asynchronous function that serves as the sub-agent tool. When called, it runs the sub-agent with a given query and returns its final result.
@@ -85,7 +85,7 @@ def create_sub_agent_tool(
             system_prompt=resolved_system_prompt,
             model_settings=resolved_model_settings,
             tools=tools,
-            mcp_servers=mcp_servers,
+            toolsets=toolsets,
         )
 
         sub_agent_run = None

zrb/config/config.py

@@ -287,6 +287,10 @@ class Config:
         """Number of seconds to sleep when throttling is required."""
         return float(os.getenv("ZRB_LLM_THROTTLE_SLEEP", "1.0"))
 
+    @property
+    def LLM_YOLO_MODE(self) -> bool:
+        return to_boolean(os.getenv("ZRB_LLM_YOLO_MODE", "false"))
+
     @property
     def LLM_SUMMARIZE_HISTORY(self) -> bool:
         return to_boolean(os.getenv("ZRB_LLM_SUMMARIZE_HISTORY", "true"))

zrb/config/default_prompt/interactive_system_prompt.md

@@ -21,10 +21,14 @@ You are an expert AI agent in a CLI. You MUST follow this workflow for this inte
     *   **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).
 
 4.  **Handle Errors (The Debugging Loop):**
-    *   If a tool call 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 (`stdout` and `stderr`).
-        2.  **Hypothesize:** State a clear, specific hypothesis about the root cause.
-        3.  **Act:** Propose and execute a concrete, single next step to fix the issue.
+    *   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. For example, "The operation failed because the file path was incorrect," "The command failed because a required argument was missing," or "The test failed because the code has a logical error."
+        3.  **Strategize and Correct:** Formulate a new action that directly addresses the hypothesis. Do not simply repeat the failed action. Your correction strategy MUST be logical and informed by the analysis. For example:
+            *   If a path is wrong, take action to discover the correct path.
+            *   If a command is malformed, correct its syntax or arguments.
+            *   If an operation failed due to invalid state (e.g., unexpected file content, a logical bug in code), take action to inspect the current state and then formulate a targeted fix.
+        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. If the user provides a vague follow-up like "try again," you MUST use the context of the previous failure to inform your next action, not just repeat the failed command.
 
 5.  **Report Results:**

zrb/config/default_prompt/summarization_prompt.md

@@ -1,42 +1,16 @@
-You are a silent AI tool. Your ONLY job is to call tools to update the conversation memory based on the `Recent Conversation (JSON)`. Your response MUST be only tool calls.
-
----
-
-### **1. Factual Notes**
-
-**Goal:** Extract permanent facts. Do NOT log activities.
-*   **Good Fact:** `User prefers Python.`
-*   **Bad Activity:** `User ran tests.`
-*   **Action:** Use `add_long_term_info` for global facts and `add_contextual_info` for project facts. **Only add *new* facts from the `Recent Conversation` that are not already present in the `Factual Notes`.**
-
----
-
-### **2. Transcript**
-
-**Goal:** Create a verbatim log of the last ~4 turns.
-*   **Format:** `[YYYY-MM-DD HH:MM:SS UTC+Z] Role: Message` or `[YYYY-MM-DD UTC+Z] Role: (calling ToolName)`
-*   **Example:**
-    ```
-    [2025-07-19 10:00:01 UTC+7] User: Please create a file named todo.py.
-    [2025-07-19 10:00:15 UTC+7] Assistant: (calling `write_to_file`)
-    [2025-07-19 10:01:13 UTC+7] Assistant: Okay, I have created the file.
-    ```
-*   **Action:** Use `write_past_conversation_transcript`.
-*   **CRITICAL:** You MUST remove all headers (e.g., `# User Message`, `# Context`).
-*   **CRITICAL:** DO NOT truncate or alter user/assistant respond for whatever reason.
----
-
-### **3. Narrative Summary**
-
-**Goal:** Combine the condensed past summary with a new summary of the recent conversation.
-*   **Logic:** Timestamps MUST become less granular over time.
-*   **Format & Examples:**
-    *   **For today:** Summarize recent key events by the hour.
-        `[2025-07-20 14:00 UTC+7] Continued work on the 'Todo' app, fixing unit tests.`
-    *   **For previous days:** Condense the entire day's activity into a single entry.
-        `[2025-07-19] Started project 'Bluebird' and set up the initial file structure.`
-    *   **For previous months:** Condense the entire month's activity.
-        `[2025-06] Worked on performance optimizations for the main API.`
-*   **Action:** Use `write_past_conversation_summary` to save the new, combined summary.
-*   **CRITICAL:** Condense past conversation summary before combining with the more recent conversation summary.
-
+You are a silent memory management AI. Your ONLY output is tool calls.
+
+**Primary Directive:** Update the conversation memory based on the `Recent Conversation`.
+
+**Actions:**
+1.  **Update Conversation:**
+    - Call `write_past_conversation_summary` ONCE. The summary must be a narrative condensing the old summary and recent conversation.
+    - Call `write_past_conversation_transcript` ONCE. The transcript MUST contain at most the last 4 (four) conversation turns. The content of these turns must not be altered or truncated, furthermore the timezone has to be included. Use the format: `[YYYY-MM-DD HH:MM:SS UTC+Z] Role: Message/Tool name being called`.
+2.  **Update Factual Notes:**
+    - Read existing notes first.
+    - Call `write_long_term_note` AT MOST ONCE with new or updated global facts (e.g., user preferences).
+    - Call `write_contextual_note` AT MOST ONCE with new or updated project-specific facts.
+    - **CRITICAL - Path Specificity:** Project-specific facts are tied to the directory where they were established. You MUST analyze the `Recent Conversation` to determine the correct `context_path` for the facts you are writing. For example, if a user sets a project name while the working directory is `/tmp/a`, the `context_path` for that fact MUST be `/tmp/a`.
+    - **CRITICAL - Note Content:** Note content MUST be raw, unformatted text. Do NOT include markdown headers. Notes must be timeless facts about the current state, not a chronological log. Only write if the content has changed.
+
+**Final Step:** After all tool calls, you MUST output the word "DONE" on a new line. Do not output anything else.

zrb/config/default_prompt/system_prompt.md

@@ -18,10 +18,14 @@ You are an expert AI agent fulfilling a single request. You must provide a compl
     *   **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 a tool call 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 (`stdout` and `stderr`).
-        2.  **Hypothesize:** State a clear, specific hypothesis about the root cause.
-        3.  **Act:** Propose and execute a concrete, single next step to fix the issue.
+    *   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. For example, "The operation failed because the file path was incorrect," "The command failed because a required argument was missing," or "The test failed because the code has a logical error."
+        3.  **Strategize and Correct:** Formulate a new action that directly addresses the hypothesis. Do not simply repeat the failed action. Your correction strategy MUST be logical and informed by the analysis. For example:
+            *   If a path is wrong, take action to discover the correct path.
+            *   If a command is malformed, correct its syntax or arguments.
+            *   If an operation failed due to invalid state (e.g., unexpected file content, a logical bug in code), take action to inspect the current state and then formulate a targeted fix.
+        4.  **Execute** the corrected action.
     *   **CRITICAL:** You must exhaust all reasonable attempts to fix the issue yourself before reporting failure.
 
 5.  **Report Final Outcome:**

zrb/config/llm_config.py

@@ -22,11 +22,9 @@ class LLMConfig:
         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_modes: list[str] | None = None,
         default_model: "Model | None" = None,
         default_model_settings: "ModelSettings | None" = None,
         default_model_provider: "Provider | None" = None,
@@ -40,18 +38,14 @@ class LLMConfig:
         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_modes = default_modes
+        self._default_model = default_model
         self._default_model_settings = default_model_settings
         self._default_model_provider = default_model_provider
-        self._default_model = default_model
 
     def _get_internal_default_prompt(self, name: str) -> str:
         if name not in self.__internal_default_prompt:
@@ -130,32 +124,18 @@ class LLMConfig:
             lambda: self._get_internal_default_prompt("persona"),
         )
 
+    @property
+    def default_modes(self) -> list[str]:
+        return self._get_property(
+            self._default_modes, CFG.LLM_MODES, lambda: ["coding"]
+        )
+
     @property
     def default_special_instruction_prompt(self) -> str:
         return self._get_property(
             self._default_special_instruction_prompt,
             CFG.LLM_SPECIAL_INSTRUCTION_PROMPT,
-            lambda: self._get_workflow_prompt(CFG.LLM_MODES),
-        )
-
-    def _get_workflow_prompt(self, modes: list[str]) -> str:
-        workflows = llm_context_config.get_workflows()
-        dir_path = os.path.dirname(__file__)
-        default_workflow_names = ("code", "content", "research")
-        for workflow_name in default_workflow_names:
-            if workflow_name in workflows:
-                continue
-            workflow_file_path = os.path.join(
-                dir_path, "default_workflow", f"{workflow_name}.md"
-            )
-            with open(workflow_file_path, "r") as f:
-                workflows[workflow_name] = f.read()
-        return "\n".join(
-            [
-                make_prompt_section(header, content)
-                for header, content in workflows.items()
-                if header.lower() in modes
-            ]
+            lambda: "",
         )
 
     @property
@@ -206,6 +186,19 @@ 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 add_default_mode(self, mode: str):
+        if self._default_modes is None:
+            self._default_modes = []
+        self._default_modes.append(mode)
+
+    def remove_default_mode(self, mode: str):
+        if self._default_modes is None:
+            self._default_modes = []
+        self._default_modes.remove(mode)
+
     def set_default_summarization_prompt(self, summarization_prompt: str):
         self._default_summarization_prompt = summarization_prompt
 

zrb/config/llm_context/config.py

@@ -1,74 +1,129 @@
 import os
 
 from zrb.config.config import CFG
-from zrb.config.llm_context.config_handler import LLMContextConfigHandler
-
-
-def cascading_path_filter(section_path: str, base_path: str) -> bool:
-    """
-    Returns True if the section path is an ancestor of, the same as the base path,
-    or if the section path is an absolute path.
-    """
-    return os.path.isabs(section_path) or base_path.startswith(section_path)
+from zrb.config.llm_context.config_parser import markdown_to_dict
+from zrb.util.llm.prompt import demote_markdown_headers
 
 
 class LLMContextConfig:
     """High-level API for interacting with cascaded configurations."""
 
-    @property
-    def _context_handler(self):
-        return LLMContextConfigHandler(
-            "Context",
-            config_file_name=CFG.LLM_CONTEXT_FILE,
-            filter_section_func=cascading_path_filter,
-            resolve_section_path=True,
-        )
-
-    @property
-    def _workflow_handler(self):
-        return LLMContextConfigHandler(
-            "Workflow",
-            config_file_name=CFG.LLM_CONTEXT_FILE,
-            resolve_section_path=False,
-        )
+    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
+
+    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:
+            config_dir = os.path.dirname(config_file)
+            sections = self._parse_config(config_file)
+            all_sections.append((config_dir, sections))
+        return all_sections
 
     def get_contexts(self, cwd: str | None = None) -> dict[str, str]:
         """Gathers all relevant contexts for a given path."""
         if cwd is None:
             cwd = os.getcwd()
-        return self._context_handler.get_section(cwd)
+        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 = key.replace("Context:", "").strip()
+                    if context_path == ".":
+                        context_path = config_dir
+                    elif not os.path.isabs(context_path):
+                        context_path = os.path.abspath(
+                            os.path.join(config_dir, context_path)
+                        )
+                    if os.path.isabs(context_path) or cwd.startswith(context_path):
+                        contexts[context_path] = value
+        return contexts
 
     def get_workflows(self, cwd: str | None = None) -> dict[str, str]:
         """Gathers all relevant workflows for a given path."""
         if cwd is None:
             cwd = os.getcwd()
-        return self._workflow_handler.get_section(cwd)
+        all_sections = self._get_all_sections(cwd)
+        workflows: dict[str, str] = {}
+        for _, sections in reversed(all_sections):
+            for key, value in sections.items():
+                if key.startswith("Workflow:"):
+                    workflow_name = key.replace("Workflow:", "").strip()
+                    if workflow_name not in workflows:
+                        workflows[workflow_name] = value
+        return workflows
 
-    def add_to_context(
+    def write_context(
         self, content: str, context_path: str | None = None, cwd: str | None = None
     ):
-        """Adds content to a context block in the nearest configuration file."""
+        """Writes content to a context block in the nearest configuration file."""
         if cwd is None:
             cwd = os.getcwd()
         if context_path is None:
             context_path = cwd
-        abs_path = os.path.abspath(context_path)
-        home_dir = os.path.expanduser("~")
-        search_dir = cwd
-        if not abs_path.startswith(home_dir):
-            search_dir = home_dir
-        self._context_handler.add_to_section(content, abs_path, cwd=search_dir)
 
-    def remove_from_context(
-        self, content: str, context_path: str | None = None, cwd: str | None = None
-    ) -> bool:
-        """Removes content from a context block in all relevant config files."""
-        if cwd is None:
-            cwd = os.getcwd()
-        if context_path is None:
-            context_path = cwd
-        abs_path = os.path.abspath(context_path)
-        return self._context_handler.remove_from_section(content, abs_path, cwd=cwd)
+        config_files = self._find_config_files(cwd)
+        if config_files:
+            config_file = config_files[0]  # Closest config file
+        else:
+            config_file = os.path.join(cwd, CFG.LLM_CONTEXT_FILE)
+
+        sections = {}
+        if os.path.exists(config_file):
+            sections = self._parse_config(config_file)
+
+        # Determine the section key
+        section_key_path = context_path
+        if not os.path.isabs(context_path):
+            config_dir = os.path.dirname(config_file)
+            section_key_path = os.path.abspath(os.path.join(config_dir, context_path))
+
+        # Find existing key
+        found_key = ""
+        for key in sections.keys():
+            if not key.startswith("Context:"):
+                continue
+            key_path = key.replace("Context:", "").strip()
+            if key_path == ".":
+                key_path = os.path.dirname(config_file)
+            elif not os.path.isabs(key_path):
+                key_path = os.path.abspath(
+                    os.path.join(os.path.dirname(config_file), key_path)
+                )
+            if key_path == section_key_path:
+                found_key = key
+                break
+
+        if found_key != "":
+            sections[found_key] = content
+        else:
+            # Add new entry
+            new_key = f"Context: {context_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)
 
 
 llm_context_config = LLMContextConfig()

zrb/config/llm_context/config_parser.py

@@ -0,0 +1,46 @@
+import re
+
+from zrb.util.llm.prompt import promote_markdown_headers
+
+
+def markdown_to_dict(markdown: str) -> dict[str, str]:
+    sections: 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)
+            if h1_match:
+                # Save previous section
+                if current_title:
+                    sections[current_title] = "\n".join(current_content).strip()
+                # Start new section
+                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()
+    return {
+        header: promote_markdown_headers(content)
+        for header, content in sections.items()
+    }

zrb/context/shared_context.py

@@ -50,7 +50,10 @@ class SharedContext(AnySharedContext):
 
     @property
     def is_tty(self) -> bool:
-        return sys.stdin.isatty()
+        try:
+            return sys.stdin.isatty()
+        except Exception:
+            return False
 
     @property
     def input(self) -> DotDict: