Resolve merge conflicts in ContentService.cs and Web.csproj

- Merged distributed caching and Redis integration from main branch
- Kept image processing functionality from feature branch
- Combined constructor parameters to include both IDistributedCache and IImageService
- Added InvalidateTipsCacheAsync method to satisfy interface requirements
- Updated package references to include both Azure Storage and Redis packages

Author: csharpfritz

.github/copilot-instructions.md

@@ -10,11 +10,74 @@ This is "Copilot That Jawn" - a comprehensive ASP.NET Core web application that
 
 ## Technology Stack
 - **Framework**: ASP.NET Core 9.0+ with Razor Pages
-- **Architecture**: Razor Pages application with MVC controllers for complex operations
+- **Architecture**: .NET Aspire cloud-native application stack with Razor Pages application and MVC controllers for complex operations
+- **Orchestration**: .NET Aspire AppHost for service orchestration and configuration
 - **Content Storage**: Markdown files in Content/ directory for tips, tutorials, and guides
 - **Database**: Entity Framework Core (SQL Server or SQLite for development) for dynamic data
 - **Frontend**: Bootstrap 5, modern responsive design with CSS Grid/Flexbox
 - **JavaScript**: Vanilla JS with modern ES6+ features, minimal dependencies
+- **Cloud Services**: Azure integration through .NET Aspire service defaults and components
+
+## .NET Aspire Architecture
+
+This application is built using .NET Aspire, Microsoft's cloud-native application stack that provides a consistent, opinionated set of tools and patterns for building observable, production-ready apps.
+
+### Aspire Project Structure
+```
+├── AppHost/                 # .NET Aspire orchestration project
+│   ├── AppHost.cs          # Application composition and service configuration
+│   ├── appsettings.json    # Aspire host configuration
+│   └── infra/              # Infrastructure templates for deployment
+├── Web/                    # Main web application project
+├── ServiceDefaults/        # Shared service configuration and extensions
+├── ContentLoader/          # Background service for content processing
+└── Shared/                 # Shared models and utilities
+```
+
+### Key Aspire Components Used
+- **Service Discovery**: Automatic service discovery and configuration
+- **Service Defaults**: Shared telemetry, health checks, and service configuration
+- **Resource Management**: Simplified resource provisioning and management
+- **Observability**: Built-in logging, metrics, and distributed tracing
+- **Development Dashboard**: Real-time monitoring and debugging during development
+
+### Aspire Development Best Practices
+
+#### AppHost Configuration
+- Define all services and their dependencies in `AppHost.cs`
+- Use environment-specific configuration for different deployment targets
+- Leverage Aspire's built-in resource templates for databases, caching, messaging
+- Configure service-to-service communication through Aspire's service discovery
+
+#### Service Defaults Integration
+- All projects should reference the `ServiceDefaults` project
+- Use `builder.AddServiceDefaults()` in each service's `Program.cs`
+- Implement consistent logging, health checks, and telemetry across services
+- Follow Aspire's conventions for configuration and dependency injection
+
+#### Running the Application
+- **Primary Development Command**: `dotnet run --project AppHost` 
+- **Alternative**: Use `dotnet watch run --project AppHost` for development with hot reload
+- **Aspire Dashboard**: Access the development dashboard at the URL shown in console output
+- **Service Monitoring**: Use the Aspire dashboard to monitor service health, logs, and metrics
+
+#### Resource Management
+- Define infrastructure requirements in the AppHost project
+- Use Aspire's resource provisioning for local development dependencies
+- Leverage infrastructure templates in `infra/` directory for cloud deployment
+- Configure connection strings and service endpoints through Aspire's configuration system
+
+#### Testing with Aspire
+- Use Aspire's testing utilities for integration tests
+- Test service communication through Aspire's service discovery
+- Validate configuration and resource dependencies
+- Implement health checks for all services
+
+### Deployment Considerations
+- Aspire applications can be deployed to various cloud platforms
+- Infrastructure templates generate appropriate deployment artifacts
+- Service configuration is managed through Aspire's configuration system
+- Observability and monitoring are built-in through Aspire's telemetry
 
 ## Project Structure Guidelines
 
@@ -198,22 +261,30 @@ Content/
 ### Development Workflow Best Practices
 
 #### Running and Testing the Application
-- **Prefer `dotnet watch`**: Always use `dotnet watch run` for development instead of manually building, running, stopping, and restarting the application
-- **Hot Reload Benefits**: `dotnet watch` provides automatic rebuilding and browser refresh when files change, significantly improving development efficiency
-- **Recommended Commands**:
-  - `dotnet watch run` - Start the application with hot reload
-  - `dotnet watch test` - Run tests with automatic re-execution on file changes
-  - `dotnet watch build` - Build with automatic rebuilding on changes
-
-#### File Monitoring
-- `dotnet watch` automatically monitors C# files, Razor pages, CSS, JavaScript, and other static assets
-- Changes trigger automatic compilation and browser refresh
-- Reduces context switching and speeds up the development cycle
+- **Primary Development Command**: `dotnet run --project AppHost` - Starts the entire Aspire application stack
+- **With Hot Reload**: `dotnet watch run --project AppHost` - Starts with automatic rebuilding and browser refresh
+- **Aspire Dashboard**: Monitor services, logs, and metrics through the Aspire development dashboard
+- **Individual Service Testing**: Use `dotnet test` in specific project directories for unit tests
+- **Integration Testing**: Run full stack tests using Aspire's testing framework
+
+#### Aspire-Specific Development Workflow
+- **Service Orchestration**: All services are managed through the AppHost project
+- **Configuration Management**: Use Aspire's configuration system for service settings and connection strings
+- **Service Discovery**: Services communicate through Aspire's built-in service discovery
+- **Observability**: Monitor application performance through the Aspire dashboard during development
+
+#### File Monitoring and Hot Reload
+- Aspire's `dotnet watch` automatically monitors all projects in the application stack
+- Changes to any service trigger appropriate rebuilds and restarts
+- The Aspire dashboard provides real-time feedback on service status during development
+- Static assets (CSS, JS) are monitored and trigger browser refresh automatically
 
 #### Development Environment Setup
-- Ensure the development environment is configured for optimal `dotnet watch` performance
-- Use the `--verbose` flag for debugging watch issues: `dotnet watch run --verbose`
-- Configure file exclusions in `.csproj` if needed to avoid unnecessary rebuilds
+- Ensure .NET 9.0+ SDK is installed for Aspire support
+- Use `dotnet run --project AppHost` as the primary development command
+- Configure the Aspire dashboard for optimal monitoring during development
+- Set up appropriate logging levels in `appsettings.Development.json` for each service
+- Use environment variables through Aspire's configuration system rather than direct file configuration
 
 ## Content Strategy
 

.github/workflows/azure-dev.yml

@@ -11,6 +11,8 @@ on:
     # Exclude Content folder changes to avoid unnecessary deployments
     paths-ignore:
       - 'Content/**'
+      - '.github/**'
+      - 'docs/*'
 
 # Set up permissions for deploying with secretless Azure federated credentials
 # https://learn.microsoft.com/en-us/azure/developer/github/connect-from-azure?tabs=azure-portal%2Clinux#set-up-azure-login-with-openid-connect-authentication
@@ -29,6 +31,7 @@ jobs:
       AZURE_ENV_NAME: ${{ vars.AZURE_ENV_NAME }}
       AZURE_LOCATION: ${{ vars.AZURE_LOCATION }}
       CACHE_REFRESH_API_KEY: ${{ secrets.CACHE_REFRESH_API_KEY }}
+      AZURE_REDIS: ${{ secrets.AZURE_REDIS }}
 
     steps:
       - name: Checkout
@@ -39,7 +42,6 @@ jobs:
         uses: actions/setup-dotnet@v4
         with:
           dotnet-version: | 
-            8.x.x
             9.x.x
 
       - name: Log in with Azure (Federated Credentials)

.github/workflows/cleanup-container-images.yml

@@ -0,0 +1,120 @@
+name: Cleanup Container Images
+
+# Run daily at 2 AM UTC to clean up old container images
+on:
+  schedule:
+    - cron: '0 2 * * *'  # Daily at 2 AM UTC
+  workflow_dispatch:     # Allow manual triggering
+    inputs:
+      dry_run:
+        description: 'Dry run mode (show what would be deleted without actually deleting)'
+        required: false
+        default: 'false'
+        type: boolean
+
+# Set up permissions for Azure authentication
+permissions:
+  id-token: write
+  contents: read
+  packages: write
+
+jobs:
+  cleanup-images:
+    runs-on: ubuntu-latest
+    env:
+      AZURE_CLIENT_ID: ${{ vars.AZURE_CLIENT_ID }}
+      AZURE_TENANT_ID: ${{ vars.AZURE_TENANT_ID }}
+      AZURE_SUBSCRIPTION_ID: ${{ vars.AZURE_SUBSCRIPTION_ID }}
+      AZURE_ENV_NAME: ${{ vars.AZURE_ENV_NAME }}
+      AZURE_LOCATION: ${{ vars.AZURE_LOCATION }}
+
+    steps:
+      - name: Install Azure CLI
+        run: |
+          curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash
+      
+      - name: Log in with Azure (Federated Credentials)
+        uses: azure/login@v2
+        with:
+          client-id: ${{ env.AZURE_CLIENT_ID }}
+          tenant-id: ${{ env.AZURE_TENANT_ID }}
+          subscription-id: ${{ env.AZURE_SUBSCRIPTION_ID }}
+      
+      - name: Get Azure Container Registry Name
+        id: get-acr
+        run: |
+          # Get the resource group name
+          rg_name="rg-${{ env.AZURE_ENV_NAME }}"
+          echo "Resource group: $rg_name"
+          
+          # Verify the resource group exists
+          if ! az group show --name "$rg_name" >/dev/null 2>&1; then
+            echo "Resource group '$rg_name' not found. Skipping cleanup."
+            echo "acr_name=" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+          
+          # Get the ACR name from the resource group
+          acr_name=$(az acr list --resource-group "$rg_name" --query "[0].name" --output tsv 2>/dev/null)
+          
+          if [ -z "$acr_name" ] || [ "$acr_name" = "null" ]; then
+            echo "No Azure Container Registry found in resource group '$rg_name'."
+            echo "acr_name=" >> $GITHUB_OUTPUT
+          else
+            echo "Found ACR: $acr_name"
+            echo "acr_name=$acr_name" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Cleanup Old Container Images
+        run: |
+          acr_name="${{ steps.get-acr.outputs.acr_name }}"
+          dry_run="${{ github.event.inputs.dry_run || 'false' }}"
+          
+          if [ -z "$acr_name" ]; then
+            echo "No Azure Container Registry found. Skipping cleanup."
+            exit 0
+          fi
+          
+          echo "Starting container image cleanup for ACR: $acr_name"
+          echo "Retention policy: Keep 5 most recent images per repository"
+          
+          # Get all repositories in the ACR
+          repositories=$(az acr repository list --name "$acr_name" --output tsv 2>/dev/null)
+          
+          if [ -z "$repositories" ]; then
+            echo "No repositories found in ACR. Nothing to clean up."
+            exit 0
+          fi
+          
+          echo "Found repositories: $(echo "$repositories" | wc -l)"
+          
+          # Build the purge command with filters for each repository
+          PURGE_FILTERS=""
+          for repo in $repositories; do
+            PURGE_FILTERS="$PURGE_FILTERS --filter '$repo:.*'"
+          done
+          
+          # Construct the purge command
+          PURGE_CMD="acr purge $PURGE_FILTERS --ago 0d --keep 5 --untagged"
+          
+          if [ "$dry_run" = "true" ]; then
+            PURGE_CMD="$PURGE_CMD --dry-run"
+            echo "🔍 DRY RUN MODE: Will show what would be deleted without actually deleting"
+          fi
+          
+          echo "Running purge command..."
+          # Set longer timeout (1 hour) for large registries
+          az acr run \
+            --cmd "$PURGE_CMD" \
+            --registry "$acr_name" \
+            --timeout 3600 \
+            /dev/null
+          
+          exit_code=$?
+          
+          if [ $exit_code -eq 0 ]; then
+            echo "✅ Cleanup process completed successfully!"
+          else
+            echo "❌ Cleanup process failed with exit code $exit_code"
+            exit $exit_code
+          fi