miniouto 0.1.0__py3-none-any.whl

miniouto/__init__.py

@@ -0,0 +1,3 @@
+"""miniouto — a minimal, file-driven CLI agent harness built on coreouto."""
+
+__version__ = "0.1.0"

miniouto/cli/__init__.py

@@ -0,0 +1,70 @@
+"""miniouto CLI entrypoint."""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from ..storage import paths
+from . import provider as provider_module
+from . import skill as skill_module
+from . import style as style_module
+from . import tui as tui_module
+from .chat import chat_cmd
+
+app = typer.Typer(
+    name="miniouto",
+    help="A minimal, file-driven CLI agent harness built on coreouto.",
+    no_args_is_help=False,
+    invoke_without_command=True,
+    add_completion=False,
+)
+app.add_typer(provider_module.app, name="provider")
+app.add_typer(style_module.app, name="style")
+app.add_typer(skill_module.app, name="skill")
+app.command("chat", help="Run a single chat turn.")(chat_cmd)
+
+console = Console()
+
+
+@app.callback()
+def _root(
+    ctx: typer.Context,
+    version: bool = typer.Option(False, "--version", help="Show version and exit."),
+) -> None:
+    paths.ensure_dirs()
+    if version:
+        from .. import __version__
+
+        console.print(f"miniouto {__version__}")
+        raise typer.Exit()
+    if ctx.invoked_subcommand is None:
+        tui_module.run_tui()
+
+
+@app.command("status")
+def status() -> None:
+    """Show current configuration."""
+
+    from ..storage import providers as provider_store
+    from ..storage import sessions as session_store
+    from ..storage import settings as settings_store
+    from ..storage import skills as skill_store
+    from ..storage import styles as style_store
+
+    s = settings_store.load()
+    active_provider = provider_store.get(s.provider) if s.provider else None
+    default_model = active_provider.default_model if active_provider else ""
+    console.print(f"[bold]Default provider:[/bold] {s.provider or '-'}")
+    console.print(f"[bold]Default model:[/bold]    {default_model or '- (use chat --model)'}")
+    console.print(f"[bold]Active style:[/bold]    {s.style or '-'}")
+    console.print(f"[bold]Session:[/bold]         {s.session or '-'}")
+    console.print(f"[bold]Storage:[/bold]         {paths.ROOT}")
+    console.print(f"[bold]Providers:[/bold]       {', '.join(provider_store.load_all()) or '-'}")
+    console.print(f"[bold]Styles:[/bold]          {', '.join(style_store.list_styles()) or '-'}")
+    console.print(f"[bold]Skills:[/bold]          {', '.join(s.name for s in skill_store.list_skills()) or '-'}")
+    console.print(f"[bold]Sessions:[/bold]        {', '.join(session_store.list_sessions()) or '-'}")
+
+
+if __name__ == "__main__":
+    app()

miniouto/cli/chat.py

@@ -0,0 +1,77 @@
+"""Single-shot chat command."""
+
+from __future__ import annotations
+
+import datetime
+import sys
+import uuid
+
+import typer
+
+from ..core.chat import ChatOptions, run_chat
+from ..core.events import ConsoleEventSink
+from ..storage import settings as settings_store
+
+
+def chat_cmd(
+    prompt: str = typer.Argument(..., help="Prompt to send to the agent."),
+    name: str | None = typer.Option(
+        None, "--name", help="Session name. Without --name and --continue, a fresh session is generated each call."
+    ),
+    provider: str | None = typer.Option(None, "--provider", help="Override the active provider."),
+    model: str | None = typer.Option(None, "--model", help="Override the default model."),
+    style: str | None = typer.Option(None, "--style", help="Override the active style."),
+    max_tokens: int | None = typer.Option(None, "--max-tokens", help="Cap output tokens."),
+    temperature: float | None = typer.Option(None, "--temperature", help="Sampling temperature."),
+    continue_session: bool = typer.Option(
+        False, "--continue", "-c", help="Prepend the session's previous history."
+    ),
+    answer_only: bool = typer.Option(
+        False, "--answer-only", "-a",
+        help="Print only the final answer. Suppresses the session marker, loop events, and finish marker.",
+    ),
+    with_session: bool = typer.Option(
+        False, "--with-session",
+        help="Print only the session marker and the final answer. Suppresses loop events and the finish marker.",
+    ),
+) -> None:
+    """Run one prompt and print the agent's reply."""
+
+    if answer_only and with_session:
+        typer.secho(
+            "✗ --answer-only and --with-session are mutually exclusive.", err=True, fg="red"
+        )
+        raise typer.Exit(1)
+
+    if continue_session:
+        session_name = name or settings_store.load().session or "default"
+    elif name is not None:
+        session_name = name
+    else:
+        # Fresh session each call: timestamp + short UUID keeps names
+        # unique even within the same second and sortable by recency,
+        # so the previous chat's `settings.session` doesn't bleed in.
+        ts = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
+        suffix = uuid.uuid4().hex[:6]
+        session_name = f"chat-{ts}-{suffix}"
+    settings_store.update(session=session_name)
+
+    opts = ChatOptions(
+        prompt=prompt,
+        session=session_name,
+        provider=provider,
+        model=model,
+        style=style,
+        max_tokens=max_tokens,
+        temperature=temperature,
+        continue_session=continue_session,
+    )
+    # The sink handles all output: braille spinner + loop events share
+    # stdout (Rich's Live display owns one channel and keeps them
+    # vertically separated). The session marker is printed up front so
+    # callers know which session the output belongs to.
+    quiet = answer_only or with_session
+    if not answer_only:
+        sys.stdout.write(f"------{session_name}------\n")
+        sys.stdout.flush()
+    run_chat(opts, sink=ConsoleEventSink(quiet=quiet))

miniouto/cli/provider.py

@@ -0,0 +1,272 @@
+"""Provider subcommands.
+
+Three groups:
+
+* **catalog** browse / add (sourced from the upstream lma catalog at
+  https://lma.blp.sh, but exposed to users as the "catalog"): `providers`,
+  `models`, `add`.
+* **storage** ops on already-configured providers: `list`, `remove`, `default`.
+* **custom** manual config (no catalog lookup): `provider custom add`.
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ..core import lma as catalog_api
+from ..core.providers import SUPPORTED_FORMATS, add_provider_from_lma, sdk_to_format
+from ..storage import paths
+from ..storage import providers as provider_store
+from ..storage import settings as settings_store
+
+app = typer.Typer(help="Manage LLM providers (catalog browse + custom config).")
+custom_app = typer.Typer(help="Manually configure a custom provider (advanced).")
+app.add_typer(custom_app, name="custom")
+
+console = Console()
+
+FORMAT_HELP = (
+    "API compatibility: "
+    "openai (OpenAI Chat Completions), "
+    "openai-response (OpenAI Responses API), "
+    "anthropic (Anthropic Messages), "
+    "google (Google Generative AI / Gemini)."
+)
+
+
+# ─── catalog commands ────────────────────────────────────────────────────────
+
+
+@app.command("providers")
+def providers_cmd() -> None:
+    """List every provider available in the catalog."""
+
+    try:
+        providers = catalog_api.list_providers()
+    except Exception as exc:
+        console.print(f"[red]✗[/red] Failed to reach catalog: {exc}")
+        raise typer.Exit(code=1) from exc
+    if not providers:
+        console.print("[yellow]No providers returned by the catalog.[/yellow]")
+        return
+
+    table = Table(
+        title=f"Catalog providers ({len(providers)})",
+        show_header=True,
+        header_style="bold",
+    )
+    table.add_column("Name", style="cyan")
+    table.add_column("SDK")
+    table.add_column("API URL")
+    table.add_column("miniouto format", style="magenta")
+    table.add_column("Addable?", justify="center")
+    for p in providers:
+        name = p.get("name", "?")
+        sdk = p.get("sdk") or "-"
+        api = p.get("api") or "-"
+        fmt, _ = sdk_to_format(sdk, api)
+        fmt_str = fmt or "[red]unsupported[/red]"
+        addable = "[green]✓[/green]" if fmt else "[dim]✗[/dim]"
+        table.add_row(name, sdk, api, fmt_str, addable)
+    console.print(table)
+
+
+@app.command("models")
+def models_cmd(
+    provider_name: str = typer.Argument(
+        ..., help="Provider name (fuzzy match, e.g. 'anthropic', 'open ai')."
+    ),
+) -> None:
+    """List every model the catalog knows for a provider."""
+
+    try:
+        models = catalog_api.list_models(provider_name)
+    except Exception as exc:
+        console.print(f"[red]✗[/red] Failed to reach catalog: {exc}")
+        raise typer.Exit(code=1) from exc
+    if not models:
+        console.print(f"[yellow]No models returned for {provider_name!r}.[/yellow]")
+        raise typer.Exit(code=1)
+    table = Table(
+        title=f"Catalog models for {provider_name!r} ({len(models)})",
+        show_header=True,
+        header_style="bold",
+    )
+    table.add_column("ID", style="cyan")
+    table.add_column("Name")
+    for m in models:
+        table.add_row(m.get("id", "?"), m.get("name", "?"))
+    console.print(table)
+
+
+@app.command("add")
+def add_cmd(
+    provider_name: str = typer.Argument(
+        ..., help="Catalog provider name (e.g. 'OpenAI', 'Anthropic', 'GitHub Copilot')."
+    ),
+    api_key: str = typer.Option(..., "--api-key", help="API key for the provider."),
+    default_model: str = typer.Option(
+        "",
+        "--default-model",
+        help="Default model id. If empty, the first model the catalog lists for this provider is used.",
+    ),
+) -> None:
+    """Add a provider from the catalog by name + API key.
+
+    For manual configuration (custom base URL / format), use
+    `miniouto provider custom add` instead.
+    """
+
+    catalog_provider = catalog_api.find_provider(provider_name)
+    if catalog_provider is None:
+        console.print(
+            f"[red]✗[/red] No catalog provider matched {provider_name!r}. "
+            "Run `miniouto provider providers` to see the catalog."
+        )
+        raise typer.Exit(code=1)
+
+    name = catalog_api.slugify(catalog_provider["name"])
+    sdk = catalog_provider.get("sdk")
+    api = catalog_provider.get("api")
+
+    try:
+        provider = add_provider_from_lma(
+            name=name,
+            api_key=api_key,
+            sdk=sdk,
+            api=api,
+            default_model=default_model,
+        )
+    except ValueError as exc:
+        console.print(f"[red]✗[/red] {exc}")
+        raise typer.Exit(code=1) from exc
+
+    if not provider.default_model:
+        try:
+            models = catalog_api.list_models(catalog_provider["name"])
+            if models:
+                provider = add_provider_from_lma(
+                    name=name,
+                    api_key=api_key,
+                    sdk=sdk,
+                    api=api,
+                    default_model=models[0].get("id", ""),
+                )
+        except Exception:
+            pass
+
+    paths.ensure_dirs()
+    if provider_store.get(name) is not None:
+        console.print(
+            f"[yellow]![/yellow] Provider [bold]{name}[/bold] already exists; overwriting."
+        )
+    provider_store.upsert(provider)
+    console.print(
+        f"[green]✓[/green] Added provider [bold]{name}[/bold] "
+        f"({provider.api_format}, default-model={provider.default_model or '-'})."
+    )
+
+
+# ─── storage commands (unchanged behavior) ───────────────────────────────────
+
+
+@app.command("list")
+def list_cmd() -> None:
+    """List configured providers."""
+
+    rows = provider_store.load_all()
+    if not rows:
+        console.print(
+            "[yellow]No providers configured.[/yellow] "
+            "Run `miniouto provider add <name>` or `miniouto provider custom add`."
+        )
+        return
+    current = settings_store.load().provider
+    table = Table(title="Providers", show_header=True, header_style="bold")
+    table.add_column("Name", style="cyan")
+    table.add_column("Type")
+    table.add_column("Format")
+    table.add_column("Base URL")
+    table.add_column("Default Model")
+    table.add_column("Default", justify="center")
+    for p in rows.values():
+        marker = "[green]●[/green]" if p.name == current else ""
+        kind = "custom" if p.source == "custom" else "catalog"
+        table.add_row(
+            p.name,
+            kind,
+            p.api_format,
+            p.base_url or "-",
+            p.default_model or "-",
+            marker,
+        )
+    console.print(table)
+
+
+@app.command("remove")
+def remove(name: str) -> None:
+    """Remove a provider by name."""
+
+    if provider_store.remove(name):
+        console.print(f"[green]✓[/green] Removed provider [bold]{name}[/bold].")
+    else:
+        console.print(f"[red]✗[/red] Provider [bold]{name}[/bold] does not exist.")
+        raise typer.Exit(code=1)
+
+
+@app.command("default")
+def default(name: str) -> None:
+    """Set the default provider for chat."""
+
+    if provider_store.get(name) is None:
+        console.print(f"[red]✗[/red] Provider [bold]{name}[/bold] is not configured.")
+        raise typer.Exit(code=1)
+    settings_store.update(provider=name)
+    console.print(f"[green]✓[/green] Default provider is now [bold]{name}[/bold].")
+
+
+# ─── custom subcommands ──────────────────────────────────────────────────────
+
+
+@custom_app.command("add")
+def add_custom(
+    name: str = typer.Option(..., "--name", help="Provider identifier (e.g. openai, minimax)."),
+    api_format: str = typer.Option("openai", "--format", help=FORMAT_HELP),
+    base_url: str = typer.Option(
+        "", "--base-url",
+        help="Base URL of the endpoint. For OpenAI-compatible services "
+        "(LocalAI, vLLM, MiniMax, Zhipu, Moonshot, etc.) use the OpenAI or "
+        "openai-response format with the provider's base URL. Anthropic "
+        "format works with the Anthropic SDK and any compatible proxy. "
+        "Google format accepts an api_endpoint via client_options.",
+    ),
+    api_key: str = typer.Option("", "--api-key", help="API key (omit to read from env at call time)."),
+    default_model: str = typer.Option(
+        "", "--default-model", help="Default model used when chat --model is not given."
+    ),
+) -> None:
+    """Manually add or update a custom provider.
+
+    For catalog providers (OpenAI, Anthropic, etc.), use
+    `miniouto provider add <name>` instead — it auto-fills base URL, format,
+    and default model.
+    """
+
+    if api_format not in SUPPORTED_FORMATS:
+        console.print(
+            f"[red]✗[/red] Unknown format {api_format!r}. "
+            f"Supported: {', '.join(SUPPORTED_FORMATS)}."
+        )
+        raise typer.Exit(code=1)
+    paths.ensure_dirs()
+    provider = provider_store.Provider(
+        name=name,
+        api_format=api_format,
+        base_url=base_url,
+        api_key=api_key,
+        default_model=default_model,
+    )
+    provider_store.upsert(provider)
+    console.print(f"[green]✓[/green] Saved custom provider [bold]{name}[/bold] ({api_format}).")

miniouto/cli/skill.py

@@ -0,0 +1,51 @@
+"""Skill CLI commands."""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ..storage import skills as skill_store
+
+app = typer.Typer(help="Manage agent skills.")
+console = Console()
+
+
+@app.command("list")
+def list_cmd() -> None:
+    """List all available skills."""
+
+    skills = skill_store.list_skills()
+    if not skills:
+        console.print("[yellow]No skills found.[/yellow] Check ~/.agents/skills/")
+        return
+
+    table = Table(title="Available Skills", show_header=True, header_style="bold")
+    table.add_column("Name", style="cyan")
+    table.add_column("Description")
+
+    for skill in skills:
+        desc = skill.description[:80] + "..." if len(skill.description) > 80 else skill.description
+        table.add_row(skill.name, desc)
+
+    console.print(table)
+
+
+@app.command("show")
+def show(name: str) -> None:
+    """Show skill content."""
+
+    skill = skill_store.get_skill(name)
+    if skill is None:
+        console.print(f"[red]✗[/red] Skill [bold]{name}[/bold] not found.")
+        raise typer.Exit(code=1)
+
+    console.print(f"[bold]Name:[/bold] {skill.name}")
+    console.print(f"[bold]Description:[/bold] {skill.description}")
+    if skill.license:
+        console.print(f"[bold]License:[/bold] {skill.license}")
+    if skill.allowed_tools:
+        console.print(f"[bold]Allowed Tools:[/bold] {skill.allowed_tools}")
+    console.print()
+    console.print(skill.content)

miniouto/cli/style.py

@@ -0,0 +1,112 @@
+"""Style subcommands."""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from ..storage import paths
+from ..storage import settings as settings_store
+from ..storage import styles as style_store
+
+app = typer.Typer(help="Manage agent style documents.")
+console = Console()
+
+
+@app.command("list")
+def list_cmd() -> None:
+    """List installed style documents."""
+
+    names = style_store.list_styles()
+    if not names:
+        console.print("[yellow]No styles installed.[/yellow]")
+        return
+    current = settings_store.load().style
+    for name in names:
+        marker = " [green]●[/green]" if name == current else ""
+        console.print(f"  - {name}{marker}")
+
+
+@app.command("set")
+def set_cmd(name: str) -> None:
+    """Activate an installed style as the default."""
+
+    if style_store.read(name) is None:
+        console.print(f"[red]✗[/red] Style [bold]{name}[/bold] is not installed.")
+        raise typer.Exit(code=1)
+    settings_store.update(style=name)
+    console.print(f"[green]✓[/green] Active style is now [bold]{name}[/bold].")
+
+
+@app.command("add")
+def add(
+    repo_url: str = typer.Argument(..., help="Git host URL whose /style-md/ directory defines styles."),
+    name: str | None = typer.Option(
+        None,
+        "--name",
+        help="Override style name (otherwise the file's basename is used).",
+    ),
+) -> None:
+    """Add styles by fetching /style-md/ from a remote repository."""
+
+    paths.ensure_dirs()
+    try:
+        added = style_store.add_from_repo(repo_url, name_override=name)
+    except Exception as exc:
+        console.print(f"[red]✗[/red] Failed to fetch styles: {exc}")
+        raise typer.Exit(code=1) from exc
+    console.print(f"[green]✓[/green] Added/updated styles: {', '.join(added)}")
+
+
+@app.command("update")
+def update_cmd() -> None:
+    """Refresh every style to its latest source.
+
+    Re-seeds all bundled styles from the miniouto package, then re-fetches
+    every repo previously added via ``style add``. Same-name files are
+    overwritten in place. Styles you created by hand (no matching bundled
+    template and no recorded repo) are left untouched.
+    """
+
+    paths.ensure_dirs()
+    refreshed_bundled = style_store.bundled_style_names()
+
+    repos = style_store.list_repos()
+    failed: list[tuple[str, str]] = []
+    refreshed_repos: list[str] = []
+    for url in repos:
+        try:
+            added = style_store.add_from_repo(url)
+        except Exception as exc:
+            failed.append((url, str(exc)))
+            continue
+        refreshed_repos.extend(added)
+
+    console.print(
+        f"[green]✓[/green] Refreshed bundled styles: "
+        f"{', '.join(refreshed_bundled) or '-'}"
+    )
+    if repos:
+        ok = sorted(set(refreshed_repos))
+        console.print(
+            f"[green]✓[/green] Re-fetched {len(repos)} repo(s): "
+            f"{', '.join(ok) or 'no .md files'}"
+        )
+        for url, err in failed:
+            console.print(f"[red]✗[/red] Failed to update {url}: {err}")
+    elif not repos:
+        console.print(
+            "[dim]No repo styles to update. Use `style add <repo-url>` "
+            "to track a repo.[/dim]"
+        )
+
+
+@app.command("show")
+def show(name: str) -> None:
+    """Print the contents of a style document."""
+
+    content = style_store.read(name)
+    if content is None:
+        console.print(f"[red]✗[/red] Style [bold]{name}[/bold] is not installed.")
+        raise typer.Exit(code=1)
+    console.print(content)