compos-cli 0.0.0__py3-none-any.whl

compos/cli/analyzers/__init__.py

@@ -0,0 +1,10 @@
+"""Analyzers package — pluggable static analysis detectors."""
+
+from compos.cli.analyzers.base import (
+    AnalysisResult,
+    Analyzer,
+    discover_analyzers,
+    merge_results,
+)
+
+__all__ = ["Analyzer", "AnalysisResult", "discover_analyzers", "merge_results"]

compos/cli/analyzers/base.py

@@ -0,0 +1,66 @@
+"""Analyzer Protocol + registry (entry-point extensible)."""
+
+from __future__ import annotations
+
+import importlib.metadata
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+if TYPE_CHECKING:
+    from compos.schema.models import Component, Relationship
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True, slots=True)
+class AnalysisResult:
+    """Output from a single analyzer run."""
+
+    components: tuple[Component, ...]
+    relationships: tuple[Relationship, ...]
+    warnings: tuple[str, ...]
+
+
+@runtime_checkable
+class Analyzer(Protocol):
+    """Interface every analyzer must satisfy."""
+
+    name: str
+
+    def can_analyze(self, project_root: Path) -> bool: ...
+    def analyze(self, project_root: Path) -> AnalysisResult: ...
+
+
+def merge_results(*results: AnalysisResult) -> AnalysisResult:
+    """Combine outputs from multiple analyzers."""
+    return AnalysisResult(
+        components=tuple(c for r in results for c in r.components),
+        relationships=tuple(r2 for r in results for r2 in r.relationships),
+        warnings=tuple(w for r in results for w in r.warnings),
+    )
+
+
+def discover_analyzers() -> list[Analyzer]:
+    """Load analyzers from the ``compos.analyzers`` entry-point group."""
+    eps = importlib.metadata.entry_points(group="compos.analyzers")
+    analyzers: list[Analyzer] = []
+    for ep in eps:
+        try:
+            cls = ep.load()
+            instance = cls()
+            if isinstance(instance, Analyzer):
+                analyzers.append(instance)
+            else:
+                logger.warning(
+                    "Entry point %s does not satisfy Analyzer protocol",
+                    ep.name,
+                )
+        except Exception:
+            logger.warning(
+                "Failed to load analyzer entry point: %s",
+                ep.name,
+                exc_info=True,
+            )
+    return analyzers

compos/cli/analyzers/docker_compose.py

@@ -0,0 +1,137 @@
+"""Docker Compose service and dependency detection."""
+
+from __future__ import annotations
+
+import logging
+from datetime import UTC, datetime
+from pathlib import Path
+
+import yaml
+
+from compos.cli.analyzers.base import AnalysisResult
+from compos.schema.models import (
+    Component,
+    ComponentType,
+    ObjectStatus,
+    Provenance,
+    ProvenanceSource,
+    Relationship,
+    RelationshipPattern,
+    RelationshipType,
+)
+
+logger = logging.getLogger(__name__)
+
+_COMPOSE_FILENAMES = (
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "compose.yml",
+    "compose.yaml",
+)
+
+_IMAGE_TYPE_MAP: dict[str, ComponentType] = {
+    "postgres": ComponentType.DATABASE,
+    "mysql": ComponentType.DATABASE,
+    "mariadb": ComponentType.DATABASE,
+    "mongo": ComponentType.DATABASE,
+    "redis": ComponentType.DATABASE,
+    "rabbitmq": ComponentType.QUEUE,
+    "kafka": ComponentType.QUEUE,
+    "zookeeper": ComponentType.OTHER,
+    "nginx": ComponentType.OTHER,
+    "traefik": ComponentType.OTHER,
+    "elasticsearch": ComponentType.DATABASE,
+    "memcached": ComponentType.DATABASE,
+}
+
+
+def _make_provenance() -> Provenance:
+    return Provenance(
+        source=ProvenanceSource.STATIC_ANALYSIS,
+        tool="cli-analyze",
+        timestamp=datetime.now(UTC),
+    )
+
+
+def _type_from_image(image: str) -> ComponentType:
+    base = image.split(":")[0].split("/")[-1]
+    for key, comp_type in _IMAGE_TYPE_MAP.items():
+        if key in base:
+            return comp_type
+    return ComponentType.SERVICE
+
+
+class DockerComposeAnalyzer:
+    name = "docker-compose"
+
+    def can_analyze(self, project_root: Path) -> bool:
+        return any((project_root / n).is_file() for n in _COMPOSE_FILENAMES)
+
+    def analyze(self, project_root: Path) -> AnalysisResult:
+        compose_file = next(
+            (
+                project_root / n
+                for n in _COMPOSE_FILENAMES
+                if (project_root / n).is_file()
+            ),
+            None,
+        )
+        if compose_file is None:
+            return AnalysisResult((), (), ())
+
+        try:
+            data = yaml.safe_load(compose_file.read_text())
+        except yaml.YAMLError as exc:
+            return AnalysisResult((), (), (f"Failed to parse {compose_file}: {exc}",))
+
+        services = (data or {}).get("services") or {}
+        if not isinstance(services, dict):
+            msg = f"Unexpected 'services' format in {compose_file}"
+            return AnalysisResult((), (), (msg,))
+
+        components: list[Component] = []
+        relationships: list[Relationship] = []
+        prov = _make_provenance()
+
+        for svc_name, svc_config in services.items():
+            if not isinstance(svc_config, dict):
+                continue
+            image = svc_config.get("image", "")
+            comp_type = _type_from_image(image) if image else ComponentType.SERVICE
+
+            components.append(
+                Component(
+                    id=f"dc-{svc_name}",
+                    name=svc_name,
+                    responsibility=f"Docker Compose service: {svc_name}",
+                    type=comp_type,
+                    detection_confidence=0.95,
+                    status=ObjectStatus.CANDIDATE,
+                    provenance=prov,
+                    paths=(str(compose_file.relative_to(project_root)),),
+                )
+            )
+
+            depends_on = svc_config.get("depends_on", [])
+            if isinstance(depends_on, dict):
+                depends_on = list(depends_on.keys())
+            for dep in depends_on:
+                relationships.append(
+                    Relationship(
+                        id=f"rel-dc-{svc_name}-dc-{dep}",
+                        source=f"dc-{svc_name}",
+                        target=f"dc-{dep}",
+                        type=RelationshipType.DEPENDENCY,
+                        pattern=RelationshipPattern.SYNCHRONOUS,
+                        description=f"Docker Compose depends_on: {svc_name} → {dep}",
+                        status=ObjectStatus.CANDIDATE,
+                        provenance=prov,
+                        detection_confidence=0.90,
+                    )
+                )
+
+        return AnalysisResult(
+            components=tuple(components),
+            relationships=tuple(relationships),
+            warnings=(),
+        )