@theihtisham/ai-testgen 1.0.0

package/src/utils/language.ts

@@ -0,0 +1,114 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import { SupportedLanguage, TestFramework } from '../types.js';
+import { LANGUAGE_EXTENSIONS, LANGUAGE_FRAMEWORKS } from '../config/defaults.js';
+
+export function detectLanguage(filePath: string): SupportedLanguage {
+  const ext = path.extname(filePath).toLowerCase();
+  const language = LANGUAGE_EXTENSIONS[ext];
+  if (!language) {
+    throw new Error(`Unsupported file extension: ${ext}. Supported: ${Object.keys(LANGUAGE_EXTENSIONS).join(', ')}`);
+  }
+  return language;
+}
+
+export function detectFramework(language: SupportedLanguage, projectDir: string): TestFramework {
+  const frameworks = LANGUAGE_FRAMEWORKS[language];
+  if (frameworks.length === 0) {
+    throw new Error(`No test framework support for language: ${language}`);
+  }
+
+  // Check for framework-specific config files
+  if (language === 'typescript' || language === 'javascript') {
+    const vitestConfig = ['vitest.config.ts', 'vitest.config.js', 'vite.config.ts'].find(
+      (f) => fs.existsSync(path.join(projectDir, f)),
+    );
+    if (vitestConfig) return 'vitest';
+
+    const jestConfig = ['jest.config.ts', 'jest.config.js', 'jest.config.mjs'].find(
+      (f) => fs.existsSync(path.join(projectDir, f)),
+    );
+    if (jestConfig) return 'jest';
+
+    // Check package.json for dependencies
+    const pkgPath = path.join(projectDir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (allDeps['vitest']) return 'vitest';
+      if (allDeps['jest']) return 'jest';
+    }
+
+    return 'vitest'; // default for JS/TS
+  }
+
+  if (language === 'python') return 'pytest';
+  if (language === 'go') return 'go-test';
+
+  return frameworks[0]!;
+}
+
+export function getTestFileExtension(language: SupportedLanguage): string {
+  const map: Record<SupportedLanguage, string> = {
+    typescript: 'ts',
+    javascript: 'js',
+    python: 'py',
+    go: 'go',
+    rust: 'rs',
+  };
+  return map[language];
+}
+
+export function buildTestFilePath(
+  sourceFilePath: string,
+  outputDir: string,
+  language: SupportedLanguage,
+  framework: TestFramework,
+): string {
+  const dir = path.dirname(sourceFilePath);
+  const ext = path.extname(sourceFilePath);
+  const baseName = path.basename(sourceFilePath, ext);
+  const testExt = getTestFileExtension(language);
+
+  let testFileName: string;
+  if (framework === 'pytest') {
+    testFileName = `test_${baseName}.py`;
+  } else if (framework === 'go-test') {
+    testFileName = `${baseName}_test.go`;
+  } else {
+    testFileName = `${baseName}.test.${testExt}`;
+  }
+
+  if (outputDir === '__tests__' || outputDir.startsWith('./') || outputDir.startsWith('../')) {
+    const testDir = path.resolve(path.dirname(sourceFilePath), outputDir);
+    return path.join(testDir, testFileName);
+  }
+
+  return path.join(dir, testFileName);
+}
+
+export function isTestFile(filePath: string): boolean {
+  const base = path.basename(filePath);
+  return (
+    base.includes('.test.') ||
+    base.includes('.spec.') ||
+    base.startsWith('test_') ||
+    base.endsWith('_test.go')
+  );
+}
+
+export function shouldAnalyze(filePath: string, excludePatterns: string[]): boolean {
+  if (isTestFile(filePath)) return false;
+
+  const normalizedPath = filePath.replace(/\\/g, '/');
+  for (const pattern of excludePatterns) {
+    const regex = pattern
+      .replace(/\*\*/g, '.*')
+      .replace(/\*/g, '[^/]*')
+      .replace(/\?/g, '[^/]');
+    if (new RegExp(regex).test(normalizedPath)) {
+      return false;
+    }
+  }
+  return true;
+}

package/src/utils/logger.ts

@@ -0,0 +1,61 @@
+import chalk from 'chalk';
+
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'success';
+
+let currentLogLevel: LogLevel = 'info';
+
+const LOG_ORDER: LogLevel[] = ['debug', 'info', 'warn', 'error', 'success'];
+
+export function setLogLevel(level: LogLevel): void {
+  currentLogLevel = level;
+}
+
+function shouldLog(level: LogLevel): boolean {
+  if (level === 'success') return true;
+  if (level === 'debug' && currentLogLevel !== 'debug') return false;
+  return LOG_ORDER.indexOf(level) >= LOG_ORDER.indexOf(currentLogLevel);
+}
+
+export const logger = {
+  debug(message: string, ...args: unknown[]): void {
+    if (shouldLog('debug')) {
+      console.log(chalk.gray(`[debug] ${message}`), ...args);
+    }
+  },
+
+  info(message: string, ...args: unknown[]): void {
+    if (shouldLog('info')) {
+      console.log(chalk.cyan(`[info] ${message}`), ...args);
+    }
+  },
+
+  warn(message: string, ...args: unknown[]): void {
+    if (shouldLog('warn')) {
+      console.warn(chalk.yellow(`[warn] ${message}`), ...args);
+    }
+  },
+
+  error(message: string, ...args: unknown[]): void {
+    if (shouldLog('error')) {
+      console.error(chalk.red(`[error] ${message}`), ...args);
+    }
+  },
+
+  success(message: string, ...args: unknown[]): void {
+    if (shouldLog('success')) {
+      console.log(chalk.green(`  ${message}`), ...args);
+    }
+  },
+
+  plain(message: string, ...args: unknown[]): void {
+    console.log(message, ...args);
+  },
+
+  heading(message: string): void {
+    console.log('\n' + chalk.bold.blue(`  ${message}`));
+  },
+
+  subheading(message: string): void {
+    console.log(chalk.bold.white(`  ${message}`));
+  },
+};

package/src/watcher/index.ts

@@ -0,0 +1 @@
+export { FileWatcher } from './watcher.js';

package/src/watcher/watcher.ts

@@ -0,0 +1,103 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { FileChangeEvent, TestGenConfig } from '../types.js';
+import { logger } from '../utils/logger.js';
+
+type FileWatcherCallback = (events: FileChangeEvent[]) => Promise<void>;
+
+export class FileWatcher {
+  private watchers: Map<string, fs.FSWatcher> = new Map();
+  private pendingEvents: FileChangeEvent[] = [];
+  private debounceTimer: ReturnType<typeof setTimeout> | null = null;
+  private debounceMs: number;
+  private ignorePatterns: string[];
+  private callback: FileWatcherCallback;
+  private running = false;
+
+  constructor(config: TestGenConfig, callback: FileWatcherCallback) {
+    this.debounceMs = config.watch.debounceMs;
+    this.ignorePatterns = config.watch.ignorePatterns;
+    this.callback = callback;
+  }
+
+  start(directories: string[]): void {
+    if (this.running) return;
+    this.running = true;
+
+    for (const dir of directories) {
+      const absoluteDir = path.resolve(dir);
+      if (!fs.existsSync(absoluteDir)) {
+        logger.warn(`Watch directory does not exist: ${absoluteDir}`);
+        continue;
+      }
+
+      try {
+        const watcher = fs.watch(
+          absoluteDir,
+          { recursive: true },
+          (eventType, filename) => {
+            if (!filename) return;
+            if (this.shouldIgnore(filename)) return;
+
+            const filePath = path.join(absoluteDir, filename);
+
+            this.pendingEvents.push({
+              filePath,
+              eventType: eventType as FileChangeEvent['eventType'],
+              timestamp: Date.now(),
+            });
+
+            this.debouncedNotify();
+          },
+        );
+
+        this.watchers.set(absoluteDir, watcher);
+        logger.info(`Watching: ${absoluteDir}`);
+      } catch (err) {
+        logger.error(`Failed to watch ${absoluteDir}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+
+  stop(): void {
+    this.running = false;
+    for (const [dir, watcher] of this.watchers) {
+      watcher.close();
+      logger.debug(`Stopped watching: ${dir}`);
+    }
+    this.watchers.clear();
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+  }
+
+  isRunning(): boolean {
+    return this.running;
+  }
+
+  private shouldIgnore(filename: string): boolean {
+    const normalized = filename.replace(/\\/g, '/');
+    return this.ignorePatterns.some((pattern) => {
+      return normalized.includes(pattern) || normalized.match(
+        new RegExp(pattern.replace(/\*/g, '.*')),
+      ) !== null;
+    });
+  }
+
+  private debouncedNotify(): void {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+
+    this.debounceTimer = setTimeout(() => {
+      const events = [...this.pendingEvents];
+      this.pendingEvents = [];
+      if (events.length > 0) {
+        this.callback(events).catch((err) => {
+          logger.error(`Watch callback error: ${err instanceof Error ? err.message : String(err)}`);
+        });
+      }
+    }, this.debounceMs);
+  }
+}

package/tests/analyzer.test.ts

@@ -0,0 +1,429 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { analyzeSource, detectEdgeCases, detectMocks } from '../src/analyzers/analyzer.js';
+import { analyzePythonSource } from '../src/analyzers/python-analyzer.js';
+import { analyzeGoSource } from '../src/analyzers/go-analyzer.js';
+
+describe('Source Analysis', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'testgen-analyze-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('TypeScript/JavaScript Analysis', () => {
+    it('analyzes a simple exported function', () => {
+      const filePath = path.join(tempDir, 'math.ts');
+      fs.writeFileSync(filePath, `
+export function add(a: number, b: number): number {
+  return a + b;
+}
+
+export function multiply(a: number, b: number): number {
+  return a * b;
+}
+`);
+      const analysis = analyzeSource(filePath, 'typescript');
+      expect(analysis.language).toBe('typescript');
+      expect(analysis.functions.length).toBeGreaterThanOrEqual(2);
+      expect(analysis.functions.some((f) => f.name === 'add')).toBe(true);
+      expect(analysis.functions.some((f) => f.name === 'multiply')).toBe(true);
+    });
+
+    it('analyzes exported classes with methods', () => {
+      const filePath = path.join(tempDir, 'service.ts');
+      fs.writeFileSync(filePath, `
+export class UserService {
+  private users: Map<string, string> = new Map();
+
+  addUser(id: string, name: string): void {
+    this.users.set(id, name);
+  }
+
+  getUser(id: string): string | undefined {
+    return this.users.get(id);
+  }
+
+  async fetchUser(id: string): Promise<string> {
+    return this.users.get(id) ?? 'unknown';
+  }
+}
+`);
+      const analysis = analyzeSource(filePath, 'typescript');
+      expect(analysis.classes.length).toBe(1);
+      expect(analysis.classes[0]!.name).toBe('UserService');
+      expect(analysis.classes[0]!.methods.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it('detects exported arrow functions', () => {
+      const filePath = path.join(tempDir, 'utils.ts');
+      fs.writeFileSync(filePath, `
+export const formatName = (first: string, last: string): string => {
+  return first + ' ' + last;
+};
+
+export const parseJSON = (input: string): unknown => {
+  return JSON.parse(input);
+};
+`);
+      const analysis = analyzeSource(filePath, 'typescript');
+      expect(analysis.functions.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it('analyzes interfaces', () => {
+      const filePath = path.join(tempDir, 'types.ts');
+      fs.writeFileSync(filePath, `
+export interface User {
+  id: string;
+  name: string;
+  email?: string;
+}
+
+export interface Repository<T> {
+  findById(id: string): T | undefined;
+  save(entity: T): void;
+}
+`);
+      const analysis = analyzeSource(filePath, 'typescript');
+      expect(analysis.interfaces.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it('detects imports and dependencies', () => {
+      const filePath = path.join(tempDir, 'imports.ts');
+      fs.writeFileSync(filePath, `
+import { useState, useEffect } from 'react';
+import * as fs from 'fs';
+import type { Config } from './config';
+
+export function useConfig(): Config | null {
+  return null;
+}
+`);
+      const analysis = analyzeSource(filePath, 'typescript');
+      expect(analysis.imports.length).toBeGreaterThanOrEqual(1);
+      expect(analysis.dependencies).toContain('react');
+    });
+
+    it('calculates cyclomatic complexity', () => {
+      const filePath = path.join(tempDir, 'complex.ts');
+      fs.writeFileSync(filePath, `
+export function complexFunction(x: number): string {
+  if (x > 0) {
+    if (x > 10) {
+      return 'big';
+    } else {
+      return 'small';
+    }
+  } else if (x === 0) {
+    return 'zero';
+  } else {
+    for (let i = 0; i < 10; i++) {
+      if (i === x) return 'found';
+    }
+    return 'negative';
+  }
+}
+`);
+      const analysis = analyzeSource(filePath, 'typescript');
+      const complexFn = analysis.functions.find((f) => f.name === 'complexFunction');
+      expect(complexFn).toBeDefined();
+      expect(complexFn!.complexity).toBeGreaterThan(1);
+    });
+
+    it('detects async functions', () => {
+      const filePath = path.join(tempDir, 'async.ts');
+      fs.writeFileSync(filePath, `
+export async function fetchData(url: string): Promise<string> {
+  const response = await fetch(url);
+  return response.text();
+}
+`);
+      const analysis = analyzeSource(filePath, 'typescript');
+      const asyncFn = analysis.functions.find((f) => f.name === 'fetchData');
+      expect(asyncFn).toBeDefined();
+      expect(asyncFn!.isAsync).toBe(true);
+    });
+  });
+
+  describe('Python Analysis', () => {
+    it('analyzes Python functions', () => {
+      const filePath = path.join(tempDir, 'math.py');
+      fs.writeFileSync(filePath, `
+def add(a: int, b: int) -> int:
+    return a + b
+
+def greet(name: str) -> str:
+    return f"Hello, {name}"
+
+async def fetch_data(url: str) -> dict:
+    return {}
+`);
+      const analysis = analyzePythonSource(filePath);
+      expect(analysis.language).toBe('python');
+      expect(analysis.functions.length).toBeGreaterThanOrEqual(2);
+      expect(analysis.functions.some((f) => f.name === 'add')).toBe(true);
+      expect(analysis.functions.some((f) => f.name === 'greet')).toBe(true);
+    });
+
+    it('analyzes Python classes', () => {
+      const filePath = path.join(tempDir, 'service.py');
+      fs.writeFileSync(filePath, `
+class UserService:
+    def __init__(self, db_url: str):
+        self.db_url = db_url
+        self.connected = False
+
+    def connect(self):
+        self.connected = True
+
+    def get_user(self, user_id: str) -> dict:
+        if not self.connected:
+            raise ConnectionError("Not connected")
+        return {"id": user_id}
+`);
+      const analysis = analyzePythonSource(filePath);
+      expect(analysis.classes.length).toBe(1);
+      expect(analysis.classes[0]!.name).toBe('UserService');
+      expect(analysis.classes[0]!.methods.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it('extracts Python imports', () => {
+      const filePath = path.join(tempDir, 'imports.py');
+      fs.writeFileSync(filePath, `
+import os
+import sys
+from typing import List, Optional
+from collections import defaultdict
+
+def process(items: List[str]) -> None:
+    pass
+`);
+      const analysis = analyzePythonSource(filePath);
+      expect(analysis.imports.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+
+  describe('Go Analysis', () => {
+    it('analyzes Go functions', () => {
+      const filePath = path.join(tempDir, 'math.go');
+      fs.writeFileSync(filePath, `package math
+
+func Add(a, b int) int {
+    return a + b
+}
+
+func Multiply(a, b int) int {
+    return a * b
+}
+
+func Divide(a, b int) (int, error) {
+    if b == 0 {
+        return 0, fmt.Errorf("division by zero")
+    }
+    return a / b, nil
+}
+`);
+      const analysis = analyzeGoSource(filePath);
+      expect(analysis.language).toBe('go');
+      expect(analysis.functions.length).toBeGreaterThanOrEqual(2);
+      expect(analysis.functions.some((f) => f.name === 'Add')).toBe(true);
+    });
+
+    it('analyzes Go interfaces', () => {
+      const filePath = path.join(tempDir, 'repo.go');
+      fs.writeFileSync(filePath, `package repo
+
+type Repository interface {
+    FindById(id string) (interface{}, error)
+    Save(entity interface{}) error
+    Delete(id string) error
+}
+`);
+      const analysis = analyzeGoSource(filePath);
+      expect(analysis.interfaces.length).toBe(1);
+      expect(analysis.interfaces[0]!.name).toBe('Repository');
+    });
+
+    it('extracts Go imports', () => {
+      const filePath = path.join(tempDir, 'main.go');
+      fs.writeFileSync(filePath, `package main
+
+import (
+    "fmt"
+    "net/http"
+    "strings"
+)
+
+func main() {
+    fmt.Println("hello")
+}
+`);
+      const analysis = analyzeGoSource(filePath);
+      expect(analysis.imports.length).toBeGreaterThanOrEqual(1);
+    });
+  });
+});
+
+describe('Edge Case Detection', () => {
+  it('detects edge cases for optional parameters', () => {
+    const edgeCases = detectEdgeCases({
+      name: 'processData',
+      isAsync: false,
+      isExported: true,
+      params: [
+        { name: 'data', type: 'string', optional: true, defaultValue: null },
+        { name: 'count', type: 'number', optional: false, defaultValue: null },
+      ],
+      returnType: 'string',
+      throws: [],
+      complexity: 1,
+      hasSideEffects: false,
+      startLine: 1,
+      endLine: 5,
+    });
+
+    expect(edgeCases.length).toBeGreaterThan(0);
+    expect(edgeCases.some((ec) => ec.name.includes('undefined'))).toBe(true);
+  });
+
+  it('detects numeric edge cases', () => {
+    const edgeCases = detectEdgeCases({
+      name: 'calculate',
+      isAsync: false,
+      isExported: true,
+      params: [
+        { name: 'value', type: 'number', optional: false, defaultValue: null },
+      ],
+      returnType: 'number',
+      throws: [],
+      complexity: 1,
+      hasSideEffects: false,
+      startLine: 1,
+      endLine: 3,
+    });
+
+    expect(edgeCases.some((ec) => ec.name.includes('zero'))).toBe(true);
+    expect(edgeCases.some((ec) => ec.inputDescription.includes('NaN'))).toBe(true);
+  });
+
+  it('detects array edge cases', () => {
+    const edgeCases = detectEdgeCases({
+      name: 'processItems',
+      isAsync: false,
+      isExported: true,
+      params: [
+        { name: 'items', type: 'string[]', optional: false, defaultValue: null },
+      ],
+      returnType: 'void',
+      throws: [],
+      complexity: 1,
+      hasSideEffects: false,
+      startLine: 1,
+      endLine: 3,
+    });
+
+    expect(edgeCases.some((ec) => ec.name.includes('empty array'))).toBe(true);
+  });
+
+  it('detects error path edge cases', () => {
+    const edgeCases = detectEdgeCases({
+      name: 'validate',
+      isAsync: false,
+      isExported: true,
+      params: [
+        { name: 'input', type: 'string', optional: false, defaultValue: null },
+      ],
+      returnType: 'boolean',
+      throws: ['ValidationError'],
+      complexity: 2,
+      hasSideEffects: false,
+      startLine: 1,
+      endLine: 5,
+    });
+
+    expect(edgeCases.some((ec) => ec.tags.includes('error-path'))).toBe(true);
+  });
+
+  it('detects async edge cases', () => {
+    const edgeCases = detectEdgeCases({
+      name: 'fetchData',
+      isAsync: true,
+      isExported: true,
+      params: [
+        { name: 'url', type: 'string', optional: false, defaultValue: null },
+      ],
+      returnType: 'Promise<string>',
+      throws: [],
+      complexity: 1,
+      hasSideEffects: true,
+      startLine: 1,
+      endLine: 5,
+    });
+
+    expect(edgeCases.some((ec) => ec.tags.includes('async'))).toBe(true);
+  });
+});
+
+describe('Mock Detection', () => {
+  it('detects external module mocks', () => {
+    const analysis = {
+      filePath: 'src/app.ts',
+      language: 'typescript' as const,
+      functions: [],
+      classes: [],
+      interfaces: [],
+      exports: [],
+      imports: [
+        {
+          modulePath: 'axios',
+          namedImports: ['axios'],
+          defaultImport: null,
+          isTypeOnly: false,
+        },
+        {
+          modulePath: 'lodash',
+          namedImports: ['debounce'],
+          defaultImport: null,
+          isTypeOnly: false,
+        },
+      ],
+      dependencies: ['axios', 'lodash'],
+      linesOfCode: 10,
+      cyclomaticComplexity: 1,
+    };
+
+    const mocks = detectMocks(analysis);
+    expect(mocks.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('skips type-only imports', () => {
+    const analysis = {
+      filePath: 'src/types.ts',
+      language: 'typescript' as const,
+      functions: [],
+      classes: [],
+      interfaces: [],
+      exports: [],
+      imports: [
+        {
+          modulePath: './types',
+          namedImports: ['User'],
+          defaultImport: null,
+          isTypeOnly: true,
+        },
+      ],
+      dependencies: [],
+      linesOfCode: 5,
+      cyclomaticComplexity: 1,
+    };
+
+    const mocks = detectMocks(analysis);
+    expect(mocks.length).toBe(0);
+  });
+});