@scemoon/cdh 1.0.7 → 1.0.9-beta.1

package/cdh/validators/__init__.py

@@ -0,0 +1,16 @@
+from cdh.validators.ears import run_ears_check
+from cdh.validators.fr_namespace import run_fr_check
+from cdh.validators.bdd import run_bdd_check
+from cdh.validators.dag import run_dag_check
+
+__all__ = [
+    "run_ears_check",
+    "run_fr_check",
+    "run_bdd_check",
+    "run_dag_check",
+]
+
+_CHECK_RESULT_SCHEMA = {
+    "passed": bool,
+    "checks": list,
+}

package/cdh/validators/bdd.py

@@ -0,0 +1,144 @@
+import re
+from pathlib import Path
+
+_FR_TAG_RE = re.compile(r"@(?P<prefix>[A-Z]+)-FR-(?P<number>\d+)")
+_SCENARIO_RE = re.compile(r"^\s*(Scenario|Scenario Outline|Scenario Template)\s*:")
+_TAG_CATEGORY_RE = re.compile(r"@(?P<cat>positive|negative|edge|logic)")
+
+
+def _find_feature_files(root: Path) -> list[Path]:
+    return sorted(Path(root).rglob("*.feature"))
+
+
+def _parse_feature_file(path: Path) -> list[dict]:
+    scenarios = []
+    try:
+        text = path.read_text(encoding="utf-8")
+    except Exception:
+        return scenarios
+
+    lines = text.split("\n")
+    current_tags = set()
+    current_frs = set()
+    in_scenario = False
+
+    for line in lines:
+        stripped = line.strip()
+
+        if stripped.startswith("@"):
+            for m in _FR_TAG_RE.finditer(stripped):
+                current_frs.add(f"{m.group('prefix')}-FR-{m.group('number')}")
+            for m in _TAG_CATEGORY_RE.finditer(stripped):
+                current_tags.add(m.group("cat"))
+            continue
+
+        if _SCENARIO_RE.match(stripped):
+            if current_frs or current_tags:
+                scenarios.append({
+                    "frs": set(current_frs),
+                    "tags": set(current_tags),
+                    "file": str(path),
+                    "name": stripped,
+                })
+            current_tags = set()
+            current_frs = set()
+
+    return scenarios
+
+
+def run_bdd_check(root: Path) -> dict:
+    checks = []
+    feature_files = _find_feature_files(root)
+
+    if not feature_files:
+        return {
+            "passed": True,
+            "checks": [{
+                "name": "bdd-feature-found",
+                "status": "pass",
+                "message": "No .feature files found yet (project may be empty)",
+            }],
+        }
+
+    fr_scenarios: dict[str, list[dict]] = {}
+    total_scenarios = 0
+
+    for ff in feature_files:
+        for sc in _parse_feature_file(ff):
+            total_scenarios += 1
+            for fr in sc["frs"]:
+                fr_scenarios.setdefault(fr, []).append(sc)
+
+    if total_scenarios == 0:
+        checks.append({
+            "name": "bdd-scenarios",
+            "status": "fail",
+            "message": f"Found {len(feature_files)} .feature files but no Scenario definitions",
+        })
+        return {"passed": False, "checks": checks}
+
+    checks.append({
+        "name": "bdd-total-scenarios",
+        "status": "pass",
+        "message": f"Found {total_scenarios} scenarios across {len(feature_files)} feature files",
+    })
+
+    frs_with_issues = []
+    frs_ok = []
+
+    for fr, scenarios in sorted(fr_scenarios.items()):
+        positive = sum(1 for s in scenarios if "positive" in s["tags"])
+        negative = sum(1 for s in scenarios if "negative" in s["tags"])
+        edge = sum(1 for s in scenarios if "edge" in s["tags"])
+        logic = sum(1 for s in scenarios if "logic" in s["tags"])
+        categories = {"positive": positive, "negative": negative, "edge": edge, "logic": logic}
+
+        missing = [cat for cat, count in categories.items() if count == 0]
+        if missing:
+            frs_with_issues.append((fr, missing, categories))
+        else:
+            frs_ok.append(fr)
+
+    if frs_ok:
+        checks.append({
+            "name": "bdd-fr-coverage",
+            "status": "pass",
+            "message": f"FRs with complete coverage (positive+negative+edge+logic): {', '.join(frs_ok)}",
+        })
+
+    for fr, missing, categories in frs_with_issues:
+        details = ", ".join(f"{k}={v}" for k, v in categories.items())
+        checks.append({
+            "name": "bdd-fr-incomplete",
+            "status": "warn",
+            "message": f"{fr}: missing categories: {', '.join(missing)} ({details})",
+        })
+
+    # Check cross-stack coverage for INT-FR
+    cross_stack_files = [f for f in feature_files if "cross-stack" in str(f)]
+    int_frs = {fr for fr in fr_scenarios if fr.startswith("INT-")}
+
+    if int_frs:
+        cross_int_frs = set()
+        for f in cross_stack_files:
+            for sc in _parse_feature_file(f):
+                for fr in sc["frs"]:
+                    if fr.startswith("INT-"):
+                        cross_int_frs.add(fr)
+
+        missing_cross = int_frs - cross_int_frs
+        if missing_cross:
+            checks.append({
+                "name": "bdd-cross-stack-missing",
+                "status": "warn",
+                "message": f"INT-FRs without cross-stack feature: {', '.join(sorted(missing_cross))}",
+            })
+        else:
+            checks.append({
+                "name": "bdd-cross-stack",
+                "status": "pass",
+                "message": f"All {len(int_frs)} INT-FRs have cross-stack feature coverage",
+            })
+
+    has_fail = any(c["status"] == "fail" for c in checks)
+    return {"passed": not has_fail, "checks": checks}

package/cdh/validators/dag.py

@@ -0,0 +1,179 @@
+import re
+from pathlib import Path
+
+import yaml
+
+
+def _find_task_lists(root: Path) -> list[Path]:
+    changes_dir = root / "aidlc" / "openspec" / "changes"
+    if not changes_dir.exists():
+        return []
+    return sorted(changes_dir.rglob("task-list.md"))
+
+
+def _parse_task_list(path: Path) -> list[dict]:
+    try:
+        text = path.read_text(encoding="utf-8")
+    except Exception:
+        return []
+
+    yaml_blocks = re.findall(
+        r"```yaml\s*\n(.*?)```", text, re.DOTALL
+    )
+    if not yaml_blocks:
+        yaml_blocks = re.findall(
+            r"```\s*\n(.*?)```", text, re.DOTALL
+        )
+
+    for block in yaml_blocks:
+        try:
+            data = yaml.safe_load(block)
+        except Exception:
+            continue
+        if isinstance(data, dict) and "units" in data:
+            return data["units"]
+        if isinstance(data, list):
+            return data
+    return []
+
+
+def _detect_cycles(units: list[dict]) -> list[str]:
+    node_map = {}
+    for u in units:
+        uid = u.get("id", "")
+        if uid:
+            node_map[uid] = {
+                "depends_on": u.get("depends_on", []) or [],
+            }
+
+    edges: list[tuple[str, str]] = []
+    for uid, info in node_map.items():
+        for dep in info["depends_on"]:
+            if dep in node_map:
+                edges.append((uid, dep))
+
+    adj: dict[str, list[str]] = {uid: [] for uid in node_map}
+    in_degree: dict[str, int] = {uid: 0 for uid in node_map}
+    for src, tgt in edges:
+        adj[src].append(tgt)
+        in_degree[tgt] = in_degree.get(tgt, 0) + 1
+
+    queue = [uid for uid, deg in in_degree.items() if deg == 0]
+    visited = 0
+
+    while queue:
+        node = queue.pop(0)
+        visited += 1
+        for neighbor in adj.get(node, []):
+            in_degree[neighbor] -= 1
+            if in_degree[neighbor] == 0:
+                queue.append(neighbor)
+
+    if visited != len(node_map):
+        cycle_nodes = [uid for uid, deg in in_degree.items() if deg > 0]
+        return cycle_nodes
+    return []
+
+
+def run_dag_check(root: Path) -> dict:
+    checks = []
+    task_lists = _find_task_lists(root)
+
+    if not task_lists:
+        return {
+            "passed": True,
+            "checks": [{
+                "name": "dag-task-list-found",
+                "status": "pass",
+                "message": "No task-list.md found yet (project may be in Understand phase)",
+            }],
+        }
+
+    all_units = []
+    for tl in task_lists:
+        units = _parse_task_list(tl)
+        if units:
+            all_units.extend(units)
+
+    if not all_units:
+        return {
+            "passed": True,
+            "checks": [{
+                "name": "dag-units-parsed",
+                "status": "pass",
+                "message": "task-list.md exists but no YAML units found (may be placeholder)",
+            }],
+        }
+
+    checks.append({
+        "name": "dag-units-found",
+        "status": "pass",
+        "message": f"Found {len(all_units)} task units across {len(task_lists)} files",
+    })
+
+    cycle_nodes = _detect_cycles(all_units)
+    if cycle_nodes:
+        checks.append({
+            "name": "dag-cycle",
+            "status": "fail",
+            "message": f"Cycle detected involving units: {', '.join(cycle_nodes)}",
+        })
+    else:
+        checks.append({
+            "name": "dag-cycle",
+            "status": "pass",
+            "message": "No cycles detected in task DAG",
+        })
+
+    # Check for units with no depends_on (isolated roots)
+    unit_ids = {u.get("id") for u in all_units if u.get("id")}
+    all_deps = set()
+    for u in all_units:
+        for dep in (u.get("depends_on") or []):
+            all_deps.add(dep)
+
+    unresolved = all_deps - unit_ids
+    if unresolved:
+        checks.append({
+            "name": "dag-unresolved-dep",
+            "status": "warn",
+            "message": f"depends_on references units not in task list: {', '.join(sorted(unresolved))}",
+        })
+    else:
+        checks.append({
+            "name": "dag-unresolved-dep",
+            "status": "pass",
+            "message": "All depends_on references resolve to defined units",
+        })
+
+    # Check cross-component: tasks consuming INT contract should depend on INT task
+    fr_to_unit = {}
+    for u in all_units:
+        fr = u.get("fr", "")
+        if fr:
+            fr_to_unit[fr] = u.get("id", "")
+
+    int_fr_defined = {fr for fr in fr_to_unit if fr.startswith("INT-")}
+    int_unit_ids = {fr_to_unit[fr] for fr in int_fr_defined}
+    consuming_frs = {fr for fr in fr_to_unit if not fr.startswith("INT-") and fr != ""}
+
+    for fr in consuming_frs:
+        uid = fr_to_unit[fr]
+        unit = next((u for u in all_units if u.get("id") == uid), None)
+        if not unit:
+            continue
+        affected = unit.get("affects", [])
+        deps = unit.get("depends_on", [])
+        affects = [a for a in (affected or []) if a != "contracts"]
+
+        if len(affects) >= 2:
+            has_int_dep = any(d in int_unit_ids for d in deps)
+            if not has_int_dep and int_unit_ids:
+                checks.append({
+                    "name": "dag-cross-component-int",
+                    "status": "warn",
+                    "message": f"Unit '{uid}' affects {len(affects)} components but has no INT-FR dependency",
+                })
+
+    has_fail = any(c["status"] == "fail" for c in checks)
+    return {"passed": not has_fail, "checks": checks}