llama2a 0.1.0__tar.gz

llama2a-0.1.0/.gitignore

@@ -0,0 +1,39 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+*.egg
+dist/
+build/
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Backups (system-generated)
+.backups/
+!workspace/.backups
+!workspace/__pycache__
+
+# Generated workspace (all apps created by Infinity)
+# workspace/*
+!workspace/README.md
+
+# Runtime data (logs, checklists, plans)
+# data/*
+!data/.gitkeep
+data/requirements.txt
+
+# OS files
+.DS_Store
+Thumbs.db

llama2a-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 AgentChain Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

llama2a-0.1.0/PKG-INFO

@@ -0,0 +1,387 @@
+Metadata-Version: 2.4
+Name: llama2a
+Version: 0.1.0
+Summary: A modular multi-agent framework for building AI development workflows with Ollama
+Project-URL: Homepage, https://github.com/yourusername/agentchain
+Project-URL: Documentation, https://github.com/yourusername/agentchain#readme
+Project-URL: Repository, https://github.com/yourusername/agentchain
+Project-URL: Issues, https://github.com/yourusername/agentchain/issues
+Author: AgentChain Contributors
+License: MIT
+License-File: LICENSE
+Keywords: agents,ai,automation,code-generation,llm,multi-agent,ollama
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: black>=23.0; extra == 'dev'
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# AgentChain 🔗
+
+A minimal, zero-dependency Python library for building multi-agent workflows.
+
+**Fluent API** • **Custom Agents** • **Per-Agent Models** • **Event Hooks** • **PyPI Ready**
+
+---
+
+## Installation
+
+```bash
+pip install agentchain
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/yourusername/agentchain
+cd agentchain
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from agentchain import AgentChain
+
+AgentChain() \
+    .requirements("Build a calculator app with add, subtract, multiply, divide") \
+    .model("deepseek-coder-v2:16b") \
+    .output("./calculator") \
+    .run()
+```
+
+That's it. AgentChain coordinates multiple AI agents to plan and implement your project.
+
+---
+
+## Core Concepts
+
+### The Default Workflow
+
+AgentChain ships with 3 agents that form a complete development pipeline:
+
+| Agent | Role | Responsibility |
+|-------|------|----------------|
+| **Contractor** | Orchestrator | Coordinates the workflow, handles retries, verifies completion |
+| **Planner** | Planning | Breaks requirements into concrete, ordered tasks |
+| **Coder** | Implementation | Writes code to files based on task specifications |
+
+### Fluent API
+
+Configure everything with method chaining:
+
+```python
+AgentChain()
+    .requirements("Your project description")  # What to build
+    .model("llama3:8b")                         # Default model for all agents
+    .configure("planner", model="llama3:70b")   # Planner gets a bigger model
+    .configure("coder", model="deepseek-coder-v2:16b")  # Coder is specialized
+    .output("./my_project")                     # Where to write files
+    .run()
+```
+
+---
+
+## Configuration
+
+### Per-Agent Models
+
+Use the right model for each task:
+
+```python
+AgentChain()
+    .requirements("Build a REST API")
+    .configure("planner", model="llama3:70b")           # Planning: bigger model
+    .configure("coder", model="deepseek-coder-v2:16b")  # Coding: code-focused model
+    .output("./api")
+    .run()
+```
+
+### Agent Parameters
+
+Pass custom parameters to specific agents:
+
+```python
+AgentChain()
+    .requirements("Build a game")
+    .configure("planner", 
+        model="llama3:70b",
+        max_tasks=20,           # Custom parameter
+        include_tests=True      # Custom parameter
+    )
+    .configure("coder",
+        model="deepseek-coder-v2:16b",
+        style="verbose",        # Custom parameter
+        language="python"       # Custom parameter
+    )
+    .output("./game")
+    .run()
+```
+
+### LLM Configuration
+
+Configure the LLM endpoint:
+
+```python
+from agentchain import ChainConfig
+
+config = ChainConfig(
+    llm_base_url="http://localhost:11434",  # Ollama default
+    default_model="llama3:8b",
+)
+
+AgentChain(config)
+    .requirements("Build something")
+    .output("./output")
+    .run()
+```
+
+---
+
+## Custom Agents
+
+### Function-Based Agents
+
+The simplest way to add an agent:
+
+```python
+from agentchain import AgentChain, agent, AgentContext, AgentResult
+
+@agent(name="reviewer", role="Code Reviewer")
+def review_code(context: AgentContext, llm) -> AgentResult:
+    code = context.get("code", "")
+    
+    response = llm.generate(
+        "Review this code for issues:\n\n" + code,
+        model="llama3:8b"
+    )
+    
+    return AgentResult.ok({"review": response})
+
+
+# Use it
+AgentChain()
+    .requirements("Build a CLI tool")
+    .register("reviewer", review_code)  # Add to this chain
+    .output("./cli")
+    .run()
+```
+
+### Class-Based Agents
+
+For more complex agents with state:
+
+```python
+from agentchain import Agent, agent, AgentContext, AgentResult
+
+@agent(name="tester", role="Test Writer")
+class TesterAgent(Agent):
+    def execute(self, context: AgentContext) -> AgentResult:
+        code_files = context.get("files", [])
+        
+        for file in code_files:
+            test_code = self._llm.generate(
+                f"Write tests for:\n{file['content']}",
+                model=self._config.get("model", "llama3:8b")
+            )
+            # Write test file...
+        
+        return AgentResult.ok({"tests_created": len(code_files)})
+```
+
+### Custom Orchestrator
+
+Replace the entire workflow:
+
+```python
+from agentchain import Orchestrator, orchestrator, AgentContext, AgentResult
+
+@orchestrator(name="my_workflow", role="Custom Pipeline")
+class MyOrchestrator(Orchestrator):
+    def execute(self, context: AgentContext) -> AgentResult:
+        # Phase 1: Your planning logic
+        plan_result = self.invoke_agent("planner", context)
+        
+        # Phase 2: Your implementation logic
+        for task in plan_result.data.get("tasks", []):
+            self.invoke_agent("coder", AgentContext(
+                task=task["description"],
+                inputs=task
+            ))
+        
+        # Phase 3: Your custom phase
+        if self.get_agent("tester"):
+            self.invoke_agent("tester", context)
+        
+        return AgentResult.ok({"status": "complete"})
+
+
+# Use it
+AgentChain()
+    .requirements("Build something")
+    .orchestrator(MyOrchestrator)
+    .output("./output")
+    .run()
+```
+
+---
+
+## Events & Callbacks
+
+Monitor progress with event hooks:
+
+```python
+from agentchain import AgentChain, Event
+
+def on_progress(event_type, data):
+    print(f"[{event_type}] {data.get('message', '')}")
+
+def on_task_complete(event_type, data):
+    task = data.get("task", {})
+    print(f"✓ Completed: {task.get('name')}")
+
+AgentChain()
+    .requirements("Build an app")
+    .on(Event.PROGRESS, on_progress)
+    .on(Event.TASK_COMPLETE, on_task_complete)
+    .on(Event.AGENT_ERROR, lambda e, d: print(f"Error: {d}"))
+    .output("./app")
+    .run()
+```
+
+### Available Events
+
+| Event | Trigger |
+|-------|---------|
+| `Event.CHAIN_START` | Chain execution begins |
+| `Event.CHAIN_COMPLETE` | Chain execution finishes |
+| `Event.AGENT_START` | An agent starts executing |
+| `Event.AGENT_COMPLETE` | An agent finishes |
+| `Event.AGENT_ERROR` | An agent encounters an error |
+| `Event.TASK_START` | A task begins |
+| `Event.TASK_COMPLETE` | A task completes |
+| `Event.TASK_FAILED` | A task fails |
+| `Event.PROGRESS` | General progress update |
+
+---
+
+## CLI Usage
+
+AgentChain includes a command-line interface:
+
+```bash
+# Basic usage
+agentchain "Build a todo app with Flask" --output ./todo-app
+
+# With specific model
+agentchain "Build a calculator" --model deepseek-coder-v2:16b --output ./calc
+
+# Verbose output
+agentchain "Build a game" --output ./game --verbose
+```
+
+---
+
+## API Reference
+
+### AgentChain
+
+The main entry point for building chains.
+
+```python
+class AgentChain:
+    def requirements(self, text: str) -> AgentChain
+    def model(self, name: str) -> AgentChain
+    def configure(self, agent_name: str, **kwargs) -> AgentChain
+    def output(self, directory: str) -> AgentChain
+    def orchestrator(self, cls: Type[Orchestrator]) -> AgentChain
+    def register(self, name: str, agent: Agent | Callable) -> AgentChain
+    def on(self, event: Event, handler: Callable) -> AgentChain
+    def run(self) -> AgentResult
+```
+
+### AgentContext
+
+Data passed to agents:
+
+```python
+class AgentContext:
+    task: str          # Current task description
+    inputs: dict       # Input data from previous agents
+    workspace: str     # Output directory path
+    
+    def get(self, key: str, default=None) -> Any
+```
+
+### AgentResult
+
+Return value from agents:
+
+```python
+class AgentResult:
+    success: bool      # Whether execution succeeded
+    data: dict         # Output data
+    error: str | None  # Error message if failed
+    
+    @classmethod
+    def ok(cls, data: dict) -> AgentResult
+    
+    @classmethod
+    def fail(cls, error: str) -> AgentResult
+```
+
+---
+
+## Requirements
+
+- **Python**: 3.9+
+- **LLM Backend**: Ollama running at `localhost:11434` (configurable)
+- **Dependencies**: None (stdlib only!)
+
+---
+
+## Examples
+
+See the [examples/](./examples) directory:
+
+- [minimal.py](./examples/minimal.py) - Basic usage
+- [multi_model.py](./examples/multi_model.py) - Different models per agent
+- [custom_agent.py](./examples/custom_agent.py) - Creating custom agents
+- [custom_orchestrator.py](./examples/custom_orchestrator.py) - Custom workflow
+
+---
+
+## License
+
+MIT License - see [LICENSE](./LICENSE)
+
+---
+
+## Contributing
+
+Contributions welcome! Please read our contributing guidelines first.
+
+```bash
+# Development install
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Format code
+black src/
+```