zai-cli 0.1.0__py3-none-any.whl

zai/cli/settings.py

@@ -0,0 +1,436 @@
+from typing import Optional
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+
+from ..config import (
+    MEMORY_FILE,
+    MODELS,
+    get_api_key,
+    get_model_config,
+    get_models,
+    load_config,
+    save_api_key,
+    save_config,
+    validate_config,
+)
+from ..core.memory import get_last_session, get_projects
+from ..core.session import (
+    delete_session,
+    export_session,
+    get_session_info,
+    list_sessions,
+    rename_session,
+    search_sessions,
+)
+from ..core.undo import (
+    clear_actions,
+    get_action,
+    list_actions,
+    redo_last_action,
+    undo_action,
+)
+
+console = Console()
+
+
+def setup():
+    """Setup API keys and preferences."""
+    console.print(Panel("[bold cyan]Welcome to zai setup![/bold cyan]", border_style="cyan"))
+    providers = [
+        ("gemini", "Google Gemini (FREE — Recommended)"),
+        ("groq", "Groq (FREE — Fast)"),
+        ("cerebras", "Cerebras (FREE — Ultra Fast)"),
+        ("openrouter", "OpenRouter (Some free models)"),
+        ("qwen", "Qwen/DashScope"),
+        ("anthropic", "Anthropic Claude (Paid)"),
+        ("openai", "OpenAI GPT-4o (Paid)"),
+    ]
+    for key, label in providers:
+        if get_api_key(key):
+            console.print(f"[green]✓[/green] {label} — already set")
+            continue
+        value = Prompt.ask(
+            f"[cyan]{label}[/cyan] API key [dim](Enter to skip)[/dim]",
+            default="",
+        )
+        if value.strip():
+            save_api_key(key, value.strip())
+            console.print("[green]✓[/green] Saved!")
+
+    config = load_config()
+    free_models = [
+        key for key, data in get_models(config).items()
+        if data["free"] and get_api_key(data["provider"])
+    ]
+    if free_models:
+        console.print(f"\n[cyan]Available free models:[/cyan] {', '.join(free_models)}")
+        default = Prompt.ask(
+            "Default model",
+            choices=list(get_models(config).keys()),
+            default=free_models[0],
+        )
+        config["default_model"] = default
+        save_config(config)
+    console.print(Panel('[green]zai is ready! Try: zai "hello"[/green]', border_style="green"))
+
+
+def model(
+    action: str = typer.Argument(
+        "list", help="list, set, fallback, add, remove, configure, info, test, or check"
+    ),
+    name: Optional[str] = typer.Argument(None),
+    provider: Optional[str] = typer.Option(None, "--provider"),
+    model_id: Optional[str] = typer.Option(None, "--model-id"),
+    context_window: int = typer.Option(128000, "--context-window", min=1024),
+    timeout: float = typer.Option(60, "--timeout", min=1, max=600),
+    retries: int = typer.Option(2, "--retries", min=0, max=10),
+    free: bool = typer.Option(False, "--free"),
+):
+    """List, configure, inspect, or test model aliases."""
+    if action == "list":
+        table = Table(title="Available Models")
+        table.add_column("Name", style="cyan")
+        table.add_column("Model", style="dim")
+        table.add_column("Context", justify="right")
+        table.add_column("Free", justify="center")
+        table.add_column("Key Set", justify="center")
+        config = load_config()
+        for key in get_models(config):
+            data = get_model_config(key, config)
+            has_key = "[green]✓[/green]" if get_api_key(data["provider"]) else "[red]✗[/red]"
+            free_label = "[green]Yes[/green]" if data["free"] else "[yellow]No[/yellow]"
+            table.add_row(
+                key,
+                data["model_id"],
+                f"{data['context_window']:,}",
+                free_label,
+                has_key,
+            )
+        console.print(table)
+    elif action == "set" and name:
+        config = load_config()
+        if name not in get_models(config):
+            console.print(f"[red]Unknown model: {name}[/red]")
+            return
+        config["default_model"] = name
+        save_config(config)
+        console.print(f"[green]✓[/green] Default model set to: [cyan]{name}[/cyan]")
+    elif action == "fallback" and name in {"on", "off"}:
+        config = load_config()
+        config["auto_fallback"] = name == "on"
+        save_config(config)
+        console.print(
+            f"[green]✓[/green] Automatic model fallback: [cyan]{name}[/cyan]"
+        )
+    elif action == "check":
+        config = load_config()
+        issues = validate_config(config)
+        if issues:
+            for issue in issues:
+                console.print(f"[red]x[/red] {issue}")
+        else:
+            console.print("[green]OK[/green] Model configuration is valid.")
+        for key in get_models(config):
+            effective = get_model_config(key, config)["model_id"]
+            console.print(f"[dim]{key}: {effective}[/dim]")
+    elif action == "add" and name:
+        if name in MODELS:
+            console.print(f"[red]Built-in model cannot be replaced: {name}[/red]")
+            return
+        if not provider or not model_id:
+            console.print(
+                "[red]Usage: zai model add <name> --provider <provider> "
+                "--model-id <id> [--context-window <tokens>] [--free][/red]"
+            )
+            return
+        allowed_providers = {data["provider"] for data in MODELS.values()}
+        if provider not in allowed_providers:
+            console.print(f"[red]Unknown provider: {provider}[/red]")
+            return
+        config = load_config()
+        models = config.setdefault("models", {})
+        if name in models:
+            console.print(f"[red]Model already exists: {name}[/red]")
+            return
+        models[name] = {
+            "name": name,
+            "provider": provider,
+            "model_id": model_id,
+            "context_window": context_window,
+            "timeout": timeout,
+            "retries": retries,
+            "free": free,
+        }
+        config.setdefault("fallback_order", []).append(name)
+        save_config(config)
+        console.print(f"[green]Added model:[/green] [cyan]{name}[/cyan]")
+    elif action == "remove" and name:
+        if name in MODELS:
+            console.print(f"[red]Built-in model cannot be removed: {name}[/red]")
+            return
+        config = load_config()
+        models = config.setdefault("models", {})
+        if name not in models:
+            console.print(f"[red]Unknown custom model: {name}[/red]")
+            return
+        del models[name]
+        config["fallback_order"] = [
+            item for item in config.get("fallback_order", []) if item != name
+        ]
+        config.get("model_overrides", {}).pop(name, None)
+        config.get("model_settings", {}).pop(name, None)
+        if config.get("default_model") == name:
+            config["default_model"] = "gemini"
+        save_config(config)
+        console.print(f"[green]Removed model:[/green] [cyan]{name}[/cyan]")
+    elif action == "configure" and name:
+        config = load_config()
+        if name not in get_models(config):
+            console.print(f"[red]Unknown model: {name}[/red]")
+            return
+        config.setdefault("model_settings", {})[name] = {
+            "timeout": timeout,
+            "retries": retries,
+        }
+        save_config(config)
+        console.print(
+            f"[green]Configured model:[/green] [cyan]{name}[/cyan] "
+            f"(timeout={timeout}s, retries={retries})"
+        )
+    elif action == "info" and name:
+        config = load_config()
+        try:
+            data = get_model_config(name, config)
+        except KeyError:
+            console.print(f"[red]Unknown model: {name}[/red]")
+            return
+        console.print(Panel(
+            "\n".join([
+                f"Alias: {name}",
+                f"Provider: {data['provider']}",
+                f"Model ID: {data['model_id']}",
+                f"Context window: {data['context_window']:,}",
+                f"Timeout: {data['timeout']} seconds",
+                f"Retries: {data['retries']}",
+                f"Free: {'yes' if data['free'] else 'no'}",
+                f"Source: {'built-in' if name in MODELS else 'custom'}",
+            ]),
+            title="[cyan]Model information[/cyan]",
+        ))
+    elif action == "test" and name:
+        from ..core.fallback import get_provider
+        from ..providers.base import Message
+
+        selected = get_provider(name)
+        if selected is None:
+            console.print(f"[red]Unknown model: {name}[/red]")
+            return
+        if not selected.is_available():
+            console.print(
+                f"[red]Model unavailable:[/red] {name}. "
+                "Check its API key or local service."
+            )
+            return
+        try:
+            response = selected.chat([
+                Message(role="user", content="Reply with exactly: ok")
+            ])
+        except Exception as error:
+            console.print(f"[red]Model test failed:[/red] {error}")
+            return
+        console.print(
+            f"[green]Model test passed:[/green] {name} "
+            f"([cyan]{response.model}[/cyan])"
+        )
+    else:
+        console.print(
+            "[red]Usage: zai model list | zai model set <name> | "
+            "zai model fallback on|off | "
+            "zai model add/remove/configure/info/test <name> | "
+            "zai model check[/red]"
+        )
+
+
+def memory(action: str = typer.Argument("show", help="show, projects, clear")):
+    """View or manage memory."""
+    if action == "show":
+        last = get_last_session()
+        if last:
+            console.print(Panel(
+                f"Task: {last['task']}\nModel: {last['model']}\nDate: {last['date']}",
+                title="[cyan]Last Session[/cyan]",
+                border_style="cyan",
+            ))
+        else:
+            console.print("[dim]No session history yet.[/dim]")
+    elif action == "projects":
+        projects = get_projects()
+        if projects:
+            for project in projects:
+                console.print(
+                    f"[cyan]{project['name']}[/cyan] — {project['path']} "
+                    f"[dim]({project['last_worked']})[/dim]"
+                )
+        else:
+            console.print("[dim]No projects yet.[/dim]")
+    elif action == "clear":
+        if MEMORY_FILE.exists():
+            MEMORY_FILE.unlink()
+        console.print("[green]✓[/green] Memory cleared.")
+    else:
+        console.print("[red]Usage: zai memory show | projects | clear[/red]")
+
+
+def session(
+    action: str = typer.Argument("list", help="list, show, search, rename, delete"),
+    name: Optional[str] = typer.Argument(None),
+    value: Optional[str] = typer.Argument(None),
+    export_format: str = typer.Option("md", "--format", "-f"),
+    output: Optional[str] = typer.Option(None, "--out", "-o"),
+):
+    """Inspect and manage saved conversations."""
+    if action == "list":
+        sessions = list_sessions()
+        if not sessions:
+            console.print("[dim]No saved sessions.[/dim]")
+            return
+        table = Table(title="Saved Sessions")
+        table.add_column("ID", style="dim")
+        table.add_column("Name", style="cyan")
+        table.add_column("Title")
+        table.add_column("Messages", justify="right")
+        table.add_column("Project", style="dim")
+        for item in sessions:
+            project = (
+                Path(item["project_path"]).name
+                if item.get("project_path")
+                else "-"
+            )
+            table.add_row(
+                item["id"][:8],
+                item["name"],
+                item["title"],
+                str(item["messages"]),
+                project,
+            )
+        console.print(table)
+    elif action == "show" and name:
+        info = get_session_info(name)
+        if not info:
+            console.print("[red]Session not found or identifier is ambiguous.[/red]")
+            return
+        console.print(Panel(
+            f"ID: {info['id']}\n"
+            f"Name: {info['name']}\n"
+            f"Title: {info['title']}\n"
+            f"Messages: {info['messages']}\n"
+            f"Project: {info.get('project_path') or '-'}\n"
+            f"Updated: {info.get('updated_at') or '-'}",
+            title="[cyan]Session[/cyan]",
+        ))
+    elif action == "search" and name:
+        matches = search_sessions(" ".join(filter(None, [name, value])))
+        if not matches:
+            console.print("[dim]No matching sessions.[/dim]")
+            return
+        for item in matches:
+            console.print(
+                f"[cyan]{item['name']}[/cyan] [dim]{item['id'][:8]}[/dim] "
+                f"— {item['title']}"
+            )
+    elif action == "rename" and name and value:
+        if rename_session(name, value):
+            console.print(f"[green]Session renamed:[/green] {value}")
+        else:
+            console.print(
+                "[red]Rename failed: missing, ambiguous, automatic, "
+                "or destination exists.[/red]"
+            )
+    elif action == "delete" and name:
+        if Confirm.ask(f"Delete session '{name}'?", default=False):
+            if delete_session(name):
+                console.print(f"[green]Session deleted:[/green] {name}")
+            else:
+                console.print("[red]Session not found or identifier is ambiguous.[/red]")
+    elif action == "export" and name:
+        exported = export_session(
+            name,
+            export_format=export_format,
+            output=output,
+            project_path=".",
+        )
+        if exported:
+            console.print(f"[green]Session exported:[/green] {exported}")
+        else:
+            console.print(
+                "[red]Export failed: session missing/ambiguous or format "
+                "must be md/json.[/red]"
+            )
+    else:
+        console.print(
+            "[red]Usage: zai session list | show <name-or-id> | "
+            "search <query> | rename <old> <new> | delete <name-or-id> | "
+            "export <name-or-id> --format md|json [--out path][/red]"
+        )
+
+
+def undo(
+    action: str = typer.Argument("list", help="list, show, apply, redo, clear"),
+    identifier: Optional[str] = typer.Argument(None, help="Undo action ID"),
+):
+    """Inspect, apply, redo, or clear project-local undo history."""
+    cwd = str(Path.cwd())
+    if action == "list":
+        actions = list_actions(cwd)
+        if not actions:
+            console.print("[dim]No undo actions.[/dim]")
+            return
+        table = Table(title="Undo History")
+        table.add_column("ID", style="cyan")
+        table.add_column("Created", style="dim")
+        table.add_column("Operation")
+        for item in actions:
+            table.add_row(
+                item["id"][:8],
+                item.get("created_at", "-"),
+                item["summary"],
+            )
+        console.print(table)
+    elif action == "show" and identifier:
+        selected_action = get_action(cwd, identifier)
+        if not selected_action:
+            console.print("[red]Undo action not found or ID is ambiguous.[/red]")
+            return
+        console.print(Panel(
+            f"ID: {selected_action['id']}\n"
+            f"Created: {selected_action.get('created_at', '-')}\n"
+            f"Operation: {selected_action['summary']}\n"
+            f"Paths: {', '.join(selected_action.get('paths', [])) or '-'}",
+            title="[cyan]Undo Action[/cyan]",
+        ))
+    elif action == "apply":
+        console.print(f"[cyan]{undo_action(cwd, identifier)}[/cyan]")
+    elif action == "redo":
+        console.print(f"[cyan]{redo_last_action(cwd)}[/cyan]")
+    elif action == "clear":
+        if Confirm.ask("Clear all undo and redo history for this project?", default=False):
+            count = clear_actions(cwd)
+            console.print(f"[green]Cleared {count} undo/redo actions.[/green]")
+    else:
+        console.print(
+            "[red]Usage: zai undo list | show <id> | apply [id] | "
+            "redo | clear[/red]"
+        )
+
+
+def register_settings_commands(app: typer.Typer) -> None:
+    app.command()(setup)
+    app.command()(model)
+    app.command()(memory)
+    app.command()(session)
+    app.command()(undo)

zai/cli/utilities.py

@@ -0,0 +1,227 @@
+from typing import Optional
+
+import typer
+from rich import print as rprint
+from rich.console import Console
+from rich.panel import Panel
+
+from ..core.errors import show_error
+from ..core.fallback import (
+    chat_with_fallback,
+    format_model_selection,
+    stream_with_fallback,
+)
+from ..core.repomap import build_repomap_result, get_repomap_prompt
+from ..config import get_model_config, load_config
+from ..tools.browser import BrowserError, scrape, screenshot
+from ..tools.code_runner import run_file
+from ..tools.files import list_files, read_file
+from ..tools.search import web_search
+from ..tools.vision import VisionError, analyze_image
+
+console = Console()
+
+
+def register_utility_commands(app: typer.Typer, context, system_prompt: str) -> None:
+    """Register utility commands using the shared conversation context."""
+
+    @app.command()
+    def search(query: str = typer.Argument(..., help="Search query")):
+        """Search the web."""
+        with console.status("[cyan]Searching...[/cyan]"):
+            results = web_search(query)
+        context.add("user", f"Web search results for '{query}':\n{results}\nSummarize this.")
+        with console.status("[cyan]Summarizing...[/cyan]"):
+            response, _ = chat_with_fallback(
+                context.get_messages(),
+                system=system_prompt,
+            )
+        context.add("assistant", response.content)
+        rprint(Panel(
+            response.content,
+            title="[cyan]Search Results[/cyan]",
+            border_style="cyan",
+        ))
+
+    @app.command()
+    def file(
+        action: str = typer.Argument(..., help="Action: read, write, list"),
+        path: Optional[str] = typer.Argument(None),
+        instruction: Optional[str] = typer.Option(
+            None,
+            "--do",
+            "-d",
+            help="What to do with the file",
+        ),
+    ):
+        """File operations: read, write, list."""
+        if action == "read" and path:
+            content = read_file(path)
+            if instruction:
+                context.add(
+                    "user",
+                    f"File: {path}\n\n{content}\n\nInstruction: {instruction}",
+                )
+                with console.status("[cyan]Processing...[/cyan]"):
+                    response, used_model = chat_with_fallback(
+                        context.get_messages(),
+                        system=system_prompt,
+                    )
+                context.add("assistant", response.content)
+                used_model = format_model_selection(used_model)
+                rprint(Panel(
+                    response.content,
+                    border_style="cyan",
+                    title=f"[dim]{used_model}[/dim]",
+                ))
+            else:
+                console.print(Panel(content[:3000], title=f"[cyan]{path}[/cyan]"))
+        elif action == "list":
+            for filename in list_files(path or ".")[:50]:
+                console.print(f"  [dim]{filename}[/dim]")
+        else:
+            console.print(
+                "[red]Usage: zai file read <path> | zai file list [dir][/red]"
+            )
+
+    @app.command()
+    def run(path: str = typer.Argument(..., help="Python file to run")):
+        """Run a Python file and show output."""
+        console.print(f"[dim]Running {path}...[/dim]")
+        output = run_file(path)
+        console.print(Panel(output, title=f"[cyan]{path}[/cyan]", border_style="cyan"))
+
+    @app.command()
+    def repo(
+        action: str = typer.Argument("map", help="map, ask"),
+        question: Optional[str] = typer.Argument(
+            None,
+            help="Question about the codebase",
+        ),
+        directory: Optional[str] = typer.Option(".", "--dir", "-d"),
+        model: Optional[str] = typer.Option(None, "--model", "-m"),
+    ):
+        """Understand your codebase: map structure or ask questions about it."""
+        if action == "map":
+            with console.status("[cyan]Mapping codebase...[/cyan]") as status:
+                result = build_repomap_result(
+                    directory,
+                    progress_callback=lambda stats: status.update(
+                        f"[cyan]Mapping codebase... {stats.scanned:,} files scanned[/cyan]"
+                    ),
+                )
+            console.print(Panel(
+                result.text,
+                title=f"[cyan]Repo Map — {directory}[/cyan]",
+                border_style="cyan",
+            ))
+        elif action == "ask" and question:
+            preferred = model or load_config()["default_model"]
+            context_window = get_model_config(preferred)["context_window"]
+            map_budget = max(2_000, min(20_000, context_window // 8))
+            with console.status("[cyan]Reading codebase...[/cyan]"):
+                repomap_prompt = get_repomap_prompt(
+                    directory,
+                    max_tokens=map_budget,
+                )
+            context.add("user", f"{repomap_prompt}\n\nQuestion: {question}")
+            console.print("[dim]── Answering about codebase ──[/dim]")
+            try:
+                content, used_model = stream_with_fallback(
+                    context.get_messages(),
+                    system=system_prompt,
+                    preferred=preferred,
+                )
+                context.add("assistant", content)
+                used_model = format_model_selection(used_model)
+                console.print(f"[dim]── {used_model} ──[/dim]")
+            except Exception as error:
+                show_error(str(error))
+        else:
+            console.print(
+                '[red]Usage: zai repo map | zai repo ask "how does auth work?"[/red]'
+            )
+
+    @app.command()
+    def vision(
+        image: str = typer.Argument(
+            ...,
+            help="Image file path (png/jpg/gif/webp)",
+        ),
+        prompt: str = typer.Option(
+            "Describe this image in detail.",
+            "--prompt",
+            "-p",
+        ),
+    ):
+        """Analyze a local image or screenshot with AI vision."""
+        try:
+            with console.status("[cyan]Analyzing image...[/cyan]"):
+                result, used_model = analyze_image(image, prompt)
+            console.print(f"[dim]── {used_model} vision ──[/dim]")
+            rprint(Panel(result, title=f"[cyan]{image}[/cyan]", border_style="cyan"))
+        except VisionError as error:
+            show_error(str(error))
+
+    @app.command()
+    def browser(
+        action: str = typer.Argument(..., help="scrape, screenshot, analyze"),
+        url: str = typer.Argument(..., help="URL to open"),
+        output: Optional[str] = typer.Option(
+            None,
+            "--out",
+            "-o",
+            help="Output file for screenshot",
+        ),
+        model: Optional[str] = typer.Option(None, "--model", "-m"),
+    ):
+        """Browser automation for public HTTP(S) webpages."""
+        try:
+            if action == "scrape":
+                with console.status(f"[cyan]Opening {url}...[/cyan]"):
+                    content = scrape(url)
+                console.print(Panel(
+                    content[:3000],
+                    title=f"[cyan]{url}[/cyan]",
+                    border_style="cyan",
+                ))
+            elif action == "screenshot":
+                output_path = output or "screenshot.png"
+                with console.status(f"[cyan]Taking screenshot of {url}...[/cyan]"):
+                    saved = screenshot(url, output_path)
+                console.print(f"[green]Screenshot saved:[/green] {saved}")
+            elif action == "analyze":
+                with console.status(f"[cyan]Loading {url}...[/cyan]"):
+                    content = scrape(url)
+                prompt = (
+                    "Analyze this webpage content and summarize what it is about:"
+                    f"\n\nURL: {url}\n\n{content}"
+                )
+                context.add("user", prompt)
+                with console.status("[cyan]Analyzing...[/cyan]"):
+                    response, _ = chat_with_fallback(
+                        context.get_messages(),
+                        system=system_prompt,
+                        preferred=model,
+                    )
+                context.add("assistant", response.content)
+                rprint(Panel(
+                    response.content,
+                    title=f"[cyan]Analysis — {url}[/cyan]",
+                    border_style="cyan",
+                ))
+            else:
+                console.print(
+                    "[red]Usage: zai browser scrape <url> | "
+                    "screenshot <url> | analyze <url>[/red]"
+                )
+        except BrowserError as error:
+            show_error(str(error))
+            if (
+                "playwright install" in str(error).lower()
+                or "not installed" in str(error).lower()
+            ):
+                console.print(
+                    "[dim]Fix: pip install playwright && "
+                    "playwright install chromium[/dim]"
+                )