@guanlin4924/devflow-pi 0.1.0

package/plugins/devflow-core/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@devflow/omp-core",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "peerDependencies": {
+    "@oh-my-pi/pi-coding-agent": "*"
+  },
+  "omp": {
+    "extensions": [
+      "./extensions/devflow-core.ts"
+    ]
+  }
+}

package/plugins/devflow-core/runtime/hooks/context_sync_gate.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""Stop hook: classify session changes and enforce the minimum context sync."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+from hook_common import (
+    changed_files_for_state,
+    changes_signature,
+    classify_changes,
+    ensure_session,
+    load_policy,
+    locked_state,
+    project_root,
+    read_event,
+    skill_kit_root,
+)
+
+
+def _run_light_sync(root: Path, files: list[str], timeout: int) -> tuple[bool, str]:
+    script = skill_kit_root(root) / "workflow-code-index/scripts/code_index.py"
+    if not script.is_file():
+        return False, f"code-index executable is missing: {script}"
+    commands = [
+        [
+            sys.executable,
+            str(script),
+            "scan",
+            "--root",
+            str(root),
+            "--output",
+            ".planning/code-index",
+            "--changed-files",
+            *files,
+        ],
+        [sys.executable, str(script), "validate", "--index", ".planning/code-index"],
+        [
+            sys.executable,
+            str(script),
+            "audit",
+            "--root",
+            str(root),
+            "--index",
+            ".planning/code-index",
+        ],
+    ]
+    output = []
+    for command in commands:
+        try:
+            result = subprocess.run(
+                command,
+                cwd=root,
+                text=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                timeout=timeout,
+                check=False,
+            )
+        except subprocess.TimeoutExpired:
+            return False, f"timed out after {timeout}s: {' '.join(command[1:4])}"
+        output.append(result.stdout.strip())
+        if result.returncode != 0:
+            detail = result.stdout.strip().splitlines()[-1] if result.stdout.strip() else "no output"
+            return False, f"command failed ({result.returncode}): {detail}"
+    return True, "\n".join(part for part in output if part)
+
+
+def _mark_state_synced(root: Path, session_id: str, level: str) -> tuple[list[str], str]:
+    policy = load_policy(root)
+    with locked_state(root, session_id) as state:
+        files = changed_files_for_state(root, state, policy)
+        required_level, _ = classify_changes(files, policy)
+        rank = {"Light": 1, "Medium": 2, "Full": 3}
+        if rank[level] < rank[required_level]:
+            raise ValueError(
+                f"cannot acknowledge {required_level} changes with a {level} sync"
+            )
+        signature = changes_signature(root, files)
+        state["synced_signature"] = signature
+        state["synced_files"] = files
+        state["synced_level"] = level
+        state["stop_block_count"] = 0
+    return files, signature
+
+
+def mark_synced(argv: list[str]) -> int:
+    parser = argparse.ArgumentParser(description="Mark the current hook change set as context-synced.")
+    parser.add_argument("--session-id", required=True)
+    parser.add_argument("--level", choices=("Light", "Medium", "Full"), required=True)
+    args = parser.parse_args(argv)
+    root = project_root()
+    try:
+        files, signature = _mark_state_synced(root, args.session_id, args.level)
+    except ValueError as error:
+        print(str(error), file=sys.stderr)
+        return 2
+    print(
+        json.dumps(
+            {
+                "status": "synced",
+                "level": args.level,
+                "changed_files": files,
+                "signature": signature,
+            },
+            ensure_ascii=False,
+        )
+    )
+    return 0
+
+
+def stop_hook() -> int:
+    event = read_event()
+    root = project_root(event)
+    policy = load_policy(root)
+    sync_policy = policy.get("context_sync", {})
+    if not sync_policy.get("enabled", True):
+        return 0
+
+    session_id = ensure_session(root, event)
+    with locked_state(root, session_id) as state:
+        files = changed_files_for_state(root, state, policy)
+        if not files:
+            state["stop_block_count"] = 0
+            return 0
+        signature = changes_signature(root, files)
+        if state.get("synced_signature") == signature:
+            state["stop_block_count"] = 0
+            return 0
+        level, matched = classify_changes(files, policy)
+
+    if level == "Light" and sync_policy.get("auto_light", True):
+        success, detail = _run_light_sync(
+            root,
+            files,
+            int(sync_policy.get("light_timeout_seconds", 120)),
+        )
+        if success:
+            _mark_state_synced(root, session_id, "Light")
+            return 0
+        failure = f"Light auto-sync failed: {detail}"
+    else:
+        failure = "manual context reconciliation is required"
+
+    with locked_state(root, session_id) as state:
+        state["stop_block_count"] = int(state.get("stop_block_count", 0)) + 1
+
+    file_text = "\n".join(f"- {path}" for path in files[:80])
+    matched_text = ", ".join(matched[:20]) if matched else "none"
+    reason = (
+        f"CONTEXT_SYNC_REQUIRED: level={level}; {failure}.\n"
+        f"Changed files:\n{file_text}\n"
+        f"Classification matches: {matched_text}.\n"
+        "Read skill://workflow-context-sync and execute only the reported level for these files. "
+        "After validation succeeds, acknowledge this exact change set with the "
+        f"devflow_context_sync tool using action=ack and level={level}."
+    )
+    print(json.dumps({"decision": "block", "reason": reason}, ensure_ascii=False))
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if argv and argv[0] == "mark-synced":
+        return mark_synced(argv[1:])
+    return stop_hook()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())