@aicgen/aicgen 1.0.0-beta.1

package/data/testing/basics.md

@@ -0,0 +1,151 @@
+# Testing Basics
+
+## Your First Unit Test
+
+A unit test verifies that a small piece of code works correctly.
+
+```pseudocode
+// Function to test
+function add(a, b):
+    return a + b
+
+// Test for the function
+test "add should sum two numbers":
+    result = add(2, 3)
+    expect result equals 5
+```
+
+## Test Structure
+
+Every test has three parts:
+
+1. **Setup** - Prepare what you need
+2. **Execute** - Run the code
+3. **Verify** - Check the result
+
+```pseudocode
+test "should create user with name":
+    // 1. Setup
+    userName = "Alice"
+
+    // 2. Execute
+    user = createUser(userName)
+
+    // 3. Verify
+    expect user.name equals "Alice"
+```
+
+## Common Assertions
+
+```pseudocode
+// Equality
+expect value equals 5
+expect value equals { id: 1 }
+
+// Truthiness
+expect value is truthy
+expect value is falsy
+expect value is null
+expect value is undefined
+
+// Numbers
+expect value > 3
+expect value < 10
+
+// Strings
+expect text contains "hello"
+
+// Arrays/Lists
+expect array contains item
+expect array length equals 3
+```
+
+## Testing Expected Errors
+
+```pseudocode
+test "should throw error for invalid input":
+    expect error when:
+        divide(10, 0)
+    with message "Cannot divide by zero"
+```
+
+## Async Tests
+
+```pseudocode
+test "should fetch user data" async:
+    user = await fetchUser(123)
+    expect user.id equals 123
+```
+
+## Test Naming
+
+Use clear, descriptive names:
+
+```pseudocode
+// ❌ Bad
+test "test1"
+test "it works"
+
+// ✅ Good
+test "should return user when ID exists"
+test "should throw error when ID is invalid"
+```
+
+## Running Tests
+
+```bash
+# Run all tests
+run-tests
+
+# Run specific test file
+run-tests user-test
+
+# Watch mode (re-run on changes)
+run-tests --watch
+```
+
+## Best Practices
+
+1. **One test, one thing** - Test one behavior per test
+2. **Independent tests** - Tests should not depend on each other
+3. **Clear names** - Name should describe what is being tested
+4. **Fast tests** - Tests should run quickly
+
+```pseudocode
+// ❌ Bad: Testing multiple things
+test "user operations":
+    expect createUser("Bob").name equals "Bob"
+    expect deleteUser(1) equals true
+    expect listUsers().length equals 0
+
+// ✅ Good: One test per operation
+test "should create user with given name":
+    user = createUser("Bob")
+    expect user.name equals "Bob"
+
+test "should delete user by ID":
+    result = deleteUser(1)
+    expect result equals true
+
+test "should return empty list when no users":
+    users = listUsers()
+    expect users.length equals 0
+```
+
+## When to Write Tests
+
+- **Before fixing bugs** - Write test that fails, then fix
+- **For new features** - Test expected behavior
+- **For edge cases** - Empty input, null values, large numbers
+
+## What to Test
+
+✅ **Do test:**
+- Public functions and methods
+- Edge cases (empty, null, zero, negative)
+- Error conditions
+
+❌ **Don't test:**
+- Private implementation details
+- Third-party libraries (they're already tested)
+- Getters/setters with no logic

package/data/testing/index.md

@@ -0,0 +1,9 @@
+# Testing Guidelines
+
+This directory contains testing best practices and patterns.
+
+## Available Chunks
+
+- **unit-fundamentals.md** - AAA pattern, behavior testing, descriptive names
+- **unit-mocking.md** - Test doubles, when to mock, mock verification
+- **integration.md** - API testing, database testing, test isolation

package/data/testing/integration.md

@@ -0,0 +1,159 @@
+# Integration Testing
+
+## Testing Real Dependencies
+
+```typescript
+describe('UserRepository Integration', () => {
+  let db: Database;
+  let repository: UserRepository;
+
+  beforeAll(async () => {
+    db = await createTestDatabase();
+    repository = new UserRepository(db);
+  });
+
+  afterAll(async () => {
+    await db.close();
+  });
+
+  beforeEach(async () => {
+    await db.clear('users'); // Clean slate for each test
+  });
+
+  it('should persist and retrieve user', async () => {
+    const userData = { email: 'test@example.com', name: 'Test User' };
+
+    const created = await repository.create(userData);
+    const found = await repository.findById(created.id);
+
+    expect(found).toEqual(expect.objectContaining(userData));
+  });
+});
+```
+
+## API Integration Tests
+
+```typescript
+describe('POST /api/users', () => {
+  let app: Express;
+  let db: Database;
+
+  beforeAll(async () => {
+    db = await createTestDatabase();
+    app = createApp(db);
+  });
+
+  afterEach(async () => {
+    await db.clear('users');
+  });
+
+  it('should create user and return 201', async () => {
+    const response = await request(app)
+      .post('/api/users')
+      .send({ email: 'new@example.com', name: 'New User' })
+      .expect(201);
+
+    expect(response.body.data).toEqual(
+      expect.objectContaining({
+        email: 'new@example.com',
+        name: 'New User'
+      })
+    );
+
+    // Verify in database
+    const user = await db.findOne('users', { email: 'new@example.com' });
+    expect(user).toBeTruthy();
+  });
+
+  it('should return 400 for invalid email', async () => {
+    const response = await request(app)
+      .post('/api/users')
+      .send({ email: 'invalid', name: 'Test' })
+      .expect(400);
+
+    expect(response.body.error.code).toBe('VALIDATION_ERROR');
+  });
+});
+```
+
+## Database Transaction Testing
+
+```typescript
+describe('OrderService Integration', () => {
+  it('should rollback on payment failure', async () => {
+    const order = await orderService.createOrder({ items: [...] });
+
+    // Mock payment to fail
+    paymentGateway.charge.mockRejectedValue(new Error('Declined'));
+
+    await expect(
+      orderService.processOrder(order.id)
+    ).rejects.toThrow('Payment failed');
+
+    // Verify order status unchanged
+    const updatedOrder = await orderRepository.findById(order.id);
+    expect(updatedOrder.status).toBe('pending');
+
+    // Verify inventory not deducted
+    const inventory = await inventoryRepository.findByProductId(productId);
+    expect(inventory.quantity).toBe(originalQuantity);
+  });
+});
+```
+
+## Test Data Builders
+
+```typescript
+class UserBuilder {
+  private data: Partial<User> = {
+    email: 'default@example.com',
+    name: 'Default User',
+    role: 'user'
+  };
+
+  withEmail(email: string) { this.data.email = email; return this; }
+  withRole(role: string) { this.data.role = role; return this; }
+  asAdmin() { this.data.role = 'admin'; return this; }
+
+  build(): User { return this.data as User; }
+
+  async save(db: Database): Promise<User> {
+    return db.insert('users', this.data);
+  }
+}
+
+// Usage
+const admin = await new UserBuilder()
+  .withEmail('admin@example.com')
+  .asAdmin()
+  .save(db);
+```
+
+## Test Isolation
+
+```typescript
+// Use transactions that rollback
+describe('IntegrationTests', () => {
+  beforeEach(async () => {
+    await db.beginTransaction();
+  });
+
+  afterEach(async () => {
+    await db.rollbackTransaction();
+  });
+});
+
+// Or use test containers
+import { PostgreSqlContainer } from '@testcontainers/postgresql';
+
+let container: PostgreSqlContainer;
+
+beforeAll(async () => {
+  container = await new PostgreSqlContainer().start();
+  db = await connect(container.getConnectionUri());
+});
+
+afterAll(async () => {
+  await container.stop();
+});
+```

package/data/testing/unit-fundamentals.md

@@ -0,0 +1,128 @@
+# Unit Testing Fundamentals
+
+## Arrange-Act-Assert Pattern
+
+```typescript
+describe('UserService', () => {
+  it('should create user with hashed password', async () => {
+    // Arrange - Set up test data and dependencies
+    const userData = { email: 'test@example.com', password: 'secret123' };
+    const mockRepo = { save: jest.fn().mockResolvedValue({ id: '1', ...userData }) };
+    const service = new UserService(mockRepo);
+
+    // Act - Execute the behavior being tested
+    const result = await service.createUser(userData);
+
+    // Assert - Verify the outcomes
+    expect(result.id).toBe('1');
+    expect(mockRepo.save).toHaveBeenCalledWith(
+      expect.objectContaining({ email: 'test@example.com' })
+    );
+  });
+});
+```
+
+## Test Observable Behavior, Not Implementation
+
+```typescript
+// ❌ Bad: Testing implementation details
+it('should call validateEmail method', () => {
+  const spy = jest.spyOn(service, 'validateEmail');
+  service.createUser({ email: 'test@example.com' });
+  expect(spy).toHaveBeenCalled();
+});
+
+// ✅ Good: Testing observable behavior
+it('should reject invalid email', async () => {
+  await expect(
+    service.createUser({ email: 'invalid-email' })
+  ).rejects.toThrow('Invalid email format');
+});
+
+it('should accept valid email', async () => {
+  const result = await service.createUser({ email: 'valid@example.com' });
+  expect(result.email).toBe('valid@example.com');
+});
+```
+
+## One Assertion Per Test Concept
+
+```typescript
+// ❌ Bad: Multiple unrelated assertions
+it('should validate user input', () => {
+  expect(() => validate({ age: -1 })).toThrow();
+  expect(() => validate({ age: 200 })).toThrow();
+  expect(() => validate({ name: '' })).toThrow();
+});
+
+// ✅ Good: One test per scenario
+it('should reject negative age', () => {
+  expect(() => validate({ age: -1 })).toThrow('Age must be positive');
+});
+
+it('should reject age over 150', () => {
+  expect(() => validate({ age: 200 })).toThrow('Age must be under 150');
+});
+
+it('should reject empty name', () => {
+  expect(() => validate({ name: '' })).toThrow('Name is required');
+});
+```
+
+## Descriptive Test Names
+
+```typescript
+// ❌ Vague names
+it('should work correctly', () => {});
+it('handles edge case', () => {});
+
+// ✅ Descriptive names - describe the scenario and expected outcome
+it('should return empty array when no users match filter', () => {});
+it('should throw ValidationError when email is empty', () => {});
+it('should retry failed payment up to 3 times before giving up', () => {});
+```
+
+## Tests Should Be Independent
+
+```typescript
+// ❌ Bad: Tests depend on each other
+let userId: string;
+
+it('should create user', async () => {
+  const user = await service.createUser(data);
+  userId = user.id; // Shared state!
+});
+
+it('should update user', async () => {
+  await service.updateUser(userId, newData); // Depends on previous test
+});
+
+// ✅ Good: Each test is self-contained
+it('should update user', async () => {
+  const user = await service.createUser(data);
+  const updated = await service.updateUser(user.id, newData);
+  expect(updated.name).toBe(newData.name);
+});
+```
+
+## Test Edge Cases
+
+```typescript
+describe('divide', () => {
+  it('should divide two positive numbers', () => {
+    expect(divide(10, 2)).toBe(5);
+  });
+
+  it('should throw when dividing by zero', () => {
+    expect(() => divide(10, 0)).toThrow('Division by zero');
+  });
+
+  it('should handle negative numbers', () => {
+    expect(divide(-10, 2)).toBe(-5);
+  });
+
+  it('should return zero when numerator is zero', () => {
+    expect(divide(0, 5)).toBe(0);
+  });
+});
+```

package/data/testing/unit-mocking.md

@@ -0,0 +1,116 @@
+# Test Doubles and Mocking
+
+## Types of Test Doubles
+
+```typescript
+// STUB: Returns canned responses
+const stubUserRepo = {
+  findById: () => ({ id: '1', name: 'Test User' })
+};
+
+// MOCK: Pre-programmed with expectations
+const mockPaymentGateway = {
+  charge: jest.fn()
+    .mockResolvedValueOnce({ success: true, transactionId: 'tx1' })
+    .mockResolvedValueOnce({ success: false, error: 'Declined' })
+};
+
+// SPY: Records calls for verification
+const spy = jest.spyOn(emailService, 'send');
+
+// FAKE: Working implementation (not for production)
+class FakeDatabase implements Database {
+  private data = new Map<string, any>();
+
+  async save(id: string, entity: any) { this.data.set(id, entity); }
+  async find(id: string) { return this.data.get(id); }
+}
+```
+
+## When to Mock
+
+```typescript
+// ✅ Mock external services (APIs, databases)
+const mockHttpClient = {
+  get: jest.fn().mockResolvedValue({ data: userData })
+};
+
+// ✅ Mock time-dependent operations
+jest.useFakeTimers();
+jest.setSystemTime(new Date('2024-01-15'));
+
+// ✅ Mock random/non-deterministic functions
+jest.spyOn(Math, 'random').mockReturnValue(0.5);
+
+// ❌ Don't mock the code you're testing
+// ❌ Don't mock simple data structures
+```
+
+## Mock Verification
+
+```typescript
+it('should send welcome email after registration', async () => {
+  const mockEmail = { send: jest.fn().mockResolvedValue(true) };
+  const service = new UserService({ emailService: mockEmail });
+
+  await service.register({ email: 'new@example.com' });
+
+  expect(mockEmail.send).toHaveBeenCalledWith({
+    to: 'new@example.com',
+    template: 'welcome',
+    subject: 'Welcome!'
+  });
+  expect(mockEmail.send).toHaveBeenCalledTimes(1);
+});
+```
+
+## Partial Mocks
+
+```typescript
+// Mock only specific methods
+const service = new OrderService();
+
+jest.spyOn(service, 'validateOrder').mockReturnValue(true);
+jest.spyOn(service, 'calculateTotal').mockReturnValue(100);
+// Other methods use real implementation
+
+const result = await service.processOrder(orderData);
+expect(result.total).toBe(100);
+```
+
+## Resetting Mocks
+
+```typescript
+describe('PaymentService', () => {
+  const mockGateway = { charge: jest.fn() };
+  const service = new PaymentService(mockGateway);
+
+  beforeEach(() => {
+    jest.clearAllMocks(); // Clear call history
+    // or jest.resetAllMocks() to also reset return values
+  });
+
+  it('should process payment', async () => {
+    mockGateway.charge.mockResolvedValue({ success: true });
+    await service.charge(100);
+    expect(mockGateway.charge).toHaveBeenCalledTimes(1);
+  });
+});
+```
+
+## Mock Modules
+
+```typescript
+// Mock entire module
+jest.mock('./email-service', () => ({
+  EmailService: jest.fn().mockImplementation(() => ({
+    send: jest.fn().mockResolvedValue(true)
+  }))
+}));
+
+// Mock with partial implementation
+jest.mock('./config', () => ({
+  ...jest.requireActual('./config'),
+  API_KEY: 'test-key'
+}));
+```

package/data/version.json

@@ -0,0 +1,49 @@
+{
+  "version": "1.0.0",
+  "lastUpdated": "2025-12-16",
+  "totalGuidelines": 82,
+  "categories": {
+    "Language": 24,
+    "Architecture": 19,
+    "Testing": 4,
+    "Security": 4,
+    "Performance": 4,
+    "Database": 5,
+    "API Design": 4,
+    "Code Style": 2,
+    "Error Handling": 2,
+    "DevOps": 3,
+    "Best Practices": 5,
+    "Design Patterns": 6
+  },
+  "languages": {
+    "typescript": 8,
+    "python": 4,
+    "go": 2,
+    "rust": 2,
+    "java": 2,
+    "csharp": 2,
+    "ruby": 2,
+    "javascript": 2
+  },
+  "architectures": {
+    "microservices": 5,
+    "modular-monolith": 2,
+    "clean-architecture": 1,
+    "ddd": 2,
+    "event-driven": 2,
+    "layered": 1,
+    "serverless": 2,
+    "hexagonal": 1
+  },
+  "levels": {
+    "basic": 17,
+    "standard": 68,
+    "expert": 82,
+    "full": 82
+  },
+  "datasources": {
+    "sql": 3,
+    "nosql": 1
+  }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,8 @@
+interface InitOptions {
+    profile?: string;
+    force?: boolean;
+    ai?: boolean;
+}
+export declare function initCommand(options: InitOptions): Promise<void>;
+export {};
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAOA,UAAU,WAAW;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,EAAE,CAAC,EAAE,OAAO,CAAC;CACd;AAED,wBAAsB,WAAW,CAAC,OAAO,EAAE,WAAW,iBAiDrD"}

package/dist/commands/init.js

@@ -0,0 +1,46 @@
+import { select } from '@inquirer/prompts';
+import ora from 'ora';
+import chalk from 'chalk';
+import { scanProject } from '../services/scanner.js';
+import { getProfile } from '../config/profiles.js';
+import { isAnthropicAvailable } from '../services/ai/anthropic.js';
+export async function initCommand(options) {
+    console.log(chalk.blue.bold('\n🤖 aicgen - AI Config Generator\n'));
+    const projectPath = process.cwd();
+    const spinner = ora('Scanning project...').start();
+    const projectInfo = await scanProject(projectPath);
+    spinner.succeed(`Project detected: ${chalk.green(projectInfo.type)}`);
+    if (projectInfo.hasExistingConfig && !options.force) {
+        console.log(chalk.yellow('\n⚠️  Configuration already exists. Use --force to overwrite.'));
+        return;
+    }
+    let profileName = options.profile;
+    if (!profileName) {
+        profileName = await select({
+            message: 'Select a profile:',
+            choices: [
+                { value: 'basic', name: 'Basic - Minimal guidelines' },
+                { value: 'balanced', name: 'Balanced - Comprehensive best practices (recommended)' },
+                { value: 'expert', name: 'Expert - Complete setup with all features' }
+            ]
+        });
+    }
+    const profile = getProfile(profileName);
+    console.log(chalk.cyan(`\n📋 Using profile: ${profile.name}`));
+    console.log(chalk.gray(`   ${profile.description}\n`));
+    const useAI = options.ai !== false && await isAnthropicAvailable();
+    if (!useAI) {
+        console.log(chalk.yellow('ℹ️  AI not available, using static templates\n'));
+    }
+    spinner.start('Generating configuration...');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    spinner.succeed('Configuration generated successfully!\n');
+    console.log(chalk.green('✨ Setup complete!'));
+    console.log(chalk.gray('\nGenerated files:'));
+    console.log(chalk.gray('  - .aicgen/claude.md'));
+    console.log(chalk.gray('  - .aicgen/instructions.md'));
+    if (profile.includeADR) {
+        console.log(chalk.gray('  - .aicgen/decisions.md'));
+    }
+}
+//# sourceMappingURL=init.js.map

package/dist/commands/init.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.js","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"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"}

package/dist/config/profiles.d.ts

@@ -0,0 +1,4 @@
+import { Profile } from '../models/profile.js';
+export declare const PROFILES: Record<string, Profile>;
+export declare function getProfile(name: string): Profile;
+//# sourceMappingURL=profiles.d.ts.map

package/dist/config/profiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profiles.d.ts","sourceRoot":"","sources":["../../src/config/profiles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAE/C,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAyB5C,CAAC;AAEF,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD"}