zrb 1.21.9__py3-none-any.whl → 1.21.28__py3-none-any.whl

zrb/attr/type.py

@@ -1,12 +1,15 @@
 from typing import Any, Callable
 
 from zrb.context.any_context import AnyContext
+from zrb.context.any_shared_context import AnySharedContext
 
 fstring = str
-AnyAttr = Any | fstring | Callable[[AnyContext], Any]
-StrAttr = str | fstring | Callable[[AnyContext], str]
-BoolAttr = bool | fstring | Callable[[AnyContext], bool]
-IntAttr = int | fstring | Callable[[AnyContext], int]
-FloatAttr = float | fstring | Callable[[AnyContext], float]
-StrDictAttr = dict[str, StrAttr] | Callable[[AnyContext], dict[str, Any]]
-StrListAttr = list[StrAttr] | Callable[[AnyContext], list[str]]
+AnyAttr = Any | fstring | Callable[[AnyContext | AnySharedContext], Any]
+StrAttr = str | fstring | Callable[[AnyContext | AnySharedContext], str | None]
+BoolAttr = bool | fstring | Callable[[AnyContext | AnySharedContext], bool | None]
+IntAttr = int | fstring | Callable[[AnyContext | AnySharedContext], int | None]
+FloatAttr = float | fstring | Callable[[AnyContext | AnySharedContext], float | None]
+StrDictAttr = (
+    dict[str, StrAttr] | Callable[[AnyContext | AnySharedContext], dict[str, Any]]
+)
+StrListAttr = list[StrAttr] | Callable[[AnyContext | AnySharedContext], list[str]]

zrb/builtin/git.py

@@ -82,6 +82,12 @@ async def get_git_diff(ctx: AnyContext):
 
 @make_task(
     name="prune-local-git-branches",
+    input=StrInput(
+        name="preserved-branch",
+        description="Branches to be preserved",
+        prompt="Branches to be preserved, comma separated",
+        default="master,main,dev,develop",
+    ),
     description="🧹 Prune local branches",
     group=git_branch_group,
     alias="prune",
@@ -93,8 +99,13 @@ async def prune_local_branches(ctx: AnyContext):
     branches = await get_branches(repo_dir, print_method=ctx.print)
     ctx.print(stylize_faint("Get current branch"))
     current_branch = await get_current_branch(repo_dir, print_method=ctx.print)
+    preserved_branches = [
+        branch.strip()
+        for branch in ctx.input.preserved_branch.split(",")
+        if branch.strip() != ""
+    ]
     for branch in branches:
-        if branch == current_branch or branch == "main" or branch == "master":
+        if branch == current_branch or branch in preserved_branches:
             continue
         ctx.print(stylize_faint(f"Removing local branch: {branch}"))
         try:

zrb/builtin/llm/chat_completion.py

@@ -0,0 +1,274 @@
+import os
+
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion
+from prompt_toolkit.document import Document
+
+from zrb.builtin.llm.chat_session_cmd import (
+    ADD_SUB_CMD,
+    ATTACHMENT_ADD_SUB_CMD_DESC,
+    ATTACHMENT_CLEAR_SUB_CMD_DESC,
+    ATTACHMENT_CMD,
+    ATTACHMENT_CMD_DESC,
+    ATTACHMENT_SET_SUB_CMD_DESC,
+    CLEAR_SUB_CMD,
+    HELP_CMD,
+    HELP_CMD_DESC,
+    MULTILINE_END_CMD,
+    MULTILINE_END_CMD_DESC,
+    MULTILINE_START_CMD,
+    MULTILINE_START_CMD_DESC,
+    QUIT_CMD,
+    QUIT_CMD_DESC,
+    RUN_CLI_CMD,
+    RUN_CLI_CMD_DESC,
+    SAVE_CMD,
+    SAVE_CMD_DESC,
+    SET_SUB_CMD,
+    WORKFLOW_ADD_SUB_CMD_DESC,
+    WORKFLOW_CLEAR_SUB_CMD_DESC,
+    WORKFLOW_CMD,
+    WORKFLOW_CMD_DESC,
+    WORKFLOW_SET_SUB_CMD_DESC,
+    YOLO_CMD,
+    YOLO_CMD_DESC,
+    YOLO_SET_CMD_DESC,
+    YOLO_SET_FALSE_CMD_DESC,
+    YOLO_SET_TRUE_CMD_DESC,
+)
+
+
+class ChatCompleter(Completer):
+
+    def get_completions(self, document: Document, complete_event: CompleteEvent):
+        # Slash command
+        for completion in self._complete_slash_command(document):
+            yield completion
+        for completion in self._complete_slash_file_command(document):
+            yield completion
+        # Appendix
+        for completion in self._complete_appendix(document):
+            yield completion
+
+    def _complete_slash_file_command(self, document: Document):
+        text = document.text_before_cursor
+        prefixes = []
+        for cmd in ATTACHMENT_CMD:
+            for subcmd in ADD_SUB_CMD:
+                prefixes.append(f"{cmd} {subcmd} ")
+        for prefix in prefixes:
+            if text.startswith(prefix):
+                pattern = text[len(prefix) :]
+                potential_options = self._fuzzy_path_search(pattern, dirs=False)
+                for prefixed_option in [
+                    f"{prefix}{option}" for option in potential_options
+                ]:
+                    yield Completion(
+                        prefixed_option,
+                        start_position=-len(text),
+                    )
+
+    def _complete_slash_command(self, document: Document):
+        text = document.text_before_cursor
+        if not text.startswith("/"):
+            return
+        for command, description in self._get_cmd_options().items():
+            if command.lower().startswith(text.lower()):
+                yield Completion(
+                    command,
+                    start_position=-len(text),
+                    display_meta=description,
+                )
+
+    def _complete_appendix(self, document: Document):
+        token = document.get_word_before_cursor(WORD=True)
+        prefix = "@"
+        if not token.startswith(prefix):
+            return
+        pattern = token[len(prefix) :]
+        potential_options = self._fuzzy_path_search(pattern, dirs=False)
+        for prefixed_option in [f"{prefix}{option}" for option in potential_options]:
+            yield Completion(
+                prefixed_option,
+                start_position=-len(token),
+            )
+
+    def _get_cmd_options(self):
+        cmd_options = {}
+        # Add all commands with their descriptions
+        for cmd in MULTILINE_START_CMD:
+            cmd_options[cmd] = MULTILINE_START_CMD_DESC
+        for cmd in MULTILINE_END_CMD:
+            cmd_options[cmd] = MULTILINE_END_CMD_DESC
+        for cmd in QUIT_CMD:
+            cmd_options[cmd] = QUIT_CMD_DESC
+        for cmd in WORKFLOW_CMD:
+            cmd_options[cmd] = WORKFLOW_CMD_DESC
+            for subcmd in ADD_SUB_CMD:
+                cmd_options[f"{cmd} {subcmd}"] = WORKFLOW_ADD_SUB_CMD_DESC
+            for subcmd in CLEAR_SUB_CMD:
+                cmd_options[f"{cmd} {subcmd}"] = WORKFLOW_CLEAR_SUB_CMD_DESC
+            for subcmd in SET_SUB_CMD:
+                cmd_options[f"{cmd} {subcmd}"] = WORKFLOW_SET_SUB_CMD_DESC
+        for cmd in SAVE_CMD:
+            cmd_options[cmd] = SAVE_CMD_DESC
+        for cmd in ATTACHMENT_CMD:
+            cmd_options[cmd] = ATTACHMENT_CMD_DESC
+            for subcmd in ADD_SUB_CMD:
+                cmd_options[f"{cmd} {subcmd}"] = ATTACHMENT_ADD_SUB_CMD_DESC
+            for subcmd in CLEAR_SUB_CMD:
+                cmd_options[f"{cmd} {subcmd}"] = ATTACHMENT_CLEAR_SUB_CMD_DESC
+            for subcmd in SET_SUB_CMD:
+                cmd_options[f"{cmd} {subcmd}"] = ATTACHMENT_SET_SUB_CMD_DESC
+        for cmd in YOLO_CMD:
+            cmd_options[cmd] = YOLO_CMD_DESC
+            for subcmd in SET_SUB_CMD:
+                cmd_options[f"{cmd} {subcmd} true"] = YOLO_SET_TRUE_CMD_DESC
+                cmd_options[f"{cmd} {subcmd} false"] = YOLO_SET_FALSE_CMD_DESC
+                cmd_options[f"{cmd} {subcmd}"] = YOLO_SET_CMD_DESC
+        for cmd in HELP_CMD:
+            cmd_options[cmd] = HELP_CMD_DESC
+        for cmd in RUN_CLI_CMD:
+            cmd_options[cmd] = RUN_CLI_CMD_DESC
+        return dict(sorted(cmd_options.items()))
+
+    def _fuzzy_path_search(
+        self,
+        pattern: str,
+        root: str | None = None,
+        max_results: int = 20,
+        include_hidden: bool = False,
+        case_sensitive: bool = False,
+        dirs: bool = True,
+        files: bool = True,
+    ) -> list[str]:
+        """
+        Return a list of filesystem paths under `root` that fuzzy-match `pattern`.
+        - pattern: e.g. "./some/x" or "proj util/io"
+        - include_hidden: if False skip files/dirs starting with '.'
+        - dirs/files booleans let you restrict results
+        - returns list of relative paths (from root), sorted best-first
+        """
+        search_pattern = pattern
+        if root is None:
+            # Determine root and adjust pattern if necessary
+            expanded_pattern = os.path.expanduser(pattern)
+            if os.path.isabs(expanded_pattern) or pattern.startswith("~"):
+                # For absolute paths, find the deepest existing directory
+                if os.path.isdir(expanded_pattern):
+                    root = expanded_pattern
+                    search_pattern = ""
+                else:
+                    root = os.path.dirname(expanded_pattern)
+                    while root and not os.path.isdir(root) and len(root) > 1:
+                        root = os.path.dirname(root)
+                    if not os.path.isdir(root):
+                        root = "."  # Fallback
+                        search_pattern = pattern
+                    else:
+                        try:
+                            search_pattern = os.path.relpath(expanded_pattern, root)
+                            if search_pattern == ".":
+                                search_pattern = ""
+                        except ValueError:
+                            search_pattern = os.path.basename(pattern)
+            else:
+                root = "."
+                search_pattern = pattern
+        # Normalize pattern -> tokens split on path separators or whitespace
+        search_pattern = search_pattern.strip()
+        if search_pattern:
+            raw_tokens = [t for t in search_pattern.split(os.path.sep) if t]
+        else:
+            raw_tokens = []
+        # prepare tokens (case)
+        if not case_sensitive:
+            tokens = [t.lower() for t in raw_tokens]
+        else:
+            tokens = raw_tokens
+        # specific ignore list
+        try:
+            is_recursive = os.path.abspath(os.path.expanduser(root)).startswith(
+                os.path.abspath(os.getcwd())
+            )
+        except Exception:
+            is_recursive = False
+        # walk filesystem
+        candidates: list[tuple[float, str]] = []
+        for dirpath, dirnames, filenames in os.walk(root):
+            # Filter directories
+            if not include_hidden:
+                dirnames[:] = [d for d in dirnames if not d.startswith(".")]
+            rel_dir = os.path.relpath(dirpath, root)
+            # treat '.' as empty prefix
+            if rel_dir == ".":
+                rel_dir = ""
+            # build list of entries to test depending on files/dirs flags
+            entries = []
+            if dirs:
+                entries.extend([os.path.join(rel_dir, d) for d in dirnames])
+            if files:
+                entries.extend([os.path.join(rel_dir, f) for f in filenames])
+            if not is_recursive:
+                dirnames[:] = []
+            for ent in entries:
+                # Normalize presentation: use ./ prefix for relative paths
+                display_path = ent if ent else "."
+                # Skip hidden entries unless requested (double check for rel path segments)
+                if not include_hidden:
+                    if any(
+                        seg.startswith(".") for seg in display_path.split(os.sep) if seg
+                    ):
+                        continue
+                cand = display_path.replace(os.sep, "/")  # unify separator
+                cand_cmp = cand if case_sensitive else cand.lower()
+                last_pos = 0
+                score = 0.0
+                matched_all = True
+                for token in tokens:
+                    # try contiguous substring search first
+                    idx = cand_cmp.find(token, last_pos)
+                    if idx != -1:
+                        # good match: reward contiguous early matches
+                        score += idx  # smaller idx preferred
+                        last_pos = idx + len(token)
+                    else:
+                        # fallback to subsequence matching
+                        pos = self._find_subsequence_pos(cand_cmp, token, last_pos)
+                        if pos is None:
+                            matched_all = False
+                            break
+                        # subsequence match is less preferred than contiguous substring
+                        score += pos + 0.5 * len(token)
+                        last_pos = pos + len(token)
+                if matched_all:
+                    # prefer shorter paths when score ties, so include length as tiebreaker
+                    score += 0.01 * len(cand)
+                    out = (
+                        cand
+                        if os.path.abspath(cand) == cand
+                        else os.path.join(root, cand)
+                    )
+                    candidates.append((score, out))
+        # sort by score then lexicographically and return top results
+        candidates.sort(key=lambda x: (x[0], x[1]))
+        return [p for _, p in candidates[:max_results]]
+
+    def _find_subsequence_pos(
+        self, hay: str, needle: str, start: int = 0
+    ) -> int | None:
+        """
+        Try to locate needle in hay as a subsequence starting at `start`.
+        Returns the index of the first matched character of the subsequence or None if not match.
+        """
+        if not needle:
+            return start
+        i = start
+        j = 0
+        first_pos = None
+        while i < len(hay) and j < len(needle):
+            if hay[i] == needle[j]:
+                if first_pos is None:
+                    first_pos = i
+                j += 1
+            i += 1
+        return first_pos if j == len(needle) else None

zrb/builtin/llm/chat_session_cmd.py

@@ -12,13 +12,14 @@ from zrb.util.cli.style import (
 )
 from zrb.util.file import write_file
 from zrb.util.markdown import make_markdown_section
+from zrb.util.string.conversion import FALSE_STRS, TRUE_STRS, to_boolean
 
 MULTILINE_START_CMD = ["/multi", "/multiline"]
 MULTILINE_END_CMD = ["/end"]
 QUIT_CMD = ["/bye", "/quit", "/q", "/exit"]
 WORKFLOW_CMD = ["/workflow", "/workflows", "/skill", "/skills", "/w"]
 SAVE_CMD = ["/save", "/s"]
-ATTACHMENT_CMD = ["/attach", "/attachment", "/attachments"]
+ATTACHMENT_CMD = ["/attachment", "/attachments", "/attach"]
 YOLO_CMD = ["/yolo"]
 HELP_CMD = ["/help", "/info"]
 ADD_SUB_CMD = ["add"]
@@ -26,6 +27,39 @@ SET_SUB_CMD = ["set"]
 CLEAR_SUB_CMD = ["clear"]
 RUN_CLI_CMD = ["/run", "/exec", "/execute", "/cmd", "/cli", "!"]
 
+# Command display constants
+MULTILINE_START_CMD_DESC = "Start multiline input"
+MULTILINE_END_CMD_DESC = "End multiline input"
+QUIT_CMD_DESC = "Quit from chat session"
+WORKFLOW_CMD_DESC = "Show active workflows"
+WORKFLOW_ADD_SUB_CMD_DESC = (
+    "Add active workflow "
+    f"(e.g., `{WORKFLOW_CMD[0]} {ADD_SUB_CMD[0]} coding,researching`)"
+)
+WORKFLOW_SET_SUB_CMD_DESC = (
+    "Set active workflows " f"(e.g., `{WORKFLOW_CMD[0]} {SET_SUB_CMD[0]} coding,`)"
+)
+WORKFLOW_CLEAR_SUB_CMD_DESC = "Deactivate all workflows"
+SAVE_CMD_DESC = f"Save last response to a file (e.g., `{SAVE_CMD[0]} conclusion.md`)"
+ATTACHMENT_CMD_DESC = "Show current attachment"
+ATTACHMENT_ADD_SUB_CMD_DESC = (
+    "Attach a file " f"(e.g., `{ATTACHMENT_CMD[0]} {ADD_SUB_CMD[0]} ./logo.png`)"
+)
+ATTACHMENT_SET_SUB_CMD_DESC = (
+    "Set attachments "
+    f"(e.g., `{ATTACHMENT_CMD[0]} {SET_SUB_CMD[0]} ./logo.png,./diagram.png`)"
+)
+ATTACHMENT_CLEAR_SUB_CMD_DESC = "Clear attachment"
+YOLO_CMD_DESC = "Show/manipulate current YOLO mode"
+YOLO_SET_CMD_DESC = (
+    "Assign YOLO tools "
+    f"(e.g., `{YOLO_CMD[0]} {SET_SUB_CMD[0]} read_from_file,analyze_file`)"
+)
+YOLO_SET_TRUE_CMD_DESC = "Activate YOLO mode for all tools"
+YOLO_SET_FALSE_CMD_DESC = "Deactivate YOLO mode for all tools"
+RUN_CLI_CMD_DESC = "Run a non-interactive CLI command"
+HELP_CMD_DESC = "Show info/help"
+
 
 def print_current_yolo_mode(
     ctx: AnyContext, current_yolo_mode_value: str | bool
@@ -115,34 +149,54 @@ def run_cli_command(ctx: AnyContext, user_input: str) -> None:
 def get_new_yolo_mode(old_yolo_mode: str | bool, user_input: str) -> str | bool:
     new_yolo_mode = get_command_param(user_input, YOLO_CMD)
     if new_yolo_mode != "":
+        if new_yolo_mode in TRUE_STRS or new_yolo_mode in FALSE_STRS:
+            return to_boolean(new_yolo_mode)
         return new_yolo_mode
-    return old_yolo_mode
+    if isinstance(old_yolo_mode, bool):
+        return old_yolo_mode
+    return _normalize_comma_separated_str(old_yolo_mode)
 
 
 def get_new_attachments(old_attachment: str, user_input: str) -> str:
     if not is_command_match(user_input, ATTACHMENT_CMD):
-        return old_attachment
+        return _normalize_comma_separated_str(old_attachment)
     if is_command_match(user_input, ATTACHMENT_CMD, SET_SUB_CMD):
-        return get_command_param(user_input, ATTACHMENT_CMD, SET_SUB_CMD)
+        return _normalize_comma_separated_str(
+            get_command_param(user_input, ATTACHMENT_CMD, SET_SUB_CMD)
+        )
     if is_command_match(user_input, ATTACHMENT_CMD, CLEAR_SUB_CMD):
         return ""
     if is_command_match(user_input, ATTACHMENT_CMD, ADD_SUB_CMD):
         new_attachment = get_command_param(user_input, ATTACHMENT_CMD, ADD_SUB_CMD)
-        return ",".join([old_attachment, new_attachment])
+        return _normalize_comma_separated_str(
+            ",".join([old_attachment, new_attachment])
+        )
     return old_attachment
 
 
 def get_new_workflows(old_workflow: str, user_input: str) -> str:
     if not is_command_match(user_input, WORKFLOW_CMD):
-        return old_workflow
+        return _normalize_comma_separated_str(old_workflow)
     if is_command_match(user_input, WORKFLOW_CMD, SET_SUB_CMD):
-        return get_command_param(user_input, WORKFLOW_CMD, SET_SUB_CMD)
+        return _normalize_comma_separated_str(
+            get_command_param(user_input, WORKFLOW_CMD, SET_SUB_CMD)
+        )
     if is_command_match(user_input, WORKFLOW_CMD, CLEAR_SUB_CMD):
         return ""
     if is_command_match(user_input, WORKFLOW_CMD, ADD_SUB_CMD):
         new_workflow = get_command_param(user_input, WORKFLOW_CMD, ADD_SUB_CMD)
-        return ",".join([old_workflow, new_workflow])
-    return old_workflow
+        return _normalize_comma_separated_str(",".join([old_workflow, new_workflow]))
+    return _normalize_comma_separated_str(old_workflow)
+
+
+def _normalize_comma_separated_str(comma_separated_str: str) -> str:
+    return ",".join(
+        [
+            workflow_name.strip()
+            for workflow_name in comma_separated_str.split(",")
+            if workflow_name.strip() != ""
+        ]
+    )
 
 
 def get_command_param(user_input: str, *cmd_patterns: list[str]) -> str:
@@ -175,31 +229,39 @@ def print_commands(ctx: AnyContext):
     ctx.print(
         "\n".join(
             [
-                _show_command("/bye", "Quit from chat session"),
-                _show_command("/multi", "Start multiline input"),
-                _show_command("/end", "End multiline input"),
-                _show_command("/attachment", "Show current attachment"),
-                _show_subcommand("add", "<new-attachment>", "Attach a file"),
+                _show_command(QUIT_CMD[0], QUIT_CMD_DESC),
+                _show_command(MULTILINE_START_CMD[0], MULTILINE_START_CMD_DESC),
+                _show_command(MULTILINE_END_CMD[0], MULTILINE_END_CMD_DESC),
+                _show_command(ATTACHMENT_CMD[0], ATTACHMENT_CMD_DESC),
                 _show_subcommand(
-                    "set", "<attachment1,attachment2,...>", "Attach a file"
+                    ADD_SUB_CMD[0], "<file-path>", ATTACHMENT_ADD_SUB_CMD_DESC
                 ),
-                _show_subcommand("clear", "", "Clear attachment"),
-                _show_command("/workflow", "Show active workflows"),
-                _show_subcommand("add", "<workflow>", "Add active workflow"),
                 _show_subcommand(
-                    "set", "<workflow1,workflow2,..>", "Set active workflows"
+                    SET_SUB_CMD[0],
+                    "<file1-path,file2-path,...>",
+                    ATTACHMENT_SET_SUB_CMD_DESC,
                 ),
-                _show_subcommand("clear", "", "Deactivate all workflows"),
-                _show_command("/save <file-path>", "Save last response to a file"),
-                _show_command("/yolo", "Show current YOLO mode"),
-                _show_command_param(
-                    "<true | false | tool1,tool2,...>", "Set YOLO mode"
+                _show_subcommand(CLEAR_SUB_CMD[0], "", ATTACHMENT_CLEAR_SUB_CMD_DESC),
+                _show_command(WORKFLOW_CMD[0], WORKFLOW_CMD_DESC),
+                _show_subcommand(
+                    ADD_SUB_CMD[0], "<workflow>", WORKFLOW_ADD_SUB_CMD_DESC
+                ),
+                _show_subcommand(
+                    SET_SUB_CMD[0],
+                    "<workflow1,workflow2,..>",
+                    WORKFLOW_SET_SUB_CMD_DESC,
                 ),
-                _show_command("/run", ""),
-                _show_command_param(
-                    "<cli-command>", "Run a non-interactive CLI command"
+                _show_subcommand(CLEAR_SUB_CMD[0], "", WORKFLOW_CLEAR_SUB_CMD_DESC),
+                _show_command(f"{SAVE_CMD[0]}", SAVE_CMD_DESC),
+                _show_command(YOLO_CMD[0], YOLO_CMD_DESC),
+                _show_subcommand(SET_SUB_CMD[0], "true", YOLO_SET_TRUE_CMD_DESC),
+                _show_subcommand(SET_SUB_CMD[0], "false", YOLO_SET_FALSE_CMD_DESC),
+                _show_subcommand(
+                    SET_SUB_CMD[0], "<tool1,tool2,tool2>", YOLO_SET_CMD_DESC
                 ),
-                _show_command("/help", "Show this message"),
+                _show_command(RUN_CLI_CMD[0], ""),
+                _show_command_param("<cli-command>", RUN_CLI_CMD_DESC),
+                _show_command(HELP_CMD[0], HELP_CMD_DESC),
             ]
         ),
         plain=True,

zrb/builtin/llm/chat_trigger.py

@@ -1,4 +1,5 @@
 import asyncio
+import os
 from asyncio import StreamReader
 from typing import TYPE_CHECKING, Any, Callable, Coroutine
 
@@ -56,9 +57,14 @@ class LLMChatTrigger:
         """Reads one line of input using the provided reader."""
         from prompt_toolkit import PromptSession
 
+        from zrb.builtin.llm.chat_completion import ChatCompleter
+
         try:
             if isinstance(reader, PromptSession):
-                return await reader.prompt_async()
+                bottom_toolbar = f"📁 Current directory: {os.getcwd()}"
+                return await reader.prompt_async(
+                    completer=ChatCompleter(), bottom_toolbar=bottom_toolbar
+                )
             line_bytes = await reader.readline()
             if not line_bytes:
                 return "/bye"  # Signal to exit

zrb/builtin/llm/history.py

@@ -3,12 +3,12 @@ import os
 from typing import Any
 
 from zrb.config.config import CFG
-from zrb.context.any_shared_context import AnySharedContext
+from zrb.context.any_context import AnyContext
 from zrb.task.llm.conversation_history_model import ConversationHistory
 from zrb.util.file import read_file, write_file
 
 
-def read_chat_conversation(ctx: AnySharedContext) -> dict[str, Any] | list | None:
+def read_chat_conversation(ctx: AnyContext) -> dict[str, Any] | list | None:
     """Reads conversation history from the session file.
     Returns the raw dictionary or list loaded from JSON, or None if not found/empty.
     The LLMTask will handle parsing this into ConversationHistory.
@@ -51,10 +51,10 @@ def read_chat_conversation(ctx: AnySharedContext) -> dict[str, Any] | list | Non
         return None
 
 
-def write_chat_conversation(ctx: AnySharedContext, history_data: ConversationHistory):
+def write_chat_conversation(ctx: AnyContext, history_data: ConversationHistory):
     """Writes the conversation history data (including context) to a session file."""
     os.makedirs(CFG.LLM_HISTORY_DIR, exist_ok=True)
-    current_session_name = ctx.session.name
+    current_session_name = ctx.session.name if ctx.session is not None else None
     if not current_session_name:
         ctx.log_warning("Cannot write history: Session name is empty.")
         return

zrb/builtin/llm/tool/code.py

@@ -149,6 +149,8 @@ async def _extract_info(
         tool_name="extract",
         tool_description="extract",
         system_prompt=CFG.LLM_REPO_EXTRACTOR_SYSTEM_PROMPT,
+        auto_summarize=False,
+        remember_history=False,
     )
     extracted_infos = []
     content_buffer = []
@@ -170,7 +172,6 @@ async def _extract_info(
         else:
             content_buffer.append(file_obj)
             current_token_count += llm_rate_limitter.count_token(file_str)
-
     # Process any remaining content in the buffer
     if content_buffer:
         prompt = json.dumps(_create_extract_info_prompt(query, content_buffer))
@@ -198,6 +199,8 @@ async def _summarize_info(
         tool_name="extract",
         tool_description="extract",
         system_prompt=CFG.LLM_REPO_SUMMARIZER_SYSTEM_PROMPT,
+        auto_summarize=False,
+        remember_history=False,
     )
     summarized_infos = []
     content_buffer = ""