npm - @pennyfarthing/core - Versions diffs - 9.2.0 → 9.3.0 - Mend

@pennyfarthing/core 9.2.0 → 9.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1039) hide show

package/pennyfarthing_scripts/prime/persona.py DELETED Viewed

@@ -1,308 +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.common.themes import (
-    get_current_theme as _get_current_theme,
-    resolve_theme_path,
-)
-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.
-    Delegates to common.themes canonical implementation.
-    Args:
-        project_root: Project root path (auto-detected if not provided)
-    Returns:
-        Theme name, or None if not configured
-    """
-    return _get_current_theme(project_root)
-def get_theme_path(theme: str, project_root: Path) -> Path | None:
-    """Get the path to a theme YAML file.
-    Delegates to common.themes canonical discovery algorithm.
-    Args:
-        theme: Theme name
-        project_root: Project root path
-    Returns:
-        Path to theme file, or None if not found
-    """
-    return resolve_theme_path(theme, project_root)
-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
-def format_persona_compressed(
-    persona: Persona,
-    theme: str,
-    agent_name: str,
-) -> str:
-    """Format persona as compressed XML for reduced token usage.
-    Compressed format (~100 tokens vs ~300 for full):
-    <persona agent="dev" character="Rosie the Riveter">
-      <voice>Can-do wartime spirit, practical, determined</voice>
-      <catchphrase>"We Can Do It!"</catchphrase>
-      <style>Direct, encouraging, efficiency-focused</style>
-    </persona>
-    Args:
-        persona: Persona to format
-        theme: Theme name
-        agent_name: Agent name
-    Returns:
-        Compressed persona XML string (~100 tokens)
-    """
-    lines = [f'<persona agent="{agent_name}" character="{persona.character}">']
-    # Voice from style (primary behavioral descriptor)
-    if persona.style:
-        lines.append(f"  <voice>{persona.style}</voice>")
-    # Catchphrase from quote
-    if persona.quote:
-        lines.append(f"  <catchphrase>{persona.quote}</catchphrase>")
-    # Style from role (short descriptor)
-    if persona.role:
-        lines.append(f"  <style>{persona.role}</style>")
-    lines.append("</persona>")
-    return "\n".join(lines)

package/pennyfarthing_scripts/prime/session.py DELETED Viewed

@@ -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

package/pennyfarthing_scripts/prime/tiers.py DELETED Viewed

@@ -1,201 +0,0 @@
-"""Tiered context injection for Prime.
-Implements four context tiers based on session state:
-- FULL (~4000 tokens): First turn of new session
-- REFRESH (~600 tokens): Resumed session, same agent
-- HANDOFF (~700 tokens): Resumed session, different agent
-- MINIMAL (~200 tokens): Deep conversation (turn 3+), same agent
-Story: MSSCI-12797 - Python Prime Tier Support
-"""
-from __future__ import annotations
-from enum import Enum
-from pathlib import Path
-from typing import Any
-def estimate_tokens(text: str) -> int:
-    """Estimate token count for a text string.
-    Uses character-based approximation (~4 characters per token) which is
-    reasonably accurate for English text with mixed code/prose content.
-    Args:
-        text: Text to estimate tokens for
-    Returns:
-        Estimated token count (0 for empty string)
-    """
-    if not text:
-        return 0
-    # Approximate: ~4 characters per token for cl100k_base encoding
-    # This is within 10% for typical agent context content
-    return max(1, len(text) // 4)
-from pennyfarthing_scripts.prime.loader import (
-    load_agent_definition,
-    load_behavior_guide,
-    load_session_context,
-    load_sidecars,
-    load_sprint_context,
-)
-from pennyfarthing_scripts.prime.persona import (
-    format_persona_compressed,
-    get_crew_manifest,
-    get_user_title,
-    is_character_voice_enabled,
-    load_persona,
-)
-from pennyfarthing_scripts.prime.workflow import detect_workflow_state
-class ContextTier(Enum):
-    """Context tier levels for session-aware injection."""
-    FULL = "FULL"
-    REFRESH = "REFRESH"
-    HANDOFF = "HANDOFF"
-    MINIMAL = "MINIMAL"
-def tier_from_string(value: str) -> ContextTier:
-    """Convert string to ContextTier enum.
-    Args:
-        value: Tier name (case-insensitive)
-    Returns:
-        ContextTier enum value
-    Raises:
-        ValueError: If value is not a valid tier name
-    """
-    normalized = value.upper()
-    try:
-        return ContextTier(normalized)
-    except ValueError:
-        valid = ", ".join(t.value for t in ContextTier)
-        raise ValueError(f"Invalid tier '{value}'. Must be one of: {valid}")
-def load_tier_components(
-    tier: ContextTier,
-    agent_name: str,
-    project_root: Path,
-) -> dict[str, Any]:
-    """Load components for the specified tier.
-    Component sets by tier:
-    - FULL: All components (workflow, agent, persona, guide, sprint, session, sidecars)
-    - REFRESH: Dynamic state only (workflow, sprint, session_header)
-    - HANDOFF: Agent essentials (workflow, agent, persona_compressed)
-    - MINIMAL: Routing only (workflow)
-    Args:
-        tier: Context tier level
-        agent_name: Name of the agent to load context for
-        project_root: Project root path
-    Returns:
-        Dict with:
-        - Component name -> content mappings
-        - "token_counts": Dict mapping component name to estimated token count
-        - "total_tokens": Sum of all component token counts
-    """
-    components: dict[str, Any] = {}
-    token_counts: dict[str, int] = {}
-    def add_component(name: str, content: str | Any) -> None:
-        """Add a component and track its token count."""
-        components[name] = content
-        # Estimate tokens for string content, 0 for structured data
-        if isinstance(content, str):
-            token_counts[name] = estimate_tokens(content)
-        else:
-            # For structured data (like WorkflowStatus), estimate from string repr
-            token_counts[name] = estimate_tokens(str(content))
-    # All tiers include workflow state
-    workflow_status = detect_workflow_state(project_root)
-    add_component("workflow_state", workflow_status)
-    if tier == ContextTier.MINIMAL:
-        # MINIMAL: Just workflow state
-        components["token_counts"] = token_counts
-        components["total_tokens"] = sum(token_counts.values())
-        return components
-    if tier == ContextTier.REFRESH:
-        # REFRESH: Dynamic state only
-        sprint_content = load_sprint_context(project_root)
-        if sprint_content:
-            add_component("sprint_context", sprint_content)
-        session_result = load_session_context(project_root)
-        if session_result:
-            filename, header, _ = session_result
-            add_component("session_header", header)
-        components["token_counts"] = token_counts
-        components["total_tokens"] = sum(token_counts.values())
-        return components
-    if tier == ContextTier.HANDOFF:
-        # HANDOFF: Agent essentials for new agent
-        agent_content = load_agent_definition(agent_name, project_root)
-        if agent_content:
-            add_component("agent_definition", agent_content)
-        # Load compressed persona
-        if is_character_voice_enabled(project_root):
-            persona, theme = load_persona(agent_name, project_root)
-            if persona and theme:
-                compressed = format_persona_compressed(persona, theme, agent_name)
-                add_component("persona_compressed", compressed)
-        components["token_counts"] = token_counts
-        components["total_tokens"] = sum(token_counts.values())
-        return components
-    # FULL tier: Everything
-    agent_content = load_agent_definition(agent_name, project_root)
-    if agent_content:
-        add_component("agent_definition", agent_content)
-    if is_character_voice_enabled(project_root):
-        persona, theme = load_persona(agent_name, project_root)
-        if persona and theme:
-            from pennyfarthing_scripts.prime.persona import format_persona_output
-            crew = get_crew_manifest(project_root)
-            user_title = get_user_title(project_root)
-            persona_content = format_persona_output(
-                persona, theme, agent_name, crew, user_title
-            )
-            add_component("persona", persona_content)
-    guide_content = load_behavior_guide(project_root)
-    if guide_content:
-        add_component("behavior_guide", guide_content)
-    sprint_content = load_sprint_context(project_root)
-    if sprint_content:
-        add_component("sprint_context", sprint_content)
-    session_result = load_session_context(project_root)
-    if session_result:
-        filename, header, assessment = session_result
-        add_component("session_header", header)
-        if assessment:
-            add_component("session_assessment", assessment)
-    sidecars = load_sidecars(agent_name, project_root)
-    if sidecars:
-        add_component("sidecars", sidecars)
-    components["token_counts"] = token_counts
-    components["total_tokens"] = sum(token_counts.values())
-    return components