animus-forge 1.3.0__tar.gz

animus_forge-1.3.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: animus-forge
+Version: 1.3.0
+Summary: Multi-agent orchestration framework for production AI workflows
+Author-email: AreteDriver <aretedriver@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/AreteDriver/animus
+Project-URL: Repository, https://github.com/AreteDriver/animus
+Keywords: multi-agent,ai,orchestration,workflow
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: openai<3,>=2.15.0
+Requires-Dist: anthropic<1,>=0.79.0
+Requires-Dist: fastapi<1,>=0.128.0
+Requires-Dist: uvicorn<1,>=0.40.0
+Requires-Dist: streamlit<2,>=1.53.0
+Requires-Dist: google-auth<3,>=2.35.0
+Requires-Dist: google-auth-oauthlib<2,>=1.2.0
+Requires-Dist: google-auth-httplib2<1,>=0.3.0
+Requires-Dist: google-api-python-client<3,>=2.150.0
+Requires-Dist: notion-client<4,>=3.0.0
+Requires-Dist: PyGithub<3,>=2.4.0
+Requires-Dist: pydantic<3,>=2.12.0
+Requires-Dist: pydantic-settings<3,>=2.13.0
+Requires-Dist: python-dotenv<2,>=1.0.0
+Requires-Dist: aiofiles<26,>=25.1.0
+Requires-Dist: apscheduler<4,>=3.11.0
+Requires-Dist: urllib3<3,>=2.6.0
+Requires-Dist: pynacl<2,>=1.6.0
+Requires-Dist: pyasn1<1,>=0.6.1
+Requires-Dist: typer<1,>=0.23.0
+Requires-Dist: rich<15,>=14.0.0
+Requires-Dist: pyyaml<7,>=6.0.0
+Requires-Dist: jsonschema<5,>=4.23.0
+Requires-Dist: slowapi<1,>=0.1.9
+Requires-Dist: bcrypt<6,>=5.0.0
+Requires-Dist: cryptography<47,>=46.0.5
+Requires-Dist: textual<9,>=8.0.0
+Requires-Dist: convergentai<2,>=1.1.0
+Provides-Extra: postgres
+Requires-Dist: psycopg2-binary>=2.9.0; extra == "postgres"
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0.0; extra == "mcp"
+Provides-Extra: messaging
+Requires-Dist: python-telegram-bot>=22.0; extra == "messaging"
+Requires-Dist: discord-py>=2.3.0; extra == "messaging"
+Provides-Extra: browser
+Requires-Dist: playwright>=1.40.0; extra == "browser"
+Provides-Extra: local
+Requires-Dist: httpx>=0.28.0; extra == "local"
+Requires-Dist: psutil>=7.0.0; extra == "local"
+Provides-Extra: all
+Requires-Dist: animus-forge[browser,local,mcp,messaging,postgres]; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=9.0.2; extra == "dev"
+Requires-Dist: pytest-cov>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=1.3.0; extra == "dev"
+Requires-Dist: pytest-benchmark>=4.0.0; extra == "dev"
+Requires-Dist: ruff>=0.15.1; extra == "dev"
+
+# Animus Forge
+
+Multi-agent orchestration framework for production AI workflows.
+
+## Features
+
+- **Workflow executor** — YAML-defined multi-agent pipelines with mixins (AI, MCP, queue, graph)
+- **Provider abstraction** — Anthropic, OpenAI, Ollama, and more
+- **Self-improvement** — Analyze codebase, generate improvements, test in sandbox, create PRs
+- **Budget management** — Persistent token/cost tracking per workflow
+- **Eval framework** — Benchmark and score agent outputs
+- **MCP tool execution** — Bridge to Model Context Protocol servers
+- **CLI + API + TUI** — Multiple interfaces for workflow management
+
+## Install
+
+```bash
+pip install animus-forge
+```
+
+## Quick Start
+
+```bash
+# Run a workflow
+gorgon run workflows/examples/build_task.yaml
+
+# Self-improve a codebase
+gorgon self-improve run --provider ollama --path /my/project
+
+# Analyze without making changes
+gorgon self-improve analyze --focus security
+```
+
+## Self-Improvement Pipeline
+
+The self-improve orchestrator runs a 10-stage workflow:
+
+1. **Analyze** — Static analysis identifies improvement opportunities
+2. **Plan** — AI generates an improvement plan from suggestions
+3. **Safety check** — Validates against protected files and change limits
+4. **Snapshot** — Creates rollback point before any changes
+5. **Implement** — AI generates code changes
+6. **Sandbox test** — Applies changes to temp copy, runs tests and lint
+7. **Apply** — Writes changes to the actual codebase
+8. **Create PR** — Creates a branch and pull request
+9. **Human approval** — Waits for merge approval (skippable with `--auto-approve`)
+10. **Rollback** — Automatic rollback if tests fail at any stage
+
+## Part of the Animus Monorepo
+
+- [Animus Core](https://pypi.org/project/animus-core/) — exocortex engine
+- [Animus Quorum](https://pypi.org/project/convergentAI/) — coordination protocol
+- [Animus Bootstrap](https://github.com/AreteDriver/animus/tree/main/packages/bootstrap) — system daemon
+
+## License
+
+MIT

animus_forge-1.3.0/README.md

@@ -0,0 +1,57 @@
+# Animus Forge
+
+Multi-agent orchestration framework for production AI workflows.
+
+## Features
+
+- **Workflow executor** — YAML-defined multi-agent pipelines with mixins (AI, MCP, queue, graph)
+- **Provider abstraction** — Anthropic, OpenAI, Ollama, and more
+- **Self-improvement** — Analyze codebase, generate improvements, test in sandbox, create PRs
+- **Budget management** — Persistent token/cost tracking per workflow
+- **Eval framework** — Benchmark and score agent outputs
+- **MCP tool execution** — Bridge to Model Context Protocol servers
+- **CLI + API + TUI** — Multiple interfaces for workflow management
+
+## Install
+
+```bash
+pip install animus-forge
+```
+
+## Quick Start
+
+```bash
+# Run a workflow
+gorgon run workflows/examples/build_task.yaml
+
+# Self-improve a codebase
+gorgon self-improve run --provider ollama --path /my/project
+
+# Analyze without making changes
+gorgon self-improve analyze --focus security
+```
+
+## Self-Improvement Pipeline
+
+The self-improve orchestrator runs a 10-stage workflow:
+
+1. **Analyze** — Static analysis identifies improvement opportunities
+2. **Plan** — AI generates an improvement plan from suggestions
+3. **Safety check** — Validates against protected files and change limits
+4. **Snapshot** — Creates rollback point before any changes
+5. **Implement** — AI generates code changes
+6. **Sandbox test** — Applies changes to temp copy, runs tests and lint
+7. **Apply** — Writes changes to the actual codebase
+8. **Create PR** — Creates a branch and pull request
+9. **Human approval** — Waits for merge approval (skippable with `--auto-approve`)
+10. **Rollback** — Automatic rollback if tests fail at any stage
+
+## Part of the Animus Monorepo
+
+- [Animus Core](https://pypi.org/project/animus-core/) — exocortex engine
+- [Animus Quorum](https://pypi.org/project/convergentAI/) — coordination protocol
+- [Animus Bootstrap](https://github.com/AreteDriver/animus/tree/main/packages/bootstrap) — system daemon
+
+## License
+
+MIT

animus_forge-1.3.0/pyproject.toml

@@ -0,0 +1,110 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "animus-forge"
+version = "1.3.0"
+description = "Multi-agent orchestration framework for production AI workflows"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.12"
+authors = [
+    {name = "AreteDriver", email = "aretedriver@gmail.com"}
+]
+keywords = ["multi-agent", "ai", "orchestration", "workflow"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+dependencies = [
+    "openai>=2.15.0,<3",
+    "anthropic>=0.79.0,<1",
+    "fastapi>=0.128.0,<1",
+    "uvicorn>=0.40.0,<1",
+    "streamlit>=1.53.0,<2",
+    "google-auth>=2.35.0,<3",
+    "google-auth-oauthlib>=1.2.0,<2",
+    "google-auth-httplib2>=0.3.0,<1",
+    "google-api-python-client>=2.150.0,<3",
+    "notion-client>=3.0.0,<4",
+    "PyGithub>=2.4.0,<3",
+    "pydantic>=2.12.0,<3",
+    "pydantic-settings>=2.13.0,<3",
+    "python-dotenv>=1.0.0,<2",
+    "aiofiles>=25.1.0,<26",
+    "apscheduler>=3.11.0,<4",
+    "urllib3>=2.6.0,<3",
+    "pynacl>=1.6.0,<2",
+    "pyasn1>=0.6.1,<1",
+    "typer>=0.23.0,<1",
+    "rich>=14.0.0,<15",
+    "pyyaml>=6.0.0,<7",
+    "jsonschema>=4.23.0,<5",
+    "slowapi>=0.1.9,<1",
+    "bcrypt>=5.0.0,<6",
+    "cryptography>=46.0.5,<47",
+    "textual>=8.0.0,<9",
+    "convergentai>=1.1.0,<2",
+]
+
+[project.optional-dependencies]
+postgres = ["psycopg2-binary>=2.9.0"]
+mcp = ["mcp>=1.0.0"]
+messaging = ["python-telegram-bot>=22.0", "discord-py>=2.3.0"]
+browser = ["playwright>=1.40.0"]
+local = ["httpx>=0.28.0", "psutil>=7.0.0"]
+all = [
+    "animus-forge[postgres,mcp,messaging,browser,local]",
+]
+dev = [
+    "pytest>=9.0.2",
+    "pytest-cov>=7.0.0",
+    "pytest-asyncio>=1.3.0",
+    "pytest-benchmark>=4.0.0",
+    "ruff>=0.15.1",
+]
+
+[project.scripts]
+animus-forge = "animus_forge.cli:app"
+
+[project.urls]
+Homepage = "https://github.com/AreteDriver/animus"
+Repository = "https://github.com/AreteDriver/animus"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W", "UP"]
+ignore = ["E501", "UP042", "UP046", "UP047"]  # UP042: StrEnum, UP046/UP047: PEP 695 generics
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+testpaths = ["tests"]
+
+[tool.coverage.run]
+source = ["src/animus_forge"]
+omit = ["*/tests/*", "*/__main__.py", "*/tui/*", "*/dashboard/workflow_builder/*", "*/dashboard/eval_page.py", "*/dashboard/app.py", "*/dashboard/mcp_page.py", "*/dashboard/cost_dashboard.py"]
+
+[tool.coverage.report]
+fail_under = 97
+show_missing = true
+exclude_lines = [
+    "pragma: no cover",
+    "if TYPE_CHECKING:",
+    "if __name__",
+    "@abstractmethod",
+    "raise NotImplementedError",
+]

animus_forge-1.3.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

animus_forge-1.3.0/src/animus_forge/__init__.py

@@ -0,0 +1,54 @@
+"""AI Workflow Orchestrator - A unified automation layer for AI-powered workflows."""
+
+__version__ = "1.2.0"
+
+from .auth import TokenAuth, create_access_token, verify_token
+from .config import Settings, get_settings
+from .jobs import (
+    Job,
+    JobManager,
+    JobStatus,
+)
+from .orchestrator import Workflow, WorkflowEngineAdapter, WorkflowResult, WorkflowStep
+from .prompts import PromptTemplate, PromptTemplateManager
+from .scheduler import (
+    CronConfig,
+    IntervalConfig,
+    ScheduleManager,
+    ScheduleStatus,
+    ScheduleType,
+    WorkflowSchedule,
+)
+from .webhooks import (
+    PayloadMapping,
+    Webhook,
+    WebhookManager,
+    WebhookStatus,
+)
+
+__all__ = [
+    "Settings",
+    "get_settings",
+    "WorkflowEngineAdapter",
+    "Workflow",
+    "WorkflowStep",
+    "WorkflowResult",
+    "PromptTemplateManager",
+    "PromptTemplate",
+    "TokenAuth",
+    "create_access_token",
+    "verify_token",
+    "ScheduleManager",
+    "WorkflowSchedule",
+    "ScheduleType",
+    "ScheduleStatus",
+    "CronConfig",
+    "IntervalConfig",
+    "WebhookManager",
+    "Webhook",
+    "WebhookStatus",
+    "PayloadMapping",
+    "JobManager",
+    "Job",
+    "JobStatus",
+]

animus_forge-1.3.0/src/animus_forge/agents/__init__.py

@@ -0,0 +1,19 @@
+"""AI Agents for autonomous task orchestration.
+
+This module provides intelligent agents that can analyze user requests,
+delegate to specialized sub-agents, and synthesize results.
+"""
+
+from .convergence import HAS_CONVERGENT, ConvergenceResult, DelegationConvergenceChecker
+from .provider_wrapper import AgentProvider, create_agent_provider
+from .supervisor import AgentDelegation, SupervisorAgent
+
+__all__ = [
+    "SupervisorAgent",
+    "AgentDelegation",
+    "AgentProvider",
+    "create_agent_provider",
+    "ConvergenceResult",
+    "DelegationConvergenceChecker",
+    "HAS_CONVERGENT",
+]

animus_forge-1.3.0/src/animus_forge/agents/convergence.py

@@ -0,0 +1,303 @@
+"""Adapter between Convergent's IntentResolver and Gorgon's delegation pipeline.
+
+Optional integration — Gorgon works without Convergent installed.
+When available, checks delegations for coherence before parallel execution:
+overlapping tasks, conflicting agents, redundant work.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+try:
+    from convergent import (
+        Intent,
+        InterfaceKind,
+        InterfaceSpec,
+        create_delegation_checker,
+    )
+
+    HAS_CONVERGENT = True
+except ImportError:
+    HAS_CONVERGENT = False
+
+
+@dataclass
+class ConvergenceResult:
+    """Result of checking delegations for coherence."""
+
+    adjustments: list[dict[str, Any]] = field(default_factory=list)
+    conflicts: list[dict[str, Any]] = field(default_factory=list)
+    dropped_agents: set[str] = field(default_factory=set)
+
+    @property
+    def has_conflicts(self) -> bool:
+        return len(self.conflicts) > 0
+
+
+class DelegationConvergenceChecker:
+    """Checks delegations for coherence using Convergent's IntentResolver.
+
+    No-ops gracefully when Convergent is not installed.
+    """
+
+    def __init__(self, resolver: Any | None = None) -> None:
+        self._resolver = resolver
+        self._enabled = HAS_CONVERGENT and resolver is not None
+
+    @property
+    def enabled(self) -> bool:
+        return self._enabled
+
+    def check_delegations(self, delegations: list[dict[str, str]]) -> ConvergenceResult:
+        """Check a list of delegations for overlap and conflicts.
+
+        Each delegation is {"agent": str, "task": str}. Publishes each as
+        an Intent, then resolves each against the graph.
+
+        Returns:
+            ConvergenceResult with any adjustments, conflicts, or agents to drop.
+        """
+        if not self._enabled:
+            return ConvergenceResult()
+
+        result = ConvergenceResult()
+
+        # Publish all delegations as intents
+        intents: list[tuple[str, Any]] = []
+        for delegation in delegations:
+            intent = self._delegation_to_intent(delegation)
+            self._resolver.publish(intent)
+            intents.append((delegation.get("agent", "unknown"), intent))
+
+        # Resolve each against the graph
+        for agent_name, intent in intents:
+            resolution = self._resolver.resolve(intent)
+
+            for adj in resolution.adjustments:
+                result.adjustments.append(
+                    {
+                        "agent": agent_name,
+                        "kind": adj.kind,
+                        "description": adj.description,
+                        "confidence": adj.confidence,
+                    }
+                )
+                # If told to consume instead, the agent is redundant
+                if adj.kind == "ConsumeInstead" and adj.confidence >= 0.7:
+                    result.dropped_agents.add(agent_name)
+
+            for conflict in resolution.conflicts:
+                result.conflicts.append(
+                    {
+                        "agent": agent_name,
+                        "description": conflict.description,
+                        "their_stability": conflict.their_stability,
+                        "confidence": conflict.confidence,
+                    }
+                )
+
+        return result
+
+    @staticmethod
+    def _delegation_to_intent(delegation: dict[str, str]) -> Any:
+        """Convert a Gorgon delegation dict to a Convergent Intent."""
+        agent = delegation.get("agent", "unknown")
+        task = delegation.get("task", "")
+
+        # Infer tags from the agent role
+        role_tags = {
+            "planner": ["planning", "architecture", "design"],
+            "builder": ["implementation", "code", "feature"],
+            "tester": ["testing", "qa", "coverage"],
+            "reviewer": ["review", "security", "quality"],
+            "architect": ["architecture", "design", "system"],
+            "documenter": ["documentation", "docs", "guide"],
+            "analyst": ["analysis", "data", "metrics"],
+        }
+        tags = role_tags.get(agent, [agent])
+
+        return Intent(
+            agent_id=agent,
+            intent=task,
+            provides=[
+                InterfaceSpec(
+                    name=f"{agent}_output",
+                    kind=InterfaceKind.FUNCTION,
+                    signature="(task: str) -> str",
+                    tags=tags,
+                ),
+            ],
+        )
+
+
+def create_checker() -> DelegationConvergenceChecker:
+    """Create a DelegationConvergenceChecker with a fresh resolver.
+
+    Returns a disabled checker if Convergent is not installed.
+    """
+    if not HAS_CONVERGENT:
+        logger.info("Convergent not installed — delegation coherence checking disabled")
+        return DelegationConvergenceChecker(resolver=None)
+
+    resolver = create_delegation_checker(min_stability=0.0)
+    logger.info("Convergent delegation coherence checker enabled")
+    return DelegationConvergenceChecker(resolver=resolver)
+
+
+def format_convergence_alert(result: ConvergenceResult) -> str:
+    """Format a ConvergenceResult into a human-readable alert string.
+
+    Returns empty string if no conflicts or dropped agents.
+    """
+    parts: list[str] = []
+
+    if result.conflicts:
+        parts.append(f"Conflicts ({len(result.conflicts)}):")
+        for c in result.conflicts:
+            parts.append(f"  - {c.get('agent', '?')}: {c.get('description', '?')}")
+
+    if result.dropped_agents:
+        agents = ", ".join(sorted(result.dropped_agents))
+        parts.append(f"Dropped agents ({len(result.dropped_agents)}): {agents}")
+
+    if result.adjustments:
+        parts.append(f"Adjustments ({len(result.adjustments)}):")
+        for a in result.adjustments:
+            parts.append(f"  - {a.get('agent', '?')}: {a.get('description', '?')}")
+
+    return "\n".join(parts)
+
+
+def create_bridge(db_path: str | None = None) -> Any:
+    """Create a GorgonBridge for coordination protocol features.
+
+    Returns None if Convergent is not installed.
+    """
+    if not HAS_CONVERGENT:
+        logger.info("Convergent not installed — coordination bridge disabled")
+        return None
+    try:
+        from pathlib import Path
+
+        from convergent import CoordinationConfig, GorgonBridge
+
+        if db_path is None:
+            db_dir = Path.home() / ".gorgon"
+            db_dir.mkdir(parents=True, exist_ok=True)
+            db_path = str(db_dir / "coordination.db")
+
+        bridge = GorgonBridge(CoordinationConfig(db_path=db_path))
+        logger.info("Convergent coordination bridge enabled (db=%s)", db_path)
+        return bridge
+    except Exception as e:
+        logger.warning("Failed to create coordination bridge: %s", e)
+        return None
+
+
+def create_event_log(db_path: str | None = None) -> Any:
+    """Create a Convergent EventLog for coordination event tracking.
+
+    Returns None if Convergent is not installed.
+
+    Args:
+        db_path: Path to SQLite database. Defaults to ~/.gorgon/coordination.events.db.
+
+    Returns:
+        EventLog instance or None.
+    """
+    if not HAS_CONVERGENT:
+        logger.info("Convergent not installed — coordination event log disabled")
+        return None
+    try:
+        from pathlib import Path
+
+        from convergent import EventLog
+
+        if db_path is None:
+            db_dir = Path.home() / ".gorgon"
+            db_dir.mkdir(parents=True, exist_ok=True)
+            db_path = str(db_dir / "coordination.events.db")
+
+        event_log = EventLog(db_path)
+        logger.info("Convergent event log enabled (db=%s)", db_path)
+        return event_log
+    except Exception as e:
+        logger.warning("Failed to create coordination event log: %s", e)
+        return None
+
+
+def get_coordination_health(bridge: Any) -> dict[str, Any]:
+    """Run a coordination health check via Convergent's HealthChecker.
+
+    Args:
+        bridge: A GorgonBridge instance.
+
+    Returns:
+        Dict with grade, issues, and subsystem metrics. Empty dict on failure.
+    """
+    if not HAS_CONVERGENT or bridge is None:
+        return {}
+    try:
+        from dataclasses import asdict
+
+        from convergent import HealthChecker
+
+        checker = HealthChecker.from_bridge(bridge)
+        health = checker.check()
+        return asdict(health)
+    except Exception as e:
+        logger.warning("Coordination health check failed: %s", e)
+        return {}
+
+
+def check_dependency_cycles(resolver: Any) -> list[dict[str, Any]]:
+    """Check the intent graph for dependency cycles.
+
+    Args:
+        resolver: An IntentResolver instance.
+
+    Returns:
+        List of cycle dicts with intent_ids and agent_ids. Empty on failure.
+    """
+    if not HAS_CONVERGENT or resolver is None:
+        return []
+    try:
+        from convergent import find_cycles
+
+        cycles = find_cycles(resolver)
+        return [
+            {
+                "intent_ids": list(c.intent_ids),
+                "agent_ids": list(c.agent_ids),
+                "display": str(c),
+            }
+            for c in cycles
+        ]
+    except Exception as e:
+        logger.warning("Dependency cycle check failed: %s", e)
+        return []
+
+
+def get_execution_order(resolver: Any) -> list[str]:
+    """Get topological execution order for intents.
+
+    Args:
+        resolver: An IntentResolver instance.
+
+    Returns:
+        List of intent IDs in dependency-first order. Empty on failure.
+    """
+    if not HAS_CONVERGENT or resolver is None:
+        return []
+    try:
+        from convergent import topological_order
+
+        return topological_order(resolver)
+    except Exception as e:
+        logger.warning("Execution order computation failed: %s", e)
+        return []