cade-cli 0.7.0__tar.gz → 0.8.0__tar.gz

{cade_cli-0.7.0 → cade_cli-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cade-cli
-Version: 0.7.0
+Version: 0.8.0
 Summary: Cade - The CLI Agent from Arcade.dev
 Project-URL: Homepage, https://arcade.dev
 Project-URL: Documentation, https://docs.arcade.dev
@@ -43,6 +43,7 @@ Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
+Requires-Dist: agent-library<1.0.0,>=0.11.0
 Requires-Dist: anthropic<1.0.0,>=0.34.0
 Requires-Dist: arcade-core<5.0.0,>=4.1.0
 Requires-Dist: arcade-mcp-server>=1.0.0
@@ -72,6 +73,12 @@ Requires-Dist: accelerate>=0.27.0; extra == 'training'
 Requires-Dist: safetensors>=0.4.2; extra == 'training'
 Requires-Dist: torch>=2.1.0; extra == 'training'
 Requires-Dist: transformers>=4.38.0; extra == 'training'
+Provides-Extra: voice
+Requires-Dist: mlx-audio<0.4.0,>=0.2.0; extra == 'voice'
+Requires-Dist: mlx-whisper>=0.1.0; extra == 'voice'
+Requires-Dist: numpy>=1.24.0; extra == 'voice'
+Requires-Dist: sounddevice>=0.4.0; extra == 'voice'
+Requires-Dist: webrtcvad>=2.0.10; extra == 'voice'
 Description-Content-Type: text/markdown
 
 # Cade

{cade_cli-0.7.0 → cade_cli-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cade-cli"
-version = "0.7.0"
+version = "0.8.0"
 description = "Cade - The CLI Agent from Arcade.dev"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -40,6 +40,7 @@ dependencies = [
     "tiktoken>=0.11.0,<1.0.0",
     "httpx>=0.27.0,<1.0.0",
     "filelock>=3.0.0,<4.0.0",
+    "agent-library>=0.11.0,<1.0.0",
 ]
 
 [project.urls]
@@ -62,6 +63,13 @@ dev = [
     "pytest-cov>=4.0.0,<5.0.0",
     "mypy>=1.10.0,<2.0.0",
 ]
+voice = [
+    "mlx-audio>=0.2.0,<0.4.0",
+    "mlx-whisper>=0.1.0",
+    "sounddevice>=0.4.0",
+    "numpy>=1.24.0",
+    "webrtcvad>=2.0.10",
+]
 training = [
     "torch>=2.1.0",
     "transformers>=4.38.0",

{cade_cli-0.7.0 → cade_cli-0.8.0}/src/cade_mcp_local/__init__.py

@@ -69,4 +69,4 @@ __all__ = [
     "FileOperationError",
 ]
 
-__version__ = "0.7.0"
+__version__ = "0.8.0"

{cade_cli-0.7.0 → cade_cli-0.8.0}/src/cade_mcp_local/tools/__init__.py

@@ -6,10 +6,9 @@ commands on the same machine as the running cade process.
 """
 
 from cade_mcp_local.tools.context import search_recent_context_tool
-from cade_mcp_local.tools.tool_results import retrieve_tool_result_tool
-from cade_mcp_local.tools.tool_schemas import tool_schema_tool
 from cade_mcp_local.tools.filesystem import (
     edit_tool,
+    insert_text_tool,
     list_files_tool,
     read_file_tool,
     write_file_tool,
@@ -21,6 +20,8 @@ from cade_mcp_local.tools.git import (
 )
 from cade_mcp_local.tools.search import search_tool
 from cade_mcp_local.tools.shell import bash_tool
+from cade_mcp_local.tools.tool_results import retrieve_tool_result_tool
+from cade_mcp_local.tools.tool_schemas import tool_schema_tool
 
 __all__ = [
     # Filesystem
@@ -28,6 +29,7 @@ __all__ = [
     "read_file_tool",
     "write_file_tool",
     "edit_tool",
+    "insert_text_tool",
     # Git
     "git_tool",
     "get_current_branch_name",

{cade_cli-0.7.0 → cade_cli-0.8.0}/src/cade_mcp_local/tools/context.py

@@ -175,9 +175,9 @@ def search_recent_context_tool(
     ] = 5,
     case_sensitive: Annotated[bool, "Whether search should be case sensitive."] = False,
     role_filter: Annotated[
-        str | None,
-        "Filter matches by message role ('user', 'assistant', 'tool'). None searches all.",
-    ] = None,
+        str,
+        "Filter matches by message role: 'user', 'assistant', or 'tool'.",
+    ] = "",
     max_results: Annotated[int, "Maximum number of matching messages to return."] = 20,
 ) -> Annotated[dict[str, Any], "Search results or backup listing."]:
     """Search or list compacted context backup files.

{cade_cli-0.7.0 → cade_cli-0.8.0}/src/cade_mcp_local/tools/filesystem.py

@@ -1,9 +1,9 @@
 """Filesystem tools for reading, writing, and editing files."""
 
+import collections
 import difflib
 import logging
 import pathlib
-from enum import Enum
 from typing import Annotated, Any, Literal
 
 from arcade_tdk import ToolContext, tool
@@ -35,9 +35,7 @@ def _read_text_file(file_path: pathlib.Path) -> str:
             continue
 
     # Fallback: read as binary and decode with replacement
-    log.warning(
-        f"Could not decode {file_path} with standard encodings, using replacement"
-    )
+    log.warning(f"Could not decode {file_path} with standard encodings, using replacement")
     return file_path.read_bytes().decode("utf-8", errors="replace")
 
 
@@ -45,12 +43,19 @@ def _write_text_file(file_path: pathlib.Path, content: str) -> None:
     """Write text content to a file, ensuring it's within project root."""
     project_root = get_project_root()
     resolved = file_path.resolve()
+    resolved_root = project_root.resolve()
 
     # Security check: must be within project root
+    # Use string prefix check as fallback for symlink/worktree edge cases
     try:
-        resolved.relative_to(project_root)
+        resolved.relative_to(resolved_root)
     except ValueError:
-        raise PathSecurityError(str(file_path), "outside project root")
+        # Fallback: compare resolved string paths
+        if not str(resolved).startswith(str(resolved_root) + "/"):
+            raise PathSecurityError(
+                str(file_path),
+                f"outside project root (resolved={resolved}, root={resolved_root})",
+            )
 
     # Create parent directories if needed
     resolved.parent.mkdir(parents=True, exist_ok=True)
@@ -75,6 +80,11 @@ def _generate_diff(
     return "\n".join(diff)
 
 
+# ===========================================================================
+# ListFiles
+# ===========================================================================
+
+
 @tool(
     name="ListFiles",
     desc="List files in a directory (recursively up to a depth limit). Local filesystem only.",
@@ -95,7 +105,7 @@ def list_files_tool(
     if not 0 <= depth <= MAX_LIST_DEPTH:
         raise InvalidInputError("depth", f"must be between 0 and {MAX_LIST_DEPTH}")
 
-    base_path = resolve_path(directory)
+    base_path = resolve_path(directory, confine_to_root=True)
     if not base_path.is_dir():
         raise PathNotFoundError(directory, f"Not a directory: {directory}")
 
@@ -111,12 +121,12 @@ def list_files_tool(
                 break
     else:
         # BFS traversal with depth tracking
-        queue: list[tuple[pathlib.Path, int]] = [
+        queue: collections.deque[tuple[pathlib.Path, int]] = collections.deque(
             (child, 0) for child in base_path.iterdir() if not should_ignore(child)
-        ]
+        )
 
         while queue and len(listed_paths) < MAX_LIST_RESULTS:
-            current, current_depth = queue.pop(0)
+            current, current_depth = queue.popleft()
 
             if current_depth > depth:
                 continue
@@ -137,16 +147,33 @@ def list_files_tool(
     return {"files": listed_paths, "message": message}
 
 
+# ===========================================================================
+# ReadFile
+# ===========================================================================
+
+
 @tool(
     name="ReadFile",
-    desc="Read the entire content of a text file. Local filesystem only.",
+    desc=(
+        "Read a text file, optionally a specific line range. "
+        "Use start_line/end_line to read portions of large files. "
+        "Lines are 1-indexed. Local filesystem only."
+    ),
 )
 def read_file_tool(
     context: ToolContext,
     file_path_arg: Annotated[str, "Path to the file to read (relative or absolute)."],
-) -> Annotated[dict[str, Any], "File content and message."]:
-    """Read content of a specified file."""
-    file_path = resolve_path(file_path_arg)
+    start_line: Annotated[
+        int,
+        "First line to return, 1-indexed. Omit to start from the beginning.",
+    ] = 0,
+    end_line: Annotated[
+        int,
+        "Last line to return, 1-indexed. Omit to read to end of file.",
+    ] = 0,
+) -> Annotated[dict[str, Any], "File content, line numbers, and message."]:
+    """Read content of a specified file, optionally a specific line range."""
+    file_path = resolve_path(file_path_arg, confine_to_root=True)
 
     if not file_path.is_file():
         raise PathNotFoundError(file_path_arg)
@@ -154,27 +181,71 @@ def read_file_tool(
     try:
         size = file_path.stat().st_size
 
+        # Line-range mode: read specific lines (0 = not specified)
+        if start_line > 0 or end_line > 0:
+            content = _read_text_file(file_path)
+            all_lines = content.splitlines(keepends=True)
+            total_lines = len(all_lines)
+
+            s = max(1, start_line) if start_line > 0 else 1
+            e = min(total_lines, end_line) if end_line > 0 else total_lines
+
+            if s > total_lines:
+                return {
+                    "content": "",
+                    "total_lines": total_lines,
+                    "message": f"start_line {s} exceeds file length ({total_lines} lines).",
+                }
+
+            selected = all_lines[s - 1 : e]
+            # Add line numbers for context
+            numbered = "".join(f"{i}: {line}" for i, line in enumerate(selected, start=s))
+            return {
+                "content": numbered,
+                "start_line": s,
+                "end_line": e,
+                "total_lines": total_lines,
+                "message": f"Lines {s}-{e} of {total_lines}.",
+            }
+
         if size > MAX_PREVIEW_BYTES:
             log.warning(f"File {file_path_arg} exceeds limit, truncating")
             with file_path.open("rb") as f:
-                start = f.read(MAX_PREVIEW_BYTES // 2).decode(
-                    "utf-8", errors="replace"
-                )
+                start = f.read(MAX_PREVIEW_BYTES // 2).decode("utf-8", errors="replace")
                 f.seek(max(0, size - MAX_PREVIEW_BYTES // 2))
                 end = f.read().decode("utf-8", errors="replace")
             content = f"{start}\n... (truncated, {size} bytes total) ...\n{end}"
-            return {"content": content, "message": "File truncated due to size."}
+            return {
+                "content": content,
+                "total_lines": None,
+                "message": (
+                    "File truncated due to size. Use start_line/end_line to read specific sections."
+                ),
+            }
 
         content = _read_text_file(file_path)
-        return {"content": content, "message": "File read successfully."}
+        total_lines = content.count("\n") + (1 if content and not content.endswith("\n") else 0)
+        return {
+            "content": content,
+            "total_lines": total_lines,
+            "message": "File read successfully.",
+        }
 
     except OSError as e:
         raise FileOperationError("read", file_path_arg, str(e))
 
 
+# ===========================================================================
+# WriteFile
+# ===========================================================================
+
+
 @tool(
     name="WriteFile",
-    desc="Write content to a file, creating/overwriting or appending. Local filesystem only.",
+    desc=(
+        "Create a new file or overwrite an existing file with the given content. "
+        "For partial edits use Edit; for appending use mode='append'."
+    ),
 )
 def write_file_tool(
     context: ToolContext,
@@ -182,7 +253,7 @@ def write_file_tool(
     content: Annotated[str, "The complete content to write into the file."],
     mode: Annotated[
         Literal["overwrite", "append"],
-        "How to write: 'overwrite' to replace, 'append' to add to end.",
+        "How to write: 'overwrite' replaces the file, 'append' adds to end.",
     ] = "overwrite",
 ) -> Annotated[dict[str, Any], "Result of the write operation."]:
     """Write content to a file."""
@@ -202,95 +273,63 @@ def write_file_tool(
         raise FileOperationError("write", file_path_arg, str(e))
 
 
-class EditMode(str, Enum):
-    """Edit operation mode."""
-
-    REPLACE = "replace"
-    INSERT = "insert"
-
-
-class InsertPosition(str, Enum):
-    """Where to insert relative to the target line."""
-
-    BEFORE = "before"
-    AFTER = "after"
+# ===========================================================================
+# Edit  (find-and-replace)
+# ===========================================================================
 
 
 @tool(
     name="Edit",
     desc=(
-        "Edit a file by replacing text or inserting at a line number. "
-        "mode='replace': find old_string and replace with new_string. "
-        "mode='insert': insert content at line_number (1-indexed, 0=end)."
+        "Find and replace text in a file. "
+        "Provide old_string (the exact text to find) and new_string (the replacement). "
+        "The old_string must match the file content exactly, including whitespace and indentation. "
+        "Use ReadFile first to see the exact content. "
+        "Returns a diff showing what changed."
     ),
 )
 def edit_tool(
     context: ToolContext,
     file_path_arg: Annotated[str, "Path to the file to edit."],
-    mode: Annotated[EditMode, "Edit mode: replace or insert."] = EditMode.REPLACE,
-    # replace mode params
     old_string: Annotated[
         str,
-        "Exact text to find and replace (mode=replace). Must match including whitespace.",
-    ] = "",
-    new_string: Annotated[str, "Replacement text (mode=replace)."] = "",
-    expected_count: Annotated[
-        int | None,
-        "Expected replacement count; fails if mismatch (mode=replace).",
-    ] = None,
-    # insert mode params
-    line_number: Annotated[
-        int, "Line to insert at, 1-indexed. 0 = end of file (mode=insert)."
-    ] = 0,
-    content: Annotated[str, "Text to insert (mode=insert)."] = "",
-    position: Annotated[
-        InsertPosition, "Insert before or after the line (mode=insert)."
-    ] = InsertPosition.BEFORE,
+        "The exact text to find in the file. Must match verbatim including whitespace.",
+    ],
+    new_string: Annotated[
+        str,
+        "The replacement text. Use an empty string to delete the matched text.",
+    ],
 ) -> Annotated[dict[str, Any], "Edit result with diff."]:
-    """Edit a file by replacing text or inserting at a line number."""
+    """Find old_string in the file and replace it with new_string."""
     resolved = resolve_path(file_path_arg)
 
     if not resolved.is_file():
         raise PathNotFoundError(file_path_arg)
 
-    if mode == EditMode.REPLACE:
-        return _edit_replace(resolved, file_path_arg, old_string, new_string, expected_count)
-    elif mode == EditMode.INSERT:
-        return _edit_insert(resolved, file_path_arg, line_number, content, position)
-    else:
-        raise InvalidInputError("mode", f"Unknown mode: {mode}")
-
-
-def _edit_replace(
-    resolved: pathlib.Path,
-    file_path_arg: str,
-    old_string: str,
-    new_string: str,
-    expected_count: int | None,
-) -> dict[str, Any]:
-    """Find-and-replace edit mode."""
     try:
         original = _read_text_file(resolved)
     except Exception as e:
         raise FileOperationError("read", file_path_arg, str(e))
 
+    if not old_string:
+        raise InvalidInputError("old_string", "cannot be empty — provide the text to replace")
+
     count = original.count(old_string)
 
     if count == 0:
-        preview = old_string[:100] + ("..." if len(old_string) > 100 else "")
+        # Provide helpful debugging info
+        preview = old_string[:120] + ("..." if len(old_string) > 120 else "")
+        lines = original.splitlines()
         return {
             "success": False,
             "error": "old_string not found in file",
             "old_string_preview": preview,
-            "file_size": len(original),
-            "suggestion": "Check whitespace, indentation, and exact character match",
-        }
-
-    if expected_count is not None and count != expected_count:
-        return {
-            "success": False,
-            "error": f"Expected {expected_count} occurrences but found {count}",
-            "actual_count": count,
+            "file_lines": len(lines),
+            "file_chars": len(original),
+            "suggestion": (
+                "The text must match exactly including whitespace and indentation. "
+                "Use ReadFile to see the current content, then copy the exact text."
+            ),
         }
 
     new_content = original.replace(old_string, new_string)
@@ -303,25 +342,52 @@ def _edit_replace(
 
     return {
         "success": True,
-        "message": f"Successfully edited {file_path_arg}",
+        "message": f"Replaced {count} occurrence(s) in {file_path_arg}",
         "replacements": count,
         "diff": diff or "(no visible diff)",
     }
 
 
-def _edit_insert(
-    resolved: pathlib.Path,
-    file_path_arg: str,
-    line_number: int,
-    content: str,
-    position: InsertPosition,
-) -> dict[str, Any]:
-    """Line-insert edit mode."""
+# ===========================================================================
+# InsertText  (line-based insertion)
+# ===========================================================================
+
+
+@tool(
+    name="InsertText",
+    desc=(
+        "Insert text at a specific line number in a file. "
+        "Use ReadFile first to find the right line number. "
+        "Lines are 1-indexed. Set line_number=0 to append at end of file."
+    ),
+)
+def insert_text_tool(
+    context: ToolContext,
+    file_path_arg: Annotated[str, "Path to the file to edit."],
+    line_number: Annotated[
+        int,
+        "Line number to insert at (1-indexed). 0 appends at end of file.",
+    ],
+    content: Annotated[str, "The text to insert."],
+    position: Annotated[
+        Literal["before", "after"],
+        "Insert before or after the specified line.",
+    ] = "before",
+) -> Annotated[dict[str, Any], "Insert result with diff."]:
+    """Insert text at a specific line in a file."""
+    resolved = resolve_path(file_path_arg)
+
+    if not resolved.is_file():
+        raise PathNotFoundError(file_path_arg)
+
     try:
         original = _read_text_file(resolved)
     except Exception as e:
         raise FileOperationError("read", file_path_arg, str(e))
 
+    if not content:
+        raise InvalidInputError("content", "cannot be empty — provide the text to insert")
+
     lines = original.splitlines(keepends=True)
 
     # Ensure content ends with newline
@@ -339,7 +405,7 @@ def _edit_insert(
         )
     else:
         idx = line_number - 1
-        if position == InsertPosition.BEFORE:
+        if position == "before":
             lines.insert(idx, insert_content)
         else:
             lines.insert(idx + 1, insert_content)
@@ -354,6 +420,6 @@ def _edit_insert(
 
     return {
         "success": True,
-        "message": f"Successfully inserted content at line {line_number}",
+        "message": f"Inserted content at line {line_number} in {file_path_arg}",
         "diff": diff,
     }

{cade_cli-0.7.0 → cade_cli-0.8.0}/src/cade_mcp_local/tools/git.py

@@ -108,40 +108,28 @@ def get_status() -> tuple[str, str | None]:
 )
 def git_tool(
     context: ToolContext,
-    action: Annotated[
-        GitAction, "Git operation: status, diff, log, or branch."
-    ] = GitAction.STATUS,
+    action: Annotated[GitAction, "Git operation: status, diff, log, or branch."] = GitAction.STATUS,
     # status params
     short: Annotated[bool, "Use short format (status)."] = True,
     # diff params
-    path: Annotated[str | None, "File/directory path (diff, log)."] = None,
+    path: Annotated[str, "File or directory path to scope the operation (diff, log)."] = "",
     staged: Annotated[bool, "Show staged changes, --cached (diff)."] = False,
-    commit: Annotated[
-        str | None, "Compare with commit, e.g. 'HEAD~1', 'main' (diff)."
-    ] = None,
+    commit: Annotated[str, "Compare with a commit ref, e.g. 'HEAD~1', 'main' (diff)."] = "",
     stat: Annotated[bool, "Show diffstat instead of full diff (diff)."] = False,
-    name_only: Annotated[
-        bool, "Show only changed file names (diff)."
-    ] = False,
+    name_only: Annotated[bool, "Show only changed file names (diff)."] = False,
     # log params
     count: Annotated[int, "Number of commits to show (log)."] = 10,
     oneline: Annotated[bool, "One line per commit (log)."] = True,
-    author: Annotated[str | None, "Filter by author (log)."] = None,
-    since: Annotated[
-        str | None, "Commits since date, e.g. '2 weeks ago' (log)."
-    ] = None,
-    until: Annotated[str | None, "Commits until date (log)."] = None,
-    grep: Annotated[str | None, "Search commit messages (log)."] = None,
+    author: Annotated[str, "Filter by author name or email (log)."] = "",
+    since: Annotated[str, "Commits since date, e.g. '2 weeks ago' (log)."] = "",
+    until: Annotated[str, "Commits until date (log)."] = "",
+    grep: Annotated[str, "Search commit messages for this text (log)."] = "",
     # branch params
     branch_action: Annotated[
         BranchAction, "Branch sub-operation (when action=branch)."
     ] = BranchAction.LIST,
-    name: Annotated[
-        str | None, "Branch name (for create/delete/switch)."
-    ] = None,
-    all_branches: Annotated[
-        bool, "Include remote branches (branch list)."
-    ] = False,
+    name: Annotated[str, "Branch name (required for create/delete/switch)."] = "",
+    all_branches: Annotated[bool, "Include remote branches (branch list)."] = False,
     force: Annotated[bool, "Force action (branch delete)."] = False,
 ) -> Annotated[dict[str, Any], "Git operation result."]:
     """Perform git operations on the local repository."""
@@ -149,18 +137,28 @@ def git_tool(
         return _git_status(short=short)
     elif action == GitAction.DIFF:
         return _git_diff(
-            path=path, staged=staged, commit=commit,
-            stat=stat, name_only=name_only,
+            path=path,
+            staged=staged,
+            commit=commit,
+            stat=stat,
+            name_only=name_only,
         )
     elif action == GitAction.LOG:
         return _git_log(
-            count=count, oneline=oneline, path=path,
-            author=author, since=since, until=until, grep=grep,
+            count=count,
+            oneline=oneline,
+            path=path,
+            author=author,
+            since=since,
+            until=until,
+            grep=grep,
         )
     elif action == GitAction.BRANCH:
         return _git_branch(
-            branch_action=branch_action, name=name,
-            all_branches=all_branches, force=force,
+            branch_action=branch_action,
+            name=name,
+            all_branches=all_branches,
+            force=force,
         )
     else:
         raise InvalidInputError("action", f"Unknown action: {action}")
@@ -199,9 +197,9 @@ def _git_status(*, short: bool) -> dict[str, Any]:
 
 def _git_diff(
     *,
-    path: str | None,
+    path: str,
     staged: bool,
-    commit: str | None,
+    commit: str,
     stat: bool,
     name_only: bool,
 ) -> dict[str, Any]:
@@ -237,12 +235,13 @@ def _git_log(
     *,
     count: int,
     oneline: bool,
-    path: str | None,
-    author: str | None,
-    since: str | None,
-    until: str | None,
-    grep: str | None,
+    path: str,
+    author: str,
+    since: str,
+    until: str,
+    grep: str,
 ) -> dict[str, Any]:
+    count = max(1, count)
     args = ["log", f"-{count}"]
 
     if oneline:
@@ -280,7 +279,7 @@ def _git_log(
                 }
             )
         else:
-            parts = line.split("|")
+            parts = line.split("|", 4)
             if len(parts) >= 5:
                 commits.append(
                     {
@@ -298,7 +297,7 @@ def _git_log(
 def _git_branch(
     *,
     branch_action: BranchAction,
-    name: str | None,
+    name: str,
     all_branches: bool,
     force: bool,
 ) -> dict[str, Any]: