fraim-framework 2.0.67 → 2.0.68

package/dist/registry/workflows/azure/cost-optimization.md

@@ -1,772 +0,0 @@
----
-{
-  "name": "cost-optimization",
-  "initialPhase": "verify-auth",
-  "phases": {
-    "verify-auth": {
-      "onSuccess": "gather-data",
-      "onFailure": "verify-auth"
-    },
-    "gather-data": {
-      "onSuccess": "identify-opportunities",
-      "onFailure": "gather-data"
-    },
-    "identify-opportunities": {
-      "onSuccess": "prioritize-actions",
-      "onFailure": "identify-opportunities"
-    },
-    "prioritize-actions": {
-      "onSuccess": "execute-changes",
-      "onFailure": "prioritize-actions"
-    },
-    "execute-changes": {
-      "onSuccess": null,
-      "onFailure": "execute-changes"
-    }
-  }
-}
----
-# Workflow: Azure Cloud Cost Optimization
-
-## INTENT
-
-Enable AI agents to systematically analyze Azure subscription costs, identify optimization opportunities, and implement cost-saving measures while maintaining production reliability.
-
-## PRINCIPLES
-
-- **Safety First**: Explicit user approval required before any changes
-- **Full Documentation**: Every action logged with before/after states
-- **Risk-Based Prioritization**: Balance savings against production impact
-- **Agent Autonomy**: Clear commands agents can execute
-- **Learning Capture**: Document lessons learned for future optimizations
-
-## VALUE PROPOSITION
-
-- Systematic 5-phase workflow (Auth → Gather → Identify → Prioritize → Execute)
-- Real-world tested: Successfully reduced costs by 65% ($344 → $119/month)
-- Agent-friendly with clear commands, error handling, and decision trees
-- Maintains production reliability while optimizing costs
-
-## WORKFLOW ACTIVATION
-
-When you need to optimize Azure cloud costs, START here:
-
-```javascript
-seekMentoring({
-  workflowType: "cost-optimization",
-  issueNumber: "{issue_number}",
-  currentPhase: "verify-auth",
-  status: "starting"
-})
-```
-
----
-
-## Phase: verify-auth
-
-### INTENT
-Verify Azure CLI is installed and user is authenticated before proceeding.
-
-### CRITICAL CONSTRAINT
-**Agents CANNOT authenticate interactively**. User must run `az login` manually.
-
-### STEPS
-
-1. **Check Azure CLI Installation**
-   ```bash
-   az --version
-   ```
-   
-   If not installed, instruct user to install:
-   - Windows: `winget install Microsoft.AzureCLI`
-   - Mac: `brew install azure-cli`
-   - Linux: See https://docs.microsoft.com/en-us/cli/azure/install-azure-cli
-
-2. **Verify Authentication**
-   ```bash
-   az account show
-   ```
-   
-   **If authentication fails**:
-   - Tell user: "Please run `az login` in your terminal and follow the browser authentication flow"
-   - Wait for user confirmation
-   - Retry `az account show`
-
-3. **Capture Subscription Info**
-   ```bash
-   az account show --query "{SubscriptionId:id, Name:name, TenantId:tenantId}" -o json
-   ```
-   
-   Store subscription ID for cost queries.
-
-### SUCCESS CRITERIA
-- Azure CLI installed and accessible
-- User authenticated (can run `az account show` successfully)
-- Subscription ID captured
-
-### REPORT BACK
-```javascript
-seekMentoring({
-  workflowType: "cost-optimization",
-  issueNumber: "{issue_number}",
-  currentPhase: "verify-auth",
-  status: "complete",
-  findings: {
-    subscriptionId: "...",
-    subscriptionName: "...",
-    tenantId: "..."
-  }
-})
-```
-
----
-
-## Phase: gather-data
-
-### INTENT
-Collect comprehensive cost data across multiple dimensions to identify patterns.
-
-### STEPS
-
-1. **Set Time Range**
-   ```bash
-   # Last 30 days
-   START_DATE=$(date -u -d '30 days ago' '+%Y-%m-%dT00:00:00Z')
-   END_DATE=$(date -u '+%Y-%m-%dT23:59:59Z')
-   ```
-
-2. **Query Costs by Resource Group**
-   ```bash
-   az rest --method post \
-     --url "https://management.azure.com/subscriptions/{SUBSCRIPTION_ID}/providers/Microsoft.CostManagement/query?api-version=2023-03-01" \
-     --body '{
-       "type": "ActualCost",
-       "timeframe": "Custom",
-       "timePeriod": {
-         "from": "'$START_DATE'",
-         "to": "'$END_DATE'"
-       },
-       "dataset": {
-         "granularity": "None",
-         "aggregation": {
-           "totalCost": {
-             "name": "Cost",
-             "function": "Sum"
-           }
-         },
-         "grouping": [
-           {
-             "type": "Dimension",
-             "name": "ResourceGroupName"
-           }
-         ]
-       }
-     }'
-   ```
-
-3. **Query Costs by Service Type**
-   ```bash
-   # Same query but group by "ServiceName" instead of "ResourceGroupName"
-   ```
-
-4. **Query Costs by Resource Type & Location**
-   ```bash
-   # Same query but group by "ResourceType" and "ResourceLocation"
-   ```
-
-5. **Calculate Daily Averages**
-   - Total cost / 30 days = daily average
-   - Daily average × 30 = monthly projection
-
-### SUCCESS CRITERIA
-- Cost data collected for all resource groups
-- Cost data collected by service type
-- Cost data collected by location
-- Daily averages and monthly projections calculated
-
-### REPORT BACK
-```javascript
-seekMentoring({
-  workflowType: "cost-optimization",
-  issueNumber: "{issue_number}",
-  currentPhase: "gather-data",
-  status: "complete",
-  findings: {
-    totalMonthlyCost: 344.00,
-    costByResourceGroup: {...},
-    costByService: {...},
-    costByLocation: {...},
-    topCostDrivers: [
-      { service: "App Service", cost: 220, percentage: 64 },
-      { service: "Cosmos DB", cost: 80, percentage: 23 }
-    ]
-  }
-})
-```
-
----
-
-## Phase: identify-opportunities
-
-### INTENT
-Analyze cost data and resource configurations to find optimization opportunities.
-
-### STEPS
-
-1. **Inspect High-Cost Resources**
-   
-   For each top cost driver:
-   
-   ```bash
-   # List resources in resource group
-   az resource list --resource-group {RG} \
-     --query "[].{Name:name, Type:type, SKU:sku.name}" -o table
-   ```
-
-2. **Analyze App Service Plans**
-   
-   ```bash
-   az appservice plan show --name {PLAN_NAME} --resource-group {RG} \
-     --query "{Name:name, SKU:sku.name, Tier:sku.tier, Capacity:sku.capacity, \
-              Features:properties.reserved, VNet:properties.isXenon, \
-              Slots:properties.maximumNumberOfWorkers}" -o json
-   ```
-   
-   **Optimization Opportunities**:
-   - Premium (P0v3) → Basic (B2) for low traffic (<1000 req/day)
-   - Check if using premium features (VNet, staging slots, auto-scale)
-   - Tier comparison:
-     | Tier | vCPU | RAM | Cost/Month | Features |
-     |------|------|-----|------------|----------|
-     | P0v3 | 1 | 4GB | $220 | VNet, slots, auto-scale |
-     | B2 | 2 | 3.5GB | $55 | Basic features only |
-     | B1 | 1 | 1.75GB | $13 | Minimal features |
-
-3. **Analyze Cosmos DB**
-   
-   ```bash
-   az cosmosdb show --name {DB_NAME} --resource-group {RG} \
-     --query "{Name:name, Kind:kind, Tier:properties.databaseAccountOfferType, \
-              Capabilities:capabilities}" -o json
-   ```
-   
-   **Optimization Opportunities**:
-   - Check if eligible for free tier (RU-based only, not vCore)
-   - Review connection pooling in code
-   - Check for singleton patterns
-
-4. **Analyze Key Vault Usage**
-   
-   ```bash
-   az keyvault show --name {KV_NAME} \
-     --query "{Name:name, SKU:properties.sku.name, Location:location}" -o json
-   ```
-   
-   **Code Pattern Analysis**:
-   - Search codebase for Key Vault operations
-   - Check if secrets are cached (should be!)
-   - Review cache TTL (can it be extended?)
-   - Calculate operations per month
-
-5. **Analyze Storage Accounts**
-   
-   ```bash
-   az storage account show --name {STORAGE_NAME} --resource-group {RG} \
-     --query "{Name:name, SKU:sku.name, Tier:accessTier, Kind:kind}" -o json
-   ```
-   
-   **Optimization Opportunities**:
-   - Hot → Cool for infrequently accessed data
-   - Implement lifecycle management policies
-
-### SUCCESS CRITERIA
-- All high-cost resources inspected
-- Optimization opportunities identified with estimated savings
-- Risk level assessed for each opportunity
-- Code patterns analyzed where relevant
-
-### REPORT BACK
-```javascript
-seekMentoring({
-  workflowType: "cost-optimization",
-  issueNumber: "{issue_number}",
-  currentPhase: "identify-opportunities",
-  status: "complete",
-  findings: {
-    opportunities: [
-      {
-        resource: "App Service Plan (ashley-cal-plan)",
-        current: "P0v3 ($220/month)",
-        proposed: "B2 ($55/month)",
-        savings: 165,
-        risk: "Medium",
-        reasoning: "Low traffic, not using premium features"
-      },
-      {
-        resource: "Key Vault token cache",
-        current: "5min TTL",
-        proposed: "30min TTL",
-        savings: 5,
-        risk: "Low",
-        reasoning: "OAuth tokens valid 1 hour, safe to extend"
-      }
-    ],
-    codeQualityFindings: {
-      connectionPooling: "✅ Already optimized",
-      caching: "✅ Proper singleton patterns",
-      cacheHitRate: "98%"
-    }
-  }
-})
-```
-
----
-
-## Phase: prioritize-actions
-
-### INTENT
-Rank optimization opportunities by savings potential vs risk.
-
-### PRIORITIZATION FORMULA
-
-```
-Priority Score = (Monthly Savings × 10) - (Risk Level × 3)
-
-Risk Levels:
-- Low: 1 (config changes, cache TTL)
-- Medium: 2 (tier downgrades with feature verification)
-- High: 3 (architectural changes, data migration)
-```
-
-### STEPS
-
-1. **Calculate Priority Scores**
-   
-   For each opportunity:
-   - Estimate monthly savings
-   - Assess risk level
-   - Calculate priority score
-   - Add notes on what could break
-
-2. **Sort by Priority**
-   
-   Highest score = highest priority
-
-3. **Group by Environment**
-   
-   - Start with non-production (dev, staging)
-   - Then production (with extra caution)
-
-4. **Create Implementation Plan**
-   
-   For each opportunity:
-   - Exact commands to execute
-   - Verification steps
-   - Rollback plan
-   - User approval required: YES/NO
-
-### SUCCESS CRITERIA
-- All opportunities ranked by priority
-- Implementation plan created
-- Rollback plans documented
-- User approval checkpoints identified
-
-### REPORT BACK
-```javascript
-seekMentoring({
-  workflowType: "cost-optimization",
-  issueNumber: "{issue_number}",
-  currentPhase: "prioritize-actions",
-  status: "complete",
-  findings: {
-    prioritizedActions: [
-      {
-        priority: 1,
-        score: 1644,
-        action: "Downgrade App Service Plan P0v3 → B2",
-        savings: 165,
-        risk: "Medium",
-        requiresApproval: true,
-        commands: ["az appservice plan update..."],
-        rollback: ["az appservice plan update... --sku P0v3"]
-      },
-      {
-        priority: 2,
-        score: 47,
-        action: "Extend Key Vault cache TTL 5min → 30min",
-        savings: 5,
-        risk: "Low",
-        requiresApproval: true,
-        commands: ["Update config file..."],
-        rollback: ["Revert config file..."]
-      }
-    ]
-  }
-})
-```
-
----
-
-## Phase: execute-changes
-
-### INTENT
-Safely implement approved optimizations with full documentation.
-
-### CRITICAL RULES
-
-1. **User Approval Required**: Get explicit YES before each change
-2. **Document Everything**: Log all commands, outputs, timestamps
-3. **Verify After Each Change**: Confirm resource still works
-4. **One Change at a Time**: Don't batch changes
-5. **Create Documentation File**: `docs/azure-cloud/cost-optimization-{DATE}.md`
-
-### DOCUMENTATION TEMPLATE
-
-```markdown
-# Azure Cost Optimization - {DATE}
-
-## Summary
-- **Initial Cost**: ${BEFORE}/month
-- **Target Cost**: ${AFTER}/month
-- **Expected Savings**: ${SAVINGS}/month ({PERCENTAGE}% reduction)
-
-## Changes Implemented
-
-### Change 1: {DESCRIPTION}
-- **Timestamp**: {ISO_TIMESTAMP}
-- **User Approval**: YES (timestamp)
-- **Command**: 
-  \`\`\`bash
-  {EXACT_COMMAND}
-  \`\`\`
-- **Output**: 
-  \`\`\`
-  {COMMAND_OUTPUT}
-  \`\`\`
-- **Verification**: 
-  - [ ] Resource accessible
-  - [ ] Application functional
-  - [ ] No errors in logs
-- **Actual Savings**: ${AMOUNT}/month
-
-### Change 2: ...
-
-## Lessons Learned
-1. {LESSON_1}
-2. {LESSON_2}
-
-## Final Results
-- **Actual Cost**: ${FINAL}/month
-- **Actual Savings**: ${TOTAL_SAVINGS}/month ({PERCENTAGE}% reduction)
-```
-
-### STEPS FOR EACH CHANGE
-
-1. **Present Change to User**
-   ```
-   I'm ready to implement:
-   
-   Change: Downgrade App Service Plan from P0v3 to B2
-   Expected Savings: $165/month
-   Risk: Medium (will lose VNet integration, staging slots)
-   
-   Command to execute:
-   az appservice plan update --name ashley-cal-plan \
-     --resource-group ashley-cal-rg --sku B2
-   
-   Rollback command (if needed):
-   az appservice plan update --name ashley-cal-plan \
-     --resource-group ashley-cal-rg --sku P0v3
-   
-   Do you approve this change? (YES/NO)
-   ```
-
-2. **Wait for Explicit YES**
-   
-   - If NO: Skip this change, move to next
-   - If YES: Proceed to execution
-
-3. **Execute Command**
-   ```bash
-   az appservice plan update --name {PLAN} --resource-group {RG} --sku B2
-   ```
-   
-   Capture full output.
-
-4. **Verify Change**
-   ```bash
-   # Verify resource updated
-   az appservice plan show --name {PLAN} --resource-group {RG} \
-     --query "{Name:name, SKU:sku.name, State:properties.status}" -o json
-   
-   # Test application endpoint
-   curl -I https://{APP_URL}
-   
-   # Check for errors
-   az webapp log tail --name {APP} --resource-group {RG}
-   ```
-
-5. **Document in File**
-   
-   Add to `docs/azure-cloud/cost-optimization-{DATE}.md`
-
-6. **Calculate Actual Savings**
-   
-   Wait 24 hours, then query costs again to confirm savings.
-
-### SUCCESS CRITERIA
-- All approved changes executed successfully
-- All changes verified and working
-- Complete documentation file created
-- Actual savings calculated and documented
-- Lessons learned captured
-
-### REPORT BACK
-```javascript
-seekMentoring({
-  workflowType: "cost-optimization",
-  issueNumber: "{issue_number}",
-  currentPhase: "execute-changes",
-  status: "complete",
-  findings: {
-    changesAttempted: 3,
-    changesSuccessful: 2,
-    changesFailed: 1,
-    changes: [
-      {
-        description: "App Service Plan P0v3 → B2",
-        status: "SUCCESS",
-        savings: 165,
-        timestamp: "2026-02-05T10:30:00Z"
-      },
-      {
-        description: "Key Vault cache TTL 5min → 30min",
-        status: "SUCCESS",
-        savings: 5,
-        timestamp: "2026-02-05T10:45:00Z"
-      },
-      {
-        description: "Cosmos DB free tier",
-        status: "FAILED",
-        reason: "vCore MongoDB not eligible for free tier",
-        timestamp: "2026-02-05T11:00:00Z"
-      }
-    ],
-    totalSavings: 170,
-    documentationFile: "docs/azure-cloud/cost-optimization-2026-02-05.md",
-    lessonsLearned: [
-      "vCore Cosmos DB not eligible for free tier (RU-based only)",
-      "Cache extension is safe for OAuth tokens",
-      "Always verify resource types before optimization"
-    ]
-  }
-})
-```
-
----
-
-## COMMON COST DRIVERS & OPTIMIZATIONS
-
-### App Service Plans
-
-**Cost Drivers**:
-- Premium tiers (P0v3, P1v3, P2v3): $220-$880/month
-- Often over-provisioned for actual traffic
-
-**Optimization Strategies**:
-1. **Analyze Traffic**:
-   ```bash
-   az monitor metrics list --resource {RESOURCE_ID} \
-     --metric "Requests" --start-time {START} --end-time {END}
-   ```
-
-2. **Check Feature Usage**:
-   - VNet integration: Required?
-   - Staging slots: Used?
-   - Auto-scale: Needed?
-
-3. **Tier Comparison**:
-   | Tier | vCPU | RAM | Cost | Use Case |
-   |------|------|-----|------|----------|
-   | P0v3 | 1 | 4GB | $220 | Production with premium features |
-   | B2 | 2 | 3.5GB | $55 | Low-traffic production |
-   | B1 | 1 | 1.75GB | $13 | Development/staging |
-
-4. **Downgrade Command**:
-   ```bash
-   az appservice plan update --name {PLAN} --resource-group {RG} --sku B2
-   ```
-
-### Cosmos DB
-
-**Cost Drivers**:
-- vCore-based: $80-$200/month minimum
-- RU-based: $24/month minimum (or free tier)
-
-**Optimization Strategies**:
-1. **Check Eligibility for Free Tier**:
-   - Only RU-based Cosmos DB
-   - Not vCore MongoDB
-   - One per subscription
-
-2. **Verify Connection Pooling**:
-   ```javascript
-   // Good: Singleton with connection pooling
-   const client = new MongoClient(uri, { maxPoolSize: 10 });
-   
-   // Bad: New connection per request
-   app.get('/', async (req, res) => {
-     const client = new MongoClient(uri); // ❌ Don't do this
-   });
-   ```
-
-3. **Check for Proper Singleton**:
-   ```javascript
-   // Good: Module-level singleton
-   let dbInstance = null;
-   export async function getDb() {
-     if (!dbInstance) {
-       dbInstance = await client.db();
-     }
-     return dbInstance;
-   }
-   ```
-
-### Key Vault
-
-**Cost Drivers**:
-- Operations: $0.03 per 10,000 operations
-- Can add up with frequent secret retrieval
-
-**Optimization Strategies**:
-1. **Analyze Operation Count**:
-   ```bash
-   az monitor metrics list --resource {KV_RESOURCE_ID} \
-     --metric "ServiceApiHit" --aggregation Total
-   ```
-
-2. **Check for Caching**:
-   ```javascript
-   // Good: Cache secrets with TTL
-   const cache = new Map();
-   async function getSecret(name) {
-     if (cache.has(name) && !isExpired(cache.get(name))) {
-       return cache.get(name).value;
-     }
-     const secret = await keyVaultClient.getSecret(name);
-     cache.set(name, { value: secret, expires: Date.now() + TTL });
-     return secret;
-   }
-   
-   // Bad: Fetch every time
-   async function getSecret(name) {
-     return await keyVaultClient.getSecret(name); // ❌ No caching
-   }
-   ```
-
-3. **Extend Cache TTL**:
-   - OAuth tokens: Valid 1 hour → 30min cache is safe
-   - Connection strings: Rarely change → 1 hour cache is safe
-   - API keys: Rarely change → 1 hour cache is safe
-
-### Storage Accounts
-
-**Cost Drivers**:
-- Hot tier: $0.0184/GB/month
-- Cool tier: $0.01/GB/month
-- Archive tier: $0.00099/GB/month
-
-**Optimization Strategies**:
-1. **Analyze Access Patterns**:
-   ```bash
-   az storage blob list --account-name {ACCOUNT} --container-name {CONTAINER} \
-     --query "[].{Name:name, LastModified:properties.lastModified, \
-              AccessTier:properties.blobTier}" -o table
-   ```
-
-2. **Implement Lifecycle Policies**:
-   ```json
-   {
-     "rules": [
-       {
-         "name": "move-to-cool",
-         "type": "Lifecycle",
-         "definition": {
-           "actions": {
-             "baseBlob": {
-               "tierToCool": {
-                 "daysAfterModificationGreaterThan": 30
-               }
-             }
-           }
-         }
-       }
-     ]
-   }
-   ```
-
----
-
-## REAL-WORLD EXAMPLE
-
-### Ashley Calendar AI Project
-
-**Initial State**:
-- Monthly Cost: $344
-- App Service Plan: P0v3 ($220/month)
-- Cosmos DB: vCore MongoDB ($80/month)
-- Key Vault: ~10,000 operations/day ($3-5/month)
-- Storage: Minimal
-
-**Optimizations Implemented**:
-
-1. **App Service Plan: P0v3 → B2**
-   - Savings: $165/month
-   - Risk: Medium
-   - Verification: Traffic <1000 req/day, no premium features used
-   - Result: ✅ SUCCESS
-
-2. **Key Vault Cache: 5min → 30min TTL**
-   - Savings: $3-5/month
-   - Risk: Low
-   - Verification: OAuth tokens valid 1 hour
-   - Result: ✅ SUCCESS
-
-3. **Cosmos DB Free Tier**
-   - Savings: $80/month (attempted)
-   - Risk: Low
-   - Result: ❌ FAILED (vCore not eligible)
-
-**Final Results**:
-- New Monthly Cost: $119
-- Actual Savings: $225/month (65% reduction)
-- Code Quality: Already optimized (connection pooling, caching, circuit breakers)
-
-**Lessons Learned**:
-1. vCore Cosmos DB not eligible for free tier (RU-based only)
-2. Cache extension is safe for OAuth tokens
-3. Code-level optimizations sometimes more effective than infrastructure
-4. Always verify resource types before optimization
-
----
-
-## SUCCESS CRITERIA
-
-- [ ] Azure CLI authenticated
-- [ ] Cost data gathered across all dimensions
-- [ ] Optimization opportunities identified with savings estimates
-- [ ] Actions prioritized by savings vs risk
-- [ ] User approval obtained for each change
-- [ ] Changes executed and verified
-- [ ] Complete documentation file created
-- [ ] Actual savings calculated and confirmed
-- [ ] Lessons learned captured
-
-## NOTES
-
-- **Agent Limitation**: Cannot authenticate interactively - user must run `az login`
-- **Safety First**: Always get explicit user approval before changes
-- **Documentation**: Full audit trail enables learning and rollback
-- **Verification**: Test after each change to catch issues early
-- **Learning**: Capture lessons learned for future optimizations
-- **Real-World Tested**: Successfully reduced costs by 65% in production