devsquad 3.6.0__py3-none-any.whl

scripts/collaboration/dual_layer_context.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+import logging
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass, field
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ContextEntry:
+    key: str
+    value: Any
+    layer: str = "task"
+    source: str = ""
+    timestamp: str = field(default_factory=lambda: datetime.now().isoformat())
+    ttl: Optional[int] = None
+
+    def is_expired(self) -> bool:
+        if self.ttl is None:
+            return False
+        from datetime import timedelta
+        created = datetime.fromisoformat(self.timestamp)
+        return (datetime.now() - created).total_seconds() > self.ttl
+
+
+class DualLayerContextManager:
+    """
+    Dual-layer context manager for DevSquad.
+
+    Manages two context layers:
+    - **Project layer**: Long-lived, project-wide context (architecture decisions, tech stack, conventions)
+    - **Task layer**: Short-lived, task-specific context (current task, worker results, scratchpad state)
+
+    This separation prevents task-specific noise from polluting project-level context,
+    and allows project context to persist across multiple task dispatches.
+    """
+
+    def __init__(self, max_project_entries: int = 100, max_task_entries: int = 50):
+        self.project_context: Dict[str, ContextEntry] = {}
+        self.task_context: Dict[str, ContextEntry] = {}
+        self.max_project = max_project_entries
+        self.max_task = max_task_entries
+
+    def set_project(self, key: str, value: Any, source: str = "", ttl: Optional[int] = None):
+        self.project_context[key] = ContextEntry(
+            key=key, value=value, layer="project", source=source, ttl=ttl,
+        )
+        self._evict_if_needed("project")
+
+    def get_project(self, key: str, default: Any = None) -> Any:
+        entry = self.project_context.get(key)
+        if entry and not entry.is_expired():
+            return entry.value
+        if entry and entry.is_expired():
+            del self.project_context[key]
+        return default
+
+    def set_task(self, key: str, value: Any, source: str = "", ttl: Optional[int] = None):
+        self.task_context[key] = ContextEntry(
+            key=key, value=value, layer="task", source=source, ttl=ttl,
+        )
+        self._evict_if_needed("task")
+
+    def get_task(self, key: str, default: Any = None) -> Any:
+        entry = self.task_context.get(key)
+        if entry and not entry.is_expired():
+            return entry.value
+        if entry and entry.is_expired():
+            del self.task_context[key]
+        return default
+
+    def get_combined(self, keys: Optional[List[str]] = None) -> Dict[str, Any]:
+        combined = {}
+        for k, v in self.project_context.items():
+            if not v.is_expired() and (keys is None or k in keys):
+                combined[k] = v.value
+        for k, v in self.task_context.items():
+            if not v.is_expired() and (keys is None or k in keys):
+                combined[k] = v.value
+        return combined
+
+    def build_prompt_context(self, role_id: str = "", task_description: str = "") -> str:
+        parts = []
+        if self.project_context:
+            parts.append("## Project Context")
+            for k, v in self.project_context.items():
+                if not v.is_expired():
+                    parts.append(f"- **{k}**: {v.value}")
+
+        if self.task_context:
+            parts.append("\n## Task Context")
+            for k, v in self.task_context.items():
+                if not v.is_expired():
+                    parts.append(f"- **{k}**: {v.value}")
+
+        return "\n".join(parts)
+
+    def clear_task_context(self):
+        self.task_context.clear()
+
+    def clear_all(self):
+        self.project_context.clear()
+        self.task_context.clear()
+
+    def cleanup_expired(self):
+        expired_project = [k for k, v in self.project_context.items() if v.is_expired()]
+        expired_task = [k for k, v in self.task_context.items() if v.is_expired()]
+        for k in expired_project:
+            del self.project_context[k]
+        for k in expired_task:
+            del self.task_context[k]
+        return len(expired_project) + len(expired_task)
+
+    def get_stats(self) -> Dict[str, Any]:
+        return {
+            "project_entries": len(self.project_context),
+            "task_entries": len(self.task_context),
+            "total_entries": len(self.project_context) + len(self.task_context),
+        }
+
+    def _evict_if_needed(self, layer: str):
+        if layer == "project" and len(self.project_context) > self.max_project:
+            oldest_key = min(self.project_context, key=lambda k: self.project_context[k].timestamp)
+            del self.project_context[oldest_key]
+        elif layer == "task" and len(self.task_context) > self.max_task:
+            oldest_key = min(self.task_context, key=lambda k: self.task_context[k].timestamp)
+            del self.task_context[oldest_key]

scripts/collaboration/enhanced_worker.py

@@ -0,0 +1,539 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Enhanced Worker Module
+
+Extends the base Worker with:
+- Agent briefing integration (personalization memory)
+- Performance monitoring integration
+- LLM cache integration
+- Retry mechanism integration
+- Protocol-based provider injection
+
+Usage:
+    from scripts.collaboration.enhanced_worker import EnhancedWorker
+
+    worker = EnhancedWorker(
+        worker_id="architect-1",
+        role_id="architect",
+        cache_provider=llm_cache,
+        retry_provider=llm_retry,
+        monitor_provider=performance_monitor,
+    )
+
+    result = worker.execute(task)
+
+Version: v1.0
+Created: 2026-05-01
+"""
+
+import re
+import time
+import logging
+import unicodedata
+from typing import Optional, Dict, Any, List
+from dataclasses import dataclass, field
+
+from .worker import Worker
+from .models import TaskDefinition, WorkerResult, ROLE_REGISTRY
+
+logger = logging.getLogger(__name__)
+
+_SAFE_FILENAME_RE = re.compile(r'[^\w\-.]')
+_MAX_RULE_TEXT_LENGTH = 500
+
+
+def _is_available(provider) -> bool:
+    """Check provider availability, compatible with both property and method."""
+    if provider is None:
+        return False
+    val = provider.is_available
+    if callable(val):
+        return val()
+    return bool(val)
+
+
+@dataclass
+class AgentBriefingOutput:
+    """Compressed state passed between Agents (latent-briefing pattern)."""
+    task_summary: str = ""
+    key_decisions: List[str] = field(default_factory=list)
+    pending_items: List[str] = field(default_factory=list)
+    rules_applied: List[str] = field(default_factory=list)
+    result_summary: str = ""
+    confidence: float = 0.0
+    assumptions: List[str] = field(default_factory=list)
+
+
+class EnhancedWorker(Worker):
+    """
+    Enhanced Worker with protocol-based provider injection.
+
+    Extends base Worker with:
+    - CacheProvider: LLM response caching
+    - RetryProvider: LLM call retry with fallback
+    - MonitorProvider: Performance monitoring
+    - Agent briefing: Personalization memory injection
+    """
+
+    def __init__(
+        self,
+        worker_id: str,
+        role_id: str,
+        role_prompt: str = "",
+        scratchpad=None,
+        llm_backend=None,
+        stream: bool = False,
+        cache_provider=None,
+        retry_provider=None,
+        monitor_provider=None,
+        memory_provider=None,
+    ):
+        """
+        Initialize EnhancedWorker.
+
+        Args:
+            worker_id: Unique worker identifier
+            role_id: Role identifier (e.g., 'architect', 'coder')
+            role_prompt: Custom role prompt
+            scratchpad: Scratchpad instance for inter-agent communication
+            llm_backend: LLM backend instance
+            stream: Whether to enable streaming output
+            cache_provider: CacheProvider implementation (optional)
+            retry_provider: RetryProvider implementation (optional)
+            monitor_provider: MonitorProvider implementation (optional)
+            memory_provider: MemoryProvider implementation (optional, for rule injection)
+        """
+        super().__init__(
+            worker_id=worker_id,
+            role_id=role_id,
+            role_prompt=role_prompt,
+            scratchpad=scratchpad,
+            llm_backend=llm_backend,
+            stream=stream,
+        )
+
+        self.cache_provider = cache_provider
+        self.retry_provider = retry_provider
+        self.monitor_provider = monitor_provider
+        self.memory_provider = memory_provider
+
+        self._briefing = None
+        self._briefing_loaded = False
+        self._last_result: Optional[WorkerResult] = None
+        self._confidence_scorer = None
+        self._injected_rules: List[Dict[str, Any]] = []
+        self._rules_applied: List[str] = []
+        self._validator = None
+
+        try:
+            from .confidence_score import ConfidenceScorer
+            self._confidence_scorer = ConfidenceScorer()
+        except Exception:
+            pass
+
+        try:
+            from .input_validator import InputValidator
+            self._validator = InputValidator()
+        except Exception:
+            pass
+
+    @property
+    def briefing(self):
+        """Get agent briefing (lazy load)."""
+        if not self._briefing_loaded:
+            self._load_briefing()
+            self._briefing_loaded = True
+        return self._briefing
+
+    def _load_briefing(self):
+        """Load agent briefing from memory provider."""
+        try:
+            from .agent_briefing import AgentBriefing
+            self._briefing = AgentBriefing(agent_role=self.role_id)
+        except Exception as e:
+            logger.warning("Failed to load briefing for %s: %s", self.role_id, e)
+            self._briefing = None
+
+    def _do_work_with_briefing(self, task: TaskDefinition) -> WorkerResult:
+        """
+        Execute task with briefing context injection.
+
+        Args:
+            task: Task definition
+
+        Returns:
+            WorkerResult with briefing context
+        """
+        start_time = time.time()
+
+        try:
+            briefing_context = None
+            if self._briefing:
+                try:
+                    briefing_context = self._briefing.get_briefing_context(task.description)
+                except Exception as e:
+                    logger.warning("Failed to get briefing context: %s", e)
+
+            result = self._do_work(task)
+
+            if briefing_context and result.output:
+                if isinstance(result.output, dict):
+                    result.output["briefing_context"] = briefing_context
+                elif isinstance(result.output, str):
+                    result.output = f"{briefing_context}\n\n{result.output}"
+
+            duration = time.time() - start_time
+            self._record_monitor(task, duration, success=True)
+
+            return result
+
+        except Exception as e:
+            duration = time.time() - start_time
+            self._record_monitor(task, duration, success=False)
+            raise
+
+    def _record_monitor(self, task: TaskDefinition, duration: float, success: bool):
+        """Record execution metrics to monitor provider."""
+        if self.monitor_provider and self.monitor_provider.is_available():
+            try:
+                self.monitor_provider.record_agent_execution(
+                    agent_role=self.role_id,
+                    task=task.description[:100],
+                    duration=duration,
+                    success=success,
+                )
+            except Exception as e:
+                logger.warning("Monitor recording failed: %s", e)
+
+    def execute(self, task: TaskDefinition) -> WorkerResult:
+        """
+        Execute task with all enhanced features.
+
+        Args:
+            task: Task definition
+
+        Returns:
+            WorkerResult
+        """
+        self._inject_rules_from_provider(task)
+
+        if self.retry_provider and self.retry_provider.is_available():
+            try:
+                result = self.retry_provider.retry_with_fallback(
+                    func=lambda: self._do_work_with_briefing(task),
+                    max_attempts=3,
+                    fallback=lambda: self._do_work(task),
+                )
+            except Exception:
+                result = self._do_work(task)
+        else:
+            result = self._do_work_with_briefing(task)
+
+        self._last_result = result
+
+        if self._confidence_scorer and result.success and result.output:
+            try:
+                output_text = result.output if isinstance(result.output, str) else str(result.output)
+                score = self._confidence_scorer.score_response(output_text)
+                if isinstance(result.output, dict):
+                    result.output["confidence"] = score.overall_score
+                    result.output["confidence_factors"] = {
+                        "completeness": score.completeness_score,
+                        "certainty": score.certainty_score,
+                        "specificity": score.specificity_score,
+                    }
+                    if score.overall_score < 0.7:
+                        result.output["low_confidence_warning"] = (
+                            f"Low confidence ({score.overall_score:.2f}). "
+                            "Assumptions may need verification by subsequent agents."
+                        )
+            except Exception as e:
+                logger.warning("Confidence scoring failed: %s", e)
+
+        if self._injected_rules and result.success and result.output:
+            violations = self._check_forbid_violations(result)
+            if violations:
+                if isinstance(result.output, dict):
+                    result.output["rule_violations"] = violations
+
+        return result
+
+    def _inject_rules_from_provider(self, task: TaskDefinition):
+        """Fetch and validate rules from MemoryProvider before task execution."""
+        if not self.memory_provider or not _is_available(self.memory_provider):
+            return
+
+        try:
+            if hasattr(self.memory_provider, 'match_rules'):
+                raw_rules = self.memory_provider.match_rules(
+                    task_description=task.description,
+                    user_id=getattr(task, 'user_id', None) or "default",
+                    role=self.role_id,
+                    max_rules=5
+                )
+            else:
+                rule_strings = self.memory_provider.get_rules(
+                    user_id=getattr(task, 'user_id', None) or "default",
+                    context={"task": task.description, "role": self.role_id}
+                )
+                raw_rules = []
+                for rs in rule_strings:
+                    if isinstance(rs, str):
+                        raw_rules.append({
+                            "rule_type": "always",
+                            "trigger": rs.lower(),
+                            "action": rs,
+                            "relevance_score": 0.0,
+                            "rule_id": "",
+                            "override": False,
+                        })
+
+            safe_rules = self._validate_injected_rules(raw_rules)
+            self._injected_rules = safe_rules
+            self._rules_applied = [r.get("rule_id", r.get("action", "")[:50]) for r in safe_rules]
+        except Exception as e:
+            logger.warning("Rule injection from provider failed: %s", e)
+            self._injected_rules = []
+
+    def _validate_injected_rules(self, rules: List[Dict]) -> List[Dict]:
+        """Sanitize rules before prompt injection to prevent prompt injection attacks.
+
+        Two-layer defense:
+        1. InputValidator check on rule text + Unicode NFKC normalization + length limit
+        2. Length check in format_rules_as_prompt() (handled by MCEAdapter)
+
+        Args:
+            rules: List of rule dicts from match_rules()
+
+        Returns:
+            List of validated rule dicts (suspicious rules silently skipped)
+        """
+        safe_rules = []
+        for rule in rules:
+            if not isinstance(rule, dict):
+                continue
+
+            action = rule.get("action", "")
+            trigger = rule.get("trigger", "")
+
+            if isinstance(action, str):
+                action = unicodedata.normalize('NFKC', action)
+                rule["action"] = action
+            if isinstance(trigger, str):
+                trigger = unicodedata.normalize('NFKC', trigger)
+                rule["trigger"] = trigger
+
+            if len(action) > _MAX_RULE_TEXT_LENGTH:
+                rule["action"] = action[:_MAX_RULE_TEXT_LENGTH]
+            if len(trigger) > _MAX_RULE_TEXT_LENGTH:
+                rule["trigger"] = trigger[:_MAX_RULE_TEXT_LENGTH]
+
+            if self._validator:
+                try:
+                    action_valid = self._validator.validate_task(action).valid
+                    trigger_valid = self._validator.validate_task(trigger).valid if trigger else True
+                    if not action_valid or not trigger_valid:
+                        logger.warning("Skipping suspicious rule: action_valid=%s, trigger_valid=%s",
+                                       action_valid, trigger_valid)
+                        continue
+                except Exception:
+                    pass
+
+            safe_rules.append(rule)
+
+        return safe_rules
+
+    def _check_forbid_violations(self, result: WorkerResult) -> List[Dict[str, str]]:
+        """
+        Post-processing check: verify forbid rules were not violated in output.
+
+        Short-term: annotate violations as warnings (no auto-retry).
+        Mid-term: auto-retry with enhanced prompt on forbid violation.
+
+        Args:
+            result: Worker execution result
+
+        Returns:
+            List of violation dicts with rule_id and description
+        """
+        violations = []
+        forbid_rules = [r for r in self._injected_rules
+                        if isinstance(r, dict) and r.get("rule_type") == "forbid"]
+
+        if not forbid_rules or not result.output:
+            return violations
+
+        output_text = result.output if isinstance(result.output, str) else str(result.output)
+        output_lower = output_text.lower()
+
+        for rule in forbid_rules:
+            trigger = rule.get("trigger", "").lower()
+            action = rule.get("action", "").lower()
+            rule_id = rule.get("rule_id", "unknown")
+
+            if trigger and trigger in output_lower:
+                violations.append({
+                    "rule_id": rule_id,
+                    "trigger": trigger,
+                    "action": action,
+                    "severity": "high" if rule.get("override") else "medium",
+                    "message": f"Output may violate forbid rule '{rule_id}': "
+                               f"trigger '{trigger}' found in output",
+                })
+
+        return violations
+
+    def get_briefing_summary(self) -> Dict[str, Any]:
+        """
+        Get agent briefing summary.
+
+        Returns:
+            Briefing summary dictionary
+        """
+        if not self._briefing:
+            return {"status": "unavailable", "role": self.role_id}
+
+        try:
+            return {
+                "status": "available",
+                "role": self.role_id,
+                "rules_count": len(self._briefing.get_rules()),
+            }
+        except Exception:
+            return {"status": "error", "role": self.role_id}
+
+    def export_briefing(self, output_dir: str = "output/briefings") -> Optional[str]:
+        """
+        Export agent briefing to file.
+
+        Args:
+            output_dir: Output directory path
+
+        Returns:
+            File path if successful, None otherwise
+        """
+        if not self._briefing:
+            return None
+
+        try:
+            import os
+            os.makedirs(output_dir, exist_ok=True)
+
+            safe_role = _SAFE_FILENAME_RE.sub('_', self.role_id)
+            output_path = os.path.join(output_dir, f"{safe_role}_briefing.json")
+
+            return self._briefing.export_briefing(output_path)
+        except Exception as e:
+            logger.warning("Failed to export briefing for %s: %s", self.role_id, e)
+            return None
+
+    def compress_to_briefing(self) -> AgentBriefingOutput:
+        """
+        Compress current execution result into a briefing for the next Agent.
+
+        Implements the latent-briefing pattern: instead of passing full message
+        history between Agents, pass a compressed state with key decisions,
+        pending items, and applied rules.
+
+        Returns:
+            AgentBriefingOutput: Compressed state for inter-Agent handoff
+        """
+        if not self._last_result:
+            return AgentBriefingOutput()
+
+        output_text = ""
+        if isinstance(self._last_result.output, dict):
+            output_text = self._last_result.output.get("finding_summary", "")
+        elif isinstance(self._last_result.output, str):
+            output_text = self._last_result.output[:500]
+
+        confidence = 0.0
+        if self._confidence_scorer and output_text:
+            try:
+                score = self._confidence_scorer.score_response(output_text)
+                confidence = score.overall_score
+            except Exception:
+                confidence = 0.5
+
+        return AgentBriefingOutput(
+            task_summary=self._last_result.task_id if hasattr(self._last_result, 'task_id') else "",
+            key_decisions=self._extract_decisions(output_text),
+            pending_items=self._extract_pending(output_text),
+            rules_applied=list(self._rules_applied),
+            result_summary=output_text[:200] if output_text else "",
+            confidence=confidence,
+            assumptions=[],
+        )
+
+    def receive_briefing(self, briefing: AgentBriefingOutput):
+        """
+        Receive compressed state from a preceding Agent.
+
+        Args:
+            briefing: Compressed state from the previous Agent
+        """
+        self._received_briefing = briefing
+
+    def _extract_decisions(self, text: str) -> List[str]:
+        """Extract key decisions from output text."""
+        decisions = []
+        markers = ["decision:", "decided:", "chosen:", "selected:", "conclusion:"]
+        for line in text.split('\n'):
+            lower = line.strip().lower()
+            for marker in markers:
+                if marker in lower:
+                    decisions.append(line.strip()[:100])
+                    break
+            if len(decisions) >= 5:
+                break
+        return decisions
+
+    def _extract_pending(self, text: str) -> List[str]:
+        """Extract pending items from output text."""
+        pending = []
+        markers = ["todo:", "pending:", "next:", "follow-up:", "remaining:"]
+        for line in text.split('\n'):
+            lower = line.strip().lower()
+            for marker in markers:
+                if marker in lower:
+                    pending.append(line.strip()[:100])
+                    break
+            if len(pending) >= 5:
+                break
+        return pending
+
+    def get_provider_status(self) -> Dict[str, Any]:
+        """
+        Get status of all injected providers.
+
+        Returns:
+            Provider status dictionary
+        """
+        return {
+            "worker_id": self.worker_id,
+            "role_id": self.role_id,
+            "cache": {
+                "available": _is_available(self.cache_provider),
+                "type": type(self.cache_provider).__name__ if self.cache_provider else "none",
+            },
+            "retry": {
+                "available": _is_available(self.retry_provider),
+                "type": type(self.retry_provider).__name__ if self.retry_provider else "none",
+            },
+            "monitor": {
+                "available": _is_available(self.monitor_provider),
+                "type": type(self.monitor_provider).__name__ if self.monitor_provider else "none",
+            },
+            "memory": {
+                "available": _is_available(self.memory_provider),
+                "type": type(self.memory_provider).__name__ if self.memory_provider else "none",
+                "rules_injected": len(self._injected_rules),
+            },
+            "briefing": {
+                "available": self._briefing is not None,
+            },
+        }
+
+
+__all__ = ["EnhancedWorker", "AgentBriefingOutput"]