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

zrb/task/llm/conversation_history_model.py

@@ -3,10 +3,11 @@ import os
 from collections.abc import Callable
 from typing import Any
 
-from zrb.config.config import CFG
+from zrb.config.llm_context.config import llm_context_config
 from zrb.context.any_context import AnyContext
 from zrb.task.llm.typing import ListOfDict
-from zrb.util.file import read_file, read_file_with_line_numbers, write_file
+from zrb.util.file import read_file
+from zrb.util.llm.prompt import make_prompt_section
 from zrb.util.run import run_async
 
 
@@ -81,14 +82,8 @@ class ConversationHistory:
         return None
 
     def fetch_newest_notes(self):
-        self.long_term_note = ""
-        long_term_note_path = self._get_long_term_note_path()
-        if os.path.isfile(long_term_note_path):
-            self.long_term_note = read_file(long_term_note_path)
-        self.contextual_note = ""
-        contextual_note_path = self._get_contextual_note_path()
-        if os.path.isfile(contextual_note_path):
-            self.contextual_note = read_file(contextual_note_path)
+        self._fetch_long_term_note()
+        self._fetch_contextual_note()
 
     @classmethod
     def parse_and_validate(
@@ -139,12 +134,13 @@ class ConversationHistory:
             past_conversation_summary (str): The summary text to store.
 
         Returns:
-            None
+            str: A JSON object indicating the success or failure of the operation.
 
         Raises:
             Exception: If the summary cannot be written.
         """
         self.past_conversation_summary = past_conversation_summary
+        return json.dumps({"success": True})
 
     def write_past_conversation_transcript(self, past_conversation_transcript: str):
         """
@@ -157,284 +153,140 @@ class ConversationHistory:
             past_conversation_transcript (str): The transcript text to store.
 
         Returns:
-            None
+            str: A JSON object indicating the success or failure of the operation.
 
         Raises:
             Exception: If the transcript cannot be written.
         """
         self.past_conversation_transcript = past_conversation_transcript
+        return json.dumps({"success": True})
 
-    def read_long_term_note(
-        self,
-        start_line: int | None = None,
-        end_line: int | None = None,
-    ) -> str:
+    def read_long_term_note(self) -> str:
         """
-        Read the content of the long-term note, optionally for a specific line range.
+        Read the content of the long-term references.
 
         This tool helps you retrieve knowledge or notes stored for long-term reference.
         If the note does not exist, you may want to create it using the write tool.
 
-        Args:
-            start_line (int, optional): 1-based line number to start reading from.
-            end_line (int, optional): 1-based line number to stop reading at (inclusive).
-
         Returns:
-            str: JSON with file path, content (with line numbers), start/end lines,
-                and total lines.
+            str: JSON with content of the notes.
 
         Raises:
             Exception: If the note cannot be read.
-                Suggests writing the note if it does not exist.
         """
-        return self._read_note(
-            self._get_long_term_note_path(),
-            start_line,
-            end_line,
-            note_type="long-term note",
-        )
+        return json.dumps({"content": self._fetch_long_term_note()})
 
-    def write_long_term_note(self, content: str) -> str:
+    def add_long_term_info(self, new_info: str) -> str:
         """
-        Write or overwrite the content of the long-term note.
-
-        Use this tool to create a new long-term note or replace its entire content.
-        Always read the note first to avoid accidental data loss, unless you are sure
-        you want to overwrite.
+        Add new info for long-term reference.
 
         Args:
-            content (str): The full content to write to the note.
+            new_info (str): New info to be added into long-term references.
 
         Returns:
-            str: JSON indicating success and the note path.
+            str: JSON with new content of the notes.
 
         Raises:
-            Exception: If the note cannot be written. Suggests checking permissions or path.
+            Exception: If the note cannot be read.
         """
-        self.long_term_note = content
-        return self._write_note(
-            self._get_long_term_note_path(), content, note_type="long-term note"
-        )
+        llm_context_config.add_to_context(new_info, cwd="/")
+        return json.dumps({"success": True, "content": self._fetch_long_term_note()})
 
-    def replace_in_long_term_note(
-        self,
-        old_string: str,
-        new_string: str,
-    ) -> str:
+    def remove_long_term_info(self, irrelevant_info: str) -> str:
         """
-        Replace the first occurrence of a string in the long-term note.
-
-        Use this tool to update a specific part of the long-term note without
-        overwriting the entire content. If the note does not exist, consider writing it
-        first. If the string is not found, check your input or read the note to verify.
+        Remove irrelevant info from long-term reference.
 
         Args:
-            old_string (str): The exact string to search for and replace.
-            new_string (str): The string to replace with.
+            irrelevant_info (str): Irrelevant info to be removed from long-term references.
 
         Returns:
-            str: JSON indicating success and the note path.
+            str: JSON with new content of the notes and deletion status.
 
         Raises:
-            Exception: If the note does not exist or the string is not found.
-                Suggests writing or reading the note.
+            Exception: If the note cannot be read.
         """
-        result = self._replace_in_note(
-            self._get_long_term_note_path(),
-            old_string,
-            new_string,
-            note_type="long-term note",
+        was_removed = llm_context_config.remove_from_context(irrelevant_info, cwd="/")
+        return json.dumps(
+            {
+                "success": was_removed,
+                "content": self._fetch_long_term_note(),
+            }
         )
-        self.long_term_note = new_string
-        return result
 
-    def read_contextual_note(
-        self,
-        start_line: int | None = None,
-        end_line: int | None = None,
-    ) -> str:
+    def read_contextual_note(self) -> str:
         """
-        Read the content of the contextual note, optionally for a specific line range.
+        Read the content of the contextual references.
 
-        This tool helps you retrieve project-specific or session-specific notes.
+        This tool helps you retrieve knowledge or notes stored for contextual reference.
         If the note does not exist, you may want to create it using the write tool.
 
-        Args:
-            start_line (int, optional): 1-based line number to start reading from.
-            end_line (int, optional): 1-based line number to stop reading at (inclusive).
-
         Returns:
-            str: JSON with file path, content (with line numbers), start/end lines,
-                and total lines.
+            str: JSON with content of the notes.
 
         Raises:
             Exception: If the note cannot be read.
-                Suggests writing the note if it does not exist.
         """
-        return self._read_note(
-            self._get_contextual_note_path(),
-            start_line,
-            end_line,
-            note_type="contextual note",
-        )
+        return json.dumps({"content": self._fetch_contextual_note()})
 
-    def write_contextual_note(self, content: str) -> str:
+    def add_contextual_info(self, new_info: str, context_path: str | None) -> str:
         """
-        Write or overwrite the content of the contextual note.
-
-        Use this tool to create a new contextual note or replace its entire content.
-        Always read the note first to avoid accidental data loss, unless you are sure
-        you want to overwrite.
+        Add new info for contextual reference.
 
         Args:
-            content (str): The full content to write to the note.
+            new_info (str): New info to be added into contextual references.
+            context_path (str, optional): contextual directory path for new info
 
         Returns:
-            str: JSON indicating success and the note path.
+            str: JSON with new content of the notes.
 
         Raises:
-            Exception: If the note cannot be written. Suggests checking permissions or path.
+            Exception: If the note cannot be read.
         """
-        self.contextual_note = content
-        return self._write_note(
-            self._get_contextual_note_path(), content, note_type="contextual note"
-        )
+        if context_path is None:
+            context_path = self.project_path
+        llm_context_config.add_to_context(new_info, context_path=context_path)
+        return json.dumps({"success": True, "content": self._fetch_contextual_note()})
 
-    def replace_in_contextual_note(
-        self,
-        old_string: str,
-        new_string: str,
+    def remove_contextual_info(
+        self, irrelevant_info: str, context_path: str | None
     ) -> str:
         """
-        Replace the first occurrence of a string in the contextual note.
-
-        Use this tool to update a specific part of the contextual note without
-        overwriting the entire content. If the note does not exist, consider writing it
-        first. If the string is not found, check your input or read the note to verify.
+        Remove irrelevant info from contextual reference.
 
         Args:
-            old_string (str): The exact string to search for and replace.
-            new_string (str): The string to replace with.
+            irrelevant_info (str): Irrelevant info to be removed from contextual references.
+            context_path (str, optional): contextual directory path of the irrelevant info
 
         Returns:
-            str: JSON indicating success and the note path.
+            str: JSON with new content of the notes and deletion status.
 
         Raises:
-            Exception: If the note does not exist or the string is not found.
-                Suggests writing or reading the note.
+            Exception: If the note cannot be read.
         """
-        result = self._replace_in_note(
-            self._get_contextual_note_path(),
-            old_string,
-            new_string,
-            note_type="contextual note",
+        if context_path is None:
+            context_path = self.project_path
+        was_removed = llm_context_config.remove_from_context(
+            irrelevant_info, context_path=context_path
+        )
+        return json.dumps(
+            {
+                "success": was_removed,
+                "content": self._fetch_contextual_note(),
+            }
         )
-        self.contextual_note = new_string
-        return result
-
-    def _get_long_term_note_path(self) -> str:
-        return os.path.abspath(os.path.expanduser(CFG.LLM_LONG_TERM_NOTE_PATH))
-
-    def _get_contextual_note_path(self) -> str:
-        return os.path.join(self.project_path, CFG.LLM_CONTEXTUAL_NOTE_FILE)
-
-    def _read_note(
-        self,
-        path: str,
-        start_line: int | None = None,
-        end_line: int | None = None,
-        note_type: str = "note",
-    ) -> str:
-        """
-        Internal helper to read a note file with line numbers and error handling.
-        """
-        if not os.path.exists(path):
-            return json.dumps(
-                {
-                    "path": path,
-                    "content": "",
-                    "start_line": 0,
-                    "end_line": 0,
-                    "total_lines": 0,
-                }
-            )
-        try:
-            content = read_file_with_line_numbers(path)
-            lines = content.splitlines()
-            total_lines = len(lines)
-            start_idx = (start_line - 1) if start_line is not None else 0
-            end_idx = end_line if end_line is not None else total_lines
-            if start_idx < 0:
-                start_idx = 0
-            if end_idx > total_lines:
-                end_idx = total_lines
-            if start_idx > end_idx:
-                start_idx = end_idx
-            selected_lines = lines[start_idx:end_idx]
-            content_result = "\n".join(selected_lines)
-            return json.dumps(
-                {
-                    "path": path,
-                    "content": content_result,
-                    "start_line": start_idx + 1,
-                    "end_line": end_idx,
-                    "total_lines": total_lines,
-                }
-            )
-        except Exception:
-            raise Exception(
-                f"Failed to read the {note_type}. "
-                f"If the {note_type} does not exist, try writing it first."
-            )
-
-    def _write_note(self, path: str, content: str, note_type: str = "note") -> str:
-        """
-        Internal helper to write a note file with error handling.
-        """
-        try:
-            directory = os.path.dirname(path)
-            if directory and not os.path.exists(directory):
-                os.makedirs(directory, exist_ok=True)
-            write_file(path, content)
-            return json.dumps({"success": True, "path": path})
-        except (OSError, IOError):
-            raise Exception(
-                f"Failed to write the {note_type}. "
-                "Please check if the path is correct and you have write permissions."
-            )
-        except Exception:
-            raise Exception(
-                f"Unexpected error while writing the {note_type}. "
-                "Please check your input and try again."
-            )
 
-    def _replace_in_note(
-        self, path: str, old_string: str, new_string: str, note_type: str = "note"
-    ) -> str:
-        """
-        Internal helper to replace a string in a note file with error handling.
-        """
-        if not os.path.exists(path):
-            raise Exception(
-                (
-                    f"{note_type.capitalize()} not found. "
-                    f"Consider writing a new {note_type} first."
-                )
-            )
-        try:
-            content = read_file(path)
-            if old_string not in content:
-                raise Exception(
-                    f"The specified string to replace was not found in the {note_type}. ("
-                    f"Try reading the {note_type} to verify its content or "
-                    f"write a new one if needed)."
-                )
-            new_content = content.replace(old_string, new_string, 1)
-            write_file(path, new_content)
-            return json.dumps({"success": True, "path": path})
-        except Exception:
-            raise Exception(
-                f"Failed to replace content in the {note_type}. ("
-                f"Try reading the {note_type} to verify its content or "
-                "write a new one if needed)."
-            )
+    def _fetch_long_term_note(self):
+        contexts = llm_context_config.get_contexts(cwd=self.project_path)
+        self.long_term_note = contexts.get("/", "")
+        return self.long_term_note
+
+    def _fetch_contextual_note(self):
+        contexts = llm_context_config.get_contexts(cwd=self.project_path)
+        self.contextual_note = "\n".join(
+            [
+                make_prompt_section(header, content)
+                for header, content in contexts.items()
+                if header != "/"
+            ]
+        )
+        return self.contextual_note

zrb/task/llm/history_summarization.py

@@ -145,16 +145,16 @@ async def summarize_history(
         tools=[
             conversation_history.write_past_conversation_summary,
             conversation_history.write_past_conversation_transcript,
-            conversation_history.read_contextual_note,
-            conversation_history.write_contextual_note,
-            conversation_history.replace_in_contextual_note,
             conversation_history.read_long_term_note,
-            conversation_history.write_long_term_note,
-            conversation_history.replace_in_long_term_note,
+            conversation_history.add_long_term_info,
+            conversation_history.remove_long_term_info,
+            conversation_history.read_contextual_note,
+            conversation_history.add_contextual_info,
+            conversation_history.remove_contextual_info,
         ],
     )
     try:
-        ctx.print(stylize_faint("📝 Summarize"), plain=True)
+        ctx.print(stylize_faint("📝 Summarize Conversation >>>"), plain=True)
         summary_run = await run_agent_iteration(
             ctx=ctx,
             agent=summarization_agent,

zrb/task/llm/prompt.py

@@ -125,38 +125,37 @@ def get_system_and_user_prompt(
 def extract_conversation_context(user_message: str) -> tuple[str, str]:
     modified_user_message = user_message
     # Match “@” + any non-space/comma sequence that contains at least one “/”
-    pattern = r"(?<!\w)@(?=[^,\s]*/)([^,\s]+)"
+    pattern = r"(?<!\w)@(?=[^,\s]*\/)([^,\s]+)"
     potential_resource_path = re.findall(pattern, user_message)
     apendixes = []
-    for ref in potential_resource_path:
+    for i, ref in enumerate(potential_resource_path):
         resource_path = os.path.abspath(os.path.expanduser(ref))
-        print("RESOURCE PATH", resource_path)
+        content = ""
+        ref_type = ""
         if os.path.isfile(resource_path):
             content = read_file_with_line_numbers(resource_path)
-            apendixes.append(
-                make_prompt_section(
-                    f"`{ref}` (file path: `{resource_path}`)", content, as_code=True
-                )
-            )
-            # Remove the '@' from the modified user message for valid file paths
-            modified_user_message = modified_user_message.replace(f"@{ref}", ref, 1)
+            ref_type = "file"
         elif os.path.isdir(resource_path):
             content = read_dir(resource_path)
+            ref_type = "directory"
+        if content != "":
+            # Replace the @-reference in the user message with the placeholder
+            placeholder = f"[Reference {i+1}: {os.path.basename(ref)}]"
+            modified_user_message = modified_user_message.replace(
+                f"@{ref}", placeholder, 1
+            )
             apendixes.append(
                 make_prompt_section(
-                    f"`{ref}` (directory path: `{resource_path}`)",
+                    f"{placeholder} ({ref_type} path: `{resource_path}`)",
                     content,
                     as_code=True,
                 )
             )
-            # Remove the '@' from the modified user message for valid directory paths
-            modified_user_message = modified_user_message.replace(f"@{ref}", ref, 1)
     conversation_context = "\n".join(
         [
             make_prompt_section("Current OS", platform.system()),
             make_prompt_section("OS Version", platform.version()),
             make_prompt_section("Python Version", platform.python_version()),
-            make_prompt_section("Apendixes", "\n".join(apendixes)),
         ]
     )
     iso_date = datetime.now(timezone.utc).astimezone().isoformat()
@@ -172,6 +171,7 @@ def extract_conversation_context(user_message: str) -> tuple[str, str]:
                             "Current working directory", current_directory
                         ),
                         make_prompt_section("Current time", iso_date),
+                        make_prompt_section("Apendixes", "\n".join(apendixes)),
                     ]
                 ),
             ),

zrb/util/llm/prompt.py

@@ -2,17 +2,53 @@ import re
 
 
 def _demote_markdown_headers(md: str) -> str:
-    def demote(match):
-        hashes = match.group(1)
-        return "#" + hashes + match.group(2)  # add one `#`
+    lines = md.split("\n")
+    new_lines = []
+    fence_stack = []
+    for line in lines:
+        stripped_line = line.strip()
+        fence_match = re.match(r"^([`~]{3,})", stripped_line)
 
-    # Replace headers at the beginning of a line
-    return re.sub(r"^(#{1,6})(\s)", demote, md, flags=re.MULTILINE)
+        if fence_match:
+            current_fence = fence_match.group(1)
+            # If stack is not empty and we found a closing fence
+            if (
+                fence_stack
+                and fence_stack[-1][0] == current_fence[0]
+                and len(current_fence) >= len(fence_stack[-1])
+            ):
+                fence_stack.pop()
+            else:
+                fence_stack.append(current_fence)
+            new_lines.append(line)
+        else:
+            if fence_stack:  # If we are inside a code block
+                new_lines.append(line)
+            else:
+                match = re.match(r"^(#{1,6})(\s)", line)
+                if match:
+                    new_lines.append("#" + line)
+                else:
+                    new_lines.append(line)
+    return "\n".join(new_lines)
 
 
 def make_prompt_section(header: str, content: str, as_code: bool = False) -> str:
     if content.strip() == "":
         return ""
     if as_code:
-        return f"# {header}\n````\n{content.strip()}\n````\n"
+        # Find the longest sequence of backticks in the content
+        longest_backtick_sequence = 0
+        # Use finditer to find all occurrences of backticks
+        for match in re.finditer(r"`+", content):
+            longest_backtick_sequence = max(
+                longest_backtick_sequence, len(match.group(0))
+            )
+
+        # The fence should be one longer than the longest sequence found
+        fence_len = 4
+        if longest_backtick_sequence >= fence_len:
+            fence_len = longest_backtick_sequence + 1
+        fence = "`" * fence_len
+        return f"# {header}\n{fence}\n{content.strip()}\n{fence}\n"
     return f"# {header}\n{_demote_markdown_headers(content.strip())}\n"

{zrb-1.10.2.dist-info → zrb-1.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.10.2
+Version: 1.11.0
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
@@ -27,7 +27,7 @@ Requires-Dist: pdfplumber (>=0.11.6,<0.12.0) ; extra == "rag" or extra == "all"
 Requires-Dist: playwright (>=1.53.0,<2.0.0) ; extra == "playwright" or extra == "all"
 Requires-Dist: prompt-toolkit (>=3.0.51,<4.0.0)
 Requires-Dist: psutil (>=7.0.0,<8.0.0)
-Requires-Dist: pydantic-ai (>=0.3.4,<0.4.0)
+Requires-Dist: pydantic-ai (>=0.4.4,<0.5.0)
 Requires-Dist: pyjwt (>=2.10.1,<3.0.0)
 Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
 Requires-Dist: python-jose[cryptography] (>=3.4.0,<4.0.0)