anythink 0.1.0__py3-none-any.whl

anythink/__init__.py

@@ -0,0 +1,10 @@
+"""Anythink — Think anything. Ask anything."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("anythink")
+except PackageNotFoundError:
+    __version__ = "0.1.0"
+
+__all__ = ["__version__"]

anythink/app/__init__.py

@@ -0,0 +1 @@
+"""Anythink application orchestration package."""

anythink/app/chat.py

@@ -0,0 +1,231 @@
+"""Interactive chat loop orchestrator."""
+
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass, field
+
+from rich.text import Text
+
+from anythink import __version__
+from anythink.app.context import AppContext
+from anythink.commands.registry import CommandRegistry
+from anythink.config.models import ModelAlias
+from anythink.exceptions import AnythinkError, SearchError
+from anythink.files.reader import FileAttachment, ImageAttachment, TextAttachment
+from anythink.providers.base import BaseProvider, ChatMessage, ContentPart, ImagePart, TextPart, TokenUsage
+from anythink.search.base import SearchResult
+from anythink.session.models import Session
+from anythink.ui.banner import print_banner
+from anythink.ui.input import make_prompt_session
+from anythink.ui.renderer import StreamRenderer
+from anythink.ui.status import ContextStatusBar
+
+
+@dataclass
+class ChatState:
+    """Mutable per-session chat state."""
+
+    provider: BaseProvider
+    model_id: str
+    context_window: int
+    history: list[ChatMessage] = field(default_factory=list)
+    total_tokens_used: int = 0
+    session_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    session_name: str = ""
+    pending_attachments: list[FileAttachment] = field(default_factory=list)
+    search_enabled: bool = False
+
+
+def _format_search_results(results: list[SearchResult], query: str) -> str:
+    lines = [f"[Web Search: {query!r}]"]
+    for i, r in enumerate(results, 1):
+        lines.append(f"{i}. {r.title} — {r.url}")
+        if r.snippet:
+            lines.append(f"   {r.snippet}")
+    return "\n".join(lines)
+
+
+class ChatApp:
+    """Interactive chat loop: banner → prompt → stream → repeat."""
+
+    def __init__(
+        self,
+        ctx: AppContext,
+        command_registry: CommandRegistry | None = None,
+    ) -> None:
+        self.ctx = ctx
+        self._registry = command_registry or CommandRegistry.from_entry_points()
+
+    async def run(self) -> int:
+        """Run the interactive chat loop. Returns an exit code (0 = normal exit)."""
+        ctx = self.ctx
+
+        state = self._resolve_state()
+        if state is None:
+            return 1
+
+        renderer = StreamRenderer(console=ctx.console, theme=ctx.theme)
+        status_bar = ContextStatusBar(theme=ctx.theme, max_tokens=state.context_window)
+        session = make_prompt_session(slash_commands=self._registry.names())
+
+        print_banner(ctx.console, ctx.theme, __version__)
+        ctx.console.print(
+            Text(
+                f"  Provider: {state.provider.name}  •  Model: {state.model_id}",
+                style=ctx.theme.muted,
+            )
+        )
+        ctx.console.print()
+
+        while True:
+            if state.total_tokens_used > 0:
+                ctx.console.print(status_bar.render(state.total_tokens_used))
+
+            try:
+                user_input: str = await session.prompt_async([("class:prompt", "You: ")])
+            except KeyboardInterrupt:
+                ctx.console.print(Text("\nInterrupted.", style=ctx.theme.muted))
+                break
+            except EOFError:
+                break
+
+            stripped = user_input.strip()
+            if not stripped:
+                continue
+
+            # Slash commands
+            if stripped.startswith("/"):
+                result = await self._registry.dispatch(stripped, ctx, state)
+                if result.message:
+                    style = ctx.theme.error if result.error else ctx.theme.secondary
+                    ctx.console.print(Text(result.message, style=style))
+                if result.should_exit:
+                    break
+                continue
+
+            # Legacy bare "exit" / "quit" shortcuts
+            if stripped.lower() in ("exit", "quit"):
+                ctx.console.print(Text("Goodbye!", style=ctx.theme.primary))
+                break
+
+            # Accumulate extra content parts (search results + file attachments)
+            extra_parts: list[ContentPart] = []
+
+            if state.search_enabled:
+                backend = ctx.search_registry.get_available(ctx.config.search_provider)
+                if backend is not None:
+                    try:
+                        search_results = await backend.search(stripped)
+                        if search_results:
+                            extra_parts.append(
+                                TextPart(_format_search_results(search_results, stripped))
+                            )
+                    except SearchError as exc:
+                        ctx.console.print(
+                            Text(f"  [Search failed: {exc.user_message}]", style=ctx.theme.error)
+                        )
+
+            for att in state.pending_attachments:
+                if isinstance(att, TextAttachment):
+                    extra_parts.append(TextPart(f"[File: {att.filename}]\n{att.content}"))
+                elif isinstance(att, ImageAttachment):
+                    extra_parts.append(att.image_part)
+            state.pending_attachments.clear()
+
+            if extra_parts:
+                if stripped:
+                    extra_parts.append(TextPart(stripped))
+                user_msg = ChatMessage(role="user", content=extra_parts)
+            else:
+                user_msg = ChatMessage(role="user", content=stripped)
+            state.history.append(user_msg)
+
+            ctx.console.print(Text("\nAssistant: ", style=ctx.theme.accent))
+
+            try:
+                chunk_stream = state.provider.stream_chat(
+                    messages=state.history,
+                    model=state.model_id,
+                )
+                full_text, usage = await renderer.stream(chunk_stream)
+            except AnythinkError as exc:
+                ctx.console.print(Text(f"\n[Error] {exc.user_message}", style=ctx.theme.error))
+                state.history.pop()
+                continue
+
+            state.history.append(ChatMessage(role="assistant", content=full_text))
+            if usage:
+                state.total_tokens_used = usage.total_tokens
+
+            ctx.console.print()
+
+        # Autosave when configured and conversation is non-empty
+        if ctx.config.session_autosave and state.history:
+            session = Session(
+                id=state.session_id,
+                provider=state.provider.name,
+                model_id=state.model_id,
+                messages=list(state.history),
+                name=state.session_name,
+            )
+            ctx.session_manager.save(session)
+
+        return 0
+
+    def _resolve_state(self) -> ChatState | None:
+        """Resolve the active provider+model from config. Returns None and prints an error on failure."""
+        ctx = self.ctx
+
+        alias_name = ctx.config.default_model_alias
+        if not alias_name:
+            ctx.console.print(
+                Text(
+                    "No default model configured. Run `anythink setup` to get started.",
+                    style=ctx.theme.error,
+                )
+            )
+            return None
+
+        alias: ModelAlias | None = ctx.model_registry.get(alias_name)
+        if alias is None:
+            ctx.console.print(
+                Text(
+                    f"Model alias '{alias_name}' not found. Run `anythink model list` to see available aliases.",
+                    style=ctx.theme.error,
+                )
+            )
+            return None
+
+        api_key = ctx.key_manager.get_key(alias.provider)
+
+        try:
+            provider = ctx.provider_registry.instantiate(
+                alias.provider,
+                api_key=api_key,
+                base_url=ctx.config.local_servers.get(alias.provider),
+            )
+        except AnythinkError as exc:
+            ctx.console.print(
+                Text(
+                    f"Failed to load provider '{alias.provider}': {exc.user_message}",
+                    style=ctx.theme.error,
+                )
+            )
+            return None
+
+        if api_key is None and provider.requires_api_key:
+            ctx.console.print(
+                Text(
+                    f"No API key for '{alias.provider}'. Run `anythink keys add {alias.provider}` to add one.",
+                    style=ctx.theme.error,
+                )
+            )
+            return None
+
+        return ChatState(
+            provider=provider,
+            model_id=alias.model_id,
+            context_window=alias.context_window,
+            search_enabled=ctx.config.web_search_enabled,
+        )

anythink/app/context.py

@@ -0,0 +1,75 @@
+"""AppContext — dependency-injection container for the Anythink app."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import IO
+
+from rich.console import Console
+
+from anythink.config.manager import ConfigManager, Paths, _resolve_paths
+from anythink.config.models import ModelRegistry
+from anythink.config.personas import PersonaManager
+from anythink.config.schema import AppConfig
+from anythink.keys.manager import KeyManager
+from anythink.plugins.manager import PluginManager
+from anythink.providers.registry import ProviderRegistry
+from anythink.search.registry import SearchRegistry
+from anythink.session.manager import SessionManager
+from anythink.ui.console import make_console
+from anythink.ui.theme import Theme, get_theme
+
+
+@dataclass
+class AppContext:
+    """Mutable container for every Anythink sub-system.
+
+    Constructed once at startup and threaded through the call stack.
+    No module-level globals; tests inject Console(file=StringIO()) here.
+    """
+
+    config: AppConfig
+    paths: Paths
+    console: Console
+    theme: Theme
+    config_manager: ConfigManager
+    key_manager: KeyManager
+    provider_registry: ProviderRegistry
+    model_registry: ModelRegistry
+    persona_manager: PersonaManager
+    session_manager: SessionManager
+    search_registry: SearchRegistry
+    plugin_manager: PluginManager
+
+    @classmethod
+    def create(
+        cls,
+        paths: Paths | None = None,
+        console_file: IO[str] | None = None,
+    ) -> AppContext:
+        """Build a fully wired AppContext from scratch."""
+        resolved = paths or _resolve_paths()
+        resolved.ensure_dirs()
+
+        config_manager = ConfigManager(paths=resolved)
+        config = config_manager.load()
+        theme = get_theme(config.active_theme)
+        console = make_console(theme, file=console_file)
+        key_manager = KeyManager(paths=resolved)
+
+        return cls(
+            config=config,
+            paths=resolved,
+            console=console,
+            theme=theme,
+            config_manager=config_manager,
+            key_manager=key_manager,
+            provider_registry=ProviderRegistry(),
+            model_registry=ModelRegistry(path=resolved.models_file),
+            persona_manager=PersonaManager(path=resolved.personas_file),
+            session_manager=SessionManager(sessions_dir=resolved.sessions_dir),
+            search_registry=SearchRegistry.from_entry_points(
+                api_keys={"serpapi": key_manager.get_key("serpapi")}
+            ),
+            plugin_manager=PluginManager(),
+        )

anythink/cli.py

@@ -0,0 +1,333 @@
+"""Anythink CLI entry point."""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+from typing_extensions import Annotated
+
+from anythink import __version__
+from anythink.app.chat import ChatApp
+from anythink.app.context import AppContext
+from anythink.config.manager import ConfigManager
+
+app = typer.Typer(
+    name="anythink",
+    help="Think anything. Ask anything. — A universal AI-powered CLI chatbot.",
+    no_args_is_help=False,
+    add_completion=True,
+)
+
+keys_app = typer.Typer(name="keys", help="Manage API keys in the OS keychain.")
+model_app = typer.Typer(name="model", help="Manage model aliases.")
+plugins_app = typer.Typer(name="plugins", help="Manage Anythink plugins.")
+
+app.add_typer(keys_app, name="keys")
+app.add_typer(model_app, name="model")
+app.add_typer(plugins_app, name="plugins")
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"anythink {__version__}")
+        raise typer.Exit()
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: Annotated[
+        bool,
+        typer.Option("--version", "-V", callback=_version_callback, is_eager=True, help="Show version and exit."),
+    ] = False,
+) -> None:
+    """Start an interactive chat session."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    config_manager = ConfigManager()
+    if not config_manager.is_configured():
+        typer.echo("Anythink is not configured yet. Run `anythink setup` to get started.")
+        raise typer.Exit(1)
+
+    app_ctx = AppContext.create(paths=config_manager.paths)
+    exit_code = asyncio.run(ChatApp(app_ctx).run())
+    raise typer.Exit(exit_code)
+
+
+@app.command("setup")
+def setup_wizard() -> None:
+    """Run the interactive first-run setup wizard."""
+    typer.echo("Setup wizard coming in Phase 11.")
+
+
+# ── keys sub-commands ──────────────────────────────────────────────────────────
+
+@keys_app.command("list")
+def keys_list() -> None:
+    """List all configured providers and their key status."""
+    from anythink.keys.manager import KeyManager
+
+    km = KeyManager(paths=ConfigManager().paths)
+    providers = km.list_providers()
+    if not providers:
+        typer.echo("No API keys configured. Use `anythink keys add <provider>` to add one.")
+        return
+    typer.echo("Configured API keys:")
+    for p in providers:
+        typer.echo(f"  {p:<20} [set]")
+
+
+@keys_app.command("add")
+def keys_add(provider: str = typer.Argument(..., help="Provider name (e.g. groq, openai).")) -> None:
+    """Add an API key for a provider."""
+    from anythink.exceptions import KeychainError
+    from anythink.keys.manager import KeyManager
+
+    km = KeyManager(paths=ConfigManager().paths)
+    api_key: str = typer.prompt(f"Enter API key for '{provider}'", hide_input=True)
+    if not api_key.strip():
+        typer.echo("Error: API key cannot be empty.", err=True)
+        raise typer.Exit(1)
+    try:
+        km.set_key(provider, api_key.strip())
+        typer.echo(f"API key for '{provider}' saved successfully.")
+    except KeychainError as exc:
+        typer.echo(f"Error: {exc.user_message}", err=True)
+        raise typer.Exit(1)
+
+
+@keys_app.command("show")
+def keys_show(provider: str = typer.Argument(..., help="Provider name.")) -> None:
+    """Show the stored key for a provider (masked)."""
+    from anythink.exceptions import KeychainError
+    from anythink.keys.manager import KeyManager
+
+    km = KeyManager(paths=ConfigManager().paths)
+    try:
+        key = km.get_key(provider)
+    except KeychainError as exc:
+        typer.echo(f"Error: {exc.user_message}", err=True)
+        raise typer.Exit(1)
+    if key is None:
+        typer.echo(f"No API key found for '{provider}'.")
+        raise typer.Exit(1)
+    masked = key[:4] + "*" * max(len(key) - 8, 0) + key[-4:] if len(key) > 8 else "****"
+    typer.echo(f"Key for '{provider}': {masked}")
+
+
+@keys_app.command("update")
+def keys_update(provider: str = typer.Argument(..., help="Provider name.")) -> None:
+    """Replace the stored key for a provider."""
+    from anythink.exceptions import KeychainError
+    from anythink.keys.manager import KeyManager
+
+    km = KeyManager(paths=ConfigManager().paths)
+    if not km.has_key(provider):
+        typer.echo(f"No existing key for '{provider}'. Use `anythink keys add {provider}` to add one.")
+        raise typer.Exit(1)
+    api_key: str = typer.prompt(f"Enter new API key for '{provider}'", hide_input=True)
+    if not api_key.strip():
+        typer.echo("Error: API key cannot be empty.", err=True)
+        raise typer.Exit(1)
+    try:
+        km.set_key(provider, api_key.strip())
+        typer.echo(f"API key for '{provider}' updated successfully.")
+    except KeychainError as exc:
+        typer.echo(f"Error: {exc.user_message}", err=True)
+        raise typer.Exit(1)
+
+
+@keys_app.command("delete")
+def keys_delete(
+    provider: str = typer.Argument(..., help="Provider name."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt."),
+) -> None:
+    """Remove a stored key from the keychain."""
+    from anythink.exceptions import KeychainError
+    from anythink.keys.manager import KeyManager
+
+    if not yes and not typer.confirm(f"Delete API key for '{provider}'?"):
+        typer.echo("Cancelled.")
+        raise typer.Exit(0)
+    km = KeyManager(paths=ConfigManager().paths)
+    try:
+        km.delete_key(provider)
+        typer.echo(f"API key for '{provider}' deleted.")
+    except KeychainError as exc:
+        typer.echo(f"Error: {exc.user_message}", err=True)
+        raise typer.Exit(1)
+
+
+@keys_app.command("test")
+def keys_test(provider: str = typer.Argument(..., help="Provider name.")) -> None:
+    """Validate the stored key by making a test API call."""
+    from anythink.exceptions import AnythinkError
+    from anythink.keys.manager import KeyManager
+    from anythink.providers.registry import ProviderRegistry
+
+    km = KeyManager(paths=ConfigManager().paths)
+    api_key = km.get_key(provider)
+    if api_key is None:
+        typer.echo(f"No API key found for '{provider}'. Add one with: anythink keys add {provider}")
+        raise typer.Exit(1)
+
+    pr = ProviderRegistry()
+    try:
+        prov = pr.instantiate(provider, api_key=api_key)
+    except AnythinkError as exc:
+        typer.echo(f"Error: {exc.user_message}", err=True)
+        raise typer.Exit(1)
+
+    typer.echo(f"Testing connection to '{provider}'...")
+    ok: bool = asyncio.run(prov.test_connection())
+    if ok:
+        typer.echo(f"  Connection to '{provider}' is working.")
+    else:
+        typer.echo(f"  Connection to '{provider}' failed.", err=True)
+        raise typer.Exit(1)
+
+
+# ── model sub-commands ─────────────────────────────────────────────────────────
+
+@model_app.command("list")
+def model_list() -> None:
+    """List all configured model aliases."""
+    from anythink.config.models import ModelRegistry
+
+    registry = ModelRegistry(path=ConfigManager().paths.models_file)
+    aliases = registry.list_all()
+    if not aliases:
+        typer.echo("No model aliases configured. Use `anythink model add` to add one.")
+        return
+    header = f"  {'Alias':<20} {'Provider':<14} {'Model ID':<30} {'Context':>10}  Vision"
+    typer.echo(header)
+    typer.echo("  " + "-" * (len(header) - 2))
+    for a in aliases:
+        vision = "yes" if a.supports_vision else "no"
+        typer.echo(f"  {a.alias:<20} {a.provider:<14} {a.model_id:<30} {a.context_window:>10,}  {vision}")
+
+
+@model_app.command("add")
+def model_add() -> None:
+    """Add a new model alias interactively."""
+    from anythink.config.models import ModelAlias, ModelRegistry
+
+    registry = ModelRegistry(path=ConfigManager().paths.models_file)
+
+    alias: str = typer.prompt("Alias name (your personal name for this model)")
+    if registry.exists(alias):
+        typer.echo(f"Alias '{alias}' already exists. Remove it first with: anythink model remove {alias}", err=True)
+        raise typer.Exit(1)
+
+    provider: str = typer.prompt("Provider (groq, openai, anthropic, gemini, ollama, ...)")
+    model_id: str = typer.prompt("Model ID (e.g. llama3-8b-8192, gpt-4o)")
+    context_raw: str = typer.prompt("Context window size (tokens)", default="4096")
+    try:
+        context_window = int(context_raw)
+    except ValueError:
+        typer.echo("Error: context window must be an integer.", err=True)
+        raise typer.Exit(1)
+
+    supports_vision: bool = typer.confirm("Does this model support image input?", default=False)
+
+    registry.add(ModelAlias(
+        alias=alias,
+        provider=provider,
+        model_id=model_id,
+        context_window=context_window,
+        supports_vision=supports_vision,
+    ))
+    typer.echo(f"Model alias '{alias}' added successfully.")
+
+
+@model_app.command("remove")
+def model_remove(
+    alias: str = typer.Argument(..., help="Alias name to remove."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt."),
+) -> None:
+    """Remove a model alias."""
+    from anythink.config.models import ModelRegistry
+    from anythink.exceptions import ConfigError
+
+    registry = ModelRegistry(path=ConfigManager().paths.models_file)
+    if not registry.exists(alias):
+        typer.echo(f"Alias '{alias}' not found.", err=True)
+        raise typer.Exit(1)
+
+    if not yes and not typer.confirm(f"Remove model alias '{alias}'?"):
+        typer.echo("Cancelled.")
+        raise typer.Exit(0)
+
+    try:
+        registry.remove(alias)
+        typer.echo(f"Model alias '{alias}' removed.")
+    except ConfigError as exc:
+        typer.echo(f"Error: {exc.user_message}", err=True)
+        raise typer.Exit(1)
+
+
+# ── plugins sub-commands ──────────────────────────────────────────────────────
+
+@plugins_app.command("list")
+def plugins_list() -> None:
+    """List all installed Anythink plugins."""
+    from anythink.plugins.manager import PluginManager
+
+    pm = PluginManager()
+    plugins = pm.list_plugins()
+    if not plugins:
+        typer.echo("No plugins installed.")
+        return
+    for p in plugins:
+        desc = f" — {p.description}" if p.description else ""
+        typer.echo(f"{p.name} {p.version}{desc}")
+
+
+@plugins_app.command("info")
+def plugins_info(package: str = typer.Argument(..., help="Plugin package name.")) -> None:
+    """Show details about an installed plugin."""
+    from anythink.plugins.manager import PluginManager
+
+    pm = PluginManager()
+    p = pm.get_plugin(package)
+    if p is None:
+        typer.echo(f"Plugin '{package}' not found.", err=True)
+        raise typer.Exit(1)
+    typer.echo(f"Name:        {p.name}")
+    typer.echo(f"Version:     {p.version}")
+    typer.echo(f"Description: {p.description}")
+    typer.echo(f"Author:      {p.author}")
+    typer.echo(f"Groups:      {', '.join(p.entry_point_groups)}")
+    if p.homepage:
+        typer.echo(f"Homepage:    {p.homepage}")
+
+
+@plugins_app.command("install")
+def plugins_install(package: str = typer.Argument(..., help="PyPI package name to install.")) -> None:
+    """Install a plugin package from PyPI."""
+    from anythink.plugins.manager import PluginManager
+
+    pm = PluginManager()
+    typer.echo(f"Installing '{package}'...")
+    ok, output = pm.install(package)
+    if ok:
+        typer.echo(f"Installed '{package}'. Restart anythink to load it.")
+    else:
+        typer.echo(f"Installation failed:\n{output[:500]}", err=True)
+        raise typer.Exit(1)
+
+
+@plugins_app.command("remove")
+def plugins_remove(package: str = typer.Argument(..., help="Plugin package name to remove.")) -> None:
+    """Remove an installed plugin package."""
+    from anythink.plugins.manager import PluginManager
+
+    pm = PluginManager()
+    ok, output = pm.remove(package)
+    if ok:
+        typer.echo(f"Removed '{package}'. Restart anythink to apply changes.")
+    else:
+        typer.echo(f"Removal failed:\n{output[:500]}", err=True)
+        raise typer.Exit(1)

anythink/commands/__init__.py

@@ -0,0 +1 @@
+"""Slash command system for Anythink."""

anythink/commands/base.py

@@ -0,0 +1,36 @@
+"""Core types for the slash command system."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Awaitable, Callable
+
+if TYPE_CHECKING:
+    from anythink.app.chat import ChatState
+    from anythink.app.context import AppContext
+    from anythink.commands.registry import CommandRegistry
+
+
+@dataclass
+class CommandResult:
+    """Return value from a slash command handler."""
+
+    should_exit: bool = False       # True → break out of the chat loop
+    message: str | None = None      # optional text to print after handling
+    error: bool = False             # True → print message in error style
+
+
+CommandHandler = Callable[
+    ["AppContext", str, "ChatState", "CommandRegistry"],
+    Awaitable[CommandResult],
+]
+
+
+@dataclass
+class SlashCommand:
+    """A registered slash command."""
+
+    name: str           # e.g. "help"  (no leading slash)
+    description: str
+    handler: CommandHandler
+    usage: str = field(default="")   # e.g. "/help [command]"