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

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

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

technical_debt_engine_runtime-1.0.0/README.md

@@ -0,0 +1,44 @@
+# Technical Debt Engine
+
+DJConnect is the primary product. Technical Debt Engine (TDE) is its compact,
+supporting engineering tool for producing reliable pipeline assessment
+decisions through public evidence and CLI contracts.
+
+Generation 2 is the consumer-driven **TDE 1.0 DJConnect Enablement Program**.
+It does not expand TDE into a general platform: its active scope is coverage
+completion, minimal dependency and security evidence, selected DJConnect CI
+consumption, and one integrated `1.0.0` qualification and release. See the
+[roadmap](PRODUCT_ROADMAP.md) and [active backlog](PRODUCT_BACKLOG.md).
+
+Release `0.2.0` is available as the PyPI distribution
+[`technical-debt-engine-runtime`](https://pypi.org/project/technical-debt-engine-runtime/0.2.0/),
+a [GitHub Release](https://github.com/pcvantol/technical-debt-engine/releases/tag/0.2.0),
+and Docker image `docker.io/pcvantol/technical-debt-engine:0.2.0`. The Docker
+OCI index is `sha256:8285a5082eaa1a5ac914b349ddec21c9e02cc4269421774d4f112383bc688ca9`;
+no `latest` tag exists. See the [Runtime Qualification Report](RUNTIME_QUALIFICATION_REPORT_0.2.0.md)
+for the immutable publication evidence and public-runtime validation.
+
+## Product contracts
+
+Consumers integrate only through the public `tde` CLI, configuration, evidence
+schema, exit codes, and stable released contracts—not runtime internals. See
+[INTEGRATION_MODEL.md](INTEGRATION_MODEL.md).
+
+Operational repository assurance is available through `tde assure`; see [SOFTWARE_ASSURANCE.md](SOFTWARE_ASSURANCE.md) for its canonical evidence and candidate-artifact verification contract.
+
+## Documentation
+
+- [Product architecture](PRODUCT_ARCHITECTURE.md)
+- [Platform vision](PLATFORM_VISION.md) and [platform strategy](PLATFORM_STRATEGY.md)
+- [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)
+- [Versioning](VERSIONING.md) and [release strategy](RELEASE_STRATEGY.md)
+- [Package build reproducibility](PACKAGING.md)
+- [Repository status](REPOSITORY_STATUS.md)
+
+The documentation index is [PROMPT_INDEX.md](PROMPT_INDEX.md).

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

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["setuptools==80.9.0"]
+requires = ["setuptools==83.0.0"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "technical-debt-engine-runtime"
-version = "0.2.0"
+version = "1.0.0"
 description = "Technical Debt Engine runtime foundation API"
 requires-python = ">=3.11"
 dependencies = ["radon==6.0.1"]

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

@@ -29,7 +29,7 @@ from tde_runtime.repository_qualification import (QualificationRegistry,
 from tde_runtime.differential import AssessmentBaselineRegistry, DifferentialEngine, DifferentialError
 
 
-CLI_VERSION = "0.2.0"
+CLI_VERSION = "1.0.0"
 GENERATION = "1"
 
 
@@ -265,7 +265,8 @@ def _apply_command_configuration(configuration: RuntimeConfiguration, arguments:
     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"}
+        supported = {"code-size": "code_size", "complexity": "complexity", "coverage": "coverage",
+                     "dependency-health": "dependency_health"}
         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

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

@@ -12,6 +12,7 @@ CAPABILITY_VERSION = "0.1.0"
 ADAPTER_ID = "code_size.cloc"
 ADAPTER_VERSION = "0.1.0"
 MINIMUM_ANALYZER_VERSION = (2, 10)
+EXCLUDED_DIRECTORIES = (".git", ".tde", "__pycache__", ".venv", "venv", "build", "dist", "bin", "obj", ".build", ".swiftpm", ".pio", ".release", ".public-release")
 
 def classify(path: str) -> str:
     value = path.replace("\\", "/").lower()
@@ -27,7 +28,7 @@ def analyze(root: Path, timeout: int = 60) -> dict[str, Any]:
     if discovery["status"] != "VALID":
         return {"status": discovery["status"], "limitations": [discovery["limitation"]]}
     try:
-        result = subprocess.run([discovery["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", f"--exclude-dir={','.join(EXCLUDED_DIRECTORIES)}", 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:

technical_debt_engine_runtime-1.0.0/src/tde_runtime/coverage.py

@@ -0,0 +1,210 @@
+"""Read-only Coverage capability adapters for existing repository artifacts."""
+
+from __future__ import annotations
+
+from hashlib import sha256
+import json
+from pathlib import Path
+import re
+from typing import Any, Mapping
+from xml.etree import ElementTree
+
+CAPABILITY_ID = "coverage"
+CAPABILITY_VERSION = "0.1.0"
+ADAPTER_ID = "coverage.artifact"
+ADAPTER_VERSION = "0.1.0"
+PARSER_VERSION = "1.0.0"
+DEFAULT_LOCATIONS = ("coverage.xml", "coverage/coverage.xml", "reports/coverage.xml", "coverage.json", "coverage/coverage.json", "lcov.info", "coverage/lcov.info", "coverage.info")
+
+
+class CoverageArtifactError(ValueError):
+    """An artifact cannot be trusted as canonical coverage evidence."""
+
+
+def _paths(root: Path, settings: Mapping[str, Any]) -> tuple[Path, ...]:
+    configured: list[str] = []
+    for key in ("path", "artifact", "file"):
+        value = settings.get(key)
+        if isinstance(value, str) and value.strip():
+            configured.append(value)
+    values = settings.get("paths")
+    if isinstance(values, (list, tuple)) and all(isinstance(value, str) and value.strip() for value in values):
+        configured.extend(values)
+    candidates = configured or list(DEFAULT_LOCATIONS)
+    return tuple((Path(candidate) if Path(candidate).is_absolute() else root / candidate) for candidate in candidates)
+
+
+def _metric(covered: int | None, total: int | None) -> dict[str, int | float | None]:
+    if covered is None or total is None:
+        return {"covered": None, "total": None, "percent": None}
+    if covered < 0 or total < 0 or covered > total:
+        raise CoverageArtifactError("coverage totals must be non-negative and covered must not exceed total")
+    return {"covered": covered, "total": total, "percent": (covered / total * 100) if total else 100.0}
+
+
+def _integer(value: str | None, label: str) -> int:
+    try:
+        number = int(value or "")
+    except ValueError as error:
+        raise CoverageArtifactError(f"{label} must be an integer") from error
+    if number < 0:
+        raise CoverageArtifactError(f"{label} must not be negative")
+    return number
+
+
+def _xml_metric(root: ElementTree.Element, names: tuple[str, ...], label: str) -> int | None:
+    for name in names:
+        if name in root.attrib:
+            return _integer(root.attrib[name], label)
+    return None
+
+
+def _rate(root: ElementTree.Element, name: str) -> float | None:
+    if name not in root.attrib:
+        return None
+    try:
+        value = float(root.attrib[name])
+    except ValueError as error:
+        raise CoverageArtifactError(f"{name} must be numeric") from error
+    if not 0 <= value <= 1:
+        raise CoverageArtifactError(f"{name} must be between 0 and 1")
+    return value
+
+
+def _parse_xml(contents: bytes) -> tuple[str, dict[str, Any]]:
+    try:
+        root = ElementTree.fromstring(contents)
+    except ElementTree.ParseError as error:
+        raise CoverageArtifactError(f"invalid XML coverage artifact: {error}") from error
+    if root.tag.rsplit("}", 1)[-1] != "coverage":
+        raise CoverageArtifactError("XML coverage artifact must have a coverage root element")
+    # Cobertura class elements own the repository line set.  Method elements
+    # may repeat those same lines, so a broad ``.//line`` query double-counts
+    # reports emitted by Istanbul and gcovr.
+    lines = root.findall(".//class/lines/line")
+    if not lines:
+        raise CoverageArtifactError("XML coverage artifact contains no line data")
+    line_hits: list[int] = []
+    branches: list[tuple[int, int]] = []
+    for line in lines:
+        number = line.attrib.get("number")
+        hits = _integer(line.attrib.get("hits"), "line hits")
+        if not number:
+            raise CoverageArtifactError("line coverage record has no line number")
+        line_hits.append(hits)
+        condition = line.attrib.get("condition-coverage")
+        if condition:
+            match = re.search(r"\((\d+)\s*/\s*(\d+)\)", condition)
+            if not match:
+                raise CoverageArtifactError("invalid branch condition coverage")
+            branches.append((_integer(match.group(1), "covered branches"), _integer(match.group(2), "total branches")))
+    derived_lines = (sum(hits > 0 for hits in line_hits), len(line_hits))
+    declared_lines = (_xml_metric(root, ("lines-covered",), "lines covered"), _xml_metric(root, ("lines-valid",), "lines valid"))
+    if all(value is not None for value in declared_lines) and declared_lines != derived_lines:
+        raise CoverageArtifactError("declared XML line totals disagree with line data")
+    derived_branches = (sum(value[0] for value in branches), sum(value[1] for value in branches)) if branches else (None, None)
+    declared_branches = (_xml_metric(root, ("branches-covered",), "branches covered"), _xml_metric(root, ("branches-valid",), "branches valid"))
+    # Coverage.py emits a zero/zero branch summary when branch collection was
+    # not enabled.  It is unavailable branch coverage, not 100% coverage.
+    if derived_branches[0] is None and declared_branches == (0, 0):
+        declared_branches = (None, None)
+    # A Cobertura document's root branch summary is the producer's aggregate
+    # metric. Some Istanbul reports expose a narrower line-condition view, so
+    # it can legitimately differ from the root aggregate. The summary is
+    # still self-validated by branch-rate below.
+    line = _metric(*(declared_lines if all(value is not None for value in declared_lines) else derived_lines))
+    branch = _metric(*(declared_branches if all(value is not None for value in declared_branches) else derived_branches))
+    for name, metric in (("line-rate", line), ("branch-rate", branch)):
+        rate = _rate(root, name)
+        if rate is not None and metric["percent"] is not None and abs(rate * 100 - float(metric["percent"])) > 0.01:
+            raise CoverageArtifactError(f"{name} disagrees with coverage totals")
+    # coverage.py emits lines-valid and a numeric major version. Other
+    # Cobertura producers, including c8 and gcovr, use the same attributes.
+    version = root.attrib.get("version", "")
+    parser = "coverage.py-xml" if b"generated by coverage.py" in contents.lower() or ("lines-valid" in root.attrib and re.match(r"^[1-9]\d*(?:\.\d+)*$", version)) else "cobertura-xml"
+    return parser, {"line": line, "branch": branch}
+
+
+def _parse_xccov_json(contents: bytes) -> tuple[str, dict[str, Any]]:
+    """Normalize the summary emitted by ``xcrun xccov view --json``."""
+    try:
+        value = json.loads(contents.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise CoverageArtifactError(f"invalid xccov JSON artifact: {error}") from error
+    if not isinstance(value, dict):
+        raise CoverageArtifactError("xccov JSON artifact must be an object")
+    covered = value.get("coveredLines")
+    total = value.get("executableLines")
+    if not isinstance(covered, int) or not isinstance(total, int):
+        raise CoverageArtifactError("xccov JSON requires integer coveredLines and executableLines")
+    line = _metric(covered, total)
+    declared_rate = value.get("lineCoverage")
+    if not isinstance(declared_rate, (int, float)) or not 0 <= float(declared_rate) <= 1:
+        raise CoverageArtifactError("xccov JSON lineCoverage must be a ratio between 0 and 1")
+    if line["percent"] is not None and abs(float(declared_rate) * 100 - float(line["percent"])) > 0.01:
+        raise CoverageArtifactError("xccov JSON lineCoverage disagrees with line totals")
+    return "xccov-json", {"line": line, "branch": _metric(None, None)}
+
+
+def _parse_lcov(contents: bytes) -> tuple[str, dict[str, Any]]:
+    try:
+        rows = contents.decode("utf-8").splitlines()
+    except UnicodeDecodeError as error:
+        raise CoverageArtifactError("LCOV artifact is not UTF-8") from error
+    lines: dict[tuple[str, str], int] = {}
+    branches: dict[tuple[str, str, str, str], int] = {}
+    source: str | None = None
+    for raw in rows:
+        row = raw.strip()
+        if not row or row == "end_of_record":
+            continue
+        if row.startswith("SF:"):
+            source = row[3:] or None
+            if source is None:
+                raise CoverageArtifactError("LCOV source file is empty")
+        elif row.startswith("DA:"):
+            if source is None:
+                raise CoverageArtifactError("LCOV line record precedes source file")
+            parts = row[3:].split(",")
+            if len(parts) < 2:
+                raise CoverageArtifactError("invalid LCOV line record")
+            key = (source, parts[0]); hits = _integer(parts[1], "LCOV line hits")
+            if key in lines and lines[key] != hits:
+                raise CoverageArtifactError("duplicate LCOV line records disagree")
+            lines[key] = hits
+        elif row.startswith("BRDA:"):
+            if source is None:
+                raise CoverageArtifactError("LCOV branch record precedes source file")
+            parts = row[5:].split(",")
+            if len(parts) != 4:
+                raise CoverageArtifactError("invalid LCOV branch record")
+            key = (source, *parts[:3]); taken = 0 if parts[3] == "-" else _integer(parts[3], "LCOV branch hits")
+            if key in branches and branches[key] != taken:
+                raise CoverageArtifactError("duplicate LCOV branch records disagree")
+            branches[key] = taken
+    if not lines:
+        raise CoverageArtifactError("LCOV artifact contains no line data")
+    return "lcov", {"line": _metric(sum(value > 0 for value in lines.values()), len(lines)),
+                     "branch": _metric(sum(value > 0 for value in branches.values()), len(branches)) if branches else _metric(None, None)}
+
+
+def analyze(root: Path, settings: Mapping[str, Any] | None = None) -> dict[str, Any]:
+    """Discover, validate, and normalize one pre-existing coverage artifact."""
+    settings = settings or {}
+    artifact = next((path for path in _paths(root, settings) if path.is_file()), None)
+    if artifact is None:
+        return {"status": "VALID", "available": False, "limitations": [{"id": "coverage.artifact.unavailable", "description": "No coverage artifact was found in configured or standard locations.", "cause": "artifact unavailable"}]}
+    try:
+        contents = artifact.read_bytes()
+        if artifact.suffix.lower() in {".info", ".lcov"} or artifact.name == "lcov.info":
+            parser, metrics = _parse_lcov(contents)
+        elif artifact.suffix.lower() == ".json":
+            parser, metrics = _parse_xccov_json(contents)
+        else:
+            parser, metrics = _parse_xml(contents)
+    except (OSError, CoverageArtifactError) as error:
+        return {"status": "FAILED_CLOSED", "limitations": [{"id": "coverage.artifact.invalid", "description": str(error), "cause": "invalid coverage artifact", "blocking": True}]}
+    return {"status": "VALID", "available": True, "parser": parser, "parserVersion": PARSER_VERSION,
+            "sourceFormat": "lcov" if parser == "lcov" else "json" if parser == "xccov-json" else "xml", "artifact": artifact.relative_to(root).as_posix() if artifact.is_relative_to(root) else artifact.name,
+            "rawOutput": contents.decode("utf-8", errors="replace"), "rawOutputHash": "sha256:" + sha256(contents).hexdigest(),
+            "metrics": metrics, "limitations": []}

technical_debt_engine_runtime-1.0.0/src/tde_runtime/dependency_health.py

@@ -0,0 +1,173 @@
+"""Consumer-driven dependency-health normalization for DJConnect repositories."""
+
+from __future__ import annotations
+
+import fnmatch
+from hashlib import sha256
+import json
+import os
+from pathlib import Path
+import re
+import shutil
+import subprocess
+import tomllib
+from typing import Any
+import xml.etree.ElementTree as ET
+
+
+ADAPTER_ID = "dependency_health.platform"
+ADAPTER_VERSION = "1.0.0"
+CAPABILITY_ID = "dependency_health"
+CAPABILITY_VERSION = "1.0.0"
+
+
+def analyze(root: Path, timeout: int) -> dict[str, Any]:
+    """Normalize only package ecosystems actually present in a repository."""
+    records = []
+    if (root / "package.json").is_file(): records.append(_npm(root, timeout))
+    python = _python(root, timeout)
+    if python is not None: records.append(python)
+    nuget = _nuget(root, timeout)
+    if nuget is not None: records.append(nuget)
+    if (root / "platformio.ini").is_file(): records.append(_platformio(root, timeout))
+    if (root / "Package.swift").is_file(): records.append(_swift(root, timeout))
+    if not records:
+        return _unavailable("no supported dependency manifest was found")
+    limitations = [item for record in records for item in record["limitations"]]
+    if any(item["blocking"] for item in limitations):
+        return {"status": "BLOCKED", "limitations": limitations}
+    raw = "\n".join(item["rawOutput"] for item in records)
+    return {"status": "VALID", "ecosystems": records, "rawOutput": raw,
+            "rawOutputHash": "sha256:" + sha256(raw.encode()).hexdigest(),
+            "limitations": limitations}
+
+
+def _npm(root: Path, timeout: int) -> dict[str, Any]:
+    package, lock = root / "package.json", root / "package-lock.json"
+    try:
+        manifest = json.loads(package.read_text(encoding="utf-8"))
+        lock_data = json.loads(lock.read_text(encoding="utf-8")) if lock.is_file() else {}
+    except (OSError, json.JSONDecodeError) as error:
+        return _blocked("npm", "npm", str(error))
+    direct = _npm_direct(manifest); packages = lock_data.get("packages", {})
+    if not isinstance(packages, dict): packages = {}
+    resolved = sorted(path.removeprefix("node_modules/") for path in packages if path.startswith("node_modules/"))
+    unknown = sorted(name for name in direct if lock.is_file() and f"node_modules/{name}" not in packages)
+    outdated, analyzer, raw, limitations = _outdated_command("npm", ["npm", "outdated", "--json", "--package-lock-only"], root, timeout)
+    return _record("npm", "npm", direct, [name for name in resolved if name not in direct], unknown, outdated, analyzer, raw, limitations)
+
+
+def _python(root: Path, timeout: int) -> dict[str, Any] | None:
+    requirements = _manifest_files(root, "requirements*.txt")
+    pyproject = root / "pyproject.toml"
+    if not requirements and not pyproject.is_file(): return None
+    direct: dict[str, str] = {}
+    for path in requirements:
+        for line in path.read_text(encoding="utf-8").splitlines():
+            match = re.match(r"^\s*([A-Za-z0-9_.-]+)\s*(.*)$", line)
+            if match and not line.lstrip().startswith(("#", "-")): direct[match.group(1)] = match.group(2).strip()
+    if pyproject.is_file():
+        try:
+            data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
+            for requirement in data.get("project", {}).get("dependencies", []):
+                match = re.match(r"^\s*([A-Za-z0-9_.-]+)\s*(.*)$", requirement)
+                if match: direct[match.group(1)] = match.group(2).strip()
+        except (OSError, tomllib.TOMLDecodeError) as error: return _blocked("PyPI", "pip", str(error))
+    pip = shutil.which("pip") or shutil.which("pip3")
+    if not pip: return _record("PyPI", "pip", sorted(direct), None, None, None, {"id": "pip", "version": "UNAVAILABLE"}, "", [_limitation("dependency_health.pip.unavailable", "pip was not found on PATH")])
+    version = _version(pip, root, timeout); outdated, raw, limitations = [], [], []
+    for name, constraint in sorted(direct.items()):
+        if not constraint.startswith("=="):
+            outdated = None; limitations.append(_limitation("dependency_health.python.outdated.unavailable", f"{name} is not pinned")); continue
+        try:
+            completed = subprocess.run([pip, "index", "versions", name], cwd=root, capture_output=True, text=True, timeout=timeout, check=True)
+            raw.append(completed.stdout); latest = re.search(r"Available versions:\s*([^,\s]+)", completed.stdout)
+            if latest and latest.group(1) != constraint[2:]: outdated.append(name)
+        except (OSError, subprocess.SubprocessError) as error:
+            outdated = None; limitations.append(_limitation("dependency_health.python.outdated.unavailable", str(error)))
+    return _record("PyPI", "pip", sorted(direct), None, None, outdated, {"id": "pip", "version": version}, "".join(raw), limitations)
+
+
+def _nuget(root: Path, timeout: int) -> dict[str, Any] | None:
+    projects = _manifest_files(root, "*.csproj")
+    if not projects: return None
+    direct = []
+    for project in projects:
+        try: direct.extend(item.attrib["Include"] for item in ET.parse(project).iter() if item.tag.endswith("PackageReference") and "Include" in item.attrib)
+        except (ET.ParseError, OSError) as error: return _blocked("NuGet", "dotnet", str(error))
+    dotnet = shutil.which("dotnet")
+    if not dotnet: return _record("NuGet", "dotnet", sorted(set(direct)), None, None, None, {"id": "dotnet", "version": "UNAVAILABLE"}, "", [_limitation("dependency_health.dotnet.unavailable", "dotnet was not found on PATH")])
+    raw, outdated, transitive, limitations = [], [], [], []
+    for project in projects:
+        try:
+            completed = subprocess.run([dotnet, "package", "list", "--project", str(project), "--outdated", "--include-transitive", "--format", "json"], cwd=root, capture_output=True, text=True, timeout=timeout, check=False)
+            raw.append(completed.stdout); payload = json.loads(completed.stdout or "{}")
+            problems = payload.get("problems", [])
+            errors = [item.get("text", "NuGet analysis failed") for item in problems if item.get("level") == "error"]
+            if completed.returncode != 0 or errors:
+                detail = "; ".join(errors) or completed.stderr.strip() or f"dotnet exited with status {completed.returncode}"
+                return _analysis_failed("NuGet", "dotnet", f"{project}: {detail}")
+            for project_data in payload.get("projects", []):
+                for framework in project_data.get("frameworks", []):
+                    outdated.extend(item["id"] for item in framework.get("topLevelPackages", []) if item.get("latestVersion"))
+                    outdated.extend(item["id"] for item in framework.get("transitivePackages", []) if item.get("latestVersion"))
+                    transitive.extend(item["id"] for item in framework.get("transitivePackages", []) if item.get("id"))
+        except (OSError, subprocess.SubprocessError, json.JSONDecodeError) as error:
+            outdated = None; transitive = None; limitations.append(_limitation("dependency_health.nuget.outdated.unavailable", str(error)))
+    return _record("NuGet", "dotnet", sorted(set(direct)), None if transitive is None else sorted(set(transitive) - set(direct)), None, None if outdated is None else sorted(set(outdated)), {"id": "dotnet", "version": _version(dotnet, root, timeout)}, "".join(raw), limitations)
+
+
+def _platformio(root: Path, timeout: int) -> dict[str, Any]:
+    direct = []
+    lines = (root / "platformio.ini").read_text(encoding="utf-8").splitlines(); in_deps = False
+    for line in lines:
+        if line.strip().startswith("lib_deps"): in_deps = True; continue
+        if in_deps and line and not line[0].isspace(): in_deps = False
+        if in_deps and line.strip(): direct.append(line.strip().split("@")[0])
+    pio = shutil.which("pio")
+    if not pio: return _record("PlatformIO", "PlatformIO", direct, None, None, None, {"id": "pio", "version": "UNAVAILABLE"}, "", [_limitation("dependency_health.platformio.unavailable", "pio was not found on PATH")])
+    try:
+        completed = subprocess.run([pio, "pkg", "outdated", "-d", str(root)], cwd=root, capture_output=True, text=True, timeout=timeout, check=False)
+        raw = completed.stdout + completed.stderr
+        outdated = [line.split()[0] for line in raw.splitlines() if re.match(r"^[A-Za-z0-9_.-]+\s+\d", line) and len(line.split()) >= 4 and line.split()[1] != line.split()[3]]
+        return _record("PlatformIO", "PlatformIO", sorted(direct), None, None, sorted(set(outdated)), {"id": "pio", "version": _version(pio, root, timeout)}, raw, [])
+    except (OSError, subprocess.SubprocessError) as error: return _record("PlatformIO", "PlatformIO", sorted(direct), None, None, None, {"id": "pio", "version": "UNAVAILABLE"}, "", [_limitation("dependency_health.platformio.outdated.unavailable", str(error))])
+
+
+def _swift(root: Path, timeout: int) -> dict[str, Any]:
+    contents = (root / "Package.swift").read_text(encoding="utf-8")
+    direct = re.findall(r"\.package\([^\n]*?(?:url|path):\s*\"([^\"]+)", contents)
+    analyzer = {"id": "swift", "version": "NOT_REQUIRED"}
+    limitations = [] if not direct else [_limitation("dependency_health.swift.outdated.unavailable", "SwiftPM has no non-mutating outdated command")]
+    return _record("SwiftPM", "SwiftPM", sorted(direct), None, None, [] if not direct else None, analyzer, "", limitations)
+
+
+def _record(ecosystem: str, manager: str, direct: list[str], transitive: list[str] | None, unknown: list[str] | None, outdated: list[str] | None, analyzer: dict[str, str], raw: str, limitations: list[dict[str, Any]]) -> dict[str, Any]:
+    return {"ecosystem": ecosystem, "packageManager": manager, "directDependencies": direct, "transitiveDependencies": transitive, "unknownDependencies": unknown, "outdatedDependencies": outdated, "analyzer": analyzer, "rawOutput": raw, "limitations": limitations}
+
+
+def _blocked(ecosystem: str, manager: str, reason: str) -> dict[str, Any]: return _record(ecosystem, manager, [], None, None, None, {"id": manager, "version": "UNAVAILABLE"}, "", [_limitation("dependency_health.manifest.invalid", reason, True)])
+def _analysis_failed(ecosystem: str, manager: str, reason: str) -> dict[str, Any]: return _record(ecosystem, manager, [], None, None, None, {"id": manager, "version": "UNAVAILABLE"}, "", [_limitation(f"dependency_health.{manager}.analysis.failed", reason, True)])
+def _unavailable(reason: str) -> dict[str, Any]: return {"status": "VALID", "ecosystems": [], "rawOutput": "", "rawOutputHash": "sha256:" + sha256(b"").hexdigest(), "limitations": [_limitation("dependency_health.ecosystem.unavailable", reason)] , "available": False}
+def _limitation(identifier: str, description: str, blocking: bool = False) -> dict[str, Any]: return {"id": identifier, "description": description, "cause": "dependency health", "blocking": blocking}
+def _version(executable: str, root: Path, timeout: int) -> str:
+    try: return subprocess.run([executable, "--version"], cwd=root, capture_output=True, text=True, timeout=timeout, check=True).stdout.strip().splitlines()[0]
+    except (OSError, subprocess.SubprocessError): return "UNAVAILABLE"
+def _npm_direct(manifest: dict[str, Any]) -> list[str]: return sorted({name for key in ("dependencies", "devDependencies", "optionalDependencies", "peerDependencies") for name in manifest.get(key, {}) if isinstance(manifest.get(key), dict)})
+def _outdated_command(name: str, command: list[str], root: Path, timeout: int) -> tuple[list[str] | None, dict[str, str], str, list[dict[str, Any]]]:
+    executable = shutil.which(name)
+    if not executable: return None, {"id": name, "version": "UNAVAILABLE"}, "", [_limitation(f"dependency_health.{name}.unavailable", f"{name} was not found on PATH")]
+    try:
+        completed = subprocess.run([executable, *command[1:]], cwd=root, capture_output=True, text=True, timeout=timeout, check=False); raw = completed.stdout or "{}"; parsed = json.loads(raw)
+        return sorted(parsed) if isinstance(parsed, dict) else None, {"id": name, "version": _version(executable, root, timeout)}, raw, []
+    except (OSError, subprocess.SubprocessError, json.JSONDecodeError) as error: return None, {"id": name, "version": "UNAVAILABLE"}, "", [_limitation(f"dependency_health.{name}.outdated.unavailable", str(error))]
+def _manifest_files(root: Path, pattern: str) -> list[Path]:
+    manifests = []
+    for directory, names, files in os.walk(root):
+        names[:] = [name for name in names if not _ignored_directory(name)]
+        manifests.extend(Path(directory, name) for name in files if fnmatch.fnmatch(name, pattern))
+    return sorted(manifests)
+
+
+def _ignored_directory(name: str) -> bool:
+    return name in {".git", "node_modules", "dist", "build", ".venv", "venv", ".build", ".swiftpm", ".pio", ".release", ".public-release"} or name.startswith(".xcode-derived")

{technical_debt_engine_runtime-0.2.0 → technical_debt_engine_runtime-1.0.0}/src/tde_runtime/execution.py

@@ -8,7 +8,8 @@ from hashlib import sha256
 
 from .code_size import ADAPTER_ID, CAPABILITY_ID, CAPABILITY_VERSION, analyze
 from .complexity import ADAPTER_ID as COMPLEXITY_ADAPTER_ID, CAPABILITY_ID as COMPLEXITY_CAPABILITY_ID, CAPABILITY_VERSION as COMPLEXITY_CAPABILITY_VERSION, analyze as analyze_complexity
-from .dependency_health import CAPABILITY_ID as DEPENDENCY_CAPABILITY_ID, CAPABILITY_VERSION as DEPENDENCY_CAPABILITY_VERSION, discover as discover_dependencies
+from .coverage import ADAPTER_ID as COVERAGE_ADAPTER_ID, CAPABILITY_ID as COVERAGE_CAPABILITY_ID, CAPABILITY_VERSION as COVERAGE_CAPABILITY_VERSION, analyze as analyze_coverage
+from .dependency_health import ADAPTER_ID as DEPENDENCY_ADAPTER_ID, CAPABILITY_ID as DEPENDENCY_CAPABILITY_ID, CAPABILITY_VERSION as DEPENDENCY_CAPABILITY_VERSION, analyze as analyze_dependencies
 from .maintainability import CAPABILITY_ID as MAINTAINABILITY_CAPABILITY_ID, CAPABILITY_VERSION as MAINTAINABILITY_CAPABILITY_VERSION, derive as derive_maintainability
 from .registries import AdapterRegistry, CapabilityRegistry
 
@@ -112,13 +113,19 @@ class CapabilityExecutionEngine:
             if result["status"] != "VALID":
                 return self._blocked(COMPLEXITY_CAPABILITY_ID, COMPLEXITY_CAPABILITY_VERSION, [COMPLEXITY_ADAPTER_ID], result["limitations"], duration)
             return self._complexity_result(context, result, duration)
-        if identifier == DEPENDENCY_CAPABILITY_ID:
-            result = discover_dependencies(context.repository_root)
+        if identifier == COVERAGE_CAPABILITY_ID and selected_adapter == COVERAGE_ADAPTER_ID:
+            settings = context.execution_options.get("capabilities", {}).get(COVERAGE_CAPABILITY_ID, {})
+            result = analyze_coverage(context.repository_root, settings)
             duration = int((perf_counter() - started) * 1000)
-            capability = {"capabilityId": DEPENDENCY_CAPABILITY_ID, "capabilityVersion": DEPENDENCY_CAPABILITY_VERSION,
-                          "status": "VALID", "adapterIds": [], "completeness": 1, "qualificationApplicable": True,
-                          "executionTiming": {"durationMs": duration}}
-            return {"measurements": result["measurements"], "findings": result["findings"], "capabilityResults": [capability]}
+            if result["status"] != "VALID":
+                return self._blocked(COVERAGE_CAPABILITY_ID, COVERAGE_CAPABILITY_VERSION, [COVERAGE_ADAPTER_ID], result["limitations"], duration, result["status"])
+            return self._coverage_result(context, result, duration)
+        if identifier == DEPENDENCY_CAPABILITY_ID and selected_adapter == DEPENDENCY_ADAPTER_ID:
+            result = analyze_dependencies(context.repository_root, timeout)
+            duration = int((perf_counter() - started) * 1000)
+            if result["status"] != "VALID":
+                return self._blocked(DEPENDENCY_CAPABILITY_ID, DEPENDENCY_CAPABILITY_VERSION, [DEPENDENCY_ADAPTER_ID], result["limitations"], duration)
+            return self._dependency_result(context, result, duration)
         if identifier != MAINTAINABILITY_CAPABILITY_ID:
             return self._blocked(identifier, "0.1.0", [], [{"id": "adapter.selection.unavailable", "description": f"no selected adapter can execute {identifier}", "cause": "adapter selection"}], 0)
         code = {"measurements": measurements}
@@ -231,3 +238,50 @@ class CapabilityExecutionEngine:
         adapter = {"adapter":result["adapter"],"analyzer":result["analyzer"],"execution":"SUCCESS","rawOutputHash":result["rawOutputHash"],"rawOutput":result["rawOutput"],"measuredScope":["repository","language","file","symbol"],"completeness":1,"draftMeasurements":measurements,"draftFindings":findings,"warnings":[],"errors":[],"limitations":result["limitations"],"executionTiming":{"durationMs":duration}}
         capability = {"capabilityId":COMPLEXITY_CAPABILITY_ID,"capabilityVersion":COMPLEXITY_CAPABILITY_VERSION,"status":"VALID","adapterIds":[COMPLEXITY_ADAPTER_ID],"completeness":1,"qualificationApplicable":True,"limitations":result["limitations"],"executionTiming":{"durationMs":duration}}
         return {"measurements":measurements,"findings":findings,"adapterResults":[adapter],"capabilityResults":[capability]}
+
+    @staticmethod
+    def _coverage_result(context: Any, result: dict[str, Any], duration: int) -> dict[str, Any]:
+        measurements = []
+        for kind, label, coverage_key in (("line", "lines", "line_coverage"), ("branch", "branches", "branch_coverage")):
+            values = result.get("metrics", {}).get(kind, {"covered": None, "total": None, "percent": None})
+            for field, suffix, unit, aggregation in (("percent", coverage_key, "percent", "ratio"), ("covered", f"covered_{label}", label, "sum"), ("total", f"total_{label}", label, "sum")):
+                measurements.append({"measurementId": f"coverage.repository.{suffix}", "capabilityId": COVERAGE_CAPABILITY_ID,
+                                     "metricKey": f"coverage.{suffix}", "value": values[field], "availability": "AVAILABLE" if values[field] is not None else "UNAVAILABLE",
+                                     "unit": unit, "scope": "repository", "targetEntityId": context.repository_id, "aggregation": aggregation,
+                                     "sourceAdapterId": COVERAGE_ADAPTER_ID, "sourceToolId": result.get("parser", "coverage-artifact")})
+        adapter = {"adapter": {"id": COVERAGE_ADAPTER_ID, "version": "0.1.0"},
+                   "analyzer": {"id": result.get("parser", "coverage-artifact"), "version": result.get("parserVersion", "1.0.0")},
+                   "execution": "SUCCESS", "rawOutputHash": result.get("rawOutputHash"), "rawOutput": result.get("rawOutput"),
+                   "measuredScope": ["repository"], "completeness": 1,
+                   "draftMeasurements": measurements, "draftFindings": [], "warnings": [], "errors": [], "limitations": result["limitations"],
+                   "evidence": {"parser": result.get("parser"), "parserVersion": result.get("parserVersion"), "sourceFormat": result.get("sourceFormat"), "artifact": result.get("artifact"), "metrics": result.get("metrics")},
+                   "executionTiming": {"durationMs": duration}}
+        capability = {"capabilityId": COVERAGE_CAPABILITY_ID, "capabilityVersion": COVERAGE_CAPABILITY_VERSION, "status": "VALID",
+                      "adapterIds": [COVERAGE_ADAPTER_ID], "completeness": 1,
+                      "qualificationApplicable": bool(result["available"]), "limitations": result["limitations"], "executionTiming": {"durationMs": duration}}
+        return {"measurements": measurements, "findings": [], "adapterResults": [adapter], "capabilityResults": [capability]}
+
+    @staticmethod
+    def _dependency_result(context: Any, result: dict[str, Any], duration: int) -> dict[str, Any]:
+        measurements = []
+        records = result["ecosystems"] or [{"ecosystem": "unavailable", "directDependencies": None, "transitiveDependencies": None,
+                                               "unknownDependencies": None, "outdatedDependencies": None,
+                                               "analyzer": {"id": "unavailable", "version": "UNAVAILABLE"}}]
+        for record in records:
+            values = (("dependency_count", None if record["directDependencies"] is None or record["transitiveDependencies"] is None else record["directDependencies"] + record["transitiveDependencies"]),
+                      ("direct_dependencies", record["directDependencies"]), ("transitive_dependencies", record["transitiveDependencies"]),
+                      ("unknown_dependencies", record["unknownDependencies"]), ("outdated_dependencies", record["outdatedDependencies"]))
+            ecosystem = record["ecosystem"].lower().replace(" ", "_")
+            measurements.extend({"measurementId": f"dependency_health.{ecosystem}.{key}", "capabilityId": DEPENDENCY_CAPABILITY_ID,
+                                 "metricKey": f"dependency_health.{key}", "value": None if value is None else len(value),
+                                 "availability": "UNAVAILABLE" if value is None else "AVAILABLE", "unit": "packages", "scope": "ecosystem",
+                                 "targetEntityId": f"ecosystem.{ecosystem}", "aggregation": "count", "sourceAdapterId": DEPENDENCY_ADAPTER_ID,
+                                 "sourceToolId": record["analyzer"]["id"]} for key, value in values)
+        adapter = {"adapter": {"id": DEPENDENCY_ADAPTER_ID, "version": "1.0.0"}, "analyzer": {"id": "platform", "version": "1.0.0"}, "execution": "SUCCESS",
+                   "rawOutputHash": result["rawOutputHash"], "rawOutput": result["rawOutput"], "measuredScope": ["repository"], "completeness": 1,
+                   "draftMeasurements": measurements, "draftFindings": [], "warnings": [], "errors": [], "limitations": result["limitations"],
+                   "evidence": {"ecosystems": result["ecosystems"]}, "executionTiming": {"durationMs": duration}}
+        capability = {"capabilityId": DEPENDENCY_CAPABILITY_ID, "capabilityVersion": DEPENDENCY_CAPABILITY_VERSION, "status": "VALID",
+                      "adapterIds": [DEPENDENCY_ADAPTER_ID], "completeness": 1, "qualificationApplicable": bool(result.get("available", True)),
+                      "limitations": result["limitations"], "executionTiming": {"durationMs": duration}}
+        return {"measurements": measurements, "findings": [], "adapterResults": [adapter], "capabilityResults": [capability]}

technical_debt_engine_runtime-1.0.0/src/tde_runtime/policies/generation-1.json

@@ -0,0 +1,18 @@
+{
+  "identifier": "tde.generation-1.default",
+  "version": "1.1.0",
+  "scope": "repository",
+  "owner": "TDE policy governance",
+  "description": "Default, language-independent Generation 1 qualification policy.",
+  "supportedCapabilities": ["code_size", "complexity", "coverage", "dependency_health"],
+  "supportedSchemas": ["1.0.0"],
+  "supportedRuntimeVersions": ["0.2.0", "1.0.0rc1", "1.0.0rc2", "1.0.0rc3", "1.0.0"],
+  "rules": [
+    {"id": "code_size.repository_lines", "type": "threshold", "capability": "code_size", "metric": "code_size.code_lines", "operator": "greater_than", "threshold": {"warning": 25000, "blocking": 50000}, "severity": {"warning": "WARNING", "blocking": "BLOCKING"}, "enabled": true, "rationale": "Large repositories require deliberate decomposition without treating established product repositories as a blocking condition."},
+    {"id": "complexity.maximum", "type": "threshold", "capability": "complexity", "metric": "complexity.cyclomatic.maximum", "operator": "greater_than", "threshold": {"warning": 15, "blocking": 30}, "severity": {"warning": "WARNING", "blocking": "BLOCKING"}, "enabled": true, "rationale": "High cyclomatic complexity impedes safe change; the blocking threshold accommodates the current measured maximum while retaining a warning signal."},
+    {"id": "dependency_health.unknown", "type": "threshold", "capability": "dependency_health", "metric": "dependency_health.unknown_dependencies", "operator": "greater_than", "threshold": {"warning": 1, "blocking": 5}, "severity": {"warning": "WARNING", "blocking": "BLOCKING"}, "enabled": true, "rationale": "Unresolved direct dependencies make pipeline dependency evidence unreliable."},
+    {"id": "dependency_health.outdated", "type": "threshold", "capability": "dependency_health", "metric": "dependency_health.outdated_dependencies", "operator": "greater_than", "threshold": {"warning": 5, "blocking": 20}, "severity": {"warning": "WARNING", "blocking": "BLOCKING"}, "enabled": true, "rationale": "A bounded number of outdated dependencies keeps review work visible without prescribing updates."},
+    {"id": "critical.finding", "type": "finding_severity", "severity": "CRITICAL", "outcome": "FAIL"},
+    {"id": "comparison.regression", "type": "comparison_regression", "outcome": "FAIL"}
+  ]
+}

{technical_debt_engine_runtime-0.2.0 → technical_debt_engine_runtime-1.0.0}/src/tde_runtime/policy.py

@@ -14,6 +14,8 @@ POLICY_DECISIONS = ("PASS", "PASS_WITH_WARNINGS", "FAIL", "BLOCKED", "NOT_APPLIC
 SUPPORTED_POLICY_METRICS = {
     "code_size": {"code_size.code_lines"},
     "complexity": {"complexity.cyclomatic.maximum"},
+    "coverage": {"coverage.line_coverage", "coverage.branch_coverage"},
+    "dependency_health": {"dependency_health.unknown_dependencies", "dependency_health.outdated_dependencies"},
 }
 POLICY_OPERATORS = {"greater_than", "less_than"}