shotgun-sh 0.1.0.dev22__py3-none-any.whl → 0.1.0.dev23__py3-none-any.whl

shotgun/artifacts/templates/loader.py

@@ -1,252 +0,0 @@
-"""Template loader for artifact templates."""
-
-from pathlib import Path
-
-import yaml
-
-from shotgun.artifacts.models import AgentMode
-from shotgun.logging_config import setup_logger
-from shotgun.utils.file_system_utils import get_shotgun_home
-
-from .models import ArtifactTemplate, TemplateSummary
-
-logger = setup_logger(__name__)
-
-TEMPLATES_DIR = Path(__file__).parent
-
-
-class ArtifactTemplateLoader:
-    """Loads and manages artifact templates from the filesystem."""
-
-    def __init__(
-        self, templates_dir: Path | None = None, include_user_templates: bool = True
-    ):
-        """Initialize the template loader.
-
-        Args:
-            templates_dir: Directory containing template files. Defaults to package templates.
-            include_user_templates: Whether to include user templates from ~/.shotgun-sh/templates/
-        """
-        self.templates_dir = templates_dir or TEMPLATES_DIR
-        self.include_user_templates = include_user_templates
-        self.user_templates_dir = (
-            get_shotgun_home() / "templates" if include_user_templates else None
-        )
-
-    def _discover_templates(self) -> dict[str, tuple[Path, AgentMode]]:
-        """Discover all template files from both built-in and user directories."""
-        # Start with built-in templates
-        templates = self._discover_templates_from_dir(self.templates_dir, "built-in")
-
-        # Add user templates (they can override built-in ones)
-        if (
-            self.include_user_templates
-            and self.user_templates_dir
-            and self.user_templates_dir.exists()
-        ):
-            user_templates = self._discover_templates_from_dir(
-                self.user_templates_dir, "user"
-            )
-            templates.update(
-                user_templates
-            )  # User templates override built-in ones with same ID
-
-        return templates
-
-    def _discover_templates_from_dir(
-        self, templates_dir: Path, source_type: str
-    ) -> dict[str, tuple[Path, AgentMode]]:
-        """Discover template files from a specific directory.
-
-        Args:
-            templates_dir: Directory to search for templates
-            source_type: Type of templates ("built-in" or "user") for logging
-
-        Returns:
-            Dictionary mapping template IDs to (path, agent_mode) tuples
-        """
-        templates: dict[str, tuple[Path, AgentMode]] = {}
-
-        if not templates_dir.exists():
-            if source_type == "built-in":
-                logger.warning("Templates directory does not exist: %s", templates_dir)
-            else:
-                logger.debug(
-                    "User templates directory does not exist: %s", templates_dir
-                )
-            return templates
-
-        logger.debug("Discovering %s templates from: %s", source_type, templates_dir)
-
-        for mode_dir in templates_dir.iterdir():
-            if not mode_dir.is_dir() or mode_dir.name.startswith("."):
-                continue
-
-            # Skip common non-agent directories without warnings
-            if mode_dir.name in ("__pycache__", "node_modules", ".git", ".DS_Store"):
-                continue
-
-            try:
-                agent_mode = AgentMode(mode_dir.name)
-            except ValueError:
-                logger.warning(
-                    "Unknown agent mode directory in %s templates: %s",
-                    source_type,
-                    mode_dir.name,
-                )
-                continue
-
-            # Find all YAML files in this mode directory
-            for template_file in mode_dir.glob("*.yaml"):
-                template_id = template_file.stem
-                full_template_id = f"{agent_mode.value}/{template_id}"
-                templates[full_template_id] = (template_file, agent_mode)
-                logger.debug("Found %s template: %s", source_type, full_template_id)
-
-        return templates
-
-    def _load_template_file(
-        self, template_path: Path, agent_mode: AgentMode, template_id: str
-    ) -> ArtifactTemplate | None:
-        """Load a single template file."""
-        try:
-            with open(template_path, encoding="utf-8") as f:
-                data = yaml.safe_load(f)
-
-            # Validate required fields
-            required_fields = ["name", "purpose", "prompt"]
-            for field in required_fields:
-                if field not in data:
-                    logger.error(
-                        "Template %s missing required field '%s'", template_path, field
-                    )
-                    return None
-
-            template = ArtifactTemplate.from_yaml_dict(data, agent_mode, template_id)
-
-            # Validate dependencies
-            dependency_errors = template.validate_dependencies()
-            if dependency_errors:
-                logger.error(
-                    "Template %s has dependency errors: %s",
-                    template_path,
-                    dependency_errors,
-                )
-                return None
-
-            return template
-
-        except yaml.YAMLError as e:
-            logger.error("Failed to parse template YAML %s: %s", template_path, e)
-            return None
-        except Exception as e:
-            logger.error("Failed to load template %s: %s", template_path, e)
-            return None
-
-    def get_template(self, template_id: str) -> ArtifactTemplate | None:
-        """Get a template by ID.
-
-        Args:
-            template_id: Full template ID (e.g., 'research/market_research')
-
-        Returns:
-            Template instance or None if not found
-        """
-        discovered = self._discover_templates()
-        if template_id not in discovered:
-            return None
-
-        template_path, agent_mode = discovered[template_id]
-        return self._load_template_file(template_path, agent_mode, template_id)
-
-    def list_templates(
-        self, agent_mode: AgentMode | None = None
-    ) -> list[TemplateSummary]:
-        """List all available templates, optionally filtered by agent mode.
-
-        Args:
-            agent_mode: Optional agent mode filter
-
-        Returns:
-            List of template summaries
-        """
-        discovered = self._discover_templates()
-        summaries = []
-
-        for full_template_id, (
-            template_path,
-            template_agent_mode,
-        ) in discovered.items():
-            if agent_mode and template_agent_mode != agent_mode:
-                continue
-
-            template = self._load_template_file(
-                template_path, template_agent_mode, full_template_id
-            )
-            if template:
-                summaries.append(
-                    TemplateSummary(
-                        template_id=full_template_id,
-                        name=template.name,
-                        purpose=template.purpose,
-                        agent_mode=template.agent_mode,
-                        section_count=len(template.sections),
-                    )
-                )
-
-        # Sort by agent mode, then by template name
-        summaries.sort(key=lambda s: (s.agent_mode.value, s.name))
-        return summaries
-
-    def get_templates_for_mode(self, agent_mode: AgentMode) -> list[ArtifactTemplate]:
-        """Get all templates for a specific agent mode.
-
-        Args:
-            agent_mode: Agent mode to filter by
-
-        Returns:
-            List of templates for the specified mode
-        """
-        discovered = self._discover_templates()
-        templates = []
-
-        for full_template_id, (
-            template_path,
-            template_agent_mode,
-        ) in discovered.items():
-            if template_agent_mode == agent_mode:
-                template = self._load_template_file(
-                    template_path, template_agent_mode, full_template_id
-                )
-                if template:
-                    templates.append(template)
-
-        templates.sort(key=lambda t: t.name)
-        return templates
-
-    def template_exists(self, template_id: str) -> bool:
-        """Check if a template exists.
-
-        Args:
-            template_id: Template ID to check
-
-        Returns:
-            True if template exists, False otherwise
-        """
-        discovered = self._discover_templates()
-        return template_id in discovered
-
-    def get_template_by_short_id(
-        self, short_id: str, agent_mode: AgentMode
-    ) -> ArtifactTemplate | None:
-        """Get template by short ID (without agent mode prefix).
-
-        Args:
-            short_id: Short template ID (e.g., 'market_research')
-            agent_mode: Agent mode to search within
-
-        Returns:
-            Template instance or None if not found
-        """
-        full_id = f"{agent_mode.value}/{short_id}"
-        return self.get_template(full_id)

shotgun/artifacts/templates/models.py

@@ -1,136 +0,0 @@
-"""Models for artifact templates."""
-
-from typing import Any
-
-from pydantic import BaseModel, Field
-
-from shotgun.artifacts.models import AgentMode
-
-
-class TemplateSection(BaseModel):
-    """Represents a section in an artifact template."""
-
-    instructions: str = Field(..., description="Detailed instructions for this section")
-    depends_on: list[str] = Field(
-        default_factory=list, description="List of section keys this section depends on"
-    )
-
-    @property
-    def formatted_instructions(self) -> str:
-        """Return formatted instructions for display."""
-        return self.instructions.strip()
-
-
-class ArtifactTemplate(BaseModel):
-    """Represents an artifact template with structured guidance."""
-
-    name: str = Field(..., description="Display name of the template")
-    purpose: str = Field(..., description="Description of what this template is for")
-    prompt: str = Field(..., description="System prompt for agents using this template")
-    sections: dict[str, TemplateSection] = Field(
-        default_factory=dict, description="Template sections with instructions"
-    )
-    agent_mode: AgentMode = Field(
-        ..., description="Agent mode this template belongs to"
-    )
-    template_id: str = Field(..., description="Unique identifier for the template")
-
-    def get_section(self, section_key: str) -> TemplateSection | None:
-        """Get a template section by key."""
-        return self.sections.get(section_key)
-
-    def get_ordered_sections(self) -> list[tuple[str, TemplateSection]]:
-        """Get sections in dependency order."""
-        # Simple topological sort for section dependencies
-        ordered = []
-        processed = set()
-
-        def process_section(key: str, section: TemplateSection) -> None:
-            if key in processed:
-                return
-
-            # Process dependencies first
-            for dep_key in section.depends_on:
-                if dep_key in self.sections and dep_key not in processed:
-                    process_section(dep_key, self.sections[dep_key])
-
-            ordered.append((key, section))
-            processed.add(key)
-
-        for key, section in self.sections.items():
-            process_section(key, section)
-
-        return ordered
-
-    def get_section_keys(self) -> list[str]:
-        """Get all section keys."""
-        return list(self.sections.keys())
-
-    def validate_dependencies(self) -> list[str]:
-        """Validate that all section dependencies exist. Returns list of errors."""
-        errors = []
-
-        for section_key, section in self.sections.items():
-            for dep_key in section.depends_on:
-                if dep_key not in self.sections:
-                    errors.append(
-                        f"Section '{section_key}' depends on non-existent section '{dep_key}'"
-                    )
-
-        return errors
-
-    def to_yaml_dict(self) -> dict[str, Any]:
-        """Convert to dictionary suitable for YAML serialization."""
-        return {
-            "name": self.name,
-            "purpose": self.purpose,
-            "prompt": self.prompt,
-            "template_id": self.template_id,
-            "sections": {
-                key: {
-                    "instructions": section.instructions,
-                    **(
-                        {"depends_on": section.depends_on} if section.depends_on else {}
-                    ),
-                }
-                for key, section in self.sections.items()
-            },
-        }
-
-    @classmethod
-    def from_yaml_dict(
-        cls, data: dict[str, Any], agent_mode: AgentMode, template_id: str
-    ) -> "ArtifactTemplate":
-        """Create template from YAML dictionary."""
-        sections = {}
-
-        for section_key, section_data in data.get("sections", {}).items():
-            sections[section_key] = TemplateSection(
-                instructions=section_data.get("instructions", ""),
-                depends_on=section_data.get("depends_on", []),
-            )
-
-        return cls(
-            name=data["name"],
-            purpose=data["purpose"],
-            prompt=data["prompt"],
-            sections=sections,
-            agent_mode=agent_mode,
-            template_id=template_id,
-        )
-
-
-class TemplateSummary(BaseModel):
-    """Summary information about a template for listing purposes."""
-
-    template_id: str = Field(..., description="Unique identifier for the template")
-    name: str = Field(..., description="Display name of the template")
-    purpose: str = Field(..., description="Description of what this template is for")
-    agent_mode: AgentMode = Field(
-        ..., description="Agent mode this template belongs to"
-    )
-    section_count: int = Field(..., description="Number of sections in the template")
-
-    def __str__(self) -> str:
-        """String representation for CLI display."""
-        return f"{self.template_id}: {self.purpose}"

shotgun/artifacts/templates/plan/delivery_and_release_plan.yaml

@@ -1,66 +0,0 @@
-name: Delivery & Release Plan
-purpose: |
-  Convert scope and roadmap into a staffed, scheduled, dependency-aware execution plan with 
-  clear ownership, milestones, risk management, and cutover/rollback strategies.
-prompt: |
-  Use this template to build a delivery plan we have the specification ready.
-  The output should enable both engineering and product stakeholders to track progress, 
-  manage dependencies, and prepare for a safe release.
-sections:
-  delivery.workstreams:
-    instructions: |
-      Define parallel streams of work (e.g., Backend, Frontend, Data, DevOps, QA, Security).
-      For each: owner (DRI), objectives, deliverables, and relation to PRD scope.
-  wbs.estimates:
-    instructions: |
-      Create a Work Breakdown Structure. Break epics → features → stories → tasks.
-      Provide estimates (T-shirt sizes + P50/P90 time in days). Highlight critical path items.
-      Include buffers for integration and testing.
-  capacity_and_staffing:
-    instructions: |
-      List team members, roles, and availability (holidays, partial allocations).
-      Define velocity assumptions and utilization factors.
-      Highlight gaps and hiring needs if capacity < required.
-  dependency_map:
-    instructions: |
-      Capture internal and external dependencies (libraries, vendors, APIs).
-      Define lead times and SLAs. Show dependency graph (Mermaid or table).
-      Suggest decoupling via feature flags, mocks, or phased integration.
-  schedule.plan:
-    instructions: |
-      Translate WBS + capacity into a timeline. Provide both:
-        - High-level milestones (alpha, beta, GA)
-        - Detailed Gantt/roadmap (Mermaid or markdown tables)
-      Show critical path and dependency-driven slips.
-  raci_and_ceremonies:
-    instructions: |
-      Define RACI (Responsible, Accountable, Consulted, Informed) for decisions.
-      Define governance cadences: daily standups, weekly demos, fortnightly checkpoints.
-      Specify escalation path for blockers.
-  quality_and_testing:
-    instructions: |
-      Define QA strategy: test types (unit, integration, regression, perf).
-      Define gates: test coverage %, perf benchmarks, security scans.
-      Specify environments: staging, pre-prod, canary.
-  cutover_and_rollback:
-    instructions: |
-      Provide release checklist: build, config, migrations, monitoring, comms.
-      Define dark launch/canary steps, health checks, rollback triggers, and procedures.
-      Specify post-release monitoring window and owner on-call.
-  release_comms:
-    instructions: |
-      Draft internal and external comms: release notes, stakeholder briefings, customer updates.
-      Specify timing relative to rollout phases.
-  delivery_risks:
-    instructions: |
-      Maintain a risk register: description, prob×impact, owner, mitigation, contingency.
-      Track status weekly. Mark high-priority risks explicitly.
-  metrics_and_tracking:
-    instructions: |
-      Link to PRD success metrics and Experiment Plan metrics.
-      Define delivery metrics: burn-down, velocity, on-time %.
-      Provide dashboards or reporting cadence.
-  status_reporting:
-    instructions: |
-      Define status update format (traffic-light summary, burndown chart, risk log).
-      Specify frequency (weekly) and audience (exec, product, eng).