acra-cli 0.1.1__py3-none-any.whl

acra/agents/human/human_node.py

@@ -0,0 +1,37 @@
+"""
+Human approval node.
+Pauses the workflow and waits for human input via stdin (CLI) or sets
+approved=False automatically in non-interactive environments.
+"""
+import sys
+from typing import Dict
+from langchain_core.messages import AIMessage
+from acra.graph.state import AgentState
+
+
+def human_node(state: AgentState) -> Dict:
+    """
+    Human-in-the-loop approval node.
+    In a TTY environment, prompts the user. Otherwise auto-denies.
+    """
+    reason = state.get("critic_feedback", "Agent requested human review.")
+    print(f"\n[HUMAN APPROVAL REQUIRED]\n{reason}\n")
+
+    approved = False
+    feedback = ""
+
+    if sys.stdin.isatty():
+        answer = input("Approve? (y/n): ").strip().lower()
+        approved = answer == "y"
+        if not approved:
+            feedback = input("Feedback (optional): ").strip()
+    else:
+        print("Non-interactive environment — auto-denying.")
+
+    return {
+        "messages": [AIMessage(content=f"Human node: {'Approved' if approved else 'Denied'}.")],
+        "approved": approved,
+        "human_feedback": feedback,
+        "next_agent": "coder" if approved else "end",
+        "current_agent": "human",
+    }

acra/agents/llm.py

@@ -0,0 +1,263 @@
+"""
+LLM initialisation for OmniAgent.
+Supports multiple LLM providers: Google Gemini, OpenAI, Groq, Ollama, HuggingFace.
+Cached as a singleton — calling llm() multiple times returns the same instance.
+"""
+import functools
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING, Union
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Import provider-specific modules
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+try:
+    from langchain_openai import ChatOpenAI
+    OPENAI_AVAILABLE = True
+except ImportError:
+    ChatOpenAI = None
+    OPENAI_AVAILABLE = False
+
+try:
+    from langchain_groq import ChatGroq
+    GROQ_AVAILABLE = True
+except ImportError:
+    ChatGroq = None
+    GROQ_AVAILABLE = False
+
+# HuggingFace imports (handled gracefully if not installed)
+try:
+    from langchain_huggingface import HuggingFaceEndpoint, ChatHuggingFace
+    from langchain_huggingface.llms import HuggingFacePipeline
+    HF_AVAILABLE = True
+except ImportError:
+    HuggingFaceEndpoint = None
+    ChatHuggingFace = None
+    HuggingFacePipeline = None
+    HF_AVAILABLE = False
+
+# Ollama imports (handled gracefully if not installed)
+try:
+    from langchain_ollama import OllamaLLM
+    OLLAMA_AVAILABLE = True
+except ImportError:
+    OllamaLLM = None
+    OLLAMA_AVAILABLE = False
+
+if TYPE_CHECKING:
+    from langchain_google_genai import ChatGoogleGenerativeAI
+    from langchain_openai import ChatOpenAI
+    from langchain_groq import ChatGroq
+    from langchain_ollama import OllamaLLM
+    from langchain_huggingface import ChatHuggingFace
+    from langchain_huggingface.llms import HuggingFacePipeline
+
+from acra.config import (
+    LLM_PROVIDER, LLM_TEMPERATURE,
+    GEMINI_MODEL,
+    OPENAI_MODEL,
+    GROQ_MODEL,
+    OLLAMA_MODEL, OLLAMA_BASE_URL,
+    HF_MODEL, HF_DEVICE, HF_LOCAL_REPO,
+)
+
+
+class LLMInitializationError(Exception):
+    """Raised when LLM initialization fails."""
+    pass
+
+
+def _init_gemini():
+    """Initialize Google Gemini LLM."""
+    gemini_api_key = os.getenv("GOOGLE_GEMINI_API_KEY") or os.getenv("GEMINI_API_KEY")
+    if not gemini_api_key or gemini_api_key.startswith("your_"):
+        raise EnvironmentError(
+            "GEMINI_API_KEY is not set. Add GOOGLE_GEMINI_API_KEY to your .env file."
+        )
+    os.environ["GOOGLE_API_KEY"] = gemini_api_key
+    return ChatGoogleGenerativeAI(
+        model=GEMINI_MODEL,
+        temperature=LLM_TEMPERATURE
+    )
+
+
+def _init_openai():
+    """Initialize OpenAI LLM."""
+    if not OPENAI_AVAILABLE:
+        raise LLMInitializationError(
+            "OpenAI support is not installed. Install with: pip install langchain-openai"
+        )
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    if not openai_api_key or openai_api_key.startswith("your_"):
+        raise LLMInitializationError(
+            "OPENAI_API_KEY is not set. Add OPENAI_API_KEY to your .env file."
+        )
+    return ChatOpenAI(
+        model=OPENAI_MODEL,
+        api_key=openai_api_key,
+        temperature=LLM_TEMPERATURE
+    )
+
+
+def _init_groq():
+    """Initialize Groq LLM."""
+    if not GROQ_AVAILABLE:
+        raise LLMInitializationError(
+            "Groq support is not installed. Install with: pip install langchain-groq"
+        )
+    groq_api_key = os.getenv("GROQ_API_KEY")
+    if not groq_api_key or groq_api_key.startswith("your_"):
+        raise LLMInitializationError(
+            "GROQ_API_KEY is not set. Add GROQ_API_KEY to your .env file."
+        )
+    return ChatGroq(
+        model=GROQ_MODEL,
+        api_key=groq_api_key,
+        temperature=LLM_TEMPERATURE
+    )
+
+
+def _init_ollama():
+    """Initialize Ollama LLM (local inference)."""
+    if not OLLAMA_AVAILABLE:
+        raise LLMInitializationError(
+            "Ollama not installed. Install with: pip install langchain-ollama"
+        )
+    
+    try:
+        # Test connection
+        llm = OllamaLLM(
+            model=OLLAMA_MODEL,
+            base_url=OLLAMA_BASE_URL,
+            temperature=LLM_TEMPERATURE
+        )
+        return llm
+    except Exception as e:
+        raise LLMInitializationError(
+            f"Failed to connect to Ollama at {OLLAMA_BASE_URL}. "
+            f"Ensure Ollama is running with: ollama serve\nError: {e}"
+        )
+
+
+def _init_huggingface_cloud():
+    """Initialize HuggingFace cloud-based LLM (via API)."""
+    if not HF_AVAILABLE:
+        raise LLMInitializationError(
+            "HuggingFace not installed. Install with: pip install langchain-huggingface"
+        )
+
+    huggingface_api_key = os.getenv("HF_API_KEY")
+    if not huggingface_api_key or huggingface_api_key.startswith("your_"):
+        raise LLMInitializationError(
+            "HF_API_KEY is not set. Add HF_API_KEY to your .env file. "
+            "Get a token at: https://huggingface.co/settings/tokens"
+        )
+
+    endpoint = HuggingFaceEndpoint(
+        repo_id=HF_MODEL,
+        huggingfacehub_api_token=huggingface_api_key,
+        temperature=LLM_TEMPERATURE
+    )
+    
+    return ChatHuggingFace(llm=endpoint)
+
+
+def _init_huggingface_local():
+    """Initialize HuggingFace local model (requires transformers & torch)."""
+    if not HF_AVAILABLE:
+        raise LLMInitializationError(
+            "HuggingFace not installed. Install with: pip install langchain-huggingface"
+        )
+    
+    try:
+        from transformers import pipeline
+        
+        # Create local repo directory
+        repo_path = Path(HF_LOCAL_REPO)
+        repo_path.mkdir(parents=True, exist_ok=True)
+        
+        # Initialize pipeline
+        pipe = pipeline(
+            "text-generation",
+            model=HF_MODEL,
+            device=0 if HF_DEVICE == "cuda" else -1,  # 0 for GPU, -1 for CPU
+            model_kwargs={"cache_dir": str(repo_path)}
+        )
+        
+        llm = HuggingFacePipeline(
+            model_id=HF_MODEL,
+            task="text-generation",
+            pipeline=pipe
+        )
+        return llm
+    except ImportError as e:
+        raise LLMInitializationError(
+            f"HuggingFace local model requires transformers and torch. "
+            f"Install with: pip install transformers torch\nError: {e}"
+        )
+    except Exception as e:
+        raise LLMInitializationError(
+            f"Failed to initialize HuggingFace local model {HF_MODEL}. "
+            f"Error: {e}"
+        )
+
+
+@functools.lru_cache(maxsize=32)
+def _get_cached_llm(
+    provider: str,
+    gemini_api_key: str,
+    openai_api_key: str,
+    groq_api_key: str,
+    hf_api_key: str,
+    ollama_model: str,
+    ollama_base_url: str,
+    hf_model: str,
+    hf_device: str,
+    hf_local_repo: str,
+    temperature: str,
+):
+    if provider == "gemini":
+        return _init_gemini()
+    if provider == "openai":
+        return _init_openai()
+    if provider == "groq":
+        return _init_groq()
+    if provider == "ollama":
+        return _init_ollama()
+    if provider == "huggingface_local":
+        return _init_huggingface_local()
+    if provider == "huggingface_cloud":
+        return _init_huggingface_cloud()
+    raise LLMInitializationError(
+        f"Unknown LLM_PROVIDER: {provider}. "
+        f"Supported providers: gemini, openai, groq, ollama, huggingface_local, huggingface_cloud"
+    )
+
+
+def llm() -> Union[
+    "ChatGoogleGenerativeAI",
+    "ChatOpenAI",
+    "ChatGroq",
+    "OllamaLLM",
+    "ChatHuggingFace",
+    "HuggingFacePipeline",
+]:
+    """Return a cached LLM instance based on the current provider configuration."""
+    provider = os.getenv("LLM_PROVIDER", LLM_PROVIDER).lower().strip()
+    return _get_cached_llm(
+        provider,
+        os.getenv("GOOGLE_GEMINI_API_KEY") or os.getenv("GEMINI_API_KEY"),
+        os.getenv("OPENAI_API_KEY"),
+        os.getenv("GROQ_API_KEY"),
+        os.getenv("HF_API_KEY"),
+        os.getenv("OLLAMA_MODEL", OLLAMA_MODEL),
+        os.getenv("OLLAMA_BASE_URL", OLLAMA_BASE_URL),
+        os.getenv("HF_MODEL", HF_MODEL),
+        os.getenv("HF_DEVICE", HF_DEVICE),
+        os.getenv("HF_LOCAL_REPO", HF_LOCAL_REPO),
+        str(LLM_TEMPERATURE),
+    )

acra/agents/llm_utils.py

@@ -0,0 +1,161 @@
+"""
+LLM provider utilities for testing and debugging.
+Run with: python -m agents.llm_utils
+"""
+import sys
+from pathlib import Path
+
+# Add project root to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from acra.agents.llm import llm, LLMInitializationError
+from acra.config import (
+    LLM_PROVIDER, LLM_TEMPERATURE,
+    GEMINI_API_KEY, OPENAI_API_KEY, GROQ_API_KEY,
+    HF_API_KEY, OLLAMA_BASE_URL, HF_MODEL, OLLAMA_MODEL
+)
+
+
+def print_config():
+    """Print current LLM configuration."""
+    print("\n" + "="*60)
+    print("OmniAgent LLM Configuration")
+    print("="*60)
+    print(f"\nProvider: {LLM_PROVIDER}")
+    print(f"Temperature: {LLM_TEMPERATURE}")
+    
+    print("\n" + "-"*60)
+    print("Credentials Status:")
+    print("-"*60)
+    print(f"Gemini API Key:     {'✓ Set' if GEMINI_API_KEY else '✗ Not set'}")
+    print(f"OpenAI API Key:     {'✓ Set' if OPENAI_API_KEY else '✗ Not set'}")
+    print(f"Groq API Key:       {'✓ Set' if GROQ_API_KEY else '✗ Not set'}")
+    print(f"HuggingFace Token:  {'✓ Set' if HF_API_KEY else '✗ Not set'}")
+    
+    print("\n" + "-"*60)
+    print("Provider-Specific Config:")
+    print("-"*60)
+    print(f"Ollama Base URL:    {OLLAMA_BASE_URL}")
+    print(f"Ollama Model:       {OLLAMA_MODEL}")
+    print(f"HuggingFace Model:  {HF_MODEL}")
+
+
+def test_provider():
+    """Test if the current LLM provider works."""
+    print("\n" + "="*60)
+    print(f"Testing LLM Provider: {LLM_PROVIDER}")
+    print("="*60 + "\n")
+    
+    try:
+        print(f"Initializing {LLM_PROVIDER} provider...", end=" ")
+        llm_instance = llm()
+        print("✓ Success!\n")
+        
+        print(f"Provider type: {type(llm_instance).__name__}")
+        print(f"Model: {getattr(llm_instance, 'model_name', getattr(llm_instance, 'model', 'Unknown'))}")
+        
+        # Test a simple prompt
+        print("\nTesting with simple prompt: 'Say hello'")
+        print("-"*60)
+        response = llm_instance.invoke("Say hello in one sentence.")
+        print(response.content if hasattr(response, 'content') else str(response))
+        print("-"*60)
+        print("\n✓ Provider test successful!")
+        return True
+        
+    except LLMInitializationError as e:
+        print(f"\n✗ Initialization Error:\n{e}")
+        return False
+    except Exception as e:
+        print(f"\n✗ Error: {e}")
+        print("\nTroubleshooting tips:")
+        if "connection" in str(e).lower():
+            print("- Check your internet connection")
+            print("- Verify the API endpoint is accessible")
+        if "key" in str(e).lower() or "auth" in str(e).lower():
+            print("- Verify your API credentials in .env file")
+        print("\nFor more help, see docs/LLM_PROVIDER_GUIDE.md")
+        return False
+
+
+def list_providers():
+    """List all available providers and their status."""
+    print("\n" + "="*60)
+    print("Available LLM Providers")
+    print("="*60 + "\n")
+    
+    providers = {
+        "gemini": {
+            "description": "Google Gemini API",
+            "credential_env": "GOOGLE_GEMINI_API_KEY",
+            "setup": "https://aistudio.google.com/app/apikeys"
+        },
+        "openai": {
+            "description": "OpenAI GPT models",
+            "credential_env": "OPENAI_API_KEY",
+            "setup": "https://platform.openai.com/api-keys"
+        },
+        "groq": {
+            "description": "Groq API (fastest inference)",
+            "credential_env": "GROQ_API_KEY",
+            "setup": "https://console.groq.com/keys"
+        },
+        "ollama": {
+            "description": "Local Ollama inference",
+            "credential_env": "None (local)",
+            "setup": "https://ollama.ai"
+        },
+        "huggingface_local": {
+            "description": "Local HuggingFace models",
+            "credential_env": "None (local)",
+            "setup": "pip install transformers torch"
+        },
+        "huggingface_cloud": {
+            "description": "HuggingFace Inference API",
+            "credential_env": "HF_API_KEY",
+            "setup": "https://huggingface.co/settings/tokens"
+        }
+    }
+    
+    for name, info in providers.items():
+        is_current = "← CURRENT" if name == LLM_PROVIDER.lower() else ""
+        print(f"{name.upper()} {is_current}")
+        print(f"  Description: {info['description']}")
+        print(f"  Credential:  {info['credential_env']}")
+        print(f"  Setup:       {info['setup']}")
+        print()
+
+
+def main():
+    """Run diagnostic utilities."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(
+        description="OmniAgent LLM Provider Utilities"
+    )
+    parser.add_argument(
+        "command",
+        choices=["config", "test", "list"],
+        help="Command to run"
+    )
+    
+    args = parser.parse_args()
+    
+    if args.command == "config":
+        print_config()
+    elif args.command == "test":
+        success = test_provider()
+        sys.exit(0 if success else 1)
+    elif args.command == "list":
+        list_providers()
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print(__doc__)
+        print("\nUsage:")
+        print("  python -m agents.llm_utils config  # Show current configuration")
+        print("  python -m agents.llm_utils test    # Test the current provider")
+        print("  python -m agents.llm_utils list    # List all available providers")
+    else:
+        main()

acra/agents/memory/memory_agent.py

@@ -0,0 +1,239 @@
+from typing import Dict
+
+from langchain_core.messages import AIMessage
+
+from acra.graph.state import AgentState
+
+from acra.agents.memory.memory_manager import (
+    get_memory_manager
+)
+
+from acra.agents.memory.retrieval import (
+    get_memory_retrieval
+)
+
+
+def memory_agent(state: AgentState) -> Dict:
+    """
+    Memory Agent
+
+    Responsibilities:
+    - Persist workflow memories
+    - Store successful execution patterns
+    - Store runtime failures
+    - Build historical context
+    - Retrieve relevant memories
+    - Support long-term autonomous reasoning
+    """
+
+    # extract state
+
+    session_id = state.get(
+        "session_id",
+        "default_session"
+    )
+
+    user_request = state.get(
+        "user_request",
+        ""
+    )
+
+    current_step = state.get(
+        "current_step",
+        ""
+    )
+
+    workflow_status = state.get(
+        "workflow_status",
+        ""
+    )
+
+    execution_success = state.get(
+        "execution_success",
+        False
+    )
+
+    execution_logs = state.get(
+        "execution_logs",
+        ""
+    )
+
+    error_message = state.get(
+        "error_message",
+        ""
+    )
+
+    generated_files = state.get(
+        "generated_files",
+        {}
+    )
+
+    critic_feedback = state.get(
+        "critic_feedback",
+        ""
+    )
+
+    quality_score = state.get(
+        "quality_score",
+        0
+    )
+
+    retry_count = state.get(
+        "retry_count",
+        0
+    )
+
+    next_agent = state.get(
+        "next_agent",
+        "end"
+    )
+
+
+    # initialize memory manager and retrieval system
+
+    memory_manager = get_memory_manager(
+        session_id=session_id
+    )
+
+    retrieval_system = get_memory_retrieval(
+        session_id=session_id
+    )
+
+
+    # determine memory type
+
+    if execution_success and quality_score >= 8:
+
+        memory_type = "successful_execution"
+
+    elif error_message:
+
+        memory_type = "execution_failure"
+
+    elif critic_feedback:
+
+        memory_type = "critic_feedback"
+
+    else:
+
+        memory_type = "workflow_context"
+
+
+    # build memory content
+
+    memory_content = {
+
+        "user_request": user_request,
+
+        "current_step": current_step,
+
+        "workflow_status": workflow_status,
+
+        "execution_success": execution_success,
+
+        "quality_score": quality_score,
+
+        "retry_count": retry_count,
+
+        "error_message": error_message,
+
+        "critic_feedback": critic_feedback,
+
+        "generated_files": list(
+            generated_files.keys()
+        ),
+
+        "execution_logs": (
+            execution_logs[:2000]
+            if execution_logs
+            else ""
+        )
+    }
+
+
+    # store memory
+
+    memory_manager.add_memory(
+        memory_type=memory_type,
+        content=memory_content
+    )
+
+
+    # retrieve relevant memories for context building
+
+    relevant_memories = (
+        retrieval_system.get_relevant_memories(
+            query=user_request,
+            limit=3
+        )
+    )
+
+
+    # retrieve similar past failures if current execution failed
+
+    similar_failures = []
+
+    if error_message:
+
+        similar_failures = (
+            retrieval_system.get_error_solutions(
+                error_message=error_message,
+                limit=3
+            )
+        )
+
+
+    # memory statistics
+
+    memory_stats = (
+        retrieval_system.get_memory_insights()
+    )
+
+
+    # build memory message
+
+    if execution_success:
+
+        memory_message = (
+            "🧠 Memory Agent: "
+            "Stored successful execution pattern "
+            "for future optimization."
+        )
+
+    elif error_message:
+
+        memory_message = (
+            "🛠️ Memory Agent: "
+            "Stored runtime failure and "
+            "retrieved similar debugging history."
+        )
+
+    else:
+
+        memory_message = (
+            "📚 Memory Agent: "
+            "Workflow context stored successfully."
+        )
+
+
+    # return updated state
+
+    return {
+
+        "messages": [
+            AIMessage(content=memory_message)
+        ],
+
+        # Memory Storage
+        "memory_type": memory_type,
+
+        "memory_stats": memory_stats,
+
+        # Retrieved Context
+        "memory_context": relevant_memories,
+
+        "similar_failures": similar_failures,
+
+        # Workflow
+        "next_agent": next_agent,
+    }