npm - @pennyfarthing/core - Versions diffs - 11.3.3 → 11.3.4 - Mend

@pennyfarthing/core 11.3.3 → 11.3.4

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 (1121) hide show

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,214 +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 (  # noqa: E402
-    load_agent_definition,
-    load_behavior_guide,
-    load_repos_topology,
-    load_session_context,
-    load_sidecars,
-    load_sprint_context,
-)
-from pennyfarthing_scripts.prime.persona import (  # noqa: E402
-    format_persona_compressed,
-    get_crew_manifest,
-    get_user_title,
-    is_character_voice_enabled,
-    load_persona,
-)
-from pennyfarthing_scripts.prime.workflow import detect_workflow_state  # noqa: E402
-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}") from None
-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)
-        topology_content = load_repos_topology(project_root)
-        if topology_content:
-            add_component("repos_topology", topology_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)
-        topology_content = load_repos_topology(project_root)
-        if topology_content:
-            add_component("repos_topology", topology_content)
-        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)
-    topology_content = load_repos_topology(project_root)
-    if topology_content:
-        add_component("repos_topology", topology_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

package/pennyfarthing_scripts/prime/workflow.py DELETED Viewed

@@ -1,317 +0,0 @@
-"""
-Workflow state detection for Prime v2.
-Detects current workflow state by analyzing:
-- Active session files in .session/
-- Session headers for phase and workflow
-- Sprint backlog for available stories
-"""
-from __future__ import annotations
-import re
-from pathlib import Path
-from typing import Any
-import yaml
-from pennyfarthing_scripts.common.config import get_project_root
-from pennyfarthing_scripts.prime.models import WorkflowState, WorkflowStatus
-def find_active_session(project_root: Path) -> Path | None:
-    """Find the active session file.
-    Looks in .session/ for *-session.md files, excluding context-*.md.
-    Returns the most recently modified session file.
-    Args:
-        project_root: Project root path
-    Returns:
-        Path to active session file, or None if not found
-    """
-    session_dir = project_root / ".session"
-    if not session_dir.is_dir():
-        return None
-    # Find *-session.md files (not context-*)
-    session_files = [
-        f for f in session_dir.glob("*-session.md")
-        if not f.name.startswith("context-")
-    ]
-    if not session_files:
-        return None
-    # Return the most recently modified one
-    return max(session_files, key=lambda f: f.stat().st_mtime)
-def parse_session_header(session_path: Path) -> dict[str, Any]:
-    """Parse session file header to extract metadata.
-    Looks for key: value patterns throughout the session file header sections.
-    Extracts workflow, phase, story_id, status from:
-    - ## Story Context section
-    - ## Workflow Phase section
-    Args:
-        session_path: Path to session file
-    Returns:
-        Dict with extracted metadata (workflow, phase, story_id, status)
-    """
-    content = session_path.read_text()
-    lines = content.split("\n")
-    result: dict[str, Any] = {}
-    # Extract story ID from filename (e.g., MSSCI-12419-session.md -> MSSCI-12419)
-    filename = session_path.stem
-    if filename.endswith("-session"):
-        result["story_id"] = filename[:-8]  # Remove "-session"
-    # Track which sections we're in (we care about Story Context and Workflow Phase)
-    in_relevant_section = True  # Start True to capture content before any ##
-    for line in lines:
-        # Track section headers
-        if line.startswith("## "):
-            # We care about Story Context and Workflow Phase sections
-            section_name = line[3:].strip().lower()
-            in_relevant_section = (
-                "story context" in section_name or
-                "workflow phase" in section_name or
-                "branch" in section_name
-            )
-            # Stop at assessment sections (too far down)
-            if "assessment" in section_name:
-                break
-            continue
-        # Only parse lines in relevant sections
-        if not in_relevant_section:
-            continue
-        # Look for key-value patterns
-        # Format is "**Key:** Value" (colon inside the bold)
-        # e.g., "- **Workflow:** tdd" or "- **Current Phase:** green"
-        match = re.search(r"\*\*([^*:]+):\*\*\s*(.+)", line)
-        if match:
-            key = match.group(1).lower().strip()
-            value = match.group(2).strip()
-            if key == "workflow":
-                result["workflow"] = value.lower()
-            elif key in ("current phase", "phase"):
-                # Extract phase name, handling "(APPROVED)" suffix
-                # Matches both "**Current Phase:**" and "**Phase:**"
-                phase_match = re.match(r"(\w+)(?:\s*\(([^)]+)\))?", value)
-                if phase_match:
-                    result["phase"] = phase_match.group(1).lower()
-                    if phase_match.group(2):
-                        result["phase_status"] = phase_match.group(2).lower()
-            elif key == "id" and "story_id" not in result:
-                result["story_id"] = value
-            elif key == "status":
-                result["status"] = value.lower()
-    return result
-def get_phase_owner(workflow: str, phase: str, project_root: Path) -> str | None:
-    """Look up the agent that owns a workflow phase.
-    Reads the workflow YAML and finds the agent for the given phase.
-    Args:
-        workflow: Workflow name (tdd, trivial, bdd, etc.)
-        phase: Phase name (setup, red, green, review, finish)
-        project_root: Project root path
-    Returns:
-        Agent name (sm, tea, dev, reviewer), or None if not found
-    """
-    workflow_path = project_root / "pennyfarthing-dist" / "workflows" / f"{workflow}.yaml"
-    if not workflow_path.exists():
-        # Fallback to symlinked location
-        workflow_path = project_root / ".pennyfarthing" / "workflows" / f"{workflow}.yaml"
-        if not workflow_path.exists():
-            return None
-    try:
-        data = yaml.safe_load(workflow_path.read_text())
-        phases = data.get("workflow", {}).get("phases", [])
-        for p in phases:
-            if p.get("name") == phase:
-                return p.get("agent")
-        return None
-    except Exception:
-        return None
-def get_backlog_count(project_root: Path) -> int:
-    """Count stories in backlog, ready, or planning status.
-    Args:
-        project_root: Project root path
-    Returns:
-        Number of stories available for work
-    """
-    # Import here to avoid circular imports
-    from pennyfarthing_scripts.sprint.loader import load_sprint
-    sprint = load_sprint(project_root)
-    if not sprint or "epics" not in sprint:
-        return 0
-    count = 0
-    for epic in sprint["epics"]:
-        if not isinstance(epic, dict):
-            continue  # Skip string refs (defensive)
-        for story in epic.get("stories", []):
-            status = story.get("status", "").lower()
-            if status in ("backlog", "ready", "planning"):
-                count += 1
-    return count
-def detect_workflow_state(project_root: Path | None = None) -> WorkflowStatus:
-    """Detect the current workflow state.
-    Returns one of:
-    - FINISH_STATE: Session exists with phase=approved or review-approved
-    - IN_PROGRESS_STATE: Session exists with active phase
-    - NEW_WORK_STATE: No session and backlog has stories
-    - EMPTY_BACKLOG_STATE: No session and backlog is empty
-    Args:
-        project_root: Project root path (auto-detected if not provided)
-    Returns:
-        WorkflowStatus with detected state and metadata
-    """
-    root = project_root or get_project_root()
-    session_file = find_active_session(root)
-    if session_file:
-        header = parse_session_header(session_file)
-        story_id = header.get("story_id")
-        workflow = header.get("workflow", "tdd")
-        phase = header.get("phase")
-        phase_status = header.get("phase_status", "")
-        # Check for finish state
-        if phase in ("approved", "review-approved", "finish"):
-            return WorkflowStatus(
-                state=WorkflowState.FINISH_STATE,
-                story_id=story_id,
-                phase=phase,
-                phase_owner="sm",
-                workflow=workflow,
-                session_file=str(session_file),
-            )
-        # Check if phase is approved (e.g., "REVIEW (APPROVED)")
-        if phase_status == "approved":
-            return WorkflowStatus(
-                state=WorkflowState.FINISH_STATE,
-                story_id=story_id,
-                phase=phase,
-                phase_owner="sm",
-                workflow=workflow,
-                session_file=str(session_file),
-            )
-        # In progress state - look up phase owner
-        owner = get_phase_owner(workflow, phase, root) if phase else None
-        return WorkflowStatus(
-            state=WorkflowState.IN_PROGRESS_STATE,
-            story_id=story_id,
-            phase=phase,
-            phase_owner=owner,
-            workflow=workflow,
-            session_file=str(session_file),
-        )
-    # No active session - check backlog
-    backlog_count = get_backlog_count(root)
-    if backlog_count > 0:
-        return WorkflowStatus(
-            state=WorkflowState.NEW_WORK_STATE,
-            backlog_count=backlog_count,
-        )
-    return WorkflowStatus(
-        state=WorkflowState.EMPTY_BACKLOG_STATE,
-    )
-def check_redirect(workflow_status: WorkflowStatus, agent_name: str) -> tuple[str, str] | None:
-    """Check if the activated agent should redirect to another agent.
-    Returns redirect info if:
-    - IN_PROGRESS_STATE and agent_name != phase_owner
-    Args:
-        workflow_status: Current workflow status
-        agent_name: Name of the activated agent
-    Returns:
-        Tuple of (target_agent, reason) if redirect needed, None otherwise
-    """
-    if workflow_status.state == WorkflowState.IN_PROGRESS_STATE:
-        if workflow_status.phase_owner and workflow_status.phase_owner != agent_name:
-            return (
-                workflow_status.phase_owner,
-                f"Phase '{workflow_status.phase}' is owned by '{workflow_status.phase_owner}'",
-            )
-    return None
-def get_phase_tandem_config(
-    workflow_name: str, phase_name: str, project_root: Path | None = None
-) -> dict[str, Any] | None:
-    """Extract tandem configuration for a specific workflow phase.
-    Reads the workflow YAML and returns the tandem block for the given phase,
-    or None if the phase has no tandem configuration.
-    Args:
-        workflow_name: Workflow name (tdd-tandem, bdd-tandem, etc.)
-        phase_name: Phase name (red, green, review, etc.)
-        project_root: Project root path (auto-detected if not provided)
-    Returns:
-        Dict with tandem config (partner, mode, model, token_budget, triggers, scope)
-        or None if no tandem config on this phase.
-    """
-    root = project_root or get_project_root()
-    workflow_path = root / "pennyfarthing-dist" / "workflows" / f"{workflow_name}.yaml"
-    if not workflow_path.exists():
-        return None
-    try:
-        data = yaml.safe_load(workflow_path.read_text())
-        phases = data.get("workflow", {}).get("phases", [])
-        for phase in phases:
-            if isinstance(phase, dict) and phase.get("name") == phase_name:
-                tandem = phase.get("tandem")
-                if isinstance(tandem, dict):
-                    return dict(tandem)
-                return None
-        return None
-    except Exception:
-        return None