@kakarot-ci/core 0.7.0 → 0.7.1

package/README.md

@@ -1,2 +1,457 @@
-# kakarot-ci
-The core package for kakarot-ci
+<div align="center">
+  <img src="assets/logo.svg" alt="Kakarot CI Logo" width="200">
+  
+  # Kakarot CI
+  
+  [![npm version](https://img.shields.io/npm/v/@kakarot-ci/core.svg)](https://www.npmjs.com/package/@kakarot-ci/core)
+  [![Node.js version](https://img.shields.io/node/v/@kakarot-ci/core.svg)](https://nodejs.org/)
+</div>
+
+> AI-powered unit test generation for TypeScript and JavaScript
+
+> **⚠️ Beta Software**: This project is currently in beta. While functional, expect occasional bugs and breaking changes as we iterate and improve. Please report issues and provide feedback!
+
+Kakarot CI automatically generates comprehensive unit tests using AI. While optimized for pull request workflows, it can be used in various scenarios: analyzing PR changes, generating tests for specific files, or creating test suites for entire codebases. It analyzes code, generates test files, runs them, and can automatically commit results back to your repository.
+
+## Features
+
+- 🤖 **AI-Powered Test Generation**: Uses LLMs (OpenAI, Anthropic, Google) to generate comprehensive unit tests
+- 🔍 **Smart Code Analysis**: Analyzes AST to extract functions and understand code structure
+- 🎯 **Targeted Testing**: Generates tests for specific functions, files, or entire codebases
+- 🔄 **Auto-Fix Loop**: Automatically fixes failing tests with multiple retry attempts
+- 📊 **Coverage Reports**: Optional test coverage analysis and summaries
+- 🚀 **GitHub Integration**: Seamlessly integrates with GitHub Actions and PR workflows (optional)
+- ⚙️ **Flexible Configuration**: Supports Jest and Vitest, configurable test locations and patterns
+- 📝 **PR Comments**: Automatically posts test generation summaries to pull requests
+
+## Installation
+
+```bash
+npm install --save-dev @kakarot-ci/core
+```
+
+## Usage
+
+### Pull Request Workflow (Primary Use Case)
+
+The simplest way to use Kakarot CI is via the command-line interface for pull requests:
+
+```bash
+npx kakarot-ci --pr 123 --owner myorg --repo myrepo --token ghp_xxxxx
+```
+
+Or in a GitHub Actions workflow:
+
+```yaml
+- name: Generate Tests
+  run: npx kakarot-ci
+  env:
+    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    KAKAROT_API_KEY: ${{ secrets.KAKAROT_API_KEY }}
+```
+
+The CLI automatically detects:
+- PR number from `GITHUB_EVENT_PATH` (GitHub Actions)
+- Repository owner/repo from `GITHUB_REPOSITORY` or git remote
+- GitHub token from `GITHUB_TOKEN` environment variable
+
+### Programmatic API
+
+#### Pull Request Processing
+
+```typescript
+import { runPullRequest } from '@kakarot-ci/core';
+
+const summary = await runPullRequest({
+  prNumber: 123,
+  owner: 'myorg',
+  repo: 'myrepo',
+  githubToken: 'ghp_xxxxx',
+});
+
+console.log(`Generated ${summary.testsGenerated} tests`);
+```
+
+#### Custom Workflows
+
+You can also use the lower-level APIs for custom workflows:
+
+```typescript
+import { 
+  TestGenerator, 
+  extractTestTargets,
+  analyzeFile,
+  writeTestFiles 
+} from '@kakarot-ci/core';
+
+// Generate tests for specific files
+const targets = await analyzeFile('src/utils.ts', 'main', githubClient, config);
+const generator = new TestGenerator({ apiKey, provider: 'openai' });
+
+for (const target of targets) {
+  const test = await generator.generateTest({
+    target,
+    framework: 'vitest',
+  });
+  // Write test file...
+}
+
+// Or extract targets from file diffs
+const prFiles = [...]; // Your file changes
+const targets = await extractTestTargets(prFiles, githubClient, 'sha', config);
+```
+
+## Configuration
+
+Kakarot CI can be configured via:
+
+1. **Config file**: `kakarot.config.js`, `.kakarot-ci.config.js`, or `.kakarot-ci.config.json`
+2. **package.json**: Add a `kakarotCi` field
+3. **Environment variables**: `KAKAROT_API_KEY`, `GITHUB_TOKEN`, etc.
+
+**Note**: TypeScript config files (`.ts`) are not supported in the compiled package. Use JavaScript (`.js`) or JSON (`.json`) config files instead.
+
+### Configuration Options
+
+#### Required
+
+- **`apiKey`** (string, required)
+  - Your LLM provider API key
+  - Can also be set via `KAKAROT_API_KEY` environment variable
+  - Example: `"sk-xxxxx"` (OpenAI) or `"sk-ant-xxxxx"` (Anthropic)
+
+#### LLM Provider Settings
+
+- **`provider`** (string, optional, default: `"openai"`)
+  - LLM provider to use: `"openai"`, `"anthropic"`, or `"google"`
+  - Can also be set via `PROVIDER` environment variable
+  - Example: `"anthropic"`
+
+- **`model`** (string, optional)
+  - Specific model to use (provider-specific)
+  - Can also be set via `MODEL` environment variable
+  - Defaults to provider's recommended model
+  - Examples: `"gpt-4"`, `"claude-3-opus-20240229"`, `"gemini-pro"`
+
+- **`maxTokens`** (number, optional, default: provider default)
+  - Maximum tokens in response (1-100000)
+  - Example: `4000`
+
+- **`temperature`** (number, optional, default: `0.2`)
+  - Temperature for test generation (0-2)
+  - Lower values = more consistent, higher = more creative
+  - Example: `0.2`
+
+- **`fixTemperature`** (number, optional, default: `0.2`)
+  - Temperature for test fixing attempts (0-2)
+  - Example: `0.3`
+
+- **`maxFixAttempts`** (number, optional, default: `3`)
+  - Maximum number of attempts to fix failing tests (0-5)
+  - Example: `5`
+
+#### Test Framework
+
+- **`framework`** (string, required)
+  - Test framework: `"jest"` or `"vitest"`
+  - Example: `"vitest"`
+
+#### Test File Organization
+
+- **`testLocation`** (string, optional, default: `"separate"`)
+  - Where to place test files: `"separate"` or `"co-located"`
+  - `"separate"`: Tests in a dedicated test directory
+  - `"co-located"`: Tests next to source files
+  - Example: `"co-located"`
+
+- **`testDirectory`** (string, optional, default: `"__tests__"`)
+  - Directory name for test files (when `testLocation` is `"separate"`)
+  - Example: `"tests"` or `"__tests__"`
+
+- **`testFilePattern`** (string, optional, default: `"*.test.ts"`)
+  - Glob pattern for test file names
+  - Example: `"*.spec.ts"` or `"*.test.js"`
+
+#### File Filtering
+
+- **`includePatterns`** (string[], optional, default: `["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"]`)
+  - Glob patterns for files to include when scanning for changes
+  - Example: `["src/**/*.ts", "lib/**/*.ts"]`
+
+- **`excludePatterns`** (string[], optional, default: `["**/*.test.ts", "**/*.spec.ts", "**/*.test.js", "**/*.spec.js", "**/node_modules/**"]`)
+  - Glob patterns for files to exclude
+  - Example: `["**/*.test.ts", "**/vendor/**"]`
+
+#### Limits
+
+- **`maxTestsPerPR`** (number, optional, default: `50`)
+  - Maximum number of test targets to process per PR
+  - Prevents excessive API usage on large PRs
+  - Example: `100`
+
+#### GitHub Integration
+
+- **`githubToken`** (string, optional)
+  - GitHub personal access token
+  - Can also be set via `GITHUB_TOKEN` environment variable
+  - Required for GitHub operations (commits, PR comments)
+  - Example: `"ghp_xxxxx"`
+
+- **`githubOwner`** (string, optional)
+  - Repository owner (can be auto-detected from git remote)
+  - Example: `"myorg"`
+
+- **`githubRepo`** (string, optional)
+  - Repository name (can be auto-detected from git remote)
+  - Example: `"myrepo"`
+
+#### Commit Strategy
+
+- **`enableAutoCommit`** (boolean, optional, default: `true`)
+  - Automatically commit generated tests
+  - Example: `false` (to review tests before committing)
+
+- **`commitStrategy`** (string, optional, default: `"direct"`)
+  - How to commit tests: `"direct"` or `"branch-pr"`
+  - `"direct"`: Commit directly to PR branch
+  - `"branch-pr"`: Create a new branch and open a PR
+  - Example: `"branch-pr"`
+
+- **`enablePRComments`** (boolean, optional, default: `true`)
+  - Post test generation summary as PR comment
+  - Example: `true`
+
+#### Coverage
+
+- **`enableCoverage`** (boolean, optional, default: `false`)
+  - Enable test coverage collection and reporting
+  - Example: `true`
+
+#### Debugging
+
+- **`debug`** (boolean, optional, default: `false`)
+  - Enable debug logging
+  - Can also be set via `KAKAROT_DEBUG=true` environment variable
+  - Example: `true`
+
+### Example Configuration
+
+**`kakarot.config.js`**:
+
+```javascript
+/** @type {import('@kakarot-ci/core').KakarotConfig} */
+const config = {
+  // Required: API key (can also be set via KAKAROT_API_KEY env var)
+  apiKey: process.env.OPENAI_API_KEY,
+  
+  // Required: Test framework
+  framework: 'vitest',
+  
+  // Optional: LLM provider settings (can also be set via PROVIDER and MODEL env vars)
+  provider: 'openai', // 'openai' | 'anthropic' | 'google'
+  model: 'gpt-4',
+  temperature: 0.2,
+  fixTemperature: 0.2,
+  maxTokens: 4000,
+  
+  // File filtering
+  includePatterns: ['src/**/*.ts'],
+  excludePatterns: [
+    '**/*.test.ts',
+    '**/*.spec.ts',
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/coverage/**',
+  ],
+  
+  // Test file organization
+  testLocation: 'co-located', // 'separate' | 'co-located'
+  testDirectory: '__tests__', // Only used when testLocation is 'separate'
+  testFilePattern: '*.test.ts',
+  
+  // Limits and behavior
+  maxTestsPerPR: 50,
+  maxFixAttempts: 3,
+  
+  // GitHub integration
+  enableAutoCommit: true,
+  commitStrategy: 'branch-pr', // 'direct' | 'branch-pr'
+  enablePRComments: true,
+  
+  // Optional features
+  enableCoverage: false,
+  debug: true,
+};
+
+module.exports = config;
+```
+
+**`.kakarot-ci.config.json`** (minimal example):
+
+```json
+{
+  "framework": "vitest",
+  "includePatterns": ["src/**/*.ts"],
+  "excludePatterns": [
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    "**/node_modules/**",
+    "**/dist/**"
+  ],
+  "maxFixAttempts": 3,
+  "enableAutoCommit": true,
+  "commitStrategy": "branch-pr",
+  "enablePRComments": true
+}
+```
+
+**Note**: The `apiKey` should be provided via the `KAKAROT_API_KEY` environment variable for security.
+
+**`package.json`**:
+
+```json
+{
+  "kakarotCi": {
+    "framework": "vitest",
+    "testLocation": "co-located",
+    "maxTestsPerPR": 50
+  }
+}
+```
+
+## GitHub Actions Integration
+
+Create a workflow file (`.github/workflows/kakarot-ci.yml`):
+
+```yaml
+name: Kakarot CI
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+jobs:
+  generate-tests:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write  # Required to push commits directly to branch (commitStrategy: 'direct')
+      pull-requests: write  # Required to create PRs (commitStrategy: 'branch-pr') and post comments
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Generate tests
+        run: npx kakarot-ci
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          KAKAROT_API_KEY: ${{ secrets.KAKAROT_API_KEY }}
+          # Optional: Override provider/model via env vars
+          # PROVIDER: openai
+          # MODEL: gpt-4
+          
+```
+
+**Note on permissions:**
+- `contents: write` is required to push commits directly to the PR branch (when using `commitStrategy: 'direct'`, the default)
+- `pull-requests: write` is required to:
+  - Create pull requests (when using `commitStrategy: 'branch-pr'`)
+  - Post PR comments (when `enablePRComments: true`)
+- Both permissions are recommended for full functionality
+
+**Using a Personal Access Token (PAT):**
+
+If your organization restricts `GITHUB_TOKEN` permissions, you'll need to use a Personal Access Token:
+
+```yaml
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GH_PAT }}  # Use PAT instead of GITHUB_TOKEN
+
+      - name: Generate tests
+        run: npx kakarot-ci
+        env:
+          GITHUB_TOKEN: ${{ secrets.GH_PAT }}  # Use PAT instead of GITHUB_TOKEN
+          KAKAROT_API_KEY: ${{ secrets.KAKAROT_API_KEY }}
+          # Optional: Override provider/model via env vars
+          # PROVIDER: openai
+          # MODEL: gpt-4
+```
+
+Create a PAT with `repo` scope and add it as a repository secret named `GH_PAT`.
+
+## How It Works
+
+### Pull Request Workflow
+
+1. **Analyze PR Changes**: Scans the pull request diff to identify changed files
+2. **Extract Functions**: Uses AST analysis to find functions, methods, and classes that were modified
+3. **Generate Tests**: Sends function code to LLM with carefully crafted prompts to generate comprehensive tests
+4. **Run Tests**: Executes the generated tests using your configured test framework
+5. **Fix Failures**: Automatically attempts to fix failing tests (up to `maxFixAttempts` times)
+6. **Commit Results**: Commits generated tests back to the PR (if `enableAutoCommit` is true)
+7. **Post Summary**: Posts a summary comment to the PR with test generation results
+
+### Core Components
+
+The tool is built with modular components that can be used independently:
+
+- **AST Analysis**: Extracts functions, methods, and classes from TypeScript/JavaScript files
+- **Test Generation**: Uses LLM prompts optimized for generating accurate, comprehensive tests
+- **Test Execution**: Runs tests using Jest or Vitest
+- **Auto-Fix Loop**: Iteratively fixes failing tests using LLM feedback
+- **GitHub Integration**: Optional integration for PR workflows, commits, and comments
+
+You can use these components programmatically for custom workflows beyond pull requests.
+
+## Requirements
+
+- Node.js >= 18.0.0
+- A test framework (Jest or Vitest) already set up in your project
+- An API key for your chosen LLM provider (OpenAI, Anthropic, or Google)
+- GitHub token with appropriate permissions (required only for GitHub integration features)
+
+## CLI Options
+
+```bash
+kakarot-ci [options]
+
+Options:
+  --pr <number>        Pull request number
+  --owner <string>     Repository owner
+  --repo <string>      Repository name
+  --token <string>     GitHub token (or use GITHUB_TOKEN env var)
+  -V, --version        Show version number
+  -h, --help           Display help
+```
+
+## Environment Variables
+
+- `KAKAROT_API_KEY`: LLM provider API key (required, can also be set in config file)
+- `PROVIDER`: LLM provider (`openai`, `anthropic`, or `google`, can also be set in config file)
+- `MODEL`: LLM model name (e.g., `gpt-4`, `claude-3-opus-20240229`, can also be set in config file)
+- `GITHUB_TOKEN`: GitHub personal access token (required for GitHub operations)
+- `GITHUB_REPOSITORY`: Repository in format `owner/repo` (auto-detected in GitHub Actions)
+- `GITHUB_EVENT_PATH`: Path to GitHub event JSON (auto-set in GitHub Actions)
+- `PR_NUMBER`: Pull request number (alternative to `--pr` flag)
+- `KAKAROT_DEBUG`: Enable debug logging (`true`/`false`)
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+**Note**: This project is maintained by a single person as a side project. While I do my best to respond to issues and review PRs, response times may vary. Your patience and understanding are appreciated!
+
+## License
+
+[BUSL-1.1](LICENSE)

package/dist/cli/index.js

@@ -276,6 +276,7 @@ var GitHubClient = class {
   async fileExists(ref, path) {
     const originalError = console.error;
     const originalWarn = console.warn;
+    const originalLog = console.log;
     const suppress404 = (...args) => {
       const message = String(args[0] || "");
       if (message.includes("404") || message.includes("Not Found")) {
@@ -290,9 +291,17 @@ var GitHubClient = class {
       }
       originalWarn(...args);
     };
+    const suppress404Log = (...args) => {
+      const message = String(args[0] || "");
+      if (message.includes("404") || message.includes("Not Found")) {
+        return;
+      }
+      originalLog(...args);
+    };
     try {
       console.error = suppress404;
       console.warn = suppress404Warn;
+      console.log = suppress404Log;
       await this.octokit.rest.repos.getContent({
         owner: this.owner,
         repo: this.repo,
@@ -315,6 +324,7 @@ var GitHubClient = class {
     } finally {
       console.error = originalError;
       console.warn = originalWarn;
+      console.log = originalLog;
     }
   }
   /**
@@ -374,24 +384,11 @@ async function findProjectRoot(startPath) {
 async function loadConfig() {
   const explorer = cosmiconfig("kakarot", {
     searchPlaces: [
-      "kakarot.config.ts",
       "kakarot.config.js",
-      ".kakarot-ci.config.ts",
       ".kakarot-ci.config.js",
       ".kakarot-ci.config.json",
       "package.json"
-    ],
-    loaders: {
-      ".ts": async (filepath) => {
-        try {
-          const configModule = await import(filepath);
-          return configModule.default || configModule.config || null;
-        } catch (err) {
-          error(`Failed to load TypeScript config: ${err instanceof Error ? err.message : String(err)}`);
-          return null;
-        }
-      }
-    }
+    ]
   });
   try {
     const result = await explorer.search();
@@ -428,7 +425,7 @@ async function loadConfig() {
   } catch (err) {
     if (err instanceof Error && err.message.includes("apiKey")) {
       error(
-        "Missing required apiKey. Provide it via:\n  - Config file (kakarot.config.ts, .kakarot-ci.config.js/json, or package.json)\n  - Environment variable: KAKAROT_API_KEY"
+        "Missing required apiKey. Provide it via:\n  - Config file (kakarot.config.js, .kakarot-ci.config.js/json, or package.json)\n  - Environment variable: KAKAROT_API_KEY"
       );
     }
     throw err;
@@ -1068,15 +1065,49 @@ function buildSystemPrompt(framework) {
   const importStatement = framework === "jest" ? "import { describe, it, expect } from 'jest';" : "import { describe, it, expect } from 'vitest';";
   return `You are an expert ${frameworkName} test writer. Your task is to generate comprehensive unit tests for TypeScript/JavaScript functions.
 
+CRITICAL: Test the ACTUAL behavior of the code, not assumed behavior.
+
 Requirements:
 1. Generate complete, runnable ${frameworkName} test code
 2. Use ${frameworkName} syntax and best practices
-3. Test edge cases, error conditions, and normal operation
-4. Use descriptive test names that explain what is being tested
-5. Include proper setup/teardown if needed
-6. Mock external dependencies appropriately
-7. Test both success and failure scenarios
-8. Follow the existing test file structure if one exists
+3. Analyze the function code to determine its ACTUAL runtime behavior before writing tests
+4. Test edge cases and normal operation based on what the code actually does
+5. Only test for errors/exceptions if the code actually throws them (check for try/catch, throw statements, or validation logic)
+6. Match JavaScript/TypeScript runtime semantics:
+   - Arithmetic operations (+, -, *, /, %, **) do NOT throw errors for invalid inputs; they return NaN or Infinity
+   - Division by zero returns Infinity (not an error)
+   - Modulo by zero returns NaN (not an error)
+   - Bitwise operations convert values to 32-bit integers
+   - Operations with null/undefined may coerce to numbers or return NaN
+   - TypeScript types are compile-time only; runtime behavior follows JavaScript rules
+7. For async functions:
+   - Use async/await or .then()/.catch() appropriately
+   - Test both resolved and rejected promises
+   - Use resolves and rejects matchers when appropriate
+   - Await async function calls in tests
+8. For functions with side effects or external dependencies:
+   - Mock external dependencies (APIs, file system, databases, etc.)
+   - Mock imported modules using ${framework === "jest" ? "jest.mock()" : "vi.mock()"}
+   - Reset mocks between tests to ensure test isolation
+   - Verify mock calls if the function's behavior depends on them
+9. For functions that modify state:
+   - Test state before and after function calls
+   - Reset state between tests if needed
+   - Test state mutations, not just return values
+10. For error testing:
+   - Only test for errors if the function actually throws them
+   - Match actual error types and messages (use toThrow() with specific error types/messages)
+   - For async errors, use rejects matcher
+11. Import handling:
+   - Use the same import paths as the source file
+   - Import types correctly (type imports for TypeScript types)
+   - Mock dependencies at the module level, not the function level
+12. Test isolation:
+   - Each test should be independent and not rely on other tests
+   - Use beforeEach/afterEach for setup/teardown when needed
+   - Don't share mutable state between tests
+13. Use descriptive test names that explain what is being tested
+14. Follow the existing test file structure if one exists
 
 Output format:
 - Return ONLY the test code, no explanations or markdown code blocks
@@ -1146,18 +1177,38 @@ ${existingTestFile}
 
 `;
   }
-  prompt += `Generate comprehensive unit tests for ${target.functionName}. Include:
+  prompt += `Generate comprehensive unit tests for ${target.functionName}. IMPORTANT: Analyze the function code above to determine its ACTUAL behavior before writing tests.
+
+`;
+  prompt += `Include:
 `;
   prompt += `- Tests for normal operation with various inputs
 `;
-  prompt += `- Tests for edge cases (null, undefined, empty arrays, etc.)
+  prompt += `- Tests for edge cases based on what the code actually does (null, undefined, empty arrays, etc.)
 `;
-  prompt += `- Tests for error conditions if applicable
+  prompt += `- Tests for error conditions ONLY if the code actually throws errors (check for throw statements, validation, or error handling)
 `;
   prompt += `- Tests for boundary conditions
 `;
   prompt += `- Proper mocking of dependencies if needed
 
+`;
+  prompt += `Key considerations:
+`;
+  prompt += `- If the function is async, use async/await in tests and test both success and error cases
+`;
+  prompt += `- If the function uses external dependencies (imports), mock them appropriately
+`;
+  prompt += `- If the function modifies state, test the state changes
+`;
+  prompt += `- Match actual return types and values, not assumed types
+`;
+  prompt += `- TypeScript types are compile-time only; test runtime behavior
+`;
+  prompt += `- JavaScript/TypeScript arithmetic and bitwise operations do NOT throw errors for invalid inputs. They return NaN, Infinity, or perform type coercion. Only test for errors if the function code explicitly throws them.
+`;
+  prompt += `- Use the same import paths as the source file for consistency
+
 `;
   prompt += `Return ONLY the test code, no explanations or markdown formatting.`;
   return prompt;
@@ -1182,13 +1233,34 @@ Context:
 - The test code failed to run or produced incorrect results
 - You need to analyze the error and fix the test code
 
+CRITICAL: Tests must match the ACTUAL behavior of the code being tested, not assumed behavior.
+
 Requirements:
-1. Fix the test code to make it pass
-2. Maintain the original test intent
-3. Use proper ${frameworkName} syntax
-4. Ensure all imports and dependencies are correct
-5. Fix any syntax errors, type errors, or logical errors
-6. If the original code being tested has issues, note that but focus on fixing the test
+1. Analyze the original function code to understand its ACTUAL runtime behavior
+2. Fix the test code to match what the function actually does, not what it "should" do
+3. Only expect errors/exceptions if the function code actually throws them
+4. Match JavaScript/TypeScript runtime semantics:
+   - Arithmetic operations do NOT throw errors; they return NaN or Infinity
+   - Division by zero returns Infinity (not an error)
+   - Modulo by zero returns NaN (not an error)
+   - Bitwise operations convert values to 32-bit integers
+   - TypeScript types are compile-time only; runtime behavior follows JavaScript rules
+5. For async functions:
+   - Ensure tests properly await async calls
+   - Use resolves/rejects matchers appropriately
+   - Test both success and error cases for async functions
+6. For functions with dependencies:
+   - Ensure mocks are properly set up
+   - Verify import paths match the source file
+   - Reset mocks if needed for test isolation
+7. For error testing:
+   - Only expect errors if the function actually throws them
+   - Match actual error types and messages
+   - Use appropriate matchers (toThrow, rejects, etc.)
+8. Maintain the original test intent where possible, but prioritize correctness
+9. Use proper ${frameworkName} syntax
+10. Ensure all imports and dependencies are correct
+11. Fix any syntax errors, type errors, or logical errors
 
 Output format:
 - Return ONLY the fixed test code, no explanations or markdown code blocks