wizelit-cli 0.1.17__py3-none-any.whl

wizelit_cli/__init__.py

@@ -0,0 +1,35 @@
+"""Interactive terminal CLI for the Wizelit deep agent (agent_cli-style)."""
+
+__version__ = "0.1.17"
+
+from wizelit_cli.agent_cli import main
+from wizelit_cli.profile_sync import load_profile_layers, sync_cli_profile_to_disk
+from wizelit_cli.profile_store import profile_path
+from wizelit_cli.runner import run_interactive, run_once
+from wizelit_cli.session import build_cli_agent
+from wizelit_cli.settings_loader import resolve_cli_llm_config
+from wizelit_cli.mcp_settings_loader import resolve_cli_mcp_servers
+from wizelit_cli.settings_types import LlmRunConfig
+from wizelit_cli.util import (
+    backend_install_root,
+    repo_thread_id,
+    resolve_cli_skills_dir,
+    resolve_cli_subagents_dir,
+)
+
+__all__ = [
+    "LlmRunConfig",
+    "backend_install_root",
+    "build_cli_agent",
+    "load_profile_layers",
+    "main",
+    "profile_path",
+    "repo_thread_id",
+    "resolve_cli_llm_config",
+    "resolve_cli_mcp_servers",
+    "resolve_cli_skills_dir",
+    "resolve_cli_subagents_dir",
+    "run_interactive",
+    "run_once",
+    "sync_cli_profile_to_disk",
+]

wizelit_cli/agent_cli.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+"""Interactive terminal agent for Wizelit v2.
+
+Examples:
+  cd packages/backend
+  uv run python scripts/agent_cli.py -i
+  uv run python scripts/agent_cli.py --repo /path/to/project -i
+  uv run python scripts/agent_cli.py "Summarize this repo"
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import logging
+import os
+import signal
+import sys
+import uuid
+from contextlib import AsyncExitStack
+from pathlib import Path
+
+from wizelit_cli.config_paths import load_cli_env
+
+load_cli_env()
+
+from wizelit_cli.checkpoint import close_checkpointer, open_checkpointer  # noqa: E402
+from wizelit_cli.runner import run_interactive, run_once  # noqa: E402
+from wizelit_cli.session import build_cli_agent, cli_user_id  # noqa: E402
+from wizelit_cli.profile_sync import load_profile_layers, sync_cli_profile_to_disk
+from wizelit_cli.settings_loader import resolve_cli_llm_config  # noqa: E402
+from wizelit_cli.shutdown import (  # noqa: E402
+    run_cli_loop,
+    shutdown_cli_session_bounded,
+)
+from wizelit_cli.mcp_loader import disconnect_mcp_servers  # noqa: E402
+from wizelit_core.mcp_manager import mcp_manager  # noqa: E402
+from wizelit_cli.terminal_ui import stop_all_spinners  # noqa: E402
+from wizelit_cli.util import repo_thread_id  # noqa: E402
+from wizelit_core.llm_catalog import get_provider_models  # noqa: E402
+
+
+def _format_version() -> str:
+    import importlib.metadata
+
+    def _pkg_version(name: str) -> str:
+        try:
+            return importlib.metadata.version(name)
+        except importlib.metadata.PackageNotFoundError:
+            return "unknown"
+
+    cli_ver = _pkg_version("wizelit-cli")
+    core_ver = _pkg_version("wizelit-core")
+    return f"wizelit-agent {cli_ver} (wizelit-core {core_ver})"
+
+
+def _configure_logging() -> None:
+    if logging.getLogger().handlers:
+        return
+    level = getattr(logging, os.getenv("LOG_LEVEL", "WARNING").upper(), logging.WARNING)
+    logging.basicConfig(level=level, format="%(levelname)s %(name)s: %(message)s")
+
+
+def _checkpoint_path(repo_path: Path) -> Path:
+    state_dir = repo_path / ".agent"
+    state_dir.mkdir(parents=True, exist_ok=True)
+    return state_dir / "cli_checkpoints.sqlite"
+
+
+def main(argv: list[str] | None = None) -> None:
+    _configure_logging()
+
+    parser = argparse.ArgumentParser(
+        description="Run the Wizelit deep agent in the terminal against a target repo.",
+    )
+    parser.add_argument(
+        "-V",
+        "--version",
+        action="version",
+        version=_format_version(),
+    )
+    parser.add_argument("prompt", nargs="*", help="Text to send to the agent.")
+    parser.add_argument(
+        "-i",
+        "--interactive",
+        action="store_true",
+        help="Interactive REPL (default when stdin is a TTY and no prompt given).",
+    )
+    parser.add_argument(
+        "--repo",
+        default=os.getcwd(),
+        help="Target repo path the agent operates on (default: CWD).",
+    )
+    parser.add_argument(
+        "--new-thread",
+        action="store_true",
+        help="Force a fresh conversation thread for this repo.",
+    )
+    parser.add_argument(
+        "--provider",
+        choices=list(get_provider_models().keys()),
+        help="LLM provider (bedrock, anthropic, google, openai).",
+    )
+    parser.add_argument("--model", help="Model id for the selected provider.")
+    parser.add_argument(
+        "--skills-dir",
+        help="Directory of skill modules (overrides bundled skills and WIZELIT_SKILLS_DIR).",
+    )
+    parser.add_argument(
+        "--subagents-dir",
+        help="Directory of subagent .md specs (overrides bundled subagents and WIZELIT_SUBAGENTS_DIR).",
+    )
+    parser.add_argument(
+        "--sync-profile",
+        action="store_true",
+        help="Fetch LLM + MCP settings from the backend and write ~/.wizelit/profile.json, then exit.",
+    )
+    args = parser.parse_args(argv)
+
+    if args.skills_dir:
+        os.environ["WIZELIT_SKILLS_DIR"] = str(Path(args.skills_dir).expanduser().resolve())
+    if args.subagents_dir:
+        os.environ["WIZELIT_SUBAGENTS_DIR"] = str(Path(args.subagents_dir).expanduser().resolve())
+
+    if args.sync_profile:
+        async def _sync_only() -> None:
+            path = await sync_cli_profile_to_disk()
+            print(f"Synced CLI profile to {path}")
+
+        try:
+            asyncio.run(_sync_only())
+        except Exception as exc:  # noqa: BLE001
+            print(f"error: profile sync failed: {exc}", file=sys.stderr)
+            sys.exit(1)
+        sys.exit(0)
+
+    repo_path = Path(args.repo).resolve()
+    if not repo_path.is_dir():
+        print(f"error: --repo {repo_path} is not a directory", file=sys.stderr)
+        sys.exit(2)
+
+    interactive = args.interactive or (not args.prompt and sys.stdin.isatty())
+    interactive_tty = interactive and sys.stdin.isatty()
+
+    thread_id = repo_thread_id(repo_path)
+    if args.new_thread:
+        thread_id = f"{thread_id}-{uuid.uuid4().hex[:8]}"
+    checkpoint_db = _checkpoint_path(repo_path)
+    clean_exit = False
+
+    async def run_cli() -> None:
+        nonlocal clean_exit
+        conn, checkpointer = await open_checkpointer(checkpoint_db)
+        active_user_id: str | None = None
+        exit_process = False
+        prefer_local_profile = False
+        stale_cancel_retries = 0
+        run_exit_code = 0
+        try:
+            while True:
+                try:
+                    profile_layers = await load_profile_layers(
+                        prefer_local=prefer_local_profile
+                    )
+                    prefer_local_profile = False
+                    try:
+                        llm_config = await resolve_cli_llm_config(
+                            provider_flag=args.provider,
+                            model_flag=args.model,
+                            interactive=interactive,
+                            interactive_tty=interactive_tty,
+                            profile_layers=profile_layers,
+                        )
+                    except ValueError as exc:
+                        print(f"error: {exc}", file=sys.stderr)
+                        sys.exit(2)
+
+                    print(
+                        f"Using provider={llm_config.provider}, model={llm_config.model_id} "
+                        f"(source={llm_config.settings_source})\n"
+                    )
+
+                    config = {
+                        "configurable": {"thread_id": thread_id},
+                        "recursion_limit": llm_config.recursion_limit,
+                    }
+                    user_id = llm_config.user_identifier or cli_user_id()
+                    active_user_id = user_id
+
+                    async with AsyncExitStack() as stack:
+                        agent = await asyncio.shield(
+                            build_cli_agent(
+                                repo_path=repo_path,
+                                checkpointer=checkpointer,
+                                stack=stack,
+                                llm_config=llm_config,
+                                thread_id=thread_id,
+                                profile_layers=profile_layers,
+                            )
+                        )
+
+                        if interactive or not args.prompt:
+                            result = await run_interactive(agent, config)
+                            if result == "RELOAD":
+                                print("Reloading agent and MCP...", flush=True)
+                                try:
+                                    await disconnect_mcp_servers(user_id)
+                                except asyncio.CancelledError:
+                                    mcp_manager.drop_user(user_id)
+                                await asyncio.sleep(0.75)
+                                prefer_local_profile = True
+                                stale_cancel_retries = 0
+                                continue
+                        else:
+                            await run_once(agent, config, " ".join(args.prompt))
+                    stale_cancel_retries = 0
+                    exit_process = True
+                    break
+                except asyncio.CancelledError:
+                    # MCP stream teardown can cancel the next loop iteration briefly.
+                    if stale_cancel_retries < 12:
+                        stale_cancel_retries += 1
+                        prefer_local_profile = True
+                        await asyncio.sleep(0.15)
+                        continue
+                    exit_process = True
+                    raise
+                except BaseException:
+                    exit_process = True
+                    run_exit_code = 1
+                    raise
+        finally:
+            if exit_process:
+                clean_exit = True
+                await shutdown_cli_session_bounded(
+                    user_id=active_user_id,
+                    conn=conn,
+                    exit_code=run_exit_code,
+                )
+            else:
+                stop_all_spinners()
+
+    def _sigint_handler(_signum: int, _frame: object) -> None:
+        stop_all_spinners()
+        raise KeyboardInterrupt
+
+    previous_sigint = signal.getsignal(signal.SIGINT)
+    if sys.stdin.isatty():
+        signal.signal(signal.SIGINT, _sigint_handler)
+
+    try:
+        run_cli_loop(run_cli())
+    except KeyboardInterrupt:
+        print("\nInterrupted.", file=sys.stderr)
+        sys.exit(130)
+    except asyncio.CancelledError:
+        if not clean_exit:
+            print("\nInterrupted.", file=sys.stderr)
+            sys.exit(130)
+    finally:
+        stop_all_spinners()
+        if sys.stdin.isatty():
+            signal.signal(signal.SIGINT, previous_sigint)
+
+
+if __name__ == "__main__":
+    main()

wizelit_cli/api_config.py

@@ -0,0 +1,77 @@
+"""Shared backend API configuration for the terminal CLI."""
+
+from __future__ import annotations
+
+import ipaddress
+import logging
+import os
+from urllib.parse import urlparse
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_API_URL = "http://localhost:8000"
+
+
+def _env_bool(name: str, default: bool) -> bool:
+    raw = os.getenv(name)
+    if raw is None:
+        return default
+    return raw.strip().lower() in {"1", "true", "yes", "on"}
+
+
+def api_url() -> str:
+    return (os.getenv("WIZELIT_API_URL") or _DEFAULT_API_URL).rstrip("/")
+
+
+def api_token() -> str | None:
+    token = (os.getenv("WIZELIT_IDE_TOKEN") or "").strip()
+    return token or None
+
+
+def use_api_settings() -> bool:
+    return _env_bool("WIZELIT_CLI_USE_API_SETTINGS", True)
+
+
+def allow_insecure_http() -> bool:
+    """Opt-in for sending credentials to remote plain-HTTP APIs."""
+    return _env_bool("WIZELIT_ALLOW_INSECURE", False)
+
+
+def _is_loopback_host(host: str | None) -> bool:
+    if not host:
+        return False
+    normalized = host.strip("[]").lower()
+    if normalized == "localhost":
+        return True
+    try:
+        return ipaddress.ip_address(normalized).is_loopback
+    except ValueError:
+        return False
+
+
+def is_insecure_remote_http(base_url: str) -> bool:
+    """True when ``base_url`` is plain HTTP to a non-loopback host."""
+    parsed = urlparse(base_url)
+    if parsed.scheme != "http":
+        return False
+    return not _is_loopback_host(parsed.hostname)
+
+
+def bearer_auth_headers(base_url: str, token: str | None) -> dict[str, str]:
+    """Build Authorization headers, refusing cleartext token to remote hosts."""
+    if not token:
+        return {}
+    if is_insecure_remote_http(base_url):
+        if allow_insecure_http():
+            logger.warning(
+                "Sending IDE bearer token to remote plain HTTP API %s "
+                "(WIZELIT_ALLOW_INSECURE=1). Prefer https://.",
+                base_url,
+            )
+        else:
+            raise ValueError(
+                f"Refusing to send IDE token over plain HTTP to non-loopback host "
+                f"({base_url}). Use https:// or set WIZELIT_ALLOW_INSECURE=1 to "
+                "override (not recommended)."
+            )
+    return {"Authorization": f"Bearer {token}"}

wizelit_cli/checkpoint.py

@@ -0,0 +1,44 @@
+"""SQLite checkpoint helpers for the terminal CLI."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+async def open_checkpointer(db_path: Path) -> tuple[Any, Any]:
+    """Open an AsyncSqliteSaver backed by aiosqlite. Returns (conn, saver)."""
+    import aiosqlite
+    from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
+
+    conn = await aiosqlite.connect(str(db_path))
+    return conn, AsyncSqliteSaver(conn)
+
+
+def _force_close_sqlite(conn: Any) -> None:
+    """Stop aiosqlite without awaiting close() (avoids wedging the event loop on exit)."""
+    try:
+        conn.stop()
+    except Exception:  # noqa: BLE001
+        pass
+    thread = getattr(conn, "_thread", None)
+    if thread is not None and thread.is_alive():
+        thread.join(timeout=1.0)
+
+
+async def close_checkpointer(conn: Any, *, force: bool = False) -> None:
+    """Close aiosqlite before the event loop stops."""
+    if conn is None:
+        return
+    if force:
+        _force_close_sqlite(conn)
+        return
+    try:
+        await asyncio.wait_for(conn.close(), timeout=2.0)
+    except Exception as exc:  # noqa: BLE001
+        logger.debug("sqlite close: %s", exc)
+        _force_close_sqlite(conn)

wizelit_cli/config_paths.py

@@ -0,0 +1,56 @@
+"""Config and install paths for the distributed terminal CLI."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def cli_config_dir() -> Path:
+    """User config directory (default ``~/.wizelit`` or ``$XDG_CONFIG_HOME/wizelit``)."""
+    if raw := os.getenv("WIZELIT_CONFIG_DIR"):
+        return Path(raw).expanduser().resolve()
+    if xdg := os.getenv("XDG_CONFIG_HOME"):
+        return (Path(xdg).expanduser() / "wizelit").resolve()
+    return (Path.home() / ".wizelit").resolve()
+
+
+def dev_backend_root() -> Path:
+    """Monorepo ``packages/backend`` when developing from a checkout."""
+    # wizelit_cli/config_paths.py → packages/cli/wizelit_cli → packages/backend
+    candidate = Path(__file__).resolve().parents[2] / "backend"
+    if (candidate / "skills").is_dir():
+        return candidate
+    return Path(__file__).resolve().parents[2]
+
+
+def backend_install_root() -> Path:
+    """Root containing bundled ``skills/`` and ``subagents/`` (wheel or source tree)."""
+    if env_root := os.getenv("WIZELIT_BACKEND_ROOT"):
+        return Path(env_root).expanduser().resolve()
+
+    import wizelit_core
+
+    site_root = Path(wizelit_core.__file__).resolve().parent.parent
+    if (site_root / "skills").is_dir():
+        return site_root
+
+    return dev_backend_root()
+
+
+def load_cli_env() -> None:
+    """Load CLI environment: user ``~/.wizelit/.env`` first, then dev ``packages/backend/.env``."""
+    from dotenv import load_dotenv
+
+    from wizelit_cli.secure_io import ensure_private_dir
+
+    config_dir = cli_config_dir()
+    ensure_private_dir(config_dir)
+    user_env = config_dir / ".env"
+    if user_env.is_file():
+        load_dotenv(user_env)
+
+    dev_env = dev_backend_root() / ".env"
+    if dev_env.is_file():
+        # Dev checkout defaults; user config values already loaded take precedence.
+        load_dotenv(dev_env, override=False)

wizelit_cli/hitl.py

@@ -0,0 +1,198 @@
+"""Human-in-the-loop prompts for the terminal CLI."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+
+from wizelit_cli.terminal_ui import style
+
+
+def _format_hitl_action(action_request: dict) -> str:
+    name = action_request.get("name", "tool")
+    args = action_request.get("args", {})
+    description = action_request.get("description", "")
+
+    if name == "write_file" and isinstance(args, dict):
+        content_value = args.get("content", "")
+        content_len = len(content_value) if isinstance(content_value, str) else len(str(content_value))
+        safe_args = {
+            "file_path": args.get("file_path"),
+            "content_length": content_len,
+        }
+    else:
+        safe_args = args
+
+    args_text = json.dumps(safe_args, indent=2, default=str)
+    parts = [
+        style("yellow", f"[approval required] {name}"),
+        f"Args:\n{args_text}",
+    ]
+    if description:
+        if name == "write_file":
+            # Middleware default description echoes full args, including content.
+            # Keep it concise for CLI HITL prompts.
+            description = "Tool execution requires approval."
+        parts.append(f"Reason:\n{description}")
+    return "\n".join(parts)
+
+
+async def collect_hitl_decisions(request: dict) -> list[dict]:
+    """Prompt for human approval decisions for a middleware HITL request."""
+    action_requests = request.get("action_requests", [])
+    review_configs = request.get("review_configs", [])
+    decisions: list[dict] = []
+
+    if not isinstance(action_requests, list) or not isinstance(review_configs, list):
+        return [{"type": "reject", "message": "Invalid HITL request payload."}]
+
+    if not action_requests:
+        # LangGraph accepts Command(resume={"decisions": []}), but an interrupt
+        # with no actions is spurious — return [] so callers skip resume.
+        return []
+
+    for idx, action in enumerate(action_requests):
+        cfg = review_configs[idx] if idx < len(review_configs) else {}
+        allowed = set(cfg.get("allowed_decisions") or [])
+        action_name = str(action.get("name", ""))
+        action_args = action.get("args", {})
+
+        if action_name == "write_file" and isinstance(action_args, dict):
+            target_path = action_args.get("file_path")
+            if isinstance(target_path, str) and target_path.strip():
+                target = Path(target_path).expanduser()
+                if target.exists():
+                    print("", flush=True)
+                    print(style("bold", f"HITL Review {idx + 1}/{len(action_requests)}"), flush=True)
+                    print(_format_hitl_action(action), flush=True)
+                    print(
+                        style("yellow", f"Target already exists: {target}"),
+                        flush=True,
+                    )
+                    print("Choose action: [e]dit existing / [n]ew path / [c]ancel (default: c)", flush=True)
+
+                    while True:
+                        existing_choice = (await asyncio.to_thread(input, "> ")).strip().lower()
+                        if existing_choice in {"", "c", "cancel"}:
+                            decisions.append(
+                                {
+                                    "type": "reject",
+                                    "message": (
+                                        f"User cancelled write_file because the target path already exists: {target}. "
+                                        "Do not write to this path unless the user explicitly asks again."
+                                    ),
+                                }
+                            )
+                            break
+                        if existing_choice in {"e", "edit"}:
+                            decisions.append(
+                                {
+                                    "type": "reject",
+                                    "message": (
+                                        f"Target file already exists: {target}. "
+                                        "Read the existing file and use edit_file instead of write_file."
+                                    ),
+                                }
+                            )
+                            break
+                        if existing_choice in {"n", "new"}:
+                            while True:
+                                new_path = (
+                                    await asyncio.to_thread(
+                                        input, "Enter new file path (or 'c' to cancel): "
+                                    )
+                                ).strip()
+                                if not new_path:
+                                    print("Please provide a non-empty path.", flush=True)
+                                    continue
+                                if new_path.lower() in {"c", "cancel"}:
+                                    decisions.append(
+                                        {
+                                            "type": "reject",
+                                            "message": (
+                                                "User cancelled while selecting a new path "
+                                                f"for existing target: {target}."
+                                            ),
+                                        }
+                                    )
+                                    break
+                                candidate = Path(new_path).expanduser()
+                                if candidate.exists():
+                                    print(
+                                        style(
+                                            "yellow",
+                                            f"Path already exists: {candidate}. Please choose another path.",
+                                        ),
+                                        flush=True,
+                                    )
+                                    continue
+                                break
+
+                            if decisions and decisions[-1].get("type") == "reject":
+                                break
+                            if "edit" in allowed:
+                                edited_args = dict(action_args)
+                                edited_args["file_path"] = new_path
+                                decisions.append(
+                                    {
+                                        "type": "edit",
+                                        "edited_action": {
+                                            "name": action_name,
+                                            "args": edited_args,
+                                        },
+                                    }
+                                )
+                            else:
+                                decisions.append(
+                                    {
+                                        "type": "reject",
+                                        "message": (
+                                            f"Target file already exists: {target}. "
+                                            f"Write the content to this new path instead: {new_path}."
+                                        ),
+                                    }
+                                )
+                            break
+                        print("Please enter e, n, or c.", flush=True)
+                    continue
+
+        # POC: support approve/reject only. If a tool is configured differently,
+        # prefer safe behavior (reject) over guessing an unsupported decision.
+        if "approve" not in allowed and "reject" in allowed:
+            decisions.append(
+                {
+                    "type": "reject",
+                    "message": "CLI POC only supports approve/reject; approve not allowed.",
+                }
+            )
+            continue
+        if "approve" not in allowed:
+            decisions.append({"type": "reject", "message": "CLI POC cannot handle this decision type."})
+            continue
+
+        print("", flush=True)
+        print(style("bold", f"HITL Review {idx + 1}/{len(action_requests)}"), flush=True)
+        print(_format_hitl_action(action), flush=True)
+
+        prompt = "Approve? [a]pprove/[r]eject (default: r): " if "reject" in allowed else "Approve? [a]: "
+        while True:
+            choice = (await asyncio.to_thread(input, prompt)).strip().lower()
+            if choice in {"", "r", "reject"} and "reject" in allowed:
+                reason = await asyncio.to_thread(
+                    input,
+                    "Optional rejection reason (enter to skip): ",
+                )
+                reason = reason.strip()
+                payload = {"type": "reject"}
+                if reason:
+                    payload["message"] = reason
+                decisions.append(payload)
+                break
+            if choice in {"a", "approve"}:
+                decisions.append({"type": "approve"})
+                break
+            print("Please enter 'a' to approve or 'r' to reject.", flush=True)
+
+    return decisions
+