# template: basic-dev
name: "Development Session"
tags: ["development", "coding"]
structure:
  start:
    - prompt: "What feature/fix are you working on?"
    - link_to: ["linear", "github"]
  
  progress_checkpoints:
    - 10: "Understanding requirements"
    - 25: "Design/planning complete"
    - 50: "Core implementation"
    - 75: "Testing & refinement"
    - 90: "Code review ready"
    - 100: "Merged/deployed"
  
  prompts:
    every_30_min: "What did you accomplish?"
    on_decision: "What alternatives did you consider?"
    on_blocker: "What's the impact? Who can help?"

msp start --template basic-dev

# template: bugfix
name: "Bug Fix Session"
tags: ["bugfix", "debugging"]
required_info:
  - bug_id: "Issue/ticket number"
  - severity: ["critical", "high", "medium", "low"]
  - reported_by: "Who reported this?"

structure:
  phases:
    - reproduce:
        goal: "Reproduce the issue"
        questions:
          - "Steps to reproduce?"
          - "Expected vs actual behavior?"
          - "Environment details?"
        progress: 20
    
    - investigate:
        goal: "Find root cause"
        questions:
          - "What's in the logs?"
          - "When did this start?"
          - "What changed recently?"
        progress: 50
    
    - fix:
        goal: "Implement solution"
        questions:
          - "What's the fix approach?"
          - "Side effects?"
          - "Tests needed?"
        progress: 80
    
    - verify:
        goal: "Verify fix works"
        questions:
          - "Original issue resolved?"
          - "No regressions?"
          - "Performance impact?"
        progress: 100

decisions:
  - template: "Root cause: {finding}"
  - template: "Fix approach: {approach}"
  - template: "Testing strategy: {strategy}"

msp start --template bugfix --bug-id "PROD-789" --severity "high"

# template: planning
name: "Feature Planning"
tags: ["planning", "architecture", "design"]
outputs:
  - technical_spec: "markdown"
  - architecture_diagram: "mermaid"
  - task_breakdown: "linear"

structure:
  sections:
    - requirements:
        time_estimate: "30 min"
        checklist:
          - [ ] User stories defined
          - [ ] Acceptance criteria clear
          - [ ] Dependencies identified
          - [ ] Performance requirements
    
    - architecture:
        time_estimate: "45 min"
        decisions_needed:
          - "Database schema"
          - "API design"
          - "Frontend approach"
          - "Third-party services"
    
    - breakdown:
        time_estimate: "30 min"
        outputs:
          - "Task list with estimates"
          - "Milestone definitions"
          - "Risk assessment"

templates:
  decision: |
    ## Decision: {title}
    **Options Considered:**
    1. {option1} - {pros1} / {cons1}
    2. {option2} - {pros2} / {cons2}
    
    **Choice:** {choice}
    **Rationale:** {rationale}

# template: code-review
name: "Code Review"
tags: ["review", "quality", "collaboration"]
metadata:
  pr_url: required
  author: required
  reviewers: optional

checklist:
  functionality:
    - [ ] Feature works as intended
    - [ ] Edge cases handled
    - [ ] Error handling appropriate
    - [ ] Performance acceptable
  
  code_quality:
    - [ ] Clear and readable
    - [ ] Well-documented
    - [ ] Follows conventions
    - [ ] No code smells
  
  testing:
    - [ ] Adequate test coverage
    - [ ] Tests are meaningful
    - [ ] Edge cases tested
    - [ ] Integration tests present

feedback_template: |
  ## Review for {pr_url}
  
  ### Strengths
  {strengths}
  
  ### Suggestions
  {suggestions}
  
  ### Required Changes
  {required_changes}
  
  **Verdict:** {approve|request_changes|comment}

# template: research
name: "Research Session"
tags: ["learning", "research", "exploration"]
structure:
  goal_setting:
    - "What do I want to learn?"
    - "Why is this important now?"
    - "How will I apply this?"
  
  exploration:
    phases:
      - read_docs:
          resources: []
          notes: "Key takeaways"
          time_box: "30 min"
      
      - try_examples:
          experiments: []
          findings: []
          time_box: "45 min"
      
      - build_poc:
          goal: "Working prototype"
          success_criteria: []
          time_box: "60 min"
  
  synthesis:
    outputs:
      - summary: "What I learned"
      - applications: "How to use this"
      - resources: "Future reference"
      - questions: "Still unclear"

knowledge_capture: |
  # Research: {topic}
  Date: {date}
  
  ## Objective
  {objective}
  
  ## Key Findings
  {findings}
  
  ## Practical Applications
  {applications}
  
  ## Resources
  {resources}
  
  ## Next Steps
  {next_steps}

# template: refactor
name: "Refactoring Session"
tags: ["refactoring", "cleanup", "optimization"]
required:
  scope: "What are we refactoring?"
  reason: "Why refactor now?"

pre_refactor:
  - [ ] Tests passing
  - [ ] Baseline metrics captured
  - [ ] Backup/branch created
  - [ ] Stakeholders notified

refactor_types:
  performance:
    metrics:
      - response_time
      - memory_usage
      - cpu_usage
    approach:
      - profile_first
      - optimize_hotspots
      - measure_improvement
  
  readability:
    goals:
      - simplify_logic
      - improve_naming
      - reduce_complexity
    principles:
      - single_responsibility
      - clear_intent
      - minimal_surprise
  
  architecture:
    patterns:
      - extract_service
      - introduce_abstraction
      - simplify_dependencies
    validation:
      - maintains_behavior
      - improves_testability
      - enables_features

post_refactor:
  - [ ] All tests pass
  - [ ] Performance validated
  - [ ] Documentation updated
  - [ ] Team notified

# template: your-template-name
# version: 1.0
# author: Your Name

# Basic metadata
name: "Template Display Name"
description: "What this template is for"
tags: ["tag1", "tag2"]
icon: "🎯" # Optional emoji

# Required information at start
required_fields:
  field_name:
    type: "string|number|choice|boolean"
    prompt: "Question to ask user"
    choices: ["option1", "option2"] # If type is choice
    default: "default value" # Optional

# Session structure
structure:
  # Linear progression
  linear:
    - phase_1:
        name: "Phase Name"
        duration: "30 min"
        progress_target: 25
        tasks:
          - "Task 1"
          - "Task 2"
    
  # Or checkpoint-based
  checkpoints:
    - at_progress: 0
      prompt: "Starting question"
      create: "decision|blocker|note"
    
    - at_progress: 50
      prompt: "Midpoint check"
      validate:
        - "Is X complete?"
        - "Has Y been tested?"

# Automated actions
automation:
  on_start:
    - create_linear_issue: true
    - notify_team: false
    - set_github_status: "in_progress"
  
  on_progress:
    25: "update_linear_comment"
    50: "create_checkpoint_commit"
    75: "request_review"
  
  on_end:
    - generate_summary: true
    - update_documentation: true
    - close_linear_issue: "if_complete"

# Output templates
outputs:
  summary_template: |
    # {session.name} Summary
    Duration: {session.duration}
    Progress: {session.start_progress}% → {session.end_progress}%
    
    ## Accomplishments
    {session.accomplishments}
    
    ## Decisions
    {session.decisions}
    
    ## Next Steps
    {session.next_steps}
  
  commit_template: |
    [{session.progress}%] {session.latest_update}
    
    Session: {session.id}
    Duration: {session.duration}h
    Decisions: {session.decision_count}

# Install from repository
msp template install "msp-framework/templates/architecture-review"

# Install from file
msp template add ./my-template.yaml

# Install from URL
msp template add https://gist.github.com/.../template.yaml

# Export template with examples
msp template export "bugfix" --include-examples

# Publish to community
msp template publish "my-awesome-template" --tags "api,testing"

# Create from existing session
msp template create --from-session "msp-2025-07-15-093042"

# Session variables
{session.id}
{session.start_time}
{session.duration}
{session.user}
{session.project}

# Progress variables
{progress.current}
{progress.delta}
{progress.milestone_next}
{progress.milestone_previous}

# Context variables
{context.decisions_count}
{context.blockers_active}
{context.last_session_summary}
{context.project_phase}

# Time variables
{time.now}
{time.today}
{time.week_number}
{time.sprint_day}

# Dynamic variables
{input.field_name} # From required_fields
{prompt.response} # From user prompts

sections:
  - if: "{progress.current} < 50"
    show:
      prompt: "What's blocking progress?"
      suggest_actions:
        - "Break down the task"
        - "Ask for help"
        - "Research similar solutions"
  
  - if: "{context.blockers_active} > 0"
    show:
      warning: "Active blockers need attention!"
      actions:
        - "Review blockers"
        - "Escalate if needed"
        - "Update status"

# template: daily-standup
name: "Daily Standup"
tags: ["meeting", "standup", "team"]
duration: "15 min"

sections:
  yesterday:
    prompt: "What did you complete yesterday?"
    pull_from: "previous_session_summary"
  
  today:
    prompt: "What's planned for today?"
    suggest_from: "linear_assigned_issues"
  
  blockers:
    prompt: "Any blockers?"
    check: "active_blockers"

output:
  format: "markdown"
  share_to: ["slack", "linear"]
  template: |
    **{user} - {date}**
    
    Yesterday:
    {yesterday}
    
    Today:
    {today}
    
    Blockers:
    {blockers|"None"}

# template: sprint-planning
name: "Sprint Planning"
tags: ["planning", "sprint", "team"]
collaborative: true

phases:
  - review_backlog:
      duration: "30 min"
      activities:
        - "Review priority items"
        - "Clarify requirements"
        - "Identify dependencies"
  
  - estimate_work:
      duration: "45 min"
      tools:
        - planning_poker: true
        - reference_velocity: "last_3_sprints"
      capture:
        - story_points
        - complexity_notes
        - risk_factors
  
  - commit_sprint:
      duration: "15 min"
      validate:
        - "Total points within capacity?"
        - "Dependencies resolved?"
        - "Team agrees?"
      output:
        - sprint_goals
        - committed_stories
        - risk_mitigation

integrations:
  linear:
    - move_to_sprint: "committed_stories"
    - add_labels: ["sprint-{sprint_number}"]
    - assign_owners: true
  
  msp:
    - create_sprint_project: true
    - set_milestones: "from_stories"
    - track_decisions: "sprint_planning"

# Copy and modify team template
msp template fork "basic-dev" --name "acme-dev"

# Edit template
msp template edit "acme-dev"

# Set as team default
msp config set team.default_template "acme-dev"