cade-cli 0.13.2__tar.gz → 0.13.4__tar.gz

{cade_cli-0.13.2 → cade_cli-0.13.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cade-cli
-Version: 0.13.2
+Version: 0.13.4
 Summary: Cade - The CLI Agent from Arcade.dev
 Project-URL: Homepage, https://arcade.dev
 Project-URL: Documentation, https://docs.arcade.dev

{cade_cli-0.13.2 → cade_cli-0.13.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cade-cli"
-version = "0.13.2"
+version = "0.13.4"
 description = "Cade - The CLI Agent from Arcade.dev"
 readme = "README.md"
 requires-python = ">=3.11"

cade_cli-0.13.4/src/cade_mcp_local/config.py

@@ -0,0 +1,116 @@
+"""Runtime configuration for the local MCP server.
+
+Configuration is resolved lazily at runtime, not at import time.
+This allows proper testing and correct behavior when installed as a package.
+"""
+
+import os
+import pathlib
+from functools import lru_cache
+
+# Environment variable that disables filesystem path confinement. When set to a
+# truthy value, filesystem tools may read/write paths outside the project root.
+#
+# This is intentionally a single on/off switch for now. A future iteration may
+# replace it with a richer policy (e.g. an explicit list of additional allowed
+# roots); keep `path_restrictions_enabled()` as the single read point so callers
+# don't need to change when that happens.
+PATH_RESTRICTIONS_ENV: str = "CADE_DISABLE_PATH_RESTRICTIONS"
+
+_TRUTHY_VALUES: frozenset[str] = frozenset({"1", "true", "yes", "on"})
+
+
+def path_restrictions_enabled() -> bool:
+    """Return whether filesystem tools must stay within the project root.
+
+    Restrictions are ON by default. They are lifted only when the
+    ``CADE_DISABLE_PATH_RESTRICTIONS`` environment variable is set to a truthy
+    value (``1``, ``true``, ``yes``, or ``on``, case-insensitive).
+
+    Returns:
+        True when path confinement should be enforced, False when tools may
+        access any path on the filesystem.
+
+    Examples:
+        >>> import os
+        >>> os.environ.pop("CADE_DISABLE_PATH_RESTRICTIONS", None)
+        >>> path_restrictions_enabled()
+        True
+        >>> os.environ["CADE_DISABLE_PATH_RESTRICTIONS"] = "1"
+        >>> path_restrictions_enabled()
+        False
+    """
+    raw = os.environ.get(PATH_RESTRICTIONS_ENV, "").strip().lower()
+    return raw not in _TRUTHY_VALUES
+
+
+def disable_path_restrictions() -> None:
+    """Lift filesystem path confinement for this process and its children.
+
+    Sets ``CADE_DISABLE_PATH_RESTRICTIONS`` in the environment so that child
+    processes (notably the local-tools MCP subprocess, which inherits
+    ``os.environ``) and the serve sandbox hook all observe the override.
+
+    This is the single supported way to flip the toggle on from code, keeping
+    the environment-variable name encapsulated in this module.
+    """
+    os.environ[PATH_RESTRICTIONS_ENV] = "1"
+
+
+@lru_cache(maxsize=1)
+def get_project_root() -> pathlib.Path:
+    """Get the project root directory.
+
+    Resolution order:
+    1. CADE_PROJECT_ROOT environment variable (set by parent process)
+    2. Current working directory
+
+    This is cached for performance but can be reset with reset_config().
+
+    Returns:
+        Resolved path to the project root directory.
+    """
+    if root := os.environ.get("CADE_PROJECT_ROOT"):
+        return pathlib.Path(root).resolve()
+    return pathlib.Path.cwd().resolve()
+
+
+def reset_config() -> None:
+    """Clear cached configuration.
+
+    Call this when:
+    - The working directory has changed
+    - CADE_PROJECT_ROOT environment variable has changed
+    - During testing to ensure isolation
+    """
+    get_project_root.cache_clear()
+
+
+# Default ignore patterns for file listings and searches
+DEFAULT_IGNORE_PATTERNS: list[str] = [
+    ".git",
+    "__pycache__",
+    "node_modules",
+    ".venv",
+    "venv",
+    ".mypy_cache",
+    ".pytest_cache",
+    "*.pyc",
+    ".DS_Store",
+    "*.egg-info",
+    "dist",
+    "build",
+    ".tox",
+    ".coverage",
+    "htmlcov",
+    ".idea",
+    ".vscode",
+    ".cursor",
+    ".claude",
+]
+
+# File operation limits
+MAX_LIST_DEPTH: int = 10
+MAX_LIST_RESULTS: int = 1000
+MAX_PREVIEW_BYTES: int = 100_000
+DEFAULT_TIMEOUT: int = 60

{cade_cli-0.13.2 → cade_cli-0.13.4}/src/cade_mcp_local/tools/filesystem.py

@@ -19,6 +19,7 @@ from cade_mcp_local.config import (
     MAX_LIST_RESULTS,
     MAX_PREVIEW_BYTES,
     get_project_root,
+    path_restrictions_enabled,
 )
 from cade_mcp_local.errors import (
     FileOperationError,
@@ -47,22 +48,25 @@ def _read_text_file(file_path: pathlib.Path) -> str:
 
 
 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()
+    """Write text content to a file, ensuring it's within project root.
+
+    Confinement to the project root is skipped when path restrictions are
+    disabled (see `path_restrictions_enabled`).
+    """
     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(resolved_root)
-    except ValueError:
-        # 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})",
-            )
+    if path_restrictions_enabled():
+        resolved_root = get_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(resolved_root)
+        except ValueError:
+            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)

{cade_cli-0.13.2 → cade_cli-0.13.4}/src/cade_mcp_local/utils.py

@@ -3,7 +3,11 @@
 import fnmatch
 import pathlib
 
-from cade_mcp_local.config import DEFAULT_IGNORE_PATTERNS, get_project_root
+from cade_mcp_local.config import (
+    DEFAULT_IGNORE_PATTERNS,
+    get_project_root,
+    path_restrictions_enabled,
+)
 
 
 def resolve_path(
@@ -46,7 +50,7 @@ def resolve_path(
     else:
         resolved = (base_dir / path).resolve()
 
-    if confine_to_root:
+    if confine_to_root and path_restrictions_enabled():
         root = get_project_root().resolve()
         try:
             resolved.relative_to(root)

{cade_cli-0.13.2 → cade_cli-0.13.4}/src/cadecoder/cli/app.py

@@ -90,7 +90,12 @@ app.add_typer(
     help="Activation contexts (persona + model + MCP bundle)",
     rich_help_panel=PANEL_CONFIGURE,
 )
-app.add_typer(persona_app, name="persona", help="Persona library", rich_help_panel=PANEL_CONFIGURE)
+app.add_typer(
+    persona_app,
+    name="persona",
+    help="Personas (custom prompt + model)",
+    rich_help_panel=PANEL_CONFIGURE,
+)
 app.add_typer(model_app, name="model", help="AI models", rich_help_panel=PANEL_CONFIGURE)
 app.add_typer(mcp_app, name="mcp", help="MCP servers", rich_help_panel=PANEL_CONFIGURE)
 
@@ -261,6 +266,15 @@ def main_callback(
             help="Run under a named Cade activation context.",
         ),
     ] = None,
+    no_path_restrictions: Annotated[
+        bool,
+        typer.Option(
+            "--no-path-restrictions",
+            help="Let filesystem tools access any path (disables project-root confinement). "
+            "Use with caution.",
+            is_eager=True,
+        ),
+    ] = False,
     message: Annotated[
         str | None,
         typer.Option(
@@ -281,8 +295,21 @@ def main_callback(
     ] = None,
 ) -> None:
     """Resolve runtime, set up logging, and dispatch to chat/resume/-m when no subcommand is given."""
+    if no_path_restrictions:
+        from cade_mcp_local.config import disable_path_restrictions
+
+        disable_path_restrictions()
+
     runtime = build_runtime(context)
     if persona:
+        from cadecoder.storage.personas import persona_exists
+
+        if not persona_exists(persona):
+            console.print(
+                f"[red]Persona '{persona}' not found.[/red] "
+                "Run 'cade persona list' to see available personas."
+            )
+            raise typer.Exit(1)
         runtime = replace(runtime, persona_name=persona)
         runtime.ensure_dirs()
     set_runtime(runtime)

{cade_cli-0.13.2 → cade_cli-0.13.4}/src/cadecoder/cli/commands/chat.py

@@ -114,6 +114,14 @@ def chat(
             help="Use a saved persona (custom system prompt). See 'cade persona list'.",
         ),
     ] = None,
+    no_path_restrictions: Annotated[
+        bool,
+        typer.Option(
+            "--no-path-restrictions",
+            help="Let filesystem tools access any path (disables project-root confinement). "
+            "Use with caution.",
+        ),
+    ] = False,
 ) -> None:
     """
     Start an interactive chat session with AI.
@@ -123,6 +131,11 @@ def chat(
     """
     command_name = "chat"
     try:
+        if no_path_restrictions:
+            from cade_mcp_local.config import disable_path_restrictions
+
+            disable_path_restrictions()
+
         if endpoint:
             _configure_custom_endpoint(endpoint)
 
@@ -329,6 +342,14 @@ def resume(
             help="Use a saved persona (custom system prompt). See 'cade persona list'.",
         ),
     ] = None,
+    no_path_restrictions: Annotated[
+        bool,
+        typer.Option(
+            "--no-path-restrictions",
+            help="Let filesystem tools access any path (disables project-root confinement). "
+            "Use with caution.",
+        ),
+    ] = False,
 ) -> None:
     """Resume a saved chat thread.
 
@@ -343,6 +364,11 @@ def resume(
     """
     command_name = "resume"
     try:
+        if no_path_restrictions:
+            from cade_mcp_local.config import disable_path_restrictions
+
+            disable_path_restrictions()
+
         if endpoint:
             _configure_custom_endpoint(endpoint)
 

{cade_cli-0.13.2 → cade_cli-0.13.4}/src/cadecoder/cli/commands/context.py

@@ -85,7 +85,14 @@ def create_context(
     else:
         ctx = ContextConfig(name=context_name)
     if persona:
-        ctx.persona = validate_name(persona, kind="persona")
+        from cadecoder.storage.personas import persona_exists
+
+        persona_name = validate_name(persona, kind="persona")
+        if not persona_exists(persona_name):
+            console.print(f"[red]Persona '{persona_name}' not found.[/red]")
+            console.print("[dim]Use 'cade persona list' to see available personas.[/dim]")
+            raise typer.Exit(1)
+        ctx.persona = persona_name
     if model:
         ctx.model = model
     save_context_config(ctx)
@@ -163,8 +170,15 @@ def set_context_persona(
     persona: Annotated[str, typer.Argument(help="Persona name")],
     context: Annotated[str | None, typer.Option("--context", "-c")] = None,
 ) -> None:
+    from cadecoder.storage.personas import persona_exists
+
+    persona_name = validate_name(persona, kind="persona")
+    if not persona_exists(persona_name):
+        console.print(f"[red]Persona '{persona_name}' not found.[/red]")
+        console.print("[dim]Use 'cade persona list' to see available personas.[/dim]")
+        raise typer.Exit(1)
     ctx = load_context_config(context or _active_or_default())
-    ctx.persona = validate_name(persona, kind="persona")
+    ctx.persona = persona_name
     save_context_config(ctx)
     reset_runtime()
     console.print(f"[green]Context '{ctx.name}' persona set to '{ctx.persona}'.[/green]")

{cade_cli-0.13.2 → cade_cli-0.13.4}/src/cadecoder/cli/commands/cron.py

@@ -10,12 +10,16 @@ from rich.console import Console
 from rich.table import Table
 
 from cadecoder.tasks.scheduler import (
+    AmbiguousTaskError,
+    TaskNotFoundError,
     add_scheduled_task,
     load_scheduled_tasks,
     remove_scheduled_task,
+    resolve_scheduled_task,
     save_scheduled_tasks,
     set_scheduled_task_enabled,
 )
+from cadecoder.tasks.types import ScheduledTask
 
 cron_app = typer.Typer(
     name="cron",
@@ -33,6 +37,29 @@ def _cb(ctx: typer.Context) -> None:
         raise typer.Exit(0)
 
 
+def _resolve_or_exit(token: str) -> ScheduledTask:
+    """Resolve a token to one task, printing a helpful error and exiting otherwise.
+
+    Args:
+        token: The id, name, or id prefix supplied on the command line.
+
+    Returns:
+        The single matching `ScheduledTask`.
+    """
+    try:
+        return resolve_scheduled_task(token)
+    except TaskNotFoundError:
+        console.print(f"[yellow]No scheduled task matching {token!r}[/yellow]")
+        raise typer.Exit(1) from None
+    except AmbiguousTaskError as e:
+        console.print(
+            f"[yellow]{token!r} matches {len(e.matches)} tasks; be more specific:[/yellow]"
+        )
+        for t in e.matches:
+            console.print(f"  [cyan]{t.id}[/cyan]  {t.name}")
+        raise typer.Exit(1) from None
+
+
 @cron_app.command("list")
 def list_cron(
     json_out: Annotated[bool, typer.Option("--json", help="Emit JSON")] = False,
@@ -86,39 +113,32 @@ def add_cron(
 
 @cron_app.command("remove")
 def remove_cron(task_id: Annotated[str, typer.Argument()]) -> None:
-    if not remove_scheduled_task(task_id):
-        console.print(f"[yellow]No scheduled task with id {task_id}[/yellow]")
-        raise typer.Exit(1)
-    console.print(f"[green]Removed {task_id}[/green]")
+    target = _resolve_or_exit(task_id)
+    remove_scheduled_task(target.id)
+    console.print(f"[green]Removed {target.id} ({target.name})[/green]")
 
 
 @cron_app.command("enable")
 def enable_cron(task_id: Annotated[str, typer.Argument()]) -> None:
-    if not set_scheduled_task_enabled(task_id, True):
-        console.print(f"[yellow]No scheduled task with id {task_id}[/yellow]")
-        raise typer.Exit(1)
-    console.print(f"[green]Enabled {task_id}[/green]")
+    target = _resolve_or_exit(task_id)
+    set_scheduled_task_enabled(target.id, True)
+    console.print(f"[green]Enabled {target.id} ({target.name})[/green]")
 
 
 @cron_app.command("disable")
 def disable_cron(task_id: Annotated[str, typer.Argument()]) -> None:
-    if not set_scheduled_task_enabled(task_id, False):
-        console.print(f"[yellow]No scheduled task with id {task_id}[/yellow]")
-        raise typer.Exit(1)
-    console.print(f"[green]Disabled {task_id}[/green]")
+    target = _resolve_or_exit(task_id)
+    set_scheduled_task_enabled(target.id, False)
+    console.print(f"[green]Disabled {target.id} ({target.name})[/green]")
 
 
 @cron_app.command("run-now")
 def run_now(task_id: Annotated[str, typer.Argument()]) -> None:
     """Mark a scheduled task to fire at the next tick by clearing last_fired."""
+    target = _resolve_or_exit(task_id)
     tasks = load_scheduled_tasks()
-    changed = False
     for t in tasks:
-        if t.id == task_id:
+        if t.id == target.id:
             t.last_fired = None
-            changed = True
-    if not changed:
-        console.print(f"[yellow]No scheduled task with id {task_id}[/yellow]")
-        raise typer.Exit(1)
     save_scheduled_tasks(tasks)
-    console.print(f"[green]Queued {task_id} for next tick[/green]")
+    console.print(f"[green]Queued {target.id} ({target.name}) for next tick[/green]")

cade_cli-0.13.4/src/cadecoder/cli/commands/mem.py

@@ -0,0 +1,176 @@
+"""``cade mem`` — persona-scoped memory management backed by agent-library.
+
+The agent-library (``librarian``) ships a Typer CLI with commands for sources
+(``list``/``add``/``rm``), search, the MCP server, index management, and
+settings (``config``). Rather than re-implement that surface, ``cade mem``
+drives librarian's Typer app **in-process** with ``prog_name="cade mem"`` so the
+entire help tree renders as ``cade mem``/``cade mem search``/… — no
+``librarian`` or ``libr`` branding leaks through.
+
+Storage is scoped to the active context/persona by setting librarian's
+environment (``DATABASE_PATH`` / ``DOCUMENTS_PATH`` / ``SOURCES_CONFIG_PATH``)
+and ``HOME`` *before* librarian is imported. Librarian reads ``HOME`` for its
+``~/.librarian`` config dir and the env vars for its storage at import time, so
+the order matters: each ``cade mem`` invocation runs in its own process and
+binds to exactly one persona.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import typer
+from rich.console import Console
+
+from cadecoder.cli.commands.persona import _ensure_memory_dir
+from cadecoder.core.runtime import get_runtime
+
+console = Console(stderr=True)
+
+MEM_CONTEXT_SETTINGS = {
+    "allow_extra_args": True,
+    "ignore_unknown_options": True,
+    # Empty list so --help / -h flow through to librarian instead of being
+    # intercepted by Typer; `cade mem --help` renders the cade-branded help.
+    "help_option_names": [],
+}
+
+_MEM_HELP = "Manage Cade persona memory — sources, search, and indexing."
+
+
+def _resolve_active_persona(ctx: typer.Context) -> str:
+    """Return the active persona name.
+
+    Precedence: ``--persona`` flag on the root ``cade`` invocation (stored in
+    ``ctx.obj``) → the active context's persona → ``"default"``.
+
+    Args:
+        ctx: The Typer/Click context for the ``mem`` invocation.
+
+    Returns:
+        The resolved persona name.
+    """
+    cursor: typer.Context | None = ctx
+    while cursor is not None:
+        obj = cursor.obj
+        if isinstance(obj, dict):
+            name = obj.get("persona")
+            if isinstance(name, str) and name.strip():
+                return name
+        cursor = cursor.parent
+
+    try:
+        name = get_runtime().persona_name
+    except Exception:
+        name = None
+    return name or "default"
+
+
+def _apply_persona_env(persona_name: str) -> Path:
+    """Pin librarian's storage to a persona by setting process environment.
+
+    Librarian has two code paths that locate its storage and they disagree:
+    ``librarian.config`` reads ``DATABASE_PATH`` / ``DOCUMENTS_PATH`` /
+    ``SOURCES_CONFIG_PATH``, but the CLI derives ``~/.librarian`` from ``HOME``.
+    Setting both — with ``HOME`` pointed at the persona directory — makes them
+    converge on ``<persona>/.librarian/*``. This MUST run before librarian is
+    imported.
+
+    Args:
+        persona_name: The persona whose memory directory to bind to.
+
+    Returns:
+        The ``.librarian`` directory for the persona.
+    """
+    import os
+
+    persona_dir = _ensure_memory_dir(persona_name)
+    librarian_dir = persona_dir / ".librarian"
+    os.environ["DATABASE_PATH"] = str(librarian_dir / "index.db")
+    os.environ["DOCUMENTS_PATH"] = str(librarian_dir / "documents")
+    os.environ["SOURCES_CONFIG_PATH"] = str(librarian_dir / "sources.json")
+    os.environ["HOME"] = str(persona_dir)
+    return librarian_dir
+
+
+def _load_librarian_app() -> Any:
+    """Import and return librarian's Typer app.
+
+    Imported lazily so the persona environment (see :func:`_apply_persona_env`)
+    is in place first, and so a missing agent-library install fails loudly only
+    when ``cade mem`` is actually used.
+
+    Returns:
+        The librarian Typer application instance.
+    """
+    from librarian.cli import app
+
+    return app
+
+
+def _run_mem(args: list[str]) -> int:
+    """Run librarian's CLI in-process, branded as ``cade mem``.
+
+    Args:
+        args: Arguments to forward to the librarian CLI (e.g. ``["search", "x"]``).
+
+    Returns:
+        The process exit code.
+    """
+    try:
+        librarian_app = _load_librarian_app()
+    except ImportError:
+        console.print(
+            "[red]agent-library is not installed.[/red] Install it into the "
+            "active environment: [bold]uv pip install agent-library[/bold]."
+        )
+        return 1
+
+    # Rebrand the app so every help screen reads "cade mem" rather than "libr".
+    librarian_app.info.name = "cade mem"
+    librarian_app.info.help = _MEM_HELP
+
+    try:
+        librarian_app(args=args, prog_name="cade mem")
+    except SystemExit as exc:
+        code = exc.code
+        if code is None:
+            return 0
+        return code if isinstance(code, int) else 1
+    return 0
+
+
+def mem_command(ctx: typer.Context) -> None:
+    """Run a ``cade mem`` subcommand scoped to the active persona.
+
+    Examples:
+        cade mem                   # show the cade mem help
+        cade mem list              # list sources for the active persona
+        cade mem add ./docs        # add a source under the active persona
+        cade mem search "topic"    # search the active persona's memory
+        cade mem config show       # show memory configuration
+        cade --persona anna mem list   # scope to a different persona
+    """
+    persona = _resolve_active_persona(ctx)
+    memory_home = _apply_persona_env(persona).parent
+    forwarded = list(ctx.args)
+    # Surface the active scope on help / no-args runs — opaque env vars are
+    # easy to get wrong and this keeps the bridge visible.
+    if not forwarded or forwarded[0] in {"--help", "-h"}:
+        console.print(
+            f"[dim]cade mem: scoped to persona [bold]{persona}[/bold] "
+            f"(storage={memory_home})[/dim]\n"
+        )
+    rc = _run_mem(forwarded)
+    raise typer.Exit(rc)
+
+
+__all__ = (
+    "MEM_CONTEXT_SETTINGS",
+    "_apply_persona_env",
+    "_load_librarian_app",
+    "_resolve_active_persona",
+    "_run_mem",
+    "mem_command",
+)