@michaelxwb/code-flow 0.8.1 → 1.0.0

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

@@ -1,266 +0,0 @@
-"""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

@@ -1,172 +0,0 @@
-#!/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()}))