@claudetools/tools 0.9.0 → 0.9.2

package/dist/codedna/kappa-vitest-generator.js

@@ -0,0 +1,739 @@
+// =============================================================================
+// Kappa v2.5 Vitest Test Generator
+// =============================================================================
+//
+// Generates Vitest unit and integration tests from Kappa entity and API blocks.
+// Includes test factories, mocks, and proper describe/it structure.
+//
+// =============================================================================
+// Type Mappings
+// =============================================================================
+const PRIMITIVE_DEFAULT_VALUES = {
+    string: "'test-string-' + Math.random().toString(36).substring(7)",
+    int: 'Math.floor(Math.random() * 100)',
+    float: 'Math.random() * 100',
+    bool: 'true',
+    email: "'test-' + Math.random().toString(36).substring(7) + '@example.com'",
+    url: "'https://example.com/' + Math.random().toString(36).substring(7)",
+    uuid: "crypto.randomUUID ? crypto.randomUUID() : '123e4567-e89b-12d3-a456-426614174000'",
+    phone: "'+61400' + Math.floor(Math.random() * 1000000).toString().padStart(6, '0')",
+    slug: "'test-slug-' + Math.random().toString(36).substring(7)",
+    markdown: "'# Test Content\\n\\nGenerated at ' + new Date().toISOString()",
+    json: '{}',
+    timestamp: 'new Date()',
+    date: 'new Date()',
+    time: "new Date().toTimeString().split(' ')[0]",
+    duration: "'1h'",
+};
+const ASSERTION_MAPPING = {
+    equals: 'toBe',
+    notEquals: 'not.toBe',
+    contains: 'toContain',
+    matches: 'toMatch',
+    throws: 'toThrow',
+    resolves: 'resolves.toBe',
+    rejects: 'rejects.toThrow',
+    truthy: 'toBeTruthy',
+    falsy: 'toBeFalsy',
+    defined: 'toBeDefined',
+    undefined: 'toBeUndefined',
+    null: 'toBeNull',
+    instanceOf: 'toBeInstanceOf',
+    lengthOf: 'toHaveLength',
+    deepEquals: 'toEqual',
+};
+// =============================================================================
+// Generator Class
+// =============================================================================
+export class KappaVitestGenerator {
+    provenance;
+    generateFactories;
+    generateMocks;
+    testType;
+    integration;
+    constructor(options = {}) {
+        this.provenance = options.provenance ?? true;
+        this.generateFactories = options.factories ?? true;
+        this.generateMocks = options.mocks ?? true;
+        this.testType = options.testType ?? 'unit';
+        this.integration = options.integration ?? false;
+    }
+    /**
+     * Generate tests from entity block
+     */
+    generateEntityTests(entity) {
+        const tests = this.generateEntityTestFile(entity);
+        const result = { tests };
+        if (this.generateFactories) {
+            result.factories = this.generateFactoryFile(entity);
+        }
+        if (this.generateMocks) {
+            result.mocks = this.generateMockFile(entity);
+        }
+        return result;
+    }
+    /**
+     * Generate tests from API block
+     */
+    generateAPITests(api, entities) {
+        const tests = this.generateAPITestFile(api, entities);
+        const result = { tests };
+        if (this.generateMocks) {
+            result.mocks = this.generateAPIMockFile(api);
+        }
+        return result;
+    }
+    /**
+     * Generate tests from TestBlock
+     */
+    generateFromTestBlock(testBlock, entities) {
+        const tests = this.generateTestBlockFile(testBlock, entities);
+        return { tests };
+    }
+    // ===========================================================================
+    // Entity Test File Generation
+    // ===========================================================================
+    generateEntityTestFile(entity) {
+        const lines = [];
+        // Header comment
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push(`// Entity: ${entity.name}`);
+            lines.push(`// Generated at: ${new Date().toISOString()}`);
+            lines.push('');
+        }
+        // Imports
+        lines.push(this.generateEntityTestImports(entity));
+        lines.push('');
+        // Test suites
+        lines.push(this.generateEntityValidationTests(entity));
+        lines.push('');
+        lines.push(this.generateEntityCRUDTests(entity));
+        lines.push('');
+        if (entity.relationships.length > 0) {
+            lines.push(this.generateEntityRelationshipTests(entity));
+            lines.push('');
+        }
+        if (this.integration) {
+            lines.push(this.generateEntityIntegrationTests(entity));
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    generateEntityTestImports(entity) {
+        const lines = [];
+        const entityName = this.toSnakeCase(entity.name);
+        lines.push("import { describe, it, expect, beforeEach, afterEach } from 'vitest';");
+        if (this.generateFactories) {
+            lines.push(`import { create${entity.name}Factory } from './${entityName}.factory';`);
+        }
+        if (this.generateMocks) {
+            lines.push(`import { mock${entity.name}Repository } from './${entityName}.mock';`);
+        }
+        return lines.join('\n');
+    }
+    generateEntityValidationTests(entity) {
+        const lines = [];
+        lines.push(`describe('${entity.name} Validation', () => {`);
+        // Generate validation tests for each field
+        for (const field of entity.fields) {
+            // Skip auto-generated and optional fields
+            if (field.modifiers.includes('optional') || field.modifiers.includes('auto'))
+                continue;
+            lines.push(`  it('should require ${field.name}', () => {`);
+            lines.push(`    const valid = create${entity.name}Factory();`);
+            lines.push(`    const invalid = { ...valid, ${field.name}: undefined };`);
+            lines.push(`    expect(() => validate${entity.name}(invalid)).toThrow();`);
+            lines.push(`  });`);
+            lines.push('');
+            // Type-specific validation
+            if (field.type.kind === 'primitive') {
+                if (field.type.type === 'email') {
+                    lines.push(`  it('should validate ${field.name} email format', () => {`);
+                    lines.push(`    const valid = create${entity.name}Factory();`);
+                    lines.push(`    const invalid = { ...valid, ${field.name}: 'not-an-email' };`);
+                    lines.push(`    expect(() => validate${entity.name}(invalid)).toThrow('Invalid email');`);
+                    lines.push(`  });`);
+                    lines.push('');
+                }
+                if (field.type.type === 'url') {
+                    lines.push(`  it('should validate ${field.name} URL format', () => {`);
+                    lines.push(`    const valid = create${entity.name}Factory();`);
+                    lines.push(`    const invalid = { ...valid, ${field.name}: 'not-a-url' };`);
+                    lines.push(`    expect(() => validate${entity.name}(invalid)).toThrow('Invalid URL');`);
+                    lines.push(`  });`);
+                    lines.push('');
+                }
+                if (field.type.range) {
+                    if (field.type.range.min !== undefined) {
+                        // String length vs numeric value
+                        const isStringType = field.type.type === 'string';
+                        const invalidValue = isStringType
+                            ? `'${'x'.repeat(field.type.range.min - 1)}'`
+                            : `${field.type.range.min - 1}`;
+                        lines.push(`  it('should enforce minimum ${field.type.range.min} for ${field.name}', () => {`);
+                        lines.push(`    const valid = create${entity.name}Factory();`);
+                        lines.push(`    const invalid = { ...valid, ${field.name}: ${invalidValue} };`);
+                        lines.push(`    expect(() => validate${entity.name}(invalid)).toThrow();`);
+                        lines.push(`  });`);
+                        lines.push('');
+                    }
+                    if (field.type.range.max !== undefined) {
+                        // String length vs numeric value
+                        const isStringType = field.type.type === 'string';
+                        const invalidValue = isStringType
+                            ? `'${'x'.repeat(field.type.range.max + 1)}'`
+                            : `${field.type.range.max + 1}`;
+                        lines.push(`  it('should enforce maximum ${field.type.range.max} for ${field.name}', () => {`);
+                        lines.push(`    const valid = create${entity.name}Factory();`);
+                        lines.push(`    const invalid = { ...valid, ${field.name}: ${invalidValue} };`);
+                        lines.push(`    expect(() => validate${entity.name}(invalid)).toThrow();`);
+                        lines.push(`  });`);
+                        lines.push('');
+                    }
+                }
+            }
+            if (field.type.kind === 'enum') {
+                lines.push(`  it('should validate ${field.name} enum values', () => {`);
+                lines.push(`    const valid = create${entity.name}Factory();`);
+                lines.push(`    const invalid = { ...valid, ${field.name}: 'INVALID_VALUE' };`);
+                lines.push(`    expect(() => validate${entity.name}(invalid)).toThrow();`);
+                lines.push(`  });`);
+                lines.push('');
+            }
+        }
+        lines.push('});');
+        return lines.join('\n');
+    }
+    generateEntityCRUDTests(entity) {
+        const lines = [];
+        const entityName = entity.name;
+        const varName = this.toLowerCamelCase(entityName);
+        lines.push(`describe('${entityName} CRUD Operations', () => {`);
+        lines.push(`  let repository: ReturnType<typeof mock${entityName}Repository>;`);
+        lines.push('');
+        lines.push('  beforeEach(() => {');
+        lines.push(`    repository = mock${entityName}Repository();`);
+        lines.push('  });');
+        lines.push('');
+        // Create test
+        lines.push(`  it('should create a new ${entityName}', async () => {`);
+        lines.push(`    const new${entityName} = create${entityName}Factory();`);
+        lines.push(`    const created = await repository.create(new${entityName});`);
+        lines.push('');
+        lines.push(`    expect(created).toBeDefined();`);
+        lines.push(`    expect(created.id).toBeDefined();`);
+        // Check a few key fields (skip auto-generated fields)
+        const keyFields = entity.fields
+            .filter(f => !f.modifiers.includes('auto'))
+            .slice(0, 2);
+        for (const field of keyFields) {
+            lines.push(`    expect(created.${field.name}).toBe(new${entityName}.${field.name});`);
+        }
+        lines.push(`  });`);
+        lines.push('');
+        // Read test
+        lines.push(`  it('should read an existing ${entityName}', async () => {`);
+        lines.push(`    const ${varName} = create${entityName}Factory();`);
+        lines.push(`    const created = await repository.create(${varName});`);
+        lines.push(`    const found = await repository.findById(created.id);`);
+        lines.push('');
+        lines.push(`    expect(found).toBeDefined();`);
+        lines.push(`    expect(found?.id).toBe(created.id);`);
+        lines.push(`  });`);
+        lines.push('');
+        // Update test
+        lines.push(`  it('should update an existing ${entityName}', async () => {`);
+        lines.push(`    const ${varName} = create${entityName}Factory();`);
+        lines.push(`    const created = await repository.create(${varName});`);
+        lines.push('');
+        // Find a mutable field to update (skip primary, auto, immutable)
+        const mutableField = entity.fields.find(f => !f.modifiers.includes('immutable') &&
+            !f.modifiers.includes('primary') &&
+            !f.modifiers.includes('auto'));
+        if (mutableField) {
+            const updateValue = this.generateTestValue(mutableField.type, true);
+            lines.push(`    const updated = await repository.update(created.id, {`);
+            lines.push(`      ${mutableField.name}: ${updateValue},`);
+            lines.push(`    });`);
+            lines.push('');
+            lines.push(`    expect(updated.${mutableField.name}).toBe(${updateValue});`);
+        }
+        else {
+            // If no mutable fields, just verify update doesn't throw
+            lines.push(`    await expect(repository.update(created.id, {})).resolves.toBeDefined();`);
+        }
+        lines.push(`  });`);
+        lines.push('');
+        // Delete test
+        lines.push(`  it('should delete an existing ${entityName}', async () => {`);
+        lines.push(`    const ${varName} = create${entityName}Factory();`);
+        lines.push(`    const created = await repository.create(${varName});`);
+        lines.push(`    await repository.delete(created.id);`);
+        lines.push('');
+        lines.push(`    const found = await repository.findById(created.id);`);
+        lines.push(`    expect(found).toBeUndefined();`);
+        lines.push(`  });`);
+        lines.push('');
+        // List test
+        lines.push(`  it('should list all ${entityName} records', async () => {`);
+        lines.push(`    const ${varName}1 = create${entityName}Factory();`);
+        lines.push(`    const ${varName}2 = create${entityName}Factory();`);
+        lines.push(`    await repository.create(${varName}1);`);
+        lines.push(`    await repository.create(${varName}2);`);
+        lines.push('');
+        lines.push(`    const list = await repository.findAll();`);
+        lines.push(`    expect(list.length).toBeGreaterThanOrEqual(2);`);
+        lines.push(`  });`);
+        lines.push('');
+        lines.push('});');
+        return lines.join('\n');
+    }
+    generateEntityRelationshipTests(entity) {
+        const lines = [];
+        lines.push(`describe('${entity.name} Relationships', () => {`);
+        for (const rel of entity.relationships) {
+            const relName = rel.as || rel.entity;
+            lines.push(`  it('should load ${relName} relationship', async () => {`);
+            lines.push(`    const ${this.toLowerCamelCase(entity.name)} = create${entity.name}Factory();`);
+            lines.push(`    const created = await repository.create(${this.toLowerCamelCase(entity.name)});`);
+            lines.push('');
+            lines.push(`    const with${relName} = await repository.findById(created.id, {`);
+            lines.push(`      include: ['${relName}']`);
+            lines.push(`    });`);
+            lines.push('');
+            lines.push(`    expect(with${relName}.${relName}).toBeDefined();`);
+            lines.push(`  });`);
+            lines.push('');
+        }
+        lines.push('});');
+        return lines.join('\n');
+    }
+    generateEntityIntegrationTests(entity) {
+        const lines = [];
+        lines.push(`describe('${entity.name} Integration Tests', () => {`);
+        lines.push(`  it('should persist to database', async () => {`);
+        lines.push(`    const ${this.toLowerCamelCase(entity.name)} = create${entity.name}Factory();`);
+        lines.push(`    const created = await db.${this.toSnakeCase(entity.name)}.create(${this.toLowerCamelCase(entity.name)});`);
+        lines.push('');
+        lines.push(`    const found = await db.${this.toSnakeCase(entity.name)}.findUnique({`);
+        lines.push(`      where: { id: created.id }`);
+        lines.push(`    });`);
+        lines.push('');
+        lines.push(`    expect(found).toBeDefined();`);
+        lines.push(`    expect(found?.id).toBe(created.id);`);
+        lines.push(`  });`);
+        lines.push('});');
+        return lines.join('\n');
+    }
+    // ===========================================================================
+    // API Test File Generation
+    // ===========================================================================
+    generateAPITestFile(api, entities) {
+        const lines = [];
+        // Header comment
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push(`// API: ${api.name}`);
+            lines.push(`// Generated at: ${new Date().toISOString()}`);
+            lines.push('');
+        }
+        // Imports
+        lines.push(this.generateAPITestImports(api));
+        lines.push('');
+        // Test suites for each operation
+        for (const operation of api.operations) {
+            lines.push(this.generateAPIOperationTests(operation, api.name));
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    generateAPITestImports(api) {
+        const lines = [];
+        lines.push("import { describe, it, expect, beforeEach, vi } from 'vitest';");
+        if (this.generateMocks) {
+            lines.push(`import { mockAPIClient } from './api.mock';`);
+        }
+        return lines.join('\n');
+    }
+    generateAPIOperationTests(operation, apiName) {
+        const lines = [];
+        lines.push(`describe('${apiName}.${operation.name}', () => {`);
+        lines.push('  let apiClient: ReturnType<typeof mockAPIClient>;');
+        lines.push('');
+        lines.push('  beforeEach(() => {');
+        lines.push('    apiClient = mockAPIClient();');
+        lines.push('  });');
+        lines.push('');
+        // Success test
+        lines.push('  it("should successfully execute", async () => {');
+        // Generate test parameters
+        const params = [];
+        for (const param of operation.parameters) {
+            const value = this.generateTestValue(param.type);
+            params.push(`${param.name}: ${value}`);
+        }
+        if (params.length > 0) {
+            lines.push(`    const params = { ${params.join(', ')} };`);
+            lines.push(`    const result = await apiClient.${operation.name}(params);`);
+        }
+        else {
+            lines.push(`    const result = await apiClient.${operation.name}();`);
+        }
+        lines.push('');
+        lines.push('    expect(result).toBeDefined();');
+        if (operation.returnType.isArray) {
+            lines.push('    expect(Array.isArray(result)).toBe(true);');
+        }
+        else {
+            lines.push(`    expect(result).toHaveProperty('id');`);
+        }
+        lines.push('  });');
+        lines.push('');
+        // Error tests
+        if (operation.throws && operation.throws.length > 0) {
+            for (const errorType of operation.throws) {
+                lines.push(`  it('should handle ${errorType}', async () => {`);
+                lines.push(`    apiClient.${operation.name}.mockRejectedValueOnce(new Error('${errorType}'));`);
+                lines.push('');
+                lines.push(`    await expect(apiClient.${operation.name}()).rejects.toThrow('${errorType}');`);
+                lines.push('  });');
+                lines.push('');
+            }
+        }
+        // Rate limit test
+        if (operation.rateLimit) {
+            lines.push('  it("should respect rate limits", async () => {');
+            lines.push(`    // Rate limit: ${operation.rateLimit}`);
+            lines.push('    // Test implementation depends on rate limiting strategy');
+            lines.push('  });');
+            lines.push('');
+        }
+        lines.push('});');
+        return lines.join('\n');
+    }
+    // ===========================================================================
+    // TestBlock Generation
+    // ===========================================================================
+    generateTestBlockFile(testBlock, entities) {
+        const lines = [];
+        // Header comment
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push(`// Test: ${testBlock.name}`);
+            lines.push(`// Target: ${testBlock.target}`);
+            lines.push(`// Type: ${testBlock.type}`);
+            lines.push(`// Generated at: ${new Date().toISOString()}`);
+            lines.push('');
+        }
+        // Imports
+        lines.push("import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';");
+        lines.push('');
+        // Generate test suite
+        lines.push(this.generateTestSuite(testBlock.suite, 0));
+        return lines.join('\n');
+    }
+    generateTestSuite(suite, depth) {
+        const lines = [];
+        const indent = '  '.repeat(depth);
+        lines.push(`${indent}describe('${suite.name}', () => {`);
+        // Setup hooks
+        if (suite.beforeAll && suite.beforeAll.length > 0) {
+            lines.push(`${indent}  beforeAll(() => {`);
+            for (const stmt of suite.beforeAll) {
+                lines.push(`${indent}    ${stmt};`);
+            }
+            lines.push(`${indent}  });`);
+            lines.push('');
+        }
+        if (suite.afterAll && suite.afterAll.length > 0) {
+            lines.push(`${indent}  afterAll(() => {`);
+            for (const stmt of suite.afterAll) {
+                lines.push(`${indent}    ${stmt};`);
+            }
+            lines.push(`${indent}  });`);
+            lines.push('');
+        }
+        if (suite.beforeEach && suite.beforeEach.length > 0) {
+            lines.push(`${indent}  beforeEach(() => {`);
+            for (const stmt of suite.beforeEach) {
+                lines.push(`${indent}    ${stmt};`);
+            }
+            lines.push(`${indent}  });`);
+            lines.push('');
+        }
+        if (suite.afterEach && suite.afterEach.length > 0) {
+            lines.push(`${indent}  afterEach(() => {`);
+            for (const stmt of suite.afterEach) {
+                lines.push(`${indent}    ${stmt};`);
+            }
+            lines.push(`${indent}  });`);
+            lines.push('');
+        }
+        // Mocks
+        for (const mock of suite.mocks) {
+            lines.push(this.generateMock(mock, depth + 1));
+            lines.push('');
+        }
+        // Test cases
+        for (const testCase of suite.tests) {
+            lines.push(this.generateTestCase(testCase, depth + 1));
+            lines.push('');
+        }
+        // Nested suites
+        for (const nestedSuite of suite.suites) {
+            lines.push(this.generateTestSuite(nestedSuite, depth + 1));
+            lines.push('');
+        }
+        lines.push(`${indent}});`);
+        return lines.join('\n');
+    }
+    generateTestCase(testCase, depth) {
+        const lines = [];
+        const indent = '  '.repeat(depth);
+        let testFn = 'it';
+        if (testCase.skip)
+            testFn = 'it.skip';
+        if (testCase.only)
+            testFn = 'it.only';
+        if (testCase.todo)
+            testFn = 'it.todo';
+        const timeout = testCase.timeout ? `, ${testCase.timeout}` : '';
+        lines.push(`${indent}${testFn}('${testCase.name}', async () => {${timeout}`);
+        // Setup
+        if (testCase.setup && testCase.setup.length > 0) {
+            for (const stmt of testCase.setup) {
+                lines.push(`${indent}  ${stmt};`);
+            }
+            lines.push('');
+        }
+        // Action
+        lines.push(`${indent}  ${testCase.action};`);
+        lines.push('');
+        // Assertions
+        for (const assertion of testCase.assertions) {
+            lines.push(this.generateAssertion(assertion, depth + 1));
+        }
+        // Teardown
+        if (testCase.teardown && testCase.teardown.length > 0) {
+            lines.push('');
+            for (const stmt of testCase.teardown) {
+                lines.push(`${indent}  ${stmt};`);
+            }
+        }
+        lines.push(`${indent}});`);
+        return lines.join('\n');
+    }
+    generateAssertion(assertion, depth) {
+        const indent = '  '.repeat(depth);
+        const matcher = ASSERTION_MAPPING[assertion.type];
+        if (assertion.expected !== undefined) {
+            return `${indent}expect(${assertion.actual}).${matcher}(${assertion.expected});`;
+        }
+        else {
+            return `${indent}expect(${assertion.actual}).${matcher}();`;
+        }
+    }
+    generateMock(mock, depth) {
+        const indent = '  '.repeat(depth);
+        if (mock.implementation) {
+            return `${indent}vi.mock('${mock.target}', () => (${mock.implementation}));`;
+        }
+        else if (mock.returns) {
+            return `${indent}vi.mock('${mock.target}', () => ({ default: vi.fn(() => ${mock.returns}) }));`;
+        }
+        else {
+            return `${indent}vi.mock('${mock.target}');`;
+        }
+    }
+    // ===========================================================================
+    // Factory File Generation
+    // ===========================================================================
+    generateFactoryFile(entity) {
+        const lines = [];
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push(`// Test Factory: ${entity.name}`);
+            lines.push(`// Generated at: ${new Date().toISOString()}`);
+            lines.push('');
+        }
+        lines.push(`export function create${entity.name}Factory(overrides = {}) {`);
+        lines.push('  return {');
+        for (const field of entity.fields) {
+            if (field.modifiers.includes('auto'))
+                continue; // Skip auto-generated fields
+            const value = this.generateTestValue(field.type);
+            lines.push(`    ${field.name}: ${value},`);
+        }
+        lines.push('    ...overrides,');
+        lines.push('  };');
+        lines.push('}');
+        return lines.join('\n');
+    }
+    // ===========================================================================
+    // Mock File Generation
+    // ===========================================================================
+    generateMockFile(entity) {
+        const lines = [];
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push(`// Mock Repository: ${entity.name}`);
+            lines.push(`// Generated at: ${new Date().toISOString()}`);
+            lines.push('');
+        }
+        lines.push("import { vi } from 'vitest';");
+        lines.push(`import { create${entity.name}Factory } from './${this.toSnakeCase(entity.name)}.factory';`);
+        lines.push('');
+        lines.push(`export function mock${entity.name}Repository() {`);
+        lines.push(`  const store = new Map();`);
+        lines.push('');
+        lines.push('  return {');
+        lines.push('    create: vi.fn(async (data) => {');
+        lines.push("      const id = Math.random().toString(36).substring(7);");
+        lines.push('      const record = { ...data, id, createdAt: new Date(), updatedAt: new Date() };');
+        lines.push('      store.set(id, record);');
+        lines.push('      return record;');
+        lines.push('    }),');
+        lines.push('');
+        lines.push('    findById: vi.fn(async (id) => {');
+        lines.push('      return store.get(id);');
+        lines.push('    }),');
+        lines.push('');
+        lines.push('    findAll: vi.fn(async () => {');
+        lines.push('      return Array.from(store.values());');
+        lines.push('    }),');
+        lines.push('');
+        lines.push('    update: vi.fn(async (id, data) => {');
+        lines.push('      const existing = store.get(id);');
+        lines.push('      if (!existing) throw new Error("Not found");');
+        lines.push('      const updated = { ...existing, ...data, updatedAt: new Date() };');
+        lines.push('      store.set(id, updated);');
+        lines.push('      return updated;');
+        lines.push('    }),');
+        lines.push('');
+        lines.push('    delete: vi.fn(async (id) => {');
+        lines.push('      store.delete(id);');
+        lines.push('    }),');
+        lines.push('  };');
+        lines.push('}');
+        return lines.join('\n');
+    }
+    generateAPIMockFile(api) {
+        const lines = [];
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push(`// Mock API Client: ${api.name}`);
+            lines.push(`// Generated at: ${new Date().toISOString()}`);
+            lines.push('');
+        }
+        lines.push("import { vi } from 'vitest';");
+        lines.push('');
+        lines.push('export function mockAPIClient() {');
+        lines.push('  return {');
+        for (const operation of api.operations) {
+            lines.push(`    ${operation.name}: vi.fn(),`);
+        }
+        lines.push('  };');
+        lines.push('}');
+        return lines.join('\n');
+    }
+    // ===========================================================================
+    // Utilities
+    // ===========================================================================
+    generateTestValue(type, alternate = false) {
+        switch (type.kind) {
+            case 'primitive':
+                if (alternate && type.type === 'string')
+                    return "'updated-value'";
+                if (alternate && type.type === 'int')
+                    return '99';
+                return PRIMITIVE_DEFAULT_VALUES[type.type];
+            case 'enum':
+                return `'${type.values[alternate ? 1 : 0]}'`;
+            case 'reference':
+                return "'ref-id-123'";
+            case 'array':
+                return '[]';
+            default:
+                return 'null';
+        }
+    }
+    toSnakeCase(str) {
+        return str
+            .replace(/([A-Z])/g, '_$1')
+            .toLowerCase()
+            .replace(/^_/, '');
+    }
+    toLowerCamelCase(str) {
+        return str.charAt(0).toLowerCase() + str.slice(1);
+    }
+}
+// =============================================================================
+// Convenience Functions
+// =============================================================================
+/**
+ * Generate Vitest tests from entity
+ */
+export function generateEntityTests(entity, options = {}) {
+    const generator = new KappaVitestGenerator(options);
+    return generator.generateEntityTests(entity);
+}
+/**
+ * Generate Vitest tests from API
+ */
+export function generateAPITests(api, entities, options = {}) {
+    const generator = new KappaVitestGenerator(options);
+    return generator.generateAPITests(api, entities);
+}
+/**
+ * Generate Vitest tests from TestBlock
+ */
+export function generateTestsFromBlock(testBlock, entities, options = {}) {
+    const generator = new KappaVitestGenerator(options);
+    return generator.generateFromTestBlock(testBlock, entities);
+}
+/**
+ * Generate tests for all entities and APIs (orchestrator function)
+ */
+export function generateTests(entities, apis, options = {}) {
+    const generator = new KappaVitestGenerator(options);
+    const testFiles = [];
+    // Generate entity tests
+    for (const entity of entities) {
+        const result = generator.generateEntityTests(entity);
+        const entityName = entity.name.toLowerCase();
+        testFiles.push({
+            path: `__tests__/${entityName}.test.ts`,
+            content: result.tests,
+        });
+        // Collect factories and mocks (combine all entities into single files)
+        if (result.factories) {
+            testFiles.push({
+                path: `__tests__/${entityName}.factory.ts`,
+                content: result.factories,
+            });
+        }
+        if (result.mocks) {
+            testFiles.push({
+                path: `__tests__/${entityName}.mock.ts`,
+                content: result.mocks,
+            });
+        }
+    }
+    // Generate API tests
+    for (const api of apis) {
+        const result = generator.generateAPITests(api, entities);
+        const apiName = api.name.toLowerCase();
+        testFiles.push({
+            path: `__tests__/${apiName}.test.ts`,
+            content: result.tests,
+        });
+        if (result.mocks) {
+            testFiles.push({
+                path: `__tests__/${apiName}.mock.ts`,
+                content: result.mocks,
+            });
+        }
+    }
+    return { testFiles };
+}