@pennyfarthing/core 11.3.2 → 11.3.4

package/pennyfarthing-dist/pf/handoff/marker.py

@@ -0,0 +1,109 @@
+"""Generate AGENT_COMMAND block for handoff markers.
+
+Replaces handoff-marker.sh with a Python implementation that reuses
+the existing context.py module for environment detection.
+
+Story: 105-4 (Script-First Handoff)
+"""
+
+from __future__ import annotations
+
+from pf.context import check_context
+
+
+def generate_marker(
+    next_agent: str | None = None,
+    *,
+    error: str | None = None,
+) -> str:
+    """Generate an AGENT_COMMAND block for agent handoff.
+
+    Args:
+        next_agent: Agent to hand off to (e.g., "dev", "tea", "reviewer").
+        error: If set, generates an error block instead of a handoff.
+
+    Returns:
+        YAML-formatted AGENT_COMMAND block string.
+    """
+    if error:
+        return _block(fallback=error, error=True)
+
+    if not next_agent:
+        return _block(fallback="No next agent specified", error=True)
+
+    ctx = check_context()
+
+    cmd = f"/pf-{next_agent}"
+    pct = ctx.usable_percent if not ctx.error else "unknown"
+
+    if pct != "unknown" and pct >= 60:
+        context_warning = f" (context: {pct}% - consider /clear before continuing)"
+    elif pct != "unknown":
+        context_warning = f" (context: {pct}%)"
+    else:
+        context_warning = ""
+
+    if not ctx.relay_mode:
+        # Relay off — ask for confirmation
+        if ctx.is_cyclist:
+            return _block(
+                marker="<!-- CYCLIST:QUESTION:yesno -->",
+                question=f"Ready to hand off to {cmd}?",
+                fallback=f"Run `{cmd}` to continue",
+            )
+        return _block(
+            fallback=f"Run `{cmd}` to continue{context_warning}",
+            relay_mode=False,
+            context_percent=pct,
+        )
+
+    # Relay on — auto-handoff
+    # Cyclist uses its feedback loop (QuickActions → slash command injection).
+    # Non-Cyclist: we're already in the session, invoke the agent directly.
+    marker = None
+    if ctx.use_tirepump:
+        marker = f"<!-- CYCLIST:CONTEXT_CLEAR:{cmd} -->" if ctx.is_cyclist else None
+    else:
+        marker = f"<!-- CYCLIST:HANDOFF:{cmd} -->" if ctx.is_cyclist else None
+
+    if ctx.is_cyclist:
+        return _block(
+            marker=marker,
+            fallback=f"Run `{cmd}` to continue",
+        )
+
+    # Non-Cyclist relay: return structured action for the agent to act on.
+    # The calling agent reads the `action` field and executes accordingly.
+    if ctx.use_tirepump:
+        return _block(
+            action="tirepump_handoff",
+            next_agent=next_agent,
+            fallback=f"Context is high ({pct}%). Run /clear then {cmd}",
+            context_percent=pct,
+            relay_mode=True,
+        )
+
+    return _block(
+        action="inline_handoff",
+        next_agent=next_agent,
+        activation_command=f"pf agent start {next_agent} --tier handoff --quiet",
+        fallback=f"Run `{cmd}` to continue",
+        context_percent=pct,
+        relay_mode=True,
+    )
+
+
+def _block(**fields: object) -> str:
+    """Format an AGENT_COMMAND YAML block."""
+    lines = ["---", "AGENT_COMMAND:"]
+    for key, value in fields.items():
+        if isinstance(value, bool):
+            lines.append(f"  {key}: {str(value).lower()}")
+        elif isinstance(value, str) and value:
+            lines.append(f'  {key}: "{value}"')
+        elif value == "":
+            lines.append(f'  {key}: ""')
+        else:
+            lines.append(f"  {key}: {value}")
+    lines.append("---")
+    return "\n".join(lines)

package/pennyfarthing-dist/pf/handoff/phase_check.py

@@ -0,0 +1,96 @@
+"""Phase check for agent activation.
+
+Determines whether the requested agent owns the current workflow phase.
+If not, returns a redirect to the correct agent. Replaces phase-check-start.sh.
+
+Story: 110-8 (CLI Relay Handoff Fix)
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pf.common.config import get_project_root
+from pf.prime.workflow import (
+    check_redirect,
+    detect_workflow_state,
+    find_active_session,
+    parse_session_header,
+)
+
+
+def phase_check_start(
+    agent_name: str,
+    project_root: Path | None = None,
+) -> dict:
+    """Check if requested agent owns current phase.
+
+    Args:
+        agent_name: Agent to check (e.g., "dev", "tea", "reviewer").
+        project_root: Project root path (auto-detected if not provided).
+
+    Returns:
+        Dict with:
+          action: "start" (proceed) or "redirect" (wrong agent)
+          agent: The agent that should run
+          story_id: Current story ID (if session exists)
+          phase: Current phase (if session exists)
+          phase_owner: Agent that owns the phase
+          message: Human-readable explanation
+    """
+    root = project_root or get_project_root()
+
+    # Find active session
+    session_file = find_active_session(root)
+    if not session_file:
+        return {
+            "action": "start",
+            "agent": agent_name,
+            "story_id": None,
+            "phase": None,
+            "phase_owner": None,
+            "message": f"No active session — starting {agent_name}",
+        }
+
+    # Parse session header
+    header = parse_session_header(session_file)
+    story_id = header.get("story_id")
+    workflow = header.get("workflow", "tdd")
+    phase = header.get("phase")
+
+    if not phase:
+        return {
+            "action": "start",
+            "agent": agent_name,
+            "story_id": story_id,
+            "phase": None,
+            "phase_owner": None,
+            "message": f"No phase detected — starting {agent_name}",
+        }
+
+    # Use detect_workflow_state + check_redirect for consistent logic
+    workflow_status = detect_workflow_state(root)
+    redirect = check_redirect(workflow_status, agent_name)
+
+    if redirect:
+        target_agent, reason = redirect
+        return {
+            "action": "redirect",
+            "agent": target_agent,
+            "story_id": story_id,
+            "phase": phase,
+            "phase_owner": target_agent,
+            "message": (
+                f"Story {story_id} is in '{phase}' phase "
+                f"(workflow: {workflow}) — owned by {target_agent}"
+            ),
+        }
+
+    return {
+        "action": "start",
+        "agent": agent_name,
+        "story_id": story_id,
+        "phase": phase,
+        "phase_owner": agent_name,
+        "message": f"Agent {agent_name} owns phase '{phase}' — proceeding",
+    }

package/pennyfarthing-dist/pf/healthscore/__init__.py

@@ -0,0 +1,21 @@
+"""
+Composite health score for codebase analysis.
+
+Aggregates 8 dimensions into a single 0-100 weighted score:
+churn, TODO density, complexity, test gaps, dead code,
+deprecation debt, dependency freshness, agent context efficiency.
+"""
+
+from pf.healthscore.analyze import analyze_healthscore
+from pf.healthscore.models import (
+    DEFAULT_WEIGHTS,
+    DimensionScore,
+    HealthscoreResult,
+)
+
+__all__ = [
+    "DimensionScore",
+    "HealthscoreResult",
+    "DEFAULT_WEIGHTS",
+    "analyze_healthscore",
+]

package/pennyfarthing-dist/pf/healthscore/__main__.py

@@ -0,0 +1,14 @@
+"""Allow running as: python -m pf.healthscore"""
+
+import logging
+import sys
+
+from pf.healthscore.cli import healthscore
+
+if __name__ == "__main__":
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(message)s",
+        stream=sys.stderr,
+    )
+    healthscore()