---
name: 'Deployment Pattern Validation'
description: 'Validates pattern schemas, detection logic, bootstrap tool, deployment readiness, and documentation for all infrastructure patterns'
on:
  pull_request:
    paths:
      - 'patterns/**'
      - 'src/tools/bootstrap-validation-loop-tool.ts'
      - 'src/tools/deployment-readiness-tool.ts'
      - 'src/utils/pattern-loader.ts'
  push:
    branches:
      - main
  workflow_dispatch:
permissions:
  issues: read
  pull-requests: read
safe-outputs:
  create-issue:
    title-prefix: '[pattern-validation]'
  add-comment:
tools:
  bash: true
  github:
    toolsets: [issues, pull_requests]
network:
  allowed:
    - defaults
    - node
---

# Deployment Pattern Validation

You validate the deployment pattern framework: pattern schemas, automatic detection logic, the bootstrap validation tool, deployment readiness checks, and pattern documentation completeness.

## Context

The mcp-adr-analysis-server includes a **Validated Patterns Framework** in `patterns/infrastructure/`. These YAML patterns are authoritative deployment templates that LLMs query for platform-specific guidance.

**Available patterns**:

- `kubernetes.yaml` — Container orchestration with kubectl
- `firebase.yaml` — Production Firebase serverless deployment
- `firebase-emulators.yaml` — Local Firebase testing (emulator-first workflow)

**Each pattern must have**:

- `authoritativeSources` — URLs with priority (1-10) for LLMs to query
- `deploymentPhases` — Ordered deployment steps with commands
- `validationChecks` — Critical checks with remediation steps
- `detectionHints` — Files/patterns for automatic detection with confidence scores

**Key tools**:

- `bootstrap-validation-loop-tool.ts` — Auto-detects patterns based on project files
- `deployment-readiness-tool.ts` — Zero-tolerance validation with hard blocking on failures

## Validation Steps

### Step 0: Install Dependencies

Install build tools required for native module compilation (e.g., tree-sitter), then install npm dependencies with error-tolerant fallbacks.

```bash
# Install build tools for native modules (requires sudo)
sudo apt-get update -qq && sudo apt-get install -y build-essential python3 || echo "⚠️ Could not install build tools (may already be present)"

# Install npm dependencies with fallback
if ! npm ci; then
  echo "⚠️ npm ci failed, falling back to npm install..."
  npm install
fi

# Rebuild tree-sitter native bindings (non-blocking)
echo "🔨 Rebuilding tree-sitter native bindings..."
if ! npm rebuild tree-sitter; then
  echo "⚠️ Tree-sitter rebuild failed, but continuing (tests handle graceful fallback)"
fi
```

If `npm` is not available or both install commands fail, you can still run the structural validation steps (Steps 3 and 6) using `grep` and shell commands directly.

### Step 1: Run Pattern Schema Validation

```bash
npm run validate:patterns
```

If this command is not available (e.g., npm install failed), proceed to manual validation in Step 3.

### Step 2: Test Pattern Detection

```bash
npm test -- tests/utils/pattern-loader.test.ts --verbose
```

If npm/Jest is unavailable, skip to Step 3 for manual pattern validation.

### Step 3: Validate All Infrastructure Patterns

Load and validate each pattern file programmatically:

```bash
node -e "
  import { loadDeploymentPattern } from './dist/src/utils/pattern-loader.js';
  import fs from 'fs';
  import path from 'path';

  const patternsDir = './patterns/infrastructure';
  const patterns = fs.readdirSync(patternsDir)
    .filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));

  console.log('Found patterns:', patterns);

  let allValid = true;
  for (const pattern of patterns) {
    try {
      const patternName = path.basename(pattern, path.extname(pattern));
      const loaded = loadDeploymentPattern(patternName);

      if (!loaded.authoritativeSources || loaded.authoritativeSources.length === 0) {
        console.error(patternName + ': Missing authoritativeSources');
        allValid = false;
        continue;
      }

      if (!loaded.deploymentPhases || loaded.deploymentPhases.length === 0) {
        console.error(patternName + ': Missing deploymentPhases');
        allValid = false;
        continue;
      }

      if (!loaded.validationChecks) {
        console.error(patternName + ': Missing validationChecks');
        allValid = false;
        continue;
      }

      console.log(patternName + ': Valid');
    } catch (error) {
      console.error(patternName + ':', error.message);
      allValid = false;
    }
  }

  if (!allValid) {
    process.exit(1);
  }

  console.log('All patterns validated successfully');
"
```

### Step 4: Test Bootstrap Validation Tool

```bash
npm test -- tests/tools/bootstrap-validation-loop-tool.test.ts --verbose
```

If npm/Jest is unavailable, skip to Step 6 for structural validation using shell commands.

### Step 5: Test Deployment Readiness Tool

```bash
npm test -- tests/tools/deployment-readiness-tool.test.ts --verbose
```

If npm/Jest is unavailable, skip to Step 6 for structural validation using shell commands.

### Step 6: Validate Pattern Documentation Completeness

For each pattern file in `patterns/infrastructure/*.yaml`, verify it contains the required sections:

```bash
for pattern in patterns/infrastructure/*.yaml; do
  echo "Checking $pattern..."

  if ! grep -q "authoritativeSources" "$pattern"; then
    echo "Missing authoritativeSources in $pattern"
    exit 1
  fi

  if ! grep -q "deploymentPhases" "$pattern"; then
    echo "Missing deploymentPhases in $pattern"
    exit 1
  fi

  if ! grep -q "detectionHints" "$pattern"; then
    echo "Missing detectionHints in $pattern"
    exit 1
  fi

  echo "$pattern validated"
done

echo "All pattern documentation validated"
```

## On Failure

If any step fails:

1. **For PR events**: Add a comment to the PR with:
   - Which pattern(s) failed validation
   - Which required section is missing or malformed
   - Link to the pattern YAML structure documentation

2. **For push/dispatch events**: Create an issue:

**Title**: `[pattern-validation] {pattern name}: {failure description}`

**Body**:

```markdown
## Deployment Pattern Validation Failure

### Patterns Validated

| Pattern                 | Status      | Issue          |
| ----------------------- | ----------- | -------------- |
| kubernetes.yaml         | {pass/fail} | {issue if any} |
| firebase.yaml           | {pass/fail} | {issue if any} |
| firebase-emulators.yaml | {pass/fail} | {issue if any} |

### Validation Steps

| Step                           | Status      |
| ------------------------------ | ----------- |
| Schema validation              | {pass/fail} |
| Pattern detection tests        | {pass/fail} |
| Infrastructure pattern loading | {pass/fail} |
| Bootstrap validation tool      | {pass/fail} |
| Deployment readiness tool      | {pass/fail} |
| Documentation completeness     | {pass/fail} |

### Failure Details

{full error output}

### Recommended Fix

1. {step 1}
2. {step 2}

---

_Generated by Deployment Pattern Validation agentic workflow_
```

## On Success

- **For PR events**: Add a comment confirming all patterns validated successfully, listing each pattern
- **For push/dispatch events**: No issue needed

---

_Replaces: .github/agents/deployment-pattern-validation.yml_
