acra-cli 0.1.1__py3-none-any.whl

acra/ui/banner.py

@@ -0,0 +1,40 @@
+"""Welcome banner and UI panels for acra."""
+
+from rich.panel import Panel
+from rich.console import Console
+
+MASCOT = r"""
+  ____   ____  ____
+ / __ \ / __ \/ __ \
+| |  | | |  | | |  | |
+| |  | | |  | | |  | |
+| |__| | |__| | |__| |
+ \____/ \____/ \____/
+"""
+
+WELCOME_TEXT = "acra: agentic CLI for LLM task workflows"
+
+
+def render_banner(provider: str, model: str, profile: str, workspace: str, theme: dict) -> Panel:
+    console = Console()
+    lines = [
+        f"[bold {theme['accent']}]acra v0.1.0[/bold {theme['accent']}]",
+        f"Provider: {provider} · Model: {model}",
+        f"Profile: {profile} · Workspace: {workspace}",
+    ]
+    content = "\n".join(lines)
+    return Panel(content, title=WELCOME_TEXT, subtitle=MASCOT, style=theme["border"], border_style=theme["border"])
+
+
+def render_tips(theme: dict) -> Panel:
+    tips = (
+        "• Run acra init to set up your workspace\n"
+        "• Run acra brain models to list available models\n"
+        "• Use / to open commands palette\n"
+        "• Use @ to pick files for context"
+    )
+    return Panel(tips, title="Getting Started", style=theme["border"], border_style=theme["accent"])
+
+
+# Compatibility alias for older imports and public package API.
+welcome_banner = render_banner

acra/ui/components.py

@@ -0,0 +1,32 @@
+"""Shared UI render components for acra."""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from typing import Any
+
+console = Console()
+
+
+def render_panel(content: Any, title: str = "acra") -> None:
+    if isinstance(content, list):
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Name")
+        table.add_column("Status")
+        table.add_column("Value")
+        for item in content:
+            if isinstance(item, dict):
+                table.add_row(
+                    str(item.get("name", "")),
+                    str(item.get("status", "")),
+                    str(item.get("value", "")),
+                )
+            else:
+                table.add_row(str(item), "", "")
+        console.print(Panel(table, title=title))
+    else:
+        console.print(Panel(str(content), title=title))
+
+
+def render_message(message: str) -> None:
+    console.print(message)

acra/ui/shell.py

@@ -0,0 +1,91 @@
+"""Interactive shell implementation for acra."""
+
+import os
+import shlex
+import subprocess
+import sys
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.shortcuts import CompleteStyle
+from acra.ui.banner import render_banner, render_tips
+from acra.ui.theme import get_theme
+from acra.config.profile_manager import ProfileManager
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+
+def _slash_completions():
+    commands = ["serve", "init", "config show", "keys list", "research", "memory list", "session list", "graph show", "brain models"]
+    for command in commands:
+        yield Completion(command, start_position=0)
+
+
+class SlashCompleter(Completer):
+    def get_completions(self, document, complete_event):
+        text = document.text_before_cursor
+        if text.startswith("/"):
+            for completion in _slash_completions():
+                yield completion
+
+
+def launch_shell(profile: str = None, workspace: str = None):
+    config = ProfileManager().load_profile(profile)
+    theme = get_theme(config.get("theme", "dark-orange"))
+    banner = render_banner(
+        config.get("provider", "gemini"),
+        config.get("model", "gemini-2.5-flash"),
+        profile or "default",
+        workspace or config.get("workspace", "."),
+        theme,
+    )
+    console.print(banner)
+    console.print(render_tips(theme))
+    session = PromptSession(
+        "> "
+    )
+    while True:
+        try:
+            user_input = session.prompt(
+                "> ",
+                completer=SlashCompleter(),
+                complete_style=CompleteStyle.COLUMN,
+            )
+            if user_input in ("exit", "quit", "q", "Ctrl+C"):
+                break
+            if not user_input.strip():
+                continue
+
+            command_text = user_input.strip()
+            if command_text.startswith("acra "):
+                command_text = command_text[len("acra "):]
+
+            if command_text in ("exit", "quit", "q"):
+                break
+
+            console.print(f"[dim]→[/dim] {user_input}")
+
+            cmd = [sys.executable, "-m", "acra"] + shlex.split(command_text)
+            completed = subprocess.run(
+                cmd,
+                cwd=os.getcwd(),
+                stdin=sys.stdin,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+            )
+            if completed.stdout:
+                console.print(completed.stdout, soft_wrap=True)
+            if completed.returncode != 0:
+                if completed.stdout and "Missing command" in completed.stdout:
+                    console.print("[dim]Tip:[/dim] try a subcommand such as 'brain models' or 'config init'.")
+                else:
+                    console.print(f"[bold red]Command failed with exit code {completed.returncode}.[/bold red]")
+        except KeyboardInterrupt:
+            break
+        except EOFError:
+            break
+
+    console.print(Panel("Goodbye", title="acra"))

acra/ui/theme.py

@@ -0,0 +1,28 @@
+"""acra theme registry."""
+
+from typing import Dict
+
+THEMES: Dict[str, Dict[str, str]] = {
+    "dark-orange": {
+        "accent": "bright_yellow",
+        "border": "dark_orange",
+        "text": "white",
+        "info": "bright_blue",
+    },
+    "dark-blue": {
+        "accent": "bright_cyan",
+        "border": "blue",
+        "text": "white",
+        "info": "bright_white",
+    },
+    "dark-green": {
+        "accent": "green",
+        "border": "bright_green",
+        "text": "white",
+        "info": "bright_white",
+    },
+}
+
+
+def get_theme(name: str) -> Dict[str, str]:
+    return THEMES.get(name, THEMES["dark-orange"])

acra/utils/__init__.py

@@ -0,0 +1,21 @@
+"""Utility helpers for acra."""
+
+from .keyring_manager import (
+    delete_key,
+    get_key,
+    get_key_status,
+    get_research_key_status,
+    list_keys,
+    set_key,
+)
+from .output_formatter import format_research_report
+
+__all__ = [
+    "delete_key",
+    "get_key",
+    "get_key_status",
+    "get_research_key_status",
+    "list_keys",
+    "set_key",
+    "format_research_report",
+]

acra/utils/context_manager.py

@@ -0,0 +1,20 @@
+"""Context management utilities for acra."""
+
+from __future__ import annotations
+
+from typing import List
+
+
+class ContextManager:
+    """Simple context storage for acra CLI commands."""
+
+    _context_items: List[str] = []
+
+    def add(self, item: str) -> None:
+        self._context_items.append(item)
+
+    def list(self) -> List[str]:
+        return list(self._context_items)
+
+    def clear(self) -> None:
+        self._context_items.clear()

acra/utils/keyring_manager.py

@@ -0,0 +1,83 @@
+"""Key management using OS keyring for acra."""
+
+import os
+from typing import Dict, List, Optional
+
+try:
+    import keyring
+except ImportError:  # pragma: no cover
+    keyring = None
+
+SERVICE_MAIN = "acra"
+SERVICE_RESEARCH = "acra-research"
+KNOWN_RESEARCH_SOURCES = ["web", "github", "docs", "arxiv"]
+
+
+def _service_and_username(name: str) -> (str, str):
+    if name.startswith("research."):
+        return SERVICE_RESEARCH, name.split("research.", 1)[1]
+    return SERVICE_MAIN, name
+
+
+def _mask_value(value: Optional[str]) -> str:
+    if not value:
+        return "not set"
+    if len(value) <= 10:
+        return value
+    return f"{value[:6]}...{value[-4:]}"
+
+
+def _env_key(name: str) -> Optional[str]:
+    if name.startswith("research."):
+        source = name.split("research.", 1)[1].upper()
+        return os.getenv(f"ACRA_RESEARCH_{source}_KEY")
+    if name == "provider":
+        return os.getenv("ACRA_PROVIDER_KEY")
+    return os.getenv(name.upper())
+
+
+def set_key(name: str, value: str) -> None:
+    if keyring is None:
+        raise RuntimeError("keyring is required for storing secrets")
+    service, username = _service_and_username(name)
+    keyring.set_password(service, username, value)
+
+
+def get_key(name: str) -> Optional[str]:
+    if keyring is not None:
+        service, username = _service_and_username(name)
+        value = keyring.get_password(service, username)
+        if value:
+            return value
+    return _env_key(name)
+
+
+def list_keys() -> List[Dict[str, str]]:
+    statuses = []
+    names = ["provider"] + [f"research.{source}" for source in KNOWN_RESEARCH_SOURCES]
+    for name in names:
+        value = get_key(name)
+        status = "configured" if value else "not set"
+        statuses.append({"name": name, "status": status, "value": _mask_value(value)})
+    return statuses
+
+
+def delete_key(name: str) -> None:
+    if keyring is None:
+        raise RuntimeError("keyring is required for deleting secrets")
+    service, username = _service_and_username(name)
+    keyring.delete_password(service, username)
+
+
+def get_key_status(name: str) -> Dict[str, str]:
+    value = get_key(name)
+    return {
+        "name": name,
+        "configured": bool(value),
+        "masked": _mask_value(value),
+    }
+
+
+def get_research_key_status(name: str) -> Dict[str, str]:
+    """Alias for research-specific key status lookup."""
+    return get_key_status(name)

acra/utils/output_formatter.py

@@ -0,0 +1,18 @@
+"""Output formatting utilities for acra."""
+
+from typing import Any, Dict
+
+
+def format_research_report(result: Dict[str, Any], output_format: str = "citations") -> Dict[str, Any]:
+    report = {
+        "query": result.get("user_request"),
+        "summary": result.get("research_summary", ""),
+        "findings": result.get("research_data", []),
+        "sources": result.get("research_sources", []),
+        "status": result.get("research_status", "unknown"),
+    }
+    if output_format == "summary":
+        report = {"query": report["query"], "summary": report["summary"]}
+    elif output_format == "detailed":
+        report["details"] = result
+    return report

acra/utils/session_manager.py

@@ -0,0 +1,59 @@
+"""Session persistence for acra."""
+
+import json
+import os
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+SESSION_DIR = Path.home() / ".acra" / "sessions"
+SESSION_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _session_path(session_id: str) -> Path:
+    return SESSION_DIR / f"{session_id}.json"
+
+
+def create_session(data: Dict[str, Any], name: Optional[str] = None) -> str:
+    session_id = uuid.uuid4().hex[:8]
+    now = datetime.utcnow().isoformat() + "Z"
+    payload = {
+        "id": session_id,
+        "name": name or f"session-{session_id}",
+        "created_at": now,
+        "updated_at": now,
+        "data": data,
+    }
+    with open(_session_path(session_id), "w", encoding="utf-8") as f:
+        json.dump(payload, f, indent=2)
+    return session_id
+
+
+def list_sessions() -> List[Dict[str, Any]]:
+    sessions = []
+    for path in sorted(SESSION_DIR.glob("*.json")):
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                sessions.append(json.load(f))
+        except Exception:
+            continue
+    return sessions
+
+
+def load_session(session_id: str) -> Optional[Dict[str, Any]]:
+    path = _session_path(session_id)
+    if not path.exists():
+        return None
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def save_session(session_id: str, data: Dict[str, Any]) -> None:
+    payload = load_session(session_id)
+    if not payload:
+        raise FileNotFoundError(f"Session not found: {session_id}")
+    payload["data"] = data
+    payload["updated_at"] = datetime.utcnow().isoformat() + "Z"
+    with open(_session_path(session_id), "w", encoding="utf-8") as f:
+        json.dump(payload, f, indent=2)