@pennyfarthing/core 11.1.1 → 11.2.1

package/pennyfarthing_scripts/bikerack/ws_client.py

@@ -75,14 +75,14 @@ class WheelHubClient:
             cb(new_state)
 
     def discover_port(self) -> int:
-        """Read port from .bikerack-port file, fallback to DEFAULT_PORT.
+        """Read port from .wheelhub-port file, fallback to DEFAULT_PORT.
 
         Priority: explicit port > port file > DEFAULT_PORT.
         """
         if self._port is not None:
             return self._port
         if self._project_dir is not None:
-            port_file = self._project_dir / ".bikerack-port"
+            port_file = self._project_dir / ".wheelhub-port"
             if port_file.exists():
                 try:
                     return int(port_file.read_text().strip())

package/pennyfarthing_scripts/cli.py

@@ -137,6 +137,16 @@ from pennyfarthing_scripts.epic.cli import epic  # noqa: E402
 
 cli.add_command(epic)
 
+# Import and register consultation group
+from pennyfarthing_scripts.consultation.cli import consultation  # noqa: E402
+
+cli.add_command(consultation)
+
+# Import and register hooks group
+from pennyfarthing_scripts.hooks.cli import hooks  # noqa: E402
+
+cli.add_command(hooks)
+
 
 @cli.group()
 def agent():
@@ -144,7 +154,8 @@ def agent():
 
     \b
     Commands:
-      start  - Start an agent session with context
+      start    - Start an agent session with context
+      heatmap  - Visualize context distribution and attention
     """
     pass
 
@@ -193,78 +204,44 @@ def agent_start(
     raise SystemExit(exit_code)
 
 
-@cli.group()
-def workflow():
-    """Workflow state and phase management.
-
-    \b
-    Commands:
-      check       - Check current workflow state
-      phase-check - Verify phase ownership
-      handoff     - Emit handoff marker
-    """
-    pass
-
-
-@workflow.command("check")
-@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
-def workflow_check(output_json: bool):
-    """Check current workflow state.
-
-    Returns the current story ID, phase, and workflow state.
-    """
-    # Lazy import - only load when command is actually invoked
-    from pennyfarthing_scripts.workflow import get_workflow_state
-
-    state = get_workflow_state()
-
-    if output_json:
-        import json
-
-        click.echo(json.dumps(state, indent=2))
-    else:
-        click.echo(f"State: {state.get('state', 'unknown')}")
-        if state.get("story_id"):
-            click.echo(f"Story: {state['story_id']}")
-        if state.get("workflow"):
-            click.echo(f"Workflow: {state['workflow']}")
-        if state.get("phase"):
-            click.echo(f"Phase: {state['phase']}")
-
+@agent.command("heatmap")
+@click.argument("name", required=False)
+@click.option("--all", "show_all", is_flag=True, help="Show summary across all primary agents")
+@click.option("--csv", "csv_output", is_flag=True, help="Output CSV for machine consumption")
+@click.option("--json", "json_output", is_flag=True, help="Output JSON")
+def agent_heatmap(
+    name: str | None,
+    show_all: bool,
+    csv_output: bool,
+    json_output: bool,
+):
+    """Visualize context distribution and attention for agent activation.
 
-@workflow.command("phase-check")
-@click.argument("workflow_name")
-@click.argument("phase")
-def workflow_phase_check(workflow_name: str, phase: str):
-    """Check which agent owns a workflow phase.
+    Shows a heat map of how tokens are distributed across sections of an
+    agent's activation context, with attention scores based on the
+    "Lost in the Middle" U-shaped attention model.
 
     \b
-    Arguments:
-      WORKFLOW_NAME  - The workflow type (tdd, trivial, etc.)
-      PHASE          - The phase to check (red, implement, review, etc.)
+    Examples:
+      pf agent heatmap sm           # Detailed view for SM
+      pf agent heatmap --all        # Summary across all agents
+      pf agent heatmap dev --json   # JSON output for tooling
     """
-    # Lazy import
-    from pennyfarthing_scripts.workflow import get_phase_owner
+    from pennyfarthing_scripts.prime.heatmap import run_heatmap
 
-    owner = get_phase_owner(workflow_name, phase)
-    click.echo(owner)
+    exit_code = run_heatmap(
+        agent_name=name,
+        show_all=show_all,
+        csv_output=csv_output,
+        json_output=json_output,
+    )
+    raise SystemExit(exit_code)
 
 
-@workflow.command("handoff")
-@click.argument("next_agent")
-def workflow_handoff(next_agent: str):
-    """Emit a handoff marker for Cyclist.
+# Import and register workflow group
+from pennyfarthing_scripts.workflow.cli import workflow  # noqa: E402
 
-    \b
-    Arguments:
-      NEXT_AGENT  - The agent to hand off to (tea, dev, reviewer, etc.)
-    """
-    # Output the marker format expected by Cyclist
-    click.echo("---")
-    click.echo("AGENT_COMMAND:")
-    click.echo(f'  marker: "<!-- CYCLIST:HANDOFF:/{next_agent} -->"')
-    click.echo(f'  fallback: "Run `/{next_agent}` to continue"')
-    click.echo("---")
+cli.add_command(workflow)
 
 
 @cli.command("help")

package/pennyfarthing_scripts/common/pr_config.py

@@ -0,0 +1,38 @@
+"""PR mode configuration reader.
+
+Reads the pr_mode preference from .pennyfarthing/config.local.yaml.
+
+Values: draft | ready | none (default: draft)
+"""
+
+from __future__ import annotations
+
+from pennyfarthing_scripts.common.config import load_pennyfarthing_config
+
+VALID_PR_MODES = {"draft", "ready", "none"}
+DEFAULT_PR_MODE = "draft"
+
+
+def get_pr_mode() -> str:
+    """Read pr_mode from pennyfarthing config.
+
+    Looks for workflow.pr_mode in .pennyfarthing/config.local.yaml.
+    Falls back to 'draft' if not set or invalid.
+
+    Returns:
+        One of: 'draft', 'ready', 'none'
+    """
+    config = load_pennyfarthing_config()
+    workflow = config.get("workflow", {})
+    if not isinstance(workflow, dict):
+        return DEFAULT_PR_MODE
+
+    mode = workflow.get("pr_mode", DEFAULT_PR_MODE)
+    if mode not in VALID_PR_MODES:
+        return DEFAULT_PR_MODE
+
+    return mode
+
+
+if __name__ == "__main__":
+    print(get_pr_mode())

package/pennyfarthing_scripts/consultation/__init__.py

@@ -0,0 +1 @@
+"""Consultation package — Dialogue file management for tandem agent consultation."""

package/pennyfarthing_scripts/consultation/cli.py

@@ -0,0 +1,149 @@
+"""Click CLI for consultation dialogue management.
+
+Provides `pf consultation` group with subcommands matching
+the bash wrapper dialogue-manager.sh interface.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+
+import click
+
+
+@click.group()
+def consultation():
+    """Tandem consultation dialogue management.
+
+    \b
+    Subcommands:
+      init       - Create dialogue file
+      append     - Append exchange
+      outcome    - Update outcome
+      summarize  - Refresh summary
+      archive    - Archive dialogue file
+    """
+    pass
+
+
+@consultation.command()
+@click.argument("story_id")
+@click.argument("workflow")
+@click.argument("leader")
+@click.argument("partner")
+def init(story_id: str, workflow: str, leader: str, partner: str) -> None:
+    """Create a new dialogue file."""
+    from pennyfarthing_scripts.consultation.dialogue_manager import (
+        DialogueHeader,
+        create_dialogue_content,
+    )
+
+    header = DialogueHeader(
+        story_id=story_id,
+        workflow=workflow,
+        leader=leader,
+        partner=partner,
+        started_at=datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+    )
+
+    content = create_dialogue_content(header)
+    session_dir = Path(".session")
+    session_dir.mkdir(parents=True, exist_ok=True)
+    dialogue_path = session_dir / f"{story_id}-dialogue.md"
+    dialogue_path.write_text(content, encoding="utf-8")
+
+    click.echo(f"Created {dialogue_path}")
+
+
+@consultation.command()
+@click.argument("story_id")
+@click.argument("question")
+@click.argument("recommendation")
+@click.argument("confidence")
+def append(story_id: str, question: str, recommendation: str, confidence: str) -> None:
+    """Append an exchange to a dialogue file."""
+    from pennyfarthing_scripts.consultation.dialogue_manager import (
+        DialogueExchange,
+        append_exchange_to_file,
+        parse_dialogue_exchanges,
+    )
+
+    dialogue_path = Path(".session") / f"{story_id}-dialogue.md"
+    if not dialogue_path.exists():
+        click.echo(f"Dialogue file not found: {dialogue_path}", err=True)
+        raise SystemExit(1)
+
+    content = dialogue_path.read_text(encoding="utf-8")
+    existing = parse_dialogue_exchanges(content)
+    next_num = len(existing) + 1
+
+    exchange = DialogueExchange(
+        number=next_num,
+        timestamp=datetime.now(timezone.utc).strftime("%H:%M"),
+        leader="",
+        partner="",
+        question=question,
+        recommendation=recommendation,
+        confidence=confidence,
+    )
+
+    result = append_exchange_to_file(dialogue_path, exchange)
+    if result.success:
+        click.echo(f"Appended exchange {next_num}")
+    else:
+        click.echo(f"Error: {result.error}", err=True)
+        raise SystemExit(1)
+
+
+@consultation.command()
+@click.argument("story_id")
+@click.argument("exchange_num", type=int)
+@click.argument("outcome_value")
+@click.option("--note", default=None, help="Outcome note")
+def outcome(story_id: str, exchange_num: int, outcome_value: str, note: str | None) -> None:
+    """Update outcome of an exchange."""
+    from pennyfarthing_scripts.consultation.dialogue_manager import (
+        update_outcome_in_file,
+    )
+
+    dialogue_path = Path(".session") / f"{story_id}-dialogue.md"
+    result = update_outcome_in_file(dialogue_path, exchange_num, outcome_value, note)  # type: ignore[arg-type]
+    if result.success:
+        click.echo(f"Updated exchange {exchange_num} outcome to {outcome_value}")
+    else:
+        click.echo(f"Error: {result.error}", err=True)
+        raise SystemExit(1)
+
+
+@consultation.command()
+@click.argument("story_id")
+def summarize(story_id: str) -> None:
+    """Refresh dialogue summary."""
+    from pennyfarthing_scripts.consultation.dialogue_manager import refresh_summary
+
+    dialogue_path = Path(".session") / f"{story_id}-dialogue.md"
+    result = refresh_summary(dialogue_path)
+    if result.success:
+        total = result.data.get("totalExchanges", 0) if result.data else 0
+        click.echo(f"Summary refreshed ({total} exchanges)")
+    else:
+        click.echo(f"Error: {result.error}", err=True)
+        raise SystemExit(1)
+
+
+@consultation.command()
+@click.argument("story_id")
+@click.option("--jira-key", default=None, help="Jira key for archive filename")
+def archive(story_id: str, jira_key: str | None) -> None:
+    """Archive dialogue file."""
+    from pennyfarthing_scripts.consultation.dialogue_manager import archive_dialogue
+
+    dialogue_path = Path(".session") / f"{story_id}-dialogue.md"
+    archive_dir = Path(".session") / "archive"
+    result = archive_dialogue(dialogue_path, archive_dir, jira_key=jira_key, story_id=story_id)
+    if result.success:
+        click.echo(f"Archived to {result.data.get('archivePath', archive_dir)}" if result.data else "Archived")
+    else:
+        click.echo(f"Error: {result.error}", err=True)
+        raise SystemExit(1)