codd-dev 2.11.0__tar.gz → 2.12.0__tar.gz

{codd_dev-2.11.0 → codd_dev-2.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.11.0
+Version: 2.12.0
 Summary: CoDD: Coherence-Driven Development — cross-artifact change impact analysis
 Project-URL: Homepage, https://github.com/yohey-w/codd-dev
 Project-URL: Repository, https://github.com/yohey-w/codd-dev
@@ -153,8 +153,10 @@ This is what lets CoDD ship one core that works for Next.js, Django, FastAPI, Ra
 
 ## 🧭 Roadmap
 
-- **v2.10.0 (current)** — Lexicon-driven completeness, 38 plug-ins, LLM-enhanced init, scope/phase filter, auto-repair across the full DAG.
-- **v2.11.0 (next)** — Sprint-less `codd implement` (`--design <path> --output <dir>` directly; `implementation_plan.md` parser removed). See [migration guide](docs/migrations/v2.11.0-sprintless.md).
+- **v2.12.0 (current)** — Test-completeness gates: C7 `actors_without_journeys` amber promotion + new C8 `ci_health` static check (workflow presence, trigger coverage, verification-in-workflow). Defaults to opt-in for legacy projects; new `codd init` projects get `ci:` defaults from the template. See [post-mortem](docs/post-mortems/test_completeness_gap.md).
+- **v2.11.0** — Sprint-less `codd implement` (`--design <path> --output <dir>` directly; `implementation_plan.md` parser removed). See [migration guide](docs/migrations/v2.11.0-sprintless.md).
+- **v2.10.0** — Lexicon-driven completeness, 38 plug-ins, LLM-enhanced init, scope/phase filter, auto-repair across the full DAG.
+- **v2.13.0 (next)** — C8 `ci_health` runtime mode (opt-in `ci.runtime_check: true`) polling the CI provider for latest-run-on-default-branch success.
 
 ---
 

{codd_dev-2.11.0 → codd_dev-2.12.0}/README.md

@@ -113,8 +113,10 @@ This is what lets CoDD ship one core that works for Next.js, Django, FastAPI, Ra
 
 ## 🧭 Roadmap
 
-- **v2.10.0 (current)** — Lexicon-driven completeness, 38 plug-ins, LLM-enhanced init, scope/phase filter, auto-repair across the full DAG.
-- **v2.11.0 (next)** — Sprint-less `codd implement` (`--design <path> --output <dir>` directly; `implementation_plan.md` parser removed). See [migration guide](docs/migrations/v2.11.0-sprintless.md).
+- **v2.12.0 (current)** — Test-completeness gates: C7 `actors_without_journeys` amber promotion + new C8 `ci_health` static check (workflow presence, trigger coverage, verification-in-workflow). Defaults to opt-in for legacy projects; new `codd init` projects get `ci:` defaults from the template. See [post-mortem](docs/post-mortems/test_completeness_gap.md).
+- **v2.11.0** — Sprint-less `codd implement` (`--design <path> --output <dir>` directly; `implementation_plan.md` parser removed). See [migration guide](docs/migrations/v2.11.0-sprintless.md).
+- **v2.10.0** — Lexicon-driven completeness, 38 plug-ins, LLM-enhanced init, scope/phase filter, auto-repair across the full DAG.
+- **v2.13.0 (next)** — C8 `ci_health` runtime mode (opt-in `ci.runtime_check: true`) polling the CI provider for latest-run-on-default-branch success.
 
 ---
 

codd_dev-2.12.0/codd/dag/checks/ci_health.py

@@ -0,0 +1,358 @@
+"""C8 CI health check with deterministic static validation."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from glob import glob
+import json
+from pathlib import Path
+import re
+from typing import Any, Mapping
+
+import yaml
+
+from codd.dag.checks import DagCheck, register_dag_check
+
+
+_DEFAULT_PROVIDER = "github" + "_actions"
+
+
+@dataclass
+class CiConfig:
+    provider: str = _DEFAULT_PROVIDER
+    workflow_glob: str = ".github/workflows/*.yml"
+    required_triggers: list[str] = field(default_factory=lambda: ["push", "pull_request"])
+    runtime_check: bool = False
+    staleness_days: int = 14
+    default_branch: str = "main"
+    trigger_key: str = "on"
+
+    @classmethod
+    def from_mapping(cls, value: Mapping[str, Any] | None) -> "CiConfig":
+        if not isinstance(value, Mapping):
+            return cls(provider="none")
+
+        config = cls()
+        return cls(
+            provider=_string_value(value.get("provider"), config.provider),
+            workflow_glob=_string_value(value.get("workflow_glob"), config.workflow_glob),
+            required_triggers=_string_list(value.get("required_triggers"), config.required_triggers),
+            runtime_check=bool(value.get("runtime_check", config.runtime_check)),
+            staleness_days=_int_value(value.get("staleness_days"), config.staleness_days),
+            default_branch=_string_value(value.get("default_branch"), config.default_branch),
+            trigger_key=_string_value(value.get("trigger_key"), config.trigger_key),
+        )
+
+
+@dataclass
+class CiHealthFinding:
+    violation_type: str
+    severity: str
+    block_deploy: bool
+    message: str
+    details: list[str] = field(default_factory=list)
+
+
+@dataclass
+class CiHealthResult:
+    check_name: str = "ci_health"
+    status: str = "pass"
+    severity: str = "info"
+    block_deploy: bool = False
+    message: str = "C8 ci_health PASS"
+    findings: list[CiHealthFinding] = field(default_factory=list)
+    workflow_files: list[str] = field(default_factory=list)
+    passed: bool = True
+
+
+@register_dag_check("ci_health")
+class CiHealthCheck(DagCheck):
+    """C8 CI workflow presence and trigger validation.
+
+    Runtime provider polling is intentionally deferred. The shipped path is
+    static, deterministic, and driven by config values.
+    """
+
+    check_name = "ci_health"
+    severity = "red"
+    block_deploy = True
+
+    def run(
+        self,
+        dag: Any | None = None,
+        project_root: str | Path | None = None,
+        settings: dict[str, Any] | None = None,
+        codd_config: dict[str, Any] | None = None,
+    ) -> CiHealthResult:
+        del dag
+        root = Path(project_root or self.project_root or ".").resolve()
+        active_settings = codd_config or settings or self.settings
+        return self.check(root, CiConfig.from_mapping(_mapping_value(active_settings, "ci")))
+
+    def check(self, project_root: Path, config: CiConfig) -> CiHealthResult:
+        project_root = Path(project_root).resolve()
+        if config.provider.strip().lower() == "none":
+            return CiHealthResult(
+                status="skip",
+                message="ci.provider=none, C8 SKIP",
+                passed=True,
+            )
+
+        workflow_files = self._locate_workflows(project_root, config.workflow_glob)
+        if not workflow_files:
+            finding = CiHealthFinding(
+                violation_type="ci_workflow_missing",
+                severity="red",
+                block_deploy=True,
+                message="No CI workflow files found matching glob.",
+                details=[config.workflow_glob],
+            )
+            return CiHealthResult(
+                status="fail",
+                severity="red",
+                block_deploy=True,
+                message=finding.message,
+                findings=[finding],
+                passed=False,
+            )
+
+        findings = [
+            *self._check_triggers(workflow_files, config.required_triggers, config.trigger_key),
+            *self._check_verification_coverage(workflow_files, project_root),
+        ]
+        block_deploy = any(finding.block_deploy for finding in findings)
+        severity = _max_severity(finding.severity for finding in findings)
+        status = "fail" if block_deploy else ("warn" if findings else "pass")
+        message = (
+            "C8 ci_health PASS"
+            if not findings
+            else f"C8 ci_health found {len(findings)} static finding(s)"
+        )
+        return CiHealthResult(
+            status=status,
+            severity=severity,
+            block_deploy=block_deploy,
+            message=message,
+            findings=findings,
+            workflow_files=[path.relative_to(project_root).as_posix() for path in workflow_files],
+            passed=not block_deploy,
+        )
+
+    def format_report(self, result: CiHealthResult) -> str:
+        return json.dumps({"ci_health_report": asdict(result)}, ensure_ascii=False, indent=2)
+
+    def _locate_workflows(self, project_root: Path, workflow_glob: str) -> list[Path]:
+        pattern = workflow_glob.strip()
+        if not pattern:
+            return []
+        if Path(pattern).is_absolute():
+            paths = [Path(path) for path in glob(pattern)]
+        else:
+            paths = list(project_root.glob(pattern))
+        return sorted(path for path in paths if path.is_file())
+
+    def _check_triggers(
+        self,
+        workflow_files: list[Path],
+        required_triggers: list[str],
+        trigger_key: str,
+    ) -> list[CiHealthFinding]:
+        required = {trigger.strip() for trigger in required_triggers if trigger.strip()}
+        if not required:
+            return []
+
+        actual: set[str] = set()
+        for path in workflow_files:
+            actual.update(self._workflow_triggers(path, trigger_key))
+
+        missing = sorted(required - actual)
+        if not missing:
+            return []
+        return [
+            CiHealthFinding(
+                violation_type="ci_trigger_incomplete",
+                severity="amber",
+                block_deploy=False,
+                message="CI workflow does not include all required triggers.",
+                details=[f"missing: {', '.join(missing)}"],
+            )
+        ]
+
+    def _workflow_triggers(self, path: Path, trigger_key: str) -> set[str]:
+        payload = _read_yaml_mapping(path)
+        value = payload.get(trigger_key)
+        if value is None and trigger_key == "on":
+            value = payload.get(True)
+        return _trigger_names(value)
+
+    def _check_verification_coverage(
+        self,
+        workflow_files: list[Path],
+        project_root: Path,
+    ) -> list[CiHealthFinding]:
+        verification_commands = self._deploy_verification_commands(project_root)
+        if not verification_commands:
+            return []
+
+        workflow_commands = {
+            _normalize_command(command)
+            for path in workflow_files
+            for command in self._workflow_commands(path)
+            if _normalize_command(command)
+        }
+        missing = [
+            command
+            for command in verification_commands
+            if not self._command_appears_in_workflow(command, workflow_commands)
+        ]
+        if not missing:
+            return []
+        return [
+            CiHealthFinding(
+                violation_type="ci_verification_not_in_workflow",
+                severity="amber",
+                block_deploy=False,
+                message="Deployment verification command is not invoked by CI workflow.",
+                details=missing,
+            )
+        ]
+
+    def _deploy_verification_commands(self, project_root: Path) -> list[str]:
+        commands: list[str] = []
+        for path in self._deploy_yaml_candidates(project_root):
+            if not path.is_file():
+                continue
+            payload = _read_yaml_mapping(path)
+            commands.extend(_hook_commands(payload))
+        return _dedupe(_normalize_command(command) for command in commands if _normalize_command(command))
+
+    @staticmethod
+    def _deploy_yaml_candidates(project_root: Path) -> list[Path]:
+        return [
+            project_root / "deploy.yaml",
+            project_root / ".codd" / "deploy.yaml",
+            project_root / "codd" / "deploy.yaml",
+        ]
+
+    def _workflow_commands(self, path: Path) -> list[str]:
+        return _command_values(_read_yaml_mapping(path))
+
+    @staticmethod
+    def _command_appears_in_workflow(command: str, workflow_commands: set[str]) -> bool:
+        return any(command == candidate or command in candidate for candidate in workflow_commands)
+
+
+def _read_yaml_mapping(path: Path) -> dict[str, Any]:
+    payload = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    return payload if isinstance(payload, dict) else {}
+
+
+def _mapping_value(mapping: Any, key: str) -> Mapping[str, Any] | None:
+    if isinstance(mapping, Mapping) and isinstance(mapping.get(key), Mapping):
+        return mapping[key]
+    return None
+
+
+def _trigger_names(value: Any) -> set[str]:
+    if isinstance(value, str):
+        return {value}
+    if isinstance(value, list):
+        return {str(item) for item in value if item}
+    if isinstance(value, dict):
+        return {str(key) for key in value if key}
+    return set()
+
+
+def _hook_commands(value: Any) -> list[str]:
+    if isinstance(value, str):
+        return [value]
+    if isinstance(value, list):
+        commands: list[str] = []
+        for item in value:
+            commands.extend(_hook_commands(item))
+        return commands
+    if isinstance(value, dict):
+        commands: list[str] = []
+        for key in ("post_deploy", "post_deploy_steps", "post_deploy_hooks", "verification", "verifications"):
+            commands.extend(_hook_commands(value.get(key)))
+        for key in ("command", "run", "script", "test"):
+            commands.extend(_hook_commands(value.get(key)))
+        targets = value.get("targets")
+        if isinstance(targets, dict):
+            for target_config in targets.values():
+                commands.extend(_hook_commands(target_config))
+        return commands
+    return []
+
+
+def _command_values(value: Any) -> list[str]:
+    if isinstance(value, str):
+        return []
+    if isinstance(value, list):
+        commands: list[str] = []
+        for item in value:
+            commands.extend(_command_values(item))
+        return commands
+    if isinstance(value, dict):
+        commands: list[str] = []
+        for key, item in value.items():
+            if key in {"run", "script", "command", "commands"}:
+                commands.extend(_coerce_command_list(item))
+            else:
+                commands.extend(_command_values(item))
+        return commands
+    return []
+
+
+def _coerce_command_list(value: Any) -> list[str]:
+    if isinstance(value, str):
+        return [value]
+    if isinstance(value, list):
+        commands: list[str] = []
+        for item in value:
+            commands.extend(_coerce_command_list(item))
+        return commands
+    return []
+
+
+def _normalize_command(value: str) -> str:
+    return re.sub(r"\s+", " ", value).strip()
+
+
+def _dedupe(values: Any) -> list[str]:
+    seen: set[str] = set()
+    result: list[str] = []
+    for value in values:
+        if not value or value in seen:
+            continue
+        seen.add(value)
+        result.append(value)
+    return result
+
+
+def _string_value(value: Any, default: str) -> str:
+    return value if isinstance(value, str) and value.strip() else default
+
+
+def _string_list(value: Any, default: list[str]) -> list[str]:
+    if not isinstance(value, list):
+        return list(default)
+    result = [str(item) for item in value if str(item).strip()]
+    return result or list(default)
+
+
+def _int_value(value: Any, default: int) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def _max_severity(values: Any) -> str:
+    order = {"info": 0, "amber": 1, "red": 2}
+    selected = "info"
+    for value in values:
+        text = str(value)
+        if order.get(text, 0) > order[selected]:
+            selected = text
+    return selected

{codd_dev-2.11.0 → codd_dev-2.12.0}/codd/dag/checks/user_journey_coherence.py

@@ -30,6 +30,7 @@ class UserJourneyCoherenceResult:
     check_name: str = "user_journey_coherence"
     severity: str = "red"
     status: str = "pass"
+    violation_type: str | None = None
     message: str = ""
     block_deploy: bool = True
     violations: list[dict[str, Any]] = field(default_factory=list)
@@ -68,10 +69,41 @@ class UserJourneyCoherenceCheck(DagCheck):
             if node.kind == "design_doc" and self._journey_entries(node)
         ]
         if not journey_docs:
+            actors = self._extract_actors(target_dag)
+            if actors:
+                message = (
+                    f"Actors identified ({', '.join(actors)}) but no user_journeys declared. "
+                    "Consider declaring journeys for each actor."
+                )
+                violation = {
+                    "type": "actors_without_journeys",
+                    "severity": "amber",
+                    "actors": actors,
+                    "message": message,
+                    "block_deploy": False,
+                    "human_review_required": self._human_review_required(actors),
+                }
+                return UserJourneyCoherenceResult(
+                    severity="amber",
+                    status="warn",
+                    violation_type="actors_without_journeys",
+                    message=message,
+                    block_deploy=False,
+                    violations=[violation],
+                    journey_reports=[
+                        {
+                            "user_journey": "(none declared)",
+                            "design_doc": "(none)",
+                            "violations": [violation],
+                            "remediation_hints": ["Declare user_journeys for the identified actors."],
+                        }
+                    ],
+                    passed=True,
+                )
             return UserJourneyCoherenceResult(
                 severity="info",
                 status="pass",
-                message="No user_journeys declared, C7 SKIP",
+                message="No actors and no user_journeys declared, C7 SKIP",
                 block_deploy=self.block_deploy,
             )
 
@@ -195,6 +227,22 @@ class UserJourneyCoherenceCheck(DagCheck):
         report["remediation_hints"] = self._remediation_hints(report["violations"], design_doc)
         return report
 
+    def _extract_actors(self, dag: DAG) -> list[str]:
+        actors: list[str] = []
+        for node in sorted(dag.nodes.values(), key=lambda item: item.id):
+            actors.extend(self._actor_names_from_mapping(node.attributes))
+            details = node.attributes.get("details")
+            if isinstance(details, dict):
+                actors.extend(
+                    self._actor_names_from_mapping(
+                        details,
+                        actor_dimension=self._is_actor_dimension(details),
+                    )
+                )
+            if self._is_actor_dimension(node.attributes):
+                actors.extend(self._actor_names_from_mapping(node.attributes, actor_dimension=True))
+        return self._dedupe_strings(actors)
+
     def _runtime_constraint_violations(
         self,
         dag: DAG,
@@ -657,6 +705,70 @@ class UserJourneyCoherenceCheck(DagCheck):
             )
         )
 
+    def _actor_names_from_mapping(self, mapping: dict[str, Any], *, actor_dimension: bool = False) -> list[str]:
+        keys = {
+            "actor",
+            "actors",
+            "role",
+            "roles",
+            "stakeholder",
+            "stakeholders",
+            "stakeholder_roles",
+        }
+        if actor_dimension:
+            keys.update({"value", "values", "item", "items", "candidate", "candidates", "name", "names"})
+
+        actors: list[str] = []
+        for key, value in mapping.items():
+            if str(key).strip().lower() in keys:
+                actors.extend(self._actor_names_from_value(value))
+        return self._dedupe_strings(actors)
+
+    def _actor_names_from_value(self, value: Any) -> list[str]:
+        if value is None:
+            return []
+        if isinstance(value, str):
+            return [actor for item in re.split(r"[,;\n]+", value) if (actor := self._clean_actor_name(item))]
+        if isinstance(value, dict):
+            for key in ("name", "id", "label", "role", "actor", "stakeholder"):
+                if key in value:
+                    return self._actor_names_from_value(value[key])
+            return []
+        if isinstance(value, Iterable) and not isinstance(value, (bytes, bytearray)):
+            actors: list[str] = []
+            for item in value:
+                actors.extend(self._actor_names_from_value(item))
+            return self._dedupe_strings(actors)
+        actor = self._clean_actor_name(str(value))
+        return [actor] if actor else []
+
+    @staticmethod
+    def _clean_actor_name(value: str) -> str | None:
+        text = value.strip().strip("'\"`")
+        if not text or len(text) > 80:
+            return None
+        if text.lower() in {
+            "actor",
+            "actors",
+            "role",
+            "roles",
+            "stakeholder",
+            "stakeholders",
+            "covered",
+            "implicit",
+            "gap",
+        }:
+            return None
+        return text
+
+    @staticmethod
+    def _is_actor_dimension(attributes: dict[str, Any]) -> bool:
+        for key in ("dimension", "axis", "axis_type"):
+            value = attributes.get(key)
+            if isinstance(value, str) and any(token in value.lower() for token in ("actor", "stakeholder", "role")):
+                return True
+        return False
+
     def _runtime_state_summary(self, actual_caps: set[str]) -> str:
         return f"capabilities_provided=[{', '.join(sorted(actual_caps))}]"
 

{codd_dev-2.11.0 → codd_dev-2.12.0}/codd/dag/runner.py

@@ -18,6 +18,7 @@ CHECK_MODULES = (
     "codd.dag.checks.transitive_closure",
     "codd.dag.checks.deployment_completeness",
     "codd.dag.checks.user_journey_coherence",
+    "codd.dag.checks.ci_health",
     "codd.dag.checks.implementation_coverage",
     "codd.dag.checks.environment_coverage",
 )

{codd_dev-2.11.0 → codd_dev-2.12.0}/codd/deployer.py

@@ -217,7 +217,7 @@ def run_deploy(
 
 
 def _run_deploy_gates(project_root: Path) -> DeployGateResult:
-    """Run validate, drift, coverage, DAG, C6, and C7 gates before apply deploy."""
+    """Run validate, drift, coverage, DAG, C6, C7, and C8 gates before apply deploy."""
     project_root = Path(project_root).resolve()
     settings = _load_gate_settings(project_root)
     codd_dir = _find_gate_codd_dir(project_root)
@@ -231,6 +231,7 @@ def _run_deploy_gates(project_root: Path) -> DeployGateResult:
     _collect_dag_completeness_gate(project_root, settings, result)
     _collect_deployment_completeness_gate_result(project_root, settings, result)
     _collect_user_journey_coherence_gate_result(project_root, settings, result)
+    _collect_ci_health_gate_result(project_root, settings, result)
     return result
 
 
@@ -525,6 +526,63 @@ def _collect_user_journey_coherence_gate_result(
     _ntfy_user_journey_coherence_fail(red_violations, settings)
 
 
+def _collect_ci_health_gate(
+    project_root: Path,
+    codd_config: dict[str, Any],
+) -> Any:
+    """Run the C8 ci_health check and return its result."""
+
+    from codd.dag.checks.ci_health import CiConfig, CiHealthCheck
+
+    return CiHealthCheck().check(
+        Path(project_root).resolve(),
+        CiConfig.from_mapping(codd_config.get("ci")),
+    )
+
+
+def _collect_ci_health_gate_result(
+    project_root: Path,
+    settings: dict[str, Any],
+    result: DeployGateResult,
+) -> None:
+    if "ci" not in settings:
+        return
+
+    try:
+        check_result = _collect_ci_health_gate(project_root, settings)
+    except Exception as exc:  # pragma: no cover - defensive gate behavior
+        result.add_failure("ci_health", str(exc))
+        return
+
+    if str(_result_value(check_result, "status") or "").lower() == "skip":
+        return
+
+    findings = list(_result_value(check_result, "findings") or [])
+    if not findings:
+        return
+
+    from codd.dag.checks.ci_health import CiHealthCheck
+
+    report = CiHealthCheck().format_report(check_result)
+    result.add_report("ci_health_report", _parse_ci_health_report(report))
+
+    red_findings = [finding for finding in findings if _ci_finding_blocks_deploy(finding)]
+    amber_findings = [
+        finding
+        for finding in findings
+        if not _ci_finding_blocks_deploy(finding) and _ci_finding_severity(finding) == "amber"
+    ]
+    if amber_findings:
+        result.add_warning(f"ci_health: {len(amber_findings)} amber finding(s)")
+
+    if red_findings:
+        result.add_failure(
+            "ci_health",
+            f"C8 ci_health: {len(red_findings)} red finding(s)",
+            [report],
+        )
+
+
 def _screen_flow_strict_edges(settings: dict[str, Any]) -> bool:
     screen_flow_config = settings.get("screen_flow", {})
     if not isinstance(screen_flow_config, dict):
@@ -821,6 +879,15 @@ def _parse_user_journey_coherence_report(report: str) -> list[dict[str, Any]]:
     return value if isinstance(value, list) else []
 
 
+def _parse_ci_health_report(report: str) -> dict[str, Any]:
+    try:
+        payload = json.loads(report)
+    except json.JSONDecodeError:
+        return {}
+    value = payload.get("ci_health_report")
+    return value if isinstance(value, dict) else {}
+
+
 def _red_user_journey_violations(violations: list[Any]) -> list[Any]:
     return [violation for violation in violations if _user_journey_violation_severity(violation) == "red"]
 
@@ -833,6 +900,14 @@ def _user_journey_violation_severity(violation: Any) -> str:
     return str(_violation_attr(violation, "severity") or "red")
 
 
+def _ci_finding_blocks_deploy(finding: Any) -> bool:
+    return bool(_violation_attr(finding, "block_deploy"))
+
+
+def _ci_finding_severity(finding: Any) -> str:
+    return str(_violation_attr(finding, "severity") or "red")
+
+
 def _violation_attr(violation: Any, key: str) -> Any:
     if isinstance(violation, dict):
         return violation.get(key)

{codd_dev-2.11.0 → codd_dev-2.12.0}/codd/elicit/__init__.py

@@ -2,7 +2,7 @@
 
 from codd.elicit.apply import ApplyResult, ElicitApplyEngine
 from codd.elicit.engine import ElicitEngine
-from codd.elicit.finding import Finding, Severity
+from codd.elicit.finding import Finding, FindingDimension, FindingType, Severity
 from codd.elicit.persistence import ElicitPersistence
 
 __all__ = [
@@ -11,5 +11,7 @@ __all__ = [
     "ElicitEngine",
     "ElicitPersistence",
     "Finding",
+    "FindingDimension",
+    "FindingType",
     "Severity",
 ]