codedd-cli 0.1.8__tar.gz → 0.1.9__tar.gz

{codedd_cli-0.1.8 → codedd_cli-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codedd-cli
-Version: 0.1.8
+Version: 0.1.9
 Summary: CLI tool for CodeDD — run code audits from your terminal
 License: MIT
 License-File: LICENSE
@@ -32,7 +32,7 @@ Requires-Dist: radon (>=6.0.0)
 Requires-Dist: rich (>=13.0.0)
 Requires-Dist: tomli (>=2.0.0) ; python_version < "3.11"
 Requires-Dist: tomli-w (>=1.0.0)
-Requires-Dist: typer[all] (>=0.9.0)
+Requires-Dist: typer (>=0.9.0)
 Project-URL: Homepage, https://codedd.ai
 Project-URL: Repository, https://gitlab.com/codedd1/codedd-cli
 Description-Content-Type: text/markdown

{codedd_cli-0.1.8 → codedd_cli-0.1.9}/codedd_cli/__init__.py

@@ -1,3 +1,3 @@
 """CodeDD CLI — run code audits from your terminal."""
 
-__version__ = "0.1.8"
+__version__ = "0.1.9"

{codedd_cli-0.1.8 → codedd_cli-0.1.9}/codedd_cli/auditor/archetype_classifier.py

@@ -35,11 +35,63 @@ except ImportError:  # pragma: no cover - pyyaml is a hard dep, but stay safe
 # from the streamed audit plan are observed by every accessor below.
 from codedd_cli.auditor.server_parity import repo_kind as rk
 from codedd_cli.auditor.server_parity import tier_definitions as td
+from codedd_cli.auditor.server_parity.taxonomy import normalize_category, normalize_edge_type
 from codedd_cli.auditor.server_parity.tech_normalizer import canonical_tech_name
 
 logger = logging.getLogger(__name__)
 
 
+# ---------------------------------------------------------------------------
+# Architecture style (topology) - orthogonal to the operational-scale tier
+# ---------------------------------------------------------------------------
+
+ARCHITECTURE_STYLE_LABELS: dict[str, str] = {
+    'microservices': 'Microservices',
+    'service_oriented': 'Service-Oriented (SOA)',
+    'modular_monolith': 'Modular Monolith',
+    'monolith': 'Monolith',
+    'library': 'Library / CLI Tool',
+    'data_pipeline': 'Data Pipeline',
+    'mobile_client': 'Mobile Client',
+    'serverless': 'Serverless',
+    'infrastructure': 'Infrastructure / IaC',
+    'documentation': 'Documentation',
+}
+
+
+def derive_architecture_style(
+    deployable_units: int,
+    logical_units: int,
+    service_node_count: int,
+    inter_service_edge_count: int,
+    detected_patterns: list[str],
+    repo_kind: str = 'service',
+    module_dirs: int = 0,
+) -> str:
+    """Topology-derived architecture style, independent of the tier ladder."""
+    kind = str(repo_kind or 'service').strip().lower()
+    if kind in rk.ABSTAIN_REPO_KINDS:
+        return kind
+
+    patterns_l = [str(p).lower() for p in (detected_patterns or [])]
+    graph_services = service_node_count if inter_service_edge_count >= 2 else 0
+    effective_services = max(int(deployable_units or 0), graph_services)
+
+    if effective_services >= 8 and (
+        inter_service_edge_count >= 4 or deployable_units >= 8
+    ):
+        return 'microservices'
+    if effective_services >= 4:
+        return 'service_oriented'
+    if (
+        module_dirs >= 3
+        or logical_units >= 4
+        or any('modular monolith' in p or 'bounded context' in p for p in patterns_l)
+    ):
+        return 'modular_monolith'
+    return 'monolith'
+
+
 # ---------------------------------------------------------------------------
 # Dimension Scorers
 # ---------------------------------------------------------------------------
@@ -84,8 +136,114 @@ class DimensionScorer:
         self.nodes = self.phase3.get('nodes', [])
         self.edges = self.phase3.get('edges', [])
 
+        self.repo_files = self._resolve_repo_file_inventory()
+
         self._tech_credit_ledger: dict[str, set[str]] = {}
         self.penalty_signals: dict[str, bool] = {}
+        self._deployable_census: tuple[int, int] | None = None
+
+    def _resolve_repo_file_inventory(self) -> list[str]:
+        """Prefer the full inventory over the budget-capped LLM selection."""
+        full = self.phase1.get('all_repository_files')
+        if isinstance(full, list) and full:
+            return [str(f) for f in full if isinstance(f, str)]
+        fallback = (
+            self.phase1.get('relevant_files', [])
+            or self.phase2.get('phase1_files', [])
+            or []
+        )
+        return [str(f) for f in fallback if isinstance(f, str)]
+
+    @staticmethod
+    def _is_first_party_service_node(node: dict) -> bool:
+        if not isinstance(node, dict):
+            return False
+        if node.get('is_external') or (node.get('properties') or {}).get('is_external'):
+            return False
+        if normalize_category(node.get('category')) == 'service':
+            return True
+        return node.get('type') in ('service', 'component', 'module')
+
+    _SYNC_RPC_EDGE_TYPES = frozenset({'api_calls', 'calls'})
+
+    def _count_inter_service_edges(
+        self, edge_types: frozenset | None = None
+    ) -> tuple[int, int]:
+        """Count graph edges connecting two distinct first-party service nodes."""
+        service_ids: set[str] = set()
+        for n in self.nodes:
+            if self._is_first_party_service_node(n):
+                node_id = n.get('id')
+                if node_id:
+                    service_ids.add(node_id)
+        count = 0
+        for e in self.edges:
+            if not isinstance(e, dict):
+                continue
+            etype = normalize_edge_type(e.get('type'))
+            if edge_types is not None and etype not in edge_types:
+                continue
+            source, target = e.get('source'), e.get('target')
+            if source in service_ids and target in service_ids and source != target:
+                count += 1
+        return count, len(service_ids)
+
+    def _count_build_module_dirs(self) -> int:
+        """Count distinct directories that carry a build manifest."""
+        manifests = (
+            'pom.xml', 'build.gradle', 'build.gradle.kts', 'package.json',
+        )
+        dirs: set[str] = set()
+        for f in self.repo_files:
+            if not isinstance(f, str):
+                continue
+            lower = f.lower().replace('\\', '/')
+            name = lower.rsplit('/', 1)[-1]
+            if name in manifests:
+                parent = lower.rsplit('/', 1)[0] if '/' in lower else '.'
+                dirs.add(parent)
+        return len(dirs)
+
+    def apply_graph_consistency_gate(
+        self, dimension_scores: dict[str, dict[str, Any]]
+    ) -> dict[str, Any]:
+        """Reconcile deployment_model with the component graph when they disagree."""
+        edge_count, service_count = self._count_inter_service_edges()
+        info: dict[str, Any] = {
+            'applied': False,
+            'service_nodes': service_count,
+            'inter_service_edges': edge_count,
+        }
+        dim = dimension_scores.get('deployment_model')
+        if not dim:
+            return info
+
+        current = float(dim.get('score', 0))
+        target: float | None = None
+        if service_count >= 8 and edge_count >= max(5, service_count // 2):
+            if current < 69:
+                target = 72.0
+        elif service_count >= 4 and edge_count >= 3:
+            if current < 47:
+                target = 50.0
+
+        if target is None or target <= current:
+            return info
+
+        info.update({
+            'applied': True,
+            'original_score': round(current, 1),
+            'adjusted_score': round(target, 1),
+        })
+        dim['score'] = round(target, 1)
+        dim['evidence'].append(self._evidence(
+            f'Graph consistency gate: {service_count} first-party service '
+            f'node(s) with {edge_count} inter-service call edge(s) contradict '
+            f'a monolith-band deployment score; re-derived from '
+            f'{current:.0f} to {target:.0f}.',
+            'strong',
+        ))
+        return info
 
     # -- helpers --------------------------------------------------------
 
@@ -269,7 +427,7 @@ class DimensionScorer:
             'helm', 'kustomize', '.github/workflows', '.gitlab-ci',
             'jenkinsfile', 'buildspec',
         ]
-        phase1_files_raw = (
+        phase1_files_raw = self.repo_files or (
             self.phase1.get('relevant_files', [])
             or self.phase2.get('phase1_files', [])
             or []
@@ -366,6 +524,7 @@ class DimensionScorer:
                 'weak',
             ))
 
+        self._deployable_census = (deployable_count, logical_count)
         return deployable_count, logical_count, evidence
 
     @staticmethod
@@ -1366,9 +1525,43 @@ class TierMatcher:
 # Tier Gap Analysis
 # ---------------------------------------------------------------------------
 
+_RECOMMENDATION_EVIDENCE_GUARDS: list[tuple[tuple[str, ...], tuple[str, ...]]] = [
+    (('containerize',), ('docker', 'kubernetes', 'k8s', 'containerd', 'podman')),
+    (('kubernetes',), ('kubernetes', 'k8s')),
+    (('infrastructure as code', 'terraform'), ('terraform', 'pulumi', 'cloudformation', 'ansible', 'bicep', 'cdk')),
+    (('distributed tracing', 'opentelemetry'), ('opentelemetry', 'otel', 'jaeger', 'zipkin', 'tempo', 'lightstep')),
+    (('centralized logging',), ('loki', 'elasticsearch', 'elk', 'fluentd', 'fluent bit', 'splunk', 'graylog')),
+    (('monitoring',), ('prometheus', 'grafana', 'datadog', 'new relic', 'newrelic', 'dynatrace', 'cloudwatch')),
+    (('caching layer', 'application-level caching'), ('redis', 'memcached', 'valkey', 'hazelcast')),
+    (('streaming platform', 'kafka'), ('kafka', 'pulsar', 'kinesis')),
+    (('gitops',), ('argocd', 'argo cd', 'argo', 'fluxcd', 'flux cd')),
+    (('cdn',), ('cloudfront', 'cloudflare', 'akamai', 'fastly')),
+    (('autoscaling policies', 'hpa/keda'), ('hpa', 'keda')),
+    (('ci/cd pipeline',), ('github actions', 'gitlab ci', 'jenkins', 'circleci', 'tekton', 'buildkite')),
+]
+
+
+def _recommendation_contradicts_evidence(
+    recommendation: str, detected_technologies: list[str]
+) -> bool:
+    """True when every capability the recommendation names is already detected."""
+    rec_lower = str(recommendation or '').lower()
+    detected_blob = ' '.join(str(t).lower() for t in (detected_technologies or []))
+    if not rec_lower or not detected_blob:
+        return False
+    matched_any = False
+    for needles, techs in _RECOMMENDATION_EVIDENCE_GUARDS:
+        if any(needle in rec_lower for needle in needles):
+            matched_any = True
+            if not any(tech in detected_blob for tech in techs):
+                return False
+    return matched_any
+
+
 def compute_tier_gap_analysis(
     primary_tier: int,
     dimension_scores: dict[str, dict[str, Any]],
+    detected_technologies: list[str] | None = None,
 ) -> dict[str, Any]:
     """Describe what is needed to advance from the current tier to the next."""
     if primary_tier >= 5:
@@ -1396,16 +1589,29 @@ def compute_tier_gap_analysis(
             }
         else:
             recs = td.GAP_RECOMMENDATIONS.get(dim_key, {})
+            recommendation = recs.get(
+                primary_tier,
+                f'Advance {td.DIMENSION_LABELS.get(dim_key, dim_key)} '
+                f'capabilities toward Tier {next_tier}.',
+            )
+            recommendation_adjusted = False
+            if _recommendation_contradicts_evidence(
+                recommendation, detected_technologies or []
+            ):
+                recommendation = (
+                    f'Core tooling for this step is already in place; deepen '
+                    f'its adoption and coverage to raise '
+                    f'{td.DIMENSION_LABELS.get(dim_key, dim_key)} toward '
+                    f'Tier {next_tier}.'
+                )
+                recommendation_adjusted = True
             actions[dim_key] = {
                 'status': 'below_target',
                 'current_score': current_score,
                 'target_score': target,
                 'gap': round(gap, 1),
-                'recommendation': recs.get(
-                    primary_tier,
-                    f'Advance {td.DIMENSION_LABELS.get(dim_key, dim_key)} '
-                    f'capabilities toward Tier {next_tier}.',
-                ),
+                'recommendation': recommendation,
+                'recommendation_adjusted': recommendation_adjusted,
             }
 
     return {
@@ -1450,6 +1656,20 @@ def classify_local(
     repo_kind_value = rk.classify_repo_kind(scorer.detected_techs, scorer.detected_patterns)
     tier_not_applicable = repo_kind_value in rk.ABSTAIN_REPO_KINDS
 
+    consistency_gate = scorer.apply_graph_consistency_gate(dimension_scores)
+
+    deployable_units, logical_units = scorer._deployable_census or (0, 0)
+    inter_service_edges, service_node_count = scorer._count_inter_service_edges()
+    architecture_style = derive_architecture_style(
+        deployable_units=deployable_units,
+        logical_units=logical_units,
+        service_node_count=service_node_count,
+        inter_service_edge_count=inter_service_edges,
+        detected_patterns=scorer.detected_patterns,
+        repo_kind=repo_kind_value,
+        module_dirs=scorer._count_build_module_dirs(),
+    )
+
     match_result = TierMatcher.match(dimension_scores)
 
     if tier_not_applicable:
@@ -1465,6 +1685,7 @@ def classify_local(
     gap_analysis = compute_tier_gap_analysis(
         match_result['primary_tier'],
         match_result['dimension_scores'],
+        detected_technologies=scorer.detected_techs,
     )
 
     elapsed = round(time.time() - start_time, 2)
@@ -1499,4 +1720,9 @@ def classify_local(
         'confidence_components': match_result.get('confidence_components', {}),
         'penalty_caps_applied': getattr(scorer, '_applied_penalty_caps', []),
         'penalty_signals': scorer.penalty_signals,
+        'architecture_style': architecture_style,
+        'architecture_style_label': ARCHITECTURE_STYLE_LABELS.get(
+            architecture_style, architecture_style.replace('_', ' ').title()
+        ),
+        'graph_consistency_gate': consistency_gate,
     }