acra-cli 0.1.1__py3-none-any.whl

acra/brain/provider_manager.py

@@ -0,0 +1,21 @@
+"""Brain provider management utilities for acra."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class ProviderManager:
+    """Stub provider manager for brain commands."""
+
+    def __init__(self) -> None:
+        self.providers: dict[str, dict[str, Any]] = {}
+
+    def add_provider(self, name: str, config: dict[str, Any]) -> None:
+        self.providers[name] = config
+
+    def get_provider(self, name: str) -> dict[str, Any] | None:
+        return self.providers.get(name)
+
+    def list_providers(self) -> list[str]:
+        return list(self.providers)

acra/cli.py

@@ -0,0 +1,52 @@
+"""acra CLI entrypoint."""
+
+import typer
+
+from acra.commands import (
+    serve_app,
+    config_app,
+    keys_app,
+    research_app,
+    memory_app,
+    session_app,
+    graph_app,
+    utils_app,
+)
+from acra.ui.shell import launch_shell
+
+app = typer.Typer(add_completion=True)
+
+app.add_typer(serve_app, name="serve")
+app.add_typer(config_app, name="config")
+app.add_typer(keys_app, name="keys")
+app.add_typer(research_app, name="research")
+app.add_typer(memory_app, name="memory")
+app.add_typer(session_app, name="session")
+app.add_typer(graph_app, name="graph")
+app.add_typer(utils_app, name="workspace")
+
+
+def app_main() -> None:
+    """Run the acra CLI."""
+    app(prog_name="acra")
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    profile: str = typer.Option(None, "--profile", help="Profile to use."),
+    workspace: str = typer.Option(None, "--workspace", help="Override workspace path."),
+    no_memory: bool = typer.Option(False, "--no-memory", help="Run without memory."),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Display planned actions without executing."),
+    json_output: bool = typer.Option(False, "--json", help="Output JSON-formatted results."),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging."),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Suppress output."),
+    timeout: int = typer.Option(0, "--timeout", help="Override execution timeout in seconds."),
+):
+    """acra: Agentic CLI for LLM powered task execution and research workflows."""
+    if ctx.invoked_subcommand is None:
+        launch_shell(profile=profile, workspace=workspace)
+
+
+if __name__ == "__main__":
+    app_main()

acra/commands/__init__.py

@@ -0,0 +1,29 @@
+"""acra command modules."""
+
+from .serve import app as serve_app
+from .config import app as config_app
+from .brain import app as brain_app
+from .research import app as research_app
+from .context import app as context_app
+from .memory import app as memory_app
+from .session import app as session_app
+from .keys import app as keys_app
+from .logs import app as logs_app
+from .graph import app as graph_app
+from .plugin import app as plugin_app
+from .utils import app as utils_app
+
+__all__ = [
+    "serve_app",
+    "config_app",
+    "brain_app",
+    "research_app",
+    "context_app",
+    "memory_app",
+    "session_app",
+    "keys_app",
+    "logs_app",
+    "graph_app",
+    "plugin_app",
+    "utils_app",
+]

acra/commands/ask.py

@@ -0,0 +1,49 @@
+"""Agent task commands for acra."""
+
+import uuid
+from typing import Optional
+
+from acra.graph.workflow import OmniAgentCallbacks, omniagent_graph
+from acra.ui.components import render_panel
+
+
+def _run_task(task: str, task_label: str, profile: Optional[str] = None, no_memory: bool = False):
+    state = {
+        "user_request": task,
+        "task_label": task_label,
+        "no_memory": no_memory,
+        "profile": profile,
+    }
+    result = omniagent_graph.invoke(state, config={"callbacks": [OmniAgentCallbacks()]})
+    render_panel(result, title=task_label)
+    return result
+
+
+def ask(task: str, profile: Optional[str] = None, no_memory: bool = False):
+    """Ask the assistant a question."""
+    return _run_task(task, "ask", profile, no_memory)
+
+
+def build(task: str, profile: Optional[str] = None, no_memory: bool = False):
+    """Run a build workflow for a project task."""
+    return _run_task(task, "build", profile, no_memory)
+
+
+def fix(task: str, profile: Optional[str] = None, no_memory: bool = False):
+    """Run a fix workflow for a code issue."""
+    return _run_task(task, "fix", profile, no_memory)
+
+
+def review(task: str, profile: Optional[str] = None, no_memory: bool = False):
+    """Review code or design with the critic pipeline."""
+    return _run_task(task, "review", profile, no_memory)
+
+
+def explain(task: str, profile: Optional[str] = None, no_memory: bool = False):
+    """Explain a technical concept or code path."""
+    return _run_task(task, "explain", profile, no_memory)
+
+
+def run(task: str, profile: Optional[str] = None, no_memory: bool = False):
+    """Execute a task using the executor agent."""
+    return _run_task(task, "run", profile, no_memory)

acra/commands/brain.py

@@ -0,0 +1,58 @@
+"""Brain management commands for acra."""
+
+import typer
+from typing import Optional
+
+from acra.brain.provider_manager import ProviderManager
+from acra.brain.model_registry import ModelRegistry
+from acra.config.profile_manager import ProfileManager
+from acra.ui.components import render_panel
+
+app = typer.Typer(help="Brain management commands for acra.")
+
+
+@app.command("add")
+def add_brain(name: str = typer.Argument(..., help="Brain name to add."), provider: str = typer.Option(..., help="LLM provider to associate.")):
+    """Add a new brain profile."""
+    manager = ProfileManager()
+    profile = manager.load_profile()
+    profile.setdefault("brains", {})[name] = {"provider": provider}
+    manager.save_profile(profile_name=profile.get("name", "default"), profile_data=profile)
+    render_panel(f"Added brain '{name}' using provider {provider}.")
+
+
+@app.command("use")
+def use_brain(name: str = typer.Argument(..., help="Brain name to activate.")):
+    """Switch to a saved brain."""
+    profile = ProfileManager().load_profile()
+    if name not in profile.get("brains", {}):
+        raise typer.BadParameter(f"Brain not found: {name}")
+    profile["active_brain"] = name
+    ProfileManager().save_profile(profile_name=profile.get("name", "default"), profile_data=profile)
+    render_panel(f"Using brain '{name}'.")
+
+
+@app.command("list")
+def list_brains():
+    """List configured brains."""
+    profile = ProfileManager().load_profile()
+    brains = profile.get("brains", {})
+    if not brains:
+        render_panel("No brains configured.")
+        return
+    rows = [{"name": name, "status": "active" if name == profile.get("active_brain") else "inactive", "value": brain["provider"]} for name, brain in brains.items()]
+    render_panel(rows, title="Brains")
+
+
+@app.command("test")
+def test_brain(name: str = typer.Argument(..., help="Brain name to test.")):
+    """Test a brain configuration."""
+    render_panel(f"Tested brain '{name}'. (stubbed)")
+
+
+@app.command("models")
+def list_models(provider: Optional[str] = typer.Option(None, help="Provider to list models for.")):
+    """List available models for a provider."""
+    registry = ModelRegistry()
+    choices = registry.list_models(provider)
+    render_panel(choices, title=f"Models for {provider or 'all providers'}")

acra/commands/config.py

@@ -0,0 +1,25 @@
+"""Configuration and initialization commands for acra."""
+
+import typer
+from typing import Optional
+
+from acra.config.profile_manager import ProfileManager
+from acra.ui.components import render_message
+
+app = typer.Typer(help="Configuration commands for acra.")
+
+
+@app.command("init")
+def init(profile: Optional[str] = typer.Option(None, help="Profile name to create")):
+    """Run first-time setup and save a config profile."""
+    manager = ProfileManager()
+    profile_name = manager.run_wizard(profile_name=profile)
+    render_message(f"Created profile: {profile_name}")
+
+
+@app.command("show")
+def show(profile: Optional[str] = typer.Option(None, help="Profile name to display")):
+    """Show the active profile configuration."""
+    manager = ProfileManager()
+    config = manager.load_profile(profile)
+    render_message(str(config))

acra/commands/context.py

@@ -0,0 +1,30 @@
+"""Context management commands for acra."""
+
+import typer
+from typing import List
+
+from acra.utils.context_manager import ContextManager
+from acra.ui.components import render_panel
+
+app = typer.Typer(help="Context management commands for acra.")
+
+
+@app.command("add")
+def add_context(item: str = typer.Argument(..., help="Context item to add.")):
+    """Add a context item."""
+    ContextManager().add(item)
+    render_panel(f"Added context: {item}")
+
+
+@app.command("list")
+def list_context():
+    """List stored context items."""
+    items = ContextManager().list()
+    render_panel(items, title="Context")
+
+
+@app.command("clear")
+def clear_context():
+    """Clear all stored context."""
+    ContextManager().clear()
+    render_panel("Context cleared.")

acra/commands/graph.py

@@ -0,0 +1,18 @@
+"""Graph utility commands for acra."""
+
+import typer
+from acra.ui.components import render_panel
+
+app = typer.Typer(help="Graph commands for acra.")
+
+
+@app.command("show")
+def show_graph():
+    """Show the workflow graph structure."""
+    render_panel("Graph visualization is not implemented yet.")
+
+
+@app.command("run")
+def run_graph():
+    """Run the workflow graph directly."""
+    render_panel("Graph run not implemented yet.")

acra/commands/keys.py

@@ -0,0 +1,40 @@
+"""Key management commands for acra."""
+
+import typer
+from typing import Optional
+
+from acra.utils.keyring_manager import (
+    set_key,
+    get_key_status,
+    delete_key,
+    list_keys,
+)
+from acra.ui.components import render_panel
+
+app = typer.Typer(help="Key management commands for acra.")
+
+
+@app.command("set")
+def set_key_cmd(
+    name: str = typer.Argument(..., help="Key name, e.g. provider or research.github"),
+    value: Optional[str] = typer.Argument(None, help="API key value. If omitted, you will be prompted."),
+):
+    """Set a provider or research API key."""
+    if value is None:
+        value = typer.prompt("Enter API key", hide_input=True)
+    set_key(name, value)
+    render_panel(f"Key set: {name}")
+
+
+@app.command("list")
+def list_key_cmd():
+    """List configured API keys."""
+    rows = list_keys()
+    render_panel(rows, title="Configured Keys")
+
+
+@app.command("delete")
+def delete_key_cmd(name: str = typer.Argument(..., help="Key name to delete.")):
+    """Delete a configured API key."""
+    delete_key(name)
+    render_panel(f"Deleted key: {name}")

acra/commands/logs.py

@@ -0,0 +1,13 @@
+"""Logging commands for acra."""
+
+import typer
+
+from acra.ui.components import render_panel
+
+app = typer.Typer(help="Logging commands for acra.")
+
+
+@app.command("show")
+def show_logs(limit: int = typer.Option(10, help="Number of log entries to show.")):
+    """Show recent log entries."""
+    render_panel([{"timestamp": "2024-01-01T00:00:00Z", "message": "Placeholder log entry."}], title=f"Last {limit} logs")

acra/commands/memory.py

@@ -0,0 +1,27 @@
+"""Memory commands for acra."""
+
+import typer
+from typing import Optional
+
+from acra.utils.keyring_manager import get_key_status
+from acra.ui.components import render_panel
+
+app = typer.Typer(help="Memory commands for acra.")
+
+
+@app.command("list")
+def list_memory():
+    """List memory entries."""
+    render_panel("Memory listing not implemented yet.")
+
+
+@app.command("clear")
+def clear_memory():
+    """Clear memory entries."""
+    render_panel("Memory cleared.")
+
+
+@app.command("search")
+def search_memory(query: str = typer.Argument(..., help="Search query.")):
+    """Search memory using semantic search."""
+    render_panel(f"Search results for: {query}")

acra/commands/plugin.py

@@ -0,0 +1,18 @@
+"""Plugin commands for acra."""
+
+import typer
+from acra.ui.components import render_panel
+
+app = typer.Typer(help="Plugin commands for acra.")
+
+
+@app.command("list")
+def list_plugins():
+    """List installed plugins."""
+    render_panel("No plugins installed.")
+
+
+@app.command("add")
+def add_plugin(name: str = typer.Argument(..., help="Plugin name to add.")):
+    """Add a plugin."""
+    render_panel(f"Plugin {name} added. (stubbed)")

acra/commands/research.py

@@ -0,0 +1,65 @@
+"""Research command module for acra."""
+
+import json
+import typer
+from typing import List, Optional
+
+from acra.graph.workflow import OmniAgentCallbacks, create_workflow
+from acra.config.profile_manager import ProfileManager
+from acra.utils.output_formatter import format_research_report
+from acra.utils.keyring_manager import get_research_key_status
+from acra.ui.components import render_panel
+
+app = typer.Typer(help="Research commands for acra.")
+
+
+def _load_profile(profile: Optional[str]):
+    manager = ProfileManager()
+    return manager.load_profile(profile)
+
+
+@app.command()
+def research(
+    query: str = typer.Argument(..., help="The research topic or question."),
+    depth: str = typer.Option("standard", help="Research depth: shallow, standard, deep."),
+    sources: str = typer.Option("all", help="Comma-separated sources to use."),
+    format: str = typer.Option("citations", help="Output format: citations, summary, detailed."),
+    output: Optional[str] = typer.Option(None, help="Write research output to a file."),
+    save: bool = typer.Option(False, help="Persist research output into memory."),
+    follow_up: bool = typer.Option(False, help="Keep the session open for follow-up questions."),
+    no_memory: bool = typer.Option(False, help="Skip memory persistence for this research."),
+    profile: Optional[str] = typer.Option(None, help="Profile to use."),
+    json_output: bool = typer.Option(False, "--json", help="Output JSON instead of rich text."),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed debug output."),
+):
+    """Run a standalone research workflow using the Researcher agent."""
+    config = _load_profile(profile)
+    source_list = [s.strip() for s in sources.split(",") if s.strip()]
+    if not source_list:
+        source_list = ["all"]
+
+    # Minimal research subgraph under the researcher agent.
+    workflow = create_workflow()
+    state = {
+        "user_request": query,
+        "research_depth": depth,
+        "research_sources": source_list,
+        "follow_up": follow_up,
+        "save_to_memory": save and not no_memory,
+        "profile": profile,
+    }
+
+    result = workflow.invoke(state, config={"callbacks": [OmniAgentCallbacks()]})
+
+    report = format_research_report(result, output_format=format)
+
+    if output:
+        with open(output, "w", encoding="utf-8") as f:
+            if output.endswith(".json"):
+                json.dump(report, f, indent=2)
+            else:
+                f.write(str(report))
+
+    render_panel(report, title="Research Results")
+    if json_output:
+        typer.echo(json.dumps(report, indent=2))

acra/commands/serve.py

@@ -0,0 +1,13 @@
+"""Interactive shell command for acra."""
+
+import typer
+from acra.ui.shell import launch_shell
+
+app = typer.Typer(help="Interactive shell for acra.", invoke_without_command=True)
+
+
+@app.callback()
+def serve(ctx: typer.Context):
+    """Launch the interactive acra shell."""
+    if ctx.invoked_subcommand is None:
+        launch_shell()

acra/commands/session.py

@@ -0,0 +1,20 @@
+"""Session commands for acra."""
+
+import typer
+from typing import Optional
+
+from acra.ui.components import render_panel
+
+app = typer.Typer(help="Session commands for acra.")
+
+
+@app.command("list")
+def list_sessions():
+    """List saved sessions."""
+    render_panel("No sessions found.")
+
+
+@app.command("resume")
+def resume_session(session_id: str = typer.Argument(..., help="Session ID to resume.")):
+    """Resume a saved session."""
+    render_panel(f"Resuming session {session_id}")

acra/commands/utils.py

@@ -0,0 +1,12 @@
+"""General utility commands for acra."""
+
+import typer
+from acra.ui.components import render_panel
+
+app = typer.Typer(help="Utility commands for acra.")
+
+
+@app.command()
+def workspace():
+    """Show the current workspace path and status."""
+    render_panel("Workspace utilities are not implemented yet.")

acra/config/__init__.py

@@ -0,0 +1,36 @@
+"""acra configuration package."""
+
+from .defaults import *
+from .profile_manager import ProfileManager
+
+__all__ = [
+    "ProfileManager",
+    "PROJECT_ROOT",
+    "USER_DATA_DIR",
+    "GENERATED_PROJECT_DIR",
+    "MEMORY_STORAGE_DIR",
+    "CHROMA_DB_PATH",
+    "CHECKPOINT_DIR",
+    "SQLITE_DB_PATH",
+    "LLM_PROVIDER",
+    "LLM_TEMPERATURE",
+    "GEMINI_MODEL",
+    "GEMINI_API_KEY",
+    "OPENAI_MODEL",
+    "OPENAI_API_KEY",
+    "GROQ_MODEL",
+    "GROQ_API_KEY",
+    "OLLAMA_MODEL",
+    "OLLAMA_BASE_URL",
+    "HF_MODEL",
+    "HF_API_KEY",
+    "HF_DEVICE",
+    "HF_LOCAL_REPO",
+    "MAX_RETRIES",
+    "EXECUTION_TIMEOUT",
+    "CHECKPOINT_BACKEND",
+    "MEMORY_MAX_ENTRIES",
+    "SHORT_TERM_MEM_LIMIT",
+    "MEMORY_LOG_TRUNCATE",
+    "EMBEDDING_MODEL",
+]

acra/config/defaults.py

@@ -0,0 +1,88 @@
+"""
+OmniAgent central configuration.
+All hardcoded constants live here. Import from this module everywhere.
+"""
+import os
+from pathlib import Path
+try:
+    from dotenv import load_dotenv
+except ImportError:
+    def load_dotenv():
+        return False
+
+try:
+    from platformdirs import user_data_dir
+except ImportError:
+    user_data_dir = None
+
+load_dotenv()
+
+# Project root
+PROJECT_ROOT = Path(__file__).resolve().parent
+
+# User data directory — resolves to the right place per OS:
+#   Linux:   ~/.local/share/omniagent
+#   macOS:   ~/Library/Application Support/omniagent
+#   Windows: C:\Users\<you>\AppData\Local\omniagent\omniagent
+def _default_user_data_dir() -> str:
+    if user_data_dir is not None:
+        return user_data_dir("omniagent", "omniagent")
+    return str(Path.home() / ".local" / "share" / "omniagent")
+
+
+USER_DATA_DIR = Path(
+    os.getenv("OMNIAGENT_DATA_DIR") or _default_user_data_dir()
+).expanduser().resolve()
+
+# Paths
+GENERATED_PROJECT_DIR = USER_DATA_DIR / "projects" 
+MEMORY_STORAGE_DIR    = USER_DATA_DIR / "memory" / "storage"
+CHROMA_DB_PATH        = USER_DATA_DIR / "memory" / "chroma_db"
+CHECKPOINT_DIR        = USER_DATA_DIR / "memory" / "checkpoints" / "data"
+SQLITE_DB_PATH        = CHECKPOINT_DIR / "workflow_checkpoints.db"
+
+# Ensure directories exist
+for _dir in [GENERATED_PROJECT_DIR, MEMORY_STORAGE_DIR, CHROMA_DB_PATH, CHECKPOINT_DIR]:
+    _dir.mkdir(parents=True, exist_ok=True)
+
+# LLM Configuration
+# Provider selection: "gemini", "openai", "groq", "ollama", "huggingface_local", "huggingface_cloud"
+LLM_PROVIDER      = os.getenv("LLM_PROVIDER", "gemini")
+LLM_TEMPERATURE   = float(os.getenv("LLM_TEMPERATURE", "0.6"))
+
+# Google Gemini
+GEMINI_MODEL      = os.getenv("GEMINI_MODEL", "gemini-2.5-flash")
+GEMINI_API_KEY    = os.getenv("GOOGLE_GEMINI_API_KEY", "")
+
+# OpenAI
+OPENAI_MODEL      = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+OPENAI_API_KEY    = os.getenv("OPENAI_API_KEY", "")
+
+# Groq
+GROQ_MODEL        = os.getenv("GROQ_MODEL", "llama-3.3-70b-versatile")
+GROQ_API_KEY      = os.getenv("GROQ_API_KEY", "")
+
+# Ollama (local inference)
+OLLAMA_MODEL      = os.getenv("OLLAMA_MODEL", "mistral")
+OLLAMA_BASE_URL   = os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
+
+# HuggingFace
+HF_MODEL          = os.getenv("HF_MODEL", "mistralai/Mistral-7B-Instruct-v0.1")
+HF_API_KEY        = os.getenv("HF_API_KEY", "")
+HF_DEVICE         = os.getenv("HF_DEVICE", "cpu")  # "cpu" or "cuda"
+HF_LOCAL_REPO     = str(Path(os.getenv("HF_LOCAL_REPO", str(USER_DATA_DIR / "hf_models"))).expanduser())
+
+# Workflow limits
+MAX_RETRIES       = 5
+EXECUTION_TIMEOUT = 60  # seconds
+
+# Checkpointing
+CHECKPOINT_BACKEND = os.getenv("CHECKPOINT_BACKEND", "sqlite")
+
+# Memory
+MEMORY_MAX_ENTRIES   = 500
+SHORT_TERM_MEM_LIMIT = 20
+MEMORY_LOG_TRUNCATE  = 2000  # chars
+
+# Embedding
+EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"