autotest-ai 1.0.0

package/README.md

@@ -0,0 +1,262 @@
+# autotest-ai
+
+**AI-powered test generator. Generate unit tests from your code using Claude or OpenAI.**
+
+Stop writing tests manually. Let AI analyze your code and generate comprehensive unit tests.
+
+[![npm version](https://img.shields.io/npm/v/autotest-ai.svg)](https://www.npmjs.com/package/autotest-ai)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg)](https://www.typescriptlang.org/)
+
+---
+
+## Features
+
+- **AI-Powered**: Uses Claude or OpenAI to understand your code and generate meaningful tests
+- **Multiple Frameworks**: Supports Jest, Vitest, Node.js test runner, and Mocha
+- **Edge Cases**: Automatically generates tests for edge cases (null, undefined, empty values)
+- **TypeScript Support**: Generates TypeScript or JavaScript tests
+- **CLI & API**: Use from command line or programmatically
+- **Batch Processing**: Generate tests for entire directories
+
+---
+
+## Installation
+
+```bash
+npm install -g autotest-ai
+```
+
+Or use with npx:
+```bash
+npx autotest-ai src/utils.ts
+```
+
+---
+
+## Quick Start
+
+### 1. Set your API key
+
+```bash
+# For Claude (recommended)
+export ANTHROPIC_API_KEY=your-api-key
+
+# For OpenAI
+export OPENAI_API_KEY=your-api-key
+```
+
+### 2. Generate tests
+
+```bash
+# Generate tests for a file
+autotest src/utils.ts
+
+# Generate tests for all files in a directory
+autotest src/
+```
+
+### 3. Run your tests
+
+```bash
+npm test
+```
+
+---
+
+## CLI Usage
+
+```bash
+autotest <file|directory> [options]
+```
+
+### Options
+
+| Option | Description |
+|--------|-------------|
+| `-p, --provider <claude\|openai>` | AI provider (default: claude) |
+| `-m, --model <model>` | Model to use |
+| `-f, --framework <framework>` | Test framework: jest, vitest, node, mocha |
+| `-o, --output <dir>` | Output directory (default: __tests__) |
+| `--no-edge-cases` | Skip edge case tests |
+| `--js` | Generate JavaScript instead of TypeScript |
+| `--dry-run` | Print tests without writing files |
+| `-h, --help` | Show help |
+
+### Examples
+
+```bash
+# Generate Jest tests (default)
+autotest src/utils.ts
+
+# Generate Vitest tests
+autotest src/utils.ts --framework vitest
+
+# Use OpenAI instead of Claude
+autotest src/utils.ts --provider openai
+
+# Preview generated tests without writing
+autotest src/utils.ts --dry-run
+
+# Generate tests for entire src directory
+autotest src/
+
+# Generate JavaScript tests
+autotest src/utils.js --js
+```
+
+---
+
+## Programmatic API
+
+```typescript
+import { generateTests, generateAndWriteTests } from 'autotest-ai';
+
+// Generate tests (returns test code)
+const result = await generateTests('src/utils.ts', {
+  provider: 'claude',
+  framework: 'jest',
+  edgeCases: true,
+});
+
+console.log(result.testCode);
+console.log(`Functions tested: ${result.functions.join(', ')}`);
+
+// Generate and write tests to file
+const written = await generateAndWriteTests('src/utils.ts', {
+  framework: 'vitest',
+  outputDir: '__tests__',
+});
+
+console.log(`Test file created: ${written.testFile}`);
+```
+
+### API Reference
+
+#### `generateTests(filePath, config?)`
+
+Generates tests for a file and returns the result.
+
+```typescript
+interface GenerateResult {
+  sourceFile: string;      // Original source file path
+  testFile: string;        // Generated test file path
+  testCode: string;        // Generated test code
+  functions: string[];     // Functions that were tested
+  tokensUsed?: number;     // API tokens used
+}
+```
+
+#### `generateAndWriteTests(filePath, config?)`
+
+Generates tests and writes them to a file.
+
+#### `generateTestsForDirectory(dirPath, config?)`
+
+Generates tests for all source files in a directory.
+
+### Config Options
+
+```typescript
+interface AutoTestConfig {
+  provider?: 'claude' | 'openai';  // AI provider
+  apiKey?: string;                  // API key (or use env var)
+  model?: string;                   // Model to use
+  framework?: 'jest' | 'vitest' | 'node' | 'mocha';
+  outputDir?: string;               // Output directory
+  edgeCases?: boolean;              // Include edge cases
+  typescript?: boolean;             // Generate TypeScript
+}
+```
+
+---
+
+## Example Output
+
+### Input: `src/math.ts`
+```typescript
+export function add(a: number, b: number): number {
+  return a + b;
+}
+
+export function divide(a: number, b: number): number {
+  if (b === 0) throw new Error('Division by zero');
+  return a / b;
+}
+```
+
+### Generated: `__tests__/math.test.ts`
+```typescript
+import { describe, it, expect } from '@jest/globals';
+import { add, divide } from '../src/math';
+
+describe('add', () => {
+  it('should add two positive numbers', () => {
+    expect(add(2, 3)).toBe(5);
+  });
+
+  it('should add negative numbers', () => {
+    expect(add(-1, -1)).toBe(-2);
+  });
+
+  it('should handle zero', () => {
+    expect(add(0, 5)).toBe(5);
+    expect(add(5, 0)).toBe(5);
+  });
+});
+
+describe('divide', () => {
+  it('should divide two numbers', () => {
+    expect(divide(10, 2)).toBe(5);
+  });
+
+  it('should handle decimal results', () => {
+    expect(divide(5, 2)).toBe(2.5);
+  });
+
+  it('should throw error for division by zero', () => {
+    expect(() => divide(10, 0)).toThrow('Division by zero');
+  });
+});
+```
+
+---
+
+## Supported Test Frameworks
+
+| Framework | Command |
+|-----------|---------|
+| **Jest** | `autotest file.ts --framework jest` |
+| **Vitest** | `autotest file.ts --framework vitest` |
+| **Node.js** | `autotest file.ts --framework node` |
+| **Mocha** | `autotest file.ts --framework mocha` |
+
+---
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `ANTHROPIC_API_KEY` | API key for Claude |
+| `OPENAI_API_KEY` | API key for OpenAI |
+
+---
+
+## Tips
+
+1. **Better tests with better code**: Well-documented functions with clear types produce better tests
+2. **Review generated tests**: AI-generated tests are a starting point, review and adjust as needed
+3. **Use --dry-run first**: Preview tests before writing to files
+4. **Combine with TDD**: Generate initial tests, then refine as you develop
+
+---
+
+## Support
+
+If autotest-ai saved you time:
+- Star the [GitHub repo](https://github.com/willzhangfly/autotest-ai)
+- [Buy me a coffee](https://buymeacoffee.com/willzhangfly)
+
+## License
+
+MIT

package/dist/chunk-OAREENOQ.mjs

@@ -0,0 +1,201 @@
+// src/index.ts
+import * as fs from "fs";
+import * as path from "path";
+var DEFAULT_CONFIG = {
+  provider: "claude",
+  apiKey: "",
+  model: "claude-sonnet-4-20250514",
+  framework: "jest",
+  outputDir: "__tests__",
+  edgeCases: true,
+  typescript: true
+};
+async function callClaude(prompt, apiKey, model) {
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: 4096,
+      messages: [{ role: "user", content: prompt }]
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Claude API error: ${response.status} - ${error}`);
+  }
+  const data = await response.json();
+  return {
+    content: data.content[0].text,
+    tokensUsed: data.usage.input_tokens + data.usage.output_tokens
+  };
+}
+async function callOpenAI(prompt, apiKey, model) {
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: 4096,
+      messages: [{ role: "user", content: prompt }]
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+  }
+  const data = await response.json();
+  return {
+    content: data.choices[0].message.content,
+    tokensUsed: data.usage.total_tokens
+  };
+}
+function buildPrompt(code, framework, edgeCases, typescript) {
+  const frameworkImports = {
+    jest: `import { describe, it, expect } from '@jest/globals';`,
+    vitest: `import { describe, it, expect } from 'vitest';`,
+    node: `import { describe, it } from 'node:test';
+import assert from 'node:assert';`,
+    mocha: `import { describe, it } from 'mocha';
+import { expect } from 'chai';`
+  };
+  const assertStyle = framework === "node" ? "assert" : "expect";
+  return `You are an expert test writer. Generate comprehensive unit tests for the following code.
+
+## Requirements:
+- Use ${framework} test framework
+- ${typescript ? "Use TypeScript" : "Use JavaScript"}
+- Import the functions being tested from the source file
+- ${edgeCases ? "Include edge cases (null, undefined, empty, boundary values)" : "Focus on happy path tests"}
+- Each test should have a clear, descriptive name
+- Use ${assertStyle} style assertions
+- Group related tests in describe blocks
+
+## Framework imports:
+${frameworkImports[framework]}
+
+## Source Code:
+\`\`\`${typescript ? "typescript" : "javascript"}
+${code}
+\`\`\`
+
+## Output:
+Generate ONLY the test code, no explanations. Start with imports and end with the last test.
+The test file should be complete and runnable.
+Import functions from '../src/filename' (adjust path as needed).`;
+}
+function extractFunctionNames(code) {
+  const functions = [];
+  const funcDecl = /function\s+(\w+)\s*\(/g;
+  let match;
+  while ((match = funcDecl.exec(code)) !== null) {
+    functions.push(match[1]);
+  }
+  const arrowFunc = /(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\(/g;
+  while ((match = arrowFunc.exec(code)) !== null) {
+    functions.push(match[1]);
+  }
+  const arrowSingle = /(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\w+\s*=>/g;
+  while ((match = arrowSingle.exec(code)) !== null) {
+    functions.push(match[1]);
+  }
+  const exportFunc = /export\s+(?:async\s+)?function\s+(\w+)/g;
+  while ((match = exportFunc.exec(code)) !== null) {
+    if (!functions.includes(match[1])) {
+      functions.push(match[1]);
+    }
+  }
+  const methods = /^\s*(?:async\s+)?(\w+)\s*\([^)]*\)\s*{/gm;
+  while ((match = methods.exec(code)) !== null) {
+    if (!["constructor", "if", "for", "while", "switch"].includes(match[1])) {
+      if (!functions.includes(match[1])) {
+        functions.push(match[1]);
+      }
+    }
+  }
+  return [...new Set(functions)];
+}
+async function generateTests(filePath, config = {}) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const apiKey = cfg.apiKey || (cfg.provider === "claude" ? process.env.ANTHROPIC_API_KEY : process.env.OPENAI_API_KEY) || "";
+  if (!apiKey) {
+    throw new Error(
+      `API key required. Set ${cfg.provider === "claude" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY"} environment variable or pass apiKey in config.`
+    );
+  }
+  const absolutePath = path.resolve(filePath);
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`File not found: ${absolutePath}`);
+  }
+  const code = fs.readFileSync(absolutePath, "utf-8");
+  const functions = extractFunctionNames(code);
+  if (functions.length === 0) {
+    throw new Error(`No functions found in ${filePath}`);
+  }
+  const prompt = buildPrompt(code, cfg.framework, cfg.edgeCases, cfg.typescript);
+  const model = cfg.model || (cfg.provider === "claude" ? "claude-sonnet-4-20250514" : "gpt-4o");
+  const callAI = cfg.provider === "claude" ? callClaude : callOpenAI;
+  const result = await callAI(prompt, apiKey, model);
+  let testCode = result.content;
+  const codeBlockMatch = testCode.match(/```(?:typescript|javascript|ts|js)?\n([\s\S]*?)```/);
+  if (codeBlockMatch) {
+    testCode = codeBlockMatch[1];
+  }
+  const ext = cfg.typescript ? ".test.ts" : ".test.js";
+  const baseName = path.basename(filePath, path.extname(filePath));
+  const testFileName = baseName + ext;
+  const testFilePath = path.join(path.dirname(absolutePath), cfg.outputDir, testFileName);
+  return {
+    sourceFile: absolutePath,
+    testFile: testFilePath,
+    testCode: testCode.trim(),
+    functions,
+    tokensUsed: result.tokensUsed
+  };
+}
+async function generateAndWriteTests(filePath, config = {}) {
+  const result = await generateTests(filePath, config);
+  const outputDir = path.dirname(result.testFile);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+  fs.writeFileSync(result.testFile, result.testCode);
+  return result;
+}
+async function generateTestsForDirectory(dirPath, config = {}) {
+  const results = [];
+  const absolutePath = path.resolve(dirPath);
+  const files = fs.readdirSync(absolutePath);
+  const sourceFiles = files.filter(
+    (f) => (f.endsWith(".ts") || f.endsWith(".js")) && !f.endsWith(".test.ts") && !f.endsWith(".test.js") && !f.endsWith(".spec.ts") && !f.endsWith(".spec.js") && !f.endsWith(".d.ts")
+  );
+  for (const file of sourceFiles) {
+    const filePath = path.join(absolutePath, file);
+    try {
+      const result = await generateAndWriteTests(filePath, config);
+      results.push(result);
+    } catch (error) {
+      console.error(`Error generating tests for ${file}:`, error);
+    }
+  }
+  return results;
+}
+var index_default = {
+  generateTests,
+  generateAndWriteTests,
+  generateTestsForDirectory
+};
+
+export {
+  generateTests,
+  generateAndWriteTests,
+  generateTestsForDirectory,
+  index_default
+};

package/dist/cli.d.mts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node