COOKBOOK:_CODE_REVIEW_AGENT

import { Agent } from '@akios/core'
import { z } from 'zod'

// Tool for analyzing code
const analyzeCode = new Tool({
  name: 'analyze_code',
  description: 'Analyze code for bugs, security issues, and best practices',
  schema: z.object({
    code: z.string(),
    language: z.string(),
    context: z.string().optional()
  }),
  handler: async ({ code, language, context }) => {
    // In practice, this would call a code analysis service
    const issues = []

    // Basic checks
    if (code.includes('eval(')) {
      issues.push({
        type: 'security',
        severity: 'high',
        message: 'Use of eval() is dangerous and should be avoided'
      })
    }

    if (code.includes('console.log') && !code.includes('// DEBUG')) {
      issues.push({
        type: 'best_practice',
        severity: 'low',
        message: 'Remove console.log statements before production'
      })
    }

    return JSON.stringify({ issues, suggestions: [] })
  }
})

// Tool for checking code style
const checkStyle = new Tool({
  name: 'check_style',
  description: 'Check code style and formatting consistency',
  schema: z.object({
    code: z.string(),
    language: z.string()
  }),
  handler: async ({ code, language }) => {
    const styleIssues = []

    // Check indentation
    const lines = code.split('\n')
    for (let i = 0; i < lines.length; i++) {
      const line = lines[i]
      const leadingSpaces = line.length - line.trimStart().length
      if (leadingSpaces % 2 !== 0) {
        styleIssues.push({
          line: i + 1,
          message: 'Inconsistent indentation (use 2 spaces)'
        })
      }
    }

    return JSON.stringify({ styleIssues })
  }
})

// Tool for generating review comments
const generateReview = new Tool({
  name: 'generate_review',
  description: 'Generate a comprehensive code review with actionable feedback',
  schema: z.object({
    code: z.string(),
    analysis: z.string(),
    style_check: z.string(),
    language: z.string()
  }),
  handler: async ({ code, analysis, style_check, language }) => {
    const analysisData = JSON.parse(analysis)
    const styleData = JSON.parse(style_check)

    let review = '# Code Review\n\n'

    // Security issues
    const securityIssues = analysisData.issues.filter(i => i.type === 'security')
    if (securityIssues.length > 0) {
      review += '## 🚨 Security Issues\n'
      securityIssues.forEach(issue => {
        review += `- **${issue.severity.toUpperCase()}**: ${issue.message}\n`
      })
      review += '\n'
    }

    // Code quality issues
    const qualityIssues = analysisData.issues.filter(i => i.type !== 'security')
    if (qualityIssues.length > 0) {
      review += '## 🔍 Code Quality\n'
      qualityIssues.forEach(issue => {
        review += `- ${issue.message}\n`
      })
      review += '\n'
    }

    // Style issues
    if (styleData.styleIssues.length > 0) {
      review += '## 💅 Style Issues\n'
      styleData.styleIssues.forEach(issue => {
        review += `- Line ${issue.line}: ${issue.message}\n`
      })
      review += '\n'
    }

    // Overall assessment
    const hasHighSeverity = [...securityIssues, ...qualityIssues]
      .some(i => i.severity === 'high')

    if (hasHighSeverity) {
      review += '## 📋 Overall Assessment\n'
      review += '❌ **Requires changes** before merging.\n'
    } else {
      review += '## 📋 Overall Assessment\n'
      review += '✅ **Approved** with suggestions.\n'
    }

    return review
  }
})

import { Agent } from '@akios/core'

const codeReviewAgent = new Agent({
  name: 'CodeReviewAgent',
  model: 'gpt-4',
  systemPrompt: `You are an expert code reviewer. Your job is to:

1. Analyze code for bugs, security vulnerabilities, and performance issues
2. Check code style and consistency
3. Provide actionable feedback
4. Be constructive and helpful
5. Focus on important issues first

Guidelines:
- Prioritize security > correctness > performance > style
- Be specific about problems and suggest solutions
- Explain why something is an issue
- Don't nitpick minor style issues unless they affect readability
- End with an overall assessment of merge readiness`,
  tools: [analyzeCode, checkStyle, generateReview]
})

// Example usage
async function reviewPullRequest(code: string, language: string) {
  // Step 1: Analyze code
  const analysisResult = await analyzeCode.execute({
    code,
    language,
    context: 'pull_request_review'
  })

  // Step 2: Check style
  const styleResult = await checkStyle.execute({
    code,
    language
  })

  // Step 3: Generate comprehensive review
  const review = await generateReview.execute({
    code,
    analysis: analysisResult,
    style_check: styleResult,
    language
  })

  return review
}

// Or use the agent directly
async function agentReview(code: string, language: string) {
  const prompt = `Please review this ${language} code:

```${language}
${code}
```

Provide a comprehensive code review focusing on:
- Security vulnerabilities
- Code quality and potential bugs
- Performance issues
- Style and readability
- Best practices

Be specific about issues and suggest improvements.`

  const result = await codeReviewAgent.run(prompt)
  return response.text
}`

import { createNodeMiddleware, createProbot } from 'probot'

const probot = createProbot()

probot.on('pull_request.opened', async (context) => {
  const pr = context.payload.pull_request
  const files = await context.octokit.pulls.listFiles({
    owner: pr.base.repo.owner.login,
    repo: pr.base.repo.name,
    pull_number: pr.number
  })

  // Get changed files
  const changedFiles = files.data.filter(f =>
    f.status === 'added' || f.status === 'modified'
  )

  // Review each file
  for (const file of changedFiles) {
    if (file.filename.endsWith('.js') || file.filename.endsWith('.ts')) {
      const content = await context.octokit.repos.getContent({
        owner: pr.base.repo.owner.login,
        repo: pr.base.repo.name,
        path: file.filename,
        ref: pr.head.sha
      })

      const code = Buffer.from(content.data.content, 'base64').toString()
      const language = file.filename.endsWith('.ts') ? 'typescript' : 'javascript'

      const review = await agentReview(code, language)

      // Post review comment
      await context.octokit.pulls.createReview({
        owner: pr.base.repo.owner.login,
        repo: pr.base.repo.name,
        pull_number: pr.number,
        body: `## AI Code Review for ${file.filename}\n\n${review}`,
        event: 'COMMENT'
      })
    }
  }
})

export default createNodeMiddleware(probot)