technical-debt-engine-runtime 0.1.0__tar.gz → 0.2.0__tar.gz

{technical_debt_engine_runtime-0.1.0 → technical_debt_engine_runtime-0.2.0}/PKG-INFO

@@ -1,5 +1,6 @@
 Metadata-Version: 2.4
 Name: technical-debt-engine-runtime
-Version: 0.1.0
+Version: 0.2.0
 Summary: Technical Debt Engine runtime foundation API
 Requires-Python: >=3.11
+Requires-Dist: radon==6.0.1

{technical_debt_engine_runtime-0.1.0 → technical_debt_engine_runtime-0.2.0}/README.md

@@ -4,8 +4,13 @@ Technical Debt Engine (TDE) is a standalone, capability-based engineering platfo
 
 TDE is project-independent, platform-independent, CI-independent, language-independent, and vendor-neutral. DJConnect is the first reference consumer; it does not own TDE's architecture, roadmap, or release lifecycle.
 
-The repository contains an operational development package and reproducible
-candidate-build foundation. No package has been published and no release exists.
+Release `0.1.0` is available as the PyPI distribution
+[`technical-debt-engine-runtime`](https://pypi.org/project/technical-debt-engine-runtime/0.1.0/),
+a [GitHub Release](https://github.com/pcvantol/technical-debt-engine/releases/tag/0.1.0),
+and Docker image `docker.io/pcvantol/technical-debt-engine:0.1.0`. The Docker
+OCI index is `sha256:aa648019045a442a0dbce029ee11ecb15c7755d845205fa8f07467e0faf18679`;
+no `latest` tag exists. See [Internal Release Report](INTERNAL_RELEASE_REPORT.md)
+for the immutable publication evidence and release boundary.
 
 ## Product contracts
 
@@ -20,6 +25,7 @@ Operational repository assurance is available through `tde assure`; see [SOFTWAR
 - [Engineering method](ENGINEERING_METHOD.md) and [session bootstrap](BOOTSTRAP.md)
 - [Capability model](CAPABILITY_MODEL.md)
 - [CLI specification](CLI_SPECIFICATION.md)
+- [Code Size Runtime contract](CODE_SIZE_RUNTIME.md)
 - [Evidence schema](EVIDENCE_SCHEMA.md)
 - [Qualification model](QUALIFICATION_MODEL.md)
 - [Roadmap](PRODUCT_ROADMAP.md) and [backlog](PRODUCT_BACKLOG.md)

{technical_debt_engine_runtime-0.1.0 → technical_debt_engine_runtime-0.2.0}/pyproject.toml

@@ -4,9 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "technical-debt-engine-runtime"
-version = "0.1.0"
+version = "0.2.0"
 description = "Technical Debt Engine runtime foundation API"
 requires-python = ">=3.11"
+dependencies = ["radon==6.0.1"]
 
 [project.scripts]
 tde = "tde_cli.main:console_main"
@@ -15,7 +16,7 @@ tde = "tde_cli.main:console_main"
 where = ["src"]
 
 [tool.setuptools.package-data]
-tde_runtime = ["policies/*.json"]
+tde_runtime = ["policies/*.json", "profiles/*.json", "schemas/*.json"]
 
 [tool.unittest]
 start-directory = "tests"

{technical_debt_engine_runtime-0.1.0 → technical_debt_engine_runtime-0.2.0}/src/tde_cli/main.py

@@ -10,6 +10,7 @@ import sys
 from typing import Any, Sequence, TextIO
 
 from tde_runtime import Runtime, RuntimeConfiguration
+from tde_runtime.assessment import AssessmentError, AssessmentOrchestrator
 from tde_runtime.baseline import BaselineError, BaselineRepository, ComparisonEngine, ComparisonRepository
 from tde_runtime.policy import PolicyEngine, PolicyError
 from tde_runtime.trend import TrendEngine
@@ -20,18 +21,28 @@ from tde_runtime.trusted_delivery import TrustedDelivery
 from tde_runtime.release_qualification import ReleaseQualification
 from tde_runtime.release_certification import ReleaseCertification
 from tde_runtime.runtime import EVIDENCE_SCHEMA_VERSION, RUNTIME_VERSION
+from tde_runtime.schemas import SchemaRegistry
+from tde_runtime.repository_qualification import (QualificationRegistry,
+                                                  RepositoryDefinitionRegistry,
+                                                  RepositoryQualification,
+                                                  RepositoryQualificationError)
+from tde_runtime.differential import AssessmentBaselineRegistry, DifferentialEngine, DifferentialError
 
 
-CLI_VERSION = "0.1.0"
+CLI_VERSION = "0.2.0"
 GENERATION = "1"
 
 
 class ExitCode:
     SUCCESS = 0
     WARNING = 1
-    FAILED = 2
-    BLOCKED = 3
+    FAILED_CLOSED = 2
+    EXECUTION_ERROR = 3
     NOT_SUPPORTED = 4
+    ANALYZER_NOT_FOUND = 5
+    # Compatibility aliases for existing non-runtime commands.
+    FAILED = FAILED_CLOSED
+    BLOCKED = EXECUTION_ERROR
 
 
 def _policy_exit_code(decision: str) -> int:
@@ -46,8 +57,10 @@ COMMANDS: dict[str, dict[str, str]] = {
     "validate": {"purpose": "Validate runtime configuration and context."},
     "inspect": {"purpose": "Inspect a target and planned Code Size execution."},
     "assess": {"purpose": "Assess a target through selected capabilities."},
+    "schema": {"purpose": "List the public, versioned assessment schemas."},
     "baseline": {"purpose": "Create an immutable baseline from persisted canonical evidence."},
     "compare": {"purpose": "Persist and qualify a canonical comparison against a baseline."},
+    "diff": {"purpose": "Compare a current assessment with an immutable baseline."},
     "trend": {"purpose": "Aggregate canonical evidence history into trends."},
     "query": {"purpose": "Query canonical engineering evidence."},
     "store": {"purpose": "Persist canonical Runtime evidence."},
@@ -70,11 +83,14 @@ def _global_options(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--output", help="Output destination (reserved; console is used now).")
     parser.add_argument("--format", choices=("human", "json", "markdown"), default="human", help="Output format.")
     parser.add_argument("--log-level", choices=("ERROR", "WARNING", "INFO", "DEBUG", "TRACE"), help="Logging level.")
-    parser.add_argument("--policy", help="Repository or workspace policy directory.")
+    parser.add_argument("--policy", metavar="FILE", help="Declarative policy configuration file.")
     parser.add_argument("--policy-override", action="append", default=[], metavar="RULE=JSON", help="Override a policy rule with a JSON object.")
+    parser.add_argument("--profile", help="Declarative assessment profile for tde assess.")
     parser.add_argument("--baseline-location", help="Directory used for immutable baselines.")
     parser.add_argument("--history-depth", type=int, help="Maximum baseline history depth for trends.")
     parser.add_argument("--store-location", help="Directory used for canonical evidence storage.")
+    parser.add_argument("--repository-definition", metavar="FILE", help="Declarative repository definition for tde qualify.")
+    parser.add_argument("--qualification-location", help="Directory used for immutable repository qualification records.")
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -88,7 +104,7 @@ def build_parser() -> argparse.ArgumentParser:
         command.add_argument("--capability", action="append", default=[], help="Enable a registered capability.")
         if identifier == "baseline":
             command.add_argument("--name", help="Immutable baseline name.")
-        if identifier == "compare":
+        if identifier in {"compare", "assess", "diff"}:
             command.add_argument("--baseline", help="Baseline name or JSON path.")
         if identifier == "query":
             command.add_argument("--resource", default="repositories", help="Evidence resource.")
@@ -139,6 +155,11 @@ def _store_location(arguments: argparse.Namespace, target: str) -> Path:
     return location if location.is_absolute() else Path(target) / location
 
 
+def _qualification_location(arguments: argparse.Namespace, target: str) -> Path:
+    location = Path(arguments.qualification_location or ".tde/qualifications")
+    return location if location.is_absolute() else Path(target) / location
+
+
 def _runtime_result(command: str, target: str, configuration: RuntimeConfiguration,
                     store: EvidenceStore | None = None) -> tuple[int, dict[str, Any]]:
     result = Runtime().execute(target, configuration)
@@ -146,14 +167,23 @@ def _runtime_result(command: str, target: str, configuration: RuntimeConfigurati
                "execution": result.report["executionSummary"], "environment": result.report["environment"], "qualification": result.report["qualification"],
                "runtimeQualification": result.evidence["runtimeQualification"], "validation": result.validation,
                "evidence": result.evidence, "evidenceId": result.evidence["integrity"]["contentDigest"]}
+    capability_statuses = {item.get("status") for item in result.evidence.get("capabilityResults", [])}
+    if "NOT_SUPPORTED" in capability_statuses:
+        return ExitCode.NOT_SUPPORTED, payload
+    if "ANALYZER_NOT_FOUND" in capability_statuses:
+        return ExitCode.ANALYZER_NOT_FOUND, payload
+    if "FAILED_CLOSED" in capability_statuses:
+        return ExitCode.FAILED_CLOSED, payload
     if store is not None:
         payload["evidenceStore"] = store.persist(result.evidence)
-    decision = result.evidence["policyEvidence"]["decision"]
-    if decision == "BLOCKED":
-        return ExitCode.BLOCKED, payload
-    if command in {"assess", "run"} and result.evidence["runtimeQualification"]["level"] != "QUALIFIED":
-        return ExitCode.BLOCKED, payload
-    return (_policy_exit_code(decision) if command in {"assess", "run"} else ExitCode.SUCCESS), payload
+    if command in {"assess", "run"}:
+        # Assessment exit codes describe the public execution contract. Policy
+        # outcomes are preserved in canonical evidence for consumers to apply;
+        # a policy threshold must not masquerade as an analyzer failure.
+        if result.evidence["runtimeQualification"]["level"] != "QUALIFIED":
+            return ExitCode.EXECUTION_ERROR, payload
+        return _policy_exit_code(result.evidence["assessmentDecision"]["decision"]), payload
+    return ExitCode.SUCCESS, payload
 
 
 def _render_capability_report(evidence: dict[str, Any], capability: str, output_format: str, stream: TextIO) -> None:
@@ -176,6 +206,9 @@ def main(argv: Sequence[str] | None = None, stdout: TextIO | None = None) -> int
     stream = stdout or sys.stdout
     parser = build_parser()
     arguments = parser.parse_args(argv)
+    if arguments.command == "schema":
+        _render({"command": "schema", "schemas": list(SchemaRegistry.catalogue())}, arguments.format, stream)
+        return ExitCode.SUCCESS
     prepared = _prepare_command(arguments, parser, stream)
     if isinstance(prepared, int): return prepared
     configuration = prepared
@@ -195,72 +228,52 @@ def main(argv: Sequence[str] | None = None, stdout: TextIO | None = None) -> int
 
 
 def _prepare_command(arguments: argparse.Namespace, parser: argparse.ArgumentParser, stream: TextIO) -> RuntimeConfiguration | int:
-    if arguments.version:
-        _render({"cliVersion": CLI_VERSION, "runtimeVersion": RUNTIME_VERSION,
-                 "schemaVersion": EVIDENCE_SCHEMA_VERSION, "generation": GENERATION}, arguments.format, stream)
-        return ExitCode.SUCCESS
-    if not arguments.command:
-        parser.print_help(stream)
-        return ExitCode.SUCCESS
-    if arguments.command == "help":
-        parser.print_help(stream)
+    if arguments.version or not arguments.command or arguments.command == "help":
+        if arguments.version:
+            _render({"cliVersion": CLI_VERSION, "runtimeVersion": RUNTIME_VERSION, "schemaVersion": EVIDENCE_SCHEMA_VERSION, "generation": GENERATION}, arguments.format, stream)
+        else:
+            parser.print_help(stream)
         return ExitCode.SUCCESS
     _configure_logging(arguments)
     try:
-        configuration = _load_configuration(arguments.config, arguments.target)
-    except ValueError as error:
-        _render({"status": "BLOCKED", "reason": str(error)}, arguments.format, stream)
+        configuration = _apply_options(_load_configuration(arguments.config, arguments.target), arguments)
+        return _apply_command_configuration(configuration, arguments)
+    except (ValueError, AssessmentError) as error:
+        _render({"command": arguments.command, "status": "BLOCKED", "reason": str(error)}, arguments.format, stream)
         return ExitCode.BLOCKED
+
+
+def _apply_options(configuration: RuntimeConfiguration, arguments: argparse.Namespace) -> RuntimeConfiguration:
     if arguments.policy or arguments.policy_override:
-        values = configuration.as_dict()
-        policy = dict(values["executionOptions"].get("policy", {}))
-        if arguments.policy:
-            policy["repository"] = arguments.policy
+        values = configuration.as_dict(); policy = dict(values["executionOptions"].get("policy", {})); policy.update({"file": arguments.policy} if arguments.policy else {})
         overrides = dict(policy.get("overrides", {}))
-        try:
-            for item in arguments.policy_override:
-                rule, raw_value = item.split("=", 1)
-                overrides[rule] = json.loads(raw_value)
-                if not isinstance(overrides[rule], dict):
-                    raise ValueError("override must be a JSON object")
-        except (ValueError, json.JSONDecodeError) as error:
-            _render({"status": "BLOCKED", "reason": f"invalid policy override: {error}"}, arguments.format, stream)
-            return ExitCode.BLOCKED
-        policy["overrides"] = overrides
-        values["policy"] = policy
-        values["executionOptions"].pop("policy", None)
-        configuration = RuntimeConfiguration.load(values)
+        for item in arguments.policy_override:
+            rule, raw_value = item.split("=", 1); overrides[rule] = json.loads(raw_value)
+            if not isinstance(overrides[rule], dict): raise ValueError("invalid policy override: override must be a JSON object")
+        policy["overrides"] = overrides; values["policy"] = policy; values["executionOptions"].pop("policy", None); configuration = RuntimeConfiguration.load(values)
     if arguments.baseline_location:
-        values = configuration.as_dict()
-        values["baseline"] = {"location": arguments.baseline_location}
-        values["executionOptions"].pop("baseline", None)
-        configuration = RuntimeConfiguration.load(values)
+        values = configuration.as_dict(); values["baseline"] = {"location": arguments.baseline_location}; values["executionOptions"].pop("baseline", None); configuration = RuntimeConfiguration.load(values)
     if arguments.history_depth is not None:
-        if arguments.history_depth < 0:
-            _render({"status": "BLOCKED", "reason": "history depth must not be negative"}, arguments.format, stream)
-            return ExitCode.BLOCKED
-        values = configuration.as_dict()
-        values["trend"] = {"historyDepth": arguments.history_depth}
-        values["executionOptions"].pop("trend", None)
-        configuration = RuntimeConfiguration.load(values)
-    if arguments.command in {"assess", "baseline", "compare", "run", "store", "inspect", "validate", "qualify", "report"} and arguments.capability:
-        supported = {"code-size": "code_size", "complexity": "complexity"}
-        if len(arguments.capability) != 1 or arguments.capability[0] not in supported:
-            _render({"command": arguments.command, "status": "NOT_SUPPORTED", "reason": "This vertical slice supports code-size and complexity."}, arguments.format, stream)
-            return ExitCode.NOT_SUPPORTED
-        configuration = configuration.with_capability(supported[arguments.capability[0]])
+        if arguments.history_depth < 0: raise ValueError("history depth must not be negative")
+        values = configuration.as_dict(); values["trend"] = {"historyDepth": arguments.history_depth}; values["executionOptions"].pop("trend", None); configuration = RuntimeConfiguration.load(values)
+    return configuration
+
+
+def _apply_command_configuration(configuration: RuntimeConfiguration, arguments: argparse.Namespace) -> RuntimeConfiguration:
+    if arguments.command in {"assess", "baseline", "compare", "run", "store", "inspect", "validate", "qualify", "report"}:
+        for capability in arguments.capability: configuration = configuration.with_capability(capability.replace("-", "_"))
+    if arguments.command == "assess":
+        return AssessmentOrchestrator().configure(configuration, profile=arguments.profile, capabilities=tuple(item.replace("-", "_") for item in arguments.capability))
     if arguments.command == "release-qualify":
         supported = {"code-size": "code_size", "complexity": "complexity"}
-        if not arguments.release_capability or any(item not in supported for item in arguments.release_capability):
-            _render({"command": "release-qualify", "status": "BLOCKED",
-                     "reason": "release-qualify requires one or more supported --release-capability values"}, arguments.format, stream)
-            return ExitCode.BLOCKED
-        for capability in sorted(set(arguments.release_capability)):
-            configuration = configuration.with_capability(supported[capability])
+        if not arguments.release_capability or any(item not in supported for item in arguments.release_capability): raise ValueError("release-qualify requires one or more supported --release-capability values")
+        for capability in sorted(set(arguments.release_capability)): configuration = configuration.with_capability(supported[capability])
     return configuration
 
 
 def _execute_command(arguments: argparse.Namespace, configuration: RuntimeConfiguration, stream: TextIO) -> int:
+    if arguments.command in {"diff"} or (arguments.command == "assess" and arguments.baseline):
+        return _differential_command(arguments, configuration, stream)
     if arguments.command in {"baseline", "compare"}:
         return _baseline_command(arguments, configuration, stream)
     if arguments.command == "trend":
@@ -268,14 +281,7 @@ def _execute_command(arguments: argparse.Namespace, configuration: RuntimeConfig
     if arguments.command == "query":
         return _query_command(arguments, configuration, stream)
     if arguments.command == "qualify":
-        try:
-            result=Runtime().execute(arguments.target,configuration)
-            capability=arguments.capability[0].replace("-","_") if arguments.capability else None
-            qualification=RuntimeQualificationEngine().qualify(result.evidence,capability)
-            _render({"command":"qualify","runtimeQualification":qualification},arguments.format,stream)
-            return ExitCode.SUCCESS if qualification["level"]!="BLOCKED" else ExitCode.BLOCKED
-        except ValueError as error:
-            _render({"command":"qualify","status":"BLOCKED","reason":str(error)},arguments.format,stream); return ExitCode.BLOCKED
+        return _qualification_command(arguments, configuration, stream)
     if arguments.command == "report":
         return _report_command(arguments, stream)
     if arguments.command == "assure":
@@ -300,13 +306,13 @@ def _execute_command(arguments: argparse.Namespace, configuration: RuntimeConfig
         return ExitCode.SUCCESS if evidence["decision"] == "RELEASE_CERTIFIED" else ExitCode.BLOCKED
     if arguments.command in {"validate", "inspect", "assess", "run"}:
         if arguments.command in {"assess", "run"}:
-            if not arguments.capability:
-                _render({"command": "assess", "status": "NOT_IMPLEMENTED", "reason": "Only code-size and complexity are delivered."}, arguments.format, stream)
+            if arguments.command == "run" and not arguments.capability:
+                _render({"command": "assess", "status": "NOT_SUPPORTED", "reason": "assess requires an explicit capability."}, arguments.format, stream)
                 return ExitCode.NOT_SUPPORTED
         try:
             store = EvidenceStore(_store_location(arguments, arguments.target)) if arguments.command in {"assess", "run"} else None
             code, payload = _runtime_result(arguments.command, arguments.target, configuration, store)
-        except (ValueError, OSError, json.JSONDecodeError) as error:
+        except (PolicyError, ValueError, OSError, json.JSONDecodeError) as error:
             _render({"status": "BLOCKED", "reason": str(error)}, arguments.format, stream)
             return ExitCode.BLOCKED
         _render(payload, arguments.format, stream)
@@ -316,6 +322,61 @@ def _execute_command(arguments: argparse.Namespace, configuration: RuntimeConfig
     return ExitCode.NOT_SUPPORTED
 
 
+def _differential_command(arguments, configuration, stream):
+    location = configuration.execution_options.get("baseline", {}).get("location", ".tde/baselines")
+    registry = AssessmentBaselineRegistry(Path(arguments.target) / location if not Path(location).is_absolute() else location)
+    store = EvidenceStore(_store_location(arguments, arguments.target))
+    try:
+        if not arguments.baseline:
+            raise DifferentialError("diff requires --baseline")
+        current = Runtime().execute(arguments.target, configuration)
+        current_record = store.persist(current.evidence)
+        baseline = registry.load(arguments.baseline)
+        previous = store.retrieve(baseline["assessmentEvidenceId"].removeprefix("sha256:"))["evidence"]
+        differential = DifferentialEngine().compare(current.evidence, baseline, previous)
+        _render({"command": "diff", "baseline": baseline, "assessmentEvidenceStore": current_record,
+                 "assessmentEvidence": current.evidence, "differentialEvidence": differential}, arguments.format, stream)
+        return _policy_exit_code(current.evidence["assessmentDecision"]["decision"])
+    except (DifferentialError, ValueError, OSError, json.JSONDecodeError) as error:
+        _render({"command": "diff", "status": "BLOCKED", "reason": str(error)}, arguments.format, stream)
+        return ExitCode.BLOCKED
+
+
+def _qualification_command(arguments: argparse.Namespace, configuration: RuntimeConfiguration, stream: TextIO) -> int:
+    """Run a profile-driven assessment and register its separate qualification result."""
+    try:
+        definition = RepositoryDefinitionRegistry().resolve(arguments.target, arguments.repository_definition)
+        profile = arguments.profile or definition["defaultAssessmentProfile"]
+        configuration = AssessmentOrchestrator().configure(
+            configuration, profile=profile,
+            capabilities=tuple(item.replace("-", "_") for item in arguments.capability),
+        )
+        target = str(definition["repositoryRoot"])
+        result = Runtime().execute(target, configuration)
+        qualification = RepositoryQualification.create(definition, result.evidence)
+        assessment_record = EvidenceStore(_store_location(arguments, target)).persist(result.evidence)
+        registry_record = QualificationRegistry(_qualification_location(arguments, target)).persist(qualification)
+        payload = {"command": "qualify", "repositoryQualification": qualification,
+                   "qualificationRegistry": registry_record, "assessmentEvidence": result.evidence,
+                   "assessmentEvidenceStore": assessment_record}
+        statuses = {item.get("status") for item in result.evidence.get("capabilityResults", [])}
+        if "NOT_SUPPORTED" in statuses:
+            code = ExitCode.NOT_SUPPORTED
+        elif "ANALYZER_NOT_FOUND" in statuses:
+            code = ExitCode.ANALYZER_NOT_FOUND
+        elif "FAILED_CLOSED" in statuses:
+            code = ExitCode.FAILED_CLOSED
+        elif qualification["qualificationStatus"] == "BLOCKED":
+            code = ExitCode.EXECUTION_ERROR
+        else:
+            code = _policy_exit_code(qualification["assessmentDecision"])
+        _render(payload, arguments.format, stream)
+        return code
+    except (RepositoryQualificationError, PolicyError, ValueError, OSError, json.JSONDecodeError) as error:
+        _render({"command": "qualify", "status": "BLOCKED", "reason": str(error)}, arguments.format, stream)
+        return ExitCode.BLOCKED
+
+
 def _baseline_command(arguments: argparse.Namespace, configuration: RuntimeConfiguration, stream: TextIO) -> int:
     location = configuration.execution_options.get("baseline", {}).get("location", ".tde/baselines")
     repository = BaselineRepository(Path(arguments.target) / location if not Path(location).is_absolute() else location)
@@ -332,7 +393,7 @@ def _baseline_command(arguments: argparse.Namespace, configuration: RuntimeConfi
 
 
 def _create_baseline(arguments, repository, evidence, persisted, stream):
-    baseline = repository.create(evidence, arguments.name)
+    baseline = AssessmentBaselineRegistry(repository.location).create(evidence, arguments.name)
     _render({"command": "baseline", "status": "VALID", "evidenceStore": persisted, "baseline": baseline}, arguments.format, stream)
     return ExitCode.SUCCESS
 
@@ -340,6 +401,9 @@ def _create_baseline(arguments, repository, evidence, persisted, stream):
 def _compare_baseline(arguments, repository, current, evidence, persisted, stream):
     if not arguments.baseline: raise BaselineError("compare requires --baseline")
     baseline = repository.load(arguments.baseline)
+    if "evidence" not in baseline:
+        baseline = {**baseline, "evidence": EvidenceStore(_store_location(arguments, arguments.target)).retrieve(
+            baseline["assessmentEvidenceId"].removeprefix("sha256:"))["evidence"]}
     comparison = ComparisonEngine().compare(evidence, baseline)
     policy = PolicyEngine().load(current.context.configuration, current.context.repository_root, current.context.runtime_version, current.context.schema_version)
     normalized = {"measurements": evidence["measurements"], "findings": evidence["findings"], "capabilityResults": evidence["capabilityResults"], "comparison": comparison}

{technical_debt_engine_runtime-0.1.0 → technical_debt_engine_runtime-0.2.0}/src/tde_runtime/__init__.py

@@ -2,5 +2,6 @@
 
 from .configuration import RuntimeConfiguration
 from .runtime import Runtime
+from .assessment import AssessmentOrchestrator
 
-__all__ = ["Runtime", "RuntimeConfiguration"]
+__all__ = ["AssessmentOrchestrator", "Runtime", "RuntimeConfiguration"]

technical_debt_engine_runtime-0.2.0/src/tde_runtime/analyzer_discovery.py

@@ -0,0 +1,21 @@
+"""Generic executable discovery for Runtime analyzer adapters."""
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+from typing import Any
+
+
+def discover(executable_name: str, minimum_version: tuple[int, int], timeout: int) -> dict[str, Any]:
+    executable = shutil.which(executable_name)
+    if not executable:
+        return {"status": "ANALYZER_NOT_FOUND", "limitation": {"id": f"analyzer.{executable_name}.unavailable", "description": f"{executable_name} is not on PATH.", "cause": "analyzer unavailable"}}
+    try:
+        version = subprocess.run([executable, "--version"], capture_output=True, text=True, timeout=timeout, check=True).stdout.strip()
+    except (subprocess.TimeoutExpired, subprocess.CalledProcessError) as error:
+        return {"status": "FAILED_CLOSED", "limitation": {"id": f"analyzer.{executable_name}.discovery_failed", "description": str(error), "cause": "analyzer discovery failed"}}
+    match = re.search(r"(\d+)\.(\d+)", version)
+    if not match or tuple(map(int, match.groups())) < minimum_version:
+        return {"status": "ANALYZER_NOT_FOUND", "limitation": {"id": f"analyzer.{executable_name}.unsupported_version", "description": f"{executable_name} {minimum_version[0]}.{minimum_version[1]}+ is required; found {version or 'unknown'}.", "cause": "unsupported analyzer version"}}
+    return {"status": "VALID", "executable": executable, "version": version}

technical_debt_engine_runtime-0.2.0/src/tde_runtime/assessment.py

@@ -0,0 +1,33 @@
+"""Profile-driven assessment orchestration without analyzer knowledge."""
+
+from __future__ import annotations
+
+from .configuration import RuntimeConfiguration
+from .registries import AssessmentProfileRegistry
+
+
+class AssessmentError(ValueError):
+    """Raised when an assessment cannot be planned from registered profiles."""
+
+
+class AssessmentOrchestrator:
+    """Selects the assessment capability set before the Runtime executes it."""
+
+    def __init__(self, profiles: AssessmentProfileRegistry | None = None) -> None:
+        self._profiles = profiles or AssessmentProfileRegistry()
+
+    def configure(self, configuration: RuntimeConfiguration, *, profile: str | None = None,
+                  capabilities: tuple[str, ...] = ()) -> RuntimeConfiguration:
+        if capabilities:
+            return configuration.with_assessment_profile("explicit", capabilities)
+        try:
+            selected = self._profiles.resolve(profile)
+        except ValueError as error:
+            raise AssessmentError(str(error)) from error
+        if selected is None:
+            label = profile if profile is not None else "default"
+            raise AssessmentError(f"assessment profile is not registered: {label}")
+        capabilities = tuple(item["identifier"] for item in selected["capabilities"])
+        return configuration.with_assessment_profile(str(selected["identifier"]), capabilities,
+                                                     identity=dict(selected["identity"]),
+                                                     policy_file=str(selected["policyFile"]))

{technical_debt_engine_runtime-0.1.0 → technical_debt_engine_runtime-0.2.0}/src/tde_runtime/baseline.py

@@ -47,9 +47,12 @@ class BaselineRepository:
             value = json.loads(path.read_text(encoding="utf-8"))
         except (OSError, json.JSONDecodeError) as error:
             raise BaselineError(f"cannot load baseline {reference}: {error}") from error
-        if not isinstance(value, dict) or "evidence" not in value:
-            raise BaselineError("baseline does not contain canonical evidence")
-        self._validate_evidence(value["evidence"])
+        if not isinstance(value, dict):
+            raise BaselineError("baseline is malformed")
+        if "evidence" in value:
+            self._validate_evidence(value["evidence"])
+        elif not {"assessmentEvidenceId", "repositoryId", "baselineId"} <= set(value):
+            raise BaselineError("baseline does not reference canonical evidence")
         return value
 
     @staticmethod

{technical_debt_engine_runtime-0.1.0 → technical_debt_engine_runtime-0.2.0}/src/tde_runtime/code_size.py

@@ -1,10 +1,11 @@
 """Code Size capability adapter backed by an explicitly installed cloc executable."""
 from __future__ import annotations
-import json, re, shutil, subprocess
+import json, subprocess
 from collections import defaultdict
 from hashlib import sha256
 from pathlib import Path
 from typing import Any
+from .analyzer_discovery import discover
 
 CAPABILITY_ID = "code_size"
 CAPABILITY_VERSION = "0.1.0"
@@ -22,19 +23,15 @@ def classify(path: str) -> str:
     return "SOURCE"
 
 def analyze(root: Path, timeout: int = 60) -> dict[str, Any]:
-    executable = shutil.which("cloc")
-    if not executable:
-        return {"status":"BLOCKED", "limitations":[{"id":"analyzer.cloc.unavailable","description":"cloc is not on PATH; install cloc 2.10+.","cause":"analyzer unavailable"}]}
+    discovery = discover("cloc", MINIMUM_ANALYZER_VERSION, timeout)
+    if discovery["status"] != "VALID":
+        return {"status": discovery["status"], "limitations": [discovery["limitation"]]}
     try:
-        version = subprocess.run([executable, "--version"], capture_output=True, text=True, timeout=timeout, check=True).stdout.strip()
-        match = re.search(r"(\d+)\.(\d+)", version)
-        if not match or tuple(map(int, match.groups())) < MINIMUM_ANALYZER_VERSION:
-            return {"status":"BLOCKED", "limitations":[{"id":"analyzer.cloc.unsupported_version","description":f"cloc {MINIMUM_ANALYZER_VERSION[0]}.{MINIMUM_ANALYZER_VERSION[1]}+ is required; found {version or 'unknown'}.","cause":"unsupported analyzer version"}]}
-        result = subprocess.run([executable, "--json", "--by-file", "--quiet", str(root)], capture_output=True, text=True, timeout=timeout, check=True)
+        result = subprocess.run([discovery["executable"], "--json", "--by-file", "--quiet", str(root)], capture_output=True, text=True, timeout=timeout, check=True)
         raw = result.stdout
         data = json.loads(raw)
     except (subprocess.TimeoutExpired, subprocess.CalledProcessError, json.JSONDecodeError) as error:
-        return {"status":"BLOCKED", "limitations":[{"id":"analyzer.cloc.failed","description":str(error),"cause":"analyzer execution failed"}]}
+        return {"status":"FAILED_CLOSED", "limitations":[{"id":"analyzer.cloc.failed","description":str(error),"cause":"analyzer execution failed"}]}
     files, languages = [], defaultdict(lambda: {"files":0,"code":0,"comment":0,"blank":0})
     totals = defaultdict(int)
     entries = ((name, item) for name, item in data.items() if name not in {"header", "SUM"})
@@ -46,4 +43,4 @@ def analyze(root: Path, timeout: int = 60) -> dict[str, Any]:
         for key in ("code","comment","blank"): totals[key] += item[key]
         totals["files"] += 1; totals[category.lower()] += item["code"]
     source = totals["source"]; ratio = totals["test"] / source if source else 0
-    return {"status":"VALID","adapter":{"id":ADAPTER_ID,"version":ADAPTER_VERSION},"analyzer":{"id":"cloc","version":version},"rawOutput":raw,"rawOutputHash":"sha256:"+sha256(raw.encode()).hexdigest(),"files":files,"languages":dict(sorted(languages.items())),"totals":dict(totals),"testToSourceRatio":ratio,"limitations":[{"id":"code_size.logical_lines.unavailable","description":"cloc does not provide logical line counts.","cause":"analyzer limitation"}]}
+    return {"status":"VALID","adapter":{"id":ADAPTER_ID,"version":ADAPTER_VERSION},"analyzer":{"id":"cloc","version":discovery["version"]},"rawOutput":raw,"rawOutputHash":"sha256:"+sha256(raw.encode()).hexdigest(),"files":files,"languages":dict(sorted(languages.items())),"totals":dict(totals),"testToSourceRatio":ratio,"limitations":[{"id":"code_size.logical_lines.unavailable","description":"cloc does not provide logical line counts.","cause":"analyzer limitation"}]}

{technical_debt_engine_runtime-0.1.0 → technical_debt_engine_runtime-0.2.0}/src/tde_runtime/complexity.py

@@ -4,12 +4,11 @@ from __future__ import annotations
 
 import fnmatch
 import json
-import re
-import shutil
 import subprocess
 from hashlib import sha256
 from pathlib import Path
 from typing import Any, Mapping
+from .analyzer_discovery import discover
 
 CAPABILITY_ID = "complexity"
 CAPABILITY_VERSION = "0.1.0"
@@ -59,15 +58,11 @@ def _thresholds(configuration: Mapping[str, Any]) -> dict[str, int]:
 def analyze(root: Path, timeout: int = 60, configuration: Mapping[str, Any] | None = None) -> dict[str, Any]:
     """Execute Radon deterministically and retain native output for evidence."""
     configuration = configuration or {}
-    executable = shutil.which("radon")
-    if not executable:
-        return {"status":"BLOCKED", "limitations":[{"id":"analyzer.radon.unavailable","description":"radon is not on PATH; install Radon 6.0+.","cause":"analyzer unavailable"}]}
+    discovery = discover("radon", MINIMUM_ANALYZER_VERSION, timeout)
+    if discovery["status"] != "VALID":
+        return {"status": discovery["status"], "limitations": [discovery["limitation"]]}
     try:
-        version = subprocess.run([executable, "--version"], capture_output=True, text=True, timeout=timeout, check=True).stdout.strip()
-        match = re.search(r"(\d+)\.(\d+)", version)
-        if not match or tuple(map(int, match.groups())) < MINIMUM_ANALYZER_VERSION:
-            return {"status":"BLOCKED", "limitations":[{"id":"analyzer.radon.unsupported_version","description":f"Radon 6.0+ is required; found {version or 'unknown'}.","cause":"unsupported analyzer version"}]}
-        completed = subprocess.run([executable, "cc", "--json", str(root)], capture_output=True, text=True, timeout=timeout, check=True)
+        completed = subprocess.run([discovery["executable"], "cc", "--json", str(root)], capture_output=True, text=True, timeout=timeout, check=True)
         raw, data = _portable_native_output(root, json.loads(completed.stdout))
     except (FileNotFoundError, subprocess.TimeoutExpired, subprocess.CalledProcessError, json.JSONDecodeError) as error:
         return {"status":"BLOCKED", "limitations":[{"id":"analyzer.radon.failed","description":str(error),"cause":"analyzer execution failed"}]}
@@ -89,4 +84,4 @@ def analyze(root: Path, timeout: int = 60, configuration: Mapping[str, Any] | No
     limitations=[]
     if skipped: limitations.append({"id":"complexity.configuration.ignored","description":f"{skipped} symbol(s) were excluded by Complexity configuration.","cause":"configured exclusion"})
     if not symbols: limitations.append({"id":"complexity.python.no_symbols","description":"Radon found no supported Python symbols after exclusions.","cause":"analyzer capability limitation"})
-    return {"status":"VALID","adapter":{"id":ADAPTER_ID,"version":ADAPTER_VERSION},"analyzer":{"id":"radon","version":version},"rawOutput":raw,"rawOutputHash":"sha256:"+sha256(raw.encode()).hexdigest(),"symbols":symbols,"thresholds":thresholds,"limitations":limitations}
+    return {"status":"VALID","adapter":{"id":ADAPTER_ID,"version":ADAPTER_VERSION},"analyzer":{"id":"radon","version":discovery["version"]},"rawOutput":raw,"rawOutputHash":"sha256:"+sha256(raw.encode()).hexdigest(),"symbols":symbols,"thresholds":thresholds,"limitations":limitations}

{technical_debt_engine_runtime-0.1.0 → technical_debt_engine_runtime-0.2.0}/src/tde_runtime/configuration.py

@@ -56,7 +56,7 @@ class RuntimeConfiguration:
     @classmethod
     def load(cls, values: Mapping[str, Any] | None = None) -> "RuntimeConfiguration":
         values = {} if values is None else dict(values)
-        allowed = {"schemaVersion", "executionOptions", "capabilities", "policy", "baseline", "trend"}
+        allowed = {"schemaVersion", "executionOptions", "capabilities", "policy", "baseline", "trend", "assessment"}
         unknown = set(values) - allowed
         if unknown:
             raise ValueError(f"unsupported runtime configuration: {sorted(unknown)}")
@@ -67,7 +67,7 @@ class RuntimeConfiguration:
         if not isinstance(options, dict):
             raise ValueError("executionOptions must be an object")
         resolved: dict[str, Any] = dict(options)
-        for key in ("capabilities", "policy", "baseline", "trend"):
+        for key in ("capabilities", "policy", "baseline", "trend", "assessment"):
             value = values.get(key, resolved.get(key, {}))
             if not isinstance(value, dict):
                 raise ValueError(f"{key} must be an object")
@@ -104,6 +104,23 @@ class RuntimeConfiguration:
         values["executionOptions"].pop("capabilities", None)
         return self.load(values)
 
+    def with_assessment_profile(self, identifier: str, capabilities: tuple[str, ...], *,
+                                identity: Mapping[str, Any] | None = None,
+                                policy_file: str | None = None) -> "RuntimeConfiguration":
+        values = self.as_dict()
+        assessment = {"profile": identifier, "capabilities": list(capabilities)}
+        if identity:
+            assessment["profileIdentity"] = dict(identity)
+        values["assessment"] = assessment
+        values["executionOptions"].pop("assessment", None)
+        if policy_file and not values["executionOptions"].get("policy", {}).get("file"):
+            values["policy"] = {**values["executionOptions"].get("policy", {}), "file": policy_file}
+            values["executionOptions"].pop("policy", None)
+        configured = self.load(values)
+        for capability in capabilities:
+            configured = configured.with_capability(capability)
+        return configured
+
     def as_dict(self) -> dict[str, Any]:
         return {"schemaVersion": self.schema_version, "executionOptions": self.execution_options or {}}