@pennyfarthing/core 7.9.0 → 7.9.2

package/pennyfarthing_scripts/prime/models.py

@@ -1,169 +0,0 @@
-"""
-Data models for Prime v2.
-
-Provides structured types for workflow state, persona, and session data.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any
-
-
-class WorkflowState(Enum):
-    """Workflow states detected by prime."""
-
-    FINISH_STATE = "FINISH_STATE"
-    IN_PROGRESS_STATE = "IN_PROGRESS_STATE"
-    NEW_WORK_STATE = "NEW_WORK_STATE"
-    EMPTY_BACKLOG_STATE = "EMPTY_BACKLOG_STATE"
-
-
-@dataclass
-class WorkflowStatus:
-    """Result of workflow state detection.
-
-    Attributes:
-        state: Current workflow state
-        story_id: Active story ID if in progress/finish
-        phase: Current workflow phase (setup, red, green, review, finish)
-        phase_owner: Agent that owns the current phase
-        workflow: Workflow name (tdd, trivial, bdd, etc.)
-        backlog_count: Number of stories in backlog (for NEW_WORK_STATE)
-        session_file: Path to active session file if exists
-    """
-
-    state: WorkflowState
-    story_id: str | None = None
-    phase: str | None = None
-    phase_owner: str | None = None
-    workflow: str | None = None
-    backlog_count: int = 0
-    session_file: str | None = None
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary for JSON serialization."""
-        return {
-            "state": self.state.value,
-            "story_id": self.story_id,
-            "phase": self.phase,
-            "phase_owner": self.phase_owner,
-            "workflow": self.workflow,
-            "backlog_count": self.backlog_count,
-            "session_file": self.session_file,
-        }
-
-
-@dataclass
-class Persona:
-    """Agent persona from theme configuration.
-
-    Attributes:
-        character: Character name (e.g., "Camina Drummer")
-        style: Communication style description
-        role: Role description
-        quote: Optional signature quote
-        trait: Optional personality trait
-        quirk: Optional personality quirk
-        motto: Optional character motto
-        helper_name: Optional helper/assistant name
-        helper_style: Optional helper communication style
-    """
-
-    character: str
-    style: str
-    role: str
-    quote: str | None = None
-    trait: str | None = None
-    quirk: str | None = None
-    motto: str | None = None
-    helper_name: str | None = None
-    helper_style: str | None = None
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary for JSON serialization."""
-        result = {
-            "character": self.character,
-            "style": self.style,
-            "role": self.role,
-        }
-        if self.quote:
-            result["quote"] = self.quote
-        if self.trait:
-            result["trait"] = self.trait
-        if self.quirk:
-            result["quirk"] = self.quirk
-        if self.motto:
-            result["motto"] = self.motto
-        if self.helper_name:
-            result["helper_name"] = self.helper_name
-        if self.helper_style:
-            result["helper_style"] = self.helper_style
-        return result
-
-
-@dataclass
-class CrewMember:
-    """A crew member in the theme manifest.
-
-    Attributes:
-        role: Agent role (sm, tea, dev, etc.)
-        character: Character name
-    """
-
-    role: str
-    character: str
-
-
-@dataclass
-class SessionInfo:
-    """Session registration information.
-
-    Attributes:
-        session_id: Unique session identifier
-        agent_name: Name of the registered agent
-        file_path: Path to the session file
-    """
-
-    session_id: str
-    agent_name: str
-    file_path: str
-
-
-@dataclass
-class PrimeResult:
-    """Complete result from prime() for JSON output.
-
-    Attributes:
-        agent_name: Requested agent name
-        workflow_status: Current workflow state
-        persona: Loaded persona (if enabled)
-        theme: Active theme name
-        redirect_to: Agent to redirect to (if wrong agent activated)
-        redirect_reason: Reason for redirect
-        session_id: Session ID (if registered)
-        crew: List of crew members for handoff reference
-    """
-
-    agent_name: str
-    workflow_status: WorkflowStatus | None = None
-    persona: Persona | None = None
-    theme: str | None = None
-    redirect_to: str | None = None
-    redirect_reason: str | None = None
-    session_id: str | None = None
-    crew: list[CrewMember] = field(default_factory=list)
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary for JSON serialization."""
-        return {
-            "agent_name": self.agent_name,
-            "workflow_status": self.workflow_status.to_dict() if self.workflow_status else None,
-            "persona": self.persona.to_dict() if self.persona else None,
-            "theme": self.theme,
-            "redirect_to": self.redirect_to,
-            "redirect_reason": self.redirect_reason,
-            "session_id": self.session_id,
-            "crew": [{"role": c.role, "character": c.character} for c in self.crew],
-        }

package/pennyfarthing_scripts/prime/persona.py

@@ -1,288 +0,0 @@
-"""
-Persona loading for Prime v2.
-
-Loads agent personas from theme YAML files for character-driven agents.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-import yaml
-
-from pennyfarthing_scripts.common.config import get_project_root, load_yaml_config
-from pennyfarthing_scripts.prime.models import CrewMember, Persona
-
-
-# Standard agent roles for crew manifest
-AGENT_ROLES = [
-    "sm", "tea", "dev", "reviewer", "architect",
-    "pm", "tech-writer", "ux-designer", "devops", "orchestrator",
-]
-
-
-def get_current_theme(project_root: Path | None = None) -> str | None:
-    """Get the currently configured theme.
-
-    Checks config files in priority order:
-    1. .pennyfarthing/config.local.yaml
-    2. .claude/persona-config.yaml
-
-    Args:
-        project_root: Project root path (auto-detected if not provided)
-
-    Returns:
-        Theme name, or None if not configured
-    """
-    root = project_root or get_project_root()
-
-    # Check config files in priority order
-    config_paths = [
-        root / ".pennyfarthing" / "config.local.yaml",
-        root / ".claude" / "persona-config.yaml",
-    ]
-
-    for config_path in config_paths:
-        config = load_yaml_config(config_path)
-        if config and "theme" in config:
-            return config["theme"]
-
-    return None
-
-
-def get_theme_path(theme: str, project_root: Path) -> Path | None:
-    """Get the path to a theme YAML file.
-
-    Args:
-        theme: Theme name
-        project_root: Project root path
-
-    Returns:
-        Path to theme file, or None if not found
-    """
-    # Single source of truth: .pennyfarthing/personas/themes/
-    theme_path = project_root / ".pennyfarthing" / "personas" / "themes" / f"{theme}.yaml"
-
-    if theme_path.exists():
-        return theme_path
-
-    # Fallback to pennyfarthing-dist (for development)
-    theme_path = project_root / "pennyfarthing-dist" / "personas" / "themes" / f"{theme}.yaml"
-
-    if theme_path.exists():
-        return theme_path
-
-    return None
-
-
-def load_theme(theme: str, project_root: Path | None = None) -> dict[str, Any] | None:
-    """Load a theme YAML file.
-
-    Args:
-        theme: Theme name
-        project_root: Project root path (auto-detected if not provided)
-
-    Returns:
-        Theme data dict, or None if not found
-    """
-    root = project_root or get_project_root()
-    theme_path = get_theme_path(theme, root)
-
-    if not theme_path:
-        return None
-
-    try:
-        return yaml.safe_load(theme_path.read_text())
-    except Exception:
-        return None
-
-
-def load_persona(agent_name: str, project_root: Path | None = None) -> tuple[Persona | None, str | None]:
-    """Load persona for an agent from the current theme.
-
-    Args:
-        agent_name: Agent name (sm, tea, dev, etc.)
-        project_root: Project root path (auto-detected if not provided)
-
-    Returns:
-        Tuple of (Persona, theme_name) or (None, None) if not found
-    """
-    root = project_root or get_project_root()
-    theme = get_current_theme(root)
-
-    if not theme:
-        return None, None
-
-    theme_data = load_theme(theme, root)
-    if not theme_data or "agents" not in theme_data:
-        return None, None
-
-    agent_data = theme_data["agents"].get(agent_name)
-    if not agent_data:
-        return None, None
-
-    # Extract helper info if present
-    helper = agent_data.get("helper", {})
-
-    persona = Persona(
-        character=agent_data.get("character", "Unknown"),
-        style=agent_data.get("style", ""),
-        role=agent_data.get("role", ""),
-        quote=agent_data.get("quote"),
-        trait=agent_data.get("trait"),
-        quirk=agent_data.get("quirk"),
-        motto=agent_data.get("motto"),
-        helper_name=helper.get("name") if helper else None,
-        helper_style=helper.get("style") if helper else None,
-    )
-
-    return persona, theme
-
-
-def get_crew_manifest(project_root: Path | None = None) -> list[CrewMember]:
-    """Get all agent characters from the current theme.
-
-    Used for handoff reference so agents know other characters.
-
-    Args:
-        project_root: Project root path (auto-detected if not provided)
-
-    Returns:
-        List of CrewMember objects for all 10 standard roles
-    """
-    root = project_root or get_project_root()
-    theme = get_current_theme(root)
-
-    if not theme:
-        return []
-
-    theme_data = load_theme(theme, root)
-    if not theme_data or "agents" not in theme_data:
-        return []
-
-    crew = []
-    for role in AGENT_ROLES:
-        agent_data = theme_data["agents"].get(role)
-        if agent_data and "character" in agent_data:
-            crew.append(CrewMember(role=role, character=agent_data["character"]))
-
-    return crew
-
-
-def get_user_title(project_root: Path | None = None) -> str | None:
-    """Get the user title from the current theme.
-
-    Args:
-        project_root: Project root path (auto-detected if not provided)
-
-    Returns:
-        User title (e.g., "Bossmang"), or None if not set
-    """
-    root = project_root or get_project_root()
-    theme = get_current_theme(root)
-
-    if not theme:
-        return None
-
-    theme_data = load_theme(theme, root)
-    if not theme_data or "theme" not in theme_data:
-        return None
-
-    return theme_data["theme"].get("user_title")
-
-
-def format_persona_output(
-    persona: Persona,
-    theme: str,
-    agent_name: str,
-    crew: list[CrewMember] | None = None,
-    user_title: str | None = None,
-) -> str:
-    """Format persona as XML output for Claude.
-
-    Matches the format from agent-session.sh:
-    <persona agent="dev" theme="the-expanse">
-    Character: Naomi Nagata
-    Style: ...
-    </persona>
-
-    Args:
-        persona: Persona to format
-        theme: Theme name
-        agent_name: Agent name
-        crew: Optional crew manifest for handoff reference
-        user_title: Optional user title
-
-    Returns:
-        Formatted persona XML string
-    """
-    lines = [
-        f'<persona agent="{agent_name}" theme="{theme}">',
-        f"Character: {persona.character}",
-        f"Style: {persona.style}",
-        f"Role: {persona.role}",
-    ]
-
-    if persona.trait:
-        lines.append(f"Trait: {persona.trait}")
-    if persona.quirk:
-        lines.append(f"Quirk: {persona.quirk}")
-    if persona.motto:
-        lines.append(f"Motto: {persona.motto}")
-    if persona.quote:
-        lines.append(f"Quote: {persona.quote}")
-    if persona.helper_name:
-        helper_line = f"Helper: {persona.helper_name}"
-        if persona.helper_style:
-            helper_line += f" - {persona.helper_style}"
-        lines.append(helper_line)
-
-    lines.append("</persona>")
-
-    # Add user title if set
-    if user_title:
-        lines.append("")
-        lines.append(f"<user-title>Address the user as: {user_title}</user-title>")
-
-    # Add crew manifest for handoff reference
-    if crew:
-        lines.append("")
-        lines.append(f'<crew theme="{theme}">')
-        lines.append("When handing off to other agents, address them by character name:")
-        for member in crew:
-            lines.append(f"  {member.role:12} {member.character}")
-        lines.append("</crew>")
-
-    return "\n".join(lines)
-
-
-def is_character_voice_enabled(project_root: Path | None = None) -> bool:
-    """Check if character voice is enabled in preferences.
-
-    Checks preferences files in order:
-    1. .claude/pennyfarthing/preferences.local.yaml
-    2. .claude/pennyfarthing/preferences.yaml
-
-    Defaults to True if no preference is set.
-
-    Args:
-        project_root: Project root path (auto-detected if not provided)
-
-    Returns:
-        True if character voice is enabled
-    """
-    root = project_root or get_project_root()
-
-    prefs_paths = [
-        root / ".claude" / "pennyfarthing" / "preferences.local.yaml",
-        root / ".claude" / "pennyfarthing" / "preferences.yaml",
-    ]
-
-    for prefs_path in prefs_paths:
-        prefs = load_yaml_config(prefs_path)
-        if prefs and "character_voice" in prefs:
-            return prefs["character_voice"] is not False
-
-    # Default to enabled
-    return True

package/pennyfarthing_scripts/prime/session.py

@@ -1,183 +0,0 @@
-"""
-Session registration for Prime v2.
-
-Manages agent session files in .session/agents/ for multi-session support.
-"""
-
-from __future__ import annotations
-
-import os
-import time
-import uuid
-from pathlib import Path
-
-from pennyfarthing_scripts.common.config import get_project_root
-from pennyfarthing_scripts.prime.models import SessionInfo
-
-
-def get_agents_dir(project_root: Path) -> Path:
-    """Get the agents session directory.
-
-    Args:
-        project_root: Project root path
-
-    Returns:
-        Path to .session/agents/
-    """
-    return project_root / ".session" / "agents"
-
-
-def register_session(
-    agent_name: str,
-    session_id: str | None = None,
-    project_root: Path | None = None,
-) -> SessionInfo:
-    """Register an agent session.
-
-    Creates a session file in .session/agents/{session_id} containing
-    the agent name. If no session_id is provided, generates a new UUID.
-
-    Args:
-        agent_name: Name of the agent to register
-        session_id: Optional session ID (generated if not provided)
-        project_root: Project root path (auto-detected if not provided)
-
-    Returns:
-        SessionInfo with session details
-    """
-    root = project_root or get_project_root()
-    agents_dir = get_agents_dir(root)
-
-    # Create agents directory if needed
-    agents_dir.mkdir(parents=True, exist_ok=True)
-
-    # Generate session ID if not provided
-    if not session_id:
-        # Check SESSION_ID environment variable first
-        session_id = os.environ.get("SESSION_ID")
-        if not session_id:
-            session_id = str(uuid.uuid4())
-
-    # Write agent file
-    session_file = agents_dir / session_id
-    session_file.write_text(agent_name)
-
-    return SessionInfo(
-        session_id=session_id,
-        agent_name=agent_name,
-        file_path=str(session_file),
-    )
-
-
-def cleanup_old_sessions(project_root: Path | None = None, max_age_days: int = 7) -> int:
-    """Remove stale session files.
-
-    Deletes session files older than max_age_days.
-
-    Args:
-        project_root: Project root path (auto-detected if not provided)
-        max_age_days: Maximum age in days before cleanup
-
-    Returns:
-        Number of files removed
-    """
-    root = project_root or get_project_root()
-    agents_dir = get_agents_dir(root)
-
-    if not agents_dir.is_dir():
-        return 0
-
-    cutoff = time.time() - (max_age_days * 86400)
-    removed = 0
-
-    for session_file in agents_dir.iterdir():
-        if session_file.is_file():
-            try:
-                if session_file.stat().st_mtime < cutoff:
-                    session_file.unlink()
-                    removed += 1
-            except OSError:
-                pass
-
-    return removed
-
-
-def get_session_agent(
-    session_id: str,
-    project_root: Path | None = None,
-) -> str | None:
-    """Get the agent name for a session.
-
-    Args:
-        session_id: Session ID to look up
-        project_root: Project root path (auto-detected if not provided)
-
-    Returns:
-        Agent name, or None if session not found
-    """
-    root = project_root or get_project_root()
-    session_file = get_agents_dir(root) / session_id
-
-    if not session_file.is_file():
-        return None
-
-    return session_file.read_text().strip()
-
-
-def unregister_session(
-    session_id: str,
-    project_root: Path | None = None,
-) -> bool:
-    """Unregister an agent session.
-
-    Removes the session file.
-
-    Args:
-        session_id: Session ID to unregister
-        project_root: Project root path (auto-detected if not provided)
-
-    Returns:
-        True if session was removed, False if not found
-    """
-    root = project_root or get_project_root()
-    session_file = get_agents_dir(root) / session_id
-
-    if not session_file.is_file():
-        return False
-
-    try:
-        session_file.unlink()
-        return True
-    except OSError:
-        return False
-
-
-def list_sessions(project_root: Path | None = None) -> list[SessionInfo]:
-    """List all active sessions.
-
-    Args:
-        project_root: Project root path (auto-detected if not provided)
-
-    Returns:
-        List of SessionInfo for all active sessions
-    """
-    root = project_root or get_project_root()
-    agents_dir = get_agents_dir(root)
-
-    if not agents_dir.is_dir():
-        return []
-
-    sessions = []
-    for session_file in agents_dir.iterdir():
-        if session_file.is_file():
-            try:
-                agent_name = session_file.read_text().strip()
-                sessions.append(SessionInfo(
-                    session_id=session_file.name,
-                    agent_name=agent_name,
-                    file_path=str(session_file),
-                ))
-            except OSError:
-                pass
-
-    return sessions