@michaelxwb/code-flow 0.6.4 → 0.8.1

package/src/core/code-flow/scripts/codeflow/acceptance/cf_acceptance_selection.py

@@ -0,0 +1,266 @@
+"""Shared owner, profile and dependency selection for acceptance scenarios."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import subprocess
+from typing import Callable, Mapping, Optional, Sequence
+
+from codeflow.acceptance.cf_acceptance_schema import scenario_check_ids
+from codeflow.acceptance.cf_check_inputs import match_path, missing_input_patterns, repo_input_files
+
+
+def select_owned(items: list[Mapping[str, object]], owner: str) -> list[Mapping[str, object]]:
+    """Keep scenarios owned by the active TASK; ownerless legacy scenarios stay
+    included so old manifests keep working. Cross-TASK depends_on edges are
+    pruned: single-TASK ordering is enforced here, whole-demand ordering at
+    the final (archive/E2E) gate."""
+    if not owner:
+        return items
+    # 逗号分隔时按多个 owner 过滤：批次 smoke 只跑本批已并入 TASK 的场景。
+    owners = {value.strip() for value in owner.split(",") if value.strip()}
+    kept = [
+        item for item in items
+        if not isinstance(item.get("owner"), str) or not item.get("owner") or item.get("owner") in owners
+    ]
+    kept_ids = {str(item.get("id")) for item in kept}
+    pruned: list[Mapping[str, object]] = []
+    for item in kept:
+        if not isinstance(item, dict):
+            pruned.append(item)
+            continue
+        deps = item.get("depends_on")
+        if isinstance(deps, list):
+            item = {**item, "depends_on": [dep for dep in deps if str(dep) in kept_ids]}
+        pruned.append(item)
+    return pruned
+
+
+def changed_paths(root: str) -> set[str]:
+    changed: set[str] = set()
+    for arguments in (("diff", "--no-renames", "--name-only", "HEAD"), ("ls-files", "--others", "--exclude-standard")):
+        completed = subprocess.run(("git", "-C", root, *arguments), text=True, capture_output=True, check=False)
+        if completed.returncode != 0:
+            return set()
+        changed.update(line.strip() for line in completed.stdout.splitlines() if line.strip())
+    return changed
+
+
+@dataclass(frozen=True)
+class _ProfileContext:
+    """Manifest-wide facts shared by every per-scenario selection rule."""
+
+    checks: Mapping[str, Mapping[str, object]]
+    changed: frozenset[str]
+    scenarios: tuple[Mapping[str, object], ...]
+    explicit_priority: bool
+    forced: frozenset[str]
+    has_smoke_profile: bool
+    has_e2e: bool
+    e2e_smoke_exists: bool
+
+
+@dataclass(frozen=True)
+class _ScenarioFacts:
+    """Per-scenario facts computed once, then consumed by the rule tables."""
+
+    scenario_id: str
+    priority: str
+    is_e2e: bool
+    smoke: bool
+    check_ids: tuple[str, ...]
+    scenario_checks: tuple[Optional[Mapping[str, object]], ...]
+    path_patterns: tuple[str, ...]
+    path_matches: bool
+    repo_scoped: bool
+    inputs_match: bool
+    inputs_incomplete: bool
+
+
+_RuleTable = tuple[tuple[Callable[["_ProfileContext", "_ScenarioFacts"], bool],
+                          Callable[["_ProfileContext", "_ScenarioFacts"], bool]], ...]
+
+
+# Ordered (condition, decision) rules. The first matching condition decides
+# whether the scenario runs; later rules are not consulted. Explicit smoke
+# markers on E2E journeys keep smoke from silently expanding to every E2E.
+_SMOKE_RULES: _RuleTable = (
+    (lambda ctx, facts: facts.is_e2e,
+     lambda ctx, facts: facts.smoke or not ctx.e2e_smoke_exists),
+    (lambda ctx, facts: ctx.explicit_priority,
+     lambda ctx, facts: facts.priority.upper() == "P0" or facts.smoke),
+    (lambda ctx, facts: ctx.has_smoke_profile,
+     lambda ctx, facts: facts.smoke),
+    (lambda ctx, facts: ctx.has_e2e,
+     lambda ctx, facts: False),
+    (lambda ctx, facts: True,
+     lambda ctx, facts: True),
+)
+
+# Changed runs only path-scoped E2E journeys. An empty changed set means the
+# diff is unavailable, so E2E journeys fail closed and still run. Smoke E2E
+# without trigger paths belongs to the explicit smoke profile.
+_CHANGED_RULES: _RuleTable = (
+    (lambda ctx, facts: facts.is_e2e and bool(facts.path_patterns),
+     lambda ctx, facts: not ctx.changed or facts.path_matches or facts.inputs_incomplete or facts.inputs_match),
+    (lambda ctx, facts: facts.is_e2e and facts.smoke,
+     lambda ctx, facts: False),
+    (lambda ctx, facts: True,
+     lambda ctx, facts: (not ctx.explicit_priority
+                         or facts.priority.upper() == "P0"
+                         or facts.smoke
+                         or facts.repo_scoped
+                         or not ctx.changed
+                         or facts.inputs_match)),
+)
+
+_PROFILE_RULES: Mapping[str, _RuleTable] = {
+    "smoke": _SMOKE_RULES,
+    "changed": _CHANGED_RULES,
+}
+
+
+def _apply_rule_table(rules: _RuleTable, ctx: _ProfileContext,
+                      facts: _ScenarioFacts) -> bool:
+    for condition, decision in rules:
+        if condition(ctx, facts):
+            return decision(ctx, facts)
+    return False
+
+
+def _profile_context(scenarios: Sequence[Mapping[str, object]],
+                     checks: Mapping[str, Mapping[str, object]],
+                     changed: Sequence[str],
+                     force_ids: Sequence[str]) -> _ProfileContext:
+    def _is_smoke(scenario: Mapping[str, object]) -> bool:
+        return bool(scenario.get("smoke")) or any(
+            str((checks.get(check_id) or {}).get("profile", "")) == "smoke"
+            for check_id in scenario_check_ids(scenario)
+        )
+
+    return _ProfileContext(
+        checks=checks,
+        changed=frozenset(changed),
+        scenarios=tuple(scenarios),
+        explicit_priority=any(isinstance(item.get("priority"), str) for item in scenarios),
+        forced=frozenset(str(item) for item in force_ids),
+        has_smoke_profile=any(
+            str((check or {}).get("profile", "")) == "smoke" for check in checks.values()),
+        has_e2e=any(str(item.get("kind", "")) == "e2e" for item in scenarios),
+        e2e_smoke_exists=any(
+            str(item.get("kind", "")) == "e2e" and _is_smoke(item) for item in scenarios),
+    )
+
+
+def _scenario_facts(ctx: _ProfileContext, scenario: Mapping[str, object]) -> _ScenarioFacts:
+    check_ids = tuple(scenario_check_ids(scenario))
+    scenario_checks = tuple(ctx.checks.get(check_id) for check_id in check_ids)
+    path_patterns = [
+        str(pattern) for pattern in (scenario.get("trigger_paths") or [])
+        if str(pattern).strip()
+    ]
+    path_patterns.extend(
+        str(pattern)
+        for check in scenario_checks if isinstance(check, Mapping)
+        for pattern in (check.get("paths") or [])
+        if str(pattern).strip()
+    )
+    path_patterns = tuple(dict.fromkeys(path_patterns))
+    inputs_by_check = [(check or {}).get("inputs") for check in scenario_checks]
+    return _ScenarioFacts(
+        scenario_id=str(scenario.get("id")),
+        priority=str(scenario.get("priority", "")),
+        is_e2e=str(scenario.get("kind", "")) == "e2e",
+        smoke=(bool(scenario.get("smoke")) or any(
+            str((check or {}).get("profile", "")) == "smoke" for check in scenario_checks)),
+        check_ids=check_ids,
+        scenario_checks=scenario_checks,
+        path_patterns=path_patterns,
+        path_matches=any(
+            match_path(path, pattern) for pattern in path_patterns for path in ctx.changed),
+        repo_scoped=not check_ids or any(not value for value in inputs_by_check)
+                    or any((check or {}).get("_inputs_incomplete") for check in scenario_checks),
+        inputs_match=any(
+            match_path(path, str(pattern))
+            for value in inputs_by_check if isinstance(value, list)
+            for pattern in value for path in ctx.changed),
+        inputs_incomplete=any((check or {}).get("_inputs_incomplete") for check in scenario_checks),
+    )
+
+
+def _scenario_selected(ctx: _ProfileContext, scenario: Mapping[str, object],
+                       profile: str) -> bool:
+    facts = _scenario_facts(ctx, scenario)
+    if facts.scenario_id in ctx.forced:
+        return True
+    return _apply_rule_table(_PROFILE_RULES[profile], ctx, facts)
+
+
+def _with_dependencies(scenarios: Sequence[Mapping[str, object]],
+                       selected: list[Mapping[str, object]]) -> list[Mapping[str, object]]:
+    selected_ids = {str(item.get("id")) for item in selected}
+    by_scenario = {str(item.get("id")): item for item in scenarios}
+    pending = list(selected)
+    while pending:
+        current = pending.pop()
+        deps = current.get("depends_on", [])
+        if not isinstance(deps, list):
+            continue
+        for dep in deps:
+            dep_id = str(dep)
+            if dep_id in selected_ids or dep_id not in by_scenario:
+                continue
+            selected.append(by_scenario[dep_id])
+            selected_ids.add(dep_id)
+            pending.append(by_scenario[dep_id])
+    return selected
+
+
+def select_scenarios(scenarios: Sequence[Mapping[str, object]],
+                      checks: Mapping[str, Mapping[str, object]],
+                      profile: str, changed: Sequence[str],
+                      force_ids: Sequence[str] = ()) -> list[Mapping[str, object]]:
+    ctx = _profile_context(scenarios, checks, changed, force_ids)
+    selected = [scenario for scenario in ctx.scenarios
+                if _scenario_selected(ctx, scenario, profile)]
+    return _with_dependencies(ctx.scenarios, selected)
+
+
+def _profile_result(data: Mapping[str, object], profile: str,
+                    selected: Sequence[Mapping[str, object]]) -> dict[str, object]:
+    selected_check_ids = {
+        check_id for item in selected for check_id in scenario_check_ids(item)
+    }
+    result = dict(data)
+    result["scenarios"] = list(selected)
+    if "checks" in data:
+        result["checks"] = [
+            item for item in data.get("checks", []) or []
+            if isinstance(item, Mapping) and str(item.get("id")) in selected_check_ids
+        ]
+    result["profile"] = profile
+    return result
+
+
+def select_profile(data: Mapping[str, object], root: str, profile: str,
+                    force_ids: Sequence[str] = ()) -> dict[str, object]:
+    """Return a shallow manifest view filtered by smoke/changed/full."""
+    if profile == "full":
+        return dict(data)
+    checks = {
+        str(item.get("id")): item
+        for item in data.get("checks", []) or []
+        if isinstance(item, Mapping) and isinstance(item.get("id"), str)
+    }
+    files = repo_input_files(root)
+    missing = {key: missing_input_patterns(root, check.get("inputs", []), files)
+               for key, check in checks.items()}
+    checks = {key: {**check, "_inputs_incomplete": bool(missing[key])} for key, check in checks.items()}
+    scenarios = [item for item in data.get("scenarios", []) or [] if isinstance(item, Mapping)]
+    selected = select_scenarios(scenarios, checks, profile, changed_paths(root), force_ids)
+    result = _profile_result(data, profile, selected)
+    if profile == "changed" and any(missing.values()):
+        result["selection_reason"] = "incomplete_inputs_conservative"
+        result["missing_input_patterns"] = {key: value for key, value in missing.items() if value}
+    return result
+
+

package/src/core/code-flow/scripts/codeflow/acceptance/cf_check_inputs.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""Per-check input hashing: content-addressed identity for incremental verify.
+
+`check.inputs` declares the files a check depends on. Hashing only those files
+lets `changed` rerun affected checks instead of the whole worktree. When inputs
+are absent the caller falls back to the repo-wide fingerprint with scope=repo.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import fnmatch
+import re
+import subprocess
+from pathlib import Path
+from typing import Mapping, Optional, Sequence
+
+
+def glob_to_regex(pattern: str) -> re.Pattern:
+    """Translate a git-style glob to regex; `**/` matches zero directories."""
+    out: list[str] = []
+    index = 0
+    while index < len(pattern):
+        char = pattern[index]
+        if char == "*":
+            if pattern[index:index + 3] == "**/":
+                out.append("(?:.*/)?")
+                index += 3
+                continue
+            if pattern[index:index + 2] == "**":
+                out.append(".*")
+                index += 2
+                continue
+            out.append("[^/]*")
+            index += 1
+            continue
+        if char == "?":
+            out.append("[^/]")
+        else:
+            out.append(re.escape(char))
+        index += 1
+    return re.compile("^" + "".join(out) + "$")
+
+
+def match_path(path: str, pattern: str) -> bool:
+    normalized = path.replace("\\", "/")
+    # Git pathspec: a pattern without a slash matches at any depth.
+    if "/" not in pattern:
+        return fnmatch.fnmatchcase(normalized.rsplit("/", 1)[-1], pattern)
+    return bool(glob_to_regex(pattern).match(normalized))
+
+
+def _git(root: str, *arguments: str) -> Optional[str]:
+    completed = subprocess.run(
+        ("git", "-C", root, *arguments), text=True, encoding="utf-8", capture_output=True, check=False
+    )
+    return completed.stdout if completed.returncode == 0 else None
+
+
+def expand_inputs(root: str, patterns: Sequence[str]) -> tuple[str, ...]:
+    """Tracked + untracked files matching the declared input globs."""
+    if not patterns:
+        return ()
+    tracked = _git(root, "ls-files")
+    untracked = _git(root, "ls-files", "--others", "--exclude-standard")
+    if tracked is None or untracked is None:
+        return ()
+    paths: set[str] = set()
+    for line in (tracked + untracked).splitlines():
+        path = line.strip()
+        if path and any(match_path(path, pattern) for pattern in patterns):
+            paths.add(path)
+    return tuple(sorted(paths))
+
+
+def hash_files(root: str, paths: Sequence[str]) -> Optional[dict[str, str]]:
+    """Batch-hash worktree contents (one git process)."""
+    if not paths:
+        return {}
+    completed = subprocess.run(
+        ("git", "-C", root, "hash-object", "--stdin-paths"),
+        input="\n".join(paths) + "\n", text=True, encoding="utf-8", capture_output=True, check=False,
+    )
+    if completed.returncode != 0:
+        return None
+    hashes = completed.stdout.splitlines()
+    if len(hashes) != len(paths):
+        return None
+    return {path: sha.strip() for path, sha in zip(paths, hashes)}
+
+
+def check_input_hash(root: str, check: Mapping[str, object],
+                     fallback: str = "") -> dict[str, object]:
+    """Return {"input_hash", "scope"} for one check."""
+    return check_input_hashes(root, {"": check}, fallback)[""]
+
+
+def _registered_fallback(check: Mapping[str, object], fallback: str) -> str:
+    registration = {key: check[key] for key in ("suite", "test_ids", "markers", "collect", "level", "environment_revision", "evidence_ttl_seconds") if key in check}
+    if not fallback or not registration:
+        return fallback
+    payload = json.dumps([fallback, registration], sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(payload.encode()).hexdigest()
+
+
+def missing_input_patterns(root: str, patterns: Sequence[str], files: Sequence[str]) -> list[str]:
+    """Report patterns with no present file; deleted and unknown inputs are unsafe."""
+    base = Path(root)
+    return [pattern for pattern in patterns if not any(
+        match_path(path, pattern) and (base / path).is_file() for path in files
+    )]
+
+
+def check_input_hashes(root: str, checks: Mapping[str, Mapping[str, object]],
+                       fallback: str = "") -> dict[str, dict[str, object]]:
+    """Hash the union of all declared inputs once, then derive per-check identities."""
+    patterns_by_check: dict[str, list[str]] = {}
+    for check_id, check in checks.items():
+        value = check.get("inputs")
+        patterns_by_check[check_id] = [str(item) for item in value] if isinstance(value, list) else []
+    all_patterns = sorted({pattern for values in patterns_by_check.values() for pattern in values})
+    repo_files = repo_input_files(root) if all_patterns else ()
+    matched: dict[str, list[str]] = {}
+    missing: dict[str, list[str]] = {}
+    union: set[str] = set()
+    for check_id, patterns in patterns_by_check.items():
+        missing[check_id] = missing_input_patterns(root, patterns, repo_files)
+        files = [path for path in repo_files if (Path(root) / path).is_file()
+                 and any(match_path(path, pattern) for pattern in patterns)]
+        matched[check_id] = files
+        union.update(files)
+    hashed = hash_files(root, sorted(union))
+    result: dict[str, dict[str, object]] = {}
+    for check_id, patterns in patterns_by_check.items():
+        bound_fallback = _registered_fallback(checks[check_id], fallback)
+        if not patterns:
+            result[check_id] = {"input_hash": bound_fallback, "scope": "repo"}
+            continue
+        if missing[check_id]:
+            result[check_id] = {"input_hash": bound_fallback, "scope": "incomplete",
+                                "missing_patterns": missing[check_id]}
+            continue
+        if not matched[check_id]:
+            result[check_id] = {"input_hash": bound_fallback, "scope": "empty"}
+            continue
+        if hashed is None:
+            result[check_id] = {"input_hash": "", "scope": "unavailable"}
+            continue
+        check = checks[check_id]
+        identity = {
+            key: check.get(key) for key in
+            ("command", "cwd", "timeout", "env", "env_scope", "preflight", "parallel_safe", "profile")
+        }
+        identity.update({key: check[key] for key in ("suite", "test_ids", "markers", "collect", "level", "environment_revision", "evidence_ttl_seconds") if key in check})
+        payload = json.dumps(
+            [identity, sorted((path, hashed[path]) for path in matched[check_id])],
+            ensure_ascii=False, sort_keys=True,
+        )
+        result[check_id] = {
+            "input_hash": hashlib.sha256(payload.encode("utf-8")).hexdigest(),
+            "scope": "inputs",
+        }
+    return result
+
+
+def repo_input_files(root: str) -> tuple[str, ...]:
+    tracked = _git(root, "ls-files")
+    untracked = _git(root, "ls-files", "--others", "--exclude-standard")
+    if tracked is None or untracked is None:
+        return ()
+    return tuple(sorted({line.strip() for line in (tracked + untracked).splitlines() if line.strip()}))