moai-adk 0.34.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

moai_adk/loop/__init__.py

@@ -0,0 +1,54 @@
+# Loop Controller Module
+"""Ralph-style autonomous feedback loop controller for MoAI-ADK.
+
+This module provides the core loop controller functionality that enables
+autonomous feedback loops with LSP diagnostics and AST-grep analysis.
+
+Main components:
+- LoopState: Data model for tracking loop execution state
+- LoopStorage: Persistent storage for loop states
+- FeedbackGenerator: Generate feedback from LSP and AST-grep results
+- MoAILoopController: Main controller orchestrating the feedback loop
+
+Usage:
+    from moai_adk.loop import MoAILoopController, LoopStorage
+
+    storage = LoopStorage(storage_dir=".moai/loop")
+    controller = MoAILoopController(storage=storage)
+
+    # Start a new feedback loop
+    state = controller.start_loop(promise="Fix all LSP errors")
+
+    # Run feedback iteration
+    result = await controller.run_feedback_loop(state)
+
+    # Check completion
+    completion = controller.check_completion(state)
+"""
+
+from moai_adk.loop.controller import MoAILoopController
+from moai_adk.loop.feedback import FeedbackGenerator
+from moai_adk.loop.state import (
+    ASTIssueSnapshot,
+    CompletionResult,
+    DiagnosticSnapshot,
+    FeedbackResult,
+    LoopState,
+    LoopStatus,
+)
+from moai_adk.loop.storage import LoopStorage
+
+__all__ = [
+    # Controller
+    "MoAILoopController",
+    # State models
+    "LoopStatus",
+    "DiagnosticSnapshot",
+    "ASTIssueSnapshot",
+    "LoopState",
+    "CompletionResult",
+    "FeedbackResult",
+    # Supporting classes
+    "LoopStorage",
+    "FeedbackGenerator",
+]

moai_adk/loop/controller.py

@@ -0,0 +1,305 @@
+# Loop Controller
+"""Ralph-style autonomous feedback loop controller.
+
+Provides the main controller for orchestrating feedback loops that
+integrate LSP diagnostics and AST-grep analysis to guide Claude
+through iterative code improvement.
+"""
+
+from __future__ import annotations
+
+import uuid
+from datetime import datetime, timezone
+
+from moai_adk.loop.feedback import FeedbackGenerator
+from moai_adk.loop.state import (
+    ASTIssueSnapshot,
+    CompletionResult,
+    DiagnosticSnapshot,
+    FeedbackResult,
+    LoopState,
+    LoopStatus,
+)
+from moai_adk.loop.storage import LoopStorage
+
+
+class MoAILoopController:
+    """Ralph-style feedback loop controller.
+
+    Orchestrates autonomous feedback loops that continuously gather
+    LSP diagnostics and AST-grep results, providing feedback to Claude
+    until the specified completion condition (promise) is met.
+
+    Attributes:
+        storage: The storage backend for loop states.
+        feedback_generator: Generator for feedback text.
+    """
+
+    def __init__(self, storage: LoopStorage | None = None):
+        """Initialize the loop controller.
+
+        Args:
+            storage: Optional storage backend. If not provided, creates
+                a default storage in .moai/loop directory.
+        """
+        self.storage = storage or LoopStorage()
+        self.feedback_generator = FeedbackGenerator()
+
+    def start_loop(
+        self,
+        promise: str,
+        max_iterations: int = 10,
+    ) -> LoopState:
+        """Start a new feedback loop.
+
+        Creates and persists a new loop state with the specified
+        completion condition and iteration limit.
+
+        Args:
+            promise: The completion condition for the loop.
+            max_iterations: Maximum number of iterations allowed.
+
+        Returns:
+            The initial LoopState for the new loop.
+        """
+        now = datetime.now(timezone.utc)
+        loop_id = f"loop-{uuid.uuid4().hex[:8]}"
+
+        state = LoopState(
+            loop_id=loop_id,
+            promise=promise,
+            current_iteration=0,
+            max_iterations=max_iterations,
+            status=LoopStatus.RUNNING,
+            created_at=now,
+            updated_at=now,
+        )
+
+        self.storage.save_state(state)
+        return state
+
+    def check_completion(self, state: LoopState) -> CompletionResult:
+        """Check if the loop's completion condition is met.
+
+        Analyzes the current state to determine if the promise
+        has been fulfilled (no remaining issues).
+
+        Args:
+            state: The current loop state to check.
+
+        Returns:
+            CompletionResult indicating completion status and progress.
+        """
+        # Get the most recent snapshots
+        current_lsp_issues = 0
+        current_ast_issues = 0
+
+        if state.diagnostics_history:
+            latest_diag = state.diagnostics_history[-1]
+            current_lsp_issues = latest_diag.total_issues()
+
+        if state.ast_issues_history:
+            latest_ast = state.ast_issues_history[-1]
+            current_ast_issues = latest_ast.total_issues
+
+        total_issues = current_lsp_issues + current_ast_issues
+
+        # Calculate progress
+        initial_issues = self._get_initial_issue_count(state)
+        if initial_issues > 0:
+            progress = ((initial_issues - total_issues) / initial_issues) * 100
+            progress = max(0, min(100, progress))
+        else:
+            progress = 100.0 if total_issues == 0 else 0.0
+
+        # Check completion
+        if total_issues == 0:
+            return CompletionResult(
+                is_complete=True,
+                reason="All issues resolved. Promise fulfilled.",
+                remaining_issues=0,
+                progress_percentage=100.0,
+            )
+
+        # Not complete
+        reason = f"{total_issues} issues remaining ({current_lsp_issues} LSP, {current_ast_issues} AST)"
+        return CompletionResult(
+            is_complete=False,
+            reason=reason,
+            remaining_issues=total_issues,
+            progress_percentage=progress,
+        )
+
+    async def run_feedback_loop(self, state: LoopState) -> FeedbackResult:
+        """Execute a single feedback loop iteration.
+
+        Gathers current LSP diagnostics and AST-grep issues,
+        generates feedback, and updates the loop state.
+
+        Args:
+            state: The current loop state.
+
+        Returns:
+            FeedbackResult containing the iteration results.
+        """
+        now = datetime.now(timezone.utc)
+
+        # Get current diagnostics
+        lsp_snapshot = self._get_lsp_diagnostics()
+        ast_snapshot = self._get_ast_issues()
+
+        # Get previous snapshot for comparison
+        previous = None
+        if state.diagnostics_history and state.ast_issues_history:
+            previous = (state.diagnostics_history[-1], state.ast_issues_history[-1])
+
+        # Generate feedback
+        feedback_text = self.feedback_generator.generate_feedback(
+            lsp_snapshot,
+            ast_snapshot,
+            previous_snapshot=previous,
+        )
+
+        # Get priority issues
+        priority_issues = self.feedback_generator.prioritize_issues([], [])
+
+        # Create feedback result
+        result = FeedbackResult(
+            lsp_diagnostics=lsp_snapshot,
+            ast_issues=ast_snapshot,
+            feedback_text=feedback_text,
+            priority_issues=priority_issues,
+        )
+
+        # Update state with new history
+        new_diagnostics_history = list(state.diagnostics_history) + [lsp_snapshot]
+        new_ast_history = list(state.ast_issues_history) + [ast_snapshot]
+
+        updated_state = LoopState(
+            loop_id=state.loop_id,
+            promise=state.promise,
+            current_iteration=state.current_iteration + 1,
+            max_iterations=state.max_iterations,
+            status=state.status,
+            created_at=state.created_at,
+            updated_at=now,
+            diagnostics_history=new_diagnostics_history,
+            ast_issues_history=new_ast_history,
+        )
+
+        self.storage.save_state(updated_state)
+
+        return result
+
+    def cancel_loop(self, loop_id: str) -> bool:
+        """Cancel an active loop.
+
+        Marks the loop as cancelled if it exists and is still active.
+
+        Args:
+            loop_id: The ID of the loop to cancel.
+
+        Returns:
+            True if the loop was cancelled, False otherwise.
+        """
+        state = self.storage.load_state(loop_id)
+        if state is None:
+            return False
+
+        if not state.is_active():
+            return False
+
+        now = datetime.now(timezone.utc)
+        cancelled_state = LoopState(
+            loop_id=state.loop_id,
+            promise=state.promise,
+            current_iteration=state.current_iteration,
+            max_iterations=state.max_iterations,
+            status=LoopStatus.CANCELLED,
+            created_at=state.created_at,
+            updated_at=now,
+            diagnostics_history=state.diagnostics_history,
+            ast_issues_history=state.ast_issues_history,
+        )
+
+        self.storage.save_state(cancelled_state)
+        return True
+
+    def get_active_loop(self) -> LoopState | None:
+        """Get the currently active loop.
+
+        Returns:
+            The active LoopState, or None if no loop is active.
+        """
+        active_id = self.storage.get_active_loop_id()
+        if active_id is None:
+            return None
+        return self.storage.load_state(active_id)
+
+    def get_loop_status(self, loop_id: str) -> LoopState | None:
+        """Get the status of a specific loop.
+
+        Args:
+            loop_id: The ID of the loop to query.
+
+        Returns:
+            The LoopState, or None if not found.
+        """
+        return self.storage.load_state(loop_id)
+
+    def _get_initial_issue_count(self, state: LoopState) -> int:
+        """Get the initial issue count from the first snapshots.
+
+        Args:
+            state: The loop state to analyze.
+
+        Returns:
+            The initial total issue count.
+        """
+        initial_count = 0
+
+        if state.diagnostics_history:
+            initial_count += state.diagnostics_history[0].total_issues()
+
+        if state.ast_issues_history:
+            initial_count += state.ast_issues_history[0].total_issues
+
+        return initial_count
+
+    def _get_lsp_diagnostics(self) -> DiagnosticSnapshot:
+        """Get current LSP diagnostics.
+
+        This method should be overridden or mocked in tests.
+        In production, it would integrate with the LSP client.
+
+        Returns:
+            DiagnosticSnapshot of current issues.
+        """
+        # Default implementation returns empty snapshot
+        # In production, this would call the LSP client
+        return DiagnosticSnapshot(
+            timestamp=datetime.now(timezone.utc),
+            error_count=0,
+            warning_count=0,
+            info_count=0,
+            files_affected=[],
+        )
+
+    def _get_ast_issues(self) -> ASTIssueSnapshot:
+        """Get current AST-grep issues.
+
+        This method should be overridden or mocked in tests.
+        In production, it would integrate with the AST-grep analyzer.
+
+        Returns:
+            ASTIssueSnapshot of current issues.
+        """
+        # Default implementation returns empty snapshot
+        # In production, this would call the AST-grep analyzer
+        return ASTIssueSnapshot(
+            timestamp=datetime.now(timezone.utc),
+            total_issues=0,
+            by_severity={},
+            by_rule={},
+            files_affected=[],
+        )

moai_adk/loop/feedback.py

@@ -0,0 +1,230 @@
+# Loop Feedback Generator
+"""Feedback generation for Claude from LSP and AST-grep results.
+
+Provides functionality to transform diagnostic and AST analysis results
+into actionable feedback for Claude during feedback loop iterations.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from moai_adk.astgrep.models import ASTMatch
+from moai_adk.loop.state import ASTIssueSnapshot, DiagnosticSnapshot
+from moai_adk.lsp.models import Diagnostic, DiagnosticSeverity
+
+# Security-related rule IDs that should be prioritized
+SECURITY_RULES = frozenset(
+    {
+        "sql-injection",
+        "xss",
+        "command-injection",
+        "path-traversal",
+        "eval-usage",
+        "no-eval",
+        "hardcoded-secret",
+        "insecure-random",
+    }
+)
+
+
+class FeedbackGenerator:
+    """Generator for Claude feedback from LSP and AST-grep results.
+
+    Transforms diagnostic snapshots and AST issue snapshots into
+    human-readable feedback text and prioritized issue lists.
+
+    Attributes:
+        max_priority_issues: Maximum number of priority issues to return.
+        include_suggestions: Whether to include fix suggestions.
+    """
+
+    def __init__(
+        self,
+        max_priority_issues: int = 10,
+        include_suggestions: bool = True,
+    ):
+        """Initialize the feedback generator.
+
+        Args:
+            max_priority_issues: Maximum number of priority issues to return.
+            include_suggestions: Whether to include fix suggestions.
+        """
+        self.max_priority_issues = max_priority_issues
+        self.include_suggestions = include_suggestions
+
+    def generate_feedback(
+        self,
+        lsp_snapshot: DiagnosticSnapshot,
+        ast_snapshot: ASTIssueSnapshot,
+        previous_snapshot: tuple[DiagnosticSnapshot, ASTIssueSnapshot] | None = None,
+    ) -> str:
+        """Generate feedback text from LSP and AST snapshots.
+
+        Creates a human-readable summary of the current diagnostic state,
+        optionally comparing with a previous snapshot to show progress.
+
+        Args:
+            lsp_snapshot: Current LSP diagnostic snapshot.
+            ast_snapshot: Current AST issue snapshot.
+            previous_snapshot: Optional previous snapshots for comparison.
+
+        Returns:
+            Formatted feedback text for Claude.
+        """
+        lines: list[str] = []
+
+        # Check if there are no issues
+        total_lsp = lsp_snapshot.total_issues()
+        total_ast = ast_snapshot.total_issues
+
+        if total_lsp == 0 and total_ast == 0:
+            lines.append("No issues found. Code is clean.")
+            return "\n".join(lines)
+
+        # LSP Diagnostics summary
+        lines.append("## LSP Diagnostics Summary")
+        lines.append(f"- Errors: {lsp_snapshot.error_count}")
+        lines.append(f"- Warnings: {lsp_snapshot.warning_count}")
+        lines.append(f"- Info: {lsp_snapshot.info_count}")
+        if lsp_snapshot.files_affected:
+            lines.append(f"- Files affected: {', '.join(lsp_snapshot.files_affected)}")
+        lines.append("")
+
+        # AST Issues summary
+        lines.append("## AST-grep Issues Summary")
+        lines.append(f"- Total issues: {ast_snapshot.total_issues}")
+        if ast_snapshot.by_severity:
+            severity_parts = [f"{count} {sev}" for sev, count in ast_snapshot.by_severity.items()]
+            lines.append(f"- By severity: {', '.join(severity_parts)}")
+        if ast_snapshot.by_rule:
+            rule_parts = [f"{rule}: {count}" for rule, count in ast_snapshot.by_rule.items()]
+            lines.append(f"- By rule: {', '.join(rule_parts)}")
+        if ast_snapshot.files_affected:
+            lines.append(f"- Files affected: {', '.join(ast_snapshot.files_affected)}")
+        lines.append("")
+
+        # Comparison with previous snapshot
+        if previous_snapshot is not None:
+            prev_lsp, prev_ast = previous_snapshot
+            lines.append("## Progress")
+
+            lsp_diff = prev_lsp.total_issues() - total_lsp
+            ast_diff = prev_ast.total_issues - total_ast
+
+            if lsp_diff > 0:
+                lines.append(f"- LSP issues reduced by {lsp_diff}")
+            elif lsp_diff < 0:
+                lines.append(f"- LSP issues increased by {-lsp_diff}")
+            else:
+                lines.append("- LSP issues unchanged")
+
+            if ast_diff > 0:
+                lines.append(f"- AST issues fixed: {ast_diff}")
+            elif ast_diff < 0:
+                lines.append(f"- AST issues increased by {-ast_diff}")
+            else:
+                lines.append("- AST issues unchanged")
+
+            total_improvement = lsp_diff + ast_diff
+            if total_improvement > 0:
+                lines.append(f"- Overall improvement: {total_improvement} issues fixed")
+            lines.append("")
+
+        # Priority guidance
+        if lsp_snapshot.error_count > 0 or ast_snapshot.by_severity.get("error", 0) > 0:
+            lines.append("## Priority")
+            lines.append("Focus on fixing errors first, then warnings.")
+
+        return "\n".join(lines)
+
+    def format_for_hook(self, feedback: str) -> dict[str, Any]:
+        """Format feedback text for hook output.
+
+        Converts the feedback text into a structured dictionary format
+        suitable for Claude Code hook consumption.
+
+        Args:
+            feedback: The feedback text to format.
+
+        Returns:
+            Dictionary with feedback and metadata.
+        """
+        return {
+            "type": "loop_feedback",
+            "source": "moai_loop_controller",
+            "feedback": feedback,
+            "text": feedback,
+        }
+
+    def prioritize_issues(
+        self,
+        diagnostics: list[Diagnostic],
+        ast_matches: list[ASTMatch],
+    ) -> list[str]:
+        """Prioritize and format issues for Claude.
+
+        Sorts issues by severity and type, with security issues first,
+        then errors, then warnings. Returns formatted issue strings.
+
+        Args:
+            diagnostics: List of LSP diagnostics.
+            ast_matches: List of AST-grep matches.
+
+        Returns:
+            List of formatted issue strings, sorted by priority.
+        """
+        if not diagnostics and not ast_matches:
+            return []
+
+        priority_issues: list[tuple[int, str]] = []
+
+        # Process AST matches (security issues get highest priority)
+        for match in ast_matches:
+            is_security = match.rule_id.lower() in SECURITY_RULES
+            is_error = match.severity.lower() == "error"
+
+            # Priority: lower is higher priority
+            # Security errors: 0, Security warnings: 1, Regular errors: 2, Regular warnings: 3
+            if is_security and is_error:
+                priority = 0
+            elif is_security:
+                priority = 1
+            elif is_error:
+                priority = 2
+            else:
+                priority = 3
+
+            line_num = match.range.start.line + 1  # Convert to 1-based
+            issue_text = f"[{match.severity.upper()}] {match.message} at {match.file_path}:{line_num}"
+            if self.include_suggestions and match.suggested_fix:
+                issue_text += f" (Fix: {match.suggested_fix})"
+
+            priority_issues.append((priority, issue_text))
+
+        # Process LSP diagnostics
+        for diag in diagnostics:
+            is_error = diag.severity == DiagnosticSeverity.ERROR
+            is_warning = diag.severity == DiagnosticSeverity.WARNING
+
+            # Priority: errors: 2, warnings: 3, info/hint: 4
+            if is_error:
+                priority = 2
+            elif is_warning:
+                priority = 3
+            else:
+                priority = 4
+
+            line_num = diag.range.start.line + 1  # Convert to 1-based
+            severity_name = diag.severity.name
+            issue_text = f"[{severity_name}] {diag.message} at line {line_num}"
+            if diag.source:
+                issue_text = f"[{severity_name}] ({diag.source}) {diag.message} at line {line_num}"
+
+            priority_issues.append((priority, issue_text))
+
+        # Sort by priority (lower number = higher priority)
+        priority_issues.sort(key=lambda x: x[0])
+
+        # Extract just the issue texts, limited to max
+        return [issue_text for _, issue_text in priority_issues[: self.max_priority_issues]]