prizmkit 1.1.1 → 1.1.3

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):
@@ -445,6 +547,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 = {
@@ -741,9 +875,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 +1092,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,
@@ -999,6 +1154,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 +1177,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 +1242,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"

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

@@ -0,0 +1,419 @@
+#!/usr/bin/env python3
+"""Generate a session-specific refactor bootstrap prompt from template and refactor-list.json.
+
+Reads the refactor-bootstrap-prompt.md template and a refactor-list.json, resolves all
+{{PLACEHOLDER}} variables, handles conditional blocks, and writes the rendered
+prompt to the specified output path.
+
+Usage:
+    python3 generate-refactor-prompt.py \
+        --refactor-list <path> --refactor-id <id> \
+        --session-id <id> --run-id <id> \
+        --retry-count <n> --resume-phase <n|null> \
+        --state-dir <path> --output <path>
+"""
+
+import argparse
+import json
+import os
+import sys
+
+from utils import enrich_global_context, load_json_file, setup_logging
+
+
+DEFAULT_MAX_RETRIES = 3
+
+LOGGER = setup_logging("generate-refactor-prompt")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description=(
+            "Generate a session-specific refactor bootstrap prompt from a template "
+            "and refactor-list.json."
+        )
+    )
+    parser.add_argument("--refactor-list", required=True, help="Path to refactor-list.json")
+    parser.add_argument("--refactor-id", required=True, help="Refactor ID to generate prompt for (e.g. R-001)")
+    parser.add_argument("--session-id", required=True, help="Session ID for this pipeline session")
+    parser.add_argument("--run-id", required=True, help="Pipeline run ID")
+    parser.add_argument("--retry-count", required=True, help="Current retry count")
+    parser.add_argument("--resume-phase", required=True, help='Phase to resume from, or "null" for fresh start')
+    parser.add_argument("--state-dir", default=None, help="State directory path for reading previous session info")
+    parser.add_argument("--output", required=True, help="Output path for the rendered prompt")
+    parser.add_argument("--template", default=None, help="Custom template path. Defaults to {script_dir}/../templates/refactor-bootstrap-prompt.md")
+    return parser.parse_args()
+
+
+def read_text_file(path):
+    """Read and return the text content of a file."""
+    abs_path = os.path.abspath(path)
+    if not os.path.isfile(abs_path):
+        return None, "File not found: {}".format(abs_path)
+    try:
+        with open(abs_path, "r", encoding="utf-8") as f:
+            return f.read(), None
+    except IOError as e:
+        return None, "Cannot read file: {}".format(str(e))
+
+
+def find_refactor(refactors, refactor_id):
+    """Find and return the refactor dict matching the given ID."""
+    for refactor in refactors:
+        if isinstance(refactor, dict) and refactor.get("id") == refactor_id:
+            return refactor
+    return None
+
+
+def format_acceptance_criteria(criteria):
+    """Format acceptance criteria as a markdown bullet list."""
+    if not criteria:
+        return "- (none specified)"
+    lines = []
+    for item in 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.
+
+    If global_context is empty/sparse and project_root is provided,
+    auto-detect tech stack from project files to fill gaps.
+    """
+    if project_root:
+        enrich_global_context(global_context, project_root)
+
+    if not global_context:
+        return "- (none specified)"
+    lines = []
+    for key, value in sorted(global_context.items()):
+        lines.append("- **{}**: {}".format(key, value))
+    return "\n".join(lines)
+
+
+def format_scope(scope):
+    """Format scope object into markdown detail lines."""
+    if not scope or not isinstance(scope, dict):
+        return "- (no scope details)"
+    lines = []
+
+    files = scope.get("files", [])
+    if files:
+        lines.append("- **Files**:")
+        for f in files:
+            lines.append("  - `{}`".format(f))
+
+    modules = scope.get("modules", [])
+    if modules:
+        lines.append("- **Modules**:")
+        for m in modules:
+            lines.append("  - `{}`".format(m))
+
+    if not lines:
+        lines.append("- (no scope details)")
+    return "\n".join(lines)
+
+
+def _format_scope_list(scope, key):
+    """Extract and format a list from scope by key (files or modules)."""
+    if not scope or not isinstance(scope, dict):
+        return "- (none specified)"
+    items = scope.get(key, [])
+    if not items:
+        return "- (none specified)"
+    return "\n".join("- `{}`".format(item) for item in items)
+
+
+def format_scope_files(scope):
+    """Extract and format just the files list from scope."""
+    return _format_scope_list(scope, "files")
+
+
+def format_scope_modules(scope):
+    """Extract and format just the modules list from scope."""
+    return _format_scope_list(scope, "modules")
+
+
+def format_behavior_preservation(bp):
+    """Format behavior_preservation object into markdown detail lines."""
+    if not bp or not isinstance(bp, dict):
+        return "- (no behavior preservation details)"
+    lines = []
+
+    strategy = bp.get("strategy", "unknown")
+    lines.append("- **Strategy**: {}".format(strategy))
+
+    existing_tests = bp.get("existing_tests", [])
+    if existing_tests:
+        lines.append("- **Existing Tests**:")
+        for t in existing_tests:
+            lines.append("  - `{}`".format(t))
+
+    new_tests_needed = bp.get("new_tests_needed", [])
+    if new_tests_needed:
+        lines.append("- **New Tests Needed**:")
+        for t in new_tests_needed:
+            lines.append("  - {}".format(t))
+
+    if len(lines) == 1:
+        lines.append("- (no additional details)")
+    return "\n".join(lines)
+
+
+def format_dependencies(dependencies):
+    """Format dependencies list as a markdown bullet list."""
+    if not dependencies or not isinstance(dependencies, list):
+        return "- (none)"
+    if len(dependencies) == 0:
+        return "- (none)"
+    lines = []
+    for dep in dependencies:
+        lines.append("- `{}`".format(dep))
+    return "\n".join(lines)
+
+
+def get_prev_session_status(state_dir, refactor_id):
+    """Read previous session status from state dir if available."""
+    if not state_dir:
+        return "N/A (first run)"
+
+    refactor_status_path = os.path.join(state_dir, "refactors", refactor_id, "status.json")
+    try:
+        with open(refactor_status_path, "r", encoding="utf-8") as f:
+            refactor_status = json.load(f)
+    except (json.JSONDecodeError, IOError, OSError):
+        return "N/A (first run)"
+
+    last_session_id = refactor_status.get("last_session_id")
+    if not last_session_id:
+        return "N/A (first run)"
+
+    session_status_path = os.path.join(
+        state_dir, "refactors", refactor_id, "sessions",
+        last_session_id, "session-status.json"
+    )
+    try:
+        with open(session_status_path, "r", encoding="utf-8") as f:
+            session_data = json.load(f)
+    except (json.JSONDecodeError, IOError, OSError):
+        return "N/A (previous session status file not found)"
+
+    status = session_data.get("status", "unknown")
+    checkpoint = session_data.get("checkpoint_reached", "none")
+    current_phase = session_data.get("current_phase", "unknown")
+    errors = session_data.get("errors", [])
+
+    result = "{} (checkpoint: {}, last phase: {})".format(
+        status, checkpoint, current_phase
+    )
+    if errors:
+        result += " — errors: {}".format("; ".join(str(e) for e in errors))
+    return result
+
+
+def resolve_project_root(script_dir):
+    """Resolve project root as the parent of dev-pipeline/."""
+    dev_pipeline_dir = os.path.dirname(script_dir)
+    project_root = os.path.dirname(dev_pipeline_dir)
+    return os.path.abspath(project_root)
+
+
+def build_replacements(args, refactor, global_context, script_dir):
+    """Build the full dict of placeholder -> replacement value."""
+    project_root = resolve_project_root(script_dir)
+
+    # Platform-aware agent/team path resolution
+    platform = os.environ.get("PRIZMKIT_PLATFORM", "")
+    home_dir = os.path.expanduser("~")
+
+    if not platform:
+        if os.path.isdir(os.path.join(project_root, ".claude", "agents")):
+            platform = "claude"
+        else:
+            platform = "codebuddy"
+
+    if platform == "claude":
+        agents_dir = os.path.join(project_root, ".claude", "agents")
+        team_config_path = os.path.join(project_root, ".claude", "team-info.json")
+    else:
+        agents_dir = os.path.join(project_root, ".codebuddy", "agents")
+        team_config_path = os.path.join(
+            home_dir, ".codebuddy", "teams", "prizm-dev-team", "config.json"
+        )
+
+    dev_subagent = os.path.join(agents_dir, "prizm-dev-team-dev.md")
+    reviewer_subagent = os.path.join(agents_dir, "prizm-dev-team-reviewer.md")
+
+    # Session status path
+    session_status_path = os.path.join(
+        project_root, "dev-pipeline", "refactor-state", "refactors", args.refactor_id,
+        "sessions", args.session_id, "session-status.json"
+    )
+
+    prev_status = get_prev_session_status(args.state_dir, args.refactor_id)
+
+    # Scope
+    scope = refactor.get("scope", {})
+
+    # Behavior preservation
+    bp = refactor.get("behavior_preservation", {})
+    behavior_strategy = bp.get("strategy", "test-gate") if isinstance(bp, dict) else "test-gate"
+    existing_tests = bp.get("existing_tests", []) if isinstance(bp, dict) else []
+    new_tests_needed = bp.get("new_tests_needed", []) if isinstance(bp, dict) else []
+
+    # Format existing tests
+    if existing_tests:
+        existing_tests_str = "\n".join("- `{}`".format(t) for t in existing_tests)
+    else:
+        existing_tests_str = "- (none specified)"
+
+    # Format new tests needed
+    if new_tests_needed:
+        new_tests_str = "\n".join("- {}".format(t) for t in new_tests_needed)
+    else:
+        new_tests_str = "- (none specified)"
+
+    replacements = {
+        "{{RUN_ID}}": args.run_id,
+        "{{SESSION_ID}}": args.session_id,
+        "{{REFACTOR_ID}}": args.refactor_id,
+        "{{REFACTOR_TITLE}}": refactor.get("title", ""),
+        "{{REFACTOR_TYPE}}": refactor.get("type", "restructure"),
+        "{{SCOPE_FILES}}": format_scope_files(scope),
+        "{{SCOPE_MODULES}}": format_scope_modules(scope),
+        "{{BEHAVIOR_STRATEGY}}": behavior_strategy,
+        "{{EXISTING_TESTS}}": existing_tests_str,
+        "{{NEW_TESTS_NEEDED}}": new_tests_str,
+        "{{PRIORITY}}": refactor.get("priority", "medium"),
+        "{{COMPLEXITY}}": refactor.get("complexity", "medium"),
+        "{{RETRY_COUNT}}": str(args.retry_count),
+        "{{MAX_RETRIES}}": str(DEFAULT_MAX_RETRIES),
+        "{{PREV_SESSION_STATUS}}": prev_status,
+        "{{RESUME_PHASE}}": args.resume_phase,
+        "{{REFACTOR_DESCRIPTION}}": refactor.get("description", ""),
+        "{{ACCEPTANCE_CRITERIA}}": format_acceptance_criteria(
+            refactor.get("acceptance_criteria", [])
+        ),
+        "{{DEPENDENCIES}}": format_dependencies(
+            refactor.get("dependencies", [])
+        ),
+        "{{GLOBAL_CONTEXT}}": format_global_context(global_context, project_root),
+        "{{TEAM_CONFIG_PATH}}": team_config_path,
+        "{{DEV_SUBAGENT_PATH}}": dev_subagent,
+        "{{REVIEWER_SUBAGENT_PATH}}": reviewer_subagent,
+        "{{SESSION_STATUS_PATH}}": session_status_path,
+        "{{PROJECT_ROOT}}": project_root,
+        "{{TIMESTAMP}}": "",  # Placeholder — agent fills in timestamp
+    }
+
+    return replacements
+
+
+def render_template(template_content, replacements):
+    """Render the template by replacing all {{PLACEHOLDER}} variables."""
+    content = template_content
+
+    # Replace all {{PLACEHOLDER}} variables
+    for placeholder, value in replacements.items():
+        content = content.replace(placeholder, value)
+
+    return content
+
+
+def write_output(output_path, content):
+    """Write the rendered content to the output file."""
+    abs_path = os.path.abspath(output_path)
+    output_dir = os.path.dirname(abs_path)
+    if output_dir and not os.path.isdir(output_dir):
+        try:
+            os.makedirs(output_dir, exist_ok=True)
+        except OSError as e:
+            return "Cannot create output directory: {}".format(str(e))
+    try:
+        with open(abs_path, "w", encoding="utf-8") as f:
+            f.write(content)
+    except IOError as e:
+        return "Cannot write output file: {}".format(str(e))
+    return None
+
+
+def emit_failure(message):
+    """Emit standardized failure JSON and exit.
+
+    Uses a different format than error_out() — includes 'success: false'
+    for compatibility with the pipeline's JSON parsing expectations.
+    """
+    print(json.dumps({"success": False, "error": message}, indent=2, ensure_ascii=False))
+    sys.exit(1)
+
+
+def main():
+    args = parse_args()
+
+    # Resolve script directory
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+
+    # Resolve template path
+    if args.template:
+        template_path = args.template
+    else:
+        template_path = os.path.join(
+            script_dir, "..", "templates", "refactor-bootstrap-prompt.md"
+        )
+
+    # Load template
+    template_content, err = read_text_file(template_path)
+    if err:
+        emit_failure("Template error: {}".format(err))
+
+    # Load refactor list
+    refactor_list_data, err = load_json_file(args.refactor_list)
+    if err:
+        emit_failure("Refactor list error: {}".format(err))
+
+    # Extract refactors array
+    refactors = refactor_list_data.get("refactors")
+    if not isinstance(refactors, list):
+        emit_failure("Refactor list does not contain a 'refactors' array")
+
+    # Find the target refactor
+    refactor = find_refactor(refactors, args.refactor_id)
+    if refactor is None:
+        emit_failure("Refactor '{}' not found in refactor list".format(args.refactor_id))
+
+    # Extract global context
+    global_context = refactor_list_data.get("global_context", {})
+    if not isinstance(global_context, dict):
+        global_context = {}
+
+    # Build replacements
+    replacements = build_replacements(args, refactor, global_context, script_dir)
+
+    # Render the template
+    rendered = render_template(template_content, replacements)
+
+    # Write the output
+    err = write_output(args.output, rendered)
+    if err:
+        emit_failure(err)
+
+    # Success
+    output = {
+        "success": True,
+        "output_path": os.path.abspath(args.output),
+    }
+    print(json.dumps(output, indent=2, ensure_ascii=False))
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        emit_failure("generate-refactor-prompt interrupted")
+    except SystemExit:
+        raise
+    except Exception as exc:
+        LOGGER.exception("Unhandled exception in generate-refactor-prompt")
+        emit_failure("Unexpected error: {}".format(str(exc)))