devsquad 3.6.0__py3-none-any.whl

scripts/collaboration/ci_feedback_adapter.py

@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+CI Feedback Adapter (P1-5)
+
+Reads CI results and injects context into dispatch pipeline:
+  - Parse CI output (pytest, Jest, coverage, lint, build)
+  - Extract key metrics: pass/fail, coverage %, errors
+  - Generate structured context for Worker prompts
+  - Provide actionable feedback for failed checks
+
+Spec reference: SPEC_V35_Agent_Skills_Quality_Framework.md Section 7.5
+"""
+
+import json
+import logging
+import re
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CIMetric:
+    """A single CI metric with value and status."""
+    name: str
+    value: Any
+    status: str  # "pass", "fail", "warning", "skip"
+    details: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "value": self.value,
+            "status": self.status,
+            "details": self.details,
+        }
+
+
+@dataclass
+class CIResult:
+    """Complete CI run result."""
+    source: str  # e.g., "pytest", "jest", "coverage", "lint"
+    timestamp: str = field(default_factory=lambda: datetime.now().isoformat())
+    metrics: List[CIMetric] = field(default_factory=list)
+    raw_output: str = ""
+    success: bool = False
+    duration_seconds: float = 0.0
+
+    def get_metric(self, name: str) -> Optional[CIMetric]:
+        for m in self.metrics:
+            if m.name == name:
+                return m
+        return None
+
+    def has_failures(self) -> bool:
+        return any(m.status == "fail" for m in self.metrics)
+
+    def to_summary(self) -> str:
+        lines = [f"CI Result ({self.source}): {'✅ PASS' if self.success else '❌ FAIL'}"]
+        for m in self.metrics:
+            icon = {"pass": "✅", "fail": "❌", "warning": "⚠️", "skip": "⏭️"}.get(m.status, "?")
+            lines.append(f"  {icon} {m.name}: {m.value}")
+        if self.duration_seconds > 0:
+            lines.append(f"  ⏱ Duration: {self.duration_seconds:.1f}s")
+        return "\n".join(lines)
+
+
+@dataclass
+class CIContext:
+    """Structured context extracted from CI results for injection into dispatch."""
+    overall_status: str  # "all_pass", "has_failures", "no_ci_data"
+    summary: str = ""
+    actionable_items: List[Dict[str, Any]] = field(default_factory=list)
+    quality_gates: Dict[str, bool] = field(default_factory=dict)
+    recommendations: List[str] = field(default_factory=list)
+
+    def to_prompt_injection(self) -> str:
+        """Generate prompt-ready context string."""
+        lines = [
+            "\n## CI/CD Feedback Context\n",
+            f"**Overall Status**: {self.overall_status.upper()}",
+            "",
+        ]
+
+        if self.summary:
+            lines.append(f"{self.summary}")
+            lines.append("")
+
+        if self.quality_gates:
+            lines.append("**Quality Gates**:")
+            for gate_name, passed in self.quality_gates.items():
+                icon = "✅" if passed else "❌"
+                lines.append(f"- {icon} {gate_name}: {'PASS' if passed else 'FAIL'}")
+            lines.append("")
+
+        if self.actionable_items:
+            lines.append("**Action Items**:")
+            for item in self.actionable_items[:10]:  # Limit to top 10
+                severity = item.get("severity", "info").upper()
+                lines.append(f"- [{severity}] {item.get('message', '')}")
+            lines.append("")
+
+        if self.recommendations:
+            lines.append("**Recommendations**:")
+            for rec in self.recommendations[:5]:  # Limit to top 5
+                lines.append(f"- {rec}")
+
+        return "\n".join(lines)
+
+
+class PytestParser:
+    """Parser for pytest-style test output."""
+
+    @staticmethod
+    def parse(output: str) -> CIResult:
+        result = CIResult(source="pytest", raw_output=output)
+
+        total_match = re.search(r'(\d+) passed', output)
+        fail_match = re.search(r'(\d+) failed', output)
+        error_match = re.search(r'(\d+) error', output)
+        skip_match = re.search(r'(\d+) skipped', output)
+
+        passed = int(total_match.group(1)) if total_match else 0
+        failed = int(fail_match.group(1)) if fail_match else 0
+        errors = int(error_match.group(1)) if error_match else 0
+        skipped = int(skip_match.group(1)) if skip_match else 0
+
+        result.metrics.append(CIMetric("tests_passed", passed, "pass"))
+        result.metrics.append(CIMetric("tests_failed", failed, "fail" if failed > 0 else "pass"))
+        result.metrics.append(CIMetric("errors", errors, "fail" if errors > 0 else "pass"))
+        result.metrics.append(CIMetric("skipped", skipped, "skip"))
+
+        duration_match = re.search(r'in ([\d.]+)s', output)
+        if duration_match:
+            result.duration_seconds = float(duration_match.group(1))
+
+        result.success = (failed == 0 and errors == 0)
+        return result
+
+
+class CoverageParser:
+    """Parser for coverage report output."""
+
+    @staticmethod
+    def parse(output: str) -> CIResult:
+        result = CIResult(source="coverage", raw_output=output)
+
+        pct_match = re.search(r'TOTAL\s+[\d\s]+\s+(\d+)%', output)
+        if pct_match:
+            pct = int(pct_match.group(1))
+            result.metrics.append(
+                CIMetric(
+                    "coverage_percentage",
+                    f"{pct}%",
+                    "pass" if pct >= 80 else ("warning" if pct >= 60 else "fail"),
+                    f"Target: ≥80%, Actual: {pct}%",
+                )
+            )
+
+        line_match = re.search(r'(\d+)\s+missed', output)
+        if line_match:
+            missed = int(line_match.group(1))
+            result.metrics.append(
+                CIMetric("lines_missed", missed, "warning" if missed > 10 else "pass")
+            )
+
+        result.success = not result.has_failures()
+        return result
+
+
+class LintParser:
+    """Parser for linter output (flake8, eslint, etc.)."""
+
+    @staticmethod
+    def parse(output: str) -> CIResult:
+        result = CIResult(source="lint", raw_output=output)
+
+        error_count = len(re.findall(r'^[EF]\d+', output, re.MULTILINE))
+        warning_count = len(re.findall(r'^W\d+', output, re.MULTILINE))
+
+        result.metrics.append(
+            CIMetric("errors", error_count, "fail" if error_count > 0 else "pass")
+        )
+        result.metrics.append(
+            CIMetric("warnings", warning_count, "warning" if warning_count > 0 else "pass")
+        )
+
+        result.success = (error_count == 0)
+        return result
+
+
+class BuildParser:
+    """Parser for build system output."""
+
+    @staticmethod
+    def parse(output: str) -> CIResult:
+        result = CIResult(source="build", raw_output=output)
+
+        success_indicators = ['Build succeeded', 'BUILD SUCCESSFUL', 'Build OK']
+        fail_indicators = ['Build failed', 'BUILD FAILED', 'Error:', 'error:']
+
+        has_success = any(ind in output for ind in success_indicators)
+        has_failure = any(ind in output for ind in fail_indicators)
+
+        result.success = has_success and not has_failure
+        result.metrics.append(
+            CIMetric("build_status", "success" if result.success else "failed",
+                     "pass" if result.success else "fail")
+        )
+
+        return result
+
+
+class CIFeedbackAdapter:
+    """
+    Main adapter that reads CI results and generates dispatch context.
+
+    Usage:
+        adapter = CIFeedbackAdapter()
+
+        ci_result = adapter.parse_ci_output(pytest_output, "pytest")
+        context = adapter.generate_context([ci_result])
+        injection = context.to_prompt_injection()
+    """
+
+    PARSERS = {
+        "pytest": PytestParser,
+        "coverage": CoverageParser,
+        "lint": LintParser,
+        "build": BuildParser,
+    }
+
+    QUALITY_GATE_THRESHOLDS = {
+        "test_pass_rate": 100.0,  # All tests must pass
+        "min_coverage": 80.0,     # Minimum coverage percentage
+        "zero_lint_errors": True,  # No lint errors allowed
+        "build_success": True,    # Build must succeed
+    }
+
+    def __init__(self, strict_mode: bool = False):
+        self._strict_mode = strict_mode
+
+    def parse_ci_output(self, output: str, source_type: str) -> Optional[CIResult]:
+        """
+        Parse CI output based on source type.
+
+        Args:
+            output: Raw CI output text
+            source_type: One of "pytest", "coverage", "lint", "build"
+
+        Returns:
+            Parsed CIResult or None if parsing fails
+        """
+        parser_cls = self.PARSERS.get(source_type.lower())
+        if parser_cls is None:
+            logger.warning("Unknown CI source type: %s", source_type)
+            return None
+
+        try:
+            return parser_cls.parse(output)
+        except Exception as e:
+            logger.error("Failed to parse %s output: %s", source_type, e)
+            return None
+
+    def generate_context(self, results: List[CIResult]) -> CIContext:
+        """
+        Generate structured context from multiple CI results.
+
+        Args:
+            results: List of CIResult objects from different sources
+
+        Returns:
+            CIContext ready for prompt injection
+        """
+        if not results:
+            return CIContext(
+                overall_status="no_ci_data",
+                summary="No CI data available. Run tests before proceeding.",
+            )
+
+        all_pass = all(r.success for r in results)
+        any_fail = any(r.has_failures() for r in results)
+
+        context = CIContext(
+            overall_status="all_pass" if all_pass else "has_failures",
+            summary=self._build_summary(results),
+        )
+
+        context.quality_gates["all_tests_pass"] = all(
+            not r.has_failures() for r in results if r.source == "pytest"
+        ) or not any(r.source == "pytest" for r in results)
+        context.quality_gates["build_succeeds"] = all(
+            r.success for r in results if r.source == "build"
+        ) or not any(r.source == "build" for r in results)
+        context.quality_gates["no_critical_errors"] = not any_fail
+
+        context.actionable_items = self._extract_action_items(results)
+        context.recommendations = self._generate_recommendations(results)
+
+        return context
+
+    def _build_summary(self, results: List[CIResult]) -> str:
+        summaries = [r.to_summary() for r in results]
+        return "\n".join(summaries)
+
+    def _extract_action_items(self, results: List[CIResult]) -> List[Dict[str, Any]]:
+        items = []
+        for r in results:
+            for m in r.metrics:
+                if m.status == "fail":
+                    items.append({
+                        "severity": "critical",
+                        "source": r.source,
+                        "metric": m.name,
+                        "message": f"{m.name} failed: {m.details or m.value}",
+                    })
+                elif m.status == "warning":
+                    items.append({
+                        "severity": "warning",
+                        "source": r.source,
+                        "metric": m.name,
+                        "message": f"{m.name} warning: {m.details or m.value}",
+                    })
+        return sorted(items, key=lambda x: {"critical": 0, "warning": 1}.get(x["severity"], 2))
+
+    def _generate_recommendations(self, results: List[CIResult]) -> List[str]:
+        recs = []
+        for r in results:
+            if r.has_failures():
+                recs.append(f"Fix failing tests/checks in {r.source} before proceeding")
+            if r.source == "coverage":
+                cov = r.get_metric("coverage_percentage")
+                if cov and cov.status != "pass":
+                    recs.append(f"Increase code coverage (current: {cov.value})")
+
+        if not recs:
+            recs.append("All CI checks passed. Safe to proceed.")
+        return recs
+
+
+def create_default_adapter() -> CIFeedbackAdapter:
+    """Create adapter with default settings."""
+    return CIFeedbackAdapter()
+
+
+def create_strict_adapter() -> CIFeedbackAdapter:
+    """Create adapter in strict mode."""
+    return CIFeedbackAdapter(strict_mode=True)

scripts/collaboration/code_map_generator.py

@@ -0,0 +1,247 @@
+#!/usr/bin/env python3
+import os
+import json
+import ast
+import logging
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass, field
+from collections import defaultdict
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CodeNode:
+    name: str
+    node_type: str
+    file_path: str = ""
+    line_start: int = 0
+    line_end: int = 0
+    docstring: str = ""
+    children: List['CodeNode'] = field(default_factory=list)
+    imports: List[str] = field(default_factory=list)
+    calls: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'name': self.name, 'type': self.node_type, 'file': self.file_path,
+            'lines': f"{self.line_start}-{self.line_end}",
+            'docstring': self.docstring[:100] if self.docstring else "",
+            'children': [c.to_dict() for c in self.children],
+            'imports': self.imports[:5], 'calls': self.calls[:5],
+        }
+
+
+class CodeMapGenerator:
+    """
+    Code map generator for multi-language projects.
+
+    Scans source files and generates a structured map of:
+    - Modules, classes, functions
+    - Import dependencies
+    - Call relationships
+    - Documentation strings
+
+    Supports Python (AST), JavaScript/TypeScript (regex), Go (regex).
+    """
+
+    MAX_FILE_SIZE = 1 * 1024 * 1024
+
+    def __init__(self, project_root: str = ".", parsers: Optional[List[Any]] = None):
+        self.project_root = Path(project_root)
+        self._parsers: List[Any] = parsers
+        self._default_parser = _PythonCompatParser()
+
+    def register_parser(self, parser: Any) -> None:
+        if self._parsers is None:
+            self._parsers = []
+        self._parsers.append(parser)
+
+    def generate_map(
+        self,
+        target_dir: str = None,
+        output_format: str = "dict",
+        languages: Optional[List[str]] = None,
+    ) -> Any:
+        """
+        Generate a code map for the target directory.
+
+        Args:
+            target_dir: Directory to scan (relative to project_root)
+            output_format: "dict", "markdown", or "json"
+            languages: Optional filter by language (e.g., ["python", "javascript"])
+
+        Returns:
+            Code map in the specified format
+        """
+        scan_dir = self.project_root / (target_dir or "")
+        if not scan_dir.exists():
+            logger.warning("Target directory does not exist: %s", scan_dir)
+            return {} if output_format != "markdown" else ""
+
+        modules = {}
+
+        if self._parsers:
+            for parser in self._parsers:
+                lang = self._detect_language(parser)
+                if languages and lang not in languages:
+                    continue
+                for pattern in parser.file_patterns():
+                    for file_path in sorted(scan_dir.rglob(pattern)):
+                        if any(p in str(file_path) for p in parser.exclude_patterns()):
+                            continue
+                        if file_path.stat().st_size > self.MAX_FILE_SIZE:
+                            continue
+                        try:
+                            source = file_path.read_text(encoding='utf-8')
+                        except UnicodeDecodeError:
+                            continue
+                        rel_path = str(file_path.relative_to(self.project_root))
+                        file_map = parser.parse_file(source, str(file_path))
+                        if file_map:
+                            modules[rel_path] = file_map
+        else:
+            for py_file in sorted(scan_dir.rglob("*.py")):
+                if any(p in str(py_file) for p in ["__pycache__", "test_", "_test.py", ".venv"]):
+                    continue
+                rel_path = py_file.relative_to(self.project_root)
+                module_map = self._default_parser.scan_file(py_file)
+                if module_map:
+                    modules[str(rel_path)] = module_map
+
+        if output_format == "markdown":
+            return self._to_markdown(modules)
+        elif output_format == "json":
+            return json.dumps(modules, indent=2, ensure_ascii=False)
+        return modules
+
+    def _detect_language(self, parser: Any) -> str:
+        patterns = parser.file_patterns()
+        if not patterns:
+            return "unknown"
+        ext = patterns[0].lstrip("*")
+        lang_map = {".py": "python", ".js": "javascript", ".jsx": "javascript",
+                    ".ts": "javascript", ".tsx": "javascript", ".go": "go"}
+        return lang_map.get(ext, ext.lstrip("."))
+
+    def _to_markdown(self, modules: Dict[str, Any]) -> str:
+        lines = ["# Code Map", ""]
+        for file_path, info in modules.items():
+            lang = info.get("language", "python")
+            lines.append(f"## {file_path} `{lang}`")
+            lines.append(f"- Classes: {info.get('total_classes', 0)} | Functions: {info.get('total_functions', 0)}")
+            if info.get('imports'):
+                lines.append(f"- Imports: {', '.join(info['imports'][:10])}")
+            for node in info.get('nodes', []):
+                ntype = node.get('type', 'function')
+                icon = {"class": "📦", "struct": "🏗️", "interface": "🔌"}.get(ntype, "⚡")
+                lines.append(f"  - {icon} **{node['name']}** ({ntype})")
+                if node.get('docstring'):
+                    lines.append(f"    > {node['docstring']}")
+                for child in node.get('children', []):
+                    lines.append(f"    - ⚡ `{child['name']}`")
+            lines.append("")
+        return "\n".join(lines)
+
+    def get_dependency_graph(self, target_dir: str = None) -> Dict[str, List[str]]:
+        scan_dir = self.project_root / (target_dir or "")
+        graph = {}
+
+        if self._parsers:
+            for parser in self._parsers:
+                for pattern in parser.file_patterns():
+                    for file_path in sorted(scan_dir.rglob(pattern)):
+                        if any(p in str(file_path) for p in parser.exclude_patterns()):
+                            continue
+                        try:
+                            source = file_path.read_text(encoding='utf-8')
+                        except UnicodeDecodeError:
+                            continue
+                        rel_path = str(file_path.relative_to(self.project_root))
+                        deps = parser.extract_dependencies(source)
+                        if deps:
+                            graph[rel_path] = deps
+        else:
+            for py_file in sorted(scan_dir.rglob("*.py")):
+                if "__pycache__" in str(py_file):
+                    continue
+                try:
+                    source = py_file.read_text(encoding='utf-8')
+                    tree = ast.parse(source)
+                except (SyntaxError, UnicodeDecodeError):
+                    continue
+                rel_path = str(py_file.relative_to(self.project_root))
+                deps = set()
+                for node in ast.walk(tree):
+                    if isinstance(node, ast.ImportFrom) and node.module:
+                        deps.add(node.module)
+                    elif isinstance(node, ast.Import):
+                        for alias in node.names:
+                            deps.add(alias.name)
+                graph[rel_path] = sorted(deps)
+        return graph
+
+
+class _PythonCompatParser:
+    """Internal Python parser maintaining backward compatibility with original CodeMapGenerator."""
+
+    def scan_file(self, file_path: Path) -> Optional[Dict[str, Any]]:
+        try:
+            if file_path.stat().st_size > CodeMapGenerator.MAX_FILE_SIZE:
+                return None
+            source = file_path.read_text(encoding='utf-8')
+            tree = ast.parse(source)
+        except (SyntaxError, UnicodeDecodeError):
+            return None
+
+        file_imports = []
+        top_level = []
+
+        for node in ast.iter_child_nodes(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    file_imports.append(alias.name)
+            elif isinstance(node, ast.ImportFrom):
+                module = node.module or ""
+                file_imports.append(module)
+
+            if isinstance(node, ast.ClassDef):
+                top_level.append(self._parse_class(node, str(file_path)))
+            elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                top_level.append(self._parse_function(node, str(file_path)))
+
+        return {
+            'file': str(file_path.name),
+            'imports': file_imports[:20],
+            'nodes': [n.to_dict() for n in top_level],
+            'total_classes': sum(1 for n in top_level if n.node_type == 'class'),
+            'total_functions': sum(1 for n in top_level if n.node_type == 'function'),
+        }
+
+    def _parse_class(self, node: ast.ClassDef, file_path: str) -> CodeNode:
+        docstring = ast.get_docstring(node) or ""
+        methods = []
+        for item in node.body:
+            if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                methods.append(self._parse_function(item, file_path))
+        return CodeNode(
+            name=node.name, node_type="class", file_path=file_path,
+            line_start=node.lineno, line_end=node.end_lineno or node.lineno,
+            docstring=docstring, children=methods,
+        )
+
+    def _parse_function(self, node, file_path: str) -> CodeNode:
+        docstring = ast.get_docstring(node) or ""
+        calls = []
+        for child in ast.walk(node):
+            if isinstance(child, ast.Call):
+                if isinstance(child.func, ast.Name):
+                    calls.append(child.func.id)
+                elif isinstance(child.func, ast.Attribute):
+                    calls.append(child.func.attr)
+        return CodeNode(
+            name=node.name, node_type="function", file_path=file_path,
+            line_start=node.lineno, line_end=node.end_lineno or node.lineno,
+            docstring=docstring, calls=list(set(calls))[:10],
+        )