validate.yml

name: Reusable Validation Workflow

"on":
  workflow_call:
    inputs:
      working_directory:
        required: false
        type: string
        default: "./gsd-opencode"

jobs:
  validate_code:
    name: Validate Code Quality
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "18"
          cache: "npm"
          cache-dependency-path: "${{ inputs.working_directory }}/package.json"

      - name: Install dependencies
        working-directory: ${{ inputs.working_directory }}
        run: npm install

      - name: Check Node.js syntax
        working-directory: ${{ inputs.working_directory }}
        run: |
          node -c bin/gsd-install.js
          echo "✓ JavaScript syntax validation passed"

      - name: Validate package.json
        working-directory: ${{ inputs.working_directory }}
        run: |
          node -e "console.log('✓ package.json is valid JSON'); JSON.parse(require('fs').readFileSync('package.json', 'utf8'))"

      - name: Check for common issues
        working-directory: ${{ inputs.working_directory }}
        run: |
          echo "Checking for console.log statements in production code..."
          if grep -r "console\.log" bin/ --exclude-dir=node_modules; then
            echo "⚠️  Warning: console.log found in bin/gsd-install.js"
          else
            echo "✓ No console.log statements found"
          fi

          echo "Checking file permissions..."
          if [ -x bin/gsd-install.js ]; then
            echo "✓ bin/gsd-install.js is executable"
          else
            echo "❌ bin/gsd-install.js is not executable"
            exit 1
          fi

  validate_gsd:
    name: Validate GSD Compliance
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0
          submodules: recursive

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "18"

      - name: Install dependencies
        working-directory: ${{ inputs.working_directory }}
        run: npm install

      - name: Validate command structure
        run: |
          echo "Checking command files..."
          command_dir="${{ inputs.working_directory }}/commands"
          if [ -d "$command_dir" ]; then
            for cmd_file in "$command_dir"/gsd/*.md; do
              if [ -f "$cmd_file" ]; then
                echo "Checking $cmd_file..."

                # Check for required YAML frontmatter
                if ! grep -q "^name:" "$cmd_file"; then
                  echo "❌ Missing 'name:' in $cmd_file"
                  exit 1
                fi

                if ! grep -q "^description:" "$cmd_file"; then
                  echo "❌ Missing 'description:' in $cmd_file"
                  exit 1
                fi

                # Check for required sections
                if ! grep -q "<objective>" "$cmd_file"; then
                  echo "❌ Missing <objective> section in $cmd_file"
                  exit 1
                fi

                echo "✓ $cmd_file structure valid"
              fi
            done
          else
            echo "⚠️  No commands directory found"
          fi

      - name: Validate workflow structure
        run: |
          echo "Checking workflow files..."
          workflows_dir="${{ inputs.working_directory }}/get-shit-done/workflows"
          if [ -d "$workflows_dir" ]; then
            for workflow_file in "$workflows_dir"/*.md; do
              if [ -f "$workflow_file" ]; then
                echo "Checking $workflow_file..."

                # Check for semantic XML tags (not generic ones)
                if grep -q "<section>" "$workflow_file" || grep -q "<item>" "$workflow_file"; then
                  echo "❌ Found generic XML tags in $workflow_file"
                  exit 1
                fi

                # Check for proper semantic tags
                if grep -E "<(purpose|when_to_use|process|step)>" "$workflow_file" > /dev/null || \
                   grep -E "<(objective|context|execution_context)>" "$workflow_file" > /dev/null; then
                  echo "✓ $workflow_file uses semantic XML tags"
                else
                  echo "⚠️  $workflow_file may need semantic XML tags"
                fi
              fi
            done
          else
            echo "❌ Workflows directory not found"
            exit 1
          fi

      - name: Validate file naming conventions
        run: |
          echo "Checking file naming conventions..."

          # Check for kebab-case in markdown files
          naming_violations=0
          find ${{ inputs.working_directory }} -name "*.md" -type f | while read file; do
            basename=$(basename "$file" .md)
            if [[ ! "$basename" =~ ^[a-z0-9-]+$ ]] && [[ "$basename" != "README" ]] && [[ "$basename" != "GSD-STYLE" ]] && [[ "$basename" != "DEBUG" ]]; then
              echo "⚠️  File name should be kebab-case: $file"
              naming_violations=$((naming_violations + 1))
            fi
          done
          
          if [ $naming_violations -eq 0 ]; then
            echo "✓ File naming follows kebab-case convention"
          else
            echo "⚠️  Found $naming_violations files with naming convention violations"
            echo "ℹ️  Consider renaming these files to follow kebab-case format"
          fi

      - name: Check for anti-patterns
        run: |
          echo "Checking for banned patterns..."

          # Check for enterprise patterns
          if grep -r -i "story point\|sprint\|raci\|knowledge transfer" ${{ inputs.working_directory }} --exclude-dir=node_modules --exclude="*.md"; then
            echo "⚠️  Found enterprise patterns - check manually"
          fi

          # Check for temporal language in implementation docs
          for file in ${{ inputs.working_directory }}/workflows/*.md; do
            if [ -f "$file" ]; then
              if grep -E "(previously|no longer|instead of|we changed)" "$file" > /dev/null; then
                echo "❌ Found temporal language in $file"
                exit 1
              fi
            fi
          done
          echo "✓ No temporal language found in workflows"

      - name: Validate template structure
        run: |
          echo "Checking template files..."
          templates_dir="${{ inputs.working_directory }}/templates"
          if [ -d "$templates_dir" ]; then
            for template_file in "$templates_dir"/*.md; do
              if [ -f "$template_file" ]; then
                basename=$(basename "$template_file" .md)

                # Check for proper template header
                if ! grep -q "# \[.*\] Template\|# $basename Template\|# $basename" "$template_file"; then
                  echo "⚠️  $template_file may need proper template header"
                fi

                # Check for placeholder conventions
                if grep -q "\[.*\]" "$template_file" || grep -q "{.*}" "$template_file"; then
                  echo "✓ $template_file uses proper placeholder conventions"
                fi
              fi
            done
          fi

      - name: Validate reference structure
        run: |
          echo "Checking reference files..."
          refs_dir="${{ inputs.working_directory }}/references"
          if [ -d "$refs_dir" ]; then
            for ref_file in "$refs_dir"/*.md; do
              if [ -f "$ref_file" ]; then
                basename=$(basename "$ref_file" .md)

                # Check for semantic outer containers
                if grep -E "<$basename>" "$ref_file" > /dev/null || \
                   grep -E "<(overview|core_principle|checkpoint_types|principles)>" "$ref_file" > /dev/null; then
                  echo "✓ $ref_file uses semantic containers"
                else
                  echo "⚠️  $ref_file may need semantic outer containers"
                fi
              fi
            done
          fi


      - name: Check forbidden strings in antipatterns
        run: |
          echo "Checking forbidden strings from antipatterns.toml..."

          # Run from repo root with NODE_PATH set to find gsd-opencode dependencies
          NODE_PATH="${{ inputs.working_directory }}/node_modules" node assets/bin/check-forbidden-strings.js

      - name: Final validation summary
        run: |
          echo "=== GSD Validation Summary ==="

          echo "✓ Command structure validated"
          echo "✓ Workflow structure validated"
          echo "✓ File naming conventions followed"
          echo "✓ Anti-patterns check passed"
          echo "✓ Template structure validated"
          echo "✓ Reference structure validated"
          echo ""
          echo "🎉 GSD compliance validation completed successfully!"