@theihtisham/ai-testgen 1.0.0

package/src/coverage.ts

@@ -0,0 +1,128 @@
+import {
+  SourceAnalysis,
+  CoveragePrediction,
+  TestSuite,
+} from './types.js';
+
+export function predictCoverage(analysis: SourceAnalysis, suite: TestSuite): CoveragePrediction {
+  const uncoveredPaths: string[] = [];
+  const suggestions: string[] = [];
+
+  const testedNames = new Set(suite.testCases.map((tc) => tc.name.split(' ')[0] ?? ''));
+
+  // Check function coverage
+  let coveredFunctions = 0;
+  for (const fn of analysis.functions) {
+    if (fn.isExported) {
+      const isTested = testedNames.has(fn.name);
+      if (isTested) {
+        coveredFunctions++;
+      } else {
+        uncoveredPaths.push(`Function ${fn.name} is not tested`);
+        suggestions.push(`Add tests for exported function: ${fn.name}`);
+      }
+    }
+  }
+
+  // Check class method coverage
+  let coveredMethods = 0;
+  let totalMethods = 0;
+  for (const cls of analysis.classes) {
+    for (const method of cls.methods) {
+      totalMethods++;
+      const isTested = testedNames.has(method.name) || Array.from(testedNames).some((n) => n.includes(method.name));
+      if (isTested) {
+        coveredMethods++;
+      } else {
+        uncoveredPaths.push(`${cls.name}.${method.name} is not tested`);
+        suggestions.push(`Add tests for ${cls.name}.${method.name} method`);
+      }
+    }
+  }
+
+  // Check for uncovered error paths
+  for (const fn of analysis.functions) {
+    if (fn.throws.length > 0) {
+      const hasErrorTest = suite.testCases.some(
+        (tc) => tc.name.includes(fn.name) && (tc.tags.includes('error') || tc.tags.includes('edge-case')),
+      );
+      if (!hasErrorTest) {
+        uncoveredPaths.push(`${fn.name} error paths not tested`);
+        suggestions.push(`Add error path tests for ${fn.name} (throws: ${fn.throws.join(', ')})`);
+      }
+    }
+  }
+
+  // Check for untested async error paths
+  for (const fn of analysis.functions) {
+    if (fn.isAsync) {
+      const hasAsyncErrorTest = suite.testCases.some(
+        (tc) => tc.name.includes(fn.name) && tc.tags.includes('async'),
+      );
+      if (!hasAsyncErrorTest) {
+        suggestions.push(`Add async rejection test for ${fn.name}`);
+      }
+    }
+  }
+
+  // Check for untested optional params
+  for (const fn of analysis.functions) {
+    const optionalParams = fn.params.filter((p) => p.optional);
+    if (optionalParams.length > 0) {
+      const hasOptionalTest = suite.testCases.some(
+        (tc) => tc.name.includes(fn.name) && tc.name.includes('undefined'),
+      );
+      if (!hasOptionalTest) {
+        suggestions.push(
+          `Test ${fn.name} without optional params: ${optionalParams.map((p) => p.name).join(', ')}`,
+        );
+      }
+    }
+  }
+
+  // Calculate estimates
+  const totalExported = analysis.functions.filter((f) => f.isExported).length + totalMethods;
+  const covered = coveredFunctions + coveredMethods;
+  const functionCoverage = totalExported > 0 ? Math.round((covered / totalExported) * 100) : 100;
+
+  const lineCoverage = Math.min(functionCoverage + 10, suite.coverageEstimate);
+  const branchCoverage = Math.max(functionCoverage - 10, 0);
+
+  return {
+    filePath: analysis.filePath,
+    estimatedLineCoverage: lineCoverage,
+    estimatedBranchCoverage: branchCoverage,
+    estimatedFunctionCoverage: functionCoverage,
+    uncoveredPaths: uncoveredPaths.slice(0, 10),
+    suggestions: suggestions.slice(0, 10),
+  };
+}
+
+export function formatCoverageReport(prediction: CoveragePrediction): string {
+  const lines: string[] = [];
+  lines.push('');
+  lines.push(`  Coverage Prediction: ${prediction.filePath}`);
+  lines.push('  ----------------------------------------');
+  lines.push(`  Line coverage:     ~${prediction.estimatedLineCoverage}%`);
+  lines.push(`  Branch coverage:   ~${prediction.estimatedBranchCoverage}%`);
+  lines.push(`  Function coverage: ~${prediction.estimatedFunctionCoverage}%`);
+
+  if (prediction.uncoveredPaths.length > 0) {
+    lines.push('');
+    lines.push('  Uncovered paths:');
+    for (const path of prediction.uncoveredPaths) {
+      lines.push(`    - ${path}`);
+    }
+  }
+
+  if (prediction.suggestions.length > 0) {
+    lines.push('');
+    lines.push('  Suggestions:');
+    for (const suggestion of prediction.suggestions) {
+      lines.push(`    + ${suggestion}`);
+    }
+  }
+
+  lines.push('');
+  return lines.join('\n');
+}

package/src/generators/ai-generator.ts

@@ -0,0 +1,170 @@
+import * as fs from 'fs';
+import OpenAI from 'openai';
+import {
+  SourceAnalysis,
+  TestSuite,
+  TestFramework,
+  TestGenConfig,
+} from '../types.js';
+import { detectEdgeCases } from '../analyzers/analyzer.js';
+
+export async function generateWithAI(
+  analysis: SourceAnalysis,
+  framework: TestFramework,
+  config: TestGenConfig,
+): Promise<string> {
+  if (!config.ai.enabled || config.ai.provider === 'none') {
+    throw new Error('AI generation is not enabled in configuration');
+  }
+
+  const apiKey = process.env[config.ai.apiKeyEnv];
+  if (!apiKey) {
+    throw new Error(
+      `AI API key not found. Set the ${config.ai.apiKeyEnv} environment variable.`,
+    );
+  }
+
+  const client = new OpenAI({ apiKey, baseURL: getBaseURL(config) });
+
+  const prompt = buildPrompt(analysis, framework, config);
+
+  const response = await client.chat.completions.create({
+    model: config.ai.model,
+    messages: [
+      {
+        role: 'system',
+        content: getSystemPrompt(framework),
+      },
+      {
+        role: 'user',
+        content: prompt,
+      },
+    ],
+    max_tokens: config.ai.maxTokens,
+    temperature: config.ai.temperature,
+  });
+
+  const content = response.choices[0]?.message?.content;
+  if (!content) {
+    throw new Error('AI returned empty response');
+  }
+
+  // Extract code from markdown code blocks if present
+  const codeBlockMatch = content.match(/```(?:typescript|javascript|python|go|tsx|jsx)?\n([\s\S]*?)```/);
+  return codeBlockMatch?.[1]?.trim() ?? content.trim();
+}
+
+function getBaseURL(config: TestGenConfig): string | undefined {
+  if (config.ai.provider === 'openai') return undefined; // uses default
+  if (config.ai.provider === 'anthropic') return 'https://api.anthropic.com/v1';
+  return undefined;
+}
+
+function getSystemPrompt(framework: TestFramework): string {
+  const frameworkName = framework === 'go-test' ? 'Go testing' : framework;
+  return `You are an expert test engineer. Generate comprehensive, well-structured test suites using ${frameworkName}.
+Follow these rules:
+- Use the appropriate testing patterns and best practices for ${frameworkName}
+- Include edge cases: null/undefined/nil, empty inputs, boundary values
+- Mock external dependencies properly
+- Include descriptive test names and comments
+- Handle both happy path and error cases
+- Return ONLY the test code, no explanations outside code comments`;
+}
+
+function buildPrompt(
+  analysis: SourceAnalysis,
+  framework: TestFramework,
+  config: TestGenConfig,
+): string {
+  const parts: string[] = [];
+
+  parts.push(`Generate a complete test suite for the following ${analysis.language} source file.`);
+  parts.push(`Use the ${framework} testing framework.`);
+  parts.push('');
+
+  if (config.ai.privacyMode) {
+    // Send only analysis metadata, not full source
+    parts.push('## Source Code Analysis');
+    parts.push(`File: ${analysis.filePath}`);
+    parts.push(`Language: ${analysis.language}`);
+    parts.push(`Lines of code: ${analysis.linesOfCode}`);
+    parts.push('');
+
+    parts.push('## Exported Functions');
+    for (const fn of analysis.functions.filter((f) => f.isExported)) {
+      const params = fn.params.map((p) => `${p.name}${p.type ? ': ' + p.type : ''}`).join(', ');
+      parts.push(`- ${fn.name}(${params})${fn.returnType ? ': ' + fn.returnType : ''}${fn.isAsync ? ' [async]' : ''}`);
+      if (fn.throws.length > 0) {
+        parts.push(`  Throws: ${fn.throws.join(', ')}`);
+      }
+    }
+    parts.push('');
+
+    parts.push('## Classes');
+    for (const cls of analysis.classes) {
+      parts.push(`- ${cls.name}${cls.extends ? ` extends ${cls.extends}` : ''}`);
+      for (const method of cls.methods) {
+        const params = method.params.map((p) => `${p.name}${p.type ? ': ' + p.type : ''}`).join(', ');
+        parts.push(`  - ${method.name}(${params})${method.returnType ? ': ' + method.returnType : ''}`);
+      }
+    }
+    parts.push('');
+
+    parts.push('## Interfaces');
+    for (const iface of analysis.interfaces) {
+      parts.push(`- ${iface.name}`);
+      for (const prop of iface.properties) {
+        parts.push(`  - ${prop.name}${prop.type ? ': ' + prop.type : ''}${prop.optional ? '?' : ''}`);
+      }
+    }
+    parts.push('');
+
+    parts.push('## Imports');
+    for (const imp of analysis.imports) {
+      parts.push(`- ${imp.modulePath}: ${imp.namedImports.join(', ') || 'default'}`);
+    }
+    parts.push('');
+
+    parts.push('## Edge Cases to Cover');
+    const edgeCases = analysis.functions.flatMap((fn) => detectEdgeCases(fn)).slice(0, 10);
+    for (const ec of edgeCases) {
+      parts.push(`- ${ec.name}: ${ec.expectedBehavior}`);
+    }
+  } else {
+    // Send full source code (not recommended for proprietary code)
+    parts.push('## Source Code');
+    parts.push('```' + analysis.language);
+    try {
+      const source = fs.readFileSync(analysis.filePath, 'utf-8');
+      parts.push(source);
+    } catch {
+      parts.push('(Could not read source file)');
+    }
+    parts.push('```');
+  }
+
+  parts.push('');
+  parts.push('Generate tests that achieve at least 90% code coverage.');
+
+  return parts.join('\n');
+}
+
+export function buildAISuite(
+  generatedCode: string,
+  analysis: SourceAnalysis,
+  framework: TestFramework,
+): TestSuite {
+  return {
+    filePath: '',
+    sourceFilePath: analysis.filePath,
+    language: analysis.language,
+    framework,
+    testCases: [],
+    mocks: [],
+    imports: [generatedCode],
+    setupCode: '',
+    teardownCode: '',
+    coverageEstimate: 90, // AI-generated tests target 90%+
+  };
+}

package/src/generators/generator.ts

@@ -0,0 +1,117 @@
+import {
+  SourceAnalysis,
+  TestSuite,
+  TestFramework,
+  TestGenConfig,
+  GenerationResult,
+  CLIOptions,
+} from '../types.js';
+import { generateJsTsTestSuite } from './js-ts-generator.js';
+import { generatePythonTestSuite } from './python-generator.js';
+import { generateGoTestSuite } from './go-generator.js';
+import { generateWithAI, buildAISuite } from './ai-generator.js';
+import { buildTestFilePath } from '../utils/language.js';
+import { writeFile } from '../utils/file.js';
+import * as path from 'path';
+
+export async function generateTestSuite(
+  analysis: SourceAnalysis,
+  framework: TestFramework,
+  config: TestGenConfig,
+  options: CLIOptions,
+): Promise<GenerationResult> {
+  const startTime = Date.now();
+  let suite: TestSuite;
+  let usedAI = false;
+
+  // Try AI generation first if enabled
+  if (config.ai.enabled && config.ai.provider !== 'none' && !options.noAI) {
+    try {
+      const generatedCode = await generateWithAI(analysis, framework, config);
+      suite = buildAISuite(generatedCode, analysis, framework);
+      usedAI = true;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      console.warn(`AI generation failed, falling back to AST-based: ${errorMessage}`);
+      suite = generateLocalSuite(analysis, framework, config);
+    }
+  } else {
+    suite = generateLocalSuite(analysis, framework, config);
+  }
+
+  // Determine output path
+  const testFilePath = buildTestFilePath(
+    analysis.filePath,
+    options.output ?? config.outputDir,
+    analysis.language,
+    framework,
+  );
+  suite.filePath = testFilePath;
+
+  // Get the final code
+  const code = suite.imports[0] ?? '';
+
+  if (!options.dryRun) {
+    writeFile(testFilePath, code);
+  }
+
+  return {
+    sourceFile: analysis.filePath,
+    testFile: testFilePath,
+    testSuite: suite,
+    duration: Date.now() - startTime,
+    usedAI,
+  };
+}
+
+function generateLocalSuite(
+  analysis: SourceAnalysis,
+  framework: TestFramework,
+  config: TestGenConfig,
+): TestSuite {
+  const maxTests = config.generation.maxTestsPerFunction;
+
+  switch (analysis.language) {
+    case 'typescript':
+    case 'javascript':
+      return generateJsTsTestSuite(analysis, framework, maxTests);
+    case 'python':
+      return generatePythonTestSuite(analysis, framework, maxTests);
+    case 'go':
+      return generateGoTestSuite(analysis, framework, maxTests);
+    case 'rust':
+      throw new Error('Rust test generation requires AI mode. Enable AI in your configuration.');
+    default:
+      throw new Error(`Unsupported language: ${analysis.language}`);
+  }
+}
+
+export function formatResults(results: GenerationResult[]): string {
+  const lines: string[] = [];
+  let totalTests = 0;
+  let totalDuration = 0;
+  let totalCoverage = 0;
+
+  for (const result of results) {
+    totalTests += result.testSuite.testCases.length;
+    totalDuration += result.duration;
+    totalCoverage += result.testSuite.coverageEstimate;
+  }
+
+  const avgCoverage = results.length > 0 ? Math.round(totalCoverage / results.length) : 0;
+
+  lines.push('');
+  lines.push(`  Files analyzed: ${results.length}`);
+  lines.push(`  Tests generated: ${totalTests}`);
+  lines.push(`  Avg coverage estimate: ${avgCoverage}%`);
+  lines.push(`  Total time: ${totalDuration}ms`);
+  lines.push(`  AI assisted: ${results.some((r) => r.usedAI) ? 'Yes' : 'No'}`);
+  lines.push('');
+
+  for (const result of results) {
+    lines.push(`  ${path.basename(result.testFile)}`);
+    lines.push(`    ${result.testSuite.testCases.length} tests | ~${result.testSuite.coverageEstimate}% coverage | ${result.duration}ms`);
+  }
+
+  return lines.join('\n');
+}

package/src/generators/go-generator.ts

@@ -0,0 +1,183 @@
+import {
+  SourceAnalysis,
+  TestSuite,
+  TestCase,
+  TestFramework,
+  AnalyzedFunction,
+} from '../types.js';
+import { detectEdgeCases } from '../analyzers/analyzer.js';
+
+export function generateGoTestSuite(
+  analysis: SourceAnalysis,
+  _framework: TestFramework,
+  maxTestsPerFunction: number,
+): TestSuite {
+  const testCases: TestCase[] = [];
+
+  for (const fn of analysis.functions) {
+    if (!fn.isExported) continue;
+    testCases.push(...generateGoFunctionTests(fn));
+    if (testCases.length > maxTestsPerFunction * analysis.functions.length) break;
+  }
+
+  for (const fn of analysis.functions) {
+    if (!fn.isExported) continue;
+    const edgeCases = detectEdgeCases(fn).slice(0, 2);
+    testCases.push(...edgeCases);
+  }
+
+  const code = renderGoTestSuite(analysis, testCases);
+
+  return {
+    filePath: '',
+    sourceFilePath: analysis.filePath,
+    language: 'go',
+    framework: 'go-test',
+    testCases,
+    mocks: [],
+    imports: [code],
+    setupCode: '',
+    teardownCode: '',
+    coverageEstimate: estimateGoCoverage(analysis, testCases),
+  };
+}
+
+function generateGoFunctionTests(fn: AnalyzedFunction): TestCase[] {
+  const cases: TestCase[] = [];
+
+  cases.push({
+    name: `Test${fn.name}`,
+    type: 'unit',
+    description: `Test ${fn.name} with valid input`,
+    code: renderGoTestFunction(fn, 'happy'),
+    expectedBehavior: 'Returns expected result',
+    inputDescription: 'Valid input',
+    tags: ['unit'],
+  });
+
+  if (fn.returnType && fn.returnType.includes('error')) {
+    cases.push({
+      name: `Test${fn.name}Error`,
+      type: 'unit',
+      description: `Test ${fn.name} returns error for invalid input`,
+      code: renderGoTestFunction(fn, 'error'),
+      expectedBehavior: 'Returns error',
+      inputDescription: 'Invalid input',
+      tags: ['unit', 'error'],
+    });
+  }
+
+  return cases;
+}
+
+function renderGoTestFunction(fn: AnalyzedFunction, testType: string): string {
+  const args = fn.params.map((p) => generateGoMockValue(p)).join(', ');
+  const lines: string[] = [];
+
+  lines.push(`func Test${fn.name}${testType === 'error' ? 'Error' : ''}(t *testing.T) {`);
+
+  if (testType === 'happy') {
+    if (fn.returnType && fn.returnType.includes('error')) {
+      lines.push(`  result, err := ${fn.name}(${args})`);
+      lines.push('  if err != nil {');
+      lines.push('    t.Fatalf("unexpected error: %v", err)');
+      lines.push('  }');
+      lines.push('  if result == nil {');
+      lines.push('    t.Error("expected non-nil result")');
+      lines.push('  }');
+    } else if (fn.returnType) {
+      lines.push(`  result := ${fn.name}(${args})`);
+      lines.push('  if result == nil {');
+      lines.push('    t.Error("expected non-nil result")');
+      lines.push('  }');
+    } else {
+      lines.push(`  ${fn.name}(${args})`);
+    }
+  } else {
+    lines.push(`  _, err := ${fn.name}(${generateGoInvalidArgs(fn)})`);
+    lines.push('  if err == nil {');
+    lines.push('    t.Error("expected error, got nil")');
+    lines.push('  }');
+  }
+
+  lines.push('}');
+  return lines.join('\n');
+}
+
+function generateGoMockValue(param: { type: string | null; name: string }): string {
+  if (!param.type) return 'nil';
+
+  const t = param.type;
+  if (t.includes('string')) return '"test"';
+  if (t.includes('int')) return '42';
+  if (t.includes('float')) return '3.14';
+  if (t.includes('bool')) return 'true';
+  if (t.includes('[]byte')) return '[]byte("test")';
+  if (t.includes('[]')) return 'nil';
+  if (t.includes('map')) return 'nil';
+  if (t.includes('context')) return 'context.Background()';
+  if (t.includes('error')) return 'nil';
+  if (t.includes('io.Reader')) return 'strings.NewReader("test")';
+  if (t.includes('time.Duration')) return 'time.Second';
+
+  return 'nil';
+}
+
+function generateGoInvalidArgs(fn: AnalyzedFunction): string {
+  return fn.params
+    .map((p) => {
+      if (p.type?.includes('string')) return '""';
+      if (p.type?.includes('int')) return '-1';
+      return 'nil';
+    })
+    .join(', ');
+}
+
+function renderGoTestSuite(analysis: SourceAnalysis, testCases: TestCase[]): string {
+  const lines: string[] = [];
+
+  lines.push(`package ${getGoPackageName(analysis.filePath)}`);
+  lines.push('');
+  lines.push('import (');
+  lines.push('  "testing"');
+
+  const needsContext = testCases.some((tc) => tc.code?.includes('context.'));
+  const needsStrings = testCases.some((tc) => tc.code?.includes('strings.'));
+  const needsTime = testCases.some((tc) => tc.code?.includes('time.'));
+
+  if (needsContext) lines.push('  "context"');
+  if (needsStrings) lines.push('  "strings"');
+  if (needsTime) lines.push('  "time"');
+
+  lines.push(')');
+  lines.push('');
+
+  for (const test of testCases) {
+    if (test.code) {
+      lines.push(test.code);
+    } else {
+      lines.push(`func ${test.name}(t *testing.T) {`);
+      lines.push(`  // ${test.description}`);
+      lines.push(`  // Expected: ${test.expectedBehavior}`);
+      lines.push('  t.Skip("placeholder test")');
+      lines.push('}');
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+function getGoPackageName(filePath: string): string {
+  const parts = filePath.replace(/\\/g, '/').split('/');
+  const dir = parts.length > 1 ? parts[parts.length - 2] : 'main';
+  return dir ?? 'main';
+}
+
+function estimateGoCoverage(analysis: SourceAnalysis, testCases: TestCase[]): number {
+  const exportedFunctions = analysis.functions.filter((f) => f.isExported).length;
+  if (exportedFunctions === 0) return 0;
+  const testedFunctions = new Set(testCases.map((tc) => tc.name.replace(/^Test/, '').replace(/Error$/, '')));
+  const coveredRatio = Math.min(testedFunctions.size / exportedFunctions, 1);
+  return Math.min(Math.round(coveredRatio * 80 + 10), 100);
+}

package/src/generators/index.ts

@@ -0,0 +1,5 @@
+export { generateTestSuite, formatResults } from './generator.js';
+export { generateJsTsTestSuite } from './js-ts-generator.js';
+export { generatePythonTestSuite } from './python-generator.js';
+export { generateGoTestSuite } from './go-generator.js';
+export { generateWithAI, buildAISuite } from './ai-generator.js';