prizmkit 1.1.1 → 1.1.4

package/bundled/dev-pipeline/scripts/generate-bootstrap-prompt.py

@@ -101,6 +101,12 @@ def parse_args():
         default=None,
         help="Override critic enablement (default: read from feature field)",
     )
+    parser.add_argument(
+        "--extract-baselines",
+        action="store_true",
+        help="Run tests and extract baseline failures (slower, optional)",
+    )
+
     return parser.parse_args()
 
 
@@ -154,6 +160,101 @@ def format_acceptance_criteria(criteria):
         lines.append("- {}".format(item))
     return "\n".join(lines)
 
+def detect_test_commands(project_root):
+    """
+    Auto-detect test commands based on project structure.
+
+    Returns: space-separated string of test commands (e.g., "npm test go test ./...")
+    """
+    test_commands = []
+
+    # Check for npm/package.json
+    if os.path.exists(os.path.join(project_root, "package.json")):
+        test_commands.append("npm test")
+
+    # Check for Go
+    if os.path.exists(os.path.join(project_root, "go.mod")):
+        test_commands.append("go test ./...")
+
+    # Check for Rust/Cargo
+    if os.path.exists(os.path.join(project_root, "Cargo.toml")):
+        test_commands.append("cargo test")
+
+    # Check for Python pytest
+    if os.path.exists(os.path.join(project_root, "pytest.ini")) or \
+       os.path.exists(os.path.join(project_root, "setup.py")):
+        test_commands.append("pytest")
+
+    # Check for Make test target
+    makefile_path = os.path.join(project_root, "Makefile")
+    if os.path.exists(makefile_path):
+        try:
+            with open(makefile_path, 'r') as f:
+                if 'test:' in f.read():
+                    test_commands.append("make test")
+        except Exception:
+            pass
+
+    # Return deduplicated space-separated list
+    return " ".join(dict.fromkeys(test_commands)) if test_commands else ""
+
+
+def extract_baseline_failures(test_cmd, project_root):
+    """
+    Run test command and extract failing tests.
+
+    Returns: semicolon-separated list of failing test names
+    """
+    if not test_cmd or test_cmd.startswith("(auto-detection"):
+        return ""
+
+    try:
+        import subprocess
+        original_cwd = os.getcwd()
+        os.chdir(project_root)
+
+        result = subprocess.run(
+            test_cmd,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=120
+        )
+
+        os.chdir(original_cwd)
+
+        output = result.stdout + result.stderr
+        failures = []
+
+        for line in output.split('\n'):
+            if 'FAILED' in line and '::' in line:
+                parts = line.split('FAILED')
+                if len(parts) > 1:
+                    test_name = parts[1].strip().split(' ')[0]
+                    if test_name and test_name not in failures:
+                        failures.append(test_name)
+
+        return ";".join(failures) if failures else ""
+
+    except Exception as e:
+        return f"(error: {str(e)})"
+    finally:
+        try:
+            os.chdir(original_cwd)
+        except Exception:
+            pass
+
+
+def format_ac_checklist(acceptance_criteria):
+    """Format acceptance criteria as a markdown checkbox list."""
+    if not acceptance_criteria:
+        return "- [ ] (no acceptance criteria specified)"
+    lines = []
+    for item in acceptance_criteria:
+        lines.append("- [ ] {}".format(item))
+    return "\n".join(lines)
+
+
 
 def format_global_context(global_context, project_root=None):
     """Format global_context dict as a key-value list.
@@ -251,8 +352,9 @@ def _read_project_brief(project_root):
 
     Returns the file content as a string, or a fallback message if absent.
     This brief is generated by app-planner during interactive planning and
-    captures cross-feature design decisions, business intent, and user
-    preferences that individual feature descriptions may not include.
+    captures the user's product ideas as a checklist. Each line is one idea,
+    marked [ ] for pending or [x] for completed. Feature sessions should mark
+    items [x] and append key file paths when implementing relevant ideas.
     """
     brief_path = os.path.join(project_root, "project-brief.md")
     if os.path.isfile(brief_path):
@@ -428,6 +530,171 @@ def determine_pipeline_mode(complexity):
     return mapping.get(complexity, "lite")
 
 
+# ============================================================
+# Checkpoint generation
+# ============================================================
+
+# Mapping: section name -> (skill_key, display_name, required_artifacts)
+# skill_key is a unique identifier in the checkpoint, not necessarily the
+# prizmkit skill name.  This ensures each section has a distinct key so
+# merge_checkpoint_state() never collides.
+SECTION_TO_SKILL = {
+    "phase0-init": ("prizmkit-init", "Project Bootstrap",
+                    [".prizm-docs/root.prizm", ".prizmkit/config.json"]),
+    "phase0-test-baseline": ("test-baseline", "Test Baseline", []),
+    "phase-context-snapshot": ("context-snapshot", "Build Context Snapshot",
+                               [".prizmkit/specs/{slug}/context-snapshot.md"]),
+    "phase-specify-plan": ("context-snapshot-and-plan", "Specify & Plan",
+                           [".prizmkit/specs/{slug}/context-snapshot.md",
+                            ".prizmkit/specs/{slug}/plan.md"]),
+    "phase-plan": ("prizmkit-plan", "Plan & Tasks",
+                   [".prizmkit/specs/{slug}/plan.md"]),
+    "phase-analyze": ("prizmkit-analyze", "Analyze", []),
+    "phase-critic-plan": ("critic-plan-review", "Critic: Plan Review", []),
+    "phase-implement": ("prizmkit-implement", "Implement + Test", []),
+    "phase-critic-code": ("critic-code-review", "Critic: Code Review", []),
+    "phase-review": ("prizmkit-code-review", "Code Review", []),
+    "phase-browser": ("browser-verification", "Browser Verification", []),
+    "phase-deploy": ("deploy-verification", "Deploy Verification", []),
+    "phase-commit": None,  # special: split into retrospective + committer
+}
+
+# phase-commit is split into two steps
+_COMMIT_STEPS = [
+    ("prizmkit-retrospective", "Retrospective", []),
+    ("prizmkit-committer", "Commit", []),
+]
+
+
+def _resolve_artifacts(artifact_templates, slug):
+    """Replace {slug} placeholder with the actual feature slug."""
+    return [a.replace("{slug}", slug) for a in artifact_templates]
+
+
+def generate_checkpoint_definition(sections, pipeline_mode, workflow_type,
+                                   item_id, item_slug, session_id,
+                                   init_done=False):
+    """Derive checkpoint step definitions from the assembled sections list.
+
+    Args:
+        sections: list of (name, content) tuples from assemble_sections()
+        pipeline_mode: "lite" | "standard" | "full"
+        workflow_type: "feature-pipeline"
+        item_id: feature ID (e.g. "F-001")
+        item_slug: feature slug (e.g. "001-user-auth")
+        session_id: current session ID
+        init_done: whether project is already initialized (Phase 0 skip)
+
+    Returns:
+        dict suitable for writing as workflow-checkpoint.json
+    """
+    steps = []
+    step_counter = 1
+    prev_step_id = None
+
+    for section_name, _content in sections:
+        if section_name not in SECTION_TO_SKILL:
+            continue
+
+        mapping = SECTION_TO_SKILL[section_name]
+
+        if mapping is None:
+            # phase-commit -> split into retrospective + committer
+            for skill, name, artifacts in _COMMIT_STEPS:
+                step_id = "S{:02d}".format(step_counter)
+                steps.append({
+                    "id": step_id,
+                    "skill": skill,
+                    "name": name,
+                    "status": "pending",
+                    "required_artifacts": _resolve_artifacts(artifacts, item_slug),
+                    "depends_on": prev_step_id,
+                })
+                prev_step_id = step_id
+                step_counter += 1
+            continue
+
+        skill, name, artifacts = mapping
+        step_id = "S{:02d}".format(step_counter)
+
+        status = "pending"
+        if init_done and section_name in ("phase0-init", "phase0-test-baseline"):
+            status = "skipped"
+
+        steps.append({
+            "id": step_id,
+            "skill": skill,
+            "name": name,
+            "status": status,
+            "required_artifacts": _resolve_artifacts(artifacts, item_slug),
+            "depends_on": prev_step_id,
+        })
+
+        prev_step_id = step_id
+        step_counter += 1
+
+    return {
+        "version": 1,
+        "workflow_type": workflow_type,
+        "pipeline_mode": pipeline_mode,
+        "item_id": item_id,
+        "item_slug": item_slug,
+        "session_id": session_id,
+        "steps": steps,
+    }
+
+
+def merge_checkpoint_state(existing, fresh, project_root):
+    """Merge existing checkpoint state into a freshly generated definition.
+
+    Matching is by skill_key (not step ID), since tier changes across retries
+    may shift step IDs.
+
+    Merge rules:
+    1. Only keep completed steps whose required_artifacts all exist on disk
+    2. Keep skipped steps unconditionally
+    3. Once a step is NOT completed/skipped, break the dependency chain:
+       all subsequent steps reset to pending
+    """
+    existing_status = {}
+    existing_artifacts = {}
+    for step in existing.get("steps", []):
+        existing_status[step["skill"]] = step["status"]
+        existing_artifacts[step["skill"]] = step.get("required_artifacts", [])
+
+    # Determine which completed steps have valid artifacts
+    valid_completed = set()
+    for skill_key, status in existing_status.items():
+        if status == "completed":
+            artifacts = existing_artifacts.get(skill_key, [])
+            if all(os.path.exists(os.path.join(project_root, a))
+                   for a in artifacts):
+                valid_completed.add(skill_key)
+            else:
+                LOGGER.warning(
+                    "Step '%s' was completed but artifacts missing — "
+                    "resetting to pending", skill_key
+                )
+        elif status == "skipped":
+            valid_completed.add(skill_key)
+
+    # Apply to fresh steps; break chain on first non-valid step
+    chain_broken = False
+    for step in fresh["steps"]:
+        if chain_broken:
+            step["status"] = "pending"
+            continue
+
+        prev = existing_status.get(step["skill"])
+        if step["skill"] in valid_completed:
+            step["status"] = prev  # completed or skipped
+        else:
+            chain_broken = True
+            step["status"] = "pending"
+
+    return fresh
+
+
 # ============================================================
 # Section Assembly (new modular approach)
 # ============================================================
@@ -445,6 +712,38 @@ def load_section(sections_dir, name):
         return f.read()
 
 
+def load_agent_prompts(templates_dir):
+    """Load agent prompt templates from agent-prompts/ directory.
+
+    Returns a dict of {{AGENT_PROMPT_XXX}} -> prompt content replacements.
+    If the directory does not exist, returns an empty dict (backward compat).
+    """
+    agent_prompts_dir = os.path.join(templates_dir, "agent-prompts")
+    if not os.path.isdir(agent_prompts_dir):
+        LOGGER.debug("No agent-prompts/ directory found, skipping")
+        return {}
+
+    # Map filename -> placeholder name
+    # e.g. dev-implement.md -> {{AGENT_PROMPT_DEV_IMPLEMENT}}
+    prompt_map = {}
+    for filename in sorted(os.listdir(agent_prompts_dir)):
+        if not filename.endswith(".md"):
+            continue
+        stem = filename[:-3]  # remove .md
+        placeholder = "{{{{AGENT_PROMPT_{}}}}}".format(
+            stem.upper().replace("-", "_")
+        )
+        filepath = os.path.join(agent_prompts_dir, filename)
+        try:
+            with open(filepath, "r", encoding="utf-8") as f:
+                prompt_map[placeholder] = f.read().strip()
+            LOGGER.debug("Loaded agent prompt: %s -> %s", filename, placeholder)
+        except IOError as exc:
+            LOGGER.warning("Failed to load agent prompt %s: %s", filename, exc)
+
+    return prompt_map
+
+
 def _tier_header(pipeline_mode):
     """Return the tier-specific header and mission description."""
     headers = {
@@ -587,6 +886,12 @@ def assemble_sections(pipeline_mode, sections_dir, init_done, is_resume,
                           load_section(sections_dir,
                                        "subagent-timeout-recovery.md")))
 
+    # --- Checkpoint System ---
+    checkpoint_section_path = os.path.join(sections_dir, "checkpoint-system.md")
+    if os.path.isfile(checkpoint_section_path):
+        sections.append(("checkpoint-system",
+                          load_section(sections_dir, "checkpoint-system.md")))
+
     # --- Execution header ---
     sections.append(("execution-header", "---\n\n## Execution\n"))
 
@@ -741,9 +1046,13 @@ def render_from_sections(sections, replacements):
     """
     content = "\n".join(text for _, text in sections)
 
-    # Replace all placeholders
-    for placeholder, value in replacements.items():
-        content = content.replace(placeholder, value)
+    # Replace all placeholders — run twice to handle agent prompt templates
+    # that contain their own {{PLACEHOLDER}} variables.  First pass injects
+    # agent prompt content (e.g. {{AGENT_PROMPT_DEV_IMPLEMENT}} expands to a
+    # block containing {{FEATURE_ID}}).  Second pass replaces the inner vars.
+    for _pass in range(2):
+        for placeholder, value in replacements.items():
+            content = content.replace(placeholder, value)
 
     return content
 
@@ -954,11 +1263,28 @@ def build_replacements(args, feature, features, global_context, script_dir):
             steps = browser_interaction.get("verify_steps", [])
             if steps:
                 browser_verify_steps = "\n".join(
-                    "   # Step {}: {}".format(i + 1, step)
+                    "   # Goal {}: {}".format(i + 1, step)
                     for i, step in enumerate(steps)
                 )
             else:
-                browser_verify_steps = "   # (no specific verify steps — just open and screenshot)"
+                browser_verify_steps = "   # (no specific verify goals — just open and screenshot)"
+
+    # Auto-detect test commands from project structure
+    test_cmd = detect_test_commands(project_root)
+    if not test_cmd:
+        test_cmd = "(auto-detection found no standard test commands; manually specify TEST_CMD)"
+
+    # Optionally extract baseline failures from test execution
+    baseline_failures = ""
+    if args.extract_baselines:
+        baseline_failures = extract_baseline_failures(test_cmd, project_root)
+
+    # Extract coverage target from feature.testing field (new in v2)
+    coverage_target = "80"  # Default coverage target
+    testing_config = feature.get("testing", {})
+    if isinstance(testing_config, dict):
+        coverage_target = str(testing_config.get("coverage_target", 80))
+
 
     replacements = {
         "{{RUN_ID}}": args.run_id,
@@ -988,6 +1314,9 @@ def build_replacements(args, feature, features, global_context, script_dir):
         "{{SESSION_STATUS_PATH}}": session_status_abs,
         "{{PROJECT_ROOT}}": project_root,
         "{{FEATURE_SLUG}}": feature_slug,
+        "{{CHECKPOINT_PATH}}": os.path.join(
+            ".prizmkit", "specs", feature_slug, "workflow-checkpoint.json",
+        ),
         "{{PIPELINE_MODE}}": pipeline_mode,
         "{{COMPLEXITY}}": complexity,
         "{{CRITIC_ENABLED}}": "true" if critic_enabled else "false",
@@ -999,6 +1328,12 @@ def build_replacements(args, feature, features, global_context, script_dir):
         "{{BROWSER_URL}}": browser_url,
         "{{BROWSER_SETUP_COMMAND}}": browser_setup_command,
         "{{BROWSER_VERIFY_STEPS}}": browser_verify_steps,
+        "{{AC_CHECKLIST}}": format_ac_checklist(
+            feature.get("acceptance_criteria", [])
+        ),
+        "{{TEST_CMD}}": test_cmd,
+        "{{BASELINE_FAILURES}}": baseline_failures,
+        "{{COVERAGE_TARGET}}": coverage_target,
     }
 
     return replacements, effective_resume, browser_enabled
@@ -1016,9 +1351,11 @@ def render_template(template_content, replacements, resume_phase, browser_enable
     content = process_mode_blocks(content, pipeline_mode, init_done, critic_enabled,
                                   browser_enabled)
 
-    # Step 3: Replace all {{PLACEHOLDER}} variables
-    for placeholder, value in replacements.items():
-        content = content.replace(placeholder, value)
+    # Step 3: Replace all {{PLACEHOLDER}} variables (two passes for nested
+    # agent prompt templates that may contain their own placeholders)
+    for _pass in range(2):
+        for placeholder, value in replacements.items():
+            content = content.replace(placeholder, value)
 
     return content
 
@@ -1079,6 +1416,10 @@ def main():
     )
     replacements["{{RESUME_PHASE}}"] = effective_resume
 
+    # Load agent prompt templates and merge into replacements
+    agent_prompt_replacements = load_agent_prompts(templates_dir)
+    replacements.update(agent_prompt_replacements)
+
     # Extract state needed for assembly
     pipeline_mode = replacements.get("{{PIPELINE_MODE}}", "lite")
     init_done = replacements.get("{{INIT_DONE}}", "false") == "true"
@@ -1147,6 +1488,52 @@ def main():
     if err:
         emit_failure(err)
 
+    # ── Generate checkpoint file ──────────────────────────────────────
+    project_root = resolve_project_root(
+        os.path.dirname(os.path.abspath(__file__))
+    )
+    feature_slug = replacements.get("{{FEATURE_SLUG}}", "")
+    checkpoint_path = ""
+
+    if use_sections and feature_slug:
+        checkpoint = generate_checkpoint_definition(
+            sections=sections,
+            pipeline_mode=pipeline_mode,
+            workflow_type="feature-pipeline",
+            item_id=args.feature_id,
+            item_slug=feature_slug,
+            session_id=args.session_id,
+            init_done=init_done,
+        )
+
+        checkpoint_dir = os.path.join(
+            project_root, ".prizmkit", "specs", feature_slug,
+        )
+        os.makedirs(checkpoint_dir, exist_ok=True)
+        checkpoint_path = os.path.join(
+            checkpoint_dir, "workflow-checkpoint.json",
+        )
+
+        # On resume, merge existing completed state (with artifact validation)
+        if is_resume and os.path.exists(checkpoint_path):
+            try:
+                with open(checkpoint_path, "r", encoding="utf-8") as f:
+                    existing = json.load(f)
+                checkpoint = merge_checkpoint_state(
+                    existing, checkpoint, project_root,
+                )
+                LOGGER.info("Merged existing checkpoint state from %s",
+                            checkpoint_path)
+            except (json.JSONDecodeError, KeyError) as exc:
+                LOGGER.warning(
+                    "Existing checkpoint corrupted (%s) — generating fresh",
+                    exc,
+                )
+
+        with open(checkpoint_path, "w", encoding="utf-8") as f:
+            json.dump(checkpoint, f, indent=2, ensure_ascii=False)
+        LOGGER.info("Wrote checkpoint to %s", checkpoint_path)
+
     # ── Success JSON ───────────────────────────────────────────────────
     feature_model = feature.get("model", "")
     mode_agent_counts = {"lite": 1, "standard": 3, "full": 3}
@@ -1164,6 +1551,7 @@ def main():
         "render_mode": "sections" if use_sections else "legacy",
         "validation_warnings": len(warnings),
         "validation_errors": len(errors),
+        "checkpoint_path": checkpoint_path,
     }
     print(json.dumps(output, indent=2, ensure_ascii=False))
     sys.exit(0)

package/bundled/dev-pipeline/scripts/generate-bugfix-prompt.py

@@ -324,6 +324,95 @@ def emit_failure(message):
     sys.exit(1)
 
 
+# ============================================================
+# Checkpoint generation for bugfix pipeline
+# ============================================================
+
+BUGFIX_STEPS = [
+    ("prizmkit-init", "Initialize", []),
+    ("bug-diagnosis", "Bug Diagnosis & Fix Plan",
+     [".prizmkit/bugfix/{slug}/fix-plan.md"]),
+    ("bug-reproduce", "Write Reproduction Test", []),
+    ("bug-fix", "Implement Fix", []),
+    ("prizmkit-code-review", "Code Review", []),
+    ("prizmkit-committer", "Commit", []),
+    ("bug-report", "Generate Fix Report & Update TRAPS",
+     [".prizmkit/bugfix/{slug}/fix-report.md"]),
+]
+
+
+def generate_bugfix_checkpoint(bug_id, session_id):
+    """Generate a checkpoint definition for bugfix pipeline.
+
+    Returns a dict suitable for writing as workflow-checkpoint.json.
+    """
+    steps = []
+    prev_id = None
+    for i, (skill, name, artifacts) in enumerate(BUGFIX_STEPS, 1):
+        step_id = "S{:02d}".format(i)
+        steps.append({
+            "id": step_id,
+            "skill": skill,
+            "name": name,
+            "status": "pending",
+            "required_artifacts": [a.replace("{slug}", bug_id) for a in artifacts],
+            "depends_on": prev_id,
+        })
+        prev_id = step_id
+
+    return {
+        "version": 1,
+        "workflow_type": "bugfix-pipeline",
+        "pipeline_mode": "single",
+        "item_id": bug_id,
+        "item_slug": bug_id,
+        "session_id": session_id,
+        "steps": steps,
+    }
+
+
+def merge_bugfix_checkpoint_state(existing, fresh, project_root):
+    """Merge existing bugfix checkpoint state into fresh definition.
+
+    Same logic as feature pipeline: validate artifacts, break chain on
+    first invalid step.
+    """
+    existing_status = {}
+    existing_artifacts = {}
+    for step in existing.get("steps", []):
+        existing_status[step["skill"]] = step["status"]
+        existing_artifacts[step["skill"]] = step.get("required_artifacts", [])
+
+    valid_completed = set()
+    for skill_key, status in existing_status.items():
+        if status == "completed":
+            artifacts = existing_artifacts.get(skill_key, [])
+            if all(os.path.exists(os.path.join(project_root, a))
+                   for a in artifacts):
+                valid_completed.add(skill_key)
+            else:
+                LOGGER.warning(
+                    "Step '%s' was completed but artifacts missing — "
+                    "resetting to pending", skill_key
+                )
+        elif status == "skipped":
+            valid_completed.add(skill_key)
+
+    chain_broken = False
+    for step in fresh["steps"]:
+        if chain_broken:
+            step["status"] = "pending"
+            continue
+        prev = existing_status.get(step["skill"])
+        if step["skill"] in valid_completed:
+            step["status"] = prev
+        else:
+            chain_broken = True
+            step["status"] = "pending"
+
+    return fresh
+
+
 def main():
     args = parse_args()
 
@@ -366,6 +455,12 @@ def main():
     # Build replacements
     replacements = build_replacements(args, bug, global_context, script_dir)
 
+    # Add checkpoint path to replacements
+    checkpoint_rel = os.path.join(
+        ".prizmkit", "bugfix", args.bug_id, "workflow-checkpoint.json",
+    )
+    replacements["{{CHECKPOINT_PATH}}"] = checkpoint_rel
+
     # Render the template
     rendered = render_template(template_content, replacements, bug)
 
@@ -374,10 +469,39 @@ def main():
     if err:
         emit_failure(err)
 
+    # Generate checkpoint file
+    project_root = resolve_project_root(script_dir)
+    checkpoint_path = os.path.join(project_root, checkpoint_rel)
+    checkpoint_dir = os.path.dirname(checkpoint_path)
+    os.makedirs(checkpoint_dir, exist_ok=True)
+
+    checkpoint = generate_bugfix_checkpoint(args.bug_id, args.session_id)
+
+    is_resume = args.resume_phase != "null"
+    if is_resume and os.path.exists(checkpoint_path):
+        try:
+            with open(checkpoint_path, "r", encoding="utf-8") as f:
+                existing = json.load(f)
+            checkpoint = merge_bugfix_checkpoint_state(
+                existing, checkpoint, project_root,
+            )
+            LOGGER.info("Merged existing bugfix checkpoint from %s",
+                        checkpoint_path)
+        except (json.JSONDecodeError, KeyError) as exc:
+            LOGGER.warning(
+                "Existing bugfix checkpoint corrupted (%s) — generating fresh",
+                exc,
+            )
+
+    with open(checkpoint_path, "w", encoding="utf-8") as f:
+        json.dump(checkpoint, f, indent=2, ensure_ascii=False)
+    LOGGER.info("Wrote bugfix checkpoint to %s", checkpoint_path)
+
     # Success
     output = {
         "success": True,
         "output_path": os.path.abspath(args.output),
+        "checkpoint_path": checkpoint_path,
     }
     print(json.dumps(output, indent=2, ensure_ascii=False))
     sys.exit(0)