codeguard-testgen 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 CodeGuard Test Generator
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,300 @@
+# CodeGuard Test Generator
+
+AI-powered unit test generator with AST analysis for TypeScript/JavaScript projects. Automatically generates comprehensive Jest tests using Claude, OpenAI, or Gemini.
+
+## Features
+
+- 🤖 **AI-Powered**: Uses Claude, OpenAI GPT, or Google Gemini to generate intelligent tests
+- 🔍 **AST Analysis**: Deep code analysis using Babel parser for accurate test generation
+- 📦 **Codebase Indexing**: Optional caching for 100x faster analysis on large projects
+- 🎯 **Multiple Modes**: File-wise, folder-wise, or function-wise test generation
+- ✅ **Smart Validation**: Detects incomplete tests, missing assertions, and legitimate failures
+- 🔄 **Iterative Fixing**: Automatically fixes import errors, missing mocks, and test issues
+- 📋 **TypeScript Support**: Full support for TypeScript types, interfaces, and decorators
+
+## Installation
+
+### Global Installation (Recommended)
+
+```bash
+npm install -g codeguard-testgen
+```
+
+### Local Installation
+
+```bash
+npm install --save-dev codeguard-testgen
+```
+
+## Configuration
+
+Create a `codeguard.json` file in your project root:
+
+```json
+{
+  "aiProvider": "claude",
+  "apiKeys": {
+    "claude": "sk-ant-api03-...",
+    "openai": "sk-...",
+    "gemini": "..."
+  },
+  "models": {
+    "claude": "claude-sonnet-4-5-20250929",
+    "openai": "gpt-5-mini",
+    "gemini": "gemini-2.0-flash-lite"
+  },
+  "testDir": "src/tests",
+  "extensions": [".ts", ".tsx", ".js", ".jsx"],
+  "excludeDirs": ["node_modules", "dist", "build", ".git", "coverage"]
+}
+```
+
+### Configuration Options
+
+| Option | Required | Description |
+|--------|----------|-------------|
+| `aiProvider` | Yes | AI provider to use: `claude`, `openai`, or `gemini` |
+| `apiKeys` | Yes | API keys for the AI providers |
+| `models` | No | Custom model names (uses defaults if not specified) |
+| `testDir` | No | Directory for test files (default: `src/tests`) |
+| `extensions` | No | File extensions to process (default: `.ts`, `.tsx`, `.js`, `.jsx`) |
+| `excludeDirs` | No | Directories to exclude from scanning |
+
+### Getting API Keys
+
+- **Claude (Anthropic)**: https://console.anthropic.com/
+- **OpenAI**: https://platform.openai.com/api-keys
+- **Gemini (Google)**: https://makersuite.google.com/app/apikey
+
+## Usage
+
+### Interactive Mode
+
+Simply run the command and follow the prompts:
+
+```bash
+testgen
+```
+
+or
+
+```bash
+codeguard
+```
+
+You'll be guided through:
+1. Selecting test generation mode (file/folder/function-wise)
+2. Choosing files or functions to test
+3. Optional codebase indexing for faster processing
+
+### Test Generation Modes
+
+#### 1. File-wise Mode
+Generate tests for a single file:
+- Select from a list of source files
+- Generates comprehensive tests for all exported functions
+- Creates test file with proper structure and mocks
+
+#### 2. Folder-wise Mode
+Generate tests for all files in a directory:
+- Select a folder from your project
+- Processes all matching files recursively
+- Batch generates tests with progress tracking
+
+#### 3. Function-wise Mode
+Generate tests for specific functions:
+- Select a file
+- Choose which functions to test
+- Preserves existing tests for other functions
+- Ideal for incremental test development
+
+## How It Works
+
+1. **AST Analysis**: Parses your code using Babel to understand structure
+2. **Dependency Resolution**: Analyzes imports and calculates correct paths
+3. **AI Generation**: Uses AI to generate comprehensive test cases
+4. **Validation**: Checks for completeness, assertions, and coverage
+5. **Execution**: Runs tests with Jest to verify correctness
+6. **Iterative Fixing**: Automatically fixes common issues like:
+   - Import path errors
+   - Missing mocks
+   - Database initialization errors
+   - Type mismatches
+7. **Failure Detection**: Distinguishes between test bugs and source code bugs
+
+## Generated Test Features
+
+The AI generates tests with:
+
+- ✅ Proper imports and type definitions
+- ✅ Jest mocks for dependencies
+- ✅ Multiple test cases per function:
+  - Happy path scenarios
+  - Edge cases (null, undefined, empty arrays)
+  - Error conditions
+  - Async behavior testing
+- ✅ Clear, descriptive test names
+- ✅ Complete implementations (no placeholder comments)
+- ✅ Real assertions with expect() statements
+
+## Advanced Features
+
+### Codebase Indexing
+
+On first run, you'll be prompted to enable codebase indexing:
+
+```
+Enable codebase indexing? (y/n)
+```
+
+Benefits:
+- 100x+ faster analysis on subsequent runs
+- Instant dependency lookups
+- Cached AST parsing
+- Automatic update detection
+
+The index is stored in `.codeguard-cache/` and automatically updates when files change.
+
+### Legitimate Failure Detection
+
+The tool distinguishes between:
+
+**Fixable Test Issues** (automatically fixed):
+- Wrong import paths
+- Missing mocks
+- Incorrect assertions
+- TypeScript errors
+
+**Legitimate Source Code Bugs** (reported, not fixed):
+- Function returns wrong type
+- Missing null checks
+- Logic errors
+- Unhandled edge cases
+
+When legitimate bugs are found, they're reported with details for you to fix in the source code.
+
+## Examples
+
+### Example: Testing a User Service
+
+```typescript
+// src/services/user.service.ts
+export class UserService {
+  async getUser(id: string): Promise<User> {
+    return await this.db.findUser(id);
+  }
+}
+```
+
+Generated test:
+
+```typescript
+// src/tests/services/user.service.test.ts
+import { UserService } from '../../services/user.service';
+
+jest.mock('../../database');
+
+describe('UserService', () => {
+  describe('getUser', () => {
+    test('should return user when id exists', async () => {
+      const mockUser = { id: '123', name: 'John' };
+      const service = new UserService();
+      service.db.findUser = jest.fn().mockResolvedValue(mockUser);
+      
+      const result = await service.getUser('123');
+      
+      expect(result).toEqual(mockUser);
+      expect(service.db.findUser).toHaveBeenCalledWith('123');
+    });
+    
+    test('should handle null id', async () => {
+      const service = new UserService();
+      await expect(service.getUser(null)).rejects.toThrow();
+    });
+  });
+});
+```
+
+## Troubleshooting
+
+### "Configuration Error: codeguard.json not found"
+
+Create a `codeguard.json` file in your project root. See Configuration section above.
+
+### "API key not configured"
+
+Ensure your `codeguard.json` has the correct API key for your selected provider:
+
+```json
+{
+  "aiProvider": "claude",
+  "apiKeys": {
+    "claude": "sk-ant-..."
+  }
+}
+```
+
+### Tests fail with import errors
+
+The tool automatically detects and fixes import path errors. If issues persist:
+1. Check that all dependencies are installed
+2. Verify your project structure matches expected paths
+3. Ensure TypeScript is configured correctly
+
+### "Missing required packages"
+
+Install Babel dependencies:
+
+```bash
+npm install --save-dev @babel/parser @babel/traverse
+```
+
+## Programmatic Usage
+
+You can also use CodeGuard as a library:
+
+```typescript
+import { generateTests, analyzeFileAST } from 'codeguard-testgen';
+
+// Generate tests for a file
+await generateTests('src/services/user.service.ts');
+
+// Analyze a file's AST
+const analysis = analyzeFileAST('src/utils/helpers.ts');
+console.log(analysis.functions);
+```
+
+## Project Structure
+
+After installation, your project will have:
+
+```
+your-project/
+├── codeguard.json          # Configuration file
+├── src/
+│   ├── services/
+│   │   └── user.service.ts
+│   └── tests/              # Generated tests
+│       └── services/
+│           └── user.service.test.ts
+└── .codeguard-cache/       # Optional index cache
+```
+
+## Requirements
+
+- Node.js >= 16.0.0
+- Jest (for running generated tests)
+- TypeScript (for TypeScript projects)
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions welcome! Please open an issue or submit a pull request.
+
+## Support
+
+For issues, questions, or feature requests, please open an issue on GitHub.
+

package/bin/testgen.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+/**
+ * CodeGuard Test Generator CLI Entry Point
+ * 
+ * This is the executable entry point for the npm package.
+ * It loads the compiled TypeScript code from dist/ and runs the main function.
+ */
+
+const { main } = require('../dist/index.js');
+
+// Run the main function and handle errors
+main().catch((error) => {
+  console.error('Error:', error.message);
+  process.exit(1);
+});
+

package/dist/codebaseIndexer.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Codebase Indexer - Caches AST analysis for faster test generation
+ *
+ * This is completely optional. Test generation works fine without it,
+ * but indexing provides significant speed improvements.
+ */
+interface FunctionInfo {
+    name: string;
+    type: string;
+    exported: boolean;
+    async: boolean;
+    params: any[];
+    returnType: string | null;
+    line: number;
+}
+interface ClassInfo {
+    name: string;
+    exported: boolean;
+    methods: any[];
+    line: number;
+}
+interface ImportInfo {
+    source: string;
+    imported: any[];
+    line: number;
+}
+interface FileAnalysis {
+    functions: FunctionInfo[];
+    classes: ClassInfo[];
+    imports: ImportInfo[];
+    exports: any[];
+    types: any[];
+    constants: any[];
+}
+export declare class CodebaseIndexer {
+    private indexPath;
+    private indexFile;
+    private index;
+    private version;
+    constructor();
+    /**
+     * Check if index exists and is valid
+     */
+    hasIndex(): boolean;
+    /**
+     * Load index from disk
+     */
+    loadIndex(): Promise<boolean>;
+    /**
+     * Build complete index from scratch
+     */
+    buildIndex(rootDir: string, analyzeFileFn: (filePath: string) => any, progressCallback?: (current: number, total: number, file: string) => void): Promise<void>;
+    /**
+     * Update index for changed files only
+     */
+    updateIndex(changedFiles: string[], analyzeFileFn: (filePath: string) => any): Promise<void>;
+    /**
+     * Save index to disk
+     */
+    private saveIndex;
+    /**
+     * Get cached file analysis
+     */
+    getFileAnalysis(filePath: string): FileAnalysis | null;
+    /**
+     * Check if file needs re-indexing
+     */
+    isFileStale(filePath: string): boolean;
+    /**
+     * Get files that need re-indexing
+     */
+    getStaleFiles(): string[];
+    /**
+     * Get index statistics
+     */
+    getStats(): {
+        version: string;
+        fileCount: number;
+        functionCount: number;
+        testCount: number;
+        createdAt: string;
+        lastUpdated: string;
+    };
+    /**
+     * Clear index cache
+     */
+    clearCache(): Promise<void>;
+    /**
+     * Get all source files recursively
+     */
+    private getAllSourceFiles;
+    /**
+     * Find corresponding test file for a source file
+     */
+    private findTestFile;
+    /**
+     * Calculate file hash
+     */
+    private calculateHash;
+}
+export {};
+//# sourceMappingURL=codebaseIndexer.d.ts.map

package/dist/codebaseIndexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codebaseIndexer.d.ts","sourceRoot":"","sources":["../src/codebaseIndexer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAcH,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,GAAG,EAAE,CAAC;IACd,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,SAAS;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,GAAG,EAAE,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,UAAU;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,GAAG,EAAE,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,YAAY;IACpB,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,OAAO,EAAE,GAAG,EAAE,CAAC;IACf,KAAK,EAAE,GAAG,EAAE,CAAC;IACb,SAAS,EAAE,GAAG,EAAE,CAAC;CAClB;AAiBD,qBAAa,eAAe;IAC1B,OAAO,CAAC,SAAS,CAA8B;IAC/C,OAAO,CAAC,SAAS,CAAyC;IAC1D,OAAO,CAAC,KAAK,CAA8B;IAC3C,OAAO,CAAC,OAAO,CAAmB;;IASlC;;OAEG;IACH,QAAQ,IAAI,OAAO;IAInB;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;IAwBnC;;OAEG;IACG,UAAU,CACd,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,GAAG,EACxC,gBAAgB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,GACxE,OAAO,CAAC,IAAI,CAAC;IA8DhB;;OAEG;IACG,WAAW,CACf,YAAY,EAAE,MAAM,EAAE,EACtB,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,GAAG,GACvC,OAAO,CAAC,IAAI,CAAC;IAqChB;;OAEG;YACW,SAAS;IAYvB;;OAEG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI;IAQtD;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAgBtC;;OAEG;IACH,aAAa,IAAI,MAAM,EAAE;IAezB;;OAEG;IACH,QAAQ;;;;;;;;IAsBR;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAQjC;;OAEG;YACW,iBAAiB;IAgC/B;;OAEG;IACH,OAAO,CAAC,YAAY;IAkCpB;;OAEG;IACH,OAAO,CAAC,aAAa;CAGtB"}