zrb 1.15.12__tar.gz → 1.15.14__tar.gz

{zrb-1.15.12 → zrb-1.15.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: zrb
-Version: 1.15.12
+Version: 1.15.14
 Summary: Your Automation Powerhouse
 License: AGPL-3.0-or-later
 Keywords: Automation,Task Runner,Code Generator,Monorepo,Low Code

{zrb-1.15.12 → zrb-1.15.14}/pyproject.toml

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

{zrb-1.15.12 → zrb-1.15.14}/src/zrb/builtin/llm/tool/code.py

@@ -122,7 +122,6 @@ async def analyze_repo(
     )
     if len(extracted_infos) == 1:
         return extracted_infos[0]
-    ctx.print(stylize_faint("  📝 Summarization"), plain=True)
     summarized_infos = extracted_infos
     while len(summarized_infos) > 1:
         ctx.print(stylize_faint("  📝 Summarization"), plain=True)

{zrb-1.15.12 → zrb-1.15.14}/src/zrb/builtin/llm/tool/web.py

@@ -98,7 +98,13 @@ def search_wikipedia(query: str) -> str:
     import requests
 
     params = {"action": "query", "list": "search", "srsearch": query, "format": "json"}
-    response = requests.get("https://en.wikipedia.org/w/api.php", params=params)
+    response = requests.get(
+        "https://en.wikipedia.org/w/api.php",
+        headers={
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+        },
+        params=params,
+    )
     return response.json()
 
 
@@ -123,7 +129,13 @@ def search_arxiv(query: str, num_results: int = 10) -> str:
     import requests
 
     params = {"search_query": f"all:{query}", "start": 0, "max_results": num_results}
-    response = requests.get("http://export.arxiv.org/api/query", params=params)
+    response = requests.get(
+        "http://export.arxiv.org/api/query",
+        headers={
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+        },
+        params=params,
+    )
     return response.content
 
 

zrb-1.15.14/src/zrb/config/default_prompt/summarization_prompt.md

@@ -0,0 +1,17 @@
+You are a memory management AI. Your goal is to curate the conversation history by calling the `update_conversation_memory` tool.
+
+Follow these steps precisely:
+
+**Step 1: Consolidate Conversation Information**
+
+1.  Create a concise narrative summary that integrates the `Past Conversation Summary` with the `Recent Conversation`.
+2.  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. Ensure the timestamp format is `[YYYY-MM-DD HH:MM:SS UTC+Z] Role: Message/Tool name being called`.
+3.  Review the `Notes` and the `Recent Conversation` to identify any new or updated facts.
+    *   Update global facts about the user or their preferences for the `long_term_note`.
+    *   Update facts specific to the current project or directory for the `contextual_note`.
+    *   **CRITICAL:** When updating `contextual_note`, you MUST determine the correct `context_path` by analyzing the `Recent Conversation`. For example, if a fact was established when the working directory was `/app`, the `context_path` MUST be `/app`.
+    *   **CRITICAL:** The content for notes must be raw, unformatted text. Do not use Markdown. Notes should be timeless facts, not a log of events. Only update notes if the information has actually changed.
+
+**Step 2: Update Memory**
+
+1.  Call the `update_conversation_memory` tool ONCE, providing all the information you consolidated in Step 1 as arguments.

{zrb-1.15.12 → zrb-1.15.14}/src/zrb/config/llm_context/config.py

@@ -35,6 +35,17 @@ class LLMContextConfig:
             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))
+
     def get_contexts(self, cwd: str | None = None) -> dict[str, str]:
         """Gathers all relevant contexts for a given path."""
         if cwd is None:
@@ -44,15 +55,14 @@ class LLMContextConfig:
         for config_dir, sections in reversed(all_sections):
             for key, value in sections.items():
                 if key.startswith("Context:"):
-                    context_path = key[len("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
+                    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
 
     def get_workflows(self, cwd: str | None = None) -> dict[str, str]:
@@ -61,60 +71,79 @@ class LLMContextConfig:
             cwd = os.getcwd()
         all_sections = self._get_all_sections(cwd)
         workflows: dict[str, str] = {}
-        for _, sections in reversed(all_sections):
+        # 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()
-                    workflow_name = key.replace("Workflow:", "").lower().strip()
-                    workflows[workflow_name] = value
+                    workflow_name = key[len("Workflow:") :].strip().lower()
+                    # First one found wins
+                    if workflow_name not in workflows:
+                        workflows[workflow_name] = value
         return workflows
 
+    def _format_context_path_for_writing(
+        self,
+        path_to_write: str,
+        cwd: 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:
+                return "."
+            return os.path.relpath(abs_path_to_write, abs_cwd)
+        # Rule 2: Inside Home
+        if abs_path_to_write.startswith(home_dir):
+            if abs_path_to_write == home_dir:
+                return "~"
+            return os.path.join("~", os.path.relpath(abs_path_to_write, home_dir))
+        # Rule 3: Absolute
+        return abs_path_to_write
+
     def write_context(
-        self, content: str, context_path: str | None = None, cwd: str | None = None
+        self,
+        content: str,
+        context_path: str | None = None,
+        cwd: str | None = None,
     ):
-        """Writes content to a context block in the nearest configuration file."""
+        """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_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)
+        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))
+        abs_context_path = os.path.abspath(os.path.join(cwd, context_path))
 
-        # Find existing key
-        found_key = ""
+        found_key = None
         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:
+            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
                 break
 
-        if found_key != "":
+        if found_key:
             sections[found_key] = content
         else:
-            # Add new entry
-            new_key = f"Context: {context_path}"
+            formatted_path = self._format_context_path_for_writing(
+                context_path,
+                cwd,
+            )
+            new_key = f"Context: {formatted_path}"
             sections[new_key] = content
 
         # Serialize back to markdown

{zrb-1.15.12 → zrb-1.15.14}/src/zrb/task/llm/conversation_history.py

@@ -1,18 +1,46 @@
 import json
+import os
 from collections.abc import Callable
 from copy import deepcopy
 from typing import Any
 
 from zrb.attr.type import StrAttr
+from zrb.config.llm_context.config import llm_context_config
 from zrb.context.any_context import AnyContext
 from zrb.context.any_shared_context import AnySharedContext
 from zrb.task.llm.conversation_history_model import ConversationHistory
 from zrb.task.llm.typing import ListOfDict
 from zrb.util.attr import get_str_attr
-from zrb.util.file import write_file
+from zrb.util.file import read_file, write_file
+from zrb.util.llm.prompt import make_prompt_section
 from zrb.util.run import run_async
 
 
+def inject_conversation_history_notes(conversation_history: ConversationHistory):
+    conversation_history.long_term_note = _fetch_long_term_note(
+        conversation_history.project_path
+    )
+    conversation_history.contextual_note = _fetch_contextual_note(
+        conversation_history.project_path
+    )
+
+
+def _fetch_long_term_note(project_path: str) -> str:
+    contexts = llm_context_config.get_contexts(cwd=project_path)
+    return contexts.get("/", "")
+
+
+def _fetch_contextual_note(project_path: str) -> str:
+    contexts = llm_context_config.get_contexts(cwd=project_path)
+    return "\n".join(
+        [
+            make_prompt_section(header, content)
+            for header, content in contexts.items()
+            if header != "/"
+        ]
+    )
+
+
 def get_history_file(
     ctx: AnyContext,
     conversation_history_file_attr: StrAttr | None,
@@ -27,6 +55,49 @@ def get_history_file(
     )
 
 
+async def _read_from_source(
+    ctx: AnyContext,
+    reader: Callable[[AnyContext], dict[str, Any] | list | None] | None,
+    file_path: str | None,
+) -> "ConversationHistory | None":
+    # Priority 1: Reader function
+    if reader:
+        try:
+            raw_data = await run_async(reader(ctx))
+            if raw_data:
+                instance = ConversationHistory.parse_and_validate(
+                    ctx, raw_data, "reader"
+                )
+                if instance:
+                    return instance
+        except Exception as e:
+            ctx.log_warning(
+                f"Error executing conversation history reader: {e}. Ignoring."
+            )
+    # Priority 2: History file
+    if file_path and os.path.isfile(file_path):
+        try:
+            content = read_file(file_path)
+            raw_data = json.loads(content)
+            instance = ConversationHistory.parse_and_validate(
+                ctx, raw_data, f"file '{file_path}'"
+            )
+            if instance:
+                return instance
+        except json.JSONDecodeError:
+            ctx.log_warning(
+                f"Could not decode JSON from history file '{file_path}'. "
+                "Ignoring file content."
+            )
+        except Exception as e:
+            ctx.log_warning(
+                f"Error reading history file '{file_path}': {e}. "
+                "Ignoring file content."
+            )
+    # Fallback: Return default value
+    return None
+
+
 async def read_conversation_history(
     ctx: AnyContext,
     conversation_history_reader: (
@@ -46,7 +117,7 @@ async def read_conversation_history(
         ctx, conversation_history_file_attr, render_history_file
     )
     # Use the class method defined above
-    history_data = await ConversationHistory.read_from_source(
+    history_data = await _read_from_source(
         ctx=ctx,
         reader=conversation_history_reader,
         file_path=history_file,

zrb-1.15.14/src/zrb/task/llm/conversation_history_model.py

@@ -0,0 +1,74 @@
+import json
+import os
+from typing import Any
+
+from zrb.context.any_context import AnyContext
+from zrb.task.llm.typing import ListOfDict
+
+
+class ConversationHistory:
+
+    def __init__(
+        self,
+        past_conversation_summary: str = "",
+        past_conversation_transcript: str = "",
+        history: ListOfDict | None = None,
+        contextual_note: str | None = None,
+        long_term_note: str | None = None,
+        project_path: str | None = None,
+    ):
+        self.past_conversation_transcript = past_conversation_transcript
+        self.past_conversation_summary = past_conversation_summary
+        self.history = history if history is not None else []
+        self.contextual_note = contextual_note if contextual_note is not None else ""
+        self.long_term_note = long_term_note if long_term_note is not None else ""
+        self.project_path = project_path if project_path is not None else os.getcwd()
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "past_conversation_summary": self.past_conversation_summary,
+            "past_conversation_transcript": self.past_conversation_transcript,
+            "history": self.history,
+            "contextual_note": self.contextual_note,
+            "long_term_note": self.long_term_note,
+        }
+
+    def model_dump_json(self, indent: int = 2) -> str:
+        return json.dumps(self.to_dict(), indent=indent)
+
+    @classmethod
+    def parse_and_validate(
+        cls, ctx: AnyContext, data: Any, source: str
+    ) -> "ConversationHistory":
+        try:
+            if isinstance(data, cls):
+                return data  # Already a valid instance
+            if isinstance(data, dict):
+                # This handles both the new format and the old {'context': ..., 'history': ...}
+                return cls(
+                    past_conversation_summary=data.get("past_conversation_summary", ""),
+                    past_conversation_transcript=data.get(
+                        "past_conversation_transcript", ""
+                    ),
+                    history=data.get("history", data.get("messages", [])),
+                    contextual_note=data.get("contextual_note", ""),
+                    long_term_note=data.get("long_term_note", ""),
+                )
+            elif isinstance(data, list):
+                # Handle very old format (just a list) - wrap it
+                ctx.log_warning(
+                    f"History from {source} contains legacy list format. "
+                    "Wrapping it into the new structure. "
+                    "Consider updating the source format."
+                )
+                return cls(history=data)
+            else:
+                ctx.log_warning(
+                    f"History data from {source} has unexpected format "
+                    f"(type: {type(data)}). Ignoring."
+                )
+        except Exception as e:  # Catch validation errors too
+            ctx.log_warning(
+                f"Error validating/parsing history data from {source}: {e}. Ignoring."
+            )
+        return cls()

{zrb-1.15.12 → zrb-1.15.14}/src/zrb/task/llm/history_summarization.py

@@ -9,9 +9,13 @@ from zrb.context.any_context import AnyContext
 from zrb.task.llm.agent import run_agent_iteration
 from zrb.task.llm.conversation_history import (
     count_part_in_history_list,
+    inject_conversation_history_notes,
     replace_system_prompt_in_history,
 )
 from zrb.task.llm.conversation_history_model import ConversationHistory
+from zrb.task.llm.history_summarization_tool import (
+    create_history_summarization_tool,
+)
 from zrb.task.llm.typing import ListOfDict
 from zrb.util.attr import get_bool_attr, get_int_attr
 from zrb.util.cli.style import stylize_faint
@@ -93,6 +97,7 @@ async def summarize_history(
     """Runs an LLM call to update the conversation summary."""
     from pydantic_ai import Agent
 
+    inject_conversation_history_notes(conversation_history)
     ctx.log_info("Attempting to summarize conversation history...")
     # Construct the user prompt for the summarization agent
     user_prompt = "\n".join(
@@ -143,14 +148,7 @@ async def summarize_history(
         system_prompt=system_prompt,
         model_settings=settings,
         retries=retries,
-        tools=[
-            conversation_history.write_past_conversation_summary,
-            conversation_history.write_past_conversation_transcript,
-            conversation_history.read_long_term_note,
-            conversation_history.write_long_term_note,
-            conversation_history.read_contextual_note,
-            conversation_history.write_contextual_note,
-        ],
+        tools=[create_history_summarization_tool(conversation_history)],
     )
     try:
         ctx.print(stylize_faint("  📝 Rollup Conversation"), plain=True)

zrb-1.15.14/src/zrb/task/llm/history_summarization_tool.py

@@ -0,0 +1,38 @@
+import json
+from typing import Callable
+
+from zrb.config.llm_context.config import llm_context_config
+from zrb.task.llm.conversation_history_model import ConversationHistory
+
+
+def create_history_summarization_tool(
+    conversation_history: ConversationHistory,
+) -> Callable:
+    def update_conversation_memory(
+        past_conversation_summary: str,
+        past_conversation_transcript: str,
+        long_term_note: str | None = None,
+        contextual_note: str | None = None,
+        context_path: str | None = None,
+    ):
+        """
+        Update the conversation memory including summary, transcript, and notes.
+        - past_conversation_summary: A concise narrative that integrates the
+          previous summary with the recent conversation.
+        - past_conversation_transcript: MUST be ONLY the last 4 (four) turns
+          of the conversation.
+        - long_term_note: Global facts about the user or their preferences.
+        - contextual_note: Facts specific to the current project or directory.
+        - context_path: The directory path for the contextual note.
+        """
+        conversation_history.past_conversation_summary = past_conversation_summary
+        conversation_history.past_conversation_transcript = past_conversation_transcript
+        if long_term_note is not None:
+            llm_context_config.write_context(long_term_note, context_path="/")
+        if contextual_note is not None:
+            if context_path is None:
+                context_path = conversation_history.project_path
+            llm_context_config.write_context(contextual_note, context_path=context_path)
+        return json.dumps({"success": True})
+
+    return update_conversation_memory

{zrb-1.15.12 → zrb-1.15.14}/src/zrb/task/llm_task.py

@@ -17,6 +17,7 @@ from zrb.task.llm.config import (
     get_model_settings,
 )
 from zrb.task.llm.conversation_history import (
+    inject_conversation_history_notes,
     read_conversation_history,
     write_conversation_history,
 )
@@ -241,7 +242,7 @@ class LLMTask(BaseTask):
             render_history_file=self._render_history_file,
             conversation_history_attr=self._conversation_history,
         )
-        conversation_history.fetch_newest_notes()
+        inject_conversation_history_notes(conversation_history)
         # 2. Get system prompt and user prompt
         system_prompt, user_message = get_system_and_user_prompt(
             ctx=ctx,

zrb-1.15.12/src/zrb/config/default_prompt/summarization_prompt.md

@@ -1,16 +0,0 @@
-You are a memory management AI. Your goal is to curate the conversation history by calling `write_past_conversation_summary`, `write_past_conversation_transcript`, `write_long_term_note` and `write_contextual_note`.
-
-Follow these steps precisely:
-
-**Step 1: Update Conversation Summary and Transcript**
-
-1.  Call the `write_past_conversation_summary` tool ONCE. The summary you provide must be a concise narrative that integrates the previous summary with the `Recent Conversation`.
-2.  Call the `write_past_conversation_transcript` tool ONCE. The content for this tool MUST be ONLY the last 4 (four) turns of the conversation. Do not change or shorten the content of these turns. Ensure the timestamp format is `[YYYY-MM-DD HH:MM:SS UTC+Z] Role: Message/Tool name being called`.
-
-**Step 2: Update Factual Notes**
-
-1.  First, read the existing notes to understand the current state.
-2.  Call `write_long_term_note` AT MOST ONCE. Use it to add or update global facts about the user or their preferences.
-3.  Call `write_contextual_note` AT MOST ONCE. Use it to add or update facts specific to the current project or directory (`context_path`).
-4.  **CRITICAL:** When calling `write_contextual_note`, you MUST determine the correct `context_path` by analyzing the `Recent Conversation`. For example, if a fact was established when the working directory was `/app`, the `context_path` MUST be `/app`.
-5.  **CRITICAL:** The content for notes must be raw, unformatted text. Do not use Markdown. Notes should be timeless facts, not a log of events. Only update notes if the information has actually changed.