@deftai/directive-content 0.55.0

package/deployments/azure/via-functions.md

@@ -0,0 +1,552 @@
+# Deploy via Azure Functions
+
+Deploy serverless functions using Azure Functions. Event-driven compute that scales automatically with consumption-based pricing.
+
+## Overview
+
+Azure Functions provides:
+- **Serverless Compute**: No infrastructure management
+- **Event-Driven**: Trigger from HTTP, timers, queues, and more
+- **Multiple Languages**: C#, JavaScript, Python, Java, PowerShell
+- **Durable Functions**: Stateful workflows
+- **Flexible Hosting**: Consumption, Premium, and Dedicated plans
+
+## Prerequisites
+
+- Azure account with subscription
+- Azure Functions Core Tools installed
+- Azure CLI installed
+- Runtime installed (Node.js, Python, etc.)
+
+## Quick Start
+
+### 1. Install Azure Functions Core Tools
+
+```bash
+# macOS
+brew tap azure/functions
+brew install azure-functions-core-tools@4
+
+# Or via npm
+npm install -g azure-functions-core-tools@4
+
+# Verify
+func --version
+```
+
+### 2. Create Function App
+
+```bash
+# Create local project
+func init myapp --python
+
+cd myapp
+
+# Create HTTP trigger function
+func new --name HttpTrigger --template "HTTP trigger"
+```
+
+### 3. Test Locally
+
+```bash
+# Start local runtime
+func start
+
+# Test function
+curl http://localhost:7071/api/HttpTrigger
+```
+
+### 4. Deploy to Azure
+
+```bash
+# Login
+az login
+
+# Create resource group
+az group create --name myapp-rg --location eastus
+
+# Create storage account (required)
+az storage account create \
+  --name myappstorage \
+  --resource-group myapp-rg \
+  --location eastus \
+  --sku Standard_LRS
+
+# Create Function App
+az functionapp create \
+  --name myapp \
+  --resource-group myapp-rg \
+  --consumption-plan-location eastus \
+  --runtime python \
+  --runtime-version 3.11 \
+  --functions-version 4 \
+  --storage-account myappstorage
+
+# Deploy
+func azure functionapp publish myapp
+```
+
+## Language-Specific Examples
+
+### Python Function
+
+```python
+# function_app.py
+import azure.functions as func
+import logging
+
+app = func.FunctionApp()
+
+@app.function_name(name="HttpTrigger")
+@app.route(route="hello", auth_level=func.AuthLevel.ANONYMOUS)
+def http_trigger(req: func.HttpRequest) -> func.HttpResponse:
+    logging.info('Python HTTP trigger function processed a request.')
+    
+    name = req.params.get('name')
+    if not name:
+        try:
+            req_body = req.get_json()
+            name = req_body.get('name')
+        except ValueError:
+            pass
+    
+    if name:
+        return func.HttpResponse(f"Hello, {name}!")
+    else:
+        return func.HttpResponse(
+            "Please pass a name on the query string or in the request body",
+            status_code=400
+        )
+
+@app.function_name(name="TimerTrigger")
+@app.schedule(schedule="0 */5 * * * *", arg_name="timer")
+def timer_trigger(timer: func.TimerRequest) -> None:
+    logging.info('Timer trigger function ran')
+```
+
+### Node.js Function
+
+```javascript
+// src/functions/httpTrigger.js
+const { app } = require('@azure/functions');
+
+app.http('httpTrigger', {
+    methods: ['GET', 'POST'],
+    authLevel: 'anonymous',
+    handler: async (request, context) => {
+        context.log('HTTP trigger function processed a request');
+        
+        const name = request.query.get('name') || await request.text() || 'World';
+        
+        return {
+            status: 200,
+            body: `Hello, ${name}!`
+        };
+    }
+});
+
+// Timer trigger
+app.timer('timerTrigger', {
+    schedule: '0 */5 * * * *',
+    handler: (myTimer, context) => {
+        context.log('Timer trigger function ran');
+    }
+});
+```
+
+### C# Function
+
+```csharp
+// HttpTrigger.cs
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Extensions.Logging;
+
+namespace MyApp
+{
+    public class HttpTrigger
+    {
+        private readonly ILogger<HttpTrigger> _logger;
+
+        public HttpTrigger(ILogger<HttpTrigger> logger)
+        {
+            _logger = logger;
+        }
+
+        [Function("HttpTrigger")]
+        public IActionResult Run(
+            [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequest req)
+        {
+            _logger.LogInformation("C# HTTP trigger function processed a request");
+            
+            string name = req.Query["name"];
+            
+            return new OkObjectResult($"Hello, {name ?? "World"}!");
+        }
+    }
+}
+```
+
+## Triggers and Bindings
+
+### HTTP Trigger
+
+```python
+@app.route(route="api/users/{id}", methods=["GET"])
+def get_user(req: func.HttpRequest) -> func.HttpResponse:
+    user_id = req.route_params.get('id')
+    return func.HttpResponse(f"User ID: {user_id}")
+```
+
+### Timer Trigger
+
+```python
+# Runs every day at 2 AM
+@app.schedule(schedule="0 0 2 * * *", arg_name="timer")
+def daily_job(timer: func.TimerRequest) -> None:
+    logging.info('Daily job executed')
+```
+
+### Queue Trigger
+
+```python
+@app.queue_trigger(
+    arg_name="msg",
+    queue_name="myqueue",
+    connection="AzureWebJobsStorage"
+)
+def queue_processor(msg: func.QueueMessage) -> None:
+    logging.info(f'Processing queue message: {msg.get_body().decode()}')
+```
+
+### Blob Trigger
+
+```python
+@app.blob_trigger(
+    arg_name="blob",
+    path="container/{name}",
+    connection="AzureWebJobsStorage"
+)
+def blob_processor(blob: func.InputStream) -> None:
+    logging.info(f'Processing blob: {blob.name}, size: {blob.length} bytes')
+```
+
+### Event Hub Trigger
+
+```python
+@app.event_hub_message_trigger(
+    arg_name="events",
+    event_hub_name="myhub",
+    connection="EventHubConnection"
+)
+def event_hub_processor(events: List[func.EventHubEvent]) -> None:
+    for event in events:
+        logging.info(f'Event: {event.get_body().decode()}')
+```
+
+### Cosmos DB Trigger
+
+```python
+@app.cosmos_db_trigger(
+    arg_name="documents",
+    database_name="mydb",
+    collection_name="mycollection",
+    connection_string_setting="CosmosDBConnection",
+    lease_collection_name="leases",
+    create_lease_collection_if_not_exists=True
+)
+def cosmos_processor(documents: func.DocumentList) -> None:
+    for doc in documents:
+        logging.info(f'Document modified: {doc["id"]}')
+```
+
+## Configuration
+
+### Application Settings
+
+```bash
+# Set environment variables
+az functionapp config appsettings set \
+  --name myapp \
+  --resource-group myapp-rg \
+  --settings \
+    APP_ENV=production \
+    DATABASE_URL="@Microsoft.KeyVault(SecretUri=...)"
+```
+
+### Connection Strings
+
+```bash
+az functionapp config connection-string set \
+  --name myapp \
+  --resource-group myapp-rg \
+  --connection-string-type SQLAzure \
+  --settings \
+    DefaultConnection="Server=..."
+```
+
+## Durable Functions
+
+### Orchestrator Function
+
+```python
+import azure.durable_functions as df
+
+@app.orchestration_trigger(context_name="context")
+def orchestrator(context: df.DurableOrchestrationContext):
+    # Chain activities
+    result1 = yield context.call_activity("Activity1", "input1")
+    result2 = yield context.call_activity("Activity2", result1)
+    result3 = yield context.call_activity("Activity3", result2)
+    
+    return result3
+
+@app.activity_trigger(input_name="input")
+def activity1(input: str) -> str:
+    return f"Activity1: {input}"
+```
+
+### Fan-out/Fan-in Pattern
+
+```python
+@app.orchestration_trigger(context_name="context")
+def fan_out_fan_in(context: df.DurableOrchestrationContext):
+    tasks = []
+    
+    # Fan-out: start parallel activities
+    for i in range(10):
+        tasks.append(context.call_activity("ProcessItem", i))
+    
+    # Fan-in: wait for all to complete
+    results = yield context.task_all(tasks)
+    
+    total = sum(results)
+    return total
+```
+
+## Hosting Plans
+
+### Consumption Plan (Default)
+
+```bash
+az functionapp create \
+  --name myapp \
+  --resource-group myapp-rg \
+  --consumption-plan-location eastus \
+  --runtime python \
+  --storage-account myappstorage
+```
+
+### Premium Plan
+
+```bash
+# Create Premium plan
+az functionapp plan create \
+  --name myapp-plan \
+  --resource-group myapp-rg \
+  --location eastus \
+  --sku EP1
+
+# Create function app on Premium plan
+az functionapp create \
+  --name myapp \
+  --resource-group myapp-rg \
+  --plan myapp-plan \
+  --runtime python \
+  --storage-account myappstorage
+```
+
+### Dedicated (App Service) Plan
+
+```bash
+# Create App Service plan
+az appservice plan create \
+  --name myapp-plan \
+  --resource-group myapp-rg \
+  --sku B1
+
+# Create function app
+az functionapp create \
+  --name myapp \
+  --resource-group myapp-rg \
+  --plan myapp-plan \
+  --runtime python \
+  --storage-account myappstorage
+```
+
+## CI/CD Integration
+
+### GitHub Actions
+
+```yaml
+# .github/workflows/azure-functions.yml
+name: Deploy to Azure Functions
+
+on:
+  push:
+    branches: [main]
+
+env:
+  AZURE_FUNCTIONAPP_NAME: myapp
+  PYTHON_VERSION: '3.11'
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - uses: actions/checkout@v3
+      
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+      
+      - uses: azure/login@v1
+        with:
+          creds: ${{ secrets.AZURE_CREDENTIALS }}
+      
+      - name: Deploy to Azure Functions
+        uses: Azure/functions-action@v1
+        with:
+          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
+          package: .
+          scm-do-build-during-deployment: true
+```
+
+### Azure DevOps Pipeline
+
+```yaml
+# azure-pipelines.yml
+trigger:
+  - main
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+variables:
+  functionAppName: 'myapp'
+  pythonVersion: '3.11'
+
+steps:
+  - task: UsePythonVersion@0
+    inputs:
+      versionSpec: '$(pythonVersion)'
+  
+  - script: |
+      pip install -r requirements.txt
+    displayName: 'Install dependencies'
+  
+  - task: ArchiveFiles@2
+    inputs:
+      rootFolderOrFile: '$(System.DefaultWorkingDirectory)'
+      includeRootFolder: false
+      archiveType: 'zip'
+      archiveFile: '$(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip'
+  
+  - task: AzureFunctionApp@1
+    inputs:
+      azureSubscription: 'Azure-Subscription'
+      appType: 'functionAppLinux'
+      appName: '$(functionAppName)'
+      package: '$(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip'
+```
+
+## Monitoring
+
+### Application Insights
+
+```bash
+# Enable Application Insights
+az monitor app-insights component create \
+  --app myapp-insights \
+  --location eastus \
+  --resource-group myapp-rg
+
+# Link to Function App
+APPINSIGHTS_KEY=$(az monitor app-insights component show \
+  --app myapp-insights \
+  --resource-group myapp-rg \
+  --query instrumentationKey -o tsv)
+
+az functionapp config appsettings set \
+  --name myapp \
+  --resource-group myapp-rg \
+  --settings \
+    APPINSIGHTS_INSTRUMENTATIONKEY=$APPINSIGHTS_KEY
+```
+
+### View Logs
+
+```bash
+# Stream logs
+func azure functionapp logstream myapp
+
+# Via Azure CLI
+az webapp log tail \
+  --name myapp \
+  --resource-group myapp-rg
+```
+
+## Best Practices
+
+1. **Use Consumption Plan**: For variable workloads
+2. **Enable Application Insights**: Track all invocations
+3. **Async/Await**: Use async functions for I/O operations
+4. **Keep Functions Small**: Single responsibility
+5. **Use Bindings**: Reduce boilerplate code
+6. **Connection Pooling**: Reuse connections across invocations
+7. **Error Handling**: Implement proper retry logic
+8. **Cold Start Optimization**: Use Premium plan if needed
+9. **Security**: Use managed identity for Azure resources
+10. **Testing**: Write unit tests, use local runtime
+
+## Troubleshooting
+
+### Function Not Triggering
+
+```bash
+# Check function status
+az functionapp function show \
+  --name myapp \
+  --resource-group myapp-rg \
+  --function-name HttpTrigger
+
+# View logs
+func azure functionapp logstream myapp
+```
+
+### Performance Issues
+
+```bash
+# Check execution times in Application Insights
+# Consider Premium plan for:
+# - VNet integration
+# - Unlimited execution duration
+# - Pre-warmed instances
+```
+
+## Cost Optimization
+
+```bash
+# Consumption plan: Pay per execution
+# - First 1M executions free
+# - Optimize function duration
+# - Use efficient triggers
+
+# Premium plan: For predictable costs
+# - Pre-warmed instances
+# - No cold starts
+```
+
+## References
+
+- [Azure Functions Documentation](https://docs.microsoft.com/azure/azure-functions/)
+- [Functions Core Tools](https://docs.microsoft.com/azure/azure-functions/functions-run-local)
+- [Durable Functions](https://docs.microsoft.com/azure/azure-functions/durable/)
+- [Functions Pricing](https://azure.microsoft.com/pricing/details/functions/)

package/deployments/cloud-gov/README.md

@@ -0,0 +1,63 @@
+# cloud.gov Deployment Module
+
+Deft-native guidance for cloud.gov deployments, translated from the upstream
+`adhocteam/cloud-gov-instructions` project (MIT License).
+
+## Status
+
+- ! Optional module
+- ~ Good for Deft usage
+- ~ Exportable for Copilot instructions
+
+## Source & Attribution
+
+This module is derived from `adhocteam/cloud-gov-instructions` **v1.1.0**.
+See `deployments/cloud-gov/upstream/` for the pinned upstream snapshot.
+
+License: MIT (see `deployments/cloud-gov/LICENSE.md`).
+
+## Files
+
+| File | Purpose |
+|------|---------|
+| `overview.md` | Repository-level cloud.gov overview |
+| `deployment.md` | Deployment workflow & blue/green guidance |
+| `manifest.md` | Manifest structure and best practices |
+| `services.md` | Managed services and `VCAP_SERVICES` usage |
+| `cicd.md` | CI/CD setup, service accounts, workflows |
+| `security.md` | FedRAMP guidance, NIST control references |
+| `logging.md` | Structured logging & log drains |
+| `agents.md` | Agent behaviors & safety guardrails |
+| `agents/compliance-docs.md` | Compliance documentation agent |
+| `skills/cf-troubleshoot.md` | Troubleshooting skill |
+
+## Tasks
+
+Run these tasks from repo root:
+
+```
+task cloudgov:sync
+task cloudgov:export
+```
+
+### Export Output
+
+Default export target: `.deft/cloud.gov/`
+
+This generates Copilot-compatible files in:
+
+```
+.deft/cloud.gov/
+  .github/
+    copilot-instructions.md
+    instructions/
+    agents/
+    skills/
+  AGENTS.md
+  LICENSE.md
+```
+
+## Notes
+
+- ! Treat `.deft/cloud.gov/` as generated output (do not edit by hand)
+- ~ Update `CLOUDGOV_VERSION` and `CLOUDGOV_EXTRACT_DIR` in `taskfiles/deployments.yml` to bump the pinned version