wcgw 2.6.3__py3-none-any.whl → 2.7.0__py3-none-any.whl

wcgw/client/file_ops/search_replace.py

@@ -0,0 +1,119 @@
+import re
+from typing import Callable
+
+from .diff_edit import FileEditInput, FileEditOutput
+
+
+def search_replace_edit(
+    lines: list[str], original_content: str, logger: Callable[[str], object]
+) -> tuple[str, str]:
+    if not lines:
+        raise Exception("Error: No input to search replace edit")
+    original_lines = original_content.split("\n")
+    n_lines = len(lines)
+    i = 0
+    search_replace_blocks = list[tuple[list[str], list[str]]]()
+    while i < n_lines:
+        if re.match(r"^<<<<<<+\s*SEARCH\s*$", lines[i]):
+            search_block = []
+            i += 1
+            while i < n_lines and not re.match(r"^======*\s*$", lines[i]):
+                search_block.append(lines[i])
+                i += 1
+            i += 1
+            if not search_block:
+                raise Exception("SEARCH block can not be empty")
+            replace_block = []
+            while i < n_lines and not re.match(r"^>>>>>>+\s*REPLACE\s*$", lines[i]):
+                replace_block.append(lines[i])
+                i += 1
+            i += 1
+
+            for line in search_block:
+                logger("> " + line)
+            logger("=======")
+            for line in replace_block:
+                logger("< " + line)
+            logger("\n\n\n\n")
+
+            search_replace_blocks.append((search_block, replace_block))
+        else:
+            i += 1
+
+    if not search_replace_blocks:
+        raise Exception(
+            "No valid search replace blocks found, ensure your SEARCH/REPLACE blocks are formatted correctly"
+        )
+
+    edited_content, comments_ = greedy_context_replace(
+        original_lines, [[x] for x in search_replace_blocks], original_lines, set(), 0
+    )
+    edited_file = "\n".join(edited_content)
+    if not comments_:
+        comments = "Edited successfully"
+    else:
+        comments = (
+            "Edited successfully. However, following warnings were generated while matching search blocks.\n"
+            + "\n".join(comments_)
+        )
+    return edited_file, comments
+
+
+def greedy_context_replace(
+    original_lines: list[str],
+    search_replace_blocks: list[list[tuple[list[str], list[str]]]],
+    running_lines: list[str],
+    running_comments: set[str],
+    current_block_offset: int,
+) -> tuple[list[str], set[str]]:
+    if current_block_offset >= len(search_replace_blocks):
+        return running_lines, running_comments
+    current_blocks = search_replace_blocks[current_block_offset]
+
+    outputs = FileEditInput(running_lines, 0, current_blocks, 0).edit_file()
+    best_matches, is_error = FileEditOutput.get_best_match(outputs)
+
+    if is_error:
+        best_matches[0].replace_or_throw(3)
+        raise Exception("Shouldn't happen")
+
+    if len(best_matches) > 1:
+        # Duplicate found, try to ground using previous blocks.
+        if current_block_offset == 0:
+            raise Exception(f"""
+    The following block matched more than once:
+    ---
+    ```
+    {'\n'.join(current_blocks[-1][0])}
+    ```
+    """)
+
+        else:
+            search_replace_blocks = (
+                search_replace_blocks[: current_block_offset - 1]
+                + [search_replace_blocks[current_block_offset - 1] + current_blocks]
+                + search_replace_blocks[current_block_offset + 1 :]
+            )
+            try:
+                return greedy_context_replace(
+                    original_lines, search_replace_blocks, original_lines, set(), 0
+                )
+            except Exception:
+                raise Exception(f"""
+        The following block matched more than once:
+        ---
+        ```
+        {'\n'.join(current_blocks[-1][0])}
+        ```
+        """)
+
+    best_match = best_matches[0]
+    running_lines, comments = best_match.replace_or_throw(3)
+    running_comments = running_comments | comments
+    return greedy_context_replace(
+        original_lines,
+        search_replace_blocks,
+        running_lines,
+        running_comments,
+        current_block_offset + 1,
+    )

wcgw/client/mcp_server/server.py

@@ -82,6 +82,7 @@ async def handle_list_tools() -> list[types.Tool]:
 - If the user has mentioned a folder or file with unclear project root, use the file or folder as `any_workspace_path`.
 - If user has mentioned any files use `initial_files_to_read` to read, use absolute paths only.
 - If `any_workspace_path` is provided, a tree structure of the workspace will be shown.
+- Leave `any_workspace_path` as empty if no file or folder is mentioned.
 """,
         ),
         ToolParam(
@@ -152,6 +153,24 @@ async def handle_list_tools() -> list[types.Tool]:
 """
             + diffinstructions,
         ),
+        #         ToolParam(
+        #             inputSchema=KnowledgeTransfer.model_json_schema(),
+        #             name="KnowledgeTransfer",
+        #             description="""
+        # Write detailed description in order to do a KT, if the user asks for it.
+        # Save all information necessary for a person to understand the task and the problems.
+        # - `all_user_instructions` should contain all instructions user shared in the conversation.
+        # - `current_status_of_the_task` should contain only what is already achieved, not what's remaining.
+        # - `all_issues_snippets` should only contain snippets of error, traceback, file snippets, commands, etc., no comments or solutions (important!).
+        # - Be very verbose in `all_issues_snippets` providing as much error context as possible.
+        # - Provide an id if the user hasn't provided one.
+        # - This tool will return a text file path where the information is saved.
+        # - After the tool completes succesfully, tell the user the task id and the generate file path. (important!)
+        # - Leave arguments as empty string if they aren't relevant.
+        # - This tool marks end of your conversation, do not run any further tools after calling this.
+        # - Provide absolute file paths only in `relevant_file_paths` containing all relevant files.
+        # """,
+        #         ),
     ]
     if COMPUTER_USE_ON_DOCKER_ENABLED:
         tools += [

wcgw/client/memory.py

@@ -0,0 +1,52 @@
+import os
+
+from ..types_ import KnowledgeTransfer
+
+
+def get_app_dir_xdg() -> str:
+    xdg_data_dir = os.environ.get("XDG_DATA_HOME", os.path.expanduser("~/.local/share"))
+    return os.path.join(xdg_data_dir, "wcgw")
+
+
+def format_memory(task_memory: KnowledgeTransfer, relevant_files: str) -> str:
+    memory_data = f"""# Goal: {task_memory.objective}\n\n
+# Instructions:\n{task_memory.all_user_instructions}\n\n
+# Current Status:\n{task_memory.current_status_of_the_task}\n\n
+# Pending Issues:\n{task_memory.all_issues_snippets}\n\n
+# Build Instructions:\n{task_memory.build_and_development_instructions}\n"""
+
+    memory_data += "\n# Relevant Files:\n" + relevant_files
+
+    return memory_data
+
+
+def save_memory(task_memory: KnowledgeTransfer, relevant_files: str) -> str:
+    app_dir = get_app_dir_xdg()
+    memory_dir = os.path.join(app_dir, "memory")
+    os.makedirs(memory_dir, exist_ok=True)
+
+    task_id = task_memory.id
+    if not task_id:
+        raise Exception("Task id can not be empty")
+    memory_data = format_memory(task_memory, relevant_files)
+
+    memory_file = os.path.join(memory_dir, f"{task_id}.json")
+    memory_file_full = os.path.join(memory_dir, f"{task_id}.txt")
+
+    with open(memory_file_full, "w") as f:
+        f.write(memory_data)
+
+    with open(memory_file, "w") as f:
+        f.write(task_memory.model_dump_json())
+
+    return memory_file_full
+
+
+def load_memory(task_id: str) -> KnowledgeTransfer:
+    app_dir = get_app_dir_xdg()
+    memory_dir = os.path.join(app_dir, "memory")
+    memory_file = os.path.join(memory_dir, f"{task_id}.json")
+
+    with open(memory_file, "r") as f:
+        task_save = KnowledgeTransfer.model_validate_json(f.read())
+    return task_save

wcgw/client/openai_client.py

@@ -27,17 +27,20 @@ from ..types_ import (
     BashCommand,
     BashInteraction,
     FileEdit,
+    KnowledgeTransfer,
     ReadFiles,
     ReadImage,
     ResetShell,
     WriteIfEmpty,
 )
 from .common import CostData, History, Models, discard_input
+from .memory import load_memory
 from .openai_utils import get_input_cost, get_output_cost
 from .tools import (
     DoneFlag,
     ImageData,
     get_tool_output,
+    initialize,
     which_tool,
 )
 
@@ -117,19 +120,24 @@ def loop(
 
     history: History = []
     waiting_for_assistant = False
+
+    memory = None
     if resume:
-        if resume == "latest":
-            resume_path = sorted(Path(".wcgw").iterdir(), key=os.path.getmtime)[-1]
-        else:
-            resume_path = Path(resume)
-        if not resume_path.exists():
-            raise FileNotFoundError(f"File {resume} not found")
-        with resume_path.open() as f:
-            history = json.load(f)
-        if len(history) <= 2:
-            raise ValueError("Invalid history file")
-        first_message = ""
-        waiting_for_assistant = history[-1]["role"] != "assistant"
+        try:
+            memory = load_memory(resume)
+        except OSError:
+            if resume == "latest":
+                resume_path = sorted(Path(".wcgw").iterdir(), key=os.path.getmtime)[-1]
+            else:
+                resume_path = Path(resume)
+            if not resume_path.exists():
+                raise FileNotFoundError(f"File {resume} not found")
+            with resume_path.open() as f:
+                history = json.load(f)
+            if len(history) <= 2:
+                raise ValueError("Invalid history file")
+            first_message = ""
+            waiting_for_assistant = history[-1]["role"] != "assistant"
 
     my_dir = os.path.dirname(__file__)
 
@@ -202,10 +210,29 @@ def loop(
             ResetShell,
             description="Resets the shell. Use only if all interrupts and prompt reset attempts have failed repeatedly.",
         ),
+        openai.pydantic_function_tool(
+            KnowledgeTransfer,
+            description="""
+Write detailed description in order to do a KT, if the user asks for it.
+Save all information necessary for a person to understand the task and the problems.
+
+- `all_user_instructions` should contain all instructions user shared in the conversation.
+- `current_status_of_the_task` should contain only what is already achieved, not what's remaining.
+- `all_issues_snippets` should only contain snippets of error, traceback, file snippets, commands, etc., no comments or solutions (important!).
+- Be very verbose in `all_issues_snippets` providing as much error context as possible.
+- Provide an id if the user hasn't provided one. 
+- This tool will return a text file path where the information is saved.
+- After the tool completes succesfully, tell the user the task id and the generate file path. (important!)
+- Leave arguments as empty string if they aren't relevant.
+- This tool marks end of your conversation, do not run any further tools after calling this.
+- Provide absolute file paths only in `relevant_file_paths` containing all relevant files.
+""",
+        ),
     ]
-    uname_sysname = os.uname().sysname
-    uname_machine = os.uname().machine
 
+    initial_info = initialize(
+        os.getcwd(), [], resume if (memory and resume) else "", 8000
+    )
     system = f"""
 You're an expert software engineer with shell and code knowledge.
 
@@ -217,10 +244,7 @@ Instructions:
     - Do not provide code snippets unless asked by the user, instead directly add/edit the code.
     - Do not install new tools/packages before ensuring no such tools/package or an alternative already exists.
 
-System information:
-    - System: {uname_sysname}
-    - Machine: {uname_machine}
-    - Current directory: {os.getcwd()}
+{initial_info}
 
 """
 

wcgw/client/tools.py

@@ -9,7 +9,7 @@ import shlex
 import time
 import traceback
 import uuid
-from difflib import SequenceMatcher
+from os.path import expanduser
 from pathlib import Path
 from tempfile import NamedTemporaryFile, TemporaryDirectory
 from typing import (
@@ -43,6 +43,7 @@ from ..types_ import (
     GetScreenInfo,
     Initialize,
     Keyboard,
+    KnowledgeTransfer,
     Mouse,
     ReadFiles,
     ReadImage,
@@ -51,6 +52,8 @@ from ..types_ import (
     WriteIfEmpty,
 )
 from .computer_use import run_computer_tool
+from .file_ops.search_replace import search_replace_edit
+from .memory import format_memory, load_memory, save_memory
 from .repo_ops.repo_context import get_repo_context
 from .sys_utils import command_run
 
@@ -290,12 +293,33 @@ BASH_STATE = BashState()
 
 
 def initialize(
-    any_workspace_path: str, read_files_: list[str], max_tokens: Optional[int]
+    any_workspace_path: str,
+    read_files_: list[str],
+    task_id_to_resume: str,
+    max_tokens: Optional[int],
 ) -> str:
     reset_shell()
 
+    # Expand the workspace path
+    any_workspace_path = expand_user(any_workspace_path, BASH_STATE.is_in_docker)
     repo_context = ""
 
+    memory = ""
+    if task_id_to_resume:
+        try:
+            task_mem = load_memory(task_id_to_resume)
+            mem_files = task_mem.relevant_file_paths
+            mem_files_read = read_files(mem_files, max_tokens)
+            memory = "Following is the retrieved task:\n" + format_memory(
+                task_mem, mem_files_read
+            )
+            if (
+                not any_workspace_path or not os.path.exists(any_workspace_path)
+            ) and os.path.exists(task_mem.project_root_path):
+                any_workspace_path = task_mem.project_root_path
+        except Exception:
+            memory = f'Error: Unable to load task with ID "{task_id_to_resume}" '
+
     if any_workspace_path:
         if os.path.exists(any_workspace_path):
             repo_context, folder_to_start = get_repo_context(any_workspace_path, 200)
@@ -306,7 +330,9 @@ def initialize(
 
             repo_context = f"---\n# Workspace structure\n{repo_context}\n---\n"
         else:
-            return f"\nInfo: Workspace path {any_workspace_path} does not exist\n"
+            repo_context = (
+                f"\nInfo: Workspace path {any_workspace_path} does not exist\n"
+            )
 
     initial_files_context = ""
     if read_files_:
@@ -325,6 +351,10 @@ Current working directory: {BASH_STATE.cwd}
 {repo_context}
 
 {initial_files_context}
+
+---
+
+{memory}
 """
 
     return output
@@ -396,6 +426,12 @@ def rstrip(lines: list[str]) -> str:
     return "\n".join([line.rstrip() for line in lines])
 
 
+def expand_user(path: str, docker_id: Optional[str]) -> str:
+    if not path or not path.startswith("~") or docker_id:
+        return path
+    return expanduser(path)
+
+
 def _incremental_text(text: str, last_pending_output: str) -> str:
     # text = render_terminal_output(text[-100_000:])
     text = text[-100_000:]
@@ -673,6 +709,9 @@ def truncate_if_over(content: str, max_tokens: Optional[int]) -> str:
 
 
 def read_image_from_shell(file_path: str) -> ImageData:
+    # Expand the path
+    file_path = expand_user(file_path, BASH_STATE.is_in_docker)
+
     if not os.path.isabs(file_path):
         file_path = os.path.join(BASH_STATE.cwd, file_path)
 
@@ -722,7 +761,7 @@ def write_file(
     if not os.path.isabs(writefile.file_path):
         return f"Failure: file_path should be absolute path, current working directory is {BASH_STATE.cwd}"
     else:
-        path_ = writefile.file_path
+        path_ = expand_user(writefile.file_path, BASH_STATE.is_in_docker)
 
     error_on_exist_ = error_on_exist and path_ not in BASH_STATE.whitelist_for_overwrite
     add_overwrite_warning = ""
@@ -828,126 +867,6 @@ Syntax errors:
     return "Success" + "".join(warnings)
 
 
-def find_least_edit_distance_substring(
-    orig_content_lines: list[str], find_lines: list[str]
-) -> tuple[list[str], str]:
-    # Prepare content lines, stripping whitespace and keeping track of original indices
-    content_lines = [line.strip() for line in orig_content_lines]
-    new_to_original_indices = {}
-    new_content_lines = []
-    for i, line in enumerate(content_lines):
-        if not line:
-            continue
-        new_content_lines.append(line)
-        new_to_original_indices[len(new_content_lines) - 1] = i
-    content_lines = new_content_lines
-
-    # Prepare find lines, removing empty lines
-    find_lines = [line.strip() for line in find_lines if line.strip()]
-
-    # Initialize variables for best match tracking
-    max_similarity = 0.0
-    min_edit_distance_lines = []
-    context_lines = []
-
-    # For each possible starting position in content
-    for i in range(max(1, len(content_lines) - len(find_lines) + 1)):
-        # Calculate similarity for the block starting at position i
-        block_similarity = 0.0
-        for j in range(len(find_lines)):
-            if (i + j) < len(content_lines):
-                # Use SequenceMatcher for more efficient similarity calculation
-                similarity = SequenceMatcher(
-                    None, content_lines[i + j], find_lines[j]
-                ).ratio()
-                block_similarity += similarity
-
-        # If this block is more similar than previous best
-        if block_similarity > max_similarity:
-            max_similarity = block_similarity
-            # Map back to original line indices
-            orig_start_index = new_to_original_indices[i]
-            orig_end_index = (
-                new_to_original_indices.get(
-                    i + len(find_lines) - 1, len(orig_content_lines) - 1
-                )
-                + 1
-            )
-            # Get the original lines
-            min_edit_distance_lines = orig_content_lines[
-                orig_start_index:orig_end_index
-            ]
-            # Get context (10 lines before and after)
-            context_lines = orig_content_lines[
-                max(0, orig_start_index - 10) : (orig_end_index + 10)
-            ]
-
-    return (
-        min_edit_distance_lines,
-        "\n".join(context_lines),
-    )
-
-
-def lines_replacer(
-    orig_content_lines: list[str], search_lines: list[str], replace_lines: list[str]
-) -> str:
-    # Validation for empty search
-    search_lines = list(filter(None, [x.strip() for x in search_lines]))
-
-    # Create mapping of non-empty lines to original indices
-    new_to_original_indices = []
-    new_content_lines = []
-    for i, line in enumerate(orig_content_lines):
-        stripped = line.strip()
-        if not stripped:
-            continue
-        new_content_lines.append(stripped)
-        new_to_original_indices.append(i)
-
-    if not new_content_lines and not search_lines:
-        return "\n".join(replace_lines)
-    elif not search_lines:
-        raise ValueError("Search block is empty")
-    elif not new_content_lines:
-        raise ValueError("File content is empty")
-
-    # Search for matching block
-    for i in range(len(new_content_lines) - len(search_lines) + 1):
-        if all(
-            new_content_lines[i + j] == search_lines[j]
-            for j in range(len(search_lines))
-        ):
-            start_idx = new_to_original_indices[i]
-            end_idx = new_to_original_indices[i + len(search_lines) - 1] + 1
-            return "\n".join(
-                orig_content_lines[:start_idx]
-                + replace_lines
-                + orig_content_lines[end_idx:]
-            )
-
-    raise ValueError("Search block not found in content")
-
-
-def edit_content(content: str, find_lines: str, replace_with_lines: str) -> str:
-    replace_with_lines_ = replace_with_lines.split("\n")
-    find_lines_ = find_lines.split("\n")
-    content_lines_ = content.split("\n")
-    try:
-        return lines_replacer(content_lines_, find_lines_, replace_with_lines_)
-    except ValueError:
-        pass
-
-    _, context_lines = find_least_edit_distance_substring(content_lines_, find_lines_)
-
-    raise Exception(
-        f"""Error: no match found for the provided search block.
-            Requested search block: \n```\n{find_lines}\n```
-            Possible relevant section in the file:\n---\n```\n{context_lines}\n```\n---\nFile not edited
-        \nPlease retry with exact search. Re-read the file if unsure.
-        """
-    )
-
-
 def do_diff_edit(fedit: FileEdit, max_tokens: Optional[int]) -> str:
     try:
         return _do_diff_edit(fedit, max_tokens)
@@ -974,7 +893,7 @@ def _do_diff_edit(fedit: FileEdit, max_tokens: Optional[int]) -> str:
             f"Failure: file_path should be absolute path, current working directory is {BASH_STATE.cwd}"
         )
     else:
-        path_ = fedit.file_path
+        path_ = expand_user(fedit.file_path, BASH_STATE.is_in_docker)
 
     # The LLM is now aware that the file exists
     BASH_STATE.add_to_whitelist_for_overwrite(path_)
@@ -1002,46 +921,7 @@ def _do_diff_edit(fedit: FileEdit, max_tokens: Optional[int]) -> str:
     )
     lines = fedit.file_edit_using_search_replace_blocks.split("\n")
 
-    if not lines or not re.match(r"^<<<<<<+\s*SEARCH\s*$", lines[0]):
-        raise Exception(
-            "Error: first line should be `<<<<<< SEARCH` to start a search-replace block"
-        )
-
-    n_lines = len(lines)
-    i = 0
-    replacement_count = 0
-    while i < n_lines:
-        if re.match(r"^<<<<<<+\s*SEARCH\s*$", lines[i]):
-            search_block = []
-            i += 1
-            while i < n_lines and not re.match(r"^======*\s*$", lines[i]):
-                search_block.append(lines[i])
-                i += 1
-            i += 1
-            replace_block = []
-            while i < n_lines and not re.match(r"^>>>>>>+\s*REPLACE\s*$", lines[i]):
-                replace_block.append(lines[i])
-                i += 1
-            i += 1
-
-            for line in search_block:
-                console.log("> " + line)
-            console.log("=======")
-            for line in replace_block:
-                console.log("< " + line)
-            console.log("\n\n\n\n")
-            search_block_ = "\n".join(search_block)
-            replace_block_ = "\n".join(replace_block)
-
-            apply_diff_to = edit_content(apply_diff_to, search_block_, replace_block_)
-            replacement_count += 1
-        else:
-            i += 1
-
-    if replacement_count == 0:
-        raise Exception(
-            "Error: no valid search-replace blocks found, please check your syntax for FileEdit"
-        )
+    apply_diff_to, comments = search_replace_edit(lines, apply_diff_to, console.log)
 
     if not BASH_STATE.is_in_docker:
         with open(path_, "w") as f:
@@ -1070,9 +950,9 @@ def _do_diff_edit(fedit: FileEdit, max_tokens: Optional[int]) -> str:
             )
 
             console.print(f"W: Syntax errors encountered: {syntax_errors}")
-            return f"""Wrote file succesfully.
+            return f"""{comments}
 ---
-However, tree-sitter reported syntax errors, please re-read the file and fix if there are any errors.
+Tree-sitter reported syntax errors, please re-read the file and fix if there are any errors.
 Syntax errors:
 {syntax_errors}
 
@@ -1081,7 +961,7 @@ Syntax errors:
     except Exception:
         pass
 
-    return "Success"
+    return comments
 
 
 class DoneFlag(BaseModel):
@@ -1123,6 +1003,7 @@ TOOLS = (
     | Keyboard
     | ScreenShot
     | GetScreenInfo
+    | KnowledgeTransfer
 )
 
 
@@ -1164,6 +1045,8 @@ def which_tool_name(name: str) -> Type[TOOLS]:
         return ScreenShot
     elif name == "GetScreenInfo":
         return GetScreenInfo
+    elif name == "KnowledgeTransfer":
+        return KnowledgeTransfer
     else:
         raise ValueError(f"Unknown tool name: {name}")
 
@@ -1216,7 +1099,12 @@ def get_tool_output(
     elif isinstance(arg, Initialize):
         console.print("Calling initial info tool")
         output = (
-            initialize(arg.any_workspace_path, arg.initial_files_to_read, max_tokens),
+            initialize(
+                arg.any_workspace_path,
+                arg.initial_files_to_read,
+                arg.task_id_to_resume,
+                max_tokens,
+            ),
             0.0,
         )
     elif isinstance(arg, (Mouse, Keyboard, ScreenShot, GetScreenInfo)):
@@ -1254,6 +1142,20 @@ def get_tool_output(
                     )
                 BASH_STATE.set_in_docker(arg.docker_image_id)
         return outputs, outputs_cost[1]
+    elif isinstance(arg, KnowledgeTransfer):
+        console.print("Calling task memory tool")
+        relevant_files = arg.relevant_file_paths
+        for i, fpath in enumerate(relevant_files):
+            if not os.path.isabs(fpath):
+                relpath = os.path.join(arg.project_root_path, fpath)
+                if os.path.exists(relpath):
+                    relevant_files[i] = relpath
+                else:
+                    raise Exception(f"The file path {fpath} does not exist")
+            elif not os.path.exists(fpath):
+                raise Exception(f"The file path {fpath} does not exist")
+        relevant_files_data = read_files(relevant_files, None)
+        output = save_memory(arg, relevant_files_data), 0.0
     else:
         raise ValueError(f"Unknown tool: {arg}")
     if isinstance(output[0], str):
@@ -1282,6 +1184,7 @@ class Mdata(BaseModel):
         | str
         | ReadFiles
         | Initialize
+        | KnowledgeTransfer
     )
 
 
@@ -1381,6 +1284,9 @@ def read_files(file_paths: list[str], max_tokens: Optional[int]) -> str:
 def read_file(file_path: str, max_tokens: Optional[int]) -> tuple[str, bool, int]:
     console.print(f"Reading file: {file_path}")
 
+    # Expand the path before checking if it's absolute
+    file_path = expand_user(file_path, BASH_STATE.is_in_docker)
+
     if not os.path.isabs(file_path):
         raise ValueError(
             f"Failure: file_path should be absolute path, current working directory is {BASH_STATE.cwd}"