codd-dev 2.0.0__tar.gz → 2.2.0__tar.gz

{codd_dev-2.0.0 → codd_dev-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.0.0
+Version: 2.2.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

{codd_dev-2.0.0 → codd_dev-2.2.0}/codd/cli.py

@@ -2973,6 +2973,130 @@ def coverage_report_cmd(
     click.echo(f"Report: {_display_path(output_path, project_root)}")
 
 
+@coverage.command("check")
+@click.option(
+    "--lexicons",
+    default="all",
+    show_default=True,
+    help="Lexicons to include: all or a comma-separated id list.",
+)
+@click.option("--path", "project_path", default=".", show_default=True, help="Project root directory")
+@click.option(
+    "--threshold",
+    "global_threshold",
+    type=float,
+    default=None,
+    help="Global covered_text_match_pct threshold override.",
+)
+@click.option(
+    "--threshold-file",
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+    default=None,
+    help="External threshold YAML file.",
+)
+@click.option(
+    "--format",
+    "format_name",
+    type=click.Choice(["human", "json", "md"]),
+    default="human",
+    show_default=True,
+    help="Output format.",
+)
+@click.option("--with-ai", is_flag=True, default=False, help="Use AI-backed elicit coverage mode.")
+@click.option("--ai-cmd", default=None, help="Override AI CLI command for --with-ai.")
+@click.option("--exit-zero", is_flag=True, default=False, help="Always exit 0 for threshold violations.")
+def coverage_check_cmd(
+    lexicons: str,
+    project_path: str,
+    global_threshold: float | None,
+    threshold_file: Path | None,
+    format_name: str,
+    with_ai: bool,
+    ai_cmd: str | None,
+    exit_zero: bool,
+) -> None:
+    """Run a lexicon coverage threshold gate."""
+    from dataclasses import asdict
+
+    from codd.lexicon_cli.formatters.json_fmt import to_json
+    from codd.lexicon_cli.reporter import CoverageReporter
+    from codd.lexicon_cli.threshold import ThresholdConfig, evaluate, load_thresholds
+
+    project_root = Path(project_path).resolve()
+    try:
+        report = CoverageReporter(project_root).build(lexicons, with_ai=with_ai, ai_command=ai_cmd)
+        config = load_thresholds(threshold_file or _default_threshold_path(project_root))
+        if global_threshold is not None:
+            config = ThresholdConfig(default_pct=global_threshold)
+        violations = evaluate(report, config)
+    except (OSError, ValueError, json.JSONDecodeError, yaml.YAMLError) as exc:
+        click.echo(f"Error: {exc}")
+        raise SystemExit(2)
+
+    payload = {
+        "status": "fail" if violations else "pass",
+        "thresholds": asdict(config),
+        "totals": report.totals,
+        "violations": [asdict(violation) for violation in violations],
+    }
+    if format_name == "json":
+        click.echo(to_json(payload), nl=False)
+    elif format_name == "md":
+        click.echo(_format_coverage_check_md(payload), nl=False)
+    else:
+        click.echo(_format_coverage_check_human(payload), nl=False)
+
+    raise SystemExit(0 if exit_zero or not violations else 1)
+
+
+def _default_threshold_path(project_root: Path) -> Path | None:
+    codd_dir = find_codd_dir(project_root)
+    return codd_dir / "codd.yaml" if codd_dir is not None else None
+
+
+def _format_coverage_check_human(payload: dict[str, Any]) -> str:
+    status = str(payload["status"]).upper()
+    totals = payload["totals"]
+    lines = [
+        f"Coverage check {status}",
+        f"Axes: {totals['covered']}/{totals['axes']} covered ({totals['covered_pct']:.2f}%)",
+    ]
+    violations = payload["violations"]
+    if violations:
+        lines.append("Violations:")
+        for violation in violations:
+            axis = violation["axis"] or "<overall>"
+            lines.append(
+                f"  - {violation['lexicon_id']} {axis}: "
+                f"{violation['observed_pct']:.2f}% < {violation['required_pct']:.2f}%"
+            )
+    return "\n".join(lines) + "\n"
+
+
+def _format_coverage_check_md(payload: dict[str, Any]) -> str:
+    totals = payload["totals"]
+    lines = [
+        "# Coverage Threshold Check",
+        "",
+        f"Status: **{str(payload['status']).upper()}**",
+        f"Axes: {totals['covered']}/{totals['axes']} covered ({totals['covered_pct']:.2f}%)",
+        "",
+        "| Lexicon | Axis | Observed | Required |",
+        "| --- | --- | ---: | ---: |",
+    ]
+    violations = payload["violations"]
+    if violations:
+        for violation in violations:
+            axis = violation["axis"] or "<overall>"
+            lines.append(
+                f"| {violation['lexicon_id']} | {axis} | "
+                f"{violation['observed_pct']:.2f}% | {violation['required_pct']:.2f}% |"
+            )
+    else:
+        lines.append("| - | - | - | - |")
+    return "\n".join(lines) + "\n"
+
+
 @main.command("deploy")
 @click.option("--target", default=None, help="Deploy target name from deploy.yaml")
 @click.option(

{codd_dev-2.0.0 → codd_dev-2.2.0}/codd/elicit/apply.py

@@ -35,6 +35,7 @@ class ElicitApplyEngine:
         pending_path = self.elicit_dir / "pending_findings.yaml"
         history_path = self.elicit_dir / "elicit_history.yaml"
         findings_md_path = self.project_root / "findings.md"
+        requirements_path = _requirements_path(self.project_root)
 
         ignored_doc = _read_yaml_mapping(ignored_path, default_key="ignored")
         pending_doc = _read_yaml_mapping(pending_path, default_key="pending")
@@ -44,8 +45,12 @@ class ElicitApplyEngine:
         pending_entries = _list_value(pending_doc, "pending")
         history_entries = _list_value(history_doc, "sessions")
 
-        existing_ids = _existing_finding_ids(ignored_entries) | _existing_finding_ids(pending_entries)
-        accepted: list[Finding] = []
+        ignored_ids = _existing_finding_ids(ignored_entries)
+        pending_ids = _existing_finding_ids(pending_entries)
+        requirements_ids = _existing_ids_in_file(requirements_path)
+        accepted_for_requirements: list[Finding] = []
+        accepted_for_review: list[Finding] = []
+        pending_review: list[Finding] = []
         rejected: list[Finding] = []
         deferred: list[Finding] = []
         duplicates: list[Finding] = []
@@ -53,31 +58,60 @@ class ElicitApplyEngine:
         for finding in approved:
             decision = _finding_decision(finding)
             if decision == "reject":
+                _remove_finding_entry(pending_entries, finding.id)
+                pending_ids.discard(finding.id)
+                if finding.id in ignored_ids:
+                    duplicates.append(finding)
+                    continue
                 rejected.append(finding)
+                ignored_ids.add(finding.id)
                 continue
             if decision == "defer":
                 deferred.append(finding)
                 continue
-            if finding.id in existing_ids:
+            if decision == "pending":
+                if finding.id in ignored_ids or finding.id in requirements_ids:
+                    duplicates.append(finding)
+                    continue
+                if finding.id in pending_ids:
+                    duplicates.append(finding)
+                    continue
+                pending_review.append(finding)
+                pending_ids.add(finding.id)
+                continue
+            if _writes_requirements(finding):
+                if finding.id in ignored_ids or finding.id in requirements_ids:
+                    duplicates.append(finding)
+                    continue
+                _remove_finding_entry(pending_entries, finding.id)
+                pending_ids.discard(finding.id)
+                accepted_for_requirements.append(finding)
+                requirements_ids.add(finding.id)
+                continue
+            if finding.id in ignored_ids or finding.id in pending_ids or finding.id in requirements_ids:
                 duplicates.append(finding)
                 continue
-            accepted.append(finding)
-            existing_ids.add(finding.id)
+            accepted_for_review.append(finding)
+            pending_ids.add(finding.id)
 
         for finding in rejected:
             ignored_entries.append(_ignored_entry(finding, timestamp))
-        for finding in accepted:
+        for finding in [*accepted_for_review, *pending_review]:
             pending_entries.append(_pending_entry(finding, timestamp))
 
         history_entries.append(
             {
                 "timestamp": timestamp,
                 "findings_total": len(approved),
-                "approved": len(accepted),
+                "approved": len(accepted_for_requirements) + len(accepted_for_review),
                 "rejected": len(rejected),
                 "deferred": len(deferred),
+                "pending": len(pending_review),
                 "duplicates": len(duplicates),
-                "findings_md": "findings.md" if accepted else None,
+                "findings_md": "findings.md" if accepted_for_review else None,
+                "requirements_md": _relative_path(requirements_path, self.project_root)
+                if accepted_for_requirements
+                else None,
             }
         )
 
@@ -89,12 +123,16 @@ class ElicitApplyEngine:
         _write_yaml(history_path, {"sessions": history_entries})
         files_updated.append(_relative_path(history_path, self.project_root))
 
-        if accepted:
-            findings_md_path.write_text(MdFormatter().format(accepted), encoding="utf-8")
+        if accepted_for_requirements:
+            _append_requirements(requirements_path, accepted_for_requirements)
+            files_updated.append(_relative_path(requirements_path, self.project_root))
+
+        if accepted_for_review:
+            findings_md_path.write_text(MdFormatter().format(accepted_for_review), encoding="utf-8")
             files_updated.append(_relative_path(findings_md_path, self.project_root))
 
         return ApplyResult(
-            applied_count=len(accepted),
+            applied_count=len(accepted_for_requirements) + len(accepted_for_review) + len(pending_review),
             skipped_count=len(rejected) + len(deferred) + len(duplicates),
             files_updated=files_updated,
         )
@@ -128,17 +166,22 @@ def _findings_from_json(raw: str) -> list[Finding]:
 
 
 _FINDING_COMMENT_RE = re.compile(r"<!--\s*codd:finding\s*(.*?)\s*-->", re.DOTALL)
+_APPROVAL_LINE_RE = re.compile(
+    r"(?m)^-\s+approval:\s*\[([^\]]*)\]\s*`?([A-Za-z0-9][A-Za-z0-9_.:-]*)`?"
+)
 
 
 def _findings_from_markdown(raw: str) -> list[Finding]:
     findings = [Finding.from_dict(json.loads(match.group(1))) for match in _FINDING_COMMENT_RE.finditer(raw)]
     if findings:
-        return findings
+        approval_states = _approval_states_from_markdown(raw)
+        return [_with_approval_state(finding, approval_states.get(finding.id)) for finding in findings]
     return _findings_from_markdown_fields(raw)
 
 
 def _findings_from_markdown_fields(raw: str) -> list[Finding]:
     findings: list[Finding] = []
+    approval_states = _approval_states_from_markdown(raw)
     for section in re.split(r"(?m)^##\s+", raw)[1:]:
         fields: dict[str, Any] = {}
         for key in ("id", "kind", "severity", "name", "question", "rationale"):
@@ -148,10 +191,36 @@ def _findings_from_markdown_fields(raw: str) -> list[Finding]:
                 if value != "N/A":
                     fields[key] = value
         if fields:
-            findings.append(Finding.from_dict(fields))
+            finding = Finding.from_dict(fields)
+            findings.append(_with_approval_state(finding, approval_states.get(finding.id)))
     return findings
 
 
+def _approval_states_from_markdown(raw: str) -> dict[str, str]:
+    states: dict[str, str] = {}
+    for match in _APPROVAL_LINE_RE.finditer(raw):
+        state = match.group(1).strip().lower()
+        finding_id = match.group(2).strip().strip("`")
+        if state:
+            states[finding_id] = state
+    return states
+
+
+def _with_approval_state(finding: Finding, state: str | None) -> Finding:
+    if state is None:
+        return finding
+    details = dict(finding.details)
+    if state in {"x", "y", "yes", "approve", "approved"}:
+        details["approval"] = "approved"
+    elif state in {"r", "n", "no", "reject", "rejected"}:
+        details["approval"] = "rejected"
+    else:
+        details["approval"] = f"unknown:{state}"
+    payload = finding.to_dict()
+    payload["details"] = details
+    return Finding.from_dict(payload)
+
+
 def _utc_timestamp() -> str:
     return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
 
@@ -197,16 +266,93 @@ def _existing_finding_ids(entries: list[Any]) -> set[str]:
     return ids
 
 
+def _remove_finding_entry(entries: list[Any], finding_id: str) -> None:
+    entries[:] = [
+        entry
+        for entry in entries
+        if _entry_finding_id(entry) != finding_id
+    ]
+
+
+def _entry_finding_id(entry: Any) -> str | None:
+    if not isinstance(entry, dict):
+        return None
+    if "id" in entry:
+        return str(entry["id"])
+    finding = entry.get("finding")
+    if isinstance(finding, dict) and "id" in finding:
+        return str(finding["id"])
+    return None
+
+
 def _finding_decision(finding: Finding) -> str:
     raw = finding.details.get("decision", finding.details.get("approval", "approve"))
     value = str(raw).strip().lower()
-    if value in {"reject", "rejected", "no", "n"}:
+    if value.startswith("unknown:"):
+        return "pending"
+    if value in {"reject", "rejected", "no", "n", "r"}:
         return "reject"
-    if value in {"defer", "deferred", "later", "pending", "d"}:
+    if value in {"pending", "unchecked", "unreviewed"}:
+        return "pending"
+    if value in {"defer", "deferred", "later", "d"}:
         return "defer"
     return "approve"
 
 
+def _writes_requirements(finding: Finding) -> bool:
+    raw = finding.details.get("decision", finding.details.get("approval"))
+    if raw is None:
+        return False
+    return str(raw).strip().lower() in {"approve", "approved", "yes", "y", "x"}
+
+
+def _requirements_path(project_root: Path) -> Path:
+    candidates = [
+        project_root / "requirements.md",
+        project_root / "docs" / "requirements" / "requirements.md",
+        project_root / "docs" / "requirements.md",
+        project_root / ".codd" / "requirements.md",
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    return candidates[0]
+
+
+def _existing_ids_in_file(path: Path) -> set[str]:
+    if not path.exists():
+        return set()
+    text = path.read_text(encoding="utf-8", errors="replace")
+    return set(re.findall(r"\[([A-Za-z0-9][A-Za-z0-9_.:-]*)\]", text))
+
+
+def _append_requirements(path: Path, findings: list[Finding]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    existing = path.read_text(encoding="utf-8") if path.exists() else ""
+    entries = "\n\n".join(_requirements_entry(finding) for finding in findings)
+    parts = [existing.rstrip()]
+    heading = "## TODO (codd elicit approved findings)"
+    if heading not in existing:
+        parts.extend(["", heading])
+    parts.extend(["", entries])
+    path.write_text("\n".join(part for part in parts if part != "").rstrip() + "\n", encoding="utf-8")
+
+
+def _requirements_entry(finding: Finding) -> str:
+    lines = [f"- [ ] TODO [{finding.id}] {_summary(finding)}"]
+    if finding.question:
+        lines.append(f"  - Question: {finding.question}")
+    if finding.rationale:
+        lines.append(f"  - Rationale: {finding.rationale}")
+    if finding.related_requirement_ids:
+        lines.append(f"  - Related requirements: {', '.join(finding.related_requirement_ids)}")
+    return "\n".join(lines)
+
+
+def _summary(finding: Finding) -> str:
+    return finding.name or finding.question or finding.rationale or finding.id
+
+
 def _ignored_entry(finding: Finding, timestamp: str) -> dict[str, Any]:
     return {
         "id": finding.id,

{codd_dev-2.0.0 → codd_dev-2.2.0}/codd/elicit/engine.py

@@ -35,9 +35,16 @@ class ElicitEngine:
 
     def run(self, project_root: Path, lexicon_config: Any | None = None) -> ElicitResult:
         root = Path(project_root)
+        project_scope, project_phase = _project_scope_phase(root)
         prompt = self.build_prompt(root, lexicon_config=lexicon_config)
         raw_output = self.invoke(prompt, root)
         result = self.deserialize_result(raw_output)
+        result.findings = _apply_scope_phase(
+            result.findings,
+            lexicon_config=lexicon_config,
+            scope=project_scope,
+            phase=project_phase,
+        )
         result.findings = ElicitPersistence(root).filter_known(result.findings)
         if not result.findings and result.lexicon_coverage_report:
             non_gap = all(
@@ -173,6 +180,151 @@ def _existing_axes_text(project_root: Path) -> str:
     return yaml.safe_dump(values, sort_keys=False, allow_unicode=True).strip()
 
 
+def _project_scope_phase(project_root: Path) -> tuple[str, str]:
+    for name in ("project_lexicon.yaml", "project_lexicon.yml"):
+        path = project_root / name
+        if not path.is_file():
+            continue
+        payload = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+        if not isinstance(payload, Mapping):
+            return "full", "production"
+        return (
+            str(payload.get("scope") or "full"),
+            str(payload.get("phase") or "production"),
+        )
+    return "full", "production"
+
+
+def _apply_scope_phase(
+    findings: list[Finding],
+    *,
+    lexicon_config: Any | None,
+    scope: str,
+    phase: str,
+) -> list[Finding]:
+    axis_concerns = _axis_concern_map(lexicon_config)
+    severity_rules = _mapping_attr(lexicon_config, "severity_rules")
+    filtered: list[Finding] = []
+    for finding in findings:
+        axis = _finding_axis(finding)
+        concern = axis_concerns.get(axis) if axis is not None else None
+        if not _scope_allows_concern(scope, concern):
+            continue
+        _apply_phase_severity(
+            finding,
+            axis=axis,
+            concern=concern,
+            phase=phase,
+            scope=scope,
+            severity_rules=severity_rules,
+        )
+        filtered.append(finding)
+    return filtered
+
+
+def _axis_concern_map(lexicon_config: Any | None) -> dict[str, str]:
+    concerns: dict[str, str] = {}
+    for axis in _list_attr(lexicon_config, "coverage_axes"):
+        if not isinstance(axis, Mapping):
+            continue
+        axis_type = axis.get("axis_type")
+        concern = axis.get("concern")
+        if isinstance(axis_type, str) and isinstance(concern, str):
+            concerns[axis_type] = concern.strip().lower()
+    return concerns
+
+
+def _finding_axis(finding: Finding) -> str | None:
+    for key in ("dimension", "axis", "axis_type"):
+        value = finding.details.get(key)
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return None
+
+
+def _scope_allows_concern(scope: str, concern: str | None) -> bool:
+    if concern is None:
+        return True
+    scope_value = scope.strip().lower()
+    concern_value = concern.strip().lower()
+    if scope_value == "system_implementation":
+        return concern_value in {"system", "both"}
+    if scope_value == "business_only":
+        return concern_value in {"business", "both"}
+    return True
+
+
+def _apply_phase_severity(
+    finding: Finding,
+    *,
+    axis: str | None,
+    concern: str | None,
+    phase: str,
+    scope: str,
+    severity_rules: Mapping[str, Any],
+) -> None:
+    phase_value = phase.strip().lower()
+    concern_value = (concern or "").strip().lower()
+    context = {
+        "axis": axis or "",
+        "dimension": axis or "",
+        "concern": concern_value,
+        "phase": phase_value,
+        "scope": scope.strip().lower(),
+        "severity": finding.severity,
+    }
+    if _apply_matching_severity_rule(finding, context, severity_rules):
+        return
+    if phase_value == "mvp" and concern_value == "business" and finding.severity != "info":
+        finding.severity = "info"
+
+
+def _apply_matching_severity_rule(
+    finding: Finding,
+    context: Mapping[str, str],
+    severity_rules: Mapping[str, Any],
+) -> bool:
+    rules = severity_rules.get("rules", [])
+    if not isinstance(rules, list):
+        return False
+    for rule in rules:
+        if not isinstance(rule, Mapping):
+            continue
+        when = rule.get("when")
+        severity = rule.get("severity")
+        if not isinstance(when, str) or not isinstance(severity, str):
+            continue
+        if _condition_matches(when, context):
+            _set_severity(finding, severity)
+            return True
+    return False
+
+
+def _condition_matches(condition: str, context: Mapping[str, str]) -> bool:
+    parts = [
+        part.strip()
+        for part in re.split(r"\bAND\b", condition, flags=re.IGNORECASE)
+        if part.strip()
+    ]
+    if not parts:
+        return False
+    for part in parts:
+        if "=" not in part:
+            return False
+        key_text, expected_text = part.split("=", 1)
+        key = key_text.strip().lower()
+        expected = expected_text.strip().lower()
+        if context.get(key, "").lower() != expected:
+            return False
+    return True
+
+
+def _set_severity(finding: Finding, severity: str) -> None:
+    cleaned = severity.strip().lower()
+    if cleaned in {"critical", "high", "medium", "info"}:
+        finding.severity = cleaned  # type: ignore[assignment]
+
+
 def _load_optional_codd_config(project_root: Path) -> dict[str, Any]:
     for dirname in ("codd", ".codd"):
         path = project_root / dirname / "codd.yaml"
@@ -237,6 +389,28 @@ def _string_attr(value: Any, name: str) -> str | None:
     return None
 
 
+def _mapping_attr(value: Any, name: str) -> Mapping[str, Any]:
+    candidate = getattr(value, name, None)
+    if isinstance(candidate, Mapping):
+        return candidate
+    if isinstance(value, Mapping):
+        candidate = value.get(name)
+        if isinstance(candidate, Mapping):
+            return candidate
+    return {}
+
+
+def _list_attr(value: Any, name: str) -> list[Any]:
+    candidate = getattr(value, name, None)
+    if isinstance(candidate, list):
+        return candidate
+    if isinstance(value, Mapping):
+        candidate = value.get(name)
+        if isinstance(candidate, list):
+            return candidate
+    return []
+
+
 def _unique_paths(paths: list[Path]) -> list[Path]:
     seen: set[Path] = set()
     unique: list[Path] = []

{codd_dev-2.0.0 → codd_dev-2.2.0}/codd/elicit/lexicon_loader.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
@@ -18,6 +18,8 @@ class LexiconConfig:
     lexicon_name: str
     prompt_extension_content: str
     recommended_kinds: list[str]
+    coverage_axes: list[dict[str, Any]] = field(default_factory=list)
+    severity_rules: dict[str, Any] = field(default_factory=dict)
 
 
 def load_lexicon(lexicon_path: Path) -> LexiconConfig:
@@ -54,10 +56,18 @@ def load_lexicon(lexicon_path: Path) -> LexiconConfig:
         prompt_content = f"{base_prompt.rstrip()}\n\n{extension_body.lstrip()}"
 
     recommended_kinds = _load_recommended_kinds(recommended_kinds_path)
+    coverage_axes = _load_coverage_axes(manifest_dir, manifest)
+    severity_rules = _load_optional_mapping_file(
+        manifest_dir,
+        _optional_str(manifest.get("severity_rules")) or "severity_rules.yaml",
+        "severity_rules",
+    )
     return LexiconConfig(
         lexicon_name=lexicon_name,
         prompt_extension_content=prompt_content,
         recommended_kinds=recommended_kinds,
+        coverage_axes=coverage_axes,
+        severity_rules=severity_rules,
     )
 
 
@@ -154,3 +164,20 @@ def _load_recommended_kinds(path: Path) -> list[str]:
             raise LexiconLoadError(f"recommended_kinds contains duplicate entry: {kind}")
         kinds.append(kind)
     return kinds
+
+
+def _load_coverage_axes(base_dir: Path, manifest: dict[str, Any]) -> list[dict[str, Any]]:
+    lexicon_path_text = _optional_str(manifest.get("lexicon")) or "lexicon.yaml"
+    payload = _load_optional_mapping_file(base_dir, lexicon_path_text, "lexicon")
+    raw_axes = payload.get("coverage_axes", manifest.get("coverage_axes", []))
+    if not isinstance(raw_axes, list):
+        return []
+    return [dict(item) for item in raw_axes if isinstance(item, dict)]
+
+
+def _load_optional_mapping_file(base_dir: Path, declared_path: str, label: str) -> dict[str, Any]:
+    try:
+        path = _resolve_existing_path(base_dir, declared_path, label)
+    except LexiconLoadError:
+        return {}
+    return _load_yaml_mapping(path, label)