<?xml version="1.0" encoding="UTF-8"?>
<xs:schema 
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  targetNamespace="https://api.reactor.dev/schema/recipe/v1"
  xmlns:tns="https://api.reactor.dev/schema/recipe/v1"
  elementFormDefault="qualified">

  <!-- ROOT ELEMENT -->
  <xs:element name="recipe" type="tns:RecipeType"/>

  <!-- RECIPE TYPE DEFINITION -->
  <xs:complexType name="RecipeType">
    <xs:annotation>
      <xs:documentation>
        Comprehensive recipe definition including metadata, implementations,
        tests, examples, and architecture. Supports validation and agent processing.
      </xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:element name="metadata" type="tns:MetadataType" minOccurs="1" maxOccurs="1"/>
      <xs:element name="description" type="xs:string" minOccurs="1" maxOccurs="1"/>
      <xs:element name="problem_statement" type="xs:string" minOccurs="1" maxOccurs="1"/>
      <xs:element name="solution_overview" type="xs:string" minOccurs="1" maxOccurs="1"/>
      <xs:element name="use_cases" type="tns:UseCaseList" minOccurs="1" maxOccurs="1"/>
      <xs:element name="implementations" type="tns:ImplementationList" minOccurs="1" maxOccurs="1"/>
      <xs:element name="testing" type="tns:TestSpecification" minOccurs="1" maxOccurs="1"/>
      <xs:element name="examples" type="tns:ExampleList" minOccurs="1" maxOccurs="1"/>
      <xs:element name="architecture" type="tns:ArchitectureSpec" minOccurs="1" maxOccurs="1"/>
      <xs:element name="tradeoffs" type="tns:TradeoffList" minOccurs="0" maxOccurs="1"/>
      <xs:element name="related" type="tns:RelatedRecipeList" minOccurs="0" maxOccurs="1"/>
      <xs:element name="tags" type="tns:TagList" minOccurs="0" maxOccurs="1"/>
      <xs:element name="validation" type="tns:ValidationResult" minOccurs="0" maxOccurs="1"/>
    </xs:sequence>
    <xs:attribute name="schema_version" type="xs:string" fixed="1.0.0" use="required"/>
  </xs:complexType>

  <!-- METADATA TYPE -->
  <xs:complexType name="MetadataType">
    <xs:sequence>
      <xs:element name="id" type="tns:RecipeID"/>
      <xs:element name="name" type="xs:string"/>
      <xs:element name="type" type="tns:RecipeTypeEnum"/>
      <xs:element name="status" type="tns:StatusEnum"/>
      <xs:element name="version" type="tns:SemanticVersion"/>
      <xs:element name="created_date" type="xs:dateTime"/>
      <xs:element name="last_updated" type="xs:dateTime"/>
      <xs:element name="created_by" type="xs:string"/>
      <xs:element name="maintainer" type="xs:string"/>
      <xs:element name="license" type="xs:string"/>
      <xs:element name="languages" type="tns:LanguageList"/>
      <xs:element name="difficulty" type="tns:DifficultyEnum"/>
      <xs:element name="estimated_time_minutes" type="xs:int"/>
      <xs:element name="repository_url" type="xs:anyURI"/>
      <xs:element name="documentation_url" type="xs:anyURI"/>
    </xs:sequence>
  </xs:complexType>

  <!-- SIMPLE TYPES -->
  <xs:simpleType name="RecipeID">
    <xs:restriction base="xs:string">
      <xs:pattern value="recipe-[a-z0-9-]+-\d{3}"/>
    </xs:restriction>
  </xs:simpleType>

  <xs:simpleType name="RecipeTypeEnum">
    <xs:restriction base="xs:string">
      <xs:enumeration value="recipe"/>
      <xs:enumeration value="pattern"/>
      <xs:enumeration value="blueprint"/>
    </xs:restriction>
  </xs:simpleType>

  <xs:simpleType name="StatusEnum">
    <xs:restriction base="xs:string">
      <xs:enumeration value="experimental"/>
      <xs:enumeration value="production"/>
      <xs:enumeration value="deprecated"/>
      <xs:enumeration value="archived"/>
    </xs:restriction>
  </xs:simpleType>

  <xs:simpleType name="DifficultyEnum">
    <xs:restriction base="xs:string">
      <xs:enumeration value="beginner"/>
      <xs:enumeration value="intermediate"/>
      <xs:enumeration value="advanced"/>
    </xs:restriction>
  </xs:simpleType>

  <xs:simpleType name="SemanticVersion">
    <xs:restriction base="xs:string">
      <xs:pattern value="\d+\.\d+\.\d+"/>
    </xs:restriction>
  </xs:simpleType>

  <!-- LANGUAGE LIST -->
  <xs:complexType name="LanguageList">
    <xs:sequence>
      <xs:element name="language" type="tns:ProgrammingLanguage" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>

  <xs:simpleType name="ProgrammingLanguage">
    <xs:restriction base="xs:string">
      <xs:enumeration value="python"/>
      <xs:enumeration value="go"/>
      <xs:enumeration value="rust"/>
      <xs:enumeration value="typescript"/>
      <xs:enumeration value="javascript"/>
      <xs:enumeration value="shell"/>
      <xs:enumeration value="bash"/>
      <xs:enumeration value="c"/>
      <xs:enumeration value="cpp"/>
      <xs:enumeration value="java"/>
      <xs:enumeration value="kotlin"/>
    </xs:restriction>
  </xs:simpleType>

  <!-- IMPLEMENTATION LIST -->
  <xs:complexType name="ImplementationList">
    <xs:sequence>
      <xs:element name="implementation" type="tns:ImplementationType" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="ImplementationType">
    <xs:sequence>
      <xs:element name="language" type="tns:ProgrammingLanguage"/>
      <xs:element name="version" type="tns:SemanticVersion"/>
      <xs:element name="runtime_version" type="xs:string"/>
      <xs:element name="repository_path" type="xs:string"/>
      <xs:element name="main_file" type="xs:string"/>
      <xs:element name="source_code" type="xs:string"/>
      <xs:element name="code_hash" type="xs:string"/>
      <xs:element name="dependencies" type="tns:DependencyList"/>
      <xs:element name="compatibility" type="tns:CompatibilityMatrix"/>
      <xs:element name="checksum_sha256" type="xs:string"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="DependencyList">
    <xs:sequence>
      <xs:element name="dependency" type="tns:DependencyType" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="DependencyType">
    <xs:sequence>
      <xs:element name="name" type="xs:string"/>
      <xs:element name="version" type="xs:string"/>
      <xs:element name="registry" type="xs:string"/>
      <xs:element name="optional" type="xs:boolean" default="false"/>
    </xs:sequence>
  </xs:complexType>

  <!-- TEST SPECIFICATION -->
  <xs:complexType name="TestSpecification">
    <xs:sequence>
      <xs:element name="framework" type="xs:string"/>
      <xs:element name="coverage_percent" type="xs:float"/>
      <xs:element name="test_count" type="xs:int"/>
      <xs:element name="test_files" type="tns:TestFileList"/>
      <xs:element name="execution_time_seconds" type="xs:float"/>
      <xs:element name="last_run_date" type="xs:dateTime"/>
      <xs:element name="test_results" type="tns:TestResults"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="TestResults">
    <xs:sequence>
      <xs:element name="passed" type="xs:int"/>
      <xs:element name="failed" type="xs:int"/>
      <xs:element name="skipped" type="xs:int"/>
      <xs:element name="warnings" type="xs:int"/>
    </xs:sequence>
  </xs:complexType>

  <!-- ARCHITECTURE SPECIFICATION -->
  <xs:complexType name="ArchitectureSpec">
    <xs:sequence>
      <xs:element name="diagram_url" type="xs:anyURI"/>
      <xs:element name="diagram_format" type="tns:DiagramFormat"/>
      <xs:element name="diagram_source" type="xs:string"/>
      <xs:element name="data_flow" type="xs:string"/>
      <xs:element name="component_list" type="tns:ComponentList"/>
      <xs:element name="interaction_model" type="xs:string"/>
    </xs:sequence>
  </xs:complexType>

  <xs:simpleType name="DiagramFormat">
    <xs:restriction base="xs:string">
      <xs:enumeration value="mermaid"/>
      <xs:enumeration value="plantuml"/>
      <xs:enumeration value="graphviz"/>
      <xs:enumeration value="svg"/>
    </xs:restriction>
  </xs:simpleType>

  <!-- EXAMPLE LIST -->
  <xs:complexType name="ExampleList">
    <xs:sequence>
      <xs:element name="example" type="tns:ExampleType" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="ExampleType">
    <xs:sequence>
      <xs:element name="name" type="xs:string"/>
      <xs:element name="description" type="xs:string"/>
      <xs:element name="language" type="tns:ProgrammingLanguage"/>
      <xs:element name="code" type="xs:string"/>
      <xs:element name="expected_output" type="xs:string"/>
      <xs:element name="difficulty" type="tns:DifficultyEnum"/>
    </xs:sequence>
  </xs:complexType>

  <!-- USE CASE LIST -->
  <xs:complexType name="UseCaseList">
    <xs:sequence>
      <xs:element name="use_case" type="tns:UseCaseType" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="UseCaseType">
    <xs:sequence>
      <xs:element name="title" type="xs:string"/>
      <xs:element name="description" type="xs:string"/>
      <xs:element name="scenario" type="xs:string"/>
    </xs:sequence>
  </xs:complexType>

  <!-- TRADEOFF LIST -->
  <xs:complexType name="TradeoffList">
    <xs:sequence>
      <xs:element name="tradeoff" type="tns:TradeoffType" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="TradeoffType">
    <xs:sequence>
      <xs:element name="dimension1" type="xs:string"/>
      <xs:element name="dimension2" type="xs:string"/>
      <xs:element name="description" type="xs:string"/>
      <xs:element name="recommendation" type="xs:string"/>
    </xs:sequence>
  </xs:complexType>

  <!-- RELATED RECIPES -->
  <xs:complexType name="RelatedRecipeList">
    <xs:sequence>
      <xs:element name="related" type="xs:string" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>

  <!-- TAG LIST -->
  <xs:complexType name="TagList">
    <xs:sequence>
      <xs:element name="concept" type="xs:string" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>

  <!-- COMPONENT LIST -->
  <xs:complexType name="ComponentList">
    <xs:sequence>
      <xs:element name="component" type="tns:ComponentType" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="ComponentType">
    <xs:sequence>
      <xs:element name="name" type="xs:string"/>
      <xs:element name="role" type="xs:string"/>
      <xs:element name="responsibility" type="xs:string"/>
    </xs:sequence>
  </xs:complexType>

  <!-- TEST FILE LIST -->
  <xs:complexType name="TestFileList">
    <xs:sequence>
      <xs:element name="test_file" type="xs:string" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>

  <!-- COMPATIBILITY MATRIX -->
  <xs:complexType name="CompatibilityMatrix">
    <xs:sequence>
      <xs:element name="os" type="xs:string" maxOccurs="unbounded"/>
      <xs:element name="architecture" type="xs:string" maxOccurs="unbounded"/>
      <xs:element name="python_versions" type="xs:string" minOccurs="0"/>
      <xs:element name="node_versions" type="xs:string" minOccurs="0"/>
      <xs:element name="rust_versions" type="xs:string" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>

  <!-- VALIDATION RESULT -->
  <xs:complexType name="ValidationResult">
    <xs:sequence>
      <xs:element name="is_valid" type="xs:boolean"/>
      <xs:element name="validation_date" type="xs:dateTime"/>
      <xs:element name="warnings" type="tns:WarningList"/>
      <xs:element name="errors" type="tns:ErrorList"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="WarningList">
    <xs:sequence>
      <xs:element name="warning" type="xs:string" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="ErrorList">
    <xs:sequence>
      <xs:element name="error" type="xs:string" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>

</xs:schema>

openapi: 3.1.0
info:
  title: Reactor Cookbook MCP Server
  version: 1.0.0
  description: >
    Model Context Protocol (MCP) server for Reactor and Cookbook ecosystems.
    Enables LLM agents to discover, retrieve, and validate recipes across
    multiple programming languages.
  contact:
    name: Reactor Team
    url: https://reactor.dev

servers:
  - url: https://mcp.reactor.dev
    description: Production MCP Server
  - url: https://mcp-staging.reactor.dev
    description: Staging Environment

paths:
  /recipes:
    get:
      operationId: list_recipes
      summary: List all recipes with filtering
      parameters:
        - name: language
          in: query
          schema:
            enum: [python, go, rust, typescript, shell]
          description: Filter by programming language
        - name: concept
          in: query
          schema:
            type: string
          description: Filter by concept tag
        - name: difficulty
          in: query
          schema:
            enum: [beginner, intermediate, advanced]
        - name: type
          in: query
          schema:
            enum: [recipe, pattern, blueprint]
        - name: status
          in: query
          schema:
            enum: [experimental, production, deprecated]
        - name: page
          in: query
          schema:
            type: integer
            default: 1
        - name: per_page
          in: query
          schema:
            type: integer
            default: 20
            maximum: 100
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RecipeListResponse'
        '400':
          description: Invalid query parameters
        '429':
          description: Rate limit exceeded
          headers:
            X-RateLimit-Remaining:
              schema:
                type: integer
            X-RateLimit-Reset:
              schema:
                type: integer

  /recipes/{recipe_id}:
    get:
      operationId: get_recipe
      summary: Get full recipe details
      parameters:
        - name: recipe_id
          in: path
          required: true
          schema:
            type: string
            pattern: '^recipe-[a-z0-9-]+-\d{3}$'
        - name: language
          in: query
          schema:
            enum: [python, go, rust, typescript, shell]
          description: Get specific language implementation
        - name: format
          in: query
          schema:
            enum: [json, xml]
            default: json
      responses:
        '200':
          description: Recipe found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Recipe'
            application/xml:
              schema:
                $ref: '#/components/schemas/Recipe'
        '404':
          description: Recipe not found
        '422':
          description: Invalid recipe_id format

  /search:
    post:
      operationId: search_recipes
      summary: Full-text search with AI ranking
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required: [query]
              properties:
                query:
                  type: string
                  minLength: 3
                  maxLength: 500
                languages:
                  type: array
                  items:
                    type: string
                    enum: [python, go, rust, typescript, shell]
                concepts:
                  type: array
                  items:
                    type: string
                min_difficulty:
                  type: string
                  enum: [beginner, intermediate, advanced]
                max_difficulty:
                  type: string
                  enum: [beginner, intermediate, advanced]
                ai_rerank:
                  type: boolean
                  default: true
                  description: Use semantic ranking via embeddings
      responses:
        '200':
          description: Search results
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SearchResults'

  /recipes/{recipe_id}/implementations:
    get:
      operationId: get_implementations
      summary: Get all implementations of a recipe across languages
      parameters:
        - name: recipe_id
          in: path
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Implementations across all languages
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ImplementationMatrix'

  /concepts:
    get:
      operationId: list_concepts
      summary: List all concepts and their recipes
      responses:
        '200':
          description: Concept catalog
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ConceptCatalog'

  /validate:
    post:
      operationId: validate_recipe
      summary: Validate recipe against schema
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Recipe'
      responses:
        '200':
          description: Validation result
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ValidationResult'

components:
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      description: API token authentication

  schemas:
    Recipe:
      type: object
      description: Complete recipe definition
      required:
        - id
        - name
        - type
        - languages
        - implementations
      properties:
        id:
          type: string
          pattern: '^recipe-[a-z0-9-]+-\d{3}$'
        name:
          type: string
        type:
          enum: [recipe, pattern, blueprint]
        status:
          enum: [experimental, production, deprecated]
        languages:
          type: array
          items:
            type: string
        implementations:
          $ref: '#/components/schemas/ImplementationList'
        tests:
          $ref: '#/components/schemas/TestSpecification'
        examples:
          type: array
          items:
            $ref: '#/components/schemas/Example'

    RecipeListResponse:
      type: object
      properties:
        recipes:
          type: array
          items:
            $ref: '#/components/schemas/Recipe'
        total:
          type: integer
        page:
          type: integer
        per_page:
          type: integer
        has_next:
          type: boolean

    SearchResults:
      type: object
      properties:
        results:
          type: array
          items:
            type: object
            properties:
              recipe_id:
                type: string
              name:
                type: string
              relevance_score:
                type: number
                format: float
                minimum: 0
                maximum: 1
              matched_fields:
                type: array
                items:
                  type: string

    ImplementationMatrix:
      type: object
      properties:
        recipe_id:
          type: string
        implementations:
          type: object
          additionalProperties:
            $ref: '#/components/schemas/Implementation'
        comparison:
          type: string
          description: Natural language comparison of implementations

    Implementation:
      type: object
      properties:
        language:
          type: string
        version:
          type: string
        code:
          type: string
        dependencies:
          type: array
          items:
            type: object
            properties:
              name:
                type: string
              version:
                type: string

    TestSpecification:
      type: object
      properties:
        framework:
          type: string
        coverage_percent:
          type: number
        test_count:
          type: integer

    Example:
      type: object
      properties:
        name:
          type: string
        code:
          type: string
        language:
          type: string

    ConceptCatalog:
      type: object
      properties:
        concepts:
          type: object
          additionalProperties:
            type: object
            properties:
              recipes:
                type: array
                items:
                  type: string
              description:
                type: string

    ValidationResult:
      type: object
      properties:
        is_valid:
          type: boolean
        warnings:
          type: array
          items:
            type: string
        errors:
          type: array
          items:
            type: string
        timestamp:
          type: string
          format: date-time

security:
  - BearerAuth: []

{
  "base_id": "appReactorPortfolio",
  "base_name": "Reactor Portfolio",
  "tables": [
    {
      "table_id": "tblKnowledgeIndex",
      "table_name": "Knowledge Index",
      "description": "Unified index of all recipes, patterns, blueprints, and tools",
      "fields": [
        {
          "id": "fldRecipeID",
          "name": "Recipe ID",
          "type": "singleLineText",
          "required": true,
          "unique": true,
          "format": "recipe-[a-z0-9-]+-\\d{3}"
        },
        {
          "id": "fldName",
          "name": "Name",
          "type": "singleLineText",
          "required": true
        },
        {
          "id": "fldType",
          "name": "Type",
          "type": "singleSelect",
          "options": ["recipe", "pattern", "blueprint", "tool"],
          "required": true
        },
        {
          "id": "fldLanguages",
          "name": "Languages",
          "type": "multipleSelect",
          "options": ["python", "go", "rust", "typescript", "shell", "java", "c++"]
        },
        {
          "id": "fldConcepts",
          "name": "Concepts",
          "type": "multipleSelect",
          "options": [
            "concurrency",
            "async",
            "error-handling",
            "resilience",
            "performance",
            "security",
            "testing",
            "deployment"
          ]
        },
        {
          "id": "fldStatus",
          "name": "Status",
          "type": "singleSelect",
          "options": ["experimental", "production", "deprecated", "archived"]
        },
        {
          "id": "fldDifficulty",
          "name": "Difficulty",
          "type": "rating",
          "max": 3,
          "description": "1=beginner, 2=intermediate, 3=advanced"
        },
        {
          "id": "fldGitHubURL",
          "name": "GitHub URL",
          "type": "url"
        },
        {
          "id": "fldDocURL",
          "name": "Documentation URL",
          "type": "url"
        },
        {
          "id": "fldLastUpdated",
          "name": "Last Updated",
          "type": "date",
          "auto_sync": true,
          "sync_source": "github_api"
        },
        {
          "id": "fldTestCoverage",
          "name": "Test Coverage %",
          "type": "number",
          "precision": 1
        },
        {
          "id": "fldGitHubStars",
          "name": "GitHub Stars",
          "type": "number",
          "auto_sync": true,
          "sync_source": "github_api"
        },
        {
          "id": "fldMonetization",
          "name": "Monetization",
          "type": "singleSelect",
          "options": ["open-source", "freemium", "commercial", "consulting"]
        },
        {
          "id": "fldMaturity",
          "name": "Maturity (1-5)",
          "type": "rating",
          "max": 5
        },
        {
          "id": "fldDescription",
          "name": "Description",
          "type": "richText"
        },
        {
          "id": "fldNotes",
          "name": "Internal Notes",
          "type": "richText"
        }
      ],
      "views": [
        {
          "view_id": "viwProductionTools",
          "view_name": "Production Tools",
          "view_type": "grid",
          "filter": "Status = 'production'"
        },
        {
          "view_id": "viwByLanguage",
          "view_name": "By Language",
          "view_type": "grid",
          "group_by": "Languages"
        },
        {
          "view_id": "viwByCategory",
          "view_name": "By Concept",
          "view_type": "grid",
          "group_by": "Concepts"
        },
        {
          "view_id": "viwMonetizationPipeline",
          "view_name": "Monetization Pipeline",
          "view_type": "kanban",
          "kanban_field": "Status"
        }
      ]
    }
  ]
}

# .github/workflows/validate-recipe.yml
name: Validate Recipe

on:
  pull_request:
    paths:
      - '**/recipes/**'
      - '**/patterns/**'
      - '**/blueprints/**'

jobs:
  validate-structure:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Validate Recipe Schema
        run: |
          python scripts/validate-recipe-schema.py \
            --schema api/schemas/recipe.xsd \
            --recipes-path recipes/**/*.xml
      
      - name: Check Required Files
        run: |
          # Each recipe must have:
          # - README.md
          # - src/
          # - tests/
          # - examples/
          # - architecture-diagram.{mmd,svg,puml}
          python scripts/validate-recipe-structure.py
      
      - name: Lint Code
        run: |
          # Python
          pylint $(find . -name "*.py" -type f)
          # Go
          golangci-lint run ./...
          # Rust
          cargo clippy --all-targets --all-features
          # TypeScript
          eslint . --ext .ts,.tsx
          # Shell
          shellcheck $(find . -name "*.sh" -type f)

  test-recipes:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        language: [python, go, rust, typescript, shell]
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Language Environment
        run: |
          case "${{ matrix.language }}" in
            python)
              python -m pip install -r requirements.txt
              ;;
            go)
              go version
              ;;
            rust)
              rustc --version
              ;;
            typescript)
              npm install
              ;;
            shell)
              bash --version
              ;;
          esac
      
      - name: Run Tests
        run: |
          case "${{ matrix.language }}" in
            python)
              pytest --cov --cov-report=xml
              ;;
            go)
              go test -v -coverprofile=coverage.out ./...
              ;;
            rust)
              cargo test --all-features
              ;;
            typescript)
              npm test -- --coverage
              ;;
            shell)
              bats tests/**/*.bats
              ;;
          esac
      
      - name: Upload Coverage
        uses: codecov/codecov-action@v3

  validate-docs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Check README Quality
        run: python scripts/validate-readme.py
      
      - name: Validate Markdown Links
        run: markdown-link-check README.md
      
      - name: Validate Diagram Syntax
        run: |
          for diagram in $(find . -name "*.mmd" -o -name "*.puml"); do
            python scripts/validate-diagram.py "$diagram"
          done

  security-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Run Trivy Scan
        uses: aquasecurity/trivy-action@master
        with:
          scan-type: 'fs'
          scan-ref: '.'
          format: 'sarif'
          output: 'trivy-results.sarif'
      
      - name: Upload Results
        uses: github/codeql-action/upload-sarif@v2
        with:
          sarif_file: 'trivy-results.sarif'

{
  "name": "GitHub → Airtable Sync (Hourly)",
  "active": true,
  "nodes": [
    {
      "name": "Cron Trigger",
      "type": "n8n-nodes-base.cron",
      "parameters": {
        "rule": {
          "interval": [1, "hours"]
        }
      }
    },
    {
      "name": "Get All Tools",
      "type": "n8n-nodes-base.airtable",
      "parameters": {
        "operation": "listRecords",
        "baseId": "appReactorPortfolio",
        "tableId": "tblKnowledgeIndex"
      }
    },
    {
      "name": "Loop Through Tools",
      "type": "n8n-nodes-base.itemLists",
      "parameters": {
        "operation": "splitOutItems",
        "fieldToSplitOut": "fields"
      }
    },
    {
      "name": "Fetch GitHub Metrics",
      "type": "n8n-nodes-github",
      "parameters": {
        "resource": "repository",
        "operation": "get",
        "owner": "={{ $node['Loop Through Tools'].json.body.fields['GitHub Owner'] }}",
        "repository": "={{ $node['Loop Through Tools'].json.body.fields['Repository Name'] }}"
      }
    },
    {
      "name": "Update Airtable",
      "type": "n8n-nodes-base.airtable",
      "parameters": {
        "operation": "update",
        "baseId": "appReactorPortfolio",
        "tableId": "tblKnowledgeIndex",
        "id": "={{ $node['Loop Through Tools'].json.body.id }}",
        "fieldsToUpdate": {
          "GitHub Stars": "={{ $node['Fetch GitHub Metrics'].json.body.stargazers_count }}",
          "Last Updated": "={{ new Date().toISOString() }}"
        }
      }
    },
    {
      "name": "Post to Slack",
      "type": "n8n-nodes-base.slack",
      "parameters": {
        "text": "✅ Updated {{ $node['Loop Through Tools'].json.body.fields['Name'] }} - {{ $node['Fetch GitHub Metrics'].json.body.stargazers_count }} ⭐"
      }
    }
  ]
}

PHASE 1: FOUNDATION (Week 1-2)
☐ cookbook.dev resolves to landing page
☐ reactor.dev resolves to landing page
☐ GitHub orgs created (reactor-python, your-name/cookbook)
☐ Airtable base created with schema validated
☐ 5 initial recipes added with all required files
☐ RTM document 100% complete

PHASE 2: INFRASTRUCTURE (Week 3-4)
☐ Mintlify documentation site live and rendering
☐ All 5 recipes visible on cookbook.dev
☐ n8n workflows deployed and tested
☐ GitHub Actions CI/CD pipelines green
☐ Search functionality working
☐ MCP server endpoint responding
☐ API endpoints returning JSON + XML

PHASE 3: VALIDATION (Week 5-6)
☐ All functional requirements (FR-1 to FR-7) tested
☐ All non-functional requirements (NFR-1 to NFR-7) measured
☐ RTM traceability 100% (every requirement → test)
☐ V&V report generated and signed
☐ User acceptance testing passed
☐ Agent testing passed (Claude can query recipes)
☐ Performance benchmarks met

PHASE 4: PRODUCTION RELEASE
☐ Security audit completed
☐ Dependency scan passed (Trivy)
☐ Code coverage >= 100% (all recipes)
☐ Documentation completeness >= 80%
☐ All team members trained
☐ Runbooks created for operation
☐ Rollback procedures documented
☐ Sign-off from stakeholders

SIGN-OFF
[ ] Project Lead Approved
[ ] Technical Lead Approved
[ ] Security Lead Approved
[ ] Date: _____________