codeoptix 0.1.0__py3-none-any.whl

codeoptix/__init__.py

@@ -0,0 +1,8 @@
+"""CodeOptiX: Agentic Code Optimization & Deep Evaluation for Superior Coding Agent Experience.
+
+The universal code optimization engine that improves coding agent experience with deep evaluations and optimization. When AI coding agents dazzle with impressive code but leave you wondering about quality, maintainability, security, and reliability, CodeOptiX ensures proper behavior through evaluations, reflection, and self-improvement.
+
+Built by Superagentic AI - Advancing AI agent optimization and autonomous systems.
+"""
+
+__version__ = "0.1.0"

codeoptix/acp/__init__.py

@@ -0,0 +1,33 @@
+"""ACP (Agent Client Protocol) integration for CodeOptiX.
+
+This module provides ACP integration:
+- CodeOptiX as an ACP agent (can be used by editors)
+- ACP client adapter (connect to other agents via ACP)
+- Quality bridge functionality
+- Agent registry and orchestration
+- Multi-agent judge support
+"""
+
+from codeoptix.acp.agent import CodeOptiXAgent
+from codeoptix.acp.bridge import ACPQualityBridge
+from codeoptix.acp.client_adapter import ACPClientAdapter
+from codeoptix.acp.code_extractor import (
+    extract_all_code,
+    extract_code_from_message,
+    extract_code_from_text,
+)
+from codeoptix.acp.orchestrator import AgentOrchestrator, MultiAgentJudge
+from codeoptix.acp.registry import ACPAgentConfig, ACPAgentRegistry
+
+__all__ = [
+    "ACPAgentConfig",
+    "ACPAgentRegistry",
+    "ACPClientAdapter",
+    "ACPQualityBridge",
+    "AgentOrchestrator",
+    "CodeOptiXAgent",
+    "MultiAgentJudge",
+    "extract_all_code",
+    "extract_code_from_message",
+    "extract_code_from_text",
+]

codeoptix/acp/agent.py

@@ -0,0 +1,209 @@
+"""CodeOptiX as an ACP Agent.
+
+This allows CodeOptiX to be used by ACP-compatible editors (Zed, JetBrains, Neovim, etc.)
+as a quality engineering agent.
+"""
+
+from typing import Any
+from uuid import uuid4
+
+from acp import (
+    Agent,
+    InitializeResponse,
+    NewSessionResponse,
+    PromptResponse,
+    text_block,
+    update_agent_message,
+)
+from acp.interfaces import Client
+from acp.schema import (
+    AudioContentBlock,
+    ClientCapabilities,
+    EmbeddedResourceContentBlock,
+    HttpMcpServer,
+    ImageContentBlock,
+    Implementation,
+    McpServerStdio,
+    ResourceContentBlock,
+    SseMcpServer,
+    TextContentBlock,
+)
+
+from codeoptix.acp.code_extractor import extract_code_from_text
+from codeoptix.adapters.base import AgentOutput
+from codeoptix.evaluation import EvaluationEngine
+from codeoptix.utils.llm import LLMClient
+
+
+class CodeOptiXAgent(Agent):
+    """CodeOptiX as an ACP agent for quality engineering."""
+
+    _conn: Client | None = None
+    _evaluation_engine: EvaluationEngine | None = None
+    _llm_client: LLMClient | None = None
+
+    def __init__(
+        self,
+        evaluation_engine: EvaluationEngine | None = None,
+        llm_client: LLMClient | None = None,
+        behaviors: list[str] | None = None,
+    ):
+        """Initialize CodeOptiX ACP agent.
+
+        Args:
+            evaluation_engine: Optional evaluation engine (will create default if not provided)
+            llm_client: Optional LLM client (will create default if not provided)
+            behaviors: List of behavior names to evaluate (default: all)
+        """
+        self._evaluation_engine = evaluation_engine
+        self._llm_client = llm_client
+        self._behaviors = behaviors or ["insecure-code", "vacuous-tests", "plan-drift"]
+
+        # Initialize default evaluation engine if not provided
+        if not self._evaluation_engine and self._llm_client:
+            # Create a minimal adapter for evaluation (dummy adapter)
+            from codeoptix.adapters.base import AgentAdapter
+            from codeoptix.adapters.factory import create_adapter
+
+            # Try to create a default adapter (will use dummy if none available)
+            try:
+                adapter = create_adapter("claude-code", {"llm_config": {"provider": "anthropic"}})
+            except Exception:
+                # Create a minimal dummy adapter
+                class DummyAdapter(AgentAdapter):
+                    def get_adapter_type(self) -> str:
+                        return "dummy"
+
+                    def generate_code(self, prompt: str, **kwargs) -> AgentOutput:
+                        return AgentOutput(code="", tests="", messages=[], metadata={})
+
+                adapter = DummyAdapter()
+
+            self._evaluation_engine = EvaluationEngine(adapter, self._llm_client)
+
+    def on_connect(self, conn: Client) -> None:
+        """Called when agent connects to client."""
+        self._conn = conn
+
+    async def initialize(
+        self,
+        protocol_version: int,
+        client_capabilities: ClientCapabilities | None = None,
+        client_info: Implementation | None = None,
+        **kwargs: Any,
+    ) -> InitializeResponse:
+        """Initialize the agent with client capabilities."""
+        return InitializeResponse(protocol_version=protocol_version)
+
+    async def new_session(
+        self,
+        cwd: str,
+        mcp_servers: list[HttpMcpServer | SseMcpServer | McpServerStdio],
+        **kwargs: Any,
+    ) -> NewSessionResponse:
+        """Create a new session."""
+        session_id = uuid4().hex
+        return NewSessionResponse(session_id=session_id)
+
+    async def prompt(
+        self,
+        prompt: list[
+            TextContentBlock
+            | ImageContentBlock
+            | AudioContentBlock
+            | ResourceContentBlock
+            | EmbeddedResourceContentBlock
+        ],
+        session_id: str,
+        **kwargs: Any,
+    ) -> PromptResponse:
+        """Handle a prompt from the client.
+
+        This is where CodeOptiX performs quality engineering on the request.
+        """
+        if not self._conn:
+            return PromptResponse(stop_reason="error", error="Not connected to client")
+
+        # Extract text from prompt blocks
+        prompt_text = ""
+        for block in prompt:
+            if isinstance(block, dict):
+                text = block.get("text", "")
+            elif isinstance(block, TextContentBlock):
+                text = block.text
+            else:
+                text = getattr(block, "text", "")
+            if text:
+                prompt_text += text + "\n"
+
+        # Send initial response
+        await self._conn.session_update(
+            session_id=session_id,
+            update=update_agent_message(text_block("🔍 CodeOptiX: Analyzing code quality...")),
+            source="codeoptix",
+        )
+
+        # Extract code from prompt
+        code_blocks = extract_code_from_text(prompt_text)
+
+        # Perform quality evaluation
+        evaluation_results = None
+        if self._evaluation_engine and code_blocks:
+            try:
+                # Extract code content
+                code_content = "\n\n".join([cb["content"] for cb in code_blocks])
+
+                if code_content:
+                    # Create agent output for evaluation
+                    AgentOutput(
+                        code=code_content,
+                        tests="",
+                        messages=[],
+                        metadata={"source": "acp_agent", "prompt": prompt_text[:200]},
+                    )
+
+                    # Evaluate behaviors
+                    evaluation_results = self._evaluation_engine.evaluate_behaviors(
+                        behavior_names=self._behaviors,
+                        context={"code": code_content, "prompt": prompt_text},
+                    )
+            except Exception as e:
+                import logging
+
+                logger = logging.getLogger(__name__)
+                logger.error(f"Error during quality evaluation: {e}")
+                evaluation_results = {"error": str(e)}
+
+        # Format response
+        if evaluation_results and "behaviors" in evaluation_results:
+            response_lines = ["## 🔍 CodeOptiX Quality Report\n"]
+
+            overall_score = evaluation_results.get("overall_score", 0.0)
+            response_lines.append(f"**Overall Score:** {overall_score:.2%}\n")
+
+            behaviors = evaluation_results.get("behaviors", {})
+            for behavior_name, behavior_data in behaviors.items():
+                passed = behavior_data.get("passed", True)
+                score = behavior_data.get("score", 0.0)
+                emoji = "✅" if passed else "❌"
+
+                response_lines.append(f"{emoji} **{behavior_name}**: {score:.2%}")
+
+                if not passed and behavior_data.get("evidence"):
+                    evidence = behavior_data["evidence"][:3]  # Limit to 3 items
+                    for ev in evidence:
+                        response_lines.append(f"   - {ev}")
+
+            response_text = "\n".join(response_lines)
+        elif code_blocks:
+            response_text = f"CodeOptiX analyzed {len(code_blocks)} code block(s).\n\n✅ Quality check complete."
+        else:
+            response_text = f"CodeOptiX received your request:\n\n{prompt_text[:500]}\n\n⚠️ No code blocks detected for quality evaluation."
+
+        await self._conn.session_update(
+            session_id=session_id,
+            update=update_agent_message(text_block(response_text)),
+            source="codeoptix",
+        )
+
+        return PromptResponse(stop_reason="end_turn")

codeoptix/acp/bridge.py

@@ -0,0 +1,402 @@
+"""ACP Quality Bridge - CodeOptiX as quality middleware between editor and agents.
+
+This implements the "Quality Bridge" pattern where CodeOptiX sits between
+the editor and coding agents, automatically performing quality checks.
+"""
+
+import asyncio
+import logging
+from typing import Any
+
+from acp import PROTOCOL_VERSION, Client, connect_to_agent, text_block, update_agent_message
+from acp.core import ClientSideConnection
+from acp.schema import (
+    AgentMessageChunk,
+    ClientCapabilities,
+    Implementation,
+    TextContentBlock,
+)
+
+from codeoptix.acp.code_extractor import extract_all_code, extract_code_from_message
+from codeoptix.acp.registry import ACPAgentRegistry
+from codeoptix.evaluation import EvaluationEngine
+from codeoptix.utils.llm import LLMClient
+
+logger = logging.getLogger(__name__)
+
+
+class ACPQualityBridge:
+    """CodeOptiX as a quality bridge between editor and agents via ACP."""
+
+    def __init__(
+        self,
+        agent_command: list[str] | None = None,
+        agent_name: str | None = None,
+        evaluation_engine: EvaluationEngine | None = None,
+        llm_client: LLMClient | None = None,
+        auto_eval: bool = True,
+        registry: ACPAgentRegistry | None = None,
+        behaviors: list[str] | None = None,
+    ):
+        """Initialize ACP quality bridge.
+
+        Args:
+            agent_command: Command to spawn the ACP agent (e.g., ["python", "agent.py"])
+            agent_name: Name of agent in registry (alternative to agent_command)
+            evaluation_engine: Optional evaluation engine
+            llm_client: Optional LLM client
+            auto_eval: Whether to automatically evaluate code quality
+            registry: Optional agent registry (for multi-agent support)
+            behaviors: List of behavior names to evaluate (default: all)
+        """
+        if not agent_command and not agent_name:
+            raise ValueError("Either agent_command or agent_name must be provided")
+
+        self.agent_command = agent_command
+        self.agent_name = agent_name
+        self.evaluation_engine = evaluation_engine
+        self.llm_client = llm_client
+        self.auto_eval = auto_eval
+        self.registry = registry
+        self.behaviors = behaviors or ["insecure-code", "vacuous-tests", "plan-drift"]
+        self._connection: ClientSideConnection | None = None
+        self._session_id: str | None = None
+        self._collected_updates: list[Any] = []  # Collect updates for code extraction
+
+    async def connect(self, cwd: str | None = None) -> None:
+        """Connect to the ACP agent."""
+        if self.agent_name and self.registry:
+            # Use registry to connect
+            self._connection = await self.registry.connect(self.agent_name)
+            self._session_id = self.registry.get_session_id(self.agent_name)
+        elif self.agent_command:
+            # Spawn agent process directly
+            process = await asyncio.create_subprocess_exec(
+                *self.agent_command,
+                stdin=asyncio.subprocess.PIPE,
+                stdout=asyncio.subprocess.PIPE,
+                cwd=cwd,
+            )
+
+            if process.stdin is None or process.stdout is None:
+                raise RuntimeError("Agent process does not expose stdio pipes")
+
+            # Create bridge client implementation
+            client_impl = _BridgeClientImpl(self)
+            self._connection = connect_to_agent(client_impl, process.stdin, process.stdout)
+
+            # Initialize connection
+            await self._connection.initialize(
+                protocol_version=PROTOCOL_VERSION,
+                client_capabilities=ClientCapabilities(),
+                client_info=Implementation(
+                    name="codeoptix-bridge",
+                    title="CodeOptiX Quality Bridge",
+                    version="0.1.0",
+                ),
+            )
+
+            # Create new session
+            session = await self._connection.new_session(mcp_servers=[], cwd=cwd or ".")
+            self._session_id = session.session_id
+        else:
+            raise RuntimeError("No agent command or registry agent name provided")
+
+    async def prompt(
+        self,
+        prompt: str,
+        **kwargs: Any,
+    ) -> str:
+        """Send a prompt through the quality bridge."""
+        if not self._connection or not self._session_id:
+            raise RuntimeError("Not connected to ACP agent")
+
+        # Clear collected updates
+        self._collected_updates = []
+
+        # Send prompt to agent
+        response = await self._connection.prompt(
+            session_id=self._session_id,
+            prompt=[text_block(prompt)],
+        )
+
+        # Perform quality evaluation on response
+        if self.auto_eval and self.evaluation_engine and self._collected_updates:
+            await self._evaluate_and_feedback()
+
+        return response.stop_reason or "end_turn"
+
+    async def _evaluate_and_feedback(self) -> None:
+        """Evaluate collected code and send feedback to editor."""
+        if not self._connection or not self._session_id:
+            return
+
+        # Extract code from collected updates
+        code_blocks = extract_all_code(self._collected_updates)
+
+        if not code_blocks:
+            logger.debug("No code blocks found in agent response")
+            return
+
+        # Send evaluation status
+        await self._connection.session_update(
+            session_id=self._session_id,
+            update=update_agent_message(text_block("🔍 CodeOptiX: Evaluating code quality...")),
+            source="codeoptix",
+        )
+
+        try:
+            # Evaluate each code block
+            all_results = []
+            for code_block in code_blocks:
+                code_content = code_block.get("content", "")
+                if not code_content:
+                    continue
+
+                # Evaluate code block (synchronous)
+                results = self.bridge._evaluate_code_block(code_content, code_block)
+
+                all_results.append(
+                    {
+                        "code_block": code_block,
+                        "results": results,
+                    }
+                )
+
+            # Format and send feedback
+            feedback = self._format_quality_feedback(all_results)
+            await self._connection.session_update(
+                session_id=self._session_id,
+                update=update_agent_message(text_block(feedback)),
+                source="codeoptix",
+            )
+
+        except Exception as e:
+            logger.error(f"Error during quality evaluation: {e}")
+            await self._connection.session_update(
+                session_id=self._session_id,
+                update=update_agent_message(text_block(f"⚠️ CodeOptiX: Evaluation error: {e!s}")),
+                source="codeoptix",
+            )
+
+    def _format_quality_feedback(self, results: list[dict[str, Any]]) -> str:
+        """Format quality evaluation results for display.
+
+        Args:
+            results: List of evaluation results
+
+        Returns:
+            Formatted feedback string
+        """
+        lines = ["## 🔍 CodeOptiX Quality Report\n"]
+
+        for i, result_data in enumerate(results, 1):
+            code_block = result_data["code_block"]
+            results_dict = result_data["results"]
+
+            lines.append(f"### Code Block {i} ({code_block.get('language', 'text')})\n")
+
+            if "behaviors" in results_dict:
+                for behavior_name, behavior_data in results_dict["behaviors"].items():
+                    passed = behavior_data.get("passed", True)
+                    score = behavior_data.get("score", 0.0)
+                    emoji = "✅" if passed else "❌"
+
+                    lines.append(f"{emoji} **{behavior_name}**: {score:.2%}")
+
+                    if not passed and behavior_data.get("evidence"):
+                        evidence = behavior_data["evidence"][:2]  # Limit to 2 items
+                        for ev in evidence:
+                            lines.append(f"   - {ev}")
+
+            lines.append("")
+
+        return "\n".join(lines)
+
+    async def close(self) -> None:
+        """Close the bridge connection."""
+        if self._connection:
+            self._connection = None
+            self._session_id = None
+
+
+class _BridgeClientImpl(Client):
+    """Internal client implementation for quality bridge."""
+
+    def __init__(self, bridge: ACPQualityBridge):
+        """Initialize bridge client."""
+        self.bridge = bridge
+
+    async def request_permission(
+        self,
+        options: list,
+        session_id: str,
+        tool_call: Any,
+        **kwargs: Any,
+    ) -> Any:
+        """Handle permission requests."""
+        # Auto-approve for bridge
+        from acp.schema import RequestPermissionResponse
+
+        return RequestPermissionResponse(granted=True)
+
+    async def write_text_file(
+        self,
+        content: str,
+        path: str,
+        session_id: str,
+        **kwargs: Any,
+    ) -> Any:
+        """Handle file write requests."""
+        # Allow file writes, but could add quality checks here
+        from acp.schema import WriteTextFileResponse
+
+        return WriteTextFileResponse()
+
+    async def read_text_file(
+        self,
+        path: str,
+        session_id: str,
+        limit: int | None = None,
+        line: int | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Handle file read requests."""
+        from acp.schema import ReadTextFileResponse
+
+        try:
+            with open(path, encoding="utf-8") as f:
+                if line is not None:
+                    lines = f.readlines()
+                    if 0 <= line < len(lines):
+                        content = lines[line]
+                    else:
+                        content = ""
+                elif limit is not None:
+                    content = f.read(limit)
+                else:
+                    content = f.read()
+            return ReadTextFileResponse(content=content)
+        except Exception as e:
+            logger.error(f"Error reading file {path}: {e}")
+            raise
+
+    async def create_terminal(self, *args: Any, **kwargs: Any) -> Any:
+        """Handle terminal creation."""
+        from acp.exceptions import RequestError
+
+        raise RequestError.method_not_found("terminal/create")
+
+    async def terminal_output(self, *args: Any, **kwargs: Any) -> Any:
+        """Handle terminal output."""
+        from acp.exceptions import RequestError
+
+        raise RequestError.method_not_found("terminal/output")
+
+    async def release_terminal(self, *args: Any, **kwargs: Any) -> Any:
+        """Handle terminal release."""
+        from acp.exceptions import RequestError
+
+        raise RequestError.method_not_found("terminal/release")
+
+    async def wait_for_terminal_exit(self, *args: Any, **kwargs: Any) -> Any:
+        """Handle terminal exit wait."""
+        from acp.exceptions import RequestError
+
+        raise RequestError.method_not_found("terminal/wait_for_exit")
+
+    async def kill_terminal(self, *args: Any, **kwargs: Any) -> Any:
+        """Handle terminal kill."""
+        from acp.exceptions import RequestError
+
+        raise RequestError.method_not_found("terminal/kill")
+
+    async def session_update(
+        self,
+        session_id: str,
+        update: Any,
+        **kwargs: Any,
+    ) -> None:
+        """Handle session updates from agent."""
+        # Collect updates for code extraction and evaluation
+        self._collected_updates.append(update)
+
+        # Intercept agent messages for quality evaluation
+        if isinstance(update, AgentMessageChunk):
+            content = update.content
+            if isinstance(content, TextContentBlock):
+                logger.debug(f"Agent message: {content.text[:100]}...")
+
+                # Extract code immediately for real-time feedback
+                if self.bridge.auto_eval and self.bridge.evaluation_engine:
+                    code_blocks = extract_code_from_message(update)
+                    if code_blocks:
+                        # Quick evaluation for real-time feedback
+                        await self.bridge._quick_evaluate_code(code_blocks, session_id)
+
+    async def ext_method(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
+        """Handle extension methods."""
+        from acp.exceptions import RequestError
+
+        raise RequestError.method_not_found(method)
+
+    async def ext_notification(self, method: str, params: dict[str, Any]) -> None:
+        """Handle extension notifications."""
+        logger.debug(f"Extension notification: {method}")
+
+    def _evaluate_code_block(self, code_content: str, code_block: dict[str, str]) -> dict[str, Any]:
+        """Evaluate a single code block.
+
+        Args:
+            code_content: Code content to evaluate
+            code_block: Code block metadata
+
+        Returns:
+            Evaluation results dictionary
+        """
+        if not self.evaluation_engine:
+            return {}
+
+        # Use evaluation engine's evaluate_behaviors (synchronous)
+        try:
+            results = self.evaluation_engine.evaluate_behaviors(
+                behavior_names=self.behaviors,
+                context={"code": code_content, "source": "acp_bridge", "code_block": code_block},
+            )
+            return results
+        except Exception as e:
+            logger.error(f"Error in code block evaluation: {e}")
+            return {"error": str(e)}
+
+    async def _quick_evaluate_code(
+        self, code_blocks: list[dict[str, str]], session_id: str
+    ) -> None:
+        """Perform quick evaluation on code blocks for real-time feedback.
+
+        Args:
+            code_blocks: List of extracted code blocks
+            session_id: ACP session ID
+        """
+        if not self._connection:
+            return
+
+        # Quick check for obvious issues (can be expanded)
+        for code_block in code_blocks:
+            code = code_block.get("content", "")
+            if not code:
+                continue
+
+            # Quick security check
+            security_keywords = ["password", "secret", "api_key", "token", "credential"]
+            if any(keyword in code.lower() for keyword in security_keywords):
+                await self._connection.session_update(
+                    session_id=session_id,
+                    update=update_agent_message(
+                        text_block("⚠️ CodeOptiX: Potential security issue detected in code")
+                    ),
+                    source="codeoptix",
+                )
+
+    def on_connect(self, conn: Any) -> None:
+        """Called when client connects to agent."""
+        logger.debug("Bridge connected to ACP agent")