Evaluating AI-Generated Code Quality

// AI-generated code with potential bug
function calculateDiscount(price, discountPercent) {
    const discountedPrice = price - (price * discountPercent / 100);
    return discountedPrice;
}

// Bug: No validation for negative inputs or invalid discount percent
const result = calculateDiscount(-50, 20); // Returns -40, which is incorrect

const validateEndpoint = async (url) => {
  try {
    const response = await fetch(url, { method: 'GET' });
    if (response.ok) {
      return { valid: true, status: response.status };
    } else {
      return { valid: false, status: response.status };
    }
  } catch (error) {
    return { valid: false, error: error.message };
  }
};

// Example usage:
const result = await validateEndpoint('https://api.example.com/users');
console.log(result); // { valid: true, status: 200 }

const licenseChecker = require("license-checker");

licenseChecker.init({
  start: './',
  excludePrivatePackages: true
}, (err, packages) => {
  if (err) {
    console.error("License check failed:", err);
  } else {
    Object.keys(packages).forEach(pkg => {
      const license = packages[pkg].license;
      if (license && !isPermissive(license)) {
        console.warn(`Non-permissive license found: ${pkg} - ${license}`);
      }
    });
  }
});

function isPermissive(license) {
  const permissiveLicenses = [
    "MIT", "ISC", "BSD-2-Clause", "BSD-3-Clause",
    "Apache-2.0", "JSON"
  ];
  return permissiveLicenses.includes(license);
}

// Sample data from a development team's AI-assisted workflow
const totalSuggestions = 500;
const acceptedSuggestions = 375;

const acceptanceRate = (acceptedSuggestions / totalSuggestions) * 100;
console.log(`Acceptance Rate: ${acceptanceRate}%`); // Output: Acceptance Rate: 75%

const testSuite = [
  {
    input: "Write a function to calculate factorial",
    expectedOutput: "function factorial(n) { ... }"
  },
  {
    input: "Implement a binary search tree",
    expectedOutput: "class TreeNode { ... }"
  }
];

const results = testSuite.map(test => {
  const generatedCode = aiAgent.generate(test.input);
  return {
    input: test.input,
    code: generatedCode,
    passesCompilation: compileAndRun(generatedCode),
    matchesExpected: generatedCode.includes(test.expectedOutput)
  };
});

// GitHub Copilot suggestion
function calculateTotal(items) {
  return items.reduce((sum, item) => sum + item.price, 0);
}

// Tabnine suggestion
function calculateTotal(items) {
  let total = 0;
  for (let i = 0; i < items.length; i++) {
    total += items[i].price;
  }
  return total;
}

const { performance } = require('node:perf_hooks');
const oldCode = require('./old-ai-module');
const newCode = require('./new-ai-module');

// Performance check
const startOld = performance.now();
oldCode.run();
const endOld = performance.now();

const startNew = performance.now();
newCode.run();
const endNew = performance.now();

console.log(`Old: ${endOld - startOld}ms`);
console.log(`New: ${endNew - startNew}ms`);

// Define test cases for code quality checks
const testCases = [
  {
    name: "Code Readability",
    description: "Evaluate code clarity and structure",
    criteria: [
      {
        id: "no-long-functions",
        description: "Functions should not exceed 20 lines",
        severity: "warning"
      },
      {
        id: "consistent-naming",
        description: "Use camelCase for variables and functions",
        severity: "error"
      }
    ]
  },
  {
    name: "Security Checks",
    description: "Ensure no vulnerable code patterns",
    criteria: [
      {
        id: "no-unsafe-eval",
        description: "Avoid usage of eval()",
        severity: "error"
      }
    ]
  }
];

// Run evaluation on generated code
function evaluateCode(code, testCases) {
  const results = [];
  testCases.forEach(testCase => {
    const testCaseResult = {
      name: testCase.name,
      checks: []
    };
    testCase.criteria.forEach(criterion => {
      const pass = checkCriterion(code, criterion);
      testCaseResult.checks.push({
        id: criterion.id,
        passed: pass,
        severity: criterion.severity
      });
    });
    results.push(testCaseResult);
  });
  return results;
}

function checkCriterion(code, criterion) {
  // Implementation depends on specific checks
  return true; // Placeholder
}