prizmkit 1.1.100 → 1.1.102

package/bundled/dev-pipeline/prizmkit_runtime/runner_status.py

@@ -0,0 +1,153 @@
+"""Status updater subprocess bridge for Python foreground runners."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+from .runner_models import RunnerEnvironment, RunnerFamily, RunnerInvocation
+
+
+@dataclass(frozen=True)
+class StatusCommandResult:
+    """Captured output from a canonical status updater script."""
+
+    action: str
+    return_code: int
+    stdout: str
+    stderr: str
+    data: object | None = None
+
+    @property
+    def ok(self) -> bool:
+        return self.return_code == 0
+
+    @property
+    def text(self) -> str:
+        return self.stdout.strip() or self.stderr.strip()
+
+
+def _resolved_max_retries(invocation: RunnerInvocation) -> int:
+    if invocation.max_retries is not None:
+        return max(0, invocation.max_retries)
+    return RunnerEnvironment.from_env().max_retries
+
+
+def run_status_action(
+    family: RunnerFamily,
+    action: str,
+    invocation: RunnerInvocation,
+    *,
+    item_id: str = "",
+    session_status: str = "",
+    session_id: str = "",
+    max_retries: int | None = None,
+    active_dev_branch: str = "",
+    base_branch: str = "",
+    last_fatal_error_code: str = "",
+    continuation_summary_path: Path | None = None,
+    no_progress_count: int | None = None,
+    progress_fingerprint: object | None = None,
+    project_root: Path | None = None,
+) -> StatusCommandResult:
+    max_retries = _resolved_max_retries(invocation) if max_retries is None else max(0, max_retries)
+    command = [
+        sys.executable,
+        str(family.updater_script),
+        family.list_arg,
+        str(invocation.list_path),
+        "--state-dir",
+        str(family.state_dir),
+        "--action",
+        action,
+        "--max-retries",
+        str(max_retries),
+        "--max-infra-retries",
+        str(invocation.max_infra_retries),
+    ]
+    if item_id:
+        command.extend([family.item_id_arg, item_id])
+    if session_status:
+        command.extend(["--session-status", session_status])
+    if session_id:
+        command.extend(["--session-id", session_id])
+    if family.kind == "feature" and invocation.item_filter:
+        command.extend(["--features", invocation.item_filter])
+    if active_dev_branch:
+        command.extend(["--active-dev-branch", active_dev_branch])
+    if base_branch:
+        command.extend(["--base-branch", base_branch])
+    if last_fatal_error_code:
+        command.extend(["--last-fatal-error-code", last_fatal_error_code])
+    if continuation_summary_path is not None:
+        command.extend(["--continuation-summary-path", str(continuation_summary_path)])
+    if no_progress_count is not None:
+        command.extend(["--no-progress-count", str(no_progress_count)])
+    if progress_fingerprint is not None:
+        command.extend(["--progress-fingerprint", json.dumps(progress_fingerprint, sort_keys=True)])
+    if project_root is not None:
+        command.extend(["--project-root", str(project_root)])
+
+    completed = subprocess.run(
+        command,
+        cwd=str(project_root or family.plan_path.parent.parent.parent),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        check=False,
+    )
+    text = completed.stdout.strip()
+    data = None
+    if text and text not in {"PIPELINE_COMPLETE", "PIPELINE_BLOCKED"}:
+        try:
+            data = json.loads(text)
+        except json.JSONDecodeError:
+            data = None
+    return StatusCommandResult(
+        action=action,
+        return_code=completed.returncode,
+        stdout=completed.stdout,
+        stderr=completed.stderr,
+        data=data,
+    )
+
+
+def get_next(family: RunnerFamily, invocation: RunnerInvocation, project_root: Path) -> StatusCommandResult:
+    return run_status_action(family, "get_next", invocation, project_root=project_root)
+
+
+def start_item(family: RunnerFamily, invocation: RunnerInvocation, item_id: str, project_root: Path) -> StatusCommandResult:
+    return run_status_action(family, "start", invocation, item_id=item_id, project_root=project_root)
+
+
+def update_item(
+    family: RunnerFamily,
+    invocation: RunnerInvocation,
+    item_id: str,
+    session_status: str,
+    session_id: str,
+    project_root: Path,
+    **metadata: object,
+) -> StatusCommandResult:
+    return run_status_action(
+        family,
+        "update",
+        invocation,
+        item_id=item_id,
+        session_status=session_status,
+        session_id=session_id,
+        project_root=project_root,
+        active_dev_branch=str(metadata.get("active_dev_branch") or ""),
+        base_branch=str(metadata.get("base_branch") or ""),
+        last_fatal_error_code=str(metadata.get("last_fatal_error_code") or ""),
+        continuation_summary_path=metadata.get("continuation_summary_path") if isinstance(metadata.get("continuation_summary_path"), Path) else None,
+        no_progress_count=metadata.get("no_progress_count") if isinstance(metadata.get("no_progress_count"), int) else None,
+        progress_fingerprint=metadata.get("progress_fingerprint"),
+    )
+
+
+def status_text(family: RunnerFamily, invocation: RunnerInvocation, project_root: Path) -> StatusCommandResult:
+    return run_status_action(family, "status", invocation, project_root=project_root)

package/bundled/dev-pipeline/prizmkit_runtime/runners.py

@@ -0,0 +1,425 @@
+"""Python foreground runner dispatch for feature, bugfix, refactor, and recovery."""
+
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+
+from .commands import CommandResult  # type: ignore  # imported only at runtime by commands.py
+from .config import load_runtime_config
+from .gitops import (
+    BranchContext,
+    WorktreePolicy,
+    branch_create_plan,
+    branch_ensure_return,
+    branch_merge_plan,
+    current_branch,
+    ensure_linked_worktree,
+    guarded_worktree_remove,
+    materialize_worktree_support_assets,
+    merge_linked_worktree,
+    run_git_command,
+    run_git_plan,
+    worktree_runtime_context,
+    worktree_save_wip,
+)
+from .runner_bookkeeping import commit_final_bookkeeping, commit_pre_branch_bookkeeping
+from .runner_classification import classify_session
+from .runner_models import RunnerEnvironment, RunnerFamily, RunnerInvocation, SessionPaths, family_for, parse_invocation
+from .runner_prompts import PromptGenerationResult, generate_prompt
+from .runner_recovery import run_recovery, run_recovery_detect
+from .runner_status import get_next, run_status_action, start_item, status_text, update_item
+from .sessions import AISessionConfig, AISessionLauncher, detect_stream_json_support
+
+
+def run_pipeline_command(kind: str, action: str, legacy_args: tuple[str, ...], paths) -> CommandResult:
+    """Dispatch a feature/bugfix/refactor Python foreground command."""
+    family = family_for(kind, paths)
+    invocation = parse_invocation(family, action, legacy_args)
+    invocation = _resolve_invocation_paths(invocation, paths.project_root)
+    if invocation.help_requested:
+        return CommandResult(0, f"Python {kind} runner", _help_text(family))
+    if action == "status":
+        status = status_text(family, invocation, paths.project_root)
+        return CommandResult(status.return_code, f"Python {kind} status", status.stdout.strip() or status.stderr.strip())
+    if action == "unskip":
+        status = run_status_action(
+            family,
+            "unskip",
+            invocation,
+            item_id=invocation.item_id,
+            project_root=paths.project_root,
+        )
+        return CommandResult(
+            status.return_code,
+            f"Python {kind} unskip",
+            status.stdout.strip() or status.stderr.strip(),
+        )
+    if action == "test-cli":
+        return _test_cli(kind, paths)
+    if action != "run":
+        return CommandResult(1, "Unsupported Python runner action", f"Unsupported action: {kind} {action}")
+    if not invocation.list_path.is_file():
+        return CommandResult(1, f"Python {kind} runner", f"Plan list not found: {invocation.list_path}")
+    try:
+        result = _run_pipeline(family, invocation, paths)
+    except Exception as exc:  # keep CLI boundary traceback-free
+        return CommandResult(1, f"Python {kind} runner failed", str(exc))
+    details = result.details + ((f"last_status: {result.last_status}",) if result.last_status else ())
+    return CommandResult(
+        0 if result.completed else 1,
+        f"Python {kind} runner",
+        f"processed={result.processed} completed={result.completed} stopped_reason={result.stopped_reason or 'none'}",
+        details=details,
+    )
+
+
+def run_recovery_command(action: str, legacy_args: tuple[str, ...], paths) -> CommandResult:
+    """Dispatch a Python recovery command."""
+    if action == "detect":
+        code, stdout, stderr, _data = run_recovery_detect(paths)
+        return CommandResult(code, "Python recovery detect", stdout.strip() or stderr.strip())
+    if action == "run":
+        code, stdout, stderr = run_recovery(paths, legacy_args)
+        return CommandResult(code, "Python recovery run", stdout.strip() or stderr.strip())
+    return CommandResult(1, "Unsupported Python recovery action", f"Unsupported action: {action}")
+
+
+def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) -> "PipelineRunResult":
+    from .runner_models import PipelineRunResult
+
+    processed = 0
+    details: list[str] = []
+    if invocation.item_id:
+        status = _process_item(family, invocation, invocation.item_id, paths, initial_metadata={})
+        return PipelineRunResult(status == "completed", 1, "single_item_done", status, tuple(details))
+
+    while True:
+        next_result = get_next(family, invocation, paths.project_root)
+        if not next_result.ok:
+            return PipelineRunResult(False, processed, "get_next_failed", details=(next_result.text,))
+        marker = next_result.stdout.strip()
+        if marker == "PIPELINE_COMPLETE":
+            return PipelineRunResult(True, processed, "pipeline_complete", details=tuple(details))
+        if marker == "PIPELINE_BLOCKED":
+            return PipelineRunResult(False, processed, "pipeline_blocked", details=tuple(details))
+        if not isinstance(next_result.data, dict):
+            return PipelineRunResult(False, processed, "invalid_get_next_output", details=(marker[:500],))
+        item_id = str(next_result.data.get(f"{family.kind}_id") or next_result.data.get("feature_id") or next_result.data.get("bug_id") or next_result.data.get("refactor_id") or "")
+        if not item_id:
+            return PipelineRunResult(False, processed, "missing_item_id", details=(marker[:500],))
+        final_status = _process_item(family, invocation, item_id, paths, initial_metadata=next_result.data)
+        processed += 1
+        details.append(f"{item_id}:{final_status}")
+        if final_status == "completed":
+            continue
+        if final_status == "pending":
+            continue
+        if RunnerEnvironment.from_env().stop_on_failure:
+            return PipelineRunResult(False, processed, "stop_on_failure", final_status, tuple(details))
+        if final_status in {"failed", "needs_info"}:
+            return PipelineRunResult(False, processed, "item_failed", final_status, tuple(details))
+
+
+def _process_item(
+    family: RunnerFamily,
+    invocation: RunnerInvocation,
+    item_id: str,
+    paths,
+    *,
+    initial_metadata: dict[str, object],
+) -> str:
+    env = RunnerEnvironment.from_env()
+    config = load_runtime_config(paths)
+    if not config.ai_client.command:
+        raise RuntimeError("No supported AI CLI command was found")
+    start = start_item(family, invocation, item_id, paths.project_root)
+    if not start.ok:
+        raise RuntimeError(start.text)
+    commit_pre_branch_bookkeeping(paths.project_root, family, item_id)
+
+    base_branch = str(initial_metadata.get("base_branch") or current_branch(paths.project_root) or "main")
+    branch_name = str(initial_metadata.get("active_dev_branch") or env.dev_branch or _default_branch_name(family, item_id))
+    branch_context = BranchContext(base_branch, branch_name, paths.project_root)
+    worktree_runtime = None
+    use_worktree = _use_worktree_for_family(env, family)
+    execution_root = paths.project_root
+    if use_worktree:
+        worktree_runtime = worktree_runtime_context(
+            branch_context,
+            WorktreePolicy(
+                use_worktree=True,
+                cleanup_on_success=True,
+                preserve_on_failure=True,
+                worktree_root=paths.state_dir / "worktrees",
+            ),
+        )
+        setup = ensure_linked_worktree(worktree_runtime)
+        if not setup.ok:
+            status = update_item(family, invocation, item_id, "infra_error", "", paths.project_root)
+            return _status_from_update(status)
+        worktree_runtime = setup.runtime or worktree_runtime
+        support_assets = materialize_worktree_support_assets(worktree_runtime)
+        if not support_assets.ok:
+            status = update_item(family, invocation, item_id, "infra_error", "", paths.project_root)
+            return _status_from_update(status)
+        execution_root = worktree_runtime.worktree_path
+    else:
+        branch_result = run_git_plan(paths.project_root, branch_create_plan(branch_context))
+        if not branch_result.ok:
+            status = update_item(family, invocation, item_id, "infra_error", "", paths.project_root)
+            return _status_from_update(status)
+
+    previous_fingerprint = initial_metadata.get("last_progress_fingerprint")
+    previous_no_progress_count = int(initial_metadata.get("no_progress_count") or 0)
+    continuation_pending = bool(initial_metadata.get("continuation_pending"))
+    previous_session_id = str(initial_metadata.get("previous_session_id") or initial_metadata.get("last_context_overflow_session_id") or "")
+    continuation_count = int(initial_metadata.get("continuation_count") or 0)
+    context_overflow_count = int(initial_metadata.get("context_overflow_count") or 0)
+
+    while True:
+        session_id = _session_id(item_id)
+        session_paths = SessionPaths.for_item(family.state_dir, item_id, session_id)
+        continuation = None
+        if continuation_pending:
+            continuation = {
+                "previous_session_id": previous_session_id,
+                "continuation_count": continuation_count,
+                "context_overflow_count": context_overflow_count,
+                "task_type": family.task_type,
+                "active_dev_branch": branch_name,
+                "base_branch": base_branch,
+                "continuation_summary_path": _continuation_summary_path(paths.project_root, family, item_id, None),
+            }
+        prompt = generate_prompt(
+            family,
+            invocation,
+            item_id=item_id,
+            session_id=session_id,
+            run_id="run-python",
+            retry_count=0,
+            session_paths=session_paths,
+            project_root=paths.project_root,
+            execution_root=execution_root,
+            continuation=continuation,
+        )
+        if invocation.dry_run:
+            return "dry_run"
+        stream_json = detect_stream_json_support(config.ai_client.command, config.ai_client.platform).enabled
+        base_head = run_git_command(execution_root, ("rev-parse", "HEAD")).stdout.strip()
+        session_result = AISessionLauncher(
+            AISessionConfig(
+                cli_command=config.ai_client.command,
+                platform=config.ai_client.platform or "codebuddy",
+                model=prompt.model or config.model,
+                prompt_path=prompt.output_path,
+                cwd=execution_root,
+                log_path=session_paths.session_log,
+                progress_path=session_paths.progress_json,
+                heartbeat_path=session_paths.heartbeat_json,
+                effort=config.effort,
+                verbose=env.verbose,
+                use_stream_json=stream_json,
+                stale_kill_threshold_seconds=env.stale_kill_threshold_seconds,
+            )
+        ).run()
+        classification = classify_session(
+            session_result,
+            project_root=execution_root,
+            base_head=base_head,
+            prompt=prompt,
+            previous_fingerprint=previous_fingerprint,
+            previous_no_progress_count=previous_no_progress_count,
+        )
+        if classification.session_status == "context_overflow":
+            summary_path = _continuation_summary_path(paths.project_root, family, item_id, prompt)
+            update = update_item(
+                family,
+                invocation,
+                item_id,
+                "context_overflow",
+                session_id,
+                paths.project_root,
+                active_dev_branch=branch_name,
+                base_branch=base_branch,
+                last_fatal_error_code=classification.fatal_error_code or "context_overflow",
+                continuation_summary_path=summary_path,
+                no_progress_count=classification.no_progress_count,
+                progress_fingerprint=classification.progress_fingerprint,
+            )
+            if not update.ok:
+                raise RuntimeError(update.text)
+            previous_fingerprint = classification.progress_fingerprint
+            previous_no_progress_count = classification.no_progress_count
+            continuation_pending = True
+            previous_session_id = session_id
+            continuation_count += 1
+            context_overflow_count += 1
+            continue
+
+        final_session_status = classification.session_status
+        if use_worktree and worktree_runtime is not None:
+            if final_session_status == "success":
+                merge = merge_linked_worktree(worktree_runtime, auto_push=env.auto_push)
+                if merge.ok:
+                    guarded_worktree_remove(worktree_runtime, delete_branch=True)
+                else:
+                    final_session_status = "merge_conflict"
+                    guarded_worktree_remove(worktree_runtime, delete_branch=False)
+            else:
+                worktree_save_wip(worktree_runtime)
+                guarded_worktree_remove(worktree_runtime, delete_branch=False)
+        else:
+            if final_session_status == "success":
+                merge = run_git_plan(paths.project_root, branch_merge_plan(branch_context, auto_push=env.auto_push))
+                if not merge.ok:
+                    branch_ensure_return(paths.project_root, base_branch, branch_name)
+                    final_session_status = "merge_conflict"
+            else:
+                branch_ensure_return(paths.project_root, base_branch, branch_name)
+
+        _write_session_status(
+            session_paths,
+            status=final_session_status,
+            session_id=session_id,
+            task_id=item_id,
+            task_type=family.task_type,
+            base_branch=base_branch,
+            active_dev_branch=branch_name,
+            worktree_path=worktree_runtime.worktree_path if worktree_runtime is not None else None,
+            reason=classification.reason,
+            fatal_error_code=classification.fatal_error_code,
+        )
+
+        update = update_item(
+            family,
+            invocation,
+            item_id,
+            final_session_status,
+            session_id,
+            paths.project_root,
+            active_dev_branch=branch_name,
+            base_branch=base_branch,
+            last_fatal_error_code=classification.fatal_error_code,
+            no_progress_count=classification.no_progress_count,
+            progress_fingerprint=classification.progress_fingerprint,
+        )
+        if not update.ok:
+            raise RuntimeError(update.text)
+        new_status = _status_from_update(update)
+        commit_final_bookkeeping(paths.project_root, family, item_id, new_status)
+        return new_status
+
+
+
+def _test_cli(kind: str, paths) -> CommandResult:
+    """Report the AI CLI resolution used by Python runner commands."""
+    config = load_runtime_config(paths)
+    cli = config.ai_client.command or "(not found)"
+    platform = config.ai_client.platform or "unresolved"
+    details = [
+        f"detected_cli: {cli}",
+        f"platform: {platform}",
+        f"source: {config.ai_client.source}",
+        f"runtime_mode: {config.runtime_mode}",
+    ]
+    if config.model:
+        details.append(f"model: {config.model}")
+    details.extend(f"note: {note}" for note in config.ai_client.notes)
+    return CommandResult(
+        0 if config.ai_client.command else 1,
+        f"Python {kind} AI CLI test",
+        "AI CLI resolution for the canonical Python runtime.",
+        tuple(details),
+    )
+
+
+def _use_worktree_for_family(env: RunnerEnvironment, family: RunnerFamily) -> bool:
+    return env.use_worktree and family.kind in {"feature", "bugfix"}
+
+
+def _write_session_status(
+    session_paths: SessionPaths,
+    *,
+    status: str,
+    session_id: str,
+    task_id: str,
+    task_type: str,
+    base_branch: str,
+    active_dev_branch: str,
+    worktree_path: Path | None = None,
+    reason: str = "",
+    fatal_error_code: str = "",
+) -> None:
+    payload = {
+        "status": status,
+        "session_id": session_id,
+        "task_id": task_id,
+        "task_type": task_type,
+        "base_branch": base_branch,
+        "active_dev_branch": active_dev_branch,
+    }
+    if worktree_path is not None:
+        payload["worktree_path"] = str(worktree_path)
+    if reason:
+        payload["reason"] = reason
+    if fatal_error_code:
+        payload["fatal_error_code"] = fatal_error_code
+    session_paths.session_status_json.parent.mkdir(parents=True, exist_ok=True)
+    session_paths.session_status_json.write_text(
+        json.dumps(payload, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+
+def _status_from_update(update_result) -> str:
+    if isinstance(update_result.data, dict):
+        return str(update_result.data.get("new_status") or update_result.data.get("status") or "unknown")
+    return "unknown"
+
+
+def _default_branch_name(family: RunnerFamily, item_id: str) -> str:
+    stamp = time.strftime("%Y%m%d%H%M")
+    return f"{family.branch_prefix}/{item_id}-{stamp}"
+
+
+def _session_id(item_id: str) -> str:
+    return f"{item_id}-{time.strftime('%Y%m%d%H%M%S')}"
+
+
+def _continuation_summary_path(project_root: Path, family: RunnerFamily, item_id: str, prompt: PromptGenerationResult | None) -> Path:
+    if prompt and prompt.artifact_path:
+        return prompt.artifact_path / "continuation-summary.md"
+    if family.kind == "feature":
+        return project_root / ".prizmkit" / "specs" / item_id / "continuation-summary.md"
+    return project_root / ".prizmkit" / family.artifact_root_name / item_id / "continuation-summary.md"
+
+
+def _resolve_invocation_paths(invocation: RunnerInvocation, project_root: Path) -> RunnerInvocation:
+    if invocation.list_path.is_absolute():
+        return invocation
+    return RunnerInvocation(
+        action=invocation.action,
+        list_path=(project_root / invocation.list_path).resolve(),
+        item_id=invocation.item_id,
+        item_filter=invocation.item_filter,
+        max_retries=invocation.max_retries,
+        max_infra_retries=invocation.max_infra_retries,
+        mode=invocation.mode,
+        critic=invocation.critic,
+        dry_run=invocation.dry_run,
+        clean=invocation.clean,
+        no_reset=invocation.no_reset,
+        resume_phase=invocation.resume_phase,
+        help_requested=invocation.help_requested,
+        unknown_args=invocation.unknown_args,
+        raw_args=invocation.raw_args,
+    )
+
+
+def _help_text(family: RunnerFamily) -> str:
+    return (
+        f"Python foreground runner for {family.kind}.\n"
+        "Supported legacy options include plan list path, item id, --features for feature, "
+        "--max-retries, --max-infra-retries, --mode, --critic/--no-critic, --resume-phase, and --dry-run."
+    )