@codebakers/cli 3.0.0 → 3.1.0

package/tests/api.test.ts

@@ -0,0 +1,216 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock fetch globally
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+describe('API communication', () => {
+  beforeEach(() => {
+    mockFetch.mockClear();
+  });
+
+  describe('content API', () => {
+    it('should fetch content with API key', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({
+          version: '5.1',
+          router: '# Router content',
+          modules: {
+            '00-core.md': '# Core',
+            '02-auth.md': '# Auth',
+          },
+        }),
+      });
+
+      const response = await fetch('https://codebakers.ai/api/content', {
+        headers: { Authorization: 'Bearer test-key' },
+      });
+
+      expect(response.ok).toBe(true);
+      const data = await response.json();
+      expect(data.version).toBe('5.1');
+      expect(Object.keys(data.modules).length).toBe(2);
+    });
+
+    it('should fetch content with trial ID', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({
+          version: '5.1',
+          router: '# Router content',
+          modules: { '00-core.md': '# Core' },
+        }),
+      });
+
+      const response = await fetch('https://codebakers.ai/api/content', {
+        headers: { 'X-Trial-ID': 'trial-123' },
+      });
+
+      expect(response.ok).toBe(true);
+    });
+
+    it('should handle unauthorized response', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        json: () => Promise.resolve({ error: 'Unauthorized' }),
+      });
+
+      const response = await fetch('https://codebakers.ai/api/content', {
+        headers: { Authorization: 'Bearer invalid-key' },
+      });
+
+      expect(response.ok).toBe(false);
+      expect(response.status).toBe(401);
+    });
+
+    it('should handle network errors', async () => {
+      mockFetch.mockRejectedValueOnce(new Error('Network error'));
+
+      await expect(
+        fetch('https://codebakers.ai/api/content')
+      ).rejects.toThrow('Network error');
+    });
+  });
+
+  describe('trial API', () => {
+    it('should start a new trial', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({
+          trialId: 'trial-123',
+          stage: 'anonymous',
+          expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+          daysRemaining: 7,
+        }),
+      });
+
+      const response = await fetch('https://codebakers.ai/api/trial/start', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          deviceHash: 'test-hash',
+          machineId: 'test-machine',
+          platform: 'test',
+          hostname: 'test-host',
+        }),
+      });
+
+      expect(response.ok).toBe(true);
+      const data = await response.json();
+      expect(data.trialId).toBe('trial-123');
+      expect(data.daysRemaining).toBe(7);
+    });
+
+    it('should handle trial not available', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 400,
+        json: () => Promise.resolve({ error: 'trial_not_available' }),
+      });
+
+      const response = await fetch('https://codebakers.ai/api/trial/start', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ deviceHash: 'used-hash' }),
+      });
+
+      expect(response.ok).toBe(false);
+      const data = await response.json();
+      expect(data.error).toBe('trial_not_available');
+    });
+
+    it('should handle expired trial', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({
+          stage: 'expired',
+          canExtend: true,
+        }),
+      });
+
+      const response = await fetch('https://codebakers.ai/api/trial/start', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ deviceHash: 'expired-hash' }),
+      });
+
+      const data = await response.json();
+      expect(data.stage).toBe('expired');
+      expect(data.canExtend).toBe(true);
+    });
+  });
+
+  describe('API key validation', () => {
+    it('should validate a correct API key', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({ valid: true }),
+      });
+
+      const response = await fetch('https://codebakers.ai/api/verify', {
+        headers: { Authorization: 'Bearer valid-key' },
+      });
+
+      expect(response.ok).toBe(true);
+      const data = await response.json();
+      expect(data.valid).toBe(true);
+    });
+
+    it('should reject an invalid API key', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        json: () => Promise.resolve({ valid: false, error: 'Invalid API key' }),
+      });
+
+      const response = await fetch('https://codebakers.ai/api/verify', {
+        headers: { Authorization: 'Bearer invalid-key' },
+      });
+
+      expect(response.ok).toBe(false);
+    });
+  });
+});
+
+describe('error handling', () => {
+  beforeEach(() => {
+    mockFetch.mockClear();
+  });
+
+  it('should provide helpful error messages for timeout', async () => {
+    mockFetch.mockRejectedValueOnce(new Error('timeout'));
+
+    try {
+      await fetch('https://codebakers.ai/api/content');
+    } catch (error) {
+      expect(error).toBeInstanceOf(Error);
+      if (error instanceof Error) {
+        expect(error.message).toContain('timeout');
+      }
+    }
+  });
+
+  it('should handle rate limiting', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 429,
+      json: () => Promise.resolve({ error: 'Too many requests' }),
+    });
+
+    const response = await fetch('https://codebakers.ai/api/content');
+    expect(response.status).toBe(429);
+  });
+
+  it('should handle server errors', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+      json: () => Promise.resolve({ error: 'Internal server error' }),
+    });
+
+    const response = await fetch('https://codebakers.ai/api/content');
+    expect(response.status).toBe(500);
+  });
+});

package/tests/doctor.test.ts

@@ -0,0 +1,168 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { existsSync, writeFileSync, mkdirSync, rmSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('doctor command checks', () => {
+  let testDir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    originalCwd = process.cwd();
+    testDir = join(tmpdir(), `codebakers-doctor-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+    process.chdir(testDir);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    try {
+      rmSync(testDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('CLAUDE.md checks', () => {
+    it('should detect missing CLAUDE.md', () => {
+      const claudeMdPath = join(testDir, 'CLAUDE.md');
+      expect(existsSync(claudeMdPath)).toBe(false);
+    });
+
+    it('should detect valid CodeBakers CLAUDE.md', () => {
+      const claudeMdPath = join(testDir, 'CLAUDE.md');
+      writeFileSync(claudeMdPath, '# CODEBAKERS SMART ROUTER\nVersion: 5.1');
+
+      const content = require('fs').readFileSync(claudeMdPath, 'utf-8');
+      const isCodeBakers = content.includes('CODEBAKERS') || content.includes('CodeBakers');
+      expect(isCodeBakers).toBe(true);
+    });
+
+    it('should detect non-CodeBakers CLAUDE.md', () => {
+      const claudeMdPath = join(testDir, 'CLAUDE.md');
+      writeFileSync(claudeMdPath, '# My Custom Instructions');
+
+      const content = require('fs').readFileSync(claudeMdPath, 'utf-8');
+      const isCodeBakers = content.includes('CODEBAKERS') || content.includes('CodeBakers');
+      expect(isCodeBakers).toBe(false);
+    });
+  });
+
+  describe('.claude folder checks', () => {
+    it('should detect missing .claude folder', () => {
+      const claudeDir = join(testDir, '.claude');
+      expect(existsSync(claudeDir)).toBe(false);
+    });
+
+    it('should count modules in .claude folder', () => {
+      const claudeDir = join(testDir, '.claude');
+      mkdirSync(claudeDir, { recursive: true });
+
+      // Create test modules
+      const modules = [
+        '00-core.md',
+        '01-database.md',
+        '02-auth.md',
+        '03-api.md',
+        '04-frontend.md',
+      ];
+
+      for (const mod of modules) {
+        writeFileSync(join(claudeDir, mod), `# ${mod}`);
+      }
+
+      const files = readdirSync(claudeDir).filter(f => f.endsWith('.md'));
+      expect(files.length).toBe(5);
+    });
+
+    it('should detect insufficient modules (less than 10)', () => {
+      const claudeDir = join(testDir, '.claude');
+      mkdirSync(claudeDir, { recursive: true });
+
+      // Create only 3 modules
+      writeFileSync(join(claudeDir, '00-core.md'), '# Core');
+      writeFileSync(join(claudeDir, '01-database.md'), '# Database');
+      writeFileSync(join(claudeDir, '02-auth.md'), '# Auth');
+
+      const files = readdirSync(claudeDir).filter(f => f.endsWith('.md'));
+      expect(files.length).toBeLessThan(10);
+    });
+
+    it('should detect full module set (47+ modules)', () => {
+      const claudeDir = join(testDir, '.claude');
+      mkdirSync(claudeDir, { recursive: true });
+
+      // Create 47 modules
+      for (let i = 0; i < 47; i++) {
+        const name = i.toString().padStart(2, '0');
+        writeFileSync(join(claudeDir, `${name}-module.md`), `# Module ${i}`);
+      }
+
+      const files = readdirSync(claudeDir).filter(f => f.endsWith('.md'));
+      expect(files.length).toBeGreaterThanOrEqual(47);
+    });
+
+    it('should check for required 00-core.md', () => {
+      const claudeDir = join(testDir, '.claude');
+      mkdirSync(claudeDir, { recursive: true });
+
+      const corePath = join(claudeDir, '00-core.md');
+      expect(existsSync(corePath)).toBe(false);
+
+      writeFileSync(corePath, '# Core patterns');
+      expect(existsSync(corePath)).toBe(true);
+    });
+  });
+
+  describe('project state checks', () => {
+    it('should handle missing PROJECT-STATE.md gracefully', () => {
+      const statePath = join(testDir, 'PROJECT-STATE.md');
+      // This is optional, should not fail
+      expect(existsSync(statePath)).toBe(false);
+    });
+
+    it('should detect existing PROJECT-STATE.md', () => {
+      const statePath = join(testDir, 'PROJECT-STATE.md');
+      writeFileSync(statePath, '# Project State\n');
+      expect(existsSync(statePath)).toBe(true);
+    });
+  });
+});
+
+describe('doctor summary', () => {
+  it('should calculate correct pass/fail counts', () => {
+    const checks = [
+      { ok: true, message: 'Check 1' },
+      { ok: true, message: 'Check 2' },
+      { ok: false, message: 'Check 3' },
+      { ok: true, message: 'Check 4' },
+    ];
+
+    const passed = checks.filter(c => c.ok).length;
+    const failed = checks.filter(c => !c.ok).length;
+    const total = checks.length;
+
+    expect(passed).toBe(3);
+    expect(failed).toBe(1);
+    expect(total).toBe(4);
+  });
+
+  it('should provide fix suggestions for common issues', () => {
+    const suggestions: string[] = [];
+
+    // Simulate missing CLAUDE.md
+    const hasClaudeMd = false;
+    if (!hasClaudeMd) {
+      suggestions.push('Run: codebakers install');
+    }
+
+    // Simulate missing hook
+    const hasHook = false;
+    if (!hasHook) {
+      suggestions.push('Run: codebakers install-hook');
+    }
+
+    expect(suggestions).toContain('Run: codebakers install');
+    expect(suggestions).toContain('Run: codebakers install-hook');
+  });
+});

package/tests/go.test.ts

@@ -0,0 +1,142 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { existsSync, writeFileSync, mkdirSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+// Mock modules before importing
+vi.mock('../src/config.js', () => ({
+  getApiKey: vi.fn(() => null),
+  getTrialState: vi.fn(() => null),
+  setTrialState: vi.fn(),
+  getApiUrl: vi.fn(() => 'https://codebakers.ai'),
+  isTrialExpired: vi.fn(() => false),
+  getTrialDaysRemaining: vi.fn(() => 7),
+}));
+
+vi.mock('../src/lib/fingerprint.js', () => ({
+  getDeviceFingerprint: vi.fn(() => ({
+    deviceHash: 'test-hash',
+    machineId: 'test-machine',
+    platform: 'test',
+    hostname: 'test-host',
+  })),
+}));
+
+describe('go command', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    // Create a temp directory for each test
+    testDir = join(tmpdir(), `codebakers-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+    process.chdir(testDir);
+  });
+
+  afterEach(() => {
+    // Clean up
+    try {
+      rmSync(testDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  it('should create CLAUDE.md when patterns are installed', async () => {
+    const claudeMdPath = join(testDir, 'CLAUDE.md');
+
+    // Simulate pattern installation
+    writeFileSync(claudeMdPath, '# CodeBakers Router');
+
+    expect(existsSync(claudeMdPath)).toBe(true);
+  });
+
+  it('should create .claude directory with modules', async () => {
+    const claudeDir = join(testDir, '.claude');
+    mkdirSync(claudeDir, { recursive: true });
+
+    // Simulate module installation
+    writeFileSync(join(claudeDir, '00-core.md'), '# Core patterns');
+    writeFileSync(join(claudeDir, '02-auth.md'), '# Auth patterns');
+
+    expect(existsSync(claudeDir)).toBe(true);
+    expect(existsSync(join(claudeDir, '00-core.md'))).toBe(true);
+    expect(existsSync(join(claudeDir, '02-auth.md'))).toBe(true);
+  });
+
+  it('should handle network errors gracefully', async () => {
+    // Mock fetch to fail
+    global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
+
+    // The go command should not throw, just warn
+    expect(() => {
+      // Simulating the error handling logic
+      try {
+        throw new Error('Network error');
+      } catch (error) {
+        if (error instanceof Error && error.message.includes('Network')) {
+          // Expected behavior - handle gracefully
+        }
+      }
+    }).not.toThrow();
+  });
+});
+
+describe('pattern file writing', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `codebakers-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    try {
+      rmSync(testDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  it('should not overwrite existing CLAUDE.md', () => {
+    const claudeMdPath = join(testDir, 'CLAUDE.md');
+    const originalContent = '# My existing CLAUDE.md';
+
+    writeFileSync(claudeMdPath, originalContent);
+
+    // Simulate check before writing
+    if (existsSync(claudeMdPath)) {
+      // Should skip writing
+      const content = require('fs').readFileSync(claudeMdPath, 'utf-8');
+      expect(content).toBe(originalContent);
+    }
+  });
+
+  it('should add .claude/ to .gitignore if exists', () => {
+    const gitignorePath = join(testDir, '.gitignore');
+    writeFileSync(gitignorePath, 'node_modules/\n.env\n');
+
+    // Simulate gitignore update
+    let gitignore = require('fs').readFileSync(gitignorePath, 'utf-8');
+    if (!gitignore.includes('.claude/')) {
+      gitignore += '\n# CodeBakers patterns\n.claude/\n';
+      writeFileSync(gitignorePath, gitignore);
+    }
+
+    const updatedContent = require('fs').readFileSync(gitignorePath, 'utf-8');
+    expect(updatedContent).toContain('.claude/');
+  });
+
+  it('should handle missing .gitignore gracefully', () => {
+    const gitignorePath = join(testDir, '.gitignore');
+
+    // Don't create .gitignore
+    expect(existsSync(gitignorePath)).toBe(false);
+
+    // Should not throw when trying to update non-existent .gitignore
+    expect(() => {
+      if (existsSync(gitignorePath)) {
+        // Would update gitignore
+      }
+    }).not.toThrow();
+  });
+});

package/vitest.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'html'],
+      include: ['src/**/*.ts'],
+      exclude: ['src/mcp/**', 'src/templates/**'],
+    },
+    testTimeout: 30000,
+  },
+});