@michaelxwb/code-flow 0.6.0 → 0.6.2

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

@@ -21,8 +21,6 @@ import os
 import sys
 
 import cf_log
-from cf_spec_context import ContextError, load_active_task
-from cf_task_runtime import evaluate_scope, run_done_gate
 from cf_checks import (
     load_check_state,
     load_spec_checks,
@@ -39,8 +37,10 @@ from cf_core import (
     match_domains,
     normalize_path,
     normalize_spec_entry,
+    resolve_enforcement,
     resolve_quality_loop,
     resolve_session_id,
+    timing_log,
 )
 
 FEEDBACK_HINT = '如认为误报，直接告诉我"这是误报"，我会标记忽略。'
@@ -93,23 +93,6 @@ def _feedback_text(violations: list) -> str:
     return "\n".join(lines)
 
 
-def _active_feedback(project_root: str) -> str:
-    marker = os.path.join(project_root, ".code-flow", ".active-task.json")
-    if not os.path.exists(marker):
-        return ""
-    active = load_active_task(project_root)
-    task_dir = os.path.join(project_root, active.task_dir)
-    scope = evaluate_scope(project_root, task_dir)
-    if scope.decision == "pause":
-        return scope.message
-    result = run_done_gate(project_root, task_dir)
-    failed = [item for item in result.evidence if item.get("status") != "verified"]
-    if not failed:
-        return ""
-    refs = ", ".join(str(item.get("verifier_ref")) for item in failed)
-    return f"当前 TASK required verifier 未通过：{refs}。修复后再继续。"
-
-
 def main() -> None:
     try:
         ensure_utf8_io()
@@ -125,20 +108,11 @@ def main() -> None:
             return
 
         project_root = os.getcwd()
-        try:
-            active_feedback = _active_feedback(project_root)
-        except (ContextError, OSError, ValueError) as exc:
-            message = f"SPEC_WORKFLOW_BLOCKED: active task is invalid: {exc}"
-            payload = {"hookSpecificOutput": {"hookEventName": "PostToolUse", "additionalContext": message}}
-            sys.stdout.write(json.dumps(payload, ensure_ascii=False))
-            return
-        if active_feedback:
-            payload = {"hookSpecificOutput": {"hookEventName": "PostToolUse", "additionalContext": active_feedback}}
-            sys.stdout.write(json.dumps(payload, ensure_ascii=False))
-            return
         config = load_config(project_root)
         if not config:
             return
+        if resolve_enforcement(config) == "inject":
+            return
         quality_loop = resolve_quality_loop(config)
         if not quality_loop["post_check"]:
             return
@@ -218,3 +192,4 @@ def main() -> None:
 
 if __name__ == "__main__":
     main()
+    timing_log("cf_post_hook")

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

@@ -1,5 +1,9 @@
 #!/usr/bin/env python3
-"""PreToolUse hook: enforce active Context or inject deterministic path Specs."""
+"""PreToolUse hook: advisory Context/scope guidance on Edit/Write/MultiEdit.
+
+Hot-path policy: never deny the tool; inject context or guidance instead.
+Hard enforcement lives at the checkpoints (start / done / stop), not here.
+"""
 
 import json
 import os
@@ -7,11 +11,14 @@ from pathlib import Path
 import sys
 
 import cf_log
-from cf_core import _log, ensure_utf8_io, normalize_path, resolve_session_id
+from cf_core import _log, ensure_utf8_io, load_config, normalize_path, resolve_enforcement, resolve_session_id, timing_log
+from cf_session_state import load_session_state, save_session_state
 from cf_spec_context import load_active_task, load_context
-from cf_spec_resolver import resolve_candidates
+from cf_spec_resolver import resolve_candidate_headers
 from cf_spec_router import RouterError, route_prompt
 
+_WARN_TEXT = "⚠ Spec Workflow 校验未通过（warn 模式）：{message} — 建议运行 cf-spec doctor 检查。"
+
 
 def _active_expansion(root: str, relative: str) -> tuple[str, ...]:
     marker = Path(root) / ".code-flow/.active-task.json"
@@ -21,13 +28,13 @@ def _active_expansion(root: str, relative: str) -> tuple[str, ...]:
     context = load_context(str(Path(root) / active.task_dir / "spec-context.yml"))
     bound = {item.spec_id for item in context.bindings}
     return tuple(
-        item.spec_id for item in resolve_candidates(root, "code", (relative,))
-        if item.spec_id not in bound and item.metadata.enforcement == "required"
+        item.spec_id for item in resolve_candidate_headers(root, "code", (relative,))
+        if item.spec_id not in bound and item.enforcement == "required"
     )
 
 
-def _deny(reason: str) -> dict[str, object]:
-    return {"hookSpecificOutput": {"hookEventName": "PreToolUse", "permissionDecision": "deny", "permissionDecisionReason": reason}}
+def _inject(text: str) -> dict[str, object]:
+    return {"hookSpecificOutput": {"hookEventName": "PreToolUse", "additionalContext": text}}
 
 
 def main() -> None:
@@ -42,24 +49,41 @@ def main() -> None:
         if tool_name not in {"Edit", "Write", "MultiEdit"} or not isinstance(file_path, str) or not file_path:
             return
         root = os.getcwd()
+        sid = resolve_session_id(data)
+        config = load_config(root)
+        enforcement = resolve_enforcement(config) if config else "required"
         absolute = file_path if os.path.isabs(file_path) else os.path.join(root, file_path)
         relative = normalize_path(os.path.relpath(absolute, root))
-        expanded = _active_expansion(root, relative)
+        try:
+            expanded = _active_expansion(root, relative)
+            result = route_prompt(root, (relative,), sid)
+        except RouterError as exc:
+            if enforcement == "required":
+                sys.stdout.write(json.dumps(_inject(f"SPEC_WORKFLOW_BLOCKED [{exc.code}]: {exc}. Run cf-spec doctor before continuing."), ensure_ascii=False))
+            elif enforcement == "warn":
+                sys.stdout.write(json.dumps(_inject(_WARN_TEXT.format(message=str(exc))), ensure_ascii=False))
+            return
         if expanded:
-            reason = f"SPEC_WORKFLOW_BLOCKED: path introduces required Specs {', '.join(expanded)}; refresh Context and Plan first."
-            sys.stdout.write(json.dumps(_deny(reason), ensure_ascii=False))
+            message = f"⚠ 该路径引入未绑定 required Spec：{', '.join(expanded)} — 建议先 refresh Context / Plan 再继续编辑。"
+            sys.stdout.write(json.dumps(_inject(message), ensure_ascii=False))
             return
-        sid = resolve_session_id(data)
-        result = route_prompt(root, (relative,), sid)
-        if result.text:
-            payload = {"hookSpecificOutput": {"hookEventName": "PreToolUse", "additionalContext": result.text}}
-            sys.stdout.write(json.dumps(payload, ensure_ascii=False))
+        text = result.text
+        if result.mode == "task" and result.context_sha256:
+            # The projection is already in context from the prompt route unless
+            # the bound rules changed; skip per-edit re-injection.
+            state = load_session_state(root)
+            if state.get("injected_sha256") == result.context_sha256:
+                text = ""
+            else:
+                state["injected_sha256"] = result.context_sha256
+                save_session_state(root, state)
+        if text:
+            sys.stdout.write(json.dumps(_inject(text), ensure_ascii=False))
         cf_log.append_event(root, "edit_intent", {"file": relative, "tool": tool_name, "specs": list(result.specs)}, sid)
-    except RouterError as exc:
-        sys.stdout.write(json.dumps(_deny(f"SPEC_WORKFLOW_BLOCKED [{exc.code}]: {exc}"), ensure_ascii=False))
     except (json.JSONDecodeError, OSError, ValueError) as exc:
         _log(f"cf_pre_tool_hook error: {exc}")
 
 
 if __name__ == "__main__":
     main()
+    timing_log("cf_pre_tool_hook")

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

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""Shared per-session state for injection/reminder cadence.
+
+Stores one JSON file per project root (`.code-flow/.session-state.json`),
+keyed by session id. Both read and write are best-effort: a corrupt or
+unwritable state degrades to no-op rather than breaking hook protocols.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Mapping
+
+
+_STATE_PATH = ".code-flow/.session-state.json"
+
+
+def load_session_state(root: str) -> dict:
+    """Return the persisted state dict; {} on any failure (never raises)."""
+    try:
+        value = json.loads((Path(root) / _STATE_PATH).read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError, UnicodeError):
+        return {}
+    return value if isinstance(value, dict) else {}
+
+
+def save_session_state(root: str, state: Mapping) -> bool:
+    """Atomically persist state; False on failure (never raises)."""
+    path = Path(root) / _STATE_PATH
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+        temporary.write_text(json.dumps(dict(state), ensure_ascii=False), encoding="utf-8")
+        os.replace(temporary, path)
+        return True
+    except (OSError, UnicodeError, TypeError):
+        return False