@oalacea/demon 1.0.0

package/prompts/UNIT.md

@@ -0,0 +1,260 @@
+# Unit Test Generation Guide
+
+This prompt is included by EXECUTE.md. It provides detailed guidance for generating unit tests.
+
+---
+
+## Component Test Patterns
+
+### Presentational Components
+
+```typescript
+// Button component test
+describe('Button', () => {
+  it('should render with default props', () => {
+    render(<Button>Click me</Button>);
+    expect(screen.getByRole('button')).toHaveTextContent('Click me');
+  });
+
+  it('should apply variant classes', () => {
+    render(<Button variant="danger">Delete</Button>);
+    expect(screen.getByRole('button')).toHaveClass('btn-danger');
+  });
+
+  it('should be disabled when loading', () => {
+    render(<Button loading>Submit</Button>);
+    expect(screen.getByRole('button')).toBeDisabled();
+    expect(screen.getByTestId('spinner')).toBeInTheDocument();
+  });
+});
+```
+
+### Container Components
+
+```typescript
+// UserList component test
+describe('UserList', () => {
+  it('should show loading state', () => {
+    vi.mocked(useUsers).mockReturnValue({ data: null, loading: true });
+    render(<UserList />);
+    expect(screen.getByTestId('skeleton')).toBeInTheDocument();
+  });
+
+  it('should show error state', () => {
+    vi.mocked(useUsers).mockReturnValue({
+      data: null,
+      loading: false,
+      error: new Error('Failed to fetch')
+    });
+    render(<UserList />);
+    expect(screen.getByText('Failed to fetch')).toBeInTheDocument();
+  });
+
+  it('should render users', () => {
+    vi.mocked(useUsers).mockReturnValue({
+      data: [{ id: '1', name: 'John' }],
+      loading: false,
+      error: null
+    });
+    render(<UserList />);
+    expect(screen.getByText('John')).toBeInTheDocument();
+  });
+});
+```
+
+---
+
+## Hook Test Patterns
+
+```typescript
+import { renderHook, act, waitFor } from '@testing-library/react';
+
+describe('useDebounce', () => {
+  vi.useFakeTimers();
+
+  it('should debounce value changes', async () => {
+    const { result } = renderHook(() => useDebounce('test', 500));
+
+    // Immediate value
+    expect(result.current).toBe('test');
+
+    // Change value immediately
+    act(() => {
+      result.current.setValue('test2');
+    });
+    expect(result.current.value).toBe('test'); // Not debounced yet
+
+    // Fast-forward
+    act(() => {
+      vi.advanceTimersByTime(500);
+    });
+    expect(result.current.value).toBe('test2');
+  });
+});
+```
+
+---
+
+## Utility Function Patterns
+
+```typescript
+describe('formatCurrency', () => {
+  it('should format positive numbers', () => {
+    expect(formatCurrency(1234.56)).toBe('$1,234.56');
+  });
+
+  it('should format zero', () => {
+    expect(formatCurrency(0)).toBe('$0.00');
+  });
+
+  it('should handle negative numbers', () => {
+    expect(formatCurrency(-100)).toBe('-$100.00');
+  });
+
+  it('should round to 2 decimal places', () => {
+    expect(formatCurrency(1.999)).toBe('$2.00');
+  });
+});
+```
+
+---
+
+## Validator Test Patterns (Zod)
+
+```typescript
+import { z } from 'zod';
+import { userSchema } from './schema';
+
+describe('userSchema', () => {
+  const validData = {
+    email: 'test@example.com',
+    age: 25,
+    name: 'John Doe'
+  };
+
+  it('should accept valid data', () => {
+    expect(() => userSchema.parse(validData)).not.toThrow();
+  });
+
+  it('should reject invalid email', () => {
+    expect(() =>
+      userSchema.parse({ ...validData, email: 'invalid' })
+    ).toThrow(z.ZodError);
+  });
+
+  it('should reject negative age', () => {
+    expect(() =>
+      userSchema.parse({ ...validData, age: -1 })
+    ).toThrow(z.ZodError);
+  });
+
+  it('should reject missing required fields', () => {
+    expect(() => userSchema.parse({})).toThrow(z.ZodError);
+  });
+});
+```
+
+---
+
+## Store Test Patterns (Zustand)
+
+```typescript
+import { create } from 'zustand';
+import { useAuthStore } from './authStore';
+
+describe('useAuthStore', () => {
+  beforeEach(() => {
+    useAuthStore.getState().reset();
+  });
+
+  it('should set user on login', () => {
+    const user = { id: '1', name: 'John' };
+    useAuthStore.getState().login(user);
+    expect(useAuthStore.getState().user).toEqual(user);
+    expect(useAuthStore.getState().isAuthenticated).toBe(true);
+  });
+
+  it('should clear user on logout', () => {
+    useAuthStore.getState().login({ id: '1', name: 'John' });
+    useAuthStore.getState().logout();
+    expect(useAuthStore.getState().user).toBeNull();
+    expect(useAuthStore.getState().isAuthenticated).toBe(false);
+  });
+});
+```
+
+---
+
+## Mock Patterns
+
+### Mocking React Query
+
+```typescript
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+
+function createTestQueryClient() {
+  return new QueryClient({
+    defaultOptions: {
+      queries: { retry: false },
+      mutations: { retry: false }
+    }
+  });
+}
+
+function Wrapper({ children }) {
+  return (
+    <QueryClientProvider client={createTestQueryClient()}>
+      {children}
+    </QueryClientProvider>
+  );
+}
+
+describe('MyComponent', () => {
+  it('should work with React Query', () => {
+    render(<MyComponent />, { wrapper: Wrapper });
+  });
+});
+```
+
+### Mocking Next.js Router
+
+```typescript
+import { useRouter } from 'next/navigation';
+
+vi.mock('next/navigation', () => ({
+  useRouter: () => ({
+    push: vi.fn(),
+    replace: vi.fn(),
+    prefetch: vi.fn(),
+    back: vi.fn(),
+    pathname: '/test'
+  }),
+  useSearchParams: () => new URLSearchParams('foo=bar'),
+  usePathname: () => '/test'
+}));
+```
+
+### Mocking Fetch
+
+```typescript
+global.fetch = vi.fn(() =>
+  Promise.resolve({
+    ok: true,
+    json: () => Promise.resolve({ data: 'test' })
+  })
+) as ReturnType<typeof vi.fn>;
+
+// Or use MSW for more complex scenarios
+import { http, HttpResponse } from 'msw';
+import { setupServer } from 'msw/node';
+
+const server = setupServer(
+  http.get('/api/users', () => {
+    return HttpResponse.json({ users: [] });
+  })
+);
+
+beforeAll(() => server.listen());
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+```

package/scripts/dev.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+
+/**
+ * Demon Development Script
+ *
+ * For local development and testing of the Demon CLI.
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+
+const command = process.argv[2] || 'help';
+
+const commands = {
+  help: () => {
+    console.log(`
+Demon Development Commands
+
+  Usage: node scripts/dev.js <command>
+
+  Commands:
+    test       Run detector test
+    build      Build Docker image
+    start      Start container
+    stop       Stop container
+    clean      Remove container and image
+    logs       Show container logs
+    shell      Open shell in container
+    link       Link package globally for testing
+  `);
+  },
+
+  test: () => {
+    console.log('Testing detector...');
+    const detector = require('../agents/detector.js');
+    detector.analyze(process.cwd())
+      .then((context) => {
+        console.log(JSON.stringify(context, null, 2));
+      })
+      .catch((err) => {
+        console.error('Detection failed:', err);
+        process.exit(1);
+      });
+  },
+
+  build: () => {
+    console.log('Building Docker image...');
+    const dockerfile = path.join(__dirname, '..', 'bin', 'Dockerfile');
+    execSync(`docker build -t demon-tools -f "${dockerfile}" "${path.dirname(dockerfile)}"`, {
+      stdio: 'inherit',
+    });
+    console.log('✓ Build complete');
+  },
+
+  start: () => {
+    console.log('Starting container...');
+    try {
+      execSync('docker start demon-tools', { stdio: 'inherit' });
+      console.log('✓ Container started');
+    } catch {
+      const isLinux = process.platform === 'linux';
+      const networkFlag = isLinux ? '--network=host' : '';
+      execSync(`docker run -d --name demon-tools ${networkFlag} demon-tools`, {
+        stdio: 'inherit',
+      });
+      console.log('✓ Container created');
+    }
+  },
+
+  stop: () => {
+    console.log('Stopping container...');
+    execSync('docker stop demon-tools', { stdio: 'inherit' });
+    console.log('✓ Container stopped');
+  },
+
+  clean: () => {
+    console.log('Removing container...');
+    execSync('docker rm -f demon-tools', { stdio: 'inherit', timeout: 5000 }).catch(() => {});
+    console.log('Removing image...');
+    execSync('docker rmi demon-tools', { stdio: 'inherit', timeout: 30000 }).catch(() => {});
+    console.log('✓ Clean complete');
+  },
+
+  logs: () => {
+    execSync('docker logs -f demon-tools', { stdio: 'inherit' });
+  },
+
+  shell: () => {
+    console.log('Opening shell in container...');
+    execSync('docker exec -it demon-tools bash', { stdio: 'inherit' });
+  },
+
+  link: () => {
+    console.log('Linking package globally...');
+    execSync('npm link', { stdio: 'inherit', cwd: path.join(__dirname, '..') });
+    console.log('✓ Package linked globally');
+    console.log('You can now run: demon');
+  },
+};
+
+if (commands[command]) {
+  commands[command]();
+} else {
+  console.log(`Unknown command: ${command}`);
+  commands.help();
+}

package/templates/README.md

@@ -0,0 +1,22 @@
+# Demon Templates
+
+This directory contains test templates for different frameworks and tools.
+
+## Structure
+
+```
+templates/
+├── vitest/          # Vitest test templates
+│   ├── component.test.ts
+│   ├── hook.test.ts
+│   └── api.test.ts
+├── playwright/      # Playwright E2E templates
+│   ├── auth.spec.ts
+│   └── crud.spec.ts
+└── k6/              # k6 performance templates
+    └── load-test.js
+```
+
+## Usage
+
+Templates are used by the test generator agent to create new test files based on the detected framework and patterns.

package/templates/k6/load-test.js

@@ -0,0 +1,54 @@
+import http from 'k6/http';
+import { check, sleep } from 'k6';
+
+// Configuration
+export const options = {
+  stages: [
+    { duration: '30s', target: 20 },   // Ramp up to 20 users
+    { duration: '1m', target: 20 },    // Stay at 20 users
+    { duration: '30s', target: 50 },   // Ramp up to 50 users
+    { duration: '1m', target: 50 },    // Stay at 50 users
+    { duration: '30s', target: 0 },    // Ramp down
+  ],
+  thresholds: {
+    http_req_duration: ['p(95)<200', 'p(99)<500'],
+    http_req_failed: ['rate<0.01'],
+  },
+};
+
+const BASE_URL = __ENV.BASE_URL || 'http://host.docker.internal:3000';
+
+export default function () {
+  // Test homepage
+  let res = http.get(`${BASE_URL}/`);
+  check(res, {
+    'homepage status 200': (r) => r.status === 200,
+    'homepage response time < 200ms': (r) => r.timings.duration < 200,
+  });
+
+  sleep(1);
+
+  // Test API endpoint
+  res = http.get(`${BASE_URL}/api/users`);
+  check(res, {
+    'users API status 200': (r) => r.status === 200,
+    'users response time < 200ms': (r) => r.timings.duration < 200,
+  });
+
+  sleep(1);
+
+  // Test POST endpoint
+  res = http.post(`${BASE_URL}/api/contact`, JSON.stringify({
+    name: 'Test User',
+    email: 'test@example.com',
+    message: 'Test message',
+  }), {
+    headers: { 'Content-Type': 'application/json' },
+  });
+
+  check(res, {
+    'contact API status 200': (r) => r.status === 200,
+  });
+
+  sleep(1);
+}

package/templates/playwright/e2e.spec.ts

@@ -0,0 +1,61 @@
+import { test, expect } from '@playwright/test';
+
+test.describe('Authentication Flow', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/login');
+  });
+
+  test('should login with valid credentials', async ({ page }) => {
+    await page.fill('input[name="email"]', 'test@example.com');
+    await page.fill('input[name="password"]', 'password123');
+    await page.click('button[type="submit"]');
+
+    // Should redirect to dashboard
+    await expect(page).toHaveURL(/\/dashboard/);
+    await expect(page.locator('h1')).toContainText('Dashboard');
+  });
+
+  test('should show error with invalid credentials', async ({ page }) => {
+    await page.fill('input[name="email"]', 'test@example.com');
+    await page.fill('input[name="password"]', 'wrong-password');
+    await page.click('button[type="submit"]');
+
+    await expect(page.locator('.error')).toContainText('Invalid credentials');
+    await expect(page).toHaveURL('/login');
+  });
+});
+
+test.describe('Navigation', () => {
+  test('should navigate between pages', async ({ page }) => {
+    await page.goto('/');
+
+    await page.click('text=About');
+    await expect(page).toHaveURL('/about');
+
+    await page.goBack();
+    await expect(page).toHaveURL('/');
+
+    await page.goForward();
+    await expect(page).toHaveURL('/about');
+  });
+});
+
+test.describe('Form Interaction', () => {
+  test('should submit form successfully', async ({ page }) => {
+    await page.goto('/form');
+
+    await page.fill('input[name="name"]', 'Test User');
+    await page.fill('input[name="email"]', 'test@example.com');
+    await page.click('button[type="submit"]');
+
+    await expect(page.locator('.success')).toContainText('Form submitted');
+  });
+
+  test('should show validation errors', async ({ page }) => {
+    await page.goto('/form');
+    await page.click('button[type="submit"]');
+
+    await expect(page.locator('input[name="name"]')).toHaveAttribute('aria-invalid', 'true');
+    await expect(page.locator('input[name="email"]')).toHaveAttribute('aria-invalid', 'true');
+  });
+});

package/templates/vitest/api.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { POST, GET, PATCH, DELETE } from '@/app/api/route';
+
+// TODO: Import database setup if needed
+// import { db } from '@test/db';
+
+describe('API Endpoint', () => {
+  beforeEach(async () => {
+    // TODO: Setup test database
+    // await db.begin();
+  });
+
+  afterEach(async () => {
+    // TODO: Cleanup test database
+    // await db.rollback();
+  });
+
+  it('should return 200 for GET request', async () => {
+    const request = new Request('http://localhost:3000/api/endpoint', {
+      method: 'GET',
+    });
+
+    const response = await GET(request);
+    expect(response.status).toBe(200);
+  });
+
+  it('should create resource with POST', async () => {
+    const request = new Request('http://localhost:3000/api/endpoint', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'Test' }),
+    });
+
+    const response = await POST(request);
+    expect(response.status).toBe(201);
+
+    const data = await response.json();
+    expect(data).toHaveProperty('id');
+  });
+
+  it('should validate input data', async () => {
+    const request = new Request('http://localhost:3000/api/endpoint', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ invalid: 'data' }),
+    });
+
+    const response = await POST(request);
+    expect(response.status).toBe(400);
+  });
+});

package/templates/vitest/component.test.ts

@@ -0,0 +1,27 @@
+import { render, screen } from '@testing-library/react';
+import { describe, it, expect, vi } from 'vitest';
+import userEvent from '@testing-library/user-event';
+
+// TODO: Import your component
+// import { ComponentName } from '@/components/ComponentName';
+
+describe('ComponentName', () => {
+  it('should render', () => {
+    // TODO: Add component render
+    // render(<ComponentName />);
+    // expect(screen.getByRole('button')).toBeInTheDocument();
+  });
+
+  it('should render with children', () => {
+    // TODO: Test children rendering
+    // render(<ComponentName>Test content</ComponentName>);
+    // expect(screen.getByText('Test content')).toBeInTheDocument();
+  });
+
+  it('should handle user interaction', async () => {
+    // TODO: Test click/hover/etc
+    // const user = userEvent.setup();
+    // render(<ComponentName onClick={vi.fn()} />);
+    // await user.click(screen.getByRole('button'));
+  });
+});

package/templates/vitest/hook.test.ts

@@ -0,0 +1,36 @@
+import { renderHook, act, waitFor } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// TODO: Import your hook
+// import { useHookName } from '@/hooks/useHookName';
+
+describe('useHookName', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return initial state', () => {
+    // TODO: Test initial state
+    // const { result } = renderHook(() => useHookName());
+    // expect(result.current).toBeDefined();
+  });
+
+  it('should update state', async () => {
+    // TODO: Test state updates
+    // const { result } = renderHook(() => useHookName());
+    // act(() => {
+    //   result.current.setValue('test');
+    // });
+    // await waitFor(() => {
+    //   expect(result.current.value).toBe('test');
+    // });
+  });
+
+  it('should cleanup on unmount', () => {
+    // TODO: Test cleanup
+    // const { unmount } = renderHook(() => useHookName());
+    // const cleanup = vi.fn();
+    // unmount();
+    // expect(cleanup).toHaveBeenCalled();
+  });
+});