prizmkit 1.1.57 → 1.1.60

package/bundled/dev-pipeline-windows/scripts/parse-stream-progress.py

@@ -0,0 +1,388 @@
+#!/usr/bin/env python3
+"""
+parse-stream-progress.py - Real-time stream-json progress parser
+
+Continuously reads an AI CLI session log (JSONL from --output-format stream-json),
+extracts tool calls, phase changes, and activity metrics, and writes structured
+progress to a progress.json file for heartbeat monitoring.
+
+Usage:
+    python3 parse-stream-progress.py --session-log <path> --progress-file <path>
+
+The script runs until:
+  - The session log stops growing and the CLI process exits
+  - It receives SIGTERM/SIGINT
+"""
+
+import argparse
+import json
+import os
+import signal
+import sys
+import tempfile
+import time
+from collections import Counter
+from datetime import datetime, timezone
+
+
+# Ordered pipeline phases — index defines forward-only progression.
+# Phase detection is monotonic: once a phase is reached, earlier phases
+# cannot be re-entered (prevents false positives from file content mentions).
+PHASE_ORDER = ["plan", "implement", "code-review", "retrospective", "commit"]
+
+# Keywords for phase detection.
+# "strong" keywords are skill invocations — high confidence, but still
+# forward-only (a mention of prizmkit-plan while in commit phase is noise).
+# "weak" keywords are contextual hints — also forward-only, used when no
+# strong keyword matches.
+PHASE_KEYWORDS = {
+    "plan": {
+        "strong": ["prizmkit-plan"],
+        "weak": ["spec.md", "plan.md", "specification", "architecture", "task checklist", "task breakdown", "gathering requirements"],
+    },
+    "implement": {
+        "strong": ["prizmkit-implement"],
+        "weak": ["implement", "writing code", "TDD", "coding"],
+    },
+    "code-review": {
+        "strong": ["prizmkit-code-review"],
+        "weak": ["code review", "review verdict", "reviewing"],
+    },
+    "retrospective": {
+        "strong": ["prizmkit-retrospective"],
+        "weak": ["retrospective", "structural sync", "architecture knowledge", ".prizmkit/prizm-docs/ sync"],
+    },
+    "commit": {
+        "strong": ["prizmkit-committer"],
+        "weak": ["git commit", "committing", "feat(", "fix("],
+    },
+}
+
+
+class ProgressTracker:
+    """Tracks progress state from stream-json events."""
+
+    def __init__(self):
+        self.message_count = 0
+        self.current_tool = None
+        self.current_tool_input_summary = ""
+        self.current_phase = None
+        self.detected_phases = []
+        self.tool_call_counts = Counter()
+        self.total_tool_calls = 0
+        self.last_text_snippet = ""
+        self.is_active = True
+        self.errors = []
+        self._text_buffer = ""
+        self._in_tool_use = False
+        self._current_tool_input_parts = []
+
+    def process_event(self, event):
+        """Process a single stream-json event and update state.
+
+        Supports two formats:
+        1. Claude API raw stream: message_start, content_block_start, content_block_delta, etc.
+        2. Claude Code verbose stream-json: assistant, user, tool_result, system, etc.
+           (produced by claude/claude-internal --verbose --output-format stream-json)
+        """
+        event_type = event.get("type", "")
+
+        # ── Claude Code verbose format ──────────────────────────────
+        if event_type == "assistant":
+            self.message_count += 1
+            self.is_active = True
+            message = event.get("message", {})
+            content_blocks = message.get("content", [])
+            for block in content_blocks:
+                block_type = block.get("type", "")
+                if block_type == "tool_use":
+                    tool_name = block.get("name", "unknown")
+                    self.current_tool = tool_name
+                    self.tool_call_counts[tool_name] += 1
+                    self.total_tool_calls += 1
+                    # Extract summary from input
+                    tool_input = block.get("input", {})
+                    if isinstance(tool_input, dict):
+                        self._extract_tool_summary_from_dict(tool_input)
+                    self._detect_phase(json.dumps(tool_input, ensure_ascii=False)[:500])
+                elif block_type == "text":
+                    text = block.get("text", "")
+                    if text.strip():
+                        self.last_text_snippet = text.strip()[:120]
+                    self._detect_phase(text)
+
+        elif event_type == "tool_result" or event_type == "user":
+            # tool_result contains output from tool execution
+            self.is_active = True
+
+        elif event_type == "system":
+            # System events (hooks, init, etc.) — track but don't count as messages
+            subtype = event.get("subtype", "")
+            if subtype == "init":
+                self.is_active = True
+
+        # ── Claude API raw stream format ────────────────────────────
+        elif event_type == "message_start":
+            self.message_count += 1
+            self.is_active = True
+
+        elif event_type == "message_stop":
+            self.current_tool = None
+            self.current_tool_input_summary = ""
+            self._in_tool_use = False
+            self._current_tool_input_parts = []
+
+        elif event_type == "content_block_start":
+            content_block = event.get("content_block", {})
+            block_type = content_block.get("type", "")
+
+            if block_type == "tool_use":
+                tool_name = content_block.get("name", "unknown")
+                self.current_tool = tool_name
+                self.current_tool_input_summary = ""
+                self.tool_call_counts[tool_name] += 1
+                self.total_tool_calls += 1
+                self._in_tool_use = True
+                self._current_tool_input_parts = []
+
+            elif block_type == "text":
+                self._text_buffer = ""
+                self._in_tool_use = False
+
+        elif event_type == "content_block_delta":
+            delta = event.get("delta", {})
+            delta_type = delta.get("type", "")
+
+            if delta_type == "text_delta":
+                text = delta.get("text", "")
+                self._text_buffer += text
+                # Keep last meaningful snippet
+                stripped = text.strip()
+                if stripped:
+                    self.last_text_snippet = stripped[:120]
+                # Try to detect phase from text
+                self._detect_phase(text)
+
+            elif delta_type == "input_json_delta":
+                partial = delta.get("partial_json", "")
+                self._current_tool_input_parts.append(partial)
+                # Build a summary from accumulated input
+                accumulated = "".join(self._current_tool_input_parts)
+                self.current_tool_input_summary = accumulated[:150]
+
+        elif event_type == "content_block_stop":
+            if self._in_tool_use:
+                # Try to extract a better summary from complete tool input
+                full_input = "".join(self._current_tool_input_parts)
+                self._extract_tool_summary(full_input)
+                self._detect_phase(full_input)
+            else:
+                # Text block finished - detect phase from accumulated text
+                if self._text_buffer:
+                    self._detect_phase(self._text_buffer)
+            self._in_tool_use = False
+            self._current_tool_input_parts = []
+
+        elif event_type == "error":
+            error_msg = event.get("error", {}).get("message", "Unknown error")
+            self.errors.append(error_msg)
+
+        # Check for subagent indicator
+        if event.get("parent_tool_use_id"):
+            # This is a sub-agent event; tool name is still tracked normally
+            pass
+
+    def _detect_phase(self, text):
+        """Detect pipeline phase from text content.
+
+        Uses monotonic (forward-only) progression to avoid false positives.
+        Strong keywords (skill invocations) always trigger; weak keywords
+        only trigger for phases at or ahead of the current position.
+        """
+        text_lower = text.lower()
+        current_idx = (
+            PHASE_ORDER.index(self.current_phase)
+            if self.current_phase in PHASE_ORDER
+            else -1
+        )
+
+        for phase, kw_groups in PHASE_KEYWORDS.items():
+            phase_idx = PHASE_ORDER.index(phase)
+
+            # Check strong keywords — high confidence but still forward-only
+            for keyword in kw_groups.get("strong", []):
+                if keyword.lower() in text_lower:
+                    if phase_idx >= current_idx:
+                        self.current_phase = phase
+                        if phase not in self.detected_phases:
+                            self.detected_phases.append(phase)
+                        return
+                    # Backward strong match — skip this phase but do NOT
+                    # early-return, so forward weak matches can still fire.
+                    break
+
+            # Check weak keywords — only trigger for forward phases
+            if phase_idx >= current_idx:
+                for keyword in kw_groups.get("weak", []):
+                    if keyword.lower() in text_lower:
+                        self.current_phase = phase
+                        if phase not in self.detected_phases:
+                            self.detected_phases.append(phase)
+                        return
+
+    def _extract_tool_summary(self, raw_input):
+        """Extract a human-readable summary from tool input JSON string."""
+        try:
+            data = json.loads(raw_input)
+            self._extract_tool_summary_from_dict(data)
+        except (json.JSONDecodeError, TypeError):
+            # Keep whatever partial summary we had
+            pass
+
+    def _extract_tool_summary_from_dict(self, data):
+        """Extract a human-readable summary from tool input dict."""
+        if isinstance(data, dict):
+            # Common patterns in tool inputs
+            if "description" in data:
+                self.current_tool_input_summary = str(data["description"])[:100]
+            elif "command" in data:
+                self.current_tool_input_summary = str(data["command"])[:100]
+            elif "file_path" in data:
+                self.current_tool_input_summary = str(data["file_path"])[:100]
+            elif "pattern" in data:
+                self.current_tool_input_summary = str(data["pattern"])[:100]
+            elif "query" in data:
+                self.current_tool_input_summary = str(data["query"])[:100]
+            elif "prompt" in data:
+                self.current_tool_input_summary = str(data["prompt"])[:100]
+
+    def to_dict(self):
+        """Export current state as a dictionary for JSON serialization."""
+        tool_calls = [
+            {"name": name, "count": count}
+            for name, count in self.tool_call_counts.most_common()
+        ]
+        return {
+            "updated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "message_count": self.message_count,
+            "current_tool": self.current_tool,
+            "current_tool_input_summary": self.current_tool_input_summary,
+            "current_phase": self.current_phase,
+            "detected_phases": self.detected_phases,
+            "tool_calls": tool_calls,
+            "total_tool_calls": self.total_tool_calls,
+            "last_text_snippet": self.last_text_snippet,
+            "is_active": self.is_active,
+            "errors": self.errors[-10:],  # Keep last 10 errors
+        }
+
+
+def atomic_write_json(data, filepath):
+    """Write JSON data atomically using tmp file + rename."""
+    dir_path = os.path.dirname(filepath)
+    tmp_path = None
+    try:
+        fd, tmp_path = tempfile.mkstemp(dir=dir_path, suffix=".tmp")
+        with os.fdopen(fd, "w") as f:
+            json.dump(data, f, indent=2)
+            f.write("\n")
+        os.rename(tmp_path, filepath)
+    except OSError:
+        # Best effort - remove tmp file if rename failed
+        if tmp_path:
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+
+
+def tail_and_parse(session_log, progress_file, poll_interval=0.5):
+    """Tail session log and parse stream-json events."""
+    tracker = ProgressTracker()
+    last_write_state = None
+
+    # Wait for log file to appear
+    wait_count = 0
+    while not os.path.exists(session_log):
+        time.sleep(poll_interval)
+        wait_count += 1
+        if wait_count > 120:  # 60 seconds max wait
+            sys.stderr.write(f"Timeout waiting for {session_log}\n")
+            sys.exit(1)
+
+    with open(session_log, "r") as f:
+        idle_count = 0
+        while True:
+            line = f.readline()
+            if line:
+                idle_count = 0
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    event = json.loads(line)
+                    tracker.process_event(event)
+                except json.JSONDecodeError:
+                    # Not a JSON line (could be stderr mixed in)
+                    # Use it as a text snippet if meaningful
+                    stripped = line.strip()
+                    if stripped and len(stripped) > 5:
+                        tracker.last_text_snippet = stripped[:120]
+                    continue
+
+                # Write progress if state changed
+                current_state = tracker.to_dict()
+                state_key = (
+                    current_state["message_count"],
+                    current_state["current_tool"],
+                    current_state["current_phase"],
+                    current_state["total_tool_calls"],
+                )
+                if state_key != last_write_state:
+                    atomic_write_json(current_state, progress_file)
+                    last_write_state = state_key
+            else:
+                idle_count += 1
+                # After 2 seconds of no new data, write current state anyway
+                # (ensures progress.json stays fresh)
+                if idle_count == 4:
+                    current_state = tracker.to_dict()
+                    atomic_write_json(current_state, progress_file)
+
+                # After 3600 idle cycles (30 min), mark inactive and exit
+                if idle_count > 3600:
+                    tracker.is_active = False
+                    atomic_write_json(tracker.to_dict(), progress_file)
+                    break
+
+                time.sleep(poll_interval)
+
+    # Final write
+    tracker.is_active = False
+    atomic_write_json(tracker.to_dict(), progress_file)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Parse stream-json progress")
+    parser.add_argument("--session-log", required=True, help="Path to session.log (JSONL)")
+    parser.add_argument("--progress-file", required=True, help="Path to write progress.json")
+    args = parser.parse_args()
+
+    # Handle graceful shutdown
+    def handle_signal(signum, frame):
+        sys.exit(0)
+
+    signal.signal(signal.SIGTERM, handle_signal)
+    signal.signal(signal.SIGINT, handle_signal)
+
+    try:
+        tail_and_parse(args.session_log, args.progress_file)
+    except SystemExit:
+        pass
+    except Exception as e:
+        sys.stderr.write(f"parse-stream-progress.py error: {e}\n")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/bundled/dev-pipeline-windows/scripts/patch-completion-notes.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""Patch completion_notes into feature-list.json, refactor-list.json, or bug-fix-list.json.
+
+Reads a completion-summary.json file written by the AI session and patches
+the corresponding item in the task list with the completion_notes field.
+
+This enables rich dependency context propagation: when a downstream task's
+bootstrap prompt is generated, it can read completion_notes from its
+completed dependencies to understand what was built/changed.
+
+Usage:
+    python3 patch-completion-notes.py \
+        --feature-list .prizmkit/plans/feature-list.json \
+        --feature-id F-001 \
+        --summary .prizmkit/specs/001-my-feature/completion-summary.json
+
+    python3 patch-completion-notes.py \
+        --refactor-list .prizmkit/plans/refactor-list.json \
+        --refactor-id R-001 \
+        --summary <path-to-summary>
+"""
+
+import argparse
+import json
+import os
+import sys
+
+from utils import load_json_file, write_json_file, setup_logging
+
+LOGGER = setup_logging("patch-completion-notes")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Patch completion_notes into a task list from completion-summary.json."
+    )
+    parser.add_argument(
+        "--feature-list",
+        default=None,
+        help="Path to .prizmkit/plans/feature-list.json",
+    )
+    parser.add_argument(
+        "--refactor-list",
+        default=None,
+        help="Path to .prizmkit/plans/refactor-list.json",
+    )
+    parser.add_argument(
+        "--bug-list",
+        default=None,
+        help="Path to .prizmkit/plans/bug-fix-list.json",
+    )
+    parser.add_argument(
+        "--feature-id",
+        default=None,
+        help="Feature ID to patch (e.g. F-001)",
+    )
+    parser.add_argument(
+        "--refactor-id",
+        default=None,
+        help="Refactor ID to patch (e.g. R-001)",
+    )
+    parser.add_argument(
+        "--bug-id",
+        default=None,
+        help="Bug ID to patch (e.g. B-001)",
+    )
+    parser.add_argument(
+        "--summary",
+        required=True,
+        help="Path to completion-summary.json file",
+    )
+    return parser.parse_args()
+
+
+def read_completion_notes(summary_path):
+    """Read completion_notes from a completion-summary.json file.
+
+    Returns a list of strings, or an empty list if the file is missing
+    or malformed.
+    """
+    if not os.path.isfile(summary_path):
+        LOGGER.warning("Summary file not found: %s", summary_path)
+        return []
+
+    data, err = load_json_file(summary_path)
+    if err:
+        LOGGER.warning("Failed to read summary: %s", err)
+        return []
+
+    notes = data.get("completion_notes", [])
+    if not isinstance(notes, list):
+        LOGGER.warning("completion_notes is not a list in %s", summary_path)
+        return []
+
+    # Filter: only keep non-empty strings
+    return [n for n in notes if isinstance(n, str) and n.strip()]
+
+
+def patch_list(list_path, item_id, item_key, notes):
+    """Patch completion_notes into a task list JSON file.
+
+    Args:
+        list_path: Path to the JSON list file
+        item_id: ID of the item to patch (e.g. "F-001" or "R-001")
+        item_key: Key for the items array (e.g. "features" or "refactors")
+        notes: List of completion note strings
+    """
+    data, err = load_json_file(list_path)
+    if err:
+        LOGGER.error("Failed to read list: %s", err)
+        return False
+
+    items = data.get(item_key, [])
+    found = False
+    for item in items:
+        if isinstance(item, dict) and item.get("id") == item_id:
+            item["completion_notes"] = notes
+            found = True
+            break
+
+    if not found:
+        LOGGER.error("Item %s not found in %s", item_id, list_path)
+        return False
+
+    err = write_json_file(list_path, data)
+    if err:
+        LOGGER.error("Failed to write list: %s", err)
+        return False
+
+    LOGGER.info(
+        "Patched %d completion notes for %s in %s",
+        len(notes), item_id, list_path,
+    )
+    return True
+
+
+def main():
+    args = parse_args()
+
+    # Determine mode: feature, refactor, or bug
+    if args.feature_list and args.feature_id:
+        list_path = args.feature_list
+        item_id = args.feature_id
+        item_key = "features"
+    elif args.refactor_list and args.refactor_id:
+        list_path = args.refactor_list
+        item_id = args.refactor_id
+        item_key = "refactors"
+    elif args.bug_list and args.bug_id:
+        list_path = args.bug_list
+        item_id = args.bug_id
+        item_key = "bugs"
+    else:
+        print(
+            "Error: must provide either (--feature-list + --feature-id) "
+            "or (--refactor-list + --refactor-id) "
+            "or (--bug-list + --bug-id)",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    # Read completion notes
+    notes = read_completion_notes(args.summary)
+    if not notes:
+        LOGGER.info("No completion notes to patch for %s", item_id)
+        sys.exit(0)
+
+    # Patch the list
+    if not patch_list(list_path, item_id, item_key, notes):
+        sys.exit(1)
+
+    # Output result
+    result = {
+        "item_id": item_id,
+        "notes_count": len(notes),
+        "list_path": os.path.abspath(list_path),
+    }
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        sys.exit(130)
+    except SystemExit:
+        raise
+    except Exception as exc:
+        LOGGER.exception("Unhandled exception")
+        print("Error: {}".format(exc), file=sys.stderr)
+        sys.exit(1)