wizelit-cli 0.1.17__tar.gz

wizelit_cli-0.1.17/.gitignore

@@ -0,0 +1,47 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.cli_bundle/
+.agent/
+.venv/
+*.egg
+
+# Node
+node_modules/
+dist/
+
+# Environment
+.env
+!.env.template
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Data
+data/
+
+# Test
+.pytest_cache/
+.coverage
+htmlcov/
+videos/
+
+# Build
+*.whl
+
+# AWS CDK
+cdk.out/
+cdk.context.json
+
+local_*

wizelit_cli-0.1.17/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wizeline
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

wizelit_cli-0.1.17/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: wizelit-cli
+Version: 0.1.17
+Summary: Wizelit terminal agent — installable CLI for local repo work
+Author-email: Wizeline <engineering@wizeline.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,cli,deepagents,terminal,wizelit
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Terminals
+Requires-Python: >=3.12
+Requires-Dist: wizelit-core==0.1.17
+Description-Content-Type: text/markdown
+
+# Wizelit CLI
+
+Terminal agent for local repository work. Depends on **`wizelit-core`** only (no FastAPI, SQLAlchemy, or Postgres). Settings and MCP sync from your Wizelit hub; skills and subagents ship inside `wizelit-core`.
+
+Install via **`uv tool install`** (Python 3.12+ pulled automatically).
+
+## Setup
+
+1. Install [uv](https://docs.astral.sh/uv/): `brew install uv`
+2. Install the CLI:
+
+```bash
+uv tool install wizelit-cli@latest
+wizelit-agent --help
+```
+
+3. Create **`~/.wizelit/.env`** (minimum):
+
+```bash
+WIZELIT_API_URL=https://your-wizelit-hub.example.com
+WIZELIT_IDE_TOKEN=wiz_xxxxxxxx
+# LLM credentials (match your web UI provider):
+GOOGLE_API_KEY=...
+# and/or AWS_REGION + keys for Bedrock, ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.
+```
+
+4. Sync settings from the hub, then run:
+
+```bash
+wizelit-agent --sync-profile
+wizelit-agent -i --repo /path/to/your-project
+```
+
+## One-shot (no install)
+
+```bash
+uvx --from wizelit-cli wizelit-agent -i --repo /path/to/project
+```
+
+## Config
+
+| Path | Purpose |
+|------|---------|
+| `~/.wizelit/.env` | Hub URL, IDE token, LLM credentials |
+| `~/.wizelit/profile.json` | Synced LLM + MCP settings (from `--sync-profile`) |
+| `{repo}/.agent/cli_checkpoints.sqlite` | Conversation checkpoints per repo |
+
+Override config directory: `WIZELIT_CONFIG_DIR`.
+
+## REPL commands
+
+| Input | Action |
+|-------|--------|
+| `/exit`, `/quit` | Leave the REPL |
+| `/reload` | Rebuild agent + reconnect MCP |
+| `/sync` | Refresh profile from API, then reload |
+| `Ctrl+C` | Interrupt current turn |
+
+## Troubleshooting
+
+| Symptom | What to do |
+|---------|------------|
+| `wizelit-agent: command not found` | New terminal after install, or `uv tool update-shell` |
+| `401` on `--sync-profile` | Refresh `WIZELIT_IDE_TOKEN` in `~/.wizelit/.env` |
+| Hub unreachable | Check `WIZELIT_API_URL`; ensure backend is running |
+| One-shot opens REPL | Drop `-i` when passing a prompt on the command line |
+
+Upgrade: `uv tool upgrade wizelit-cli`

wizelit_cli-0.1.17/README.md

@@ -0,0 +1,68 @@
+# Wizelit CLI
+
+Terminal agent for local repository work. Depends on **`wizelit-core`** only (no FastAPI, SQLAlchemy, or Postgres). Settings and MCP sync from your Wizelit hub; skills and subagents ship inside `wizelit-core`.
+
+Install via **`uv tool install`** (Python 3.12+ pulled automatically).
+
+## Setup
+
+1. Install [uv](https://docs.astral.sh/uv/): `brew install uv`
+2. Install the CLI:
+
+```bash
+uv tool install wizelit-cli@latest
+wizelit-agent --help
+```
+
+3. Create **`~/.wizelit/.env`** (minimum):
+
+```bash
+WIZELIT_API_URL=https://your-wizelit-hub.example.com
+WIZELIT_IDE_TOKEN=wiz_xxxxxxxx
+# LLM credentials (match your web UI provider):
+GOOGLE_API_KEY=...
+# and/or AWS_REGION + keys for Bedrock, ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.
+```
+
+4. Sync settings from the hub, then run:
+
+```bash
+wizelit-agent --sync-profile
+wizelit-agent -i --repo /path/to/your-project
+```
+
+## One-shot (no install)
+
+```bash
+uvx --from wizelit-cli wizelit-agent -i --repo /path/to/project
+```
+
+## Config
+
+| Path | Purpose |
+|------|---------|
+| `~/.wizelit/.env` | Hub URL, IDE token, LLM credentials |
+| `~/.wizelit/profile.json` | Synced LLM + MCP settings (from `--sync-profile`) |
+| `{repo}/.agent/cli_checkpoints.sqlite` | Conversation checkpoints per repo |
+
+Override config directory: `WIZELIT_CONFIG_DIR`.
+
+## REPL commands
+
+| Input | Action |
+|-------|--------|
+| `/exit`, `/quit` | Leave the REPL |
+| `/reload` | Rebuild agent + reconnect MCP |
+| `/sync` | Refresh profile from API, then reload |
+| `Ctrl+C` | Interrupt current turn |
+
+## Troubleshooting
+
+| Symptom | What to do |
+|---------|------------|
+| `wizelit-agent: command not found` | New terminal after install, or `uv tool update-shell` |
+| `401` on `--sync-profile` | Refresh `WIZELIT_IDE_TOKEN` in `~/.wizelit/.env` |
+| Hub unreachable | Check `WIZELIT_API_URL`; ensure backend is running |
+| One-shot opens REPL | Drop `-i` when passing a prompt on the command line |
+
+Upgrade: `uv tool upgrade wizelit-cli`

wizelit_cli-0.1.17/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "wizelit-cli"
+version = "0.1.17"
+description = "Wizelit terminal agent — installable CLI for local repo work"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.12"
+authors = [{ name = "Wizeline", email = "engineering@wizeline.com" }]
+keywords = ["wizelit", "cli", "agents", "terminal", "deepagents"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Terminals",
+]
+dependencies = [
+    "wizelit-core==0.1.17",
+]
+
+[project.scripts]
+wizelit-agent = "wizelit_cli.agent_cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["wizelit_cli"]
+
+[tool.hatch.build.targets.sdist]
+include = ["LICENSE", "README.md", "wizelit_cli/**/*.py"]
+
+[tool.uv.sources]
+wizelit-core = { workspace = true }

wizelit_cli-0.1.17/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-0.1.17/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-0.1.17/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-0.1.17/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)