codedna-analyzer 1.4.0__py3-none-any.whl

codedna/mcp/server.py

@@ -0,0 +1,393 @@
+"""CodeDNA MCP Server — JSON-RPC 2.0 stdio server for AI client inter-connectivity."""
+
+from __future__ import annotations
+
+import json
+import logging
+import sys
+from pathlib import Path
+from typing import Any
+
+from codedna import __version__
+from codedna.analyzers.architecture_detector import ArchitectureDetector
+from codedna.analyzers.complexity_analyzer import ComplexityAnalyzer
+from codedna.analyzers.dependency_mapper import DependencyMapper
+from codedna.analyzers.diff_engine import DiffEngine
+from codedna.analyzers.language_detector import LanguageDetector
+from codedna.analyzers.security_detector import SecurityDetector
+from codedna.analyzers.structure_analyzer import StructureAnalyzer
+from codedna.ci.gatekeeper import Gatekeeper
+from codedna.config import load_config
+
+from .protocol import (
+    METHOD_NOT_FOUND,
+    JSONRPCRequest,
+    JSONRPCResponse,
+    MCPToolDefinition,
+)
+
+logger = logging.getLogger("codedna.mcp")
+
+
+class CodeDNAMCPServer:
+    """Stdio and programmatic Model Context Protocol server for CodeDNA."""
+
+    def __init__(self) -> None:
+        self.server_name = "codedna-mcp"
+        self.server_version = __version__
+        self._register_tools()
+
+    def _register_tools(self) -> None:
+        self.tools: dict[str, MCPToolDefinition] = {
+            "codedna_analyze": MCPToolDefinition(
+                name="codedna_analyze",
+                description="Run complete reverse-engineering DNA analysis on a repository path or directory.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "path": {"type": "string", "description": "Local path to codebase root", "default": "."},
+                    },
+                },
+            ),
+            "codedna_inspect_architecture": MCPToolDefinition(
+                name="codedna_inspect_architecture",
+                description="Detect architecture patterns (MVC, Layered, Clean/Hexagonal, Microservices, Event-Driven) and infrastructure traits.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "path": {"type": "string", "description": "Local directory path", "default": "."},
+                    },
+                },
+            ),
+            "codedna_security_audit": MCPToolDefinition(
+                name="codedna_security_audit",
+                description="Scan codebase for hardcoded credentials, AI API keys, Shannon high-entropy secrets, and injection vulnerabilities.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "path": {"type": "string", "description": "Local directory path", "default": "."},
+                    },
+                },
+            ),
+            "codedna_complexity_metrics": MCPToolDefinition(
+                name="codedna_complexity_metrics",
+                description="Analyze McCabe Cyclomatic Complexity, Cognitive Complexity, and Maintainability Index (MI) across source functions.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "path": {"type": "string", "description": "Local directory path", "default": "."},
+                    },
+                },
+            ),
+            "codedna_dependency_graph": MCPToolDefinition(
+                name="codedna_dependency_graph",
+                description="Build internal dependency graph, detect circular cycles, coupling density, and PageRank centrality.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "path": {"type": "string", "description": "Local directory path", "default": "."},
+                    },
+                },
+            ),
+            "codedna_quality_gate": MCPToolDefinition(
+                name="codedna_quality_gate",
+                description="Evaluate repository against CI/CD architectural quality gates and security policies.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "path": {"type": "string", "description": "Local directory path", "default": "."},
+                        "min_health": {"type": "string", "enum": ["Healthy", "Fair", "Needs Attention", "Critical"], "default": "Fair"},
+                        "fail_on_secrets": {"type": "boolean", "default": True},
+                        "fail_on_circular": {"type": "boolean", "default": False},
+                    },
+                },
+            ),
+            "codedna_drift_diff": MCPToolDefinition(
+                name="codedna_drift_diff",
+                description="Compare two codebases or branches to calculate genetic drift, similarity percentage, and architectural deltas.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "baseline": {"type": "string", "description": "Baseline directory or DNA JSON profile"},
+                        "target": {"type": "string", "description": "Target directory or DNA JSON profile"},
+                    },
+                    "required": ["baseline", "target"],
+                },
+            ),
+            "codedna_generate_sbom": MCPToolDefinition(
+                name="codedna_generate_sbom",
+                description="Generate CycloneDX 1.5 or SPDX 2.3 Software Bill of Materials (SBOM) across Python, Node.js, Rust, and Go dependencies.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "path": {"type": "string", "description": "Local codebase path", "default": "."},
+                        "format": {"type": "string", "enum": ["cyclonedx", "spdx"], "default": "cyclonedx"},
+                    },
+                },
+            ),
+            "codedna_plan_remediation": MCPToolDefinition(
+                name="codedna_plan_remediation",
+                description="Plan and optionally apply automated, deterministic code remediation diffs for security flaws, bare exceptions, and wildcard pins.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "path": {"type": "string", "description": "Local codebase path", "default": "."},
+                        "apply_fixes": {"type": "boolean", "description": "Apply autofixes directly to disk", "default": False},
+                        "rules": {"type": "array", "items": {"type": "string"}, "description": "Filter by rule IDs"},
+                    },
+                },
+            ),
+        }
+
+    def handle_message(self, message_str: str) -> str | None:
+        """Handle raw JSON-RPC string message and return JSON string response."""
+        try:
+            data = json.loads(message_str)
+        except Exception as e:
+            err_resp = JSONRPCResponse(id=None, error={"code": -32700, "message": f"Parse error: {e}"})
+            return json.dumps(err_resp.to_dict())
+
+        if not isinstance(data, (dict, list)):
+            err_resp = JSONRPCResponse(id=None, error={"code": -32600, "message": "Invalid Request: expected JSON object or array"})
+            return json.dumps(err_resp.to_dict())
+
+        if isinstance(data, list):
+            responses = []
+            for item in data:
+                if not isinstance(item, dict):
+                    responses.append(JSONRPCResponse(id=None, error={"code": -32600, "message": "Invalid Request: expected object"}).to_dict())
+                    continue
+                req = JSONRPCRequest.from_dict(item)
+                res = self.handle_request(req)
+                if res:
+                    responses.append(res.to_dict())
+            return json.dumps(responses) if responses else None
+
+        req = JSONRPCRequest.from_dict(data)
+        res = self.handle_request(req)
+        return json.dumps(res.to_dict()) if res else None
+
+    def handle_request(self, req: JSONRPCRequest) -> JSONRPCResponse | None:
+        """Dispatch JSON-RPC request to appropriate MCP handler."""
+        method = req.method
+
+        if method == "initialize":
+            return JSONRPCResponse(
+                id=req.id,
+                result={
+                    "protocolVersion": "2024-11-05",
+                    "serverInfo": {
+                        "name": self.server_name,
+                        "version": self.server_version,
+                    },
+                    "capabilities": {
+                        "tools": {"listChanged": False},
+                    },
+                },
+            )
+
+        elif method == "notifications/initialized":
+            # Handshake notification, no response required
+            return None
+
+        elif method == "ping":
+            return JSONRPCResponse(id=req.id, result={})
+
+        elif method == "tools/list":
+            return JSONRPCResponse(
+                id=req.id,
+                result={
+                    "tools": [t.to_dict() for t in self.tools.values()],
+                },
+            )
+
+        elif method == "tools/call":
+            params = req.params
+            tool_name = params.get("name", "")
+            args = params.get("arguments", {})
+
+            if tool_name not in self.tools:
+                return JSONRPCResponse(
+                    id=req.id,
+                    error={"code": METHOD_NOT_FOUND, "message": f"Tool '{tool_name}' not found"},
+                )
+
+            try:
+                content_text = self._execute_tool(tool_name, args)
+                return JSONRPCResponse(
+                    id=req.id,
+                    result={
+                        "content": [{"type": "text", "text": content_text}],
+                        "isError": False,
+                    },
+                )
+            except Exception as e:
+                return JSONRPCResponse(
+                    id=req.id,
+                    result={
+                        "content": [{"type": "text", "text": f"Error executing '{tool_name}': {e}"}],
+                        "isError": True,
+                    },
+                )
+
+        else:
+            return JSONRPCResponse(
+                id=req.id,
+                error={"code": METHOD_NOT_FOUND, "message": f"Method '{method}' not supported"},
+            )
+
+    def _execute_tool(self, name: str, args: dict[str, Any]) -> str:
+        """Execute selected tool and return serialized response text."""
+        target_path = Path(args.get("path", ".")).resolve()
+
+        if name == "codedna_analyze":
+            config = load_config(target_path)
+            langs = LanguageDetector().detect(target_path)
+            struct = StructureAnalyzer().analyze(target_path)
+            arch = ArchitectureDetector().detect(target_path)
+            sec = SecurityDetector(config=config).detect(target_path)
+            cmp = ComplexityAnalyzer().analyze(target_path, config=config)
+            deps = DependencyMapper().map(target_path)
+
+            summary = {
+                "source": str(target_path),
+                "primary_language": langs.get("primary", "Unknown"),
+                "system_type": arch.get("primary_pattern", "Unknown"),
+                "total_files": struct.get("total_files", 0),
+                "total_lines": langs.get("total_lines", 0),
+                "maintainability_index": cmp.get("maintainability_index", 100.0),
+                "maintainability_rank": cmp.get("maintainability_rank", "A"),
+                "critical_security_vulnerabilities": sec.get("total_critical", 0),
+                "has_secrets": sec.get("has_secrets", False),
+                "circular_dependencies": deps.get("has_circular_deps", False),
+                "dependency_density": deps.get("density", 0.0),
+            }
+            return json.dumps(summary, indent=2)
+
+        elif name == "codedna_inspect_architecture":
+            arch = ArchitectureDetector().detect(target_path)
+            return json.dumps(arch, indent=2)
+
+        elif name == "codedna_security_audit":
+            config = load_config(target_path)
+            sec = SecurityDetector(config=config).detect(target_path)
+            return json.dumps(sec, indent=2)
+
+        elif name == "codedna_complexity_metrics":
+            config = load_config(target_path)
+            cmp = ComplexityAnalyzer().analyze(target_path, config=config)
+            return json.dumps(cmp, indent=2)
+
+        elif name == "codedna_dependency_graph":
+            deps = DependencyMapper().map(target_path)
+            return json.dumps(deps, indent=2)
+
+        elif name == "codedna_quality_gate":
+            config = load_config(target_path)
+            langs = LanguageDetector().detect(target_path)
+            struct = StructureAnalyzer().analyze(target_path)
+            arch = ArchitectureDetector().detect(target_path)
+            deps = DependencyMapper().map(target_path)
+            sec = SecurityDetector(config=config).detect(target_path)
+            cmp = ComplexityAnalyzer().analyze(target_path, config=config)
+
+            mock_profile = {
+                "health": {
+                    "overall": "Healthy" if sec.get("total_critical", 0) == 0 else "Critical",
+                    "severity_counts": {"critical": sec.get("total_critical", 0), "warning": 0, "info": 0},
+                },
+                "dependencies": deps,
+                "security": sec,
+                "complexity": cmp,
+                "structure_stats": struct,
+                "architecture": arch,
+                "languages": langs,
+            }
+
+            gatekeeper = Gatekeeper(
+                min_health=args.get("min_health", config.min_health),
+                fail_on_secrets=args.get("fail_on_secrets", config.fail_on_secrets),
+                fail_on_circular=args.get("fail_on_circular", config.fail_on_circular),
+                max_cyclomatic_complexity=config.max_cyclomatic_complexity,
+                min_maintainability_index=config.min_maintainability_index,
+                max_density=config.max_density,
+                max_critical_smells=config.max_critical_smells,
+                max_smells=config.max_smells,
+            )
+            result = gatekeeper.evaluate(mock_profile)
+            return json.dumps(result.to_dict(), indent=2)
+
+        elif name == "codedna_drift_diff":
+            baseline_path = Path(args["baseline"]).resolve()
+            target_path_b = Path(args["target"]).resolve()
+
+            # Helper to load or analyze
+            def _get_profile(p: Path) -> dict:
+                if p.is_file() and p.suffix == ".json":
+                    return json.loads(p.read_text(encoding="utf-8"))
+                cfg = load_config(p)
+                return {
+                    "metadata": {"source": str(p)},
+                    "languages": LanguageDetector().detect(p),
+                    "structure_stats": StructureAnalyzer().analyze(p),
+                    "architecture": ArchitectureDetector().detect(p),
+                    "dependencies": DependencyMapper().map(p),
+                    "security": SecurityDetector(config=cfg).detect(p),
+                    "health": {"overall": "Healthy", "severity_counts": {"critical": 0, "warning": 0, "info": 0}},
+                }
+
+            prof_a = _get_profile(baseline_path)
+            prof_b = _get_profile(target_path_b)
+            diff = DiffEngine().compare(prof_a, prof_b)
+            return json.dumps(diff, indent=2)
+
+        elif name == "codedna_generate_sbom":
+            from codedna.compliance.sbom import SBOMGenerator
+
+            fmt = args.get("format", "cyclonedx").lower()
+            generator = SBOMGenerator(target_path)
+            if fmt == "spdx":
+                doc = generator.generate_spdx_json()
+            else:
+                doc = generator.generate_cyclonedx_json()
+            return json.dumps(doc, indent=2)
+
+        elif name == "codedna_plan_remediation":
+            from codedna.remediation.planner import RemediationPlanner
+
+            planner = RemediationPlanner(target_path)
+            rules = args.get("rules")
+            actions = planner.plan(rule_filter=rules)
+            apply_fixes = args.get("apply_fixes", False)
+            if apply_fixes:
+                apply_res = planner.apply(actions, dry_run=False)
+                return json.dumps({
+                    "plan": [a.to_dict() for a in actions],
+                    "application": apply_res,
+                }, indent=2)
+            return json.dumps({
+                "total_remediations": len(actions),
+                "autofixable_count": sum(1 for a in actions if a.autofixable),
+                "actions": [a.to_dict() for a in actions],
+            }, indent=2)
+
+        return "{}"
+
+    def run_stdio(self) -> None:
+        """Run standard I/O loop consuming line-delimited JSON-RPC from stdin."""
+        sys.stderr.write(f"🧬 CodeDNA MCP Server v{self.server_version} running on stdio...\n")
+        sys.stderr.flush()
+
+        for line in sys.stdin:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                response_str = self.handle_message(line)
+                if response_str:
+                    sys.stdout.write(response_str + "\n")
+                    sys.stdout.flush()
+            except Exception as e:
+                err_resp = JSONRPCResponse(id=None, error={"code": -32603, "message": f"Internal error: {e}"})
+                sys.stdout.write(json.dumps(err_resp.to_dict()) + "\n")
+                sys.stdout.flush()

codedna/remediation/__init__.py

@@ -0,0 +1,5 @@
+"""Intelligent Remediation and Auto-Fix Subsystem."""
+
+from .planner import RemediationAction, RemediationPlanner
+
+__all__ = ["RemediationAction", "RemediationPlanner"]

codedna/remediation/planner.py

@@ -0,0 +1,244 @@
+"""Automated Intelligent Remediation Planner for CodeDNA.
+
+Translates security vulnerabilities, code smells, and quality gate failures
+into structured, deterministic, reviewable remediation diffs and patches.
+"""
+
+from __future__ import annotations
+
+import difflib
+import logging
+import os
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+IGNORE_DIRS = {
+    ".git", ".svn", ".hg", "node_modules", "venv", ".venv", "env",
+    "__pycache__", ".pytest_cache", "build", "dist", "target"
+}
+
+
+@dataclass
+class RemediationAction:
+    rule_id: str
+    title: str
+    file_path: str
+    line_number: int
+    severity: str
+    description: str
+    original_text: str
+    proposed_text: str
+    unified_diff: str
+    autofixable: bool = True
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "rule_id": self.rule_id,
+            "title": self.title,
+            "file": self.file_path,
+            "line": self.line_number,
+            "severity": self.severity,
+            "description": self.description,
+            "original_text": self.original_text,
+            "proposed_text": self.proposed_text,
+            "diff": self.unified_diff,
+            "autofixable": self.autofixable,
+            "metadata": self.metadata,
+        }
+
+
+class RemediationPlanner:
+    """Analyzes codebase findings and plans safe, deterministic code patches."""
+
+    def __init__(self, repo_path: str | Path = ".") -> None:
+        self.repo_path = Path(repo_path).resolve()
+
+    def plan(self, rule_filter: Optional[List[str]] = None) -> List[RemediationAction]:
+        """Scans the repository and produces prioritized remediation proposals."""
+        actions: List[RemediationAction] = []
+
+        for root, dirs, files in os.walk(self.repo_path):
+            dirs[:] = [d for d in dirs if d not in IGNORE_DIRS and not d.startswith(".")]
+
+            for fname in files:
+                fpath = Path(root) / fname
+                rel_path = str(fpath.relative_to(self.repo_path))
+
+                # Python remediations
+                if fname.endswith(".py"):
+                    actions.extend(self._scan_python_file(fpath, rel_path))
+
+                # Node.js package.json wildcard remediations
+                elif fname == "package.json":
+                    actions.extend(self._scan_package_json(fpath, rel_path))
+
+        if rule_filter:
+            allowed = set(r.upper() for r in rule_filter)
+            actions = [a for a in actions if a.rule_id.upper() in allowed]
+
+        actions.sort(key=lambda a: (0 if a.severity == "critical" else 1 if a.severity == "warning" else 2, a.file_path, a.line_number))
+        return actions
+
+    def _scan_python_file(self, path: Path, rel_path: str) -> List[RemediationAction]:
+        actions: List[RemediationAction] = []
+        try:
+            content = path.read_text(encoding="utf-8", errors="ignore")
+            lines = content.splitlines(keepends=True)
+
+            # 1. Bare except: -> except Exception:
+            for idx, line in enumerate(lines):
+                bare_match = re.search(r"^([ \t]*)except[ \t]*:", line)
+                if bare_match:
+                    indent = bare_match.group(1)
+                    orig_line = line
+                    fixed_line = f"{indent}except Exception:\n" if line.endswith("\n") else f"{indent}except Exception:"
+                    diff = self._make_diff(orig_line, fixed_line, rel_path)
+                    actions.append(RemediationAction(
+                        rule_id="SMELL-BARE-EXCEPT",
+                        title="Narrow Bare Exception Handler",
+                        file_path=rel_path,
+                        line_number=idx + 1,
+                        severity="warning",
+                        description="Bare 'except:' catches system interrupts (KeyboardInterrupt, SystemExit). Narrow to 'except Exception:'.",
+                        original_text=orig_line.strip(),
+                        proposed_text=fixed_line.strip(),
+                        unified_diff=diff,
+                        autofixable=True
+                    ))
+
+            # 2. Dangerous eval / exec calls with user input or direct strings
+            for idx, line in enumerate(lines):
+                if re.search(r"\b(eval|exec)\s*\(", line) and not line.strip().startswith("#"):
+                    actions.append(RemediationAction(
+                        rule_id="SEC-DANGEROUS-DYNAMIC-EXEC",
+                        title="Refactor Dynamic Code Execution",
+                        file_path=rel_path,
+                        line_number=idx + 1,
+                        severity="critical",
+                        description=f"Direct invocation of {line.strip()[:30]}... allows arbitrary code execution. Refactor to ast.literal_eval or structured parsers.",
+                        original_text=line.strip(),
+                        proposed_text="# TODO: Replace dynamic execution with safe ast.literal_eval or parser",
+                        unified_diff=self._make_diff(line, f"# Refactor dynamic exec: {line}", rel_path),
+                        autofixable=False
+                    ))
+
+            # 3. High-entropy hardcoded secret assignment
+            secret_pattern = re.compile(
+                r"^([ \t]*)(?:api_key|secret_key|auth_token|password|access_token)\s*=\s*['\"][A-Za-z0-9_\-+/]{24,}['\"]",
+                re.IGNORECASE
+            )
+            for idx, line in enumerate(lines):
+                m = secret_pattern.search(line)
+                if m and not line.strip().startswith("#"):
+                    indent = m.group(1)
+                    var_name = line.split("=")[0].strip()
+                    env_var = var_name.upper()
+                    orig_line = line
+                    fixed_line = f"{indent}{var_name} = os.getenv('{env_var}', '')\n" if line.endswith("\n") else f"{indent}{var_name} = os.getenv('{env_var}', '')"
+                    diff = self._make_diff(orig_line, fixed_line, rel_path)
+                    actions.append(RemediationAction(
+                        rule_id="SEC-HARDCODED-SECRET",
+                        title="Extract Hardcoded Secret to Environment Variable",
+                        file_path=rel_path,
+                        line_number=idx + 1,
+                        severity="critical",
+                        description=f"Hardcoded sensitive token assigned to {var_name}. Extract to os.getenv('{env_var}').",
+                        original_text=orig_line.strip(),
+                        proposed_text=fixed_line.strip(),
+                        unified_diff=diff,
+                        autofixable=True
+                    ))
+
+        except Exception as e:
+            logger.debug("Failed scanning %s for remediation: %s", path, e)
+        return actions
+
+    def _scan_package_json(self, path: Path, rel_path: str) -> List[RemediationAction]:
+        actions: List[RemediationAction] = []
+        try:
+            content = path.read_text(encoding="utf-8", errors="ignore")
+            lines = content.splitlines(keepends=True)
+            for idx, line in enumerate(lines):
+                # Pattern: "some-pkg": "*"
+                m = re.search(r'([ \t]*"[^"]+"\s*:\s*)"\*"(,?)', line)
+                if m:
+                    prefix = m.group(1)
+                    comma = m.group(2)
+                    orig_line = line
+                    fixed_line = f'{prefix}"^1.0.0"{comma}\n' if line.endswith("\n") else f'{prefix}"^1.0.0"{comma}'
+                    diff = self._make_diff(orig_line, fixed_line, rel_path)
+                    actions.append(RemediationAction(
+                        rule_id="DEP-WILDCARD-PIN",
+                        title="Pin Wildcard Dependency Version",
+                        file_path=rel_path,
+                        line_number=idx + 1,
+                        severity="warning",
+                        description="Unrestricted wildcard version '*' exposes builds to supply-chain tampering. Pin to semantic range.",
+                        original_text=orig_line.strip(),
+                        proposed_text=fixed_line.strip(),
+                        unified_diff=diff,
+                        autofixable=True
+                    ))
+        except Exception as e:
+            logger.debug("Failed scanning %s for remediation: %s", path, e)
+        return actions
+
+    def _make_diff(self, original: str, proposed: str, file_path: str) -> str:
+        orig_lines = [original if original.endswith("\n") else original + "\n"]
+        prop_lines = [proposed if proposed.endswith("\n") else proposed + "\n"]
+        diff = difflib.unified_diff(
+            orig_lines,
+            prop_lines,
+            fromfile=f"a/{file_path}",
+            tofile=f"b/{file_path}",
+            n=1
+        )
+        return "".join(diff)
+
+    def apply(self, actions: List[RemediationAction], dry_run: bool = False) -> Dict[str, Any]:
+        """Applies autofixable remediation actions to workspace files."""
+        autofixable = [a for a in actions if a.autofixable]
+        files_modified = set()
+        applied_count = 0
+
+        # Group actions by file path
+        by_file: Dict[str, List[RemediationAction]] = {}
+        for a in autofixable:
+            by_file.setdefault(a.file_path, []).append(a)
+
+        for rel_file, file_actions in by_file.items():
+            full_path = self.repo_path / rel_file
+            if not full_path.exists():
+                continue
+
+            try:
+                content = full_path.read_text(encoding="utf-8")
+                modified_content = content
+                file_changed = False
+
+                for act in file_actions:
+                    if act.original_text and act.original_text in modified_content:
+                        modified_content = modified_content.replace(act.original_text, act.proposed_text, 1)
+                        applied_count += 1
+                        file_changed = True
+
+                if file_changed:
+                    files_modified.add(rel_file)
+                    if not dry_run:
+                        full_path.write_text(modified_content, encoding="utf-8")
+
+            except Exception as e:
+                logger.error("Error applying remediation to %s: %s", rel_file, e)
+
+        return {
+            "success": True,
+            "dry_run": dry_run,
+            "applied_count": applied_count,
+            "total_candidates": len(actions),
+            "files_modified": sorted(list(files_modified)),
+        }

codedna/visualization/__init__.py

@@ -0,0 +1 @@
+"""CodeDNA visualization — rendering modules."""