elric-cli 1.0.0__py3-none-any.whl

elric_cli/install.sh

@@ -0,0 +1,92 @@
+#!/bin/bash
+
+# Elric Framework - Installation Script
+# This script installs the 'elric' command globally on your system
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Get the absolute path of the CLI repository root
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
+
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "${BLUE}  Elric Framework - Installation${NC}"
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+
+# Check if uv is installed
+if ! command -v uv &> /dev/null; then
+    echo -e "${RED}✗ Error: 'uv' is not installed${NC}"
+    echo -e "${YELLOW}  Please install uv first: https://github.com/astral-sh/uv${NC}"
+    echo -e "${YELLOW}  Quick install: curl -LsSf https://astral.sh/uv/install.sh | sh${NC}"
+    exit 1
+fi
+
+echo -e "${GREEN}✓ Found uv package manager${NC}"
+
+# Determine installation directory
+if [ -w "/usr/local/bin" ]; then
+    INSTALL_DIR="/usr/local/bin"
+elif [ -w "$HOME/.local/bin" ]; then
+    INSTALL_DIR="$HOME/.local/bin"
+    mkdir -p "$INSTALL_DIR"
+else
+    INSTALL_DIR="$HOME/.local/bin"
+    mkdir -p "$INSTALL_DIR"
+fi
+
+echo -e "${BLUE}→ Installation directory: ${INSTALL_DIR}${NC}"
+
+# Create wrapper script
+WRAPPER_SCRIPT="${INSTALL_DIR}/elric"
+
+echo -e "${BLUE}→ Creating wrapper script...${NC}"
+
+cat > "$WRAPPER_SCRIPT" << EOF
+#!/bin/bash
+# Elric Framework CLI Wrapper
+# Auto-generated by install.sh
+
+PROJECT_DIR="${PROJECT_DIR}"
+
+# Run elric from the CLI project while preserving current working directory
+uv run --project "\${PROJECT_DIR}" elric "\$@"
+EOF
+
+# Make wrapper executable
+chmod +x "$WRAPPER_SCRIPT"
+
+echo -e "${GREEN}✓ Wrapper script created${NC}"
+
+# Check if installation directory is in PATH
+if [[ ":$PATH:" != *":${INSTALL_DIR}:"* ]]; then
+    echo ""
+    echo -e "${YELLOW}⚠ Warning: ${INSTALL_DIR} is not in your PATH${NC}"
+    echo -e "${YELLOW}  Add this line to your ~/.zshrc or ~/.bashrc:${NC}"
+    echo -e "${BLUE}  export PATH=\"${INSTALL_DIR}:\$PATH\"${NC}"
+    echo ""
+    echo -e "${YELLOW}  Then reload your shell:${NC}"
+    echo -e "${BLUE}  source ~/.zshrc  # or source ~/.bashrc${NC}"
+    echo ""
+fi
+
+echo ""
+echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "${GREEN}  ✓ Installation completed successfully!${NC}"
+echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+echo -e "${BLUE}  You can now use the 'elric' command from anywhere:${NC}"
+echo -e "${GREEN}    elric --help${NC}"
+echo -e "${GREEN}    elric make agent MyAgent${NC}"
+echo -e "${GREEN}    elric serve${NC}"
+echo ""
+echo -e "${BLUE}  Project directory: ${PROJECT_DIR}${NC}"
+echo -e "${BLUE}  Wrapper installed: ${WRAPPER_SCRIPT}${NC}"
+echo ""

elric_cli/stubs/agent.stub.py

@@ -0,0 +1,23 @@
+from typing import Any
+
+from app.ai.agents.base_agent import BaseAgent
+
+
+class {{ class_name }}(BaseAgent):
+    """{{ class_name }} agent implementation."""
+
+    def __init__(self):
+        super().__init__(name="{{ snake_name }}")
+
+    async def run(self, input_data: dict[str, Any]) -> dict[str, Any]:
+        """
+        Execute the agent logic.
+        
+        Args:
+            input_data: Input data for the agent
+            
+        Returns:
+            dict: Agent execution result
+        """
+        # TODO: Implement agent logic here
+        return {"status": "success", "message": "{{ class_name }} executed"}

elric_cli/stubs/agent_chat.stub.py

@@ -0,0 +1,62 @@
+from typing import Any
+
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+
+from app.ai.agents.base_agent import BaseAgent
+from {{ llm_import }}
+
+
+class {{ class_name }}(BaseAgent):
+    """{{ class_name }} - Chat agent with conversation memory."""
+
+    def __init__(self, model: str = "{{ model_name }}", system_prompt: str = "You are a helpful AI assistant."):
+        super().__init__(name="{{ snake_name }}")
+        self.llm = {{ llm_class }}(model=model)
+        self.system_prompt = system_prompt
+        self.chat_history: list = []
+        
+        self.prompt = ChatPromptTemplate.from_messages([
+            ("system", "{system_prompt}"),
+            MessagesPlaceholder(variable_name="chat_history"),
+            ("human", "{input}")
+        ])
+        
+        self.chain = self.prompt | self.llm
+
+    async def run(self, input_data: dict[str, Any]) -> dict[str, Any]:
+        """
+        Execute the chat agent logic with conversation memory.
+        
+        Args:
+            input_data: Input data containing 'message' and optional 'clear_history'
+            
+        Returns:
+            dict: Agent execution result with response and chat history
+        """
+        message = input_data.get("message", "")
+        clear_history = input_data.get("clear_history", False)
+        
+        if clear_history:
+            self.chat_history = []
+        
+        response = await self.chain.ainvoke({
+            "system_prompt": self.system_prompt,
+            "chat_history": self.chat_history,
+            "input": message
+        })
+        
+        # Update chat history
+        self.chat_history.append(HumanMessage(content=message))
+        self.chat_history.append(AIMessage(content=response.content))
+        
+        return {
+            "status": "success",
+            "response": response.content,
+            "model": self.llm.model_name,
+            "history_length": len(self.chat_history)
+        }
+    
+    def clear_history(self):
+        """Clear the conversation history."""
+        self.chat_history = []

elric_cli/stubs/agent_planner.stub.py

@@ -0,0 +1,82 @@
+from typing import Any
+
+from langchain.chains import LLMChain
+from langchain_core.prompts import ChatPromptTemplate
+
+from app.ai.agents.base_agent import BaseAgent
+from {{ llm_import }}
+
+
+class {{ class_name }}(BaseAgent):
+    """{{ class_name }} - Planner agent for complex task decomposition."""
+
+    def __init__(self, model: str = "{{ model_name }}"):
+        super().__init__(name="{{ snake_name }}")
+        self.llm = {{ llm_class }}(model=model, temperature=0.7)
+        
+        # Planning prompt
+        self.planning_prompt = ChatPromptTemplate.from_messages([
+            ("system", """You are an expert task planner. Break down complex tasks into clear, actionable steps.
+For each step, provide:
+1. Step number
+2. Action to take
+3. Expected outcome
+4. Dependencies (if any)
+
+Format your response as a structured plan."""),
+            ("human", "Task: {task}\n\nCreate a detailed plan to accomplish this task.")
+        ])
+        
+        # Execution prompt
+        self.execution_prompt = ChatPromptTemplate.from_messages([
+            ("system", "You are executing step {step_number} of a plan: {step_description}"),
+            ("human", "{input}")
+        ])
+        
+        self.planning_chain = self.planning_prompt | self.llm
+        self.execution_chain = self.execution_prompt | self.llm
+
+    async def run(self, input_data: dict[str, Any]) -> dict[str, Any]:
+        """
+        Execute the planner agent logic.
+        
+        Args:
+            input_data: Input data containing 'task' and optional 'execute_plan'
+            
+        Returns:
+            dict: Agent execution result with plan and optional execution results
+        """
+        task = input_data.get("task", "")
+        execute_plan = input_data.get("execute_plan", False)
+        
+        # Generate plan
+        plan_response = await self.planning_chain.ainvoke({"task": task})
+        plan = plan_response.content
+        
+        result = {
+            "status": "success",
+            "plan": plan,
+            "model": self.llm.model_name,
+            "task": task
+        }
+        
+        # Optionally execute the plan
+        if execute_plan:
+            execution_results = []
+            # TODO: Parse plan and execute each step
+            # This is a placeholder for plan execution logic
+            result["execution_results"] = execution_results
+            result["executed"] = True
+        else:
+            result["executed"] = False
+        
+        return result
+    
+    async def execute_step(self, step_number: int, step_description: str, input_data: str) -> str:
+        """Execute a single step of the plan."""
+        response = await self.execution_chain.ainvoke({
+            "step_number": step_number,
+            "step_description": step_description,
+            "input": input_data
+        })
+        return response.content

elric_cli/stubs/agent_react.stub.py

@@ -0,0 +1,83 @@
+from typing import Any
+
+from langchain.agents import AgentExecutor, create_react_agent
+from langchain_core.prompts import PromptTemplate
+
+from app.ai.agents.base_agent import BaseAgent
+from {{ llm_import }}
+
+
+class {{ class_name }}(BaseAgent):
+    """{{ class_name }} - ReAct (Reasoning + Acting) agent implementation."""
+
+    def __init__(self, model: str = "{{ model_name }}", tools: list = None):
+        super().__init__(name="{{ snake_name }}")
+        self.llm = {{ llm_class }}(model=model)
+        self.tools = tools or []
+        
+        # ReAct prompt template
+        self.prompt = PromptTemplate.from_template(
+            """Answer the following questions as best you can. You have access to the following tools:
+
+{tools}
+
+Use the following format:
+
+Question: the input question you must answer
+Thought: you should always think about what to do
+Action: the action to take, should be one of [{tool_names}]
+Action Input: the input to the action
+Observation: the result of the action
+... (this Thought/Action/Action Input/Observation can repeat N times)
+Thought: I now know the final answer
+Final Answer: the final answer to the original input question
+
+Begin!
+
+Question: {input}
+Thought: {agent_scratchpad}"""
+        )
+        
+        if self.tools:
+            agent = create_react_agent(self.llm, self.tools, self.prompt)
+            self.agent_executor = AgentExecutor(
+                agent=agent, 
+                tools=self.tools, 
+                verbose=True,
+                max_iterations=5,
+                handle_parsing_errors=True
+            )
+        else:
+            self.agent_executor = None
+
+    async def run(self, input_data: dict[str, Any]) -> dict[str, Any]:
+        """
+        Execute the ReAct agent logic with reasoning and acting.
+        
+        Args:
+            input_data: Input data containing 'input' and optional 'max_iterations'
+            
+        Returns:
+            dict: Agent execution result with reasoning steps
+        """
+        user_input = input_data.get("input", "")
+        max_iterations = input_data.get("max_iterations", 5)
+        
+        if not self.agent_executor:
+            return {
+                "status": "error",
+                "message": "No tools configured for this ReAct agent",
+                "model": self.llm.model_name
+            }
+        
+        self.agent_executor.max_iterations = max_iterations
+        
+        result = await self.agent_executor.ainvoke({"input": user_input})
+        
+        return {
+            "status": "success",
+            "response": result.get("output", ""),
+            "model": self.llm.model_name,
+            "tools_available": len(self.tools),
+            "reasoning_steps": result.get("intermediate_steps", [])
+        }

elric_cli/stubs/agent_simple.stub.py

@@ -0,0 +1,32 @@
+from typing import Any
+
+from app.ai.agents.base_agent import BaseAgent
+from {{ llm_import }}
+
+
+class {{ class_name }}(BaseAgent):
+    """{{ class_name }} - Simple agent implementation."""
+
+    def __init__(self, model: str = "{{ model_name }}"):
+        super().__init__(name="{{ snake_name }}")
+        self.llm = {{ llm_class }}(model=model)
+
+    async def run(self, input_data: dict[str, Any]) -> dict[str, Any]:
+        """
+        Execute the agent logic.
+        
+        Args:
+            input_data: Input data for the agent
+            
+        Returns:
+            dict: Agent execution result
+        """
+        # TODO: Implement agent logic here
+        prompt = input_data.get("prompt", "")
+        response = await self.llm.ainvoke(prompt)
+        
+        return {
+            "status": "success",
+            "response": response.content,
+            "model": self.llm.model_name
+        }

elric_cli/stubs/agent_streaming.stub.py

@@ -0,0 +1,59 @@
+from typing import Any, AsyncIterator
+
+from langchain_core.prompts import ChatPromptTemplate
+
+from app.ai.agents.base_agent import BaseAgent
+from {{ llm_import }}
+
+
+class {{ class_name }}(BaseAgent):
+    """{{ class_name }} - Streaming agent for real-time responses."""
+
+    def __init__(self, model: str = "{{ model_name }}"):
+        super().__init__(name="{{ snake_name }}")
+        self.llm = {{ llm_class }}(model=model, streaming=True)
+        
+        self.prompt = ChatPromptTemplate.from_messages([
+            ("system", "You are a helpful AI assistant."),
+            ("human", "{input}")
+        ])
+        
+        self.chain = self.prompt | self.llm
+
+    async def run(self, input_data: dict[str, Any]) -> dict[str, Any]:
+        """
+        Execute the agent logic with streaming disabled (use stream() for streaming).
+        
+        Args:
+            input_data: Input data for the agent
+            
+        Returns:
+            dict: Agent execution result
+        """
+        user_input = input_data.get("input", "")
+        
+        response = await self.chain.ainvoke({"input": user_input})
+        
+        return {
+            "status": "success",
+            "response": response.content,
+            "model": self.llm.model_name
+        }
+    
+    async def stream(self, input_data: dict[str, Any]) -> AsyncIterator[str]:
+        """
+        Stream the agent response in real-time.
+        
+        Args:
+            input_data: Input data containing 'input'
+            
+        Yields:
+            str: Chunks of the response as they are generated
+        """
+        user_input = input_data.get("input", "")
+        
+        async for chunk in self.chain.astream({"input": user_input}):
+            if hasattr(chunk, 'content'):
+                yield chunk.content
+            else:
+                yield str(chunk)

elric_cli/stubs/agent_tool.stub.py

@@ -0,0 +1,63 @@
+from typing import Any
+
+from langchain.agents import AgentExecutor, create_tool_calling_agent
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+
+from app.ai.agents.base_agent import BaseAgent
+from {{ llm_import }}
+
+
+class {{ class_name }}(BaseAgent):
+    """{{ class_name }} - Tool-using agent implementation."""
+
+    def __init__(self, model: str = "{{ model_name }}", tools: list = None):
+        super().__init__(name="{{ snake_name }}")
+        self.llm = {{ llm_class }}(model=model)
+        self.tools = tools or []
+        
+        self.prompt = ChatPromptTemplate.from_messages([
+            ("system", "You are a helpful AI assistant with access to tools. Use them when needed."),
+            ("human", "{input}"),
+            MessagesPlaceholder(variable_name="agent_scratchpad"),
+        ])
+        
+        if self.tools:
+            agent = create_tool_calling_agent(self.llm, self.tools, self.prompt)
+            self.agent_executor = AgentExecutor(agent=agent, tools=self.tools, verbose=True)
+        else:
+            self.agent_executor = None
+
+    async def run(self, input_data: dict[str, Any]) -> dict[str, Any]:
+        """
+        Execute the tool agent logic.
+        
+        Args:
+            input_data: Input data containing 'input' and optional 'tools'
+            
+        Returns:
+            dict: Agent execution result with tool usage information
+        """
+        user_input = input_data.get("input", "")
+        
+        if not self.agent_executor:
+            return {
+                "status": "error",
+                "message": "No tools configured for this agent",
+                "model": self.llm.model_name
+            }
+        
+        result = await self.agent_executor.ainvoke({"input": user_input})
+        
+        return {
+            "status": "success",
+            "response": result.get("output", ""),
+            "model": self.llm.model_name,
+            "tools_used": len(self.tools)
+        }
+    
+    def add_tool(self, tool):
+        """Add a tool to the agent."""
+        self.tools.append(tool)
+        # Recreate agent executor with new tools
+        agent = create_tool_calling_agent(self.llm, self.tools, self.prompt)
+        self.agent_executor = AgentExecutor(agent=agent, tools=self.tools, verbose=True)

elric_cli/stubs/chain.stub.py

@@ -0,0 +1,23 @@
+from typing import Any
+
+from app.ai.chains.base_chain import BaseChain
+
+
+class {{ class_name }}(BaseChain):
+    """{{ class_name }} chain implementation."""
+
+    def __init__(self):
+        super().__init__(name="{{ snake_name }}")
+
+    async def run(self, input_data: dict[str, Any]) -> dict[str, Any]:
+        """
+        Execute the chain logic.
+        
+        Args:
+            input_data: Input data for the chain
+            
+        Returns:
+            dict: Chain execution result
+        """
+        # TODO: Implement chain logic here
+        return {"status": "success", "message": "{{ class_name }} executed"}

elric_cli/stubs/controller.stub.py

@@ -0,0 +1,30 @@
+from typing import Any
+
+
+class {{ class_name }}:
+    """{{ class_name }} controller for business logic."""
+
+    async def index(self) -> dict[str, Any]:
+        """List all items."""
+        # TODO: Implement list logic
+        return {"data": [], "total": 0}
+
+    async def show(self, id: str) -> dict[str, Any]:
+        """Get a specific item by ID."""
+        # TODO: Implement get logic
+        return {"id": id, "data": {}}
+
+    async def create(self, data: dict[str, Any]) -> dict[str, Any]:
+        """Create a new item."""
+        # TODO: Implement create logic
+        return {"id": "new_id", "data": data}
+
+    async def update(self, id: str, data: dict[str, Any]) -> dict[str, Any]:
+        """Update an item by ID."""
+        # TODO: Implement update logic
+        return {"id": id, "data": data}
+
+    async def delete(self, id: str) -> dict[str, Any]:
+        """Delete an item by ID."""
+        # TODO: Implement delete logic
+        return {"id": id, "deleted": True}

elric_cli/stubs/event.stub.py

@@ -0,0 +1,18 @@
+from datetime import datetime
+from typing import Any
+
+
+class {{ class_name }}:
+    """{{ class_name }} event."""
+
+    def __init__(self, data: dict[str, Any]):
+        self.data = data
+        self.timestamp = datetime.utcnow()
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert event to dictionary."""
+        return {
+            "event": "{{ snake_name }}",
+            "data": self.data,
+            "timestamp": self.timestamp.isoformat(),
+        }

elric_cli/stubs/exception.stub.py

@@ -0,0 +1,21 @@
+from typing import Any, Optional
+
+from app.exceptions.base import ElricException
+
+
+class {{ class_name }}(ElricException):
+    """{{ class_name }} exception."""
+
+    def __init__(
+        self,
+        message: str = "{{ class_name }} error occurred",
+        error_code: str = "{{ snake_name }}_error",
+        status_code: int = 500,
+        details: Optional[dict[str, Any]] = None,
+    ):
+        super().__init__(
+            message=message,
+            status_code=status_code,
+            error_code=error_code,
+            details=details,
+        )

elric_cli/stubs/job.stub.py

@@ -0,0 +1,24 @@
+import structlog
+
+logger = structlog.get_logger()
+
+
+class {{ class_name }}:
+    """{{ class_name }} background job."""
+
+    async def execute(self, *args, **kwargs):
+        """
+        Execute the job logic.
+        
+        Args:
+            *args: Positional arguments
+            **kwargs: Keyword arguments
+        """
+        logger.info("job.started", job="{{ snake_name }}")
+        
+        try:
+            # TODO: Implement job logic here
+            logger.info("job.completed", job="{{ snake_name }}")
+        except Exception as e:
+            logger.error("job.failed", job="{{ snake_name }}", error=str(e))
+            raise

elric_cli/stubs/listener.stub.py

@@ -0,0 +1,23 @@
+import structlog
+
+logger = structlog.get_logger()
+
+
+class {{ class_name }}:
+    """{{ class_name }} event listener."""
+
+    async def handle(self, event):
+        """
+        Handle the event.
+        
+        Args:
+            event: The event to handle
+        """
+        logger.info("listener.handling", listener="{{ snake_name }}", event=event.to_dict())
+        
+        try:
+            # TODO: Implement event handling logic here
+            logger.info("listener.handled", listener="{{ snake_name }}")
+        except Exception as e:
+            logger.error("listener.failed", listener="{{ snake_name }}", error=str(e))
+            raise

elric_cli/stubs/middleware.stub.py

@@ -0,0 +1,32 @@
+import structlog
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+
+logger = structlog.get_logger()
+
+
+class {{ class_name }}(BaseHTTPMiddleware):
+    """{{ class_name }} middleware."""
+
+    async def dispatch(self, request: Request, call_next):
+        """
+        Process the request.
+        
+        Args:
+            request: The incoming request
+            call_next: The next middleware/route handler
+            
+        Returns:
+            Response from the next handler
+        """
+        logger.debug("middleware.before", middleware="{{ snake_name }}", path=request.url.path)
+        
+        # TODO: Add pre-processing logic here
+        
+        response = await call_next(request)
+        
+        # TODO: Add post-processing logic here
+        
+        logger.debug("middleware.after", middleware="{{ snake_name }}", status_code=response.status_code)
+        
+        return response