@michaelxwb/code-flow 0.6.2 → 0.6.3

package/src/core/code-flow/scripts/cf_task_runtime.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass, replace
 import hashlib
+import json
 from pathlib import Path
 import time
 from typing import Mapping, Optional
@@ -29,6 +30,8 @@ from cf_spec_resolver import resolve_candidates, SpecCandidate
 from cf_spec_session import context_sha256
 from cf_spec_verify import VerificationEvidence, VerificationScope, run_all_verifiers
 from cf_core import phase_timing
+from cf_acceptance_schema import load_manifest, validate_execution_baseline, verified_evidence
+from cf_exec_base import execution_session
 
 
 @dataclass(frozen=True)
@@ -51,24 +54,45 @@ def _context_path(task_dir: str) -> str:
     return str(Path(task_dir) / "spec-context.yml")
 
 
-def _manual_manifest_issue(task_dir: str) -> str:
+def _manual_manifest_issue(task_dir: str, owner: str = "") -> str:
     path = Path(task_dir) / ".acceptance-manifest.json"
     if not path.is_file():
         return ""
     try:
         import json
 
-        data = json.loads(path.read_text(encoding="utf-8"))
+        data = load_manifest(path)
         pending = [
             item.get("id", "unknown")
             for item in data.get("scenarios", [])
-            if isinstance(item, dict) and item.get("kind") == "manual" and item.get("status") != "verified"
+            if item.get("kind") == "manual" and not verified_evidence(item)
+            and (not owner or not isinstance(item.get("owner"), str) or not item.get("owner") or item.get("owner") == owner)
         ]
         return f"manual 场景未完成: {', '.join(pending)}" if pending else ""
     except (OSError, ValueError, TypeError):
         return "acceptance manifest invalid"
 
 
+def _acceptance_baseline_issue(task_dir: str, owner: str) -> str:
+    from cf_workflow_service import locate_task_file
+    path = Path(task_dir) / ".acceptance-manifest.json"
+    task = locate_task_file(task_dir, owner)
+    try:
+        requires = task is not None and "## Acceptance Coverage" in task.read_text(encoding="utf-8")
+        if not path.is_file():
+            return "acceptance_manifest_missing" if requires else ""
+        data = load_manifest(path)
+        if requires:
+            from cf_acceptance_manifest import validate_manifest
+            valid, reason = validate_manifest(str(task), str(path))
+            if not valid:
+                return reason
+        validate_execution_baseline(path, data)
+        return ""
+    except (OSError, ValueError) as exc:
+        return f"acceptance_manifest_invalid: {exc}"
+
+
 def _required_candidate(candidate: SpecCandidate) -> bool:
     metadata = candidate.metadata
     return metadata.enforcement == "required" and any(
@@ -176,33 +200,38 @@ def _rule_manual_confirmation(rule: RuleBinding) -> Optional[Mapping[str, object
     }
 
 
-def run_done_gate(root: str, task_dir: str, cheap: bool = False, budget: Optional[float] = None, include_e2e: bool = False) -> DoneResult:
+def _run_acceptance(root: str, task_dir: str, owner: str, include_e2e: bool,
+                    deadline: Optional[float]) -> str:
+    baseline_issue = _acceptance_baseline_issue(task_dir, owner)
+    if baseline_issue:
+        return baseline_issue
+    manual_issue = _manual_manifest_issue(task_dir, owner)
+    if manual_issue:
+        return manual_issue
+    manifest_path = Path(task_dir) / ".acceptance-manifest.json"
+    if manifest_path.is_file():
+        from cf_acceptance_runner import run_manifest
+        scenario_result = run_manifest(str(manifest_path), root, write_evidence=True, include_e2e=include_e2e, owner=owner, deadline=deadline)
+        if scenario_result["decision"] == "block":
+            reason = scenario_result.get("error") or "acceptance scenario failed"
+            return f"acceptance scenario failed: {reason}"
+    return ""
+
+
+def _run_done_gate(root: str, task_dir: str, cheap: bool = False, budget: Optional[float] = None, include_e2e: bool = False, task_id: str = "") -> DoneResult:
+    active = load_active_task(root)
+    owner = task_id or active.task_id
+    if owner != active.task_id or (Path(root) / active.task_dir).resolve() != Path(task_dir).resolve():
+        return DoneResult("block", (), (), "active_mismatch: task identity does not match marker")
     started = time.monotonic()
-    phase_started = time.monotonic()
     scope_result = evaluate_scope(root, task_dir)
-    phase_timing("done.evaluate_scope", phase_started)
+    phase_timing("done.evaluate_scope", started)
     if scope_result.decision == "pause":
         return DoneResult("block", scope_result.files, (), scope_result.message)
-    manual_issue = _manual_manifest_issue(task_dir)
-    if manual_issue:
-        return DoneResult("block", scope_result.files, (), manual_issue)
-    manifest_path = Path(task_dir) / ".acceptance-manifest.json"
-    if manifest_path.is_file():
-        try:
-            import json
-            manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
-            has_commands = any(
-                isinstance(item, dict) and isinstance(item.get("command"), list)
-                for item in manifest.get("scenarios", [])
-            )
-        except (OSError, ValueError, TypeError):
-            return DoneResult("block", scope_result.files, (), "acceptance manifest invalid")
-        if has_commands:
-            from cf_acceptance_runner import run_manifest
-
-            scenario_result = run_manifest(str(manifest_path), root, write_evidence=True, include_e2e=include_e2e)
-            if scenario_result["decision"] == "block":
-                return DoneResult("block", scope_result.files, (), "acceptance scenario failed")
+    deadline = started + budget if budget is not None else None
+    issue = _run_acceptance(root, task_dir, owner, include_e2e, deadline)
+    if issue:
+        return DoneResult("block", scope_result.files, (), issue)
     phase_started = time.monotonic()
     context = load_context(_context_path(task_dir))
     diff_hash = _diff_hash(root, scope_result.files)
@@ -227,4 +256,10 @@ def run_done_gate(root: str, task_dir: str, cheap: bool = False, budget: Optiona
         save_context(_context_path(task_dir), updated)
     gate = validate_stage(updated, "code", diff_sha256=diff_hash)
     phase_timing("done.total", started)
-    return DoneResult(gate.decision, scope_result.files, tuple(all_evidence))
+    return DoneResult(gate.decision, scope_result.files, tuple(all_evidence),
+                      "; ".join(issue.message for issue in gate.errors))
+
+
+def run_done_gate(root: str, task_dir: str, cheap: bool = False, budget: Optional[float] = None, include_e2e: bool = False, task_id: str = "") -> DoneResult:
+    with execution_session():
+        return _run_done_gate(root, task_dir, cheap, budget, include_e2e, task_id)

package/src/core/code-flow/scripts/cf_task_state.py

@@ -0,0 +1,3 @@
+"""Shared lifecycle predicates without loading the workflow runtime."""
+
+FINISHED_STATUSES = ("done", "verified")

package/src/core/code-flow/scripts/cf_task_workflow.py

@@ -0,0 +1,107 @@
+"""Executable task handoffs used by every platform command."""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+from pathlib import Path
+from typing import IO, Optional, Sequence
+import sys
+
+from cf_acceptance_runner import run_manifest
+from cf_acceptance_schema import load_manifest, validate_execution_baseline, verified_evidence
+from cf_task_index import parse_task_file
+from cf_task_runtime import run_done_gate
+from cf_workflow_service import (FINISHED_STATUSES, _require_marker_task,
+                                 _sync_markdown, block_task, complete_task, locate_task_file, resume_task)
+from cf_workflow_transaction import recover_transition
+
+
+def finish_task(root: str, directory: str, task_file: str, task_id: str) -> dict[str, object]:
+    _require_marker_task(root, task_id, directory, task_file)
+    gate = run_done_gate(root, directory, task_id=task_id)
+    if gate.decision != "pass":
+        return {"decision": "block", "reason": gate.message, "evidence": gate.evidence}
+    return {"decision": "pass", **complete_task(root, directory, task_file, task_id, True)}
+
+
+def _demand_tasks(directory: Path) -> list[tuple[Path, str, str]]:
+    tasks = []
+    seen = set()
+    for task_file in sorted(directory.glob("*.md")):
+        if task_file.name.endswith((".design.md", ".prd.md")):
+            continue
+        if not re.search(r"(?m)^## TASK-\d+:", task_file.read_text(encoding="utf-8")):
+            continue
+        for node in parse_task_file(str(task_file)):
+            if node.task_id in seen:
+                raise ValueError(f"duplicate task id: {node.task_id}")
+            seen.add(node.task_id)
+            tasks.append((task_file, node.task_id, node.status))
+    if not tasks:
+        raise ValueError("no TASK sections found")
+    return tasks
+
+
+def verify_e2e(root: str, directory: str) -> dict[str, object]:
+    recover_transition(root)
+    tasks = _demand_tasks(Path(directory))
+    unfinished = [task_id for _, task_id, status in tasks if status not in FINISHED_STATUSES]
+    if unfinished:
+        return {"decision": "block", "reason": "unfinished_tasks", "tasks": unfinished}
+    if (Path(root) / ".code-flow/.active-task.json").exists():
+        return {"decision": "block", "reason": "finish_active_task_first"}
+    manifest = Path(directory) / ".acceptance-manifest.json"
+    data = load_manifest(manifest)
+    validate_execution_baseline(manifest, data)
+    bound_task = (manifest.parent / str(data.get("task_file", ""))).resolve()
+    if {task.resolve() for task, _, _ in tasks} != {bound_task}:
+        return {"decision": "block", "reason": "acceptance_manifest_task_mismatch"}
+    required = [row["id"] for row in data["scenarios"] if row.get("kind", "functional") != "e2e"
+                and not verified_evidence(row)]
+    if required:
+        return {"decision": "block", "reason": "functional_or_manual_evidence_missing", "scenarios": required}
+    result = run_manifest(str(manifest), root, write_evidence=True, only_e2e=True)
+    if result["decision"] == "pass":
+        for task_file, task_id, _ in tasks:
+            _sync_markdown(str(task_file), task_id, "verified")
+    return result
+
+
+def main(argv: Optional[Sequence[str]] = None, stdout: IO[str] = sys.stdout) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("action", choices=("finish", "block", "resume", "verify-e2e"))
+    parser.add_argument("--root", default=os.getcwd())
+    parser.add_argument("--task-dir", required=True)
+    parser.add_argument("--task", default="")
+    parser.add_argument("--reason", default="")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv)
+    try:
+        root = str(Path(args.root).resolve())
+        directory = str((Path(root) / args.task_dir).resolve())
+        if Path(root) not in Path(directory).parents:
+            raise ValueError("task directory outside project")
+        recover_transition(root)
+        if args.action == "verify-e2e":
+            result = verify_e2e(root, directory)
+        else:
+            task = locate_task_file(directory, args.task)
+            if task is None:
+                raise ValueError("task file missing or ambiguous")
+            if args.action == "finish":
+                result = finish_task(root, directory, str(task), args.task)
+            elif args.action == "block":
+                result = block_task(root, directory, str(task), args.task, args.reason)
+            else:
+                result = resume_task(root, directory, str(task), args.task)
+        stdout.write(json.dumps(result, ensure_ascii=False))
+        return 3 if result.get("decision") == "block" else 0
+    except (OSError, ValueError) as exc:
+        stdout.write(json.dumps({"decision": "block", "error": str(exc)}, ensure_ascii=False))
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/core/code-flow/scripts/cf_user_prompt_hook.py

@@ -19,6 +19,7 @@ from cf_core import (
     timing_log,
 )
 from cf_session_state import load_session_state, save_session_state
+from cf_spec_context import injection_version
 from cf_spec_router import RouterError, route_prompt
 
 
@@ -133,9 +134,11 @@ def main() -> None:
             reminder = _session_reminder(root, sid)
         text = result.text
         if result.mode == "task" and result.context_sha256:
-            # Dedup: inject the projection once per session/context, refreshing
+            # Dedup: inject once per session/task/contract version, refreshing
             # at the compress cadence so long sessions do not re-pay 12k chars
-            # on every prompt.
+            # on every prompt. The key covers task_id and the TASK contract
+            # digest (not just the Context hash) so switching TASKs on a
+            # shared Context always re-injects the new contract.
             state = load_session_state(root)
             count = int(state.get("prompt_count", 0))
             dirty = False
@@ -146,12 +149,13 @@ def main() -> None:
                 count += 1
                 state["prompt_count"] = count
                 dirty = True
-            injected = state.get("injected_sha256")
+            version = injection_version(root, sid, result.context_sha256)
+            injected = state.get("injected_version")
             last_inject = int(state.get("last_inject_prompt", 0))
-            if injected == result.context_sha256 and count - last_inject < _REINJECT_INTERVAL:
+            if injected == version and count - last_inject < _REINJECT_INTERVAL:
                 text = ""
             else:
-                state["injected_sha256"] = result.context_sha256
+                state["injected_version"] = version
                 state["last_inject_prompt"] = count
                 dirty = True
             if dirty:

package/src/core/code-flow/scripts/cf_validation.py

@@ -0,0 +1,81 @@
+"""Programmatic validation entry with complete Git scope and argv execution."""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+from pathlib import Path
+from typing import IO, Optional, Sequence
+import sys
+
+from cf_exec_base import execution_session
+from cf_spec_context import _git_changes, current_owned_paths, load_active_task
+
+
+def validation_scope(root: str, files: Sequence[str] = ()) -> tuple[str, ...]:
+    base = Path(root).resolve()
+    if files:
+        selected = []
+        for name in files:
+            path = (base / name).resolve()
+            if base not in path.parents:
+                raise ValueError(f"validation path outside project: {name}")
+            selected.append(path.relative_to(base).as_posix())
+        return tuple(sorted(set(selected)))
+    if (base / ".code-flow/.active-task.json").exists():
+        return current_owned_paths(str(base), load_active_task(str(base)))
+    return tuple(sorted(_git_changes(str(base))))
+
+
+def _validators(root: str) -> list[dict[str, object]]:
+    from cf_stop_hook import load_validators
+    if (Path(root) / ".code-flow/validation.yml").is_file():
+        return load_validators(root)
+    package = Path(root) / "package.json"
+    if not package.is_file():
+        return []
+    data = json.loads(package.read_text(encoding="utf-8"))
+    scripts = data.get("scripts", {}) if isinstance(data, dict) else {}
+    if not isinstance(scripts, dict):
+        raise ValueError("invalid package scripts")
+    return [{"name": name, "trigger": "*", "command": f"npm run {name}", "timeout": 60000}
+            for name in ("test", "lint") if isinstance(scripts.get(name), str)]
+
+
+def validate_files(root: str, files: Sequence[str] = (), budget: Optional[float] = None) -> dict[str, object]:
+    from cf_stop_hook import run_validators
+    selected = validation_scope(root, files)
+    validators = _validators(root)
+    if not selected:
+        return {"decision": "pass", "files": [], "reason": "no_changes"}
+    if not validators:
+        return {"decision": "block", "files": selected, "reason": "no_validators_configured"}
+    maximum = budget if budget is not None else sum(float(v.get("timeout", 30000)) / 1000 for v in validators)
+    if not math.isfinite(maximum) or maximum <= 0:
+        raise ValueError("validation budget must be finite and positive")
+    with execution_session():
+        failures, truncated = run_validators(root, validators, list(selected), "cf-validate", maximum, strict=True)
+    return {"decision": "block" if failures or truncated else "pass", "files": selected,
+            "failures": failures, "incomplete": truncated}
+
+
+def main(argv: Optional[Sequence[str]] = None, stdout: IO[str] = sys.stdout) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--root", default=os.getcwd())
+    parser.add_argument("--files", nargs="*", default=[])
+    parser.add_argument("--budget", type=float)
+    parser.add_argument("--scope-only", action="store_true")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv)
+    try:
+        result = {"files": validation_scope(args.root, args.files)} if args.scope_only else validate_files(args.root, args.files, args.budget)
+        stdout.write(json.dumps(result, ensure_ascii=False))
+        return 3 if result.get("decision") == "block" else 0
+    except (OSError, ValueError) as exc:
+        stdout.write(json.dumps({"decision": "block", "error": str(exc)}, ensure_ascii=False))
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())