orchid-cli 0.1.0__py3-none-any.whl

orchid_cli/__init__.py

@@ -0,0 +1 @@
+# Orchid CLI

orchid_cli/bootstrap.py

@@ -0,0 +1,186 @@
+"""
+Shared bootstrapping — load config, build graph, initialize persistence.
+
+Mirrors the lifespan logic from orchid-api but without FastAPI.
+SQLite storage is always initialized by default (no external DB required).
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import Any
+
+from orchid_ai.config.loader import load_config
+from orchid_ai.config.schema import AgentsConfig
+from orchid_ai.core.repository import VectorReader, VectorStoreAdmin
+from orchid_ai.graph.graph import build_graph
+from orchid_ai.persistence.base import ChatStorage
+from orchid_ai.persistence.factory import build_chat_storage
+from orchid_ai.rag.factory import build_reader
+
+logger = logging.getLogger(__name__)
+
+# ── YAML key → env var mapping (same as orchid-api/settings.py) ──────
+_YAML_TO_ENV: dict[tuple[str, str], str] = {
+    ("agents", "config_path"): "AGENTS_CONFIG_PATH",
+    ("llm", "model"): "LITELLM_MODEL",
+    ("llm", "ollama_api_base"): "OLLAMA_API_BASE",
+    ("llm", "groq_api_key"): "GROQ_API_KEY",
+    ("llm", "gemini_api_key"): "GEMINI_API_KEY",
+    ("llm", "anthropic_api_key"): "ANTHROPIC_API_KEY",
+    ("llm", "openai_api_key"): "OPENAI_API_KEY",
+    ("auth", "dev_bypass"): "DEV_AUTH_BYPASS",
+    ("auth", "identity_resolver_class"): "IDENTITY_RESOLVER_CLASS",
+    ("auth", "domain"): "AUTH_DOMAIN",
+    ("startup", "hook"): "STARTUP_HOOK",
+    ("rag", "vector_backend"): "VECTOR_BACKEND",
+    ("rag", "qdrant_url"): "QDRANT_URL",
+    ("rag", "embedding_model"): "EMBEDDING_MODEL",
+    ("rag", "openai_api_key"): "OPENAI_API_KEY",
+    ("rag", "gemini_api_key"): "GEMINI_API_KEY",
+    ("upload", "vision_model"): "VISION_MODEL",
+    ("upload", "namespace"): "UPLOAD_NAMESPACE",
+    ("upload", "max_size_mb"): "UPLOAD_MAX_SIZE_MB",
+    ("upload", "chunk_size"): "CHUNK_SIZE",
+    ("upload", "chunk_overlap"): "CHUNK_OVERLAP",
+    ("storage", "class"): "CHAT_STORAGE_CLASS",
+    ("storage", "dsn"): "CHAT_DB_DSN",
+    ("mcp", "catalog_url"): "MCP_CATALOG_URL",
+    ("mcp", "notifications_url"): "MCP_NOTIFICATIONS_URL",
+    ("tracing", "langsmith_tracing"): "LANGSMITH_TRACING",
+    ("tracing", "langsmith_api_key"): "LANGSMITH_API_KEY",
+    ("tracing", "langsmith_project"): "LANGSMITH_PROJECT",
+}
+
+
+def _apply_yaml_to_env(config_path: str) -> None:
+    """Parse orchid.yml and export values as env vars (if not already set).
+
+    Storage settings (class, dsn) are skipped — the CLI has its own
+    defaults (SQLite at ~/.orchid/chats.db) that are more appropriate
+    than Docker-oriented paths often found in orchid.yml.
+    """
+    try:
+        import yaml
+
+        with open(config_path) as f:
+            data = yaml.safe_load(f) or {}
+    except FileNotFoundError:
+        logger.warning("[CLI] Config file %s not found — ignoring", config_path)
+        return
+
+    # Storage config in orchid.yml is typically Docker-oriented (e.g. /data/chats.db).
+    # The CLI defaults to ~/.orchid/chats.db which is always writable.
+    _SKIP_SECTIONS = {"storage"}
+
+    for section, body in data.items():
+        if not isinstance(body, dict) or section in _SKIP_SECTIONS:
+            continue
+        for key, value in body.items():
+            env_var = _YAML_TO_ENV.get((section, key))
+            if env_var and env_var not in os.environ:
+                os.environ[env_var] = str(value)
+
+    logger.debug("[CLI] Applied YAML config from %s", config_path)
+
+
+# Defaults — SQLite storage ships with orchid, no external DB needed
+DEFAULT_STORAGE_CLASS = "orchid_ai.persistence.sqlite.SQLiteChatStorage"
+DEFAULT_STORAGE_DSN = "~/.orchid/chats.db"
+
+
+@dataclass
+class OrchidContext:
+    """Runtime context for CLI operations."""
+
+    graph: Any
+    reader: VectorReader
+    chat_repo: ChatStorage
+    config: AgentsConfig
+    model: str
+
+
+async def bootstrap(
+    config_path: str,
+    *,
+    model: str = "",
+    vector_backend: str = "",
+    qdrant_url: str = "",
+    embedding_model: str = "",
+    chat_storage_class: str = "",
+    chat_db_dsn: str = "",
+) -> OrchidContext:
+    """
+    Load config, build reader, build graph — return a ready-to-use context.
+
+    Chat storage is always initialized (defaults to SQLite at ~/.orchid/chats.db).
+    """
+    # Apply YAML config to environment — mirrors orchid-api/settings.py:_apply_yaml_config()
+    if config_path:
+        os.environ.setdefault("ORCHID_CONFIG", config_path)
+        _apply_yaml_to_env(config_path)
+
+    # Load YAML agent config
+    agents_config_path = os.environ.get("AGENTS_CONFIG_PATH", "agents.yaml")
+    agents_config = load_config(agents_config_path)
+
+    # Resolve defaults from env
+    resolved_model = model or os.environ.get("LITELLM_MODEL", "ollama/llama3.2")
+    resolved_backend = vector_backend or os.environ.get("VECTOR_BACKEND", "qdrant")
+    resolved_qdrant_url = qdrant_url or os.environ.get("QDRANT_URL", "http://qdrant:6333")
+    resolved_embedding = embedding_model or os.environ.get("EMBEDDING_MODEL", "text-embedding-3-small")
+
+    # Build reader
+    reader = build_reader(
+        vector_backend=resolved_backend,
+        qdrant_url=resolved_qdrant_url,
+        embedding_model=resolved_embedding,
+    )
+
+    # Ensure collections
+    if isinstance(reader, VectorStoreAdmin):
+        namespaces = [a.rag.namespace for a in agents_config.agents.values() if a.rag.enabled and a.rag.namespace]
+        if namespaces:
+            await reader.ensure_collections([*namespaces, "uploads"])
+
+    # Chat persistence — always initialized, defaults to SQLite
+    resolved_storage_class = chat_storage_class or os.environ.get("CHAT_STORAGE_CLASS", "") or DEFAULT_STORAGE_CLASS
+    resolved_dsn = chat_db_dsn or os.environ.get("CHAT_DB_DSN", "") or DEFAULT_STORAGE_DSN
+    chat_repo = build_chat_storage(class_path=resolved_storage_class, dsn=resolved_dsn)
+    await chat_repo.init_db()
+
+    # Build graph
+    graph = build_graph(
+        config=agents_config,
+        default_model=resolved_model,
+        reader=reader,
+    )
+
+    logger.info(
+        "[CLI] Ready — model=%s, backend=%s, storage=%s, agents=%s",
+        resolved_model,
+        resolved_backend,
+        resolved_storage_class.rsplit(".", 1)[-1],
+        list(agents_config.agents.keys()),
+    )
+
+    return OrchidContext(
+        graph=graph,
+        reader=reader,
+        chat_repo=chat_repo,
+        config=agents_config,
+        model=resolved_model,
+    )
+
+
+@asynccontextmanager
+async def cli_context(config_path: str, *, model: str = ""):
+    """Bootstrap and ensure clean shutdown (closes aiosqlite before event loop exits)."""
+    ctx = await bootstrap(config_path, model=model)
+    try:
+        yield ctx
+    finally:
+        await ctx.chat_repo.close()

orchid_cli/commands/__init__.py

@@ -0,0 +1 @@
+# CLI commands package

orchid_cli/commands/chat.py

@@ -0,0 +1,428 @@
+"""
+Chat commands — full CRUD + message send with persistence.
+
+Mirrors orchid-api chat endpoints:
+    orchid chat create [--title "My Chat"]
+    orchid chat list
+    orchid chat delete <chat_id>
+    orchid chat history <chat_id>
+    orchid chat send <chat_id> "message"
+    orchid chat interactive [--chat <chat_id>]
+    orchid chat rename <chat_id> "new title"
+    orchid chat share <chat_id>
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Optional
+
+import typer
+from langchain_core.messages import AIMessage, HumanMessage
+from rich.console import Console
+from rich.table import Table
+
+from orchid_ai.core.state import AuthContext
+
+from ..bootstrap import cli_context
+
+app = typer.Typer(help="Chat management and messaging", no_args_is_help=True)
+console = Console()
+
+# CLI uses a fixed auth context — no OAuth needed
+_CLI_AUTH = AuthContext(
+    access_token="cli-token",
+    tenant_key="cli",
+    user_id="cli-user",
+)
+
+
+# ── Chat CRUD ───────────────────────────────────────────────
+
+
+@app.command()
+def create(
+    title: str = typer.Option("New chat", "--title", "-t", help="Chat title"),
+    config: str = typer.Option("", "--config", "-c", help="Path to orchid.yml"),
+    model: str = typer.Option("", "--model", "-m", help="Override LLM model"),
+):
+    """Create a new chat session."""
+    asyncio.run(_create(title, config, model))
+
+
+async def _create(title: str, config_path: str, model: str) -> None:
+    async with cli_context(config_path, model=model) as ctx:
+        session = await ctx.chat_repo.create_chat(
+            tenant_id=_CLI_AUTH.tenant_key,
+            user_id=_CLI_AUTH.user_id,
+            title=title,
+        )
+        console.print(f"[bold green]Created:[/bold green] {session.id}")
+        console.print(f"  Title: {session.title}")
+        console.print(f"  Created: {session.created_at.isoformat()}")
+
+
+@app.command("list")
+def list_chats(
+    config: str = typer.Option("", "--config", "-c", help="Path to orchid.yml"),
+    model: str = typer.Option("", "--model", "-m", help="Override LLM model"),
+):
+    """List all chat sessions."""
+    asyncio.run(_list_chats(config, model))
+
+
+async def _list_chats(config_path: str, model: str) -> None:
+    async with cli_context(config_path, model=model) as ctx:
+        sessions = await ctx.chat_repo.list_chats(
+            tenant_id=_CLI_AUTH.tenant_key,
+            user_id=_CLI_AUTH.user_id,
+        )
+
+        if not sessions:
+            console.print("[dim]No chats found. Use 'orchid chat create' to start one.[/dim]")
+            return
+
+        table = Table(title="Chat Sessions")
+        table.add_column("ID", style="cyan", no_wrap=True)
+        table.add_column("Title", style="white")
+        table.add_column("Messages", justify="right")
+        table.add_column("Updated", style="dim")
+        table.add_column("Shared", justify="center")
+
+        for s in sessions:
+            messages = await ctx.chat_repo.get_messages(s.id, limit=1000)
+            table.add_row(
+                s.id[:12] + "…",
+                s.title[:40],
+                str(len(messages)),
+                s.updated_at.strftime("%Y-%m-%d %H:%M"),
+                "✓" if s.is_shared else "",
+            )
+
+        console.print(table)
+
+
+@app.command()
+def delete(
+    chat_id: str = typer.Argument(..., help="Chat ID (or prefix)"),
+    config: str = typer.Option("", "--config", "-c", help="Path to orchid.yml"),
+    model: str = typer.Option("", "--model", "-m", help="Override LLM model"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+):
+    """Delete a chat session and all its messages."""
+    asyncio.run(_delete(chat_id, config, model, force))
+
+
+async def _delete(chat_id: str, config_path: str, model: str, force: bool) -> None:
+    async with cli_context(config_path, model=model) as ctx:
+        resolved_id = await _resolve_chat_id(ctx, chat_id)
+        if not resolved_id:
+            return
+
+        chat = await ctx.chat_repo.get_chat(resolved_id)
+        if not force:
+            confirm = typer.confirm(f"Delete chat '{chat.title}' ({resolved_id[:12]}…)?")
+            if not confirm:
+                console.print("[dim]Cancelled.[/dim]")
+                return
+
+        await ctx.chat_repo.delete_chat(resolved_id)
+        console.print(f"[bold red]Deleted:[/bold red] {resolved_id[:12]}…")
+
+
+@app.command()
+def history(
+    chat_id: str = typer.Argument(..., help="Chat ID (or prefix)"),
+    limit: int = typer.Option(50, "--limit", "-n", help="Max messages to show"),
+    config: str = typer.Option("", "--config", "-c", help="Path to orchid.yml"),
+    model: str = typer.Option("", "--model", "-m", help="Override LLM model"),
+):
+    """Show message history for a chat."""
+    asyncio.run(_history(chat_id, limit, config, model))
+
+
+async def _history(chat_id: str, limit: int, config_path: str, model: str) -> None:
+    async with cli_context(config_path, model=model) as ctx:
+        resolved_id = await _resolve_chat_id(ctx, chat_id)
+        if not resolved_id:
+            return
+
+        chat = await ctx.chat_repo.get_chat(resolved_id)
+        messages = await ctx.chat_repo.get_messages(resolved_id, limit=limit)
+
+        console.print(f"[bold]{chat.title}[/bold] ({resolved_id[:12]}…)")
+        console.print()
+
+        if not messages:
+            console.print("[dim]No messages yet.[/dim]")
+            return
+
+        for msg in messages:
+            if msg.role == "user":
+                console.print(f"[bold cyan]You:[/bold cyan] {msg.content}")
+            elif msg.role == "assistant":
+                console.print(f"[bold green]Assistant:[/bold green] {msg.content}")
+                if msg.agents_used:
+                    console.print(f"  [dim]Agents: {', '.join(msg.agents_used)}[/dim]")
+            else:
+                console.print(f"[dim]{msg.role}: {msg.content}[/dim]")
+            console.print()
+
+
+@app.command()
+def rename(
+    chat_id: str = typer.Argument(..., help="Chat ID (or prefix)"),
+    title: str = typer.Argument(..., help="New title"),
+    config: str = typer.Option("", "--config", "-c", help="Path to orchid.yml"),
+    model: str = typer.Option("", "--model", "-m", help="Override LLM model"),
+):
+    """Rename a chat session."""
+    asyncio.run(_rename(chat_id, title, config, model))
+
+
+async def _rename(chat_id: str, title: str, config_path: str, model: str) -> None:
+    async with cli_context(config_path, model=model) as ctx:
+        resolved_id = await _resolve_chat_id(ctx, chat_id)
+        if not resolved_id:
+            return
+
+        await ctx.chat_repo.update_title(resolved_id, title)
+        console.print(f"[bold]Renamed:[/bold] {resolved_id[:12]}… → {title}")
+
+
+@app.command()
+def share(
+    chat_id: str = typer.Argument(..., help="Chat ID (or prefix)"),
+    config: str = typer.Option("", "--config", "-c", help="Path to orchid.yml"),
+    model: str = typer.Option("", "--model", "-m", help="Override LLM model"),
+):
+    """Mark a chat as shared."""
+    asyncio.run(_share(chat_id, config, model))
+
+
+async def _share(chat_id: str, config_path: str, model: str) -> None:
+    async with cli_context(config_path, model=model) as ctx:
+        resolved_id = await _resolve_chat_id(ctx, chat_id)
+        if not resolved_id:
+            return
+
+        await ctx.chat_repo.mark_shared(resolved_id)
+        console.print(f"[bold]Shared:[/bold] {resolved_id[:12]}…")
+
+
+# ── Messaging ───────────────────────────────────────────────
+
+
+@app.command()
+def send(
+    chat_id: str = typer.Argument(..., help="Chat ID (or prefix)"),
+    message: str = typer.Argument(..., help="The message to send"),
+    config: str = typer.Option("", "--config", "-c", help="Path to orchid.yml"),
+    model: str = typer.Option("", "--model", "-m", help="Override LLM model"),
+):
+    """Send a message to a chat and print the response."""
+    asyncio.run(_send(chat_id, message, config, model))
+
+
+async def _send(chat_id: str, message: str, config_path: str, model: str) -> None:
+    async with cli_context(config_path, model=model) as ctx:
+        resolved_id = await _resolve_chat_id(ctx, chat_id)
+        if not resolved_id:
+            return
+
+        response_text, agents_used = await _send_message(ctx, resolved_id, message)
+
+        console.print()
+        console.print(response_text)
+        if agents_used:
+            console.print(f"\n[dim]Agents used: {', '.join(agents_used)}[/dim]")
+
+
+@app.command()
+def interactive(
+    chat_id: Optional[str] = typer.Argument(None, help="Chat ID to resume (or prefix). Creates new if omitted."),
+    config: str = typer.Option("", "--config", "-c", help="Path to orchid.yml"),
+    model: str = typer.Option("", "--model", "-m", help="Override LLM model"),
+):
+    """Start an interactive chat REPL with full persistence."""
+    asyncio.run(_interactive(chat_id, config, model))
+
+
+async def _interactive(chat_id: str | None, config_path: str, model: str) -> None:
+    async with cli_context(config_path, model=model) as ctx:
+        # Resolve or create a chat
+        if chat_id:
+            resolved_id = await _resolve_chat_id(ctx, chat_id)
+            if not resolved_id:
+                return
+            chat = await ctx.chat_repo.get_chat(resolved_id)
+            console.print(f"[bold]Resuming:[/bold] {chat.title} ({resolved_id[:12]}…)")
+        else:
+            chat = await ctx.chat_repo.create_chat(
+                tenant_id=_CLI_AUTH.tenant_key,
+                user_id=_CLI_AUTH.user_id,
+                title="Interactive session",
+            )
+            resolved_id = chat.id
+            console.print(f"[bold]New chat:[/bold] {resolved_id[:12]}…")
+
+        console.print()
+        console.print("[bold]Orchid Interactive Chat[/bold]")
+        console.print("Commands: /quit, /switch <id>, /list, /new [title], /history, /rename <title>")
+        console.print()
+
+        current_chat_id = resolved_id
+
+        while True:
+            try:
+                user_input = console.input("[bold cyan]You:[/bold cyan] ")
+            except (EOFError, KeyboardInterrupt):
+                break
+
+            stripped = user_input.strip()
+            if not stripped:
+                continue
+
+            # Handle slash commands
+            if stripped.startswith("/"):
+                parts = stripped.split(maxsplit=1)
+                cmd = parts[0].lower()
+                arg = parts[1] if len(parts) > 1 else ""
+
+                if cmd in ("/quit", "/exit", "/q"):
+                    break
+
+                elif cmd == "/list":
+                    sessions = await ctx.chat_repo.list_chats(
+                        tenant_id=_CLI_AUTH.tenant_key,
+                        user_id=_CLI_AUTH.user_id,
+                    )
+                    if not sessions:
+                        console.print("[dim]No chats.[/dim]")
+                    else:
+                        for s in sessions:
+                            marker = " [bold]← current[/bold]" if s.id == current_chat_id else ""
+                            console.print(f"  {s.id[:12]}…  {s.title}{marker}")
+                    console.print()
+                    continue
+
+                elif cmd == "/switch":
+                    if not arg:
+                        console.print("[red]Usage: /switch <chat_id>[/red]")
+                        continue
+                    new_id = await _resolve_chat_id(ctx, arg)
+                    if new_id:
+                        current_chat_id = new_id
+                        chat = await ctx.chat_repo.get_chat(current_chat_id)
+                        console.print(f"[bold]Switched to:[/bold] {chat.title} ({current_chat_id[:12]}…)\n")
+                    continue
+
+                elif cmd == "/new":
+                    title = arg or "Interactive session"
+                    new_chat = await ctx.chat_repo.create_chat(
+                        tenant_id=_CLI_AUTH.tenant_key,
+                        user_id=_CLI_AUTH.user_id,
+                        title=title,
+                    )
+                    current_chat_id = new_chat.id
+                    console.print(f"[bold green]New chat:[/bold green] {current_chat_id[:12]}… — {title}\n")
+                    continue
+
+                elif cmd == "/history":
+                    messages = await ctx.chat_repo.get_messages(current_chat_id, limit=20)
+                    if not messages:
+                        console.print("[dim]No messages yet.[/dim]\n")
+                    else:
+                        for msg in messages:
+                            if msg.role == "user":
+                                console.print(f"  [cyan]You:[/cyan] {msg.content[:80]}")
+                            elif msg.role == "assistant":
+                                console.print(f"  [green]Asst:[/green] {msg.content[:80]}")
+                        console.print()
+                    continue
+
+                elif cmd == "/rename":
+                    if not arg:
+                        console.print("[red]Usage: /rename <new title>[/red]")
+                        continue
+                    await ctx.chat_repo.update_title(current_chat_id, arg)
+                    console.print(f"[bold]Renamed:[/bold] {arg}\n")
+                    continue
+
+                else:
+                    console.print(f"[red]Unknown command: {cmd}[/red]")
+                    continue
+
+            # Send message
+            response_text, agents_used = await _send_message(ctx, current_chat_id, stripped)
+            console.print(f"\n[bold green]Assistant:[/bold green] {response_text}")
+            if agents_used:
+                console.print(f"  [dim]Agents: {', '.join(agents_used)}[/dim]")
+            console.print()
+
+        console.print("\n[dim]Session ended.[/dim]")
+
+
+# ── Helpers ─────────────────────────────────────────────────
+
+
+async def _send_message(ctx, chat_id: str, message: str) -> tuple[str, list[str]]:
+    """Send a message through the graph, persist to storage, return (response, agents_used)."""
+    # Load history
+    history_rows = await ctx.chat_repo.get_messages(chat_id, limit=50)
+    history_messages = []
+    for row in history_rows:
+        if row.role == "user":
+            history_messages.append(HumanMessage(content=row.content, id=row.id))
+        elif row.role == "assistant":
+            history_messages.append(AIMessage(content=row.content, id=row.id))
+
+    initial_state = {
+        "messages": history_messages + [HumanMessage(content=message)],
+        "auth_context": _CLI_AUTH,
+        "chat_id": chat_id,
+    }
+
+    result = await ctx.graph.ainvoke(initial_state)
+
+    response_text = result.get("final_response", "No response generated.")
+    agents_used = result.get("active_agents", [])
+
+    # Persist original message + response
+    await ctx.chat_repo.add_message(chat_id, "user", message)
+    await ctx.chat_repo.add_message(chat_id, "assistant", response_text, agents_used=agents_used)
+
+    # Auto-title from first message
+    if not history_rows:
+        title = message[:50].strip()
+        if len(message) > 50:
+            title += "…"
+        await ctx.chat_repo.update_title(chat_id, title)
+
+    return response_text, agents_used
+
+
+async def _resolve_chat_id(ctx, chat_id_prefix: str) -> str | None:
+    """Resolve a chat ID prefix to a full ID. Prints error if not found."""
+    # Try exact match first
+    chat = await ctx.chat_repo.get_chat(chat_id_prefix)
+    if chat and chat.user_id == _CLI_AUTH.user_id:
+        return chat.id
+
+    # Try prefix match
+    sessions = await ctx.chat_repo.list_chats(
+        tenant_id=_CLI_AUTH.tenant_key,
+        user_id=_CLI_AUTH.user_id,
+    )
+    matches = [s for s in sessions if s.id.startswith(chat_id_prefix)]
+
+    if len(matches) == 1:
+        return matches[0].id
+    elif len(matches) > 1:
+        console.print(f"[red]Ambiguous prefix '{chat_id_prefix}' — matches {len(matches)} chats:[/red]")
+        for s in matches:
+            console.print(f"  {s.id[:12]}…  {s.title}")
+        return None
+    else:
+        console.print(f"[red]Chat not found: {chat_id_prefix}[/red]")
+        return None

orchid_cli/commands/config.py

@@ -0,0 +1,38 @@
+"""
+Config command — validate YAML configuration files.
+
+Usage:
+    orchid config validate examples/basketball/orchid.yml
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from orchid_ai.config.loader import load_config
+
+app = typer.Typer(help="Configuration management", no_args_is_help=True)
+console = Console()
+
+
+@app.command()
+def validate(
+    config_path: str = typer.Argument(..., help="Path to agents.yaml config file"),
+):
+    """Validate an agents.yaml configuration file."""
+    try:
+        config = load_config(config_path)
+        console.print(f"[green]Valid[/green] — {len(config.agents)} agent(s) configured:")
+        for name, agent_cfg in config.agents.items():
+            desc = agent_cfg.description[:60] if agent_cfg.description else "(no description)"
+            cls = agent_cfg.class_path or "GenericAgent"
+            console.print(f"  [bold]{name}[/bold] ({cls}) — {desc}")
+
+        if config.supervisor:
+            console.print(f"\n  Supervisor: assistant_name={config.supervisor.assistant_name!r}")
+        if config.skills:
+            console.print(f"  Orchestrator skills: {len(config.skills)}")
+    except Exception as exc:
+        console.print(f"[red]Invalid[/red] — {exc}")
+        raise typer.Exit(code=1)

orchid_cli/commands/index.py

@@ -0,0 +1,45 @@
+"""
+Index command — seed the vector store with data.
+
+Usage:
+    orchid index seed --config examples/basketball/orchid.yml --tenant default
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+from rich.console import Console
+
+from orchid_ai.core.repository import VectorWriter
+from orchid_ai.rag.indexer import StaticIndexer
+
+
+app = typer.Typer(help="Vector store indexing", no_args_is_help=True)
+console = Console()
+
+
+@app.command()
+def seed(
+    config: str = typer.Option("", "--config", "-c", help="Path to orchid.yml"),
+    tenant: str = typer.Option("default", "--tenant", "-t", help="Tenant ID for indexing"),
+):
+    """Seed the vector store with static data."""
+    asyncio.run(_seed(config, tenant))
+
+
+async def _seed(config_path: str, tenant: str) -> None:
+    from ..bootstrap import cli_context
+
+    async with cli_context(config_path) as ctx:
+        if not isinstance(ctx.reader, VectorWriter):
+            console.print("[red]Error:[/red] Vector store does not support writing (backend may be 'null')")
+            raise typer.Exit(code=1)
+
+        indexer = StaticIndexer(writer=ctx.reader)
+        counts = await indexer.index_all(tenant_key=tenant)
+
+        console.print(f"[green]Indexed[/green] for tenant={tenant}:")
+        for namespace, count in counts.items():
+            console.print(f"  {namespace}: {count} document(s)")

orchid_cli/commands/skill.py

@@ -0,0 +1,539 @@
+"""
+Skill command — generate Claude Code skills from Orchid agent configuration.
+
+Usage:
+    orchid skill generate examples/basketball/agents.yaml --output .claude/skills
+    orchid skill generate examples/helpdesk/config/agents.yaml -o ./skills --include basketball,psychologist
+"""
+
+from __future__ import annotations
+
+import importlib
+import inspect
+import shutil
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from orchid_ai.config.loader import load_config
+from orchid_ai.config.schema import (
+    AgentConfig,
+    AgentsConfig,
+    BuiltinToolConfig,
+    OrchestratorSkillConfig,
+)
+
+app = typer.Typer(help="Generate Claude Code skills from Orchid config", no_args_is_help=True)
+console = Console()
+
+
+# ── Public command ────────────────────────────────────────────────
+
+
+@app.command()
+def generate(
+    config_path: str = typer.Argument(..., help="Path to agents.yaml config file"),
+    output: str = typer.Option(".claude/skills", "-o", "--output", help="Output directory for generated skills"),
+    include: str | None = typer.Option(
+        None, "--include", help="Comma-separated agent/skill names to include (default: all)"
+    ),
+    overwrite: bool = typer.Option(False, "--overwrite", help="Overwrite existing skill directories"),
+    zip_archive: bool = typer.Option(False, "--zip", help="Create a zip archive of the generated skills"),
+) -> None:
+    """Generate Claude Code skill folders from an Orchid agents.yaml configuration."""
+    try:
+        config = load_config(config_path)
+    except Exception as exc:
+        console.print(f"[red]Error loading config:[/red] {exc}")
+        raise typer.Exit(code=1)
+
+    out_dir = Path(output)
+    include_set = {n.strip() for n in include.split(",")} if include else None
+
+    generated: list[str] = []
+    skipped: list[str] = []
+
+    # Generate agent skills
+    for agent_name, agent_cfg in config.agents.items():
+        if include_set and agent_name not in include_set:
+            continue
+        skill_dir = out_dir / agent_name
+        if skill_dir.exists() and not overwrite:
+            skipped.append(agent_name)
+            continue
+        _generate_agent_skill(skill_dir, agent_name, agent_cfg, config)
+        generated.append(agent_name)
+
+    # Generate orchestrator skills
+    for skill_name, skill_cfg in config.skills.items():
+        if include_set and skill_name not in include_set:
+            continue
+        skill_dir = out_dir / skill_name
+        if skill_dir.exists() and not overwrite:
+            skipped.append(skill_name)
+            continue
+        _generate_orchestrator_skill(skill_dir, skill_name, skill_cfg, config)
+        generated.append(skill_name)
+
+    # Summary
+    if generated:
+        console.print(f"\n[green]Generated {len(generated)} skill(s):[/green]")
+        for name in generated:
+            console.print(f"  [bold]{out_dir / name}/SKILL.md[/bold]")
+    if skipped:
+        console.print(f"\n[yellow]Skipped {len(skipped)} (already exist, use --overwrite):[/yellow]")
+        for name in skipped:
+            console.print(f"  {name}")
+    if not generated and not skipped:
+        console.print("[yellow]No agents or skills matched the filter.[/yellow]")
+
+    # Create zip archive if requested
+    if zip_archive and generated:
+        zip_path = Path(f"{output.rstrip('/')}.zip")
+        shutil.make_archive(str(zip_path.with_suffix("")), "zip", root_dir=out_dir.parent, base_dir=out_dir.name)
+        console.print(f"\n[green]Archive created:[/green] [bold]{zip_path}[/bold]")
+
+
+# ── Agent skill generation ────────────────────────────────────────
+
+
+def _generate_agent_skill(
+    skill_dir: Path,
+    agent_name: str,
+    agent_cfg: AgentConfig,
+    config: AgentsConfig,
+) -> None:
+    """Generate a Claude Code skill directory for one Orchid agent."""
+    skill_dir.mkdir(parents=True, exist_ok=True)
+
+    # Generate executable scripts for built-in tools
+    tool_scripts = _generate_tool_scripts(skill_dir, agent_cfg, config)
+
+    # Build SKILL.md
+    skill_md = _build_agent_skill_md(agent_name, agent_cfg, config, tool_scripts)
+    (skill_dir / "SKILL.md").write_text(skill_md, encoding="utf-8")
+
+
+def _build_agent_skill_md(
+    agent_name: str,
+    agent_cfg: AgentConfig,
+    config: AgentsConfig,
+    tool_scripts: dict[str, _ToolScriptInfo],
+) -> str:
+    """Build the SKILL.md content for an Orchid agent."""
+    parts: list[str] = []
+
+    # ── Frontmatter ──
+    description = _clean_description(agent_cfg.description)
+    allowed: list[str] = []
+    if tool_scripts:
+        allowed.append("Bash(python *)")
+    frontmatter_lines = [
+        "---",
+        f"name: {agent_name}",
+        f'description: "{_truncate(description, 240)}"',
+    ]
+    if allowed:
+        frontmatter_lines.append(f'allowed-tools: "{" ".join(allowed)}"')
+    frontmatter_lines.append("---")
+    parts.append("\n".join(frontmatter_lines) + "\n")
+
+    # ── Title + origin ──
+    parts.append(f"# {agent_name}\n")
+    parts.append(
+        f"> Auto-generated from Orchid agent configuration. "
+        f"This skill replicates the knowledge and instructions of the `{agent_name}` agent.\n"
+    )
+
+    # ── Agent system prompt (the core value) ──
+    parts.append("## Instructions\n")
+    parts.append(agent_cfg.prompt.strip() + "\n")
+
+    # ── Built-in tools as executable scripts ──
+    if tool_scripts:
+        parts.append("## Available Tools\n")
+        parts.append(
+            "This skill includes executable Python scripts for each built-in tool. Run them to get real results.\n"
+        )
+        for tool_name, info in tool_scripts.items():
+            tool_cfg = config.tools.get(tool_name)
+            desc = tool_cfg.description if tool_cfg else ""
+            parts.append(f"### {tool_name}\n")
+            if desc:
+                parts.append(f"{desc}\n")
+            # Show usage with the actual parameters
+            parts.append(f"```bash\npython ${{CLAUDE_SKILL_DIR}}/scripts/{info.script_name} {info.usage_hint}\n```\n")
+            if info.parameters:
+                parts.append("**Parameters:**\n")
+                for param_name, param_desc in info.parameters.items():
+                    parts.append(f"- `{param_name}`: {param_desc}")
+                parts.append("")
+
+    # ── MCP servers (informational, not portable) ──
+    if agent_cfg.mcp_servers:
+        parts.append("## External Integrations (Orchid Runtime Required)\n")
+        parts.append(
+            "The following MCP server integrations are available in the Orchid runtime "
+            "but cannot be used directly in Claude Code skills.\n"
+        )
+        for srv in agent_cfg.mcp_servers:
+            tool_list = ", ".join(t.name for t in srv.tools) if srv.tools else "(all)"
+            parts.append(f"- **{srv.name}** ({srv.transport}): tools = {tool_list}")
+        parts.append("")
+
+    # ── Agent-level skills (workflows) ──
+    if agent_cfg.skills:
+        parts.append("## Workflows\n")
+        parts.append(
+            "The original agent supports these multi-step workflows. "
+            "Follow these step sequences when the user's request matches.\n"
+        )
+        for skill_name, skill_cfg in agent_cfg.skills.items():
+            parts.append(f"### {skill_name}\n")
+            if skill_cfg.description:
+                parts.append(f"{skill_cfg.description.strip()}\n")
+            parts.append("**Steps:**\n")
+            for i, step in enumerate(skill_cfg.steps, 1):
+                if step.tool:
+                    info = tool_scripts.get(step.tool)
+                    if info:
+                        parts.append(
+                            f"{i}. Run `python ${{CLAUDE_SKILL_DIR}}/scripts/{info.script_name} {info.usage_hint}`"
+                        )
+                    else:
+                        src = f" (from {step.source})" if step.source else ""
+                        parts.append(f"{i}. Call tool `{step.tool}`{src}")
+                elif step.agent:
+                    parts.append(f"{i}. Delegate to agent `{step.agent}`: {step.instruction}")
+            parts.append("")
+
+    # ── RAG context note ──
+    if agent_cfg.rag.enabled:
+        ns = agent_cfg.rag.namespace or agent_name
+        parts.append("## RAG Context (Orchid Runtime Required)\n")
+        parts.append(
+            f"In the Orchid runtime, this agent retrieves contextual documents from "
+            f"the `{ns}` namespace (top-{agent_cfg.rag.k} results). "
+            f"This capability is not available in the Claude Code skill.\n"
+        )
+
+    return "\n".join(parts)
+
+
+# ── Orchestrator skill generation ─────────────────────────────────
+
+
+def _generate_orchestrator_skill(
+    skill_dir: Path,
+    skill_name: str,
+    skill_cfg: OrchestratorSkillConfig,
+    config: AgentsConfig,
+) -> None:
+    """Generate a Claude Code skill directory for an Orchid orchestrator skill."""
+    skill_dir.mkdir(parents=True, exist_ok=True)
+
+    skill_md = _build_orchestrator_skill_md(skill_name, skill_cfg, config)
+    (skill_dir / "SKILL.md").write_text(skill_md, encoding="utf-8")
+
+
+def _build_orchestrator_skill_md(
+    skill_name: str,
+    skill_cfg: OrchestratorSkillConfig,
+    config: AgentsConfig,
+) -> str:
+    """Build the SKILL.md content for an Orchid orchestrator skill."""
+    parts: list[str] = []
+
+    description = _clean_description(skill_cfg.description)
+    parts.append(f'---\nname: {skill_name.replace("_", "-")}\ndescription: "{_truncate(description, 240)}"\n---\n')
+
+    parts.append(f"# {skill_name.replace('_', ' ').title()}\n")
+    parts.append(
+        "> Auto-generated from Orchid orchestrator skill. "
+        "This is a multi-agent workflow that coordinates several specialists.\n"
+    )
+
+    if skill_cfg.description:
+        parts.append("## Purpose\n")
+        parts.append(skill_cfg.description.strip() + "\n")
+
+    # ── Workflow steps ──
+    parts.append("## Workflow Steps\n")
+    parts.append("Execute these steps in order. Each step's output feeds into the next.\n")
+    for i, step in enumerate(skill_cfg.steps, 1):
+        agent_cfg = config.agents.get(step.agent)
+        agent_desc = _clean_description(agent_cfg.description) if agent_cfg else ""
+        parts.append(f"### Step {i}: {step.agent}\n")
+        if agent_desc:
+            parts.append(f"*Agent role: {agent_desc}*\n")
+        if step.instruction:
+            parts.append(f"**Instruction:** {step.instruction}\n")
+        # Include the agent's prompt as context
+        if agent_cfg:
+            parts.append("<details>\n<summary>Agent system prompt</summary>\n")
+            parts.append(f"```\n{agent_cfg.prompt.strip()}\n```\n")
+            parts.append("</details>\n")
+
+    # ── Participating agents summary ──
+    agent_names = [s.agent for s in skill_cfg.steps]
+    parts.append("## Participating Agents\n")
+    for name in dict.fromkeys(agent_names):  # unique, preserving order
+        agent_cfg = config.agents.get(name)
+        if agent_cfg:
+            desc = _clean_description(agent_cfg.description)
+            parts.append(f"- **{name}**: {desc}")
+    parts.append("")
+
+    return "\n".join(parts)
+
+
+# ── Tool script generation ────────────────────────────────────────
+
+
+class _ToolScriptInfo:
+    """Metadata about a generated tool script."""
+
+    __slots__ = ("script_name", "usage_hint", "parameters")
+
+    def __init__(self, script_name: str, usage_hint: str, parameters: dict[str, str]) -> None:
+        self.script_name = script_name
+        self.usage_hint = usage_hint
+        self.parameters = parameters
+
+
+def _generate_tool_scripts(
+    skill_dir: Path,
+    agent_cfg: AgentConfig,
+    config: AgentsConfig,
+) -> dict[str, _ToolScriptInfo]:
+    """Generate executable Python scripts for each built-in tool.
+
+    Groups tools from the same source module into a single script file.
+    Returns a mapping of tool_name -> _ToolScriptInfo.
+    """
+    tool_names = agent_cfg.tools
+    if not tool_names:
+        return {}
+
+    scripts_dir = skill_dir / "scripts"
+    scripts_dir.mkdir(parents=True, exist_ok=True)
+
+    # Group tools by source module path
+    module_tools: dict[str, list[tuple[str, BuiltinToolConfig]]] = {}
+    for tool_name in tool_names:
+        tool_cfg = config.tools.get(tool_name)
+        if not tool_cfg:
+            continue
+        module_path = tool_cfg.handler.rsplit(".", 1)[0]
+        module_tools.setdefault(module_path, []).append((tool_name, tool_cfg))
+
+    result: dict[str, _ToolScriptInfo] = {}
+
+    for module_path, tools_in_module in module_tools.items():
+        # Read the source file of the module
+        source = _read_module_source(module_path)
+        if source is None:
+            continue
+
+        # Determine script filename from the last part of the module path
+        module_short_name = module_path.rsplit(".", 1)[-1]
+        script_name = f"{module_short_name}.py"
+
+        # Build the __main__ CLI wrapper
+        cli_wrapper = _build_cli_wrapper(tools_in_module)
+
+        # Strip __future__ annotations from source if present (we re-add it)
+        clean_source = _strip_future_annotations(source)
+
+        script_content = (
+            '"""Auto-generated tool script from Orchid agent configuration."""\n'
+            "from __future__ import annotations\n\n"
+            f"{clean_source}\n\n"
+            f"{cli_wrapper}\n"
+        )
+
+        (scripts_dir / script_name).write_text(script_content, encoding="utf-8")
+
+        # Build info for each tool in this module
+        for tool_name, tool_cfg in tools_in_module:
+            func_name = tool_cfg.handler.rsplit(".", 1)[1]
+            params = _extract_parameters(module_path, func_name)
+            usage_hint = _build_usage_hint(func_name, params)
+            result[tool_name] = _ToolScriptInfo(
+                script_name=script_name,
+                usage_hint=usage_hint,
+                parameters=params,
+            )
+
+    return result
+
+
+def _read_module_source(module_path: str) -> str | None:
+    """Read the source code of a Python module by its dotted import path."""
+    try:
+        module = importlib.import_module(module_path)
+        source_file = inspect.getfile(module)
+        return Path(source_file).read_text(encoding="utf-8")
+    except Exception:
+        return None
+
+
+def _strip_future_annotations(source: str) -> str:
+    """Remove 'from __future__ import annotations' to avoid duplication."""
+    lines = source.splitlines(keepends=True)
+    filtered = []
+    for line in lines:
+        stripped = line.strip()
+        if stripped == "from __future__ import annotations":
+            continue
+        filtered.append(line)
+    return "".join(filtered)
+
+
+def _extract_parameters(module_path: str, func_name: str) -> dict[str, str]:
+    """Extract parameter names and descriptions from a function's signature and docstring."""
+    try:
+        module = importlib.import_module(module_path)
+        func = getattr(module, func_name)
+        sig = inspect.signature(func)
+        docstring = inspect.getdoc(func) or ""
+
+        params: dict[str, str] = {}
+        for name, param in sig.parameters.items():
+            if name in ("kwargs", "self", "cls"):
+                continue
+            # Try to find description in docstring Parameters section
+            desc = _find_param_doc(docstring, name)
+            if not desc:
+                # Fall back to annotation
+                ann = param.annotation
+                if ann != inspect.Parameter.empty:
+                    desc = str(ann).replace("'", "")
+                else:
+                    desc = "string"
+            params[name] = desc
+
+        return params
+    except Exception:
+        return {}
+
+
+def _find_param_doc(docstring: str, param_name: str) -> str:
+    """Extract a parameter description from a NumPy-style docstring."""
+    lines = docstring.splitlines()
+    in_params = False
+    found_param = False
+    for line in lines:
+        stripped = line.strip()
+        if stripped in ("Parameters", "Parameters:"):
+            in_params = True
+            continue
+        if in_params and stripped.startswith("---"):
+            continue
+        if in_params and stripped in ("Returns", "Returns:", "Raises", "Raises:"):
+            break
+        if in_params:
+            # Look for "param_name : type" line
+            if stripped.startswith(param_name) and ":" in stripped:
+                found_param = True
+                continue
+            if found_param:
+                if stripped and not stripped[0].isalpha() or not stripped:
+                    # Description line (indented) or blank
+                    if stripped:
+                        return stripped
+                    break
+                else:
+                    # Next parameter
+                    break
+    return ""
+
+
+def _build_usage_hint(func_name: str, params: dict[str, str]) -> str:
+    """Build a CLI usage hint like '--player_name "LeBron James"'."""
+    if not params:
+        return func_name
+    args = " ".join(f'--{name} "<{name}>"' for name in params)
+    return f"{func_name} {args}"
+
+
+def _build_cli_wrapper(tools_in_module: list[tuple[str, BuiltinToolConfig]]) -> str:
+    """Build a __main__ CLI wrapper that dispatches to tool functions."""
+    func_entries: list[tuple[str, str]] = []  # (tool_name, func_name)
+    for tool_name, tool_cfg in tools_in_module:
+        func_name = tool_cfg.handler.rsplit(".", 1)[1]
+        func_entries.append((tool_name, func_name))
+
+    lines: list[str] = []
+    lines.append("# ── CLI wrapper (auto-generated) ──────────────────────────────")
+    lines.append("")
+    lines.append("")
+    lines.append("if __name__ == '__main__':")
+    lines.append("    import sys")
+    lines.append("    import json as _json")
+    lines.append("")
+    lines.append("    _TOOLS = {")
+    for tool_name, func_name in func_entries:
+        lines.append(f"        '{func_name}': {func_name},")
+    lines.append("    }")
+    lines.append("")
+    tool_names_str = ", ".join(fn for _, fn in func_entries)
+    lines.append("    if len(sys.argv) < 2 or sys.argv[1] in ('-h', '--help'):")
+    lines.append("        print(f'Usage: python {sys.argv[0]} <tool_name> [--arg value ...]')")
+    lines.append(f"        print('Available tools: {tool_names_str}')")
+    lines.append("        sys.exit(0)")
+    lines.append("")
+    lines.append("    _tool_name = sys.argv[1]")
+    lines.append("    if _tool_name not in _TOOLS:")
+    lines.append("        print(f'Unknown tool: {_tool_name}')")
+    lines.append(f"        print('Available tools: {tool_names_str}')")
+    lines.append("        sys.exit(1)")
+    lines.append("")
+    lines.append("    # Parse --key value arguments")
+    lines.append("    _kwargs = {}")
+    lines.append("    _args = sys.argv[2:]")
+    lines.append("    _i = 0")
+    lines.append("    while _i < len(_args):")
+    lines.append("        if _args[_i].startswith('--') and _i + 1 < len(_args):")
+    lines.append("            _kwargs[_args[_i][2:]] = _args[_i + 1]")
+    lines.append("            _i += 2")
+    lines.append("        else:")
+    lines.append("            _i += 1")
+    lines.append("")
+    lines.append("    # Coerce argument types using function annotations")
+    lines.append("    import inspect as _inspect")
+    lines.append("    _sig = _inspect.signature(_TOOLS[_tool_name])")
+    lines.append("    _coerced = {}")
+    lines.append("    for _k, _v in _kwargs.items():")
+    lines.append("        _param = _sig.parameters.get(_k)")
+    lines.append("        if _param and _param.annotation != _inspect.Parameter.empty:")
+    lines.append("            _ann = _param.annotation")
+    lines.append("            if _ann in (int, 'int'):")
+    lines.append("                _v = int(_v)")
+    lines.append("            elif _ann in (float, 'float'):")
+    lines.append("                _v = float(_v)")
+    lines.append("            elif _ann in (bool, 'bool'):")
+    lines.append("                _v = _v.lower() in ('true', '1', 'yes')")
+    lines.append("        _coerced[_k] = _v")
+    lines.append("")
+    lines.append("    _result = _TOOLS[_tool_name](**_coerced)")
+    lines.append("    print(_json.dumps(_result, indent=2, default=str))")
+
+    return "\n".join(lines)
+
+
+# ── Helpers ───────────────────────────────────────────────────────
+
+
+def _clean_description(text: str) -> str:
+    """Collapse whitespace in a YAML multi-line description."""
+    return " ".join(text.split()).strip()
+
+
+def _truncate(text: str, max_len: int) -> str:
+    """Truncate text with ellipsis if needed, escaping quotes for YAML."""
+    text = text.replace('"', '\\"')
+    if len(text) <= max_len:
+        return text
+    return text[: max_len - 1] + "…"

orchid_cli/main.py

@@ -0,0 +1,30 @@
+"""
+Orchid CLI — command-line interface for the Orchid agent framework.
+
+Usage:
+    orchid chat "What are LeBron's stats?" --config examples/basketball/orchid.yml
+    orchid chat --interactive --config examples/basketball/orchid.yml
+    orchid config validate examples/basketball/orchid.yml
+    orchid index --config examples/basketball/orchid.yml
+"""
+
+from __future__ import annotations
+
+import typer
+
+from .commands import chat, config, index, skill
+
+app = typer.Typer(
+    name="orchid",
+    help="Orchid — multi-agent AI framework CLI",
+    no_args_is_help=True,
+)
+
+app.add_typer(chat.app, name="chat")
+app.add_typer(config.app, name="config")
+app.add_typer(index.app, name="index")
+app.add_typer(skill.app, name="skill")
+
+
+if __name__ == "__main__":
+    app()

orchid_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: orchid-cli
+Version: 0.1.0
+Summary: Orchid CLI — command-line interface for the Orchid agent framework
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: langchain-core>=0.3.0
+Requires-Dist: orchid-ai>=1.1.0
+Requires-Dist: pydantic-settings>=2.7.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.12.0
+Provides-Extra: dev
+Requires-Dist: gitlint>=0.19.0; extra == 'dev'
+Requires-Dist: pre-commit>=4.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.25.0; extra == 'dev'
+Requires-Dist: pytest-cov>=6.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.9.0; extra == 'dev'

orchid_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+orchid_cli/__init__.py,sha256=TR3LU0f00o8wk6UNhveP9HkWru6m0HE5lup8hSkJVc0,13
+orchid_cli/bootstrap.py,sha256=d00k4b_TAwcxyxudbrdqweLdifj1KjwbcrEihsVqH7A,6743
+orchid_cli/main.py,sha256=KaSBSoSGvsQuR2XDtDqNwoAFjmZifU8P7zrmSrUn_L4,769
+orchid_cli/commands/__init__.py,sha256=ZgebDddFSsH7OC0ZjpvzOouWrwfLdfWilzAwu5de8AE,23
+orchid_cli/commands/chat.py,sha256=klC7mz1BkulZQnZxEPD30ZL0JWzUhK5B_BHrbakwXJE,16363
+orchid_cli/commands/config.py,sha256=M6mtK7nYXfS_EZU8Mq4gWlnLDRoxaYtAbeDxk6VSG9A,1293
+orchid_cli/commands/index.py,sha256=M_uS1LLq6mqewvemxCw2c7pg7r5djO0CQfhM0cj4Irs,1371
+orchid_cli/commands/skill.py,sha256=k3EYGr8P1IO53Osg0kAVCttRCTuPAedbLI_qEqWwxS0,21175
+orchid_cli-0.1.0.dist-info/METADATA,sha256=X-v0bkRW5ZoHil6YNTK1bAo4UM6Um5-HdqdH_ukm88c,699
+orchid_cli-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+orchid_cli-0.1.0.dist-info/entry_points.txt,sha256=lQMig0J_0tiSlmBTME0s-Xt9TMxCaDfbDeOdKH2gyk8,47
+orchid_cli-0.1.0.dist-info/licenses/LICENSE,sha256=Y7UF4tWj3YhozK8JcR7EqqEVYX1ZQSrNdII70UfMnVE,1076
+orchid_cli-0.1.0.dist-info/RECORD,,

orchid_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

orchid_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+orchid = orchid_cli.main:app

orchid_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Orchid Contributors
+
+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.