prizmkit 1.1.8 → 1.1.10

package/bundled/dev-pipeline/scripts/update-bug-status.py

@@ -1,18 +1,20 @@
 #!/usr/bin/env python3
 """Core state machine for updating bug status in the bug-fix pipeline.
 
-Handles six actions:
+Handles eight actions:
   - get_next: Find the next bug to process based on priority and severity
+  - start: Mark a bug as fixing when a session starts
   - update: Update a bug's status based on session outcome
   - status: Print a formatted overview of all bugs
   - pause: Save pipeline state for graceful shutdown
   - reset: Reset a bug to pending (status + retry count)
   - clean: Reset + delete session history + delete bugfix artifacts
+  - unskip: Reset skipped bugs back to pending
 
 Usage:
     python3 update-bug-status.py \
         --bug-list <path> --state-dir <path> \
-        --action <get_next|update|status|pause|reset|clean> \
+        --action <get_next|start|update|status|pause|reset|clean|unskip> \
         [--bug-id <id>] [--session-status <status>] \
         [--session-id <id>] [--max-retries <n>]
 """
@@ -39,12 +41,14 @@ SESSION_STATUS_VALUES = [
     "failed",
     "crashed",
     "timed_out",
+    "commit_missing",
+    "docs_missing",
     "merge_conflict",
 ]
 
 TERMINAL_STATUSES = {"completed", "failed", "skipped", "needs_info"}
 
-# 严重度优先级（数值越小越优先）
+# Severity priority (lower value = higher priority)
 SEVERITY_PRIORITY = {
     "critical": 0,
     "high": 1,
@@ -61,7 +65,7 @@ def parse_args():
     parser.add_argument("--state-dir", required=True, help="Path to the state directory (default: .prizmkit/state/bugfix)")
     parser.add_argument(
         "--action", required=True,
-        choices=["get_next", "update", "status", "pause", "reset", "clean"],
+        choices=["get_next", "start", "update", "status", "pause", "reset", "clean", "unskip", "complete"],
         help="Action to perform",
     )
     parser.add_argument("--bug-id", default=None, help="Bug ID (required for 'update'/'reset'/'clean' actions)")
@@ -183,12 +187,12 @@ def action_get_next(bug_list_data, state_dir):
         elif bstatus == "pending":
             pending_bugs.append(bug)
 
-    _PRIORITY_ORDER = {"critical": 0, "high": 1, "medium": 2, "low": 3}
+    _PRIORITY_ORDER = {"high": 0, "medium": 1, "low": 2}
 
     def sort_key(b):
         severity = b.get("severity", "medium")
         sev_order = SEVERITY_PRIORITY.get(severity, 2)
-        priority = _PRIORITY_ORDER.get(b.get("priority", "low"), 3)
+        priority = _PRIORITY_ORDER.get(b.get("priority", "low"), 2)
         return (sev_order, priority)
 
     if in_progress_bugs:
@@ -196,7 +200,7 @@ def action_get_next(bug_list_data, state_dir):
     elif pending_bugs:
         candidates = sorted(pending_bugs, key=sort_key)
     else:
-        # 所有剩余的 bug 都处于非终端但也非 pending/in_progress 状态
+        # All remaining bugs are in non-terminal but also non-pending/in_progress states
         print("PIPELINE_BLOCKED")
         return
 
@@ -240,17 +244,23 @@ def action_update(args, bug_list_path, state_dir):
         if err:
             error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
             return
-    elif session_status == "merge_conflict":
-        # Degraded outcome: keep artifacts for retry (branch preserves work)
+    elif session_status in ("commit_missing", "docs_missing", "merge_conflict"):
+        # Degraded outcome: keep artifacts for retry (branch preserves work).
+        # Write schema-valid status to bug-fix-list.json ("pending" for retry,
+        # "failed" if max retries exceeded). Store the granular degraded reason
+        # in status.json only (internal pipeline state, not schema-bound).
         bs["retry_count"] = bs.get("retry_count", 0) + 1
 
         if bs["retry_count"] >= max_retries:
             bs["status"] = "failed"
             target_status = "failed"
         else:
-            bs["status"] = "merge_conflict"
-            target_status = "merge_conflict"
+            # status.json keeps the granular degraded reason for diagnostics
+            bs["status"] = session_status
+            # bug-fix-list.json gets schema-valid "pending" (will be retried)
+            target_status = "pending"
 
+        bs["degraded_reason"] = session_status
         bs["resume_from_phase"] = None
         bs["sessions"] = []
         bs["last_session_id"] = None
@@ -307,8 +317,8 @@ def action_update(args, bug_list_path, state_dir):
         "resume_from_phase": bs.get("resume_from_phase"),
         "updated_at": bs["updated_at"],
     }
-    if session_status == "merge_conflict":
-        summary["degraded_reason"] = "merge_conflict"
+    if session_status in ("commit_missing", "docs_missing", "merge_conflict"):
+        summary["degraded_reason"] = session_status
         summary["restart_policy"] = "finalization_retry"
     elif session_status != "success":
         summary["restart_policy"] = "full_restart"
@@ -661,6 +671,133 @@ def action_pause(state_dir):
     print(json.dumps(result, indent=2, ensure_ascii=False))
 
 
+# ---------------------------------------------------------------------------
+# Action: start
+# ---------------------------------------------------------------------------
+
+def action_start(args, bug_list_path, state_dir):
+    """Mark a bug as in_progress when a session starts.
+
+    This keeps bug-fix-list.json/state status in sync during execution,
+    instead of only updating after session end.
+    """
+    bug_id = args.bug_id
+    if not bug_id:
+        error_out("--bug-id is required for 'start' action")
+        return
+
+    bs = load_bug_status(state_dir, bug_id)
+    old_status = bs.get("status", "pending")
+
+    bs["status"] = "in_progress"
+    bs["updated_at"] = now_iso()
+
+    err = save_bug_status(state_dir, bug_id, bs)
+    if err:
+        error_out("Failed to save bug status: {}".format(err))
+        return
+
+    err = update_bug_in_list(bug_list_path, bug_id, "in_progress")
+    if err:
+        error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
+        return
+
+    result = {
+        "action": "start",
+        "bug_id": bug_id,
+        "old_status": old_status,
+        "new_status": "in_progress",
+        "updated_at": bs["updated_at"],
+    }
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+# ---------------------------------------------------------------------------
+# Action: unskip
+# ---------------------------------------------------------------------------
+
+def action_unskip(args, bug_list_path, state_dir):
+    """Reset skipped bugs back to pending.
+
+    Two modes:
+    - --bug-id B-001: Reset the specified skipped bug to pending.
+    - No --bug-id: Reset ALL skipped bugs to pending.
+    """
+    bug_id = args.bug_id
+
+    data, err = load_json_file(bug_list_path)
+    if err:
+        error_out("Cannot load bug fix list: {}".format(err))
+        return
+    bugs = data.get("bugs", [])
+
+    to_reset = set()
+
+    if bug_id:
+        # Find the target bug
+        target = None
+        for b in bugs:
+            if isinstance(b, dict) and b.get("id") == bug_id:
+                target = b
+                break
+        if not target:
+            error_out("Bug '{}' not found in .prizmkit/plans/bug-fix-list.json".format(bug_id))
+            return
+        if target.get("status") not in ("failed", "skipped", "needs_info"):
+            error_out(
+                "Bug '{}' has status '{}', expected 'failed', 'skipped', or 'needs_info'".format(
+                    bug_id, target.get("status", "unknown")
+                )
+            )
+            return
+        to_reset.add(bug_id)
+    else:
+        # No bug-id: reset ALL skipped/failed/needs_info bugs
+        for b in bugs:
+            if isinstance(b, dict) and b.get("id"):
+                if b.get("status") in ("failed", "skipped", "needs_info"):
+                    to_reset.add(b["id"])
+
+    if not to_reset:
+        error_out("No bugs to unskip")
+        return
+
+    # Reset all collected bugs in bug-fix-list.json
+    reset_details = []
+    for b in bugs:
+        if isinstance(b, dict) and b.get("id") in to_reset:
+            old_status = b.get("status", "unknown")
+            b["status"] = "pending"
+            reset_details.append({
+                "bug_id": b["id"],
+                "title": b.get("title", ""),
+                "old_status": old_status,
+            })
+
+    err = write_json_file(bug_list_path, data)
+    if err:
+        error_out("Failed to write .prizmkit/plans/bug-fix-list.json: {}".format(err))
+        return
+
+    # Reset status.json for each bug
+    for bid in to_reset:
+        bs = load_bug_status(state_dir, bid)
+        bs["status"] = "pending"
+        bs["retry_count"] = 0
+        bs["sessions"] = []
+        bs["last_session_id"] = None
+        bs["resume_from_phase"] = None
+        bs["updated_at"] = now_iso()
+        save_bug_status(state_dir, bid, bs)
+
+    result = {
+        "action": "unskip",
+        "reset_count": len(to_reset),
+        "bugs": reset_details,
+    }
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
 # ---------------------------------------------------------------------------
 # Main
 # ---------------------------------------------------------------------------
@@ -673,7 +810,7 @@ def main():
             error_out("--bug-id is required for 'update' action")
         if not args.session_status:
             error_out("--session-status is required for 'update' action")
-    if args.action in ("reset", "clean"):
+    if args.action in ("start", "reset", "clean", "complete"):
         if not args.bug_id:
             error_out("--bug-id is required for '{}' action".format(args.action))
     if args.action == "clean":
@@ -686,6 +823,8 @@ def main():
 
     if args.action == "get_next":
         action_get_next(bug_list_data, args.state_dir)
+    elif args.action == "start":
+        action_start(args, args.bug_list, args.state_dir)
     elif args.action == "update":
         action_update(args, args.bug_list, args.state_dir)
     elif args.action == "status":
@@ -696,6 +835,12 @@ def main():
         action_clean(args, args.bug_list, args.state_dir)
     elif args.action == "pause":
         action_pause(args.state_dir)
+    elif args.action == "unskip":
+        action_unskip(args, args.bug_list, args.state_dir)
+    elif args.action == "complete":
+        # Shortcut: 'complete' is equivalent to 'update --session-status success'
+        args.session_status = "success"
+        action_update(args, args.bug_list, args.state_dir)
 
 
 if __name__ == "__main__":

package/bundled/dev-pipeline/scripts/update-feature-status.py

@@ -608,16 +608,21 @@ def action_update(args, feature_list_path, state_dir):
             error_out("Failed to update .prizmkit/plans/feature-list.json: {}".format(err))
             return
     elif session_status in ("commit_missing", "docs_missing", "merge_conflict"):
-        # Degraded outcome: keep artifacts for retry and expose specific status.
+        # Degraded outcome: keep artifacts for retry.
+        # Store granular reason in status.json (internal state),
+        # but write only schema-valid status to feature-list.json.
         fs["retry_count"] = fs.get("retry_count", 0) + 1
 
         if fs["retry_count"] >= max_retries:
             fs["status"] = "failed"
             target_status = "failed"
         else:
+            # status.json keeps the granular degraded reason for diagnostics
             fs["status"] = session_status
-            target_status = session_status
+            # feature-list.json gets schema-valid "pending" (will be retried)
+            target_status = "pending"
 
+        fs["degraded_reason"] = session_status
         fs["resume_from_phase"] = None
         fs["sessions"] = []
         fs["last_session_id"] = None
@@ -707,11 +712,12 @@ BOX_WIDTH = 68
 
 
 def _calc_feature_duration(state_dir, feature_id):
-    """计算已完成 Feature 的耗时（秒）。
+    """Calculate the duration (in seconds) of a completed feature.
 
-    通过 status.json 的 created_at 和 updated_at 来计算。
-    如果有 session 记录，尝试用第一个 session 的 started_at 到最后更新时间来计算。
-    返回 None 如果无法计算。
+    Computes duration from status.json's created_at and updated_at fields.
+    If session records exist, attempts to use the first session's started_at
+    to the last update time for the calculation.
+    Returns None if the duration cannot be calculated.
     """
     fs_path = os.path.join(state_dir, "features", feature_id, "status.json")
     if not os.path.isfile(fs_path):
@@ -730,7 +736,7 @@ def _calc_feature_duration(state_dir, feature_id):
         t_start = datetime.strptime(created_at, fmt)
         t_end = datetime.strptime(updated_at, fmt)
         delta = (t_end - t_start).total_seconds()
-        # 过滤异常值：少于 10 秒或超过 24 小时的忽略
+        # Filter outliers: ignore durations less than 10s or more than 24h
         if delta < 10 or delta > 86400:
             return None
         return delta
@@ -739,7 +745,7 @@ def _calc_feature_duration(state_dir, feature_id):
 
 
 def _format_duration(seconds):
-    """将秒数格式化为人类可读的时间字符串。"""
+    """Format seconds into a human-readable duration string."""
     if seconds is None:
         return "N/A"
     seconds = int(seconds)
@@ -756,17 +762,18 @@ def _format_duration(seconds):
 
 
 def _estimate_remaining_time(features, state_dir, counts, feature_list_data=None):
-    """基于已完成 Feature 的历史耗时，按 complexity 加权预估剩余时间。
+    """Estimate remaining time based on completed feature durations, weighted by complexity.
 
-    策略:
-    1. 收集所有已完成 Feature 的耗时，按 complexity 分组
-    2. 对剩余的 pending/in_progress Feature，用对应 complexity 的平均耗时估算
-    3. 如果某个 complexity 没有历史数据，用全局平均值兜底
+    Strategy:
+    1. Collect durations of all completed features, grouped by complexity
+    2. For remaining pending/in_progress features, estimate using the average duration
+       of the corresponding complexity level
+    3. If no historical data exists for a complexity level, fall back to the global average
 
-    返回 (estimated_seconds, confidence) 元组。
-    confidence: "high" (>=50% 已完成), "medium" (>=25%), "low" (<25%)
+    Returns an (estimated_seconds, confidence) tuple.
+    confidence: "high" (>=50% completed), "medium" (>=25%), "low" (<25%)
     """
-    # complexity 权重（用于没有历史数据时的估算）
+    # Complexity weights (used for estimation when no historical data is available)
     COMPLEXITY_WEIGHT = {"low": 1.0, "medium": 2.0, "high": 4.0}
 
     # Build feature-list status map for terminal status override
@@ -776,7 +783,7 @@ def _estimate_remaining_time(features, state_dir, counts, feature_list_data=None
             if isinstance(f, dict) and f.get("id"):
                 fl_status_map[f["id"]] = f.get("status")
 
-    # 按 complexity 分组收集已完成 Feature 的耗时
+    # Collect completed feature durations grouped by complexity
     duration_by_complexity = {}  # complexity -> [duration_seconds]
     feature_complexity_map = {}  # feature_id -> complexity
 
@@ -811,13 +818,13 @@ def _estimate_remaining_time(features, state_dir, counts, feature_list_data=None
     if not all_durations:
         return None, "low"
 
-    # 计算各 complexity 的平均耗时
+    # Calculate average duration per complexity level
     avg_by_complexity = {}
     for c, durations in duration_by_complexity.items():
         avg_by_complexity[c] = sum(durations) / len(durations)
     global_avg = sum(all_durations) / len(all_durations)
 
-    # 估算剩余 Feature 的耗时
+    # Estimate duration for remaining features
     remaining_seconds = 0.0
     remaining_count = 0
     for feature in features:
@@ -835,12 +842,12 @@ def _estimate_remaining_time(features, state_dir, counts, feature_list_data=None
         if complexity in avg_by_complexity:
             remaining_seconds += avg_by_complexity[complexity]
         else:
-            # 没有该 complexity 的历史数据，用全局均值 × 权重比例估算
+            # No historical data for this complexity; estimate using global avg × weight ratio
             weight = COMPLEXITY_WEIGHT.get(complexity, 2.0)
             base_weight = COMPLEXITY_WEIGHT.get("medium", 2.0)
             remaining_seconds += global_avg * (weight / base_weight)
 
-    # 计算置信度
+    # Calculate confidence level
     total = len([f for f in features if isinstance(f, dict) and f.get("id")])
     completed = counts.get("completed", 0)
     if total > 0:
@@ -882,8 +889,6 @@ def action_status(feature_list_data, state_dir, feature_filter=None):
         "pending": 0,
         "skipped": 0,
         "auto_skipped": 0,
-        "commit_missing": 0,
-        "docs_missing": 0,
     }
     feature_lines = []
 
@@ -897,6 +902,19 @@ def action_status(feature_list_data, state_dir, feature_filter=None):
             continue
         status_map[fid] = feature.get("status", "pending")
 
+    # Build degraded_reason map from status.json (internal pipeline state)
+    degraded_reason_map = {}
+    for feature in features:
+        if not isinstance(feature, dict):
+            continue
+        fid = feature.get("id")
+        if not fid:
+            continue
+        fs = load_feature_status(state_dir, fid, feature.get("status"))
+        dr = fs.get("degraded_reason")
+        if dr:
+            degraded_reason_map[fid] = dr
+
     for feature in features:
         if not isinstance(feature, dict):
             continue
@@ -906,6 +924,7 @@ def action_status(feature_list_data, state_dir, feature_filter=None):
             continue
 
         fstatus = feature.get("status", "pending")
+        degraded_reason = degraded_reason_map.get(fid)
 
         # Count statuses
         if fstatus in counts:
@@ -914,7 +933,14 @@ def action_status(feature_list_data, state_dir, feature_filter=None):
             counts["pending"] += 1
 
         # Build status indicator and color
-        if fstatus == "completed":
+        # Show degraded reason via icon when a pending feature has one
+        if fstatus == "pending" and degraded_reason == "commit_missing":
+            icon = COLOR_RED + "[↑]" + COLOR_RESET
+        elif fstatus == "pending" and degraded_reason == "docs_missing":
+            icon = COLOR_RED + "[D]" + COLOR_RESET
+        elif fstatus == "pending" and degraded_reason == "merge_conflict":
+            icon = COLOR_RED + "[⚡]" + COLOR_RESET
+        elif fstatus == "completed":
             icon = COLOR_GREEN + "[✓]" + COLOR_RESET
         elif fstatus == "in_progress":
             icon = COLOR_YELLOW + "[→]" + COLOR_RESET
@@ -924,16 +950,22 @@ def action_status(feature_list_data, state_dir, feature_filter=None):
             icon = COLOR_GRAY + "[—]" + COLOR_RESET
         elif fstatus == "auto_skipped":
             icon = COLOR_GRAY + "[⊘]" + COLOR_RESET
-        elif fstatus == "commit_missing":
-            icon = COLOR_RED + "[↑]" + COLOR_RESET
-        elif fstatus == "docs_missing":
-            icon = COLOR_RED + "[D]" + COLOR_RESET
         else:
             icon = COLOR_GRAY + "[ ]" + COLOR_RESET
 
         # Build detail suffix
         detail = ""
-        if fstatus == "pending":
+        if fstatus == "pending" and degraded_reason:
+            detail = " ({}, retrying)".format(degraded_reason)
+            # Also check if blocked by dependencies
+            deps = feature.get("dependencies", [])
+            blocking = [
+                d for d in deps
+                if status_map.get(d, "pending") != "completed"
+            ]
+            if blocking:
+                detail = " ({}, blocked by {})".format(degraded_reason, ", ".join(blocking))
+        elif fstatus == "pending":
             # Check if blocked by dependencies
             deps = feature.get("dependencies", [])
             blocking = [
@@ -950,6 +982,8 @@ def action_status(feature_list_data, state_dir, feature_filter=None):
             ]
             if blockers:
                 detail = " (auto-skipped: blocked by {})".format(", ".join(blockers))
+        elif fstatus == "failed" and degraded_reason:
+            detail = " (last failure: {})".format(degraded_reason)
 
         # Apply color to the whole line content
         if fstatus == "completed":
@@ -964,7 +998,7 @@ def action_status(feature_list_data, state_dir, feature_filter=None):
             line_content = "{} {} {}{}".format(
                 fid, icon, COLOR_RED + title + COLOR_RESET, detail
             )
-        elif fstatus in ("commit_missing", "docs_missing"):
+        elif degraded_reason:
             line_content = "{} {} {}{}".format(
                 fid, icon, COLOR_RED + title + COLOR_RESET, detail
             )
@@ -978,16 +1012,16 @@ def action_status(feature_list_data, state_dir, feature_filter=None):
     total = len(features)
     completed = counts["completed"]
 
-    # 计算百分比
+    # Calculate percentage
     if total > 0:
         percent = round(completed / total * 100, 1)
     else:
         percent = 0.0
 
-    # 生成进度条
+    # Generate progress bar
     progress_bar = _build_progress_bar(percent, width=24)
 
-    # 预估剩余时间
+    # Estimate remaining time
     est_remaining, confidence = _estimate_remaining_time(
         features, state_dir, counts, feature_list_data
     )
@@ -998,11 +1032,18 @@ def action_status(feature_list_data, state_dir, feature_filter=None):
     summary_line2 = "Failed: {} | Pending: {} | Skipped: {} | Auto-skipped: {}".format(
         counts["failed"], counts["pending"], counts["skipped"], counts["auto_skipped"]
     )
-    summary_line3 = "Commit Missing: {} | Docs Missing: {}".format(
-        counts["commit_missing"], counts["docs_missing"]
+
+    # Count degraded features (pending with a degraded_reason from status.json)
+    degraded_count = sum(
+        1 for fid, dr in degraded_reason_map.items()
+        if status_map.get(fid) == "pending" and dr
     )
+    if degraded_count > 0:
+        summary_line3 = "Degraded (retrying): {}".format(degraded_count)
+    else:
+        summary_line3 = None
 
-    # 构建预估剩余时间行
+    # Build estimated remaining time line
     CONFIDENCE_ICONS = {"high": "●", "medium": "◐", "low": "○"}
     if est_remaining is not None:
         eta_str = _format_duration(est_remaining)
@@ -1021,7 +1062,8 @@ def action_status(feature_list_data, state_dir, feature_filter=None):
     print("║" + pad_right("  Project: {}".format(app_name), inner) + " ║")
     print("║" + pad_right("  {}".format(summary_line), inner) + " ║")
     print("║" + pad_right("  {}".format(summary_line2), inner) + " ║")
-    print("║" + pad_right("  {}".format(summary_line3), inner) + " ║")
+    if summary_line3:
+        print("║" + pad_right("  {}".format(summary_line3), inner) + " ║")
     print("╠" + "─" * BOX_WIDTH + "╣")
     print("║" + pad_right("  Progress: {}".format(progress_bar), inner) + " ║")
     print("║" + pad_right("  {}".format(eta_line), inner) + " ║")