gdmcode 0.1.0__py3-none-any.whl

src/agent/impact_analyzer.py

@@ -0,0 +1,149 @@
+"""Pre-edit impact gate: score risk before applying file edits."""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+
+__all__ = ["ImpactAnalyzer", "ImpactGateError", "ImpactGateResult"]
+
+log = logging.getLogger(__name__)
+
+
+class ImpactGateError(Exception):
+    """Raised when a high-risk edit is blocked (enforce=True)."""
+
+    def __init__(self, message: str, result: "ImpactGateResult | None" = None) -> None:
+        super().__init__(message)
+        self.result = result
+
+
+@dataclass
+class ImpactGateResult:
+    allowed: bool
+    risk_score: float          # 0.0 (safe) - 1.0 (critical)
+    callers_count: int
+    is_public_api: bool
+    semver_recommendation: str  # "patch" | "minor" | "major"
+    reason: str                 # human-readable explanation
+
+
+class ImpactAnalyzer:
+    """Scores the risk of editing a file and optionally blocks high-risk edits."""
+
+    # Risk thresholds
+    WARN_THRESHOLD = 0.5    # log warning
+    BLOCK_THRESHOLD = 0.85  # block edit (when enforce=True)
+
+    def __init__(self, project_root: str | Path = ".", enforce: bool = False) -> None:
+        self._root = Path(project_root)
+        self._enforce = enforce   # if True, raise on high-risk; if False, warn only
+
+    def gate(self, file_path: str, change_description: str = "") -> ImpactGateResult:
+        """Score impact for file_path. Raise ImpactGateError if blocked."""
+        callers_count, is_public = self._get_impact_report(file_path, change_description)
+        risk_score = self._compute_risk(callers_count, is_public, file_path)
+        allowed = risk_score < self.BLOCK_THRESHOLD
+        semver = self._semver(callers_count, is_public)
+
+        if not allowed:
+            reason = (
+                f"Blocked: high-risk edit to '{file_path}' "
+                f"(score={risk_score:.2f}, callers={callers_count}, "
+                f"public_api={is_public})"
+            )
+        elif risk_score >= self.WARN_THRESHOLD:
+            reason = (
+                f"Warning: moderate risk for '{file_path}' "
+                f"(score={risk_score:.2f}, callers={callers_count})"
+            )
+            log.warning(reason)
+        else:
+            reason = f"Allowed: low-risk edit to '{file_path}' (score={risk_score:.2f})"
+
+        result = ImpactGateResult(
+            allowed=allowed,
+            risk_score=risk_score,
+            callers_count=callers_count,
+            is_public_api=is_public,
+            semver_recommendation=semver,
+            reason=reason,
+        )
+
+        if not allowed and self._enforce:
+            raise ImpactGateError(reason, result)
+
+        return result
+
+    def _compute_risk(self, callers: int, is_public: bool, path: str) -> float:
+        """Heuristic: public API + many callers = high risk."""
+        score = 0.0
+
+        if is_public:
+            score += 0.5
+
+        if callers > 10:
+            score += 0.45
+        elif callers > 5:
+            score += 0.35
+        elif callers > 0:
+            score += 0.2
+
+        # Private files (underscore-prefixed) carry slightly less risk.
+        if Path(path).stem.startswith("_"):
+            score -= 0.1
+
+        return max(0.0, min(1.0, score))
+
+    def _get_impact_report(self, file_path: str, change_description: str) -> tuple[int, bool]:
+        """Call impact_tools.ImpactTool or fall back to heuristic if unavailable."""
+        module_name = Path(file_path).stem
+        try:
+            from src.tools.impact_tools import ImpactAnalysisTool  # noqa: PLC0415
+            tool = ImpactAnalysisTool()
+            callers = tool._find_callers(module_name, self._root, include_tests=True)
+            is_public = tool._is_public_api(module_name, self._root)
+            return len(callers), is_public
+        except Exception:  # noqa: BLE001
+            log.debug("ImpactAnalysisTool unavailable for %r; using heuristic", file_path)
+            return self._heuristic_callers(file_path), self._heuristic_public(file_path)
+
+    def _heuristic_callers(self, file_path: str) -> int:
+        """Count Python files that reference this module by stem name."""
+        stem = Path(file_path).stem
+        count = 0
+        try:
+            target = Path(file_path).resolve()
+            for py_file in self._root.rglob("*.py"):
+                if py_file.resolve() == target:
+                    continue
+                try:
+                    if stem in py_file.read_text(errors="ignore"):
+                        count += 1
+                except OSError:
+                    continue
+        except Exception:  # noqa: BLE001
+            pass
+        return count
+
+    def _heuristic_public(self, file_path: str) -> bool:
+        """Return True if the file's stem appears in any __init__.py."""
+        stem = Path(file_path).stem
+        try:
+            for init in self._root.rglob("__init__.py"):
+                try:
+                    if stem in init.read_text(errors="ignore"):
+                        return True
+                except OSError:
+                    continue
+        except Exception:  # noqa: BLE001
+            pass
+        return False
+
+    @staticmethod
+    def _semver(callers: int, is_public: bool) -> str:
+        if is_public:
+            return "major"
+        if callers > 5:
+            return "minor"
+        return "patch"

src/agent/impact_graph.py

@@ -0,0 +1,117 @@
+"""
+Impact Graph — static dependency analysis for Python codebases.
+
+Builds a file-level import dependency graph, then given a set of changed files,
+computes the transitive impact set (all files that may be affected by the change).
+"""
+from __future__ import annotations
+import ast
+import logging
+import re
+from pathlib import Path
+from typing import Optional
+
+log = logging.getLogger(__name__)
+
+class ImpactGraph:
+    """
+    Directed graph where edge A→B means "A imports from B" (B impacts A).
+    To find what is impacted by changing file X: find all nodes that transitively
+    import X (reverse edges).
+    """
+    def __init__(self):
+        self._deps: dict[str, set[str]] = {}        # file → set of files it imports
+        self._reverse: dict[str, set[str]] = {}     # file → set of files that import it
+
+    def add_file(self, file_path: str, imports: list[str]) -> None:
+        self._deps[file_path] = set(imports)
+        for imp in imports:
+            self._reverse.setdefault(imp, set()).add(file_path)
+
+    def get_dependencies(self, file_path: str) -> set[str]:
+        """Files that file_path depends on (imports)."""
+        return set(self._deps.get(file_path, set()))
+
+    def get_dependents(self, file_path: str) -> set[str]:
+        """Files that import file_path (directly impacted by changes to it)."""
+        return set(self._reverse.get(file_path, set()))
+
+    def get_transitive_dependents(self, file_path: str,
+                                   max_depth: int = 10) -> set[str]:
+        """BFS to find all files transitively impacted by changes to file_path."""
+        visited: set[str] = set()
+        queue = [file_path]
+        depth = 0
+        while queue and depth < max_depth:
+            next_queue = []
+            for node in queue:
+                for dependent in self._reverse.get(node, set()):
+                    if dependent not in visited:
+                        visited.add(dependent)
+                        next_queue.append(dependent)
+            queue = next_queue
+            depth += 1
+        return visited
+
+    def compute_impact_set(self, changed_files: list[str]) -> set[str]:
+        """Union of transitive dependents for all changed files."""
+        impact: set[str] = set()
+        for f in changed_files:
+            impact |= self.get_transitive_dependents(f)
+        return impact - set(changed_files)  # exclude the changed files themselves
+
+    def all_files(self) -> set[str]:
+        return set(self._deps.keys())
+
+
+def _extract_imports(source_code: str, file_path: str = "") -> list[str]:
+    """Extract imported module names from Python source using AST."""
+    imports: list[str] = []
+    try:
+        tree = ast.parse(source_code, filename=file_path)
+    except SyntaxError:
+        return imports
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                imports.append(alias.name)
+        elif isinstance(node, ast.ImportFrom):
+            if node.module:
+                imports.append(node.module)
+    return imports
+
+
+def _module_to_file(module_name: str, root: Path,
+                    known_files: set[str]) -> Optional[str]:
+    """Convert a dotted module name to a file path if it exists in the project."""
+    rel = module_name.replace(".", "/")
+    candidates = [
+        str(root / f"{rel}.py"),
+        str(root / rel / "__init__.py"),
+    ]
+    for c in candidates:
+        if c in known_files:
+            return c
+    return None
+
+
+def build_impact_graph(root: Path, glob_pattern: str = "**/*.py") -> ImpactGraph:
+    """Scan all Python files under root and build the import dependency graph."""
+    graph = ImpactGraph()
+    py_files = list(root.glob(glob_pattern))
+    known_files = {str(f) for f in py_files}
+
+    for py_file in py_files:
+        try:
+            source = py_file.read_text(encoding="utf-8", errors="ignore")
+        except Exception:
+            continue
+        raw_imports = _extract_imports(source, str(py_file))
+        resolved: list[str] = []
+        for mod in raw_imports:
+            resolved_path = _module_to_file(mod, root, known_files)
+            if resolved_path:
+                resolved.append(resolved_path)
+        graph.add_file(str(py_file), resolved)
+
+    return graph