cometapi-cli 0.1.0__py3-none-any.whl

cometapi_cli/commands/chat_repl.py

@@ -0,0 +1,229 @@
+"""Interactive multi-turn chat REPL."""
+
+from __future__ import annotations
+
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.history import FileHistory
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.text import Text
+
+from ..config import CONFIG_DIR, get_client, get_default_model
+from ..console import console, err_console
+
+SLASH_COMMANDS = {
+    "/model": "Switch model: /model <name>",
+    "/system": "Set system prompt: /system <prompt>",
+    "/clear": "Clear conversation history",
+    "/history": "Show conversation history",
+    "/save": "Save conversation: /save <file.json|file.md>",
+    "/tokens": "Show approximate token count",
+    "/help": "Show available commands",
+    "/exit": "Exit chat (also Ctrl+D)",
+}
+
+
+def _banner(model: str) -> Panel:
+    text = Text.assemble(
+        ("CometAPI Chat", "bold cyan"),
+        "  •  Model: ",
+        (model, "bold green"),
+        "\n",
+        ("Type /help for commands, /exit or Ctrl+D to quit.", "dim"),
+    )
+    return Panel(text, border_style="cyan", padding=(0, 1))
+
+
+def _estimate_tokens(messages: list[dict[str, str]]) -> int:
+    """Rough token estimate (~4 chars per token)."""
+    total_chars = sum(len(m.get("content", "")) for m in messages)
+    return total_chars // 4
+
+
+def _format_history(messages: list[dict[str, str]]) -> None:
+    for msg in messages:
+        role = msg["role"]
+        content = msg["content"]
+        if role == "system":
+            console.print(f"[bold magenta]system:[/] {content}")
+        elif role == "user":
+            console.print(f"[bold blue]you:[/] {content}")
+        elif role == "assistant":
+            console.print(f"[bold green]assistant:[/] {content}")
+
+
+def _save_conversation(messages: list[dict[str, str]], filepath: str, model: str) -> None:
+    path = Path(filepath)
+    if path.suffix in (".json",):
+        data = {
+            "model": model,
+            "exported_at": datetime.now(tz=timezone.utc).isoformat(),
+            "messages": messages,
+        }
+        path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+        console.print(f"[green]Saved to {path}[/]")
+    elif path.suffix in (".md", ".markdown"):
+        lines = [f"# Chat Export — {model}\n"]
+        for msg in messages:
+            role = msg["role"].capitalize()
+            lines.append(f"## {role}\n")
+            lines.append(msg["content"])
+            lines.append("")
+        path.write_text("\n".join(lines), encoding="utf-8")
+        console.print(f"[green]Saved to {path}[/]")
+    else:
+        err_console.print("[yellow]Unsupported format. Use .json or .md[/]")
+
+
+def _send_message(
+    client: object,
+    messages: list[dict[str, str]],
+    model: str,
+    stream: bool = True,
+    temperature: float | None = None,
+    max_tokens: int | None = None,
+) -> str:
+    """Send messages to the API and return the assistant response."""
+    kwargs: dict = {"model": model, "messages": messages, "stream": stream}
+    if temperature is not None:
+        kwargs["temperature"] = temperature
+    if max_tokens is not None:
+        kwargs["max_tokens"] = max_tokens
+
+    if stream:
+        response = client.chat.completions.create(**kwargs)  # type: ignore[union-attr]
+        full_text = ""
+        for chunk in response:
+            if not chunk.choices:
+                continue
+            delta = chunk.choices[0].delta.content or ""
+            sys.stdout.write(delta)
+            sys.stdout.flush()
+            full_text += delta
+        sys.stdout.write("\n")
+        sys.stdout.flush()
+        return full_text
+    else:
+        response = client.chat.completions.create(**kwargs)  # type: ignore[union-attr]
+        text = response.choices[0].message.content or ""
+        console.print(Markdown(text))
+        return text
+
+
+def run_chat_repl(
+    model: str | None = None,
+    system: str | None = None,
+    temperature: float | None = None,
+    max_tokens: int | None = None,
+    stream: bool = True,
+) -> None:
+    """Run interactive multi-turn chat REPL."""
+    client = get_client()
+    current_model = model or get_default_model()
+
+    messages: list[dict[str, str]] = []
+    if system:
+        messages.append({"role": "system", "content": system})
+
+    console.print(_banner(current_model))
+
+    # Set up prompt_toolkit session with persistent history
+    history_file = CONFIG_DIR / "chat_history"
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    session: PromptSession[str] = PromptSession(
+        history=FileHistory(str(history_file)),
+        multiline=False,
+    )
+
+    while True:
+        try:
+            user_input = session.prompt(HTML("<b><ansiblue>you → </ansiblue></b>")).strip()
+        except (EOFError, KeyboardInterrupt):
+            console.print("\n[dim]Goodbye![/]")
+            break
+
+        if not user_input:
+            continue
+
+        # Handle slash commands
+        if user_input.startswith("/"):
+            cmd_parts = user_input.split(maxsplit=1)
+            cmd = cmd_parts[0].lower()
+            arg = cmd_parts[1] if len(cmd_parts) > 1 else ""
+
+            if cmd in ("/exit", "/quit", "/q"):
+                console.print("[dim]Goodbye![/]")
+                break
+
+            elif cmd == "/help":
+                for slash_cmd, desc in SLASH_COMMANDS.items():
+                    console.print(f"  [cyan]{slash_cmd:<12}[/] {desc}")
+
+            elif cmd == "/model":
+                if arg:
+                    current_model = arg
+                    console.print(f"[green]Model switched to {current_model}[/]")
+                else:
+                    console.print(f"[cyan]Current model: {current_model}[/]")
+
+            elif cmd == "/system":
+                if arg:
+                    # Remove existing system message if any
+                    messages = [m for m in messages if m["role"] != "system"]
+                    messages.insert(0, {"role": "system", "content": arg})
+                    console.print(f"[green]System prompt set ({len(arg)} chars).[/]")
+                else:
+                    sys_msg = next((m["content"] for m in messages if m["role"] == "system"), None)
+                    if sys_msg:
+                        console.print(f"[cyan]System prompt:[/] {sys_msg}")
+                    else:
+                        console.print("[dim]No system prompt set.[/]")
+
+            elif cmd == "/clear":
+                sys_msg = next((m for m in messages if m["role"] == "system"), None)
+                messages = [sys_msg] if sys_msg else []
+                console.print("[green]History cleared.[/]")
+
+            elif cmd == "/history":
+                if not messages:
+                    console.print("[dim]No messages yet.[/]")
+                else:
+                    _format_history(messages)
+
+            elif cmd == "/save":
+                if arg:
+                    _save_conversation(messages, arg, current_model)
+                else:
+                    err_console.print("[yellow]Usage: /save <filename.json|filename.md>[/]")
+
+            elif cmd == "/tokens":
+                tokens = _estimate_tokens(messages)
+                console.print(f"[cyan]~{tokens} tokens[/] in {len(messages)} messages")
+
+            else:
+                err_console.print(f"[yellow]Unknown command: {cmd}. Type /help for available commands.[/]")
+
+            continue
+
+        # Regular message — send to API
+        messages.append({"role": "user", "content": user_input})
+
+        try:
+            reply = _send_message(
+                client, messages, current_model,
+                stream=stream, temperature=temperature, max_tokens=max_tokens,
+            )
+            messages.append({"role": "assistant", "content": reply})
+        except KeyboardInterrupt:
+            console.print("\n[dim]Response interrupted.[/]")
+            # Remove the user message that didn't get a response
+            messages.pop()
+        except Exception as e:
+            err_console.print(f"[red bold]Error:[/] {e}")
+            # Keep the user message in history for retry

cometapi_cli/commands/config_cmd.py

@@ -0,0 +1,174 @@
+"""Config management and init wizard."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+
+from ..config import CONFIG_FILE, VALID_KEYS, load_config, mask_secret, save_config
+from ..console import console, err_console
+from ..errors import handle_errors
+from ..formatters import OutputFormat, output, resolve_format
+
+config_app = typer.Typer(name="config", help="Manage CLI configuration.")
+
+
+@handle_errors
+def init(ctx: typer.Context) -> None:
+    """Interactive setup wizard — configure API keys and preferences."""
+    from ..config import get_default_model
+
+    console.print(
+        Panel(
+            "[bold blue]CometAPI CLI Setup[/bold blue]\n\n"
+            "Let's configure your CometAPI client.\n"
+            "You can change these settings later with [bold]cometapi config set[/bold].",
+            title="🚀 Welcome",
+            border_style="blue",
+        )
+    )
+
+    console.print(
+        Panel(
+            "[bold yellow]⚠ Security Notice[/bold yellow]\n\n"
+            "Your API key and access token are sensitive credentials.\n"
+            "• Never share keys in public repos, logs, or chat messages.\n"
+            "• You are responsible for all usage and charges incurred with your keys.\n\n"
+            "[bold]Create your API key at:[/bold] https://www.cometapi.com/console/token\n"
+            "[bold]Get your access token at:[/bold] https://www.cometapi.com/console/personal",
+            border_style="yellow",
+        )
+    )
+
+    cfg = load_config()
+
+    # API Key
+    current_key = cfg.get("api_key", "")
+    default_display = mask_secret(current_key) if current_key else None
+    api_key = Prompt.ask(
+        "[bold]API Key[/bold] (COMETAPI_KEY)",
+        default=default_display,
+    )
+    if api_key and api_key != default_display:
+        cfg["api_key"] = api_key
+
+    # Validate connectivity
+    if cfg.get("api_key"):
+        console.print("[dim]Testing API connectivity...[/]", end=" ")
+        try:
+            from cometapi_cli.client import CometClient
+
+            test_client = CometClient(api_key=cfg["api_key"])
+            test_client.models.list()
+            console.print("[green]✓ Connected[/green]")
+        except Exception:
+            console.print("[yellow]⚠ Could not verify (check later with cometapi doctor)[/yellow]")
+
+    # Access Token (optional)
+    console.print()
+    current_token = cfg.get("access_token", "")
+    if Confirm.ask(
+        "[bold]Configure access token?[/bold] (for account/stats commands)",
+        default=bool(current_token),
+    ):
+        default_token_display = mask_secret(current_token) if current_token else None
+        access_token = Prompt.ask(
+            "[bold]Access Token[/bold] (COMETAPI_ACCESS_TOKEN)",
+            default=default_token_display,
+        )
+        if access_token and access_token != default_token_display:
+            cfg["access_token"] = access_token
+
+    # Default model
+    console.print()
+    default_model = Prompt.ask(
+        "[bold]Default model[/bold]",
+        default=cfg.get("default_model", get_default_model()),
+    )
+    cfg["default_model"] = default_model
+
+    # Save
+    save_config(cfg)
+
+    console.print()
+    console.print(
+        Panel(
+            f"[green]Configuration saved to[/green] {CONFIG_FILE}\n"
+            "[dim]File permissions: 0600 (owner read/write only)[/dim]\n\n"
+            "[dim]Credentials are stored locally. Never commit this file to version control.[/dim]\n\n"
+            "Next steps:\n"
+            "  [bold]cometapi doctor[/bold]    — verify your setup\n"
+            "  [bold]cometapi models[/bold]    — list available models\n"
+            "  [bold]cometapi chat[/bold]      — start chatting",
+            title="✅ Setup Complete",
+            border_style="green",
+        )
+    )
+
+
+@config_app.command("show")
+@handle_errors
+def config_show(
+    ctx: typer.Context,
+    output_format: Annotated[OutputFormat | None, typer.Option("--format", "-f", help="Output format.")] = None,
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON.")] = False,
+) -> None:
+    """Display current configuration (secrets are masked)."""
+    fmt = resolve_format(ctx, json_output, output_format)
+    cfg = load_config()
+
+    if not cfg:
+        console.print("[dim]No configuration file found. Run [bold]cometapi init[/bold] to create one.[/]")
+        return
+
+    display = {}
+    for key, value in cfg.items():
+        if key in ("api_key", "access_token"):
+            display[key] = mask_secret(str(value))
+        else:
+            display[key] = value
+
+    output(display, fmt, title="CometAPI Configuration")
+
+
+@config_app.command("set")
+@handle_errors
+def config_set(
+    key: Annotated[str, typer.Argument(help="Configuration key.")],
+    value: Annotated[str, typer.Argument(help="Configuration value.")],
+) -> None:
+    """Set a configuration value."""
+    if key not in VALID_KEYS:
+        err_console.print(f"[red bold]Error:[/] Unknown key '{key}'. Valid keys: {', '.join(sorted(VALID_KEYS))}")
+        raise typer.Exit(code=2)
+
+    cfg = load_config()
+    cfg[key] = value
+    save_config(cfg)
+    display_value = mask_secret(value) if key in ("api_key", "access_token") else value
+    console.print(f"[green]✓[/green] Set [bold]{key}[/bold] = {display_value}")
+
+
+@config_app.command("unset")
+@handle_errors
+def config_unset(
+    key: Annotated[str, typer.Argument(help="Configuration key to remove.")],
+) -> None:
+    """Remove a configuration value."""
+    cfg = load_config()
+    if key not in cfg:
+        err_console.print(f"[yellow]Key '{key}' is not set.[/yellow]")
+        return
+
+    del cfg[key]
+    save_config(cfg)
+    console.print(f"[green]✓[/green] Removed [bold]{key}[/bold]")
+
+
+@config_app.command("path")
+def config_path() -> None:
+    """Show the configuration file path."""
+    console.print(str(CONFIG_FILE))

cometapi_cli/commands/doctor.py

@@ -0,0 +1,144 @@
+"""Doctor command — diagnostics and health checks."""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Annotated
+
+import typer
+
+from ..config import CONFIG_FILE, get_client, load_config, mask_secret
+from ..console import console
+from ..errors import ConfigMissing, ExitCode, handle_errors
+from ..formatters import OutputFormat, output, resolve_format
+
+
+def _check_mark(ok: bool) -> str:
+    return "[green]✓[/green]" if ok else "[red]✗[/red]"
+
+
+def _warn_mark() -> str:
+    return "[yellow]⚠[/yellow]"
+
+
+@handle_errors
+def doctor(
+    ctx: typer.Context,
+    output_format: Annotated[OutputFormat | None, typer.Option("--format", "-f", help="Output format.")] = None,
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON.")] = False,
+) -> None:
+    """Check CLI configuration and API connectivity."""
+    from .. import __version__
+
+    fmt = resolve_format(ctx, json_output, output_format)
+    cfg = load_config()
+    results: dict = {}
+    all_ok = True
+
+    # Check 1: Config file
+    config_exists = CONFIG_FILE.exists()
+    results["config_file"] = {
+        "status": "ok" if config_exists else "warning",
+        "path": str(CONFIG_FILE),
+    }
+
+    # Check 2: API key
+    api_key = os.environ.get("COMETAPI_KEY") or cfg.get("api_key", "")
+    key_source = "environment" if os.environ.get("COMETAPI_KEY") else ("config" if cfg.get("api_key") else "none")
+    has_key = bool(api_key)
+    results["api_key"] = {
+        "status": "ok" if has_key else "error",
+        "masked": mask_secret(api_key) if api_key else "not set",
+        "source": key_source,
+    }
+    if not has_key:
+        all_ok = False
+
+    # Check 3: Connectivity
+    if has_key:
+        try:
+            client = get_client()
+            client.models.list()
+            base_url = os.environ.get("COMETAPI_BASE_URL") or cfg.get("base_url", "https://api.cometapi.com/v1")
+            results["connectivity"] = {"status": "ok", "base_url": base_url}
+        except ConfigMissing:
+            results["connectivity"] = {"status": "error", "message": "API key required"}
+            all_ok = False
+        except Exception as e:
+            exc_type = type(e).__name__
+            if "AuthenticationError" in exc_type:
+                results["connectivity"] = {"status": "warning", "message": "connected but auth failed"}
+            else:
+                results["connectivity"] = {"status": "error", "message": str(e)[:100]}
+                all_ok = False
+    else:
+        results["connectivity"] = {"status": "skipped", "message": "no API key"}
+
+    # Check 4: Access token
+    access_token = os.environ.get("COMETAPI_ACCESS_TOKEN") or cfg.get("access_token", "")
+    results["access_token"] = {
+        "status": "ok" if access_token else "warning",
+        "masked": mask_secret(access_token) if access_token else "not set (optional)",
+    }
+
+    # Check 5: Versions
+    results["versions"] = {
+        "python": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+        "cometapi_cli": __version__,
+    }
+
+    # JSON / YAML output
+    if fmt in (OutputFormat.JSON, OutputFormat.YAML):
+        output(results, fmt)
+        if not all_ok:
+            raise typer.Exit(code=ExitCode.CONFIG_MISSING)
+        return
+
+    # Rich formatted output
+    console.print()
+    console.print("[bold]CometAPI Doctor[/bold]")
+    console.print("─" * 40)
+
+    # Config file
+    mark = _check_mark(config_exists) if config_exists else _warn_mark()
+    status_text = "found" if config_exists else "not found"
+    console.print(f"  {mark} Config file: {status_text} ({CONFIG_FILE})")
+
+    # API key
+    mark = _check_mark(has_key)
+    key_display = mask_secret(api_key) if api_key else "not set"
+    console.print(f"  {mark} API key: {key_display} [dim]({key_source})[/dim]")
+    if not has_key:
+        console.print("       [dim]Create one at: https://www.cometapi.com/console/token[/dim]")
+
+    # Connectivity
+    conn = results["connectivity"]
+    if conn["status"] == "ok":
+        console.print(f"  {_check_mark(True)} API connectivity: {conn['base_url']}")
+    elif conn["status"] == "warning":
+        console.print(f"  {_warn_mark()} API connectivity: {conn['message']}")
+    elif conn["status"] == "skipped":
+        console.print("  [dim]- API connectivity: skipped (no API key)[/dim]")
+    else:
+        console.print(f"  {_check_mark(False)} API connectivity: {conn.get('message', 'failed')}")
+
+    # Access token
+    token_ok = bool(access_token)
+    mark = _check_mark(token_ok) if token_ok else _warn_mark()
+    token_display = mask_secret(access_token) if access_token else "not set (optional)"
+    console.print(f"  {mark} Access token: {token_display}")
+    if not token_ok:
+        console.print("       [dim]Get one at: https://www.cometapi.com/console/personal[/dim]")
+
+    # Versions
+    v = results["versions"]
+    ver_line = f"Python {v['python']} · cometapi-cli {v['cometapi_cli']}"
+    console.print(f"  {_check_mark(True)} {ver_line}")
+
+    console.print()
+    if all_ok:
+        console.print("[green bold]All checks passed![/green bold]")
+    else:
+        console.print("[yellow]Some checks need attention. Run [bold]cometapi init[/bold] to configure.[/yellow]")
+        raise typer.Exit(code=ExitCode.CONFIG_MISSING)