Restructure report/unit modules and add CLI logging/output options

.gitignore

@@ -6,3 +6,5 @@
 codra.egg-info/
 
 result.json
+
+viewer/node_modules/

.vscode/launch.json

@@ -9,12 +9,14 @@
       "env": {
         "PYTHONPATH": "${workspaceFolder}"
       },
-      "module": "codra.cli",
+      "module": "codra.cli.main",
       "args": [
         "${workspaceFolder}/codra",
         "--threshold-csa", "5",
         "--threshold-id", "2",
-        "--threshold-bps", "0.7"
+        "--threshold-bps", "0.7",
+        "--log-level", "DEBUG",
+        "--output", "${workspaceFolder}/report.json"
       ],
       "console": "integratedTerminal",
       "justMyCode": false

PROMT.md

@@ -0,0 +1,50 @@
+1) Prompt for Writing New Code (optimize CSA, ID, BPS)
+Prompt:
+
+You are writing Python code that will be analyzed using three metrics:
+
+CSA (complexity / symbol usage),
+
+ID (indirection depth / call graph complexity),
+
+BPS (branching/condition penalty; complex conditions reduce the score).
+
+Write code that optimizes all three metrics:
+
+Keep functions small, single-purpose, and avoid deep call chains (low ID).
+
+Minimize external symbol usage and keep dependencies localized (low CSA).
+
+Keep if conditions simple; avoid chained boolean logic and function calls inside conditions (high BPS).
+
+Precompute values before conditionals, and use helper functions to isolate logic.
+
+Prefer clear, flat control flow (early returns) over nested branches.
+
+Produce clean, readable, and maintainable code that adheres to these constraints.
+
+
+
+
+2) Prompt for Refactoring Existing Code (improve CSA, ID, BPS)
+Prompt:
+
+You are refactoring existing Python code to improve CSA, ID, and BPS metrics:
+
+CSA improves by reducing external symbol usage and simplifying symbol dependencies.
+
+ID improves by shortening call chains and reducing indirection depth.
+
+BPS improves by simplifying conditional expressions and removing calls inside conditions.
+
+Refactor the code while preserving behavior:
+
+Extract complex condition logic into small helpers and precompute values outside if statements.
+
+Split large functions into smaller ones only if it does not create deeper call chains.
+
+Reduce dependency on external symbols by localizing logic and data.
+
+Flatten control flow and avoid unnecessary layers of abstraction.
+
+Keep the output behavior identical, add tests only when needed, and explain how the changes improve CSA, ID, and BPS.

README.md

@@ -20,13 +20,19 @@ pip install -e .
 Analizza un percorso e stampa il report JSON su stdout:
 
 ```bash
-python3 -m codra.cli /percorso/progetto
+python3 -m codra.cli.main /percorso/progetto
 ```
 
 Esempio con soglie:
 
 ```bash
-python3 -m codra.cli /percorso/progetto --threshold-csa 10 --threshold-id 2 --threshold-bps 0.7
+python3 -m codra.cli.main /percorso/progetto --threshold-csa 10 --threshold-id 2 --threshold-bps 0.7
+```
+
+Esempio con log e file di output:
+
+```bash
+python3 -m codra.cli.main /percorso/progetto --log-level DEBUG --output report.json
 ```
 
 ## Viewer React (opzionale)

codra/__init__.py

@@ -1,14 +1,14 @@
-from .bps_analyzer import BpsAnalyzer
-from .bps_result import BpsResult
-from .csa_analyzer import CsaAnalyzer
-from .csa_result import CsaResult
-from .directory_scanner import DirectoryScanner
-from .indirection_analyzer import IndirectionAnalyzer
-from .indirection_result import IndirectionResult
-from .report import Report
-from .report_builder import ReportBuilder
-from .report_serializer import ReportSerializer
-from .unit_definition import UnitDefinition
+from .bps.analyzer import BpsAnalyzer
+from .bps.result import BpsResult
+from .csa.analyzer import CsaAnalyzer
+from .csa.result import CsaResult
+from .directory.scanner import DirectoryScanner
+from .indirection.analyzer import IndirectionAnalyzer
+from .indirection.result import IndirectionResult
+from .report.builder import ReportBuilder
+from .report.model import Report
+from .report.serializer import ReportSerializer
+from .unit.definition import UnitDefinition
 
 __all__ = [
     "BpsAnalyzer",

codra/alias_collector.py → codra/alias/collector.py

@@ -1,22 +1,24 @@
 from __future__ import annotations
 
 import ast
+from ast import NodeVisitor
 from dataclasses import dataclass, field
 
 
 @dataclass
-class AliasCollector(ast.NodeVisitor):
+class AliasCollector(NodeVisitor):
+    """AST visitor collecting top-level alias assignments via NodeVisitor."""
     aliases: dict[str, str] = field(default_factory=dict)
     depth: int = 0
 
     def collect(self, tree: ast.AST) -> dict[str, str]:
-        self.visit(tree)
+        super().visit(tree)
         return dict(self.aliases)
 
     def visit_Module(self, node: ast.Module) -> None:
         self.depth += 1
         for statement in node.body:
-            self.visit(statement)
+            super().visit(statement)
         self.depth -= 1
 
     def visit_FunctionDef(self, node: ast.FunctionDef) -> None:

codra/bps/analyzer.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+
+from ..condition.collector import ConditionMetricsCollector
+from ..function.symbol_collector import FunctionSymbolCollector
+from ..if_.collector import IfCollector
+from ..unit.node import UnitNode
+from ..unit.node_collector import UnitNodeCollector
+from .result import BpsResult
+
+
+@dataclass
+class BpsAnalyzer:
+    def analyze_file(self, file_path: str) -> list[BpsResult]:
+        tree = self._parse_file(file_path)
+        unit_nodes = self._collect_units(tree, file_path)
+        scores = [self._collect_bps(unit_node) for unit_node in unit_nodes]
+        return self._build_results(unit_nodes, scores)
+
+    def _parse_file(self, file_path: str) -> ast.AST:
+        with open(file_path, "r", encoding="utf-8") as handle:
+            source = handle.read()
+        return ast.parse(source, filename=file_path)
+
+    def _collect_units(self, tree: ast.AST, file_path: str) -> list[UnitNode]:
+        unit_collector = UnitNodeCollector(file_path=file_path)
+        unit_collector.visit(tree)
+        return unit_collector.units
+
+    def _collect_bps(self, unit_node: UnitNode) -> float:
+        usage = FunctionSymbolCollector().collect(unit_node.node)
+        local_names = usage.locals
+        if_nodes = IfCollector().collect(unit_node.node)
+        if not if_nodes:
+            return 1.0
+        scores: list[float] = []
+        for if_node in if_nodes:
+            metrics = ConditionMetricsCollector(local_names=local_names).collect(
+                if_node.test
+            )
+            penalty = (
+                metrics.bool_ops
+                + metrics.compare_ops
+                + 2 * metrics.calls
+                + 2 * metrics.external_refs
+            )
+            scores.append(1.0 / (1.0 + penalty))
+        return sum(scores) / len(scores)
+
+    def _build_results(
+        self, unit_nodes: list[UnitNode], scores: list[float]
+    ) -> list[BpsResult]:
+        return [
+            BpsResult(unit=unit_node.definition, bps=bps)
+            for unit_node, bps in zip(unit_nodes, scores, strict=True)
+        ]

codra/bps_result.py → codra/bps/result.py

@@ -2,7 +2,7 @@
 
 from dataclasses import dataclass
 
-from .unit_definition import UnitDefinition
+from ..unit.definition import UnitDefinition
 
 
 @dataclass(frozen=True)

codra/call_collector.py → codra/call/collector.py

@@ -1,16 +1,18 @@
 from __future__ import annotations
 
 import ast
+from ast import NodeVisitor
 from dataclasses import dataclass, field
 
 
 @dataclass
-class CallCollector(ast.NodeVisitor):
+class CallCollector(NodeVisitor):
+    """AST visitor collecting call expressions via NodeVisitor."""
     calls: list[str] = field(default_factory=list)
 
     def collect(self, node: ast.AST) -> list[str]:
         for statement in node.body:
-            self.visit(statement)
+            super().visit(statement)
         return list(self.calls)
 
     def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
@@ -25,4 +27,7 @@ def visit_ClassDef(self, node: ast.ClassDef) -> None:
     def visit_Call(self, node: ast.Call) -> None:
         if isinstance(node.func, ast.Name):
             self.calls.append(node.func.id)
-        self.generic_visit(node)
+        elif isinstance(node.func, ast.Attribute):
+            if isinstance(node.func.value, ast.Name) and node.func.value.id == "self":
+                self.calls.append(f"self.{node.func.attr}")
+        super().generic_visit(node)

codra/cli/args.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class CliArgs:
+    path: str
+    threshold_csa: int | None
+    threshold_id: int | None
+    threshold_bps: float | None
+    log_level: str
+    output: str | None

codra/cli/dependencies.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ..report.builder import ReportBuilder
+from ..report.serializer import ReportSerializer
+
+
+@dataclass(frozen=True)
+class CliDependencies:
+    builder: ReportBuilder
+    serializer: ReportSerializer