name: AI PR Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      
      - name: Get PR diff
        id: diff
        run: |
          git diff origin/${{ github.base_ref }}...HEAD > pr.diff
          echo "diff=$(cat pr.diff | jq -Rs .)" >> $GITHUB_OUTPUT
      
      - name: AI Review
        uses: actions/github-script@v7
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        with:
          script: |
            const diff = process.env.DIFF;
            const prompt = `
              Review this PR diff for:
              1. Code style violations
              2. Potential bugs (null pointer, race conditions)
              3. Missing error handling
              4. Performance issues
              5. Security vulnerabilities
              
              Diff:\n${diff}
              
              Return JSON with: { issues: [{ line, message, severity }], summary }
            `;
            
            const response = await fetch('https://api.openai.com/v1/chat/completions', {
              method: 'POST',
              headers: {
                'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
                'Content-Type': 'application/json',
              },
              body: JSON.stringify({
                model: 'gpt-4o-mini',
                messages: [{ role: 'user', content: prompt }],
                temperature: 0.2,
              }),
            });
            
            const data = await response.json();
            const review = JSON.parse(data.choices[0].message.content);
            
            // Post comment on PR
            const comment = `## AI PR Review\n\n**Summary:** ${review.summary}\n\n**Issues:**\n${review.issues.map(i => `- [${i.severity}] Line ${i.line}: ${i.message}`).join('\n')}`;
            
            await github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: comment,
            });

name: AI Issue Triage
on:
  issues:
    types: [opened]

jobs:
  triage:
    runs-on: ubuntu-latest
    steps:
      - name: Analyze issue
        uses: actions/github-script@v7
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        with:
          script: |
            const issueBody = context.payload.issue.body;
            const issueTitle = context.payload.issue.title;
            
            const prompt = `
              Analyze this GitHub issue:
              Title: ${issueTitle}
              Body: ${issueBody}
              
              Determine:
              1. Category: ["bug", "feature", "docs", "question", "performance"]
              2. Priority: ["high", "medium", "low"]
              3. Suggested assignee (based on keyword: "frontend", "backend", "devops")
              4. Estimated complexity: ["easy", "medium", "hard"]
              
              Return JSON.
            `;
            
            // Call OpenAI API (same as above)
            const result = await callOpenAI(prompt);
            
            // Add labels
            await github.rest.issues.addLabels({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              labels: [result.category, `priority-${result.priority}`, `complexity-${result.complexity}`],
            });
            
            // Auto-assign if confidence high
            if (result.suggested_assignee) {
              await github.rest.issues.addAssignees({
                issue_number: context.issue.number,
                owner: context.repo.owner,
                repo: context.repo.repo,
                assignees: [result.suggested_assignee],
              });
            }

import { Octokit } from '@octokit/rest';
import OpenAI from 'openai';

const octokit = new Octokit({ auth: process.env.GITHUB_TOKEN });
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

async function getMergedPRs(fromDate: string) {
  const { data } = await octokit.pulls.list({
    owner: 'your-org',
    repo: 'your-repo',
    state: 'closed',
    sort: 'updated',
    direction: 'desc',
  });
  
  return data.filter(pr => pr.merged_at && pr.merged_at > fromDate);
}

async function generateReleaseNotes(prs: any[]) {
  const prSummaries = prs.map(pr => ({
    title: pr.title,
    author: pr.user.login,
    labels: pr.labels.map(l => l.name),
    url: pr.html_url,
  }));
  
  const prompt = `
    Generate release notes from these pull requests:
    ${JSON.stringify(prSummaries, null, 2)}
    
    Group by: Features, Bug Fixes, Performance Improvements, Documentation, Dependencies.
    Add emojis for each section. Keep tone professional but friendly.
  `;
  
  const response = await openai.chat.completions.create({
    model: 'gpt-4o-mini',
    messages: [{ role: 'user', content: prompt }],
    temperature: 0.5,
  });
  
  return response.choices[0].message.content;
}

// Run before each release
const lastRelease = '2026-04-01';
const prs = await getMergedPRs(lastRelease);
const notes = await generateReleaseNotes(prs);
console.log(notes);
// Then write to CHANGELOG.md and create GitHub release

name: AI Dependency Check
on:
  schedule:
    - cron: '0 12 * * 1'  # Weekly
  workflow_dispatch:

jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
      
      - name: Check for outdated packages
        run: npm outdated --json > outdated.json
      
      - name: AI analysis
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        run: |
          node scripts/ai-dependency-analyzer.js
      
      - name: Create PR for safe updates
        if: success()
        run: |
          # Create branch and PR for each recommended update
          npx npm-check-updates -u --target minor
          npm install
          git commit -am "chore(deps): AI-recommended updates"
          gh pr create --title "chore: safe dependency updates" --body "AI analyzed changelogs and tests"

const fs = require('fs');
const OpenAI = require('openai');

const outdated = JSON.parse(fs.readFileSync('outdated.json'));

async function analyzeDependency(pkg, current, wanted, latest) {
  const prompt = `
    Package: ${pkg}
    Current: ${current}
    Wanted (semver): ${wanted}
    Latest: ${latest}
    
    Should we update to latest? Consider:
    - Breaking changes (major version bump)
    - Security patches
    - Ecosystem adoption (check npm trends)
    - Test suite compatibility
    
    Return JSON: { safe: boolean, reason: string, recommendedVersion: string }
  `;
  
  const response = await openai.chat.completions.create({
    model: 'gpt-4o-mini',
    messages: [{ role: 'user', content: prompt }],
  });
  
  return JSON.parse(response.choices[0].message.content);
}

for (const [pkg, info] of Object.entries(outdated)) {
  const analysis = await analyzeDependency(pkg, info.current, info.wanted, info.latest);
  if (analysis.safe && analysis.recommendedVersion !== info.current) {
    console.log(`Update ${pkg} to ${analysis.recommendedVersion}: ${analysis.reason}`);
    // Run npm install ${pkg}@${analysis.recommendedVersion}
  }
}

npm install @microsoft/tsdoc jsdoc-to-markdown

name: Generate API Docs
on:
  push:
    branches: [main]

jobs:
  docs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Generate docs
        run: |
          npx jsdoc-to-markdown src/**/*.ts > API.md
      - name: Enhance with AI
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        run: |
          node scripts/enhance-docs.js
      - name: Commit docs
        run: |
          git config user.name "AI Doc Bot"
          git add API.md
          git commit -m "docs: auto-generate API reference" || true
          git push