onecoder 0.0.2__py3-none-any.whl

onecoder/review.py

@@ -0,0 +1,233 @@
+import subprocess
+import os
+import sys
+import json
+import asyncio
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+from rich.console import Console
+from rich.panel import Panel
+from rich.markdown import Markdown
+
+# ADK Imports
+try:
+    from google.adk.agents import LlmAgent
+    from google.adk.models.lite_llm import LiteLlm
+except ImportError:
+    # Fallback/Mock if ADK not present
+    LlmAgent = None
+    LiteLlm = None
+
+from .tools.kit_tools import kit_index_tool, kit_symbols_tool, kit_file_tree_tool
+from .llm import LLMClient # keep for fallback
+
+try:
+    from ai_sprint.state import SprintStateManager
+    from ai_sprint.policy import PolicyEngine
+    from ai_sprint.trace import trace_specifications
+except ImportError as e:
+    SprintStateManager = None
+    PolicyEngine = None
+
+console = Console()
+
+class CodeReviewer:
+    def __init__(self, project_root: Optional[str] = None):
+        if project_root:
+            self.project_root = Path(project_root).absolute()
+        else:
+            # Try to find project root by looking for .git
+            current = Path.cwd().absolute()
+            while current != current.parent:
+                if (current / ".git").exists():
+                    self.project_root = current
+                    break
+                current = current.parent
+            else:
+                self.project_root = Path.cwd().absolute()
+        
+        self.console = Console()
+        self.use_agent = (LlmAgent is not None)
+
+    def _get_git_diff(self, target: str = "main") -> str:
+        """Get the git diff for the review context."""
+        try:
+            # If local changes (staged or unstaged)
+            res = subprocess.run(
+                ["git", "diff", target], capture_output=True, text=True
+            )
+            return res.stdout
+        except Exception:
+            return ""
+
+    def _get_sprint_context(self) -> Dict[str, Any]:
+        """Fetch active sprint context."""
+        if not SprintStateManager:
+            return {}
+        
+        # Try to find active sprint
+        sprint_dir = self.project_root / ".sprint"
+        if not sprint_dir.exists():
+            return {}
+            
+        # Simplified: find first active sprint
+        for item in sprint_dir.iterdir():
+            if item.is_dir() and item.name.startswith("0"):
+                 # Check status
+                status_file = item / ".status"
+                if not status_file.exists() or status_file.read_text().strip() == "Active":
+                    manager = SprintStateManager(item)
+                    return manager.get_context_summary(None) # Get full summary
+        return {}
+
+    def _get_governance_rules(self) -> str:
+        """Read governance.yaml."""
+        gov_file = self.project_root / "governance.yaml"
+        if gov_file.exists():
+            return gov_file.read_text()
+        return "No governance.yaml found."
+
+    def review(self, pr_id: Optional[str] = None, local: bool = False):
+        """Perform a policy-grounded review."""
+        self.console.print("[cyan]Gathering Context Triad (Code, Intent, Law)...[/cyan]")
+
+        # 1. Code (The Change)
+        diff = self._get_git_diff("HEAD" if local else "main")
+        if not diff:
+            self.console.print("[yellow]No code changes detected.[/yellow]")
+            return
+
+        # 2. Intent (Sprint Context)
+        sprint_ctx = self._get_sprint_context() or {}
+        goal = sprint_ctx.get("goal", "Unknown Goal")
+        active_task_obj = sprint_ctx.get("active_task") or {}
+        active_task = active_task_obj.get("title", "Unknown Task")
+
+        # 3. Law (Governance)
+        rules = self._get_governance_rules()
+
+        # 4. The Verdict (Deterministic L1 Status)
+        verification_file = self.project_root / ".verification_results.json"
+        l1_verdict = "No deterministic L1 verification results found."
+        if verification_file.exists():
+            try:
+                l1_verdict = verification_file.read_text()
+            except Exception as e:
+                l1_verdict = f"Error reading L1 verification: {e}"
+
+        # Construct System Prompt (Intelligence)
+        system_prompt = f"""
+You are the Governance Enforcer for OneCoder.
+
+**THE RULES (governance.yaml)**:
+{rules}
+
+**THE INTENT (Sprint Context)**:
+Goal: {goal}
+Active Task: {active_task}
+
+**THE VERDICT (Deterministic L1 Status)**:
+{l1_verdict}
+
+**YOUR MISSION**:
+1. Verify if the Code fulfills the Intent.
+2. PRIORITY: If there are L1 failures in THE VERDICT, analyze the specific error logs and provide a mitigation plan to fix them.
+3. Check for any other violations of The Rules (especially Banned Files, Architecture constraints).
+4. Assess code quality (Security, Performance).
+5. If the diff is ambiguous, USE YOUR TOOLS (kit_index, kit_symbols, etc.) to investigate the repository context.
+
+**OUTPUT FORMAT**:
+You must ALWAYS respond with a Strict JSON object:
+{{
+  "pass": boolean,
+  "violations": ["list", "of", "strings"],
+  "feedback": "markdown string summarizing the review",
+  "mitigation_notes": "Technical notes for a coding agent to fix the violations. Be specific about files and changes needed."
+}}
+"""
+        user_message = f"**THE CODE (Git Diff)**:\n{diff[:10000]} # Truncated"
+
+        self.console.print("[cyan]Consulting Intelligence (Agentic Reviewer)...[/cyan]")
+
+        if self.use_agent:
+            try:
+                # Use Agentic flow
+                asyncio.run(self._run_agent_review(system_prompt, user_message))
+                return
+            except Exception as e:
+                self.console.print(f"[yellow]Agentic review failed ({e}). Falling back to simple LLM.[/yellow]")
+
+        # Fallback to simple LLM
+        self._run_simple_review(system_prompt, user_message)
+
+    async def _run_agent_review(self, system_prompt: str, user_message: str):
+        """Run the review using LlmAgent with tools."""
+        model_name = os.getenv("ONECODER_MODEL", "openrouter/xiaomi/mimo-v2-flash:free")
+        model = LiteLlm(model_name)
+        
+        agent = LlmAgent(
+            name="reviewer_agent",
+            model=model,
+            instruction=system_prompt,
+            tools=[kit_index_tool, kit_symbols_tool, kit_file_tree_tool],
+            output_key="final_response"
+        )
+        
+        # Agent run
+        # We append user message to history or as prompt
+        # LlmAgent usually takes a user prompt
+        response = await agent.run(user_message)
+        
+        # Parse output - Agent returns a string usually, hopefully JSON if instructed
+        try:
+            # Clean up markdown code blocks if present
+            clean_response = response.strip()
+            if clean_response.startswith("```json"):
+                clean_response = clean_response[7:]
+            if clean_response.endswith("```"):
+                clean_response = clean_response[:-3]
+            
+            result = json.loads(clean_response)
+            self._render_result(result)
+        except json.JSONDecodeError:
+             self.console.print(f"[red]Agent output is not valid JSON:[/red] {response}")
+             sys.exit(1)
+
+    def _run_simple_review(self, system_prompt: str, user_message: str):
+        """Run legacy simple review."""
+        llm = LLMClient()
+        prompt = system_prompt + "\n\n" + user_message
+        result = llm.generate_json(prompt)
+        self._render_result(result)
+
+    def _render_result(self, result: Dict[str, Any]):
+        passed = result.get("pass", False)
+        color = "green" if passed else "red"
+        
+        self.console.print(Panel(
+            Markdown(result.get("feedback", "")),
+            title=f"[{color}]Review Result: {'PASSED' if passed else 'FAILED'}[/{color}]",
+            border_style=color
+        ))
+        
+        mitigation_notes = result.get("mitigation_notes")
+        if mitigation_notes:
+             self.console.print("\n[bold yellow]Mitigation Notes for Agent:[/bold yellow]")
+             self.console.print(mitigation_notes)
+        
+        # Persist state for delegation
+        try:
+            state_dir = self.project_root / ".onecoder"
+            state_dir.mkdir(exist_ok=True)
+            state_file = state_dir / "review_state.json"
+            state_file.write_text(json.dumps(result, indent=2))
+        except Exception as e:
+            self.console.print(f"[dim]Failed to save review state: {e}[/dim]")
+
+        if not passed:
+            self.console.print("\n[bold red]Violations:[/bold red]")
+            for v in result.get("violations", []):
+                self.console.print(f"  ❌ {v}")
+            sys.exit(1)
+        else:
+             self.console.print("\n[bold green]Policy Checks Passed.[/bold green]")

onecoder/services/delegation_service.py

@@ -0,0 +1,209 @@
+import logging
+import os
+from typing import List, Optional
+from pathlib import Path
+
+from ..models.delegation import DelegationSession
+from ..worktree import WorktreeManager
+from ..tmux import TmuxManager
+from ..blackboard import BlackboardMemory
+from ..backends.base import BaseBackend
+from ..backends.local_tui import LocalTUIBackend
+
+logger = logging.getLogger(__name__)
+
+class DelegationService:
+    """
+    Orchestrates delegated tasks using WorktreeManager and TmuxManager.
+    """
+
+    def __init__(self, blackboard: Optional[BlackboardMemory] = None):
+        self.worktree_mgr = WorktreeManager()
+        self.tmux_mgr = TmuxManager()
+        self.blackboard = blackboard or BlackboardMemory()
+        self.sessions_namespace = "delegation_sessions"
+        self.backends: Dict[str, BaseBackend] = {
+            "local-tui": LocalTUIBackend(self)
+        }
+
+    def create_session(self, task_id: str, backend: str = "local-tui", command: Optional[str] = None, external_id: Optional[str] = None) -> DelegationSession:
+        """Creates and persists a new delegation session."""
+        parent_branch = self.worktree_mgr.get_current_branch()
+        active_sprint_id = os.environ.get("ACTIVE_SPRINT_ID")
+        
+        # Try to find spec_id from knowledge
+        spec_id = None
+        try:
+            from ..knowledge import ProjectKnowledge
+            pk = ProjectKnowledge()
+            knowledge = pk.get_l1_context()
+            if knowledge:
+                # Usually spec_id is in the goal or active task metadata in some implementations
+                # but for now we look for SPEC- prefix in active task title or goal
+                goal = knowledge.get("goal", "")
+                active_task = knowledge.get("active_task", {})
+                
+                import re
+                spec_match = re.search(r"(SPEC-[A-Z0-9.-]+)", goal + " " + active_task.get("title", ""))
+                if spec_match:
+                    spec_id = spec_match.group(1)
+        except Exception:
+            pass
+
+        session = DelegationSession(
+            task_id=task_id,
+            backend=backend,
+            command=command,
+            parent_branch=parent_branch,
+            sprint_id=active_sprint_id,
+            spec_id=spec_id,
+            external_id=external_id
+        )
+        self._save_session(session)
+        return session
+
+    def _save_session(self, session: DelegationSession):
+        """Persists session to blackboard memory."""
+        self.blackboard.set(
+            key=session.id,
+            value=session.model_dump(mode='json'),
+            scope="global",
+            namespace=self.sessions_namespace
+        )
+
+    def get_session(self, session_id: str) -> Optional[DelegationSession]:
+        """Retrieves a session from blackboard."""
+        data = self.blackboard.get(
+            key=session_id,
+            scope="global",
+            namespace=self.sessions_namespace
+        )
+        if data:
+            return DelegationSession(**data)
+        return None
+
+    def list_sessions(self) -> List[DelegationSession]:
+        """Lists all active delegation sessions."""
+        all_data = self.blackboard.get_all(scope="global", namespace=self.sessions_namespace)
+        return [DelegationSession(**data) for data in all_data.values()]
+
+    async def start_session(self, session: DelegationSession, context_metadata: Optional[str] = None) -> str:
+        """
+        Starts a delegation session using the appropriate backend.
+        """
+        backend = self.backends.get(session.backend)
+        if not backend:
+            raise ValueError(f"Unknown backend: {session.backend}")
+            
+        return await backend.spawn(session)
+
+    def stop_session(self, session_id: str, cleanup: bool = True):
+        """Stops a session and optionally cleans up resources."""
+        session = self.get_session(session_id)
+        if not session:
+            return
+
+        if session.tmux_session:
+            self.tmux_mgr.kill_session(session.tmux_session)
+        
+        if cleanup and session.worktree_path:
+            self.worktree_mgr.remove_worktree(session.id, delete_branch=True)
+
+        session.status = "stopped"
+        self._save_session(session)
+
+    def register_task_in_sprint(self, title: str, repo_root: Path) -> tuple[Optional[str], Optional[str]]:
+        """
+        Registers a new task in the active sprint's TODO.md and returns the generated ID.
+        Returns: (sprint_id, task_id)
+        """
+        try:
+            from ai_sprint.state import SprintStateManager
+        except ImportError:
+            logger.warning("ai_sprint SDK not available. Cannot register task.")
+            return None, None
+
+        sprint_dir = repo_root / ".sprint"
+        if not sprint_dir.exists():
+            return None, None
+
+        # 1. Detect Active Sprint
+        # Priority: ACTIVE_SPRINT_ID env > First Active Sprint found
+        active_sprint_id = os.environ.get("ACTIVE_SPRINT_ID")
+        
+        if not active_sprint_id:
+            # Simple discovery: Find first dir with .status containing "Active" or missing .status
+            for item in sorted(sprint_dir.iterdir()):
+                if item.is_dir() and item.name[0].isdigit(): # basic check for sprint dir
+                    status_file = item / ".status"
+                    if not status_file.exists() or status_file.read_text().strip() == "Active":
+                        active_sprint_id = item.name
+                        break
+        
+        if not active_sprint_id:
+            return None, None
+
+        target_sprint_dir = sprint_dir / active_sprint_id
+        todo_file = target_sprint_dir / "TODO.md"
+        
+        if not todo_file.exists():
+            return None, None
+
+        # 2. Append to TODO.md
+        # specific format: "- [ ] {title}"
+        try:
+            with open(todo_file, "a") as f:
+                f.write(f"\n- [ ] {title}\n")
+            
+            # 3. Sync and Retrieve ID
+            state_mgr = SprintStateManager(target_sprint_dir)
+            state_mgr.sync_from_files()
+            task_id = state_mgr.get_task_id_by_title(title)
+            
+            return active_sprint_id, task_id
+            
+        except Exception as e:
+            logger.error(f"Failed to register task in sprint: {e}")
+            return None, None
+
+    def _inject_context(self, wt_path: Path, session: DelegationSession, metadata: Optional[str] = None):
+        """Writes a BOOTSTRAP.md to the worktree to reduce agent TTU."""
+        bootstrap_path = wt_path / "BOOTSTRAP.md"
+        content = f"# Task: {session.task_id}\n\n"
+        content += f"## Branch Context\nParent Branch: `{session.parent_branch}`\n"
+        if session.sprint_id:
+            content += f"Active Sprint: `{session.sprint_id}`\n"
+        if session.spec_id:
+            content += f"Spec ID: `{session.spec_id}`\n"
+            
+        content += f"\n## Instructions\n{session.command or 'No command provided.'}\n\n"
+        content += "## Repository Context\n"
+        
+        # Try to gather automated knowledge
+        try:
+            from ..knowledge import ProjectKnowledge
+            pk = ProjectKnowledge()
+            knowledge = pk.get_rag_ready_output()
+            content += knowledge
+        except Exception:
+            content += "Automated context gathering failed.\n"
+
+        # Inject Mitigation Notes from recent review
+        try:
+            # Assume we are running from project root or can find it
+            review_state_path = Path(".onecoder/review_state.json")
+            if review_state_path.exists():
+                import json
+                state = json.loads(review_state_path.read_text())
+                mitigation_notes = state.get("mitigation_notes")
+                if mitigation_notes:
+                    content += f"\n## Mitigation Notes (Recent Review)\n{mitigation_notes}\n"
+        except Exception as e:
+            logger.warning(f"Failed to inject review notes: {e}")
+
+        if metadata:
+            content += f"\n## Additional Metadata\n{metadata}\n"
+
+        with open(bootstrap_path, "w") as f:
+            f.write(content)
+        logger.info(f"Injected context at {bootstrap_path}")

onecoder/services/validation_service.py

@@ -0,0 +1,104 @@
+import logging
+import subprocess
+from abc import ABC, abstractmethod
+from typing import List, Any, Dict, Optional
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+class BaseValidationRule(ABC):
+    """Base class for all validation rules."""
+    @abstractmethod
+    def validate(self, context: Dict[str, Any]) -> bool:
+        pass
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        pass
+
+class FileExistsRule(BaseValidationRule):
+    """Checks if a file exists relative to a base path."""
+    def __init__(self, filepath: str):
+        self.filepath = filepath
+
+    @property
+    def name(self) -> str:
+        return f"FileExists({self.filepath})"
+
+    def validate(self, context: Dict[str, Any]) -> bool:
+        base_path = context.get("worktree_path")
+        if not base_path:
+            return False
+        return (Path(base_path) / self.filepath).exists()
+
+class CommandSuccessRule(BaseValidationRule):
+    """Checks if a command executes successfully (exit code 0)."""
+    def __init__(self, command: str):
+        self.command = command
+
+    @property
+    def name(self) -> str:
+        return f"CommandSuccess({self.command})"
+
+    def validate(self, context: Dict[str, Any]) -> bool:
+        base_path = context.get("worktree_path")
+        try:
+            result = subprocess.run(
+                self.command,
+                shell=True,
+                cwd=base_path,
+                capture_output=True,
+                check=False
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+
+class ValidationReport:
+    """Structured report for validation results."""
+    def __init__(self, session_id: str, all_passed: bool, results: List[Dict[str, Any]]):
+        self.session_id = session_id
+        self.all_passed = all_passed
+        self.results = results
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "session_id": self.session_id,
+            "all_passed": self.all_passed,
+            "results": self.results
+        }
+
+class ValidationService:
+    """
+    ValidationService runs a set of rules against a delegation session.
+    """
+
+    def validate_session(self, session_context: Dict[str, Any], rules: List[BaseValidationRule]) -> ValidationReport:
+        """
+        Runs all rules and returns a structured ValidationReport.
+        """
+        session_id = session_context.get("session_id", "unknown")
+        results = []
+        all_passed = True
+        
+        for rule in rules:
+            try:
+                passed = rule.validate(session_context)
+                results.append({
+                    "rule": rule.name,
+                    "passed": passed,
+                    "error": None
+                })
+                if not passed:
+                    all_passed = False
+            except Exception as e:
+                logger.error(f"Rule {rule.name} failed with error: {e}")
+                results.append({
+                    "rule": rule.name,
+                    "passed": False,
+                    "error": str(e)
+                })
+                all_passed = False
+                
+        return ValidationReport(session_id, all_passed, results)