devskill 2.0.7 → 2.0.8

package/skills/aws-cdk-python-setup/SYNC.md

@@ -0,0 +1,5 @@
+# Sync Info
+
+- **Source:** `vendor/awesome-copilot/skills/aws-cdk-python-setup`
+- **Git SHA:** `23fb7006c132a0bba75b0e5af7a35cab11272812`
+- **Synced:** 2026-03-24

package/skills/az-cost-optimize/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright GitHub, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/az-cost-optimize/SKILL.md

@@ -0,0 +1,305 @@
+---
+name: az-cost-optimize
+description: 'Analyze Azure resources used in the app (IaC files and/or resources in a target rg) and optimize costs - creating GitHub issues for identified optimizations.'
+---
+
+# Azure Cost Optimize
+
+This workflow analyzes Infrastructure-as-Code (IaC) files and Azure resources to generate cost optimization recommendations. It creates individual GitHub issues for each optimization opportunity plus one EPIC issue to coordinate implementation, enabling efficient tracking and execution of cost savings initiatives.
+
+## Prerequisites
+- Azure MCP server configured and authenticated
+- GitHub MCP server configured and authenticated  
+- Target GitHub repository identified
+- Azure resources deployed (IaC files optional but helpful)
+- Prefer Azure MCP tools (`azmcp-*`) over direct Azure CLI when available
+
+## Workflow Steps
+
+### Step 1: Get Azure Best Practices
+**Action**: Retrieve cost optimization best practices before analysis
+**Tools**: Azure MCP best practices tool
+**Process**:
+1. **Load Best Practices**:
+   - Execute `azmcp-bestpractices-get` to get some of the latest Azure optimization guidelines. This may not cover all scenarios but provides a foundation.
+   - Use these practices to inform subsequent analysis and recommendations as much as possible
+   - Reference best practices in optimization recommendations, either from the MCP tool output or general Azure documentation
+
+### Step 2: Discover Azure Infrastructure
+**Action**: Dynamically discover and analyze Azure resources and configurations
+**Tools**: Azure MCP tools + Azure CLI fallback + Local file system access
+**Process**:
+1. **Resource Discovery**:
+   - Execute `azmcp-subscription-list` to find available subscriptions
+   - Execute `azmcp-group-list --subscription <subscription-id>` to find resource groups
+   - Get a list of all resources in the relevant group(s):
+     - Use `az resource list --subscription <id> --resource-group <name>`
+   - For each resource type, use MCP tools first if possible, then CLI fallback:
+     - `azmcp-cosmos-account-list --subscription <id>` - Cosmos DB accounts
+     - `azmcp-storage-account-list --subscription <id>` - Storage accounts  
+     - `azmcp-monitor-workspace-list --subscription <id>` - Log Analytics workspaces
+     - `azmcp-keyvault-key-list` - Key Vaults
+     - `az webapp list` - Web Apps (fallback - no MCP tool available)
+     - `az appservice plan list` - App Service Plans (fallback)
+     - `az functionapp list` - Function Apps (fallback)
+     - `az sql server list` - SQL Servers (fallback)
+     - `az redis list` - Redis Cache (fallback)
+     - ... and so on for other resource types
+
+2. **IaC Detection**:
+   - Use `file_search` to scan for IaC files: "**/*.bicep", "**/*.tf", "**/main.json", "**/*template*.json"
+   - Parse resource definitions to understand intended configurations
+   - Compare against discovered resources to identify discrepancies
+   - Note presence of IaC files for implementation recommendations later on
+   - Do NOT use any other file from the repository, only IaC files. Using other files is NOT allowed as it is not a source of truth.
+   - If you do not find IaC files, then STOP and report no IaC files found to the user.
+
+3. **Configuration Analysis**:
+   - Extract current SKUs, tiers, and settings for each resource
+   - Identify resource relationships and dependencies
+   - Map resource utilization patterns where available
+
+### Step 3: Collect Usage Metrics & Validate Current Costs
+**Action**: Gather utilization data AND verify actual resource costs
+**Tools**: Azure MCP monitoring tools + Azure CLI
+**Process**:
+1. **Find Monitoring Sources**:
+   - Use `azmcp-monitor-workspace-list --subscription <id>` to find Log Analytics workspaces
+   - Use `azmcp-monitor-table-list --subscription <id> --workspace <name> --table-type "CustomLog"` to discover available data
+
+2. **Execute Usage Queries**:
+   - Use `azmcp-monitor-log-query` with these predefined queries:
+     - Query: "recent" for recent activity patterns
+     - Query: "errors" for error-level logs indicating issues
+   - For custom analysis, use KQL queries:
+   ```kql
+   // CPU utilization for App Services
+   AppServiceAppLogs
+   | where TimeGenerated > ago(7d)
+   | summarize avg(CpuTime) by Resource, bin(TimeGenerated, 1h)
+   
+   // Cosmos DB RU consumption  
+   AzureDiagnostics
+   | where ResourceProvider == "MICROSOFT.DOCUMENTDB"
+   | where TimeGenerated > ago(7d)
+   | summarize avg(RequestCharge) by Resource
+   
+   // Storage account access patterns
+   StorageBlobLogs
+   | where TimeGenerated > ago(7d)
+   | summarize RequestCount=count() by AccountName, bin(TimeGenerated, 1d)
+   ```
+
+3. **Calculate Baseline Metrics**:
+   - CPU/Memory utilization averages
+   - Database throughput patterns
+   - Storage access frequency
+   - Function execution rates
+
+4. **VALIDATE CURRENT COSTS**: 
+   - Using the SKU/tier configurations discovered in Step 2
+   - Look up current Azure pricing at https://azure.microsoft.com/pricing/ or use `az billing` commands
+   - Document: Resource → Current SKU → Estimated monthly cost
+   - Calculate realistic current monthly total before proceeding to recommendations
+
+### Step 4: Generate Cost Optimization Recommendations
+**Action**: Analyze resources to identify optimization opportunities
+**Tools**: Local analysis using collected data
+**Process**:
+1. **Apply Optimization Patterns** based on resource types found:
+   
+   **Compute Optimizations**:
+   - App Service Plans: Right-size based on CPU/memory usage
+   - Function Apps: Premium → Consumption plan for low usage
+   - Virtual Machines: Scale down oversized instances
+   
+   **Database Optimizations**:
+   - Cosmos DB: 
+     - Provisioned → Serverless for variable workloads
+     - Right-size RU/s based on actual usage
+   - SQL Database: Right-size service tiers based on DTU usage
+   
+   **Storage Optimizations**:
+   - Implement lifecycle policies (Hot → Cool → Archive)
+   - Consolidate redundant storage accounts
+   - Right-size storage tiers based on access patterns
+   
+   **Infrastructure Optimizations**:
+   - Remove unused/redundant resources
+   - Implement auto-scaling where beneficial
+   - Schedule non-production environments
+
+2. **Calculate Evidence-Based Savings**: 
+   - Current validated cost → Target cost = Savings
+   - Document pricing source for both current and target configurations
+
+3. **Calculate Priority Score** for each recommendation:
+   ```
+   Priority Score = (Value Score × Monthly Savings) / (Risk Score × Implementation Days)
+   
+   High Priority: Score > 20
+   Medium Priority: Score 5-20
+   Low Priority: Score < 5
+   ```
+
+4. **Validate Recommendations**:
+   - Ensure Azure CLI commands are accurate
+   - Verify estimated savings calculations
+   - Assess implementation risks and prerequisites
+   - Ensure all savings calculations have supporting evidence
+
+### Step 5: User Confirmation
+**Action**: Present summary and get approval before creating GitHub issues
+**Process**:
+1. **Display Optimization Summary**:
+   ```
+   🎯 Azure Cost Optimization Summary
+   
+   📊 Analysis Results:
+   • Total Resources Analyzed: X
+   • Current Monthly Cost: $X 
+   • Potential Monthly Savings: $Y 
+   • Optimization Opportunities: Z
+   • High Priority Items: N
+   
+   🏆 Recommendations:
+   1. [Resource]: [Current SKU] → [Target SKU] = $X/month savings - [Risk Level] | [Implementation Effort]
+   2. [Resource]: [Current Config] → [Target Config] = $Y/month savings - [Risk Level] | [Implementation Effort]
+   3. [Resource]: [Current Config] → [Target Config] = $Z/month savings - [Risk Level] | [Implementation Effort]
+   ... and so on
+   
+   💡 This will create:
+   • Y individual GitHub issues (one per optimization)
+   • 1 EPIC issue to coordinate implementation
+   
+   ❓ Proceed with creating GitHub issues? (y/n)
+   ```
+
+2. **Wait for User Confirmation**: Only proceed if user confirms
+
+### Step 6: Create Individual Optimization Issues
+**Action**: Create separate GitHub issues for each optimization opportunity. Label them with "cost-optimization" (green color), "azure" (blue color).
+**MCP Tools Required**: `create_issue` for each recommendation
+**Process**:
+1. **Create Individual Issues** using this template:
+
+   **Title Format**: `[COST-OPT] [Resource Type] - [Brief Description] - $X/month savings`
+   
+   **Body Template**:
+   ```markdown
+   ## 💰 Cost Optimization: [Brief Title]
+   
+   **Monthly Savings**: $X | **Risk Level**: [Low/Medium/High] | **Implementation Effort**: X days
+   
+   ### 📋 Description
+   [Clear explanation of the optimization and why it's needed]
+   
+   ### 🔧 Implementation
+   
+   **IaC Files Detected**: [Yes/No - based on file_search results]
+   
+   ```bash
+   # If IaC files found: Show IaC modifications + deployment
+   # File: infrastructure/bicep/modules/app-service.bicep
+   # Change: sku.name: 'S3' → 'B2'
+   az deployment group create --resource-group [rg] --template-file infrastructure/bicep/main.bicep
+   
+   # If no IaC files: Direct Azure CLI commands + warning
+   # ⚠️ No IaC files found. If they exist elsewhere, modify those instead.
+   az appservice plan update --name [plan] --sku B2
+   ```
+   
+   ### 📊 Evidence
+   - Current Configuration: [details]
+   - Usage Pattern: [evidence from monitoring data]
+   - Cost Impact: $X/month → $Y/month
+   - Best Practice Alignment: [reference to Azure best practices if applicable]
+   
+   ### ✅ Validation Steps
+   - [ ] Test in non-production environment
+   - [ ] Verify no performance degradation
+   - [ ] Confirm cost reduction in Azure Cost Management
+   - [ ] Update monitoring and alerts if needed
+   
+   ### ⚠️ Risks & Considerations
+   - [Risk 1 and mitigation]
+   - [Risk 2 and mitigation]
+   
+   **Priority Score**: X | **Value**: X/10 | **Risk**: X/10
+   ```
+
+### Step 7: Create EPIC Coordinating Issue
+**Action**: Create master issue to track all optimization work. Label it with "cost-optimization" (green color), "azure" (blue color), and "epic" (purple color).
+**MCP Tools Required**: `create_issue` for EPIC
+**Note about mermaid diagrams**: Ensure you verify mermaid syntax is correct and create the diagrams taking accessibility guidelines into account (styling, colors, etc.).
+**Process**:
+1. **Create EPIC Issue**:
+
+   **Title**: `[EPIC] Azure Cost Optimization Initiative - $X/month potential savings`
+   
+   **Body Template**:
+   ```markdown
+   # 🎯 Azure Cost Optimization EPIC
+   
+   **Total Potential Savings**: $X/month | **Implementation Timeline**: X weeks
+   
+   ## 📊 Executive Summary
+   - **Resources Analyzed**: X
+   - **Optimization Opportunities**: Y  
+   - **Total Monthly Savings Potential**: $X
+   - **High Priority Items**: N
+   
+   ## 🏗️ Current Architecture Overview
+   
+   ```mermaid
+   graph TB
+       subgraph "Resource Group: [name]"
+           [Generated architecture diagram showing current resources and costs]
+       end
+   ```
+   
+   ## 📋 Implementation Tracking
+   
+   ### 🚀 High Priority (Implement First)
+   - [ ] #[issue-number]: [Title] - $X/month savings
+   - [ ] #[issue-number]: [Title] - $X/month savings
+   
+   ### ⚡ Medium Priority 
+   - [ ] #[issue-number]: [Title] - $X/month savings
+   - [ ] #[issue-number]: [Title] - $X/month savings
+   
+   ### 🔄 Low Priority (Nice to Have)
+   - [ ] #[issue-number]: [Title] - $X/month savings
+   
+   ## 📈 Progress Tracking
+   - **Completed**: 0 of Y optimizations
+   - **Savings Realized**: $0 of $X/month
+   - **Implementation Status**: Not Started
+   
+   ## 🎯 Success Criteria
+   - [ ] All high-priority optimizations implemented
+   - [ ] >80% of estimated savings realized
+   - [ ] No performance degradation observed
+   - [ ] Cost monitoring dashboard updated
+   
+   ## 📝 Notes
+   - Review and update this EPIC as issues are completed
+   - Monitor actual vs. estimated savings
+   - Consider scheduling regular cost optimization reviews
+   ```
+
+## Error Handling
+- **Cost Validation**: If savings estimates lack supporting evidence or seem inconsistent with Azure pricing, re-verify configurations and pricing sources before proceeding
+- **Azure Authentication Failure**: Provide manual Azure CLI setup steps
+- **No Resources Found**: Create informational issue about Azure resource deployment
+- **GitHub Creation Failure**: Output formatted recommendations to console
+- **Insufficient Usage Data**: Note limitations and provide configuration-based recommendations only
+
+## Success Criteria
+- ✅ All cost estimates verified against actual resource configurations and Azure pricing
+- ✅ Individual issues created for each optimization (trackable and assignable)
+- ✅ EPIC issue provides comprehensive coordination and tracking
+- ✅ All recommendations include specific, executable Azure CLI commands
+- ✅ Priority scoring enables ROI-focused implementation
+- ✅ Architecture diagram accurately represents current state
+- ✅ User confirmation prevents unwanted issue creation

package/skills/az-cost-optimize/SYNC.md

@@ -0,0 +1,5 @@
+# Sync Info
+
+- **Source:** `vendor/awesome-copilot/skills/az-cost-optimize`
+- **Git SHA:** `23fb7006c132a0bba75b0e5af7a35cab11272812`
+- **Synced:** 2026-03-24

package/skills/azure-deployment-preflight/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright GitHub, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/azure-deployment-preflight/SKILL.md

@@ -0,0 +1,216 @@
+---
+name: azure-deployment-preflight
+description: 'Performs comprehensive preflight validation of Bicep deployments to Azure, including template syntax validation, what-if analysis, and permission checks. Use this skill before any deployment to Azure to preview changes, identify potential issues, and ensure the deployment will succeed. Activate when users mention deploying to Azure, validating Bicep files, checking deployment permissions, previewing infrastructure changes, running what-if, or preparing for azd provision.'
+---
+
+# Azure Deployment Preflight Validation
+
+This skill validates Bicep deployments before execution, supporting both Azure CLI (`az`) and Azure Developer CLI (`azd`) workflows.
+
+## When to Use This Skill
+
+- Before deploying infrastructure to Azure
+- When preparing or reviewing Bicep files
+- To preview what changes a deployment will make
+- To verify permissions are sufficient for deployment
+- Before running `azd up`, `azd provision`, or `az deployment` commands
+
+## Validation Process
+
+Follow these steps in order. Continue to the next step even if a previous step fails—capture all issues in the final report.
+
+### Step 1: Detect Project Type
+
+Determine the deployment workflow by checking for project indicators:
+
+1. **Check for azd project**: Look for `azure.yaml` in the project root
+   - If found → Use **azd workflow**
+   - If not found → Use **az CLI workflow**
+
+2. **Locate Bicep files**: Find all `.bicep` files to validate
+   - For azd projects: Check `infra/` directory first, then project root
+   - For standalone: Use the file specified by the user or search common locations (`infra/`, `deploy/`, project root)
+
+3. **Auto-detect parameter files**: For each Bicep file, look for matching parameter files:
+   - `<filename>.bicepparam` (Bicep parameters - preferred)
+   - `<filename>.parameters.json` (JSON parameters)
+   - `parameters.json` or `parameters/<env>.json` in same directory
+
+### Step 2: Validate Bicep Syntax
+
+Run Bicep CLI to check template syntax before attempting deployment validation:
+
+```bash
+bicep build <bicep-file> --stdout
+```
+
+**What to capture:**
+- Syntax errors with line/column numbers
+- Warning messages
+- Build success/failure status
+
+**If Bicep CLI is not installed:**
+- Note the issue in the report
+- Continue to Step 3 (Azure will validate syntax during what-if)
+
+### Step 3: Run Preflight Validation
+
+Choose the appropriate validation based on project type detected in Step 1.
+
+#### For azd Projects (azure.yaml exists)
+
+Use `azd provision --preview` to validate the deployment:
+
+```bash
+azd provision --preview
+```
+
+If an environment is specified or multiple environments exist:
+```bash
+azd provision --preview --environment <env-name>
+```
+
+#### For Standalone Bicep (no azure.yaml)
+
+Determine the deployment scope from the Bicep file's `targetScope` declaration:
+
+| Target Scope | Command |
+|--------------|---------|
+| `resourceGroup` (default) | `az deployment group what-if` |
+| `subscription` | `az deployment sub what-if` |
+| `managementGroup` | `az deployment mg what-if` |
+| `tenant` | `az deployment tenant what-if` |
+
+**Run with Provider validation level first:**
+
+```bash
+# Resource Group scope (most common)
+az deployment group what-if \
+  --resource-group <rg-name> \
+  --template-file <bicep-file> \
+  --parameters <param-file> \
+  --validation-level Provider
+
+# Subscription scope
+az deployment sub what-if \
+  --location <location> \
+  --template-file <bicep-file> \
+  --parameters <param-file> \
+  --validation-level Provider
+
+# Management Group scope
+az deployment mg what-if \
+  --location <location> \
+  --management-group-id <mg-id> \
+  --template-file <bicep-file> \
+  --parameters <param-file> \
+  --validation-level Provider
+
+# Tenant scope
+az deployment tenant what-if \
+  --location <location> \
+  --template-file <bicep-file> \
+  --parameters <param-file> \
+  --validation-level Provider
+```
+
+**Fallback Strategy:**
+
+If `--validation-level Provider` fails with permission errors (RBAC), retry with `ProviderNoRbac`:
+
+```bash
+az deployment group what-if \
+  --resource-group <rg-name> \
+  --template-file <bicep-file> \
+  --validation-level ProviderNoRbac
+```
+
+Note the fallback in the report—the user may lack full deployment permissions.
+
+### Step 4: Capture What-If Results
+
+Parse the what-if output to categorize resource changes:
+
+| Change Type | Symbol | Meaning |
+|-------------|--------|---------|
+| Create | `+` | New resource will be created |
+| Delete | `-` | Resource will be deleted |
+| Modify | `~` | Resource properties will change |
+| NoChange | `=` | Resource unchanged |
+| Ignore | `*` | Resource not analyzed (limits reached) |
+| Deploy | `!` | Resource will be deployed (changes unknown) |
+
+For modified resources, capture the specific property changes.
+
+### Step 5: Generate Report
+
+Create a Markdown report file in the **project root** named:
+- `preflight-report.md`
+
+Use the template structure from [references/REPORT-TEMPLATE.md](references/REPORT-TEMPLATE.md).
+
+**Report sections:**
+1. **Summary** - Overall status, timestamp, files validated, target scope
+2. **Tools Executed** - Commands run, versions, validation levels used
+3. **Issues** - All errors and warnings with severity and remediation
+4. **What-If Results** - Resources to create/modify/delete/unchanged
+5. **Recommendations** - Actionable next steps
+
+## Required Information
+
+Before running validation, gather:
+
+| Information | Required For | How to Obtain |
+|-------------|--------------|---------------|
+| Resource Group | `az deployment group` | Ask user or check existing `.azure/` config |
+| Subscription | All deployments | `az account show` or ask user |
+| Location | Sub/MG/Tenant scope | Ask user or use default from config |
+| Environment | azd projects | `azd env list` or ask user |
+
+If required information is missing, prompt the user before proceeding.
+
+## Error Handling
+
+See [references/ERROR-HANDLING.md](references/ERROR-HANDLING.md) for detailed error handling guidance.
+
+**Key principle:** Continue validation even when errors occur. Capture all issues in the final report.
+
+| Error Type | Action |
+|------------|--------|
+| Not logged in | Note in report, suggest `az login` or `azd auth login` |
+| Permission denied | Fall back to `ProviderNoRbac`, note in report |
+| Bicep syntax error | Include all errors, continue to other files |
+| Tool not installed | Note in report, skip that validation step |
+| Resource group not found | Note in report, suggest creating it |
+
+## Tool Requirements
+
+This skill uses the following tools:
+
+- **Azure CLI** (`az`) - Version 2.76.0+ recommended for `--validation-level`
+- **Azure Developer CLI** (`azd`) - For projects with `azure.yaml`
+- **Bicep CLI** (`bicep`) - For syntax validation
+- **Azure MCP Tools** - For documentation lookups and best practices
+
+Check tool availability before starting:
+```bash
+az --version
+azd version
+bicep --version
+```
+
+## Example Workflow
+
+1. User: "Validate my Bicep deployment before I run it"
+2. Agent detects `azure.yaml` → azd project
+3. Agent finds `infra/main.bicep` and `infra/main.bicepparam`
+4. Agent runs `bicep build infra/main.bicep --stdout`
+5. Agent runs `azd provision --preview`
+6. Agent generates `preflight-report.md` in project root
+7. Agent summarizes findings to user
+
+## Reference Documentation
+
+- [Validation Commands Reference](references/VALIDATION-COMMANDS.md)
+- [Report Template](references/REPORT-TEMPLATE.md)
+- [Error Handling Guide](references/ERROR-HANDLING.md)

package/skills/azure-deployment-preflight/SYNC.md

@@ -0,0 +1,5 @@
+# Sync Info
+
+- **Source:** `vendor/awesome-copilot/skills/azure-deployment-preflight`
+- **Git SHA:** `23fb7006c132a0bba75b0e5af7a35cab11272812`
+- **Synced:** 2026-03-24