@mc1global/opencode-jarvis 0.13.1 → 0.14.0

package/src/application/kanban/context_bridge.py

@@ -1,244 +0,0 @@
-"""
-Context Memory Bridge for Kanban.
-
-Handles integration between Kanban and Context Memory for:
-- Activity logging (notes with card tags)
-- Inter-agent messaging
-- Cross-agent coordination
-
-Follows Interface Segregation Principle - focused on context_memory integration only.
-"""
-
-import subprocess
-import sys
-from pathlib import Path
-from typing import Optional
-from dataclasses import dataclass
-
-
-@dataclass
-class BridgeResult:
-    """Result from context_memory operation."""
-    success: bool
-    message: str = ''
-
-
-class ContextMemoryBridge:
-    """Bridge between Kanban and Context Memory systems."""
-
-    def __init__(self, workspace: str = 'default'):
-        self.workspace = workspace
-        self._cli_path = self._get_cli_path()
-
-    def _get_cli_path(self) -> str:
-        """Get path to context_memory_cli.py."""
-        return str(
-            Path(__file__).parent.parent.parent.parent
-            / "scripts" / "context_memory_cli.py"
-        )
-
-    def _run_cli(self, args: list) -> BridgeResult:
-        """Execute context_memory_cli with arguments."""
-        try:
-            result = subprocess.run(
-                [sys.executable, self._cli_path] + args,
-                capture_output=True,
-                text=True,
-                timeout=10
-            )
-            return BridgeResult(
-                success=result.returncode == 0,
-                message=result.stdout.strip() if result.returncode == 0 else result.stderr.strip()
-            )
-        except subprocess.TimeoutExpired:
-            return BridgeResult(success=False, message='timeout')
-        except Exception as e:
-            return BridgeResult(success=False, message=str(e)[:50])
-
-    def log_activity(
-        self,
-        action: str,
-        card_id: str,
-        agent: str,
-        details: str = '',
-        extra_tags: str = ''
-    ) -> BridgeResult:
-        """
-        Log card activity to context_memory as a note.
-
-        Args:
-            action: Action type (STARTED, PAUSED, RESUMED, COMPLETED, etc.)
-            card_id: Card identifier (CD-001)
-            agent: Agent performing action
-            details: Additional details
-            extra_tags: Extra comma-separated tags
-        """
-        content = f"[{action.upper()}] Card {card_id} by {agent}"
-        if details:
-            content += f" - {details}"
-
-        tags = f"kanban,card:{card_id},agent:{agent}"
-        if extra_tags:
-            tags += f",{extra_tags}"
-
-        return self._run_cli([
-            "note", "add", content,
-            "--tags", tags,
-            "--workspace", self.workspace
-        ])
-
-    def send_message(
-        self,
-        from_agent: str,
-        to_agent: str,
-        subject: str,
-        content: str,
-        priority: int = 3,
-        card_id: Optional[str] = None
-    ) -> BridgeResult:
-        """
-        Send inter-agent message via context_memory.
-
-        Args:
-            from_agent: Sender agent name
-            to_agent: Recipient agent name
-            subject: Message subject
-            content: Message content
-            priority: Priority 1-5 (default 3)
-            card_id: Optional card reference to include in subject
-        """
-        if card_id:
-            subject = f"[{card_id}] {subject}"
-
-        return self._run_cli([
-            "message", "send",
-            "--from", from_agent,
-            "--to", to_agent,
-            "--subject", subject,
-            "--content", content,
-            "--workspace", self.workspace,
-            "--priority", str(priority)
-        ])
-
-    def search_card_context(self, card_id: str) -> BridgeResult:
-        """
-        Search context_memory for entries related to a card.
-
-        Args:
-            card_id: Card identifier to search for
-        """
-        return self._run_cli([
-            "search", f"card:{card_id}",
-            "--workspace", self.workspace
-        ])
-
-    def log_card_started(
-        self, card_id: str, agent: str, title: str
-    ) -> BridgeResult:
-        """Log that agent started working on card."""
-        return self.log_activity(
-            action="STARTED",
-            card_id=card_id,
-            agent=agent,
-            details=title[:50],
-            extra_tags="work_started"
-        )
-
-    def log_card_paused(
-        self, card_id: str, agent: str, reason: str = ''
-    ) -> BridgeResult:
-        """Log that agent paused work on card."""
-        return self.log_activity(
-            action="PAUSED",
-            card_id=card_id,
-            agent=agent,
-            details=reason,
-            extra_tags="work_paused"
-        )
-
-    def log_card_resumed(self, card_id: str, agent: str) -> BridgeResult:
-        """Log that agent resumed work on card."""
-        return self.log_activity(
-            action="RESUMED",
-            card_id=card_id,
-            agent=agent,
-            extra_tags="work_resumed"
-        )
-
-    def log_card_completed(
-        self, card_id: str, agent: str, summary: str = ''
-    ) -> BridgeResult:
-        """Log that agent completed work on card."""
-        return self.log_activity(
-            action="COMPLETED",
-            card_id=card_id,
-            agent=agent,
-            details=summary or "Ready for review",
-            extra_tags="work_completed"
-        )
-
-    def send_review_request(
-        self,
-        card_id: str,
-        card_title: str,
-        from_agent: str,
-        to_reviewer: str,
-        summary: str = ''
-    ) -> BridgeResult:
-        """
-        Send review request message to reviewer.
-
-        Args:
-            card_id: Card ready for review
-            card_title: Card title for context
-            from_agent: Agent requesting review
-            to_reviewer: Reviewer agent
-            summary: Work summary
-        """
-        content = (
-            f"Card '{card_title}' is ready for review.\n\n"
-            f"Summary: {summary or 'N/A'}\n\n"
-            f"Review using: kanban_manager.py card review {card_id} --pass/--fail"
-        )
-
-        return self.send_message(
-            from_agent=from_agent,
-            to_agent=to_reviewer,
-            subject=f"Review Request: {card_id}",
-            content=content,
-            priority=4,
-            card_id=card_id
-        )
-
-    def send_card_message(
-        self,
-        card_id: str,
-        card_title: str,
-        from_agent: str,
-        to_agent: str,
-        subject: str,
-        content: str,
-        priority: int = 3
-    ) -> BridgeResult:
-        """
-        Send message about a card to another agent.
-
-        Args:
-            card_id: Related card
-            card_title: Card title for context
-            from_agent: Sender
-            to_agent: Recipient
-            subject: Message subject
-            content: Message body
-            priority: Priority 1-5
-        """
-        full_content = f"Re: Card {card_id} - {card_title}\n\n{content}"
-
-        return self.send_message(
-            from_agent=from_agent,
-            to_agent=to_agent,
-            subject=subject,
-            content=full_content,
-            priority=priority,
-            card_id=card_id
-        )

package/src/application/kanban/grooming_validator.py

@@ -1,219 +0,0 @@
-"""
-Grooming Validator Service for Kanban bounded context.
-
-Validates that cards have completed required grooming activities
-before allowing transition from GROOMING to READY status.
-
-Following DDD: Application layer orchestrates validation logic,
-Domain layer defines what constitutes valid grooming.
-"""
-
-from typing import Optional
-from dataclasses import dataclass
-from datetime import datetime, timezone
-import sqlite3
-
-from src.infrastructure.kanban import KanbanRepository
-
-
-@dataclass
-class GroomingResult:
-    """Result of grooming validation."""
-    valid: bool
-    artifacts_count: int = 0
-    has_description: bool = False
-    has_acceptance_criteria: bool = False
-    errors: list = None
-
-    def __post_init__(self):
-        if self.errors is None:
-            self.errors = []
-
-
-class GroomingValidator:
-    """
-    Validates grooming phase completion for cards.
-
-    Checks required artifacts and acceptance criteria before
-    allowing promotion from GROOMING to READY status.
-    """
-
-    # Minimum requirements for grooming completion
-    MIN_ARTIFACTS = 1
-    REQUIRE_DESCRIPTION = True
-
-    def __init__(self, workspace: str):
-        self.workspace = workspace
-        self._repo: Optional[KanbanRepository] = None
-
-    def _get_repo(self) -> KanbanRepository:
-        if self._repo is None:
-            self._repo = KanbanRepository(self.workspace)
-            self._repo.connect()
-        return self._repo
-
-    def validate_for_ready(self, card_id: str) -> GroomingResult:
-        """
-        Validate if a card is ready to move from GROOMING to READY.
-
-        Requirements:
-        - At least MIN_ARTIFACTS artifacts (scope_doc, diagram, etc)
-        - Description is not empty (if REQUIRE_DESCRIPTION is True)
-
-        Returns:
-            GroomingResult with validation status and details
-        """
-        repo = self._get_repo()
-        conn = repo._conn
-
-        # Get card info
-        card = repo.get_card(card_id)
-        if not card:
-            return GroomingResult(
-                valid=False,
-                errors=[f"card_not_found:{card_id}"]
-            )
-
-        # Check current status
-        if card.status != 'grooming':
-            return GroomingResult(
-                valid=False,
-                errors=[f"card_not_in_grooming:{card.status}"]
-            )
-
-        errors = []
-
-        # Count artifacts from both tables
-        artifacts_count = self._count_artifacts(conn, card_id)
-        if artifacts_count < self.MIN_ARTIFACTS:
-            errors.append(f"insufficient_artifacts:{artifacts_count}<{self.MIN_ARTIFACTS}")
-
-        # Check description
-        has_description = bool(card.description and card.description.strip())
-        if self.REQUIRE_DESCRIPTION and not has_description:
-            errors.append("missing_description")
-
-        # Check acceptance criteria (optional but recommended)
-        ac_count = self._count_acceptance_criteria(conn, card_id)
-        has_ac = ac_count > 0
-
-        return GroomingResult(
-            valid=len(errors) == 0,
-            artifacts_count=artifacts_count,
-            has_description=has_description,
-            has_acceptance_criteria=has_ac,
-            errors=errors
-        )
-
-    def complete_grooming(self, card_id: str) -> GroomingResult:
-        """
-        Mark grooming as completed for a card.
-
-        This should only be called after validate_for_ready() returns valid=True.
-        Updates the grooming tracking fields in the cards table.
-
-        Returns:
-            GroomingResult with updated artifact count
-        """
-        repo = self._get_repo()
-        conn = repo._conn
-
-        # First validate
-        validation = self.validate_for_ready(card_id)
-        if not validation.valid:
-            return validation
-
-        # Update grooming fields
-        now = datetime.now(timezone.utc).isoformat()
-        conn.execute(
-            """
-            UPDATE cards
-            SET grooming_completed = 1,
-                grooming_artifacts_count = ?,
-                grooming_at = ?,
-                updated_at = ?
-            WHERE id = ?
-            """,
-            (validation.artifacts_count, now, now, card_id)
-        )
-        conn.commit()
-
-        return GroomingResult(
-            valid=True,
-            artifacts_count=validation.artifacts_count,
-            has_description=validation.has_description,
-            has_acceptance_criteria=validation.has_acceptance_criteria
-        )
-
-    def get_grooming_status(self, card_id: str) -> GroomingResult:
-        """
-        Get current grooming status for a card without validation.
-
-        Returns current artifact count and field status.
-        """
-        repo = self._get_repo()
-        conn = repo._conn
-
-        card = repo.get_card(card_id)
-        if not card:
-            return GroomingResult(
-                valid=False,
-                errors=[f"card_not_found:{card_id}"]
-            )
-
-        artifacts_count = self._count_artifacts(conn, card_id)
-        has_description = bool(card.description and card.description.strip())
-        ac_count = self._count_acceptance_criteria(conn, card_id)
-
-        # Check if grooming was already completed
-        cursor = conn.execute(
-            "SELECT grooming_completed, grooming_at FROM cards WHERE id = ?",
-            (card_id,)
-        )
-        row = cursor.fetchone()
-        grooming_completed = row[0] == 1 if row else False
-
-        return GroomingResult(
-            valid=grooming_completed or (artifacts_count >= self.MIN_ARTIFACTS and has_description),
-            artifacts_count=artifacts_count,
-            has_description=has_description,
-            has_acceptance_criteria=ac_count > 0
-        )
-
-    def _count_artifacts(self, conn: sqlite3.Connection, card_id: str) -> int:
-        """Count artifacts from both artifacts and technical_artifacts tables."""
-        # Basic artifacts
-        cursor = conn.execute(
-            "SELECT COUNT(*) FROM artifacts WHERE card_id = ?",
-            (card_id,)
-        )
-        basic_count = cursor.fetchone()[0]
-
-        # Technical artifacts
-        cursor = conn.execute(
-            "SELECT COUNT(*) FROM technical_artifacts WHERE card_id = ? AND status = 'active'",
-            (card_id,)
-        )
-        tech_count = cursor.fetchone()[0]
-
-        return basic_count + tech_count
-
-    def _count_acceptance_criteria(self, conn: sqlite3.Connection, card_id: str) -> int:
-        """Count acceptance criteria for a card."""
-        cursor = conn.execute(
-            "SELECT COUNT(*) FROM acceptance_criteria WHERE card_id = ?",
-            (card_id,)
-        )
-        return cursor.fetchone()[0]
-
-    def close(self):
-        """Close repository connection."""
-        if self._repo:
-            self._repo.close()
-            self._repo = None
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()