popeye-cli 1.7.0 → 1.9.0

package/tests/types/audit.test.ts

@@ -0,0 +1,250 @@
+/**
+ * Tests for audit type schemas.
+ */
+import { describe, it, expect } from 'vitest';
+import {
+  AuditSeveritySchema,
+  AuditCategorySchema,
+  ComponentKindSchema,
+  AuditEvidenceSchema,
+  DependencyManifestSchema,
+  FileEntrySchema,
+  ComponentScanSchema,
+  WiringMismatchSchema,
+  WiringMatrixSchema,
+  SearchMetadataSchema,
+  AuditFindingSchema,
+  ProjectSummaryReportSchema,
+  ProjectAuditReportSchema,
+  RecoveryTaskSchema,
+  RecoveryMilestoneSchema,
+  RecoveryPlanSchema,
+  AuditModeOptionsSchema,
+} from '../../src/types/audit.js';
+
+describe('AuditSeveritySchema', () => {
+  it('should accept valid severity values', () => {
+    expect(AuditSeveritySchema.parse('critical')).toBe('critical');
+    expect(AuditSeveritySchema.parse('major')).toBe('major');
+    expect(AuditSeveritySchema.parse('minor')).toBe('minor');
+    expect(AuditSeveritySchema.parse('info')).toBe('info');
+  });
+
+  it('should reject invalid values', () => {
+    expect(() => AuditSeveritySchema.parse('high')).toThrow();
+    expect(() => AuditSeveritySchema.parse('')).toThrow();
+  });
+});
+
+describe('AuditCategorySchema', () => {
+  it('should accept all valid categories', () => {
+    const categories = [
+      'feature-completeness',
+      'integration-wiring',
+      'test-coverage',
+      'config-deployment',
+      'dependency-sanity',
+      'consistency',
+      'security',
+      'documentation',
+    ];
+    for (const cat of categories) {
+      expect(AuditCategorySchema.parse(cat)).toBe(cat);
+    }
+  });
+
+  it('should reject invalid category', () => {
+    expect(() => AuditCategorySchema.parse('performance')).toThrow();
+  });
+});
+
+describe('ComponentKindSchema', () => {
+  it('should accept valid kinds', () => {
+    expect(ComponentKindSchema.parse('frontend')).toBe('frontend');
+    expect(ComponentKindSchema.parse('backend')).toBe('backend');
+    expect(ComponentKindSchema.parse('website')).toBe('website');
+    expect(ComponentKindSchema.parse('shared')).toBe('shared');
+    expect(ComponentKindSchema.parse('infra')).toBe('infra');
+  });
+
+  it('should reject unknown kind', () => {
+    expect(() => ComponentKindSchema.parse('mobile')).toThrow();
+  });
+});
+
+describe('ComponentScanSchema', () => {
+  const validComponent = {
+    kind: 'frontend',
+    rootDir: 'apps/frontend',
+    language: 'typescript',
+    framework: 'react',
+    entryPoints: ['src/main.tsx'],
+    routeFiles: ['src/App.tsx'],
+    testFiles: [{ path: 'tests/App.test.tsx', lines: 50 }],
+    sourceFiles: [{ path: 'src/main.tsx', lines: 20, extension: '.tsx' }],
+    dependencyManifests: [
+      { file: 'package.json', type: 'package.json', dependencies: { react: '^18.0.0' } },
+    ],
+  };
+
+  it('should validate a complete component scan', () => {
+    const result = ComponentScanSchema.parse(validComponent);
+    expect(result.kind).toBe('frontend');
+    expect(result.rootDir).toBe('apps/frontend');
+    expect(result.sourceFiles).toHaveLength(1);
+  });
+
+  it('should accept minimal component scan', () => {
+    const minimal = {
+      kind: 'backend',
+      rootDir: '.',
+      language: 'python',
+      entryPoints: [],
+      routeFiles: [],
+      testFiles: [],
+      sourceFiles: [],
+      dependencyManifests: [],
+    };
+    const result = ComponentScanSchema.parse(minimal);
+    expect(result.framework).toBeUndefined();
+  });
+
+  it('should reject invalid language', () => {
+    expect(() =>
+      ComponentScanSchema.parse({ ...validComponent, language: 'rust' })
+    ).toThrow();
+  });
+});
+
+describe('WiringMatrixSchema', () => {
+  it('should validate a complete wiring matrix', () => {
+    const wiring = {
+      frontendApiBaseEnvKeys: ['VITE_API_URL'],
+      frontendApiBaseResolved: 'http://localhost:3000',
+      backendCorsOrigins: ['http://localhost:5173'],
+      backendApiPrefix: '/api',
+      potentialMismatches: [
+        {
+          type: 'cors-origin-mismatch',
+          details: 'Frontend origin not in CORS list',
+          evidence: [{ file: '.env.example', snippet: 'VITE_API_URL=http://localhost:3000' }],
+        },
+      ],
+    };
+    const result = WiringMatrixSchema.parse(wiring);
+    expect(result.potentialMismatches).toHaveLength(1);
+  });
+
+  it('should accept empty mismatches', () => {
+    const wiring = {
+      frontendApiBaseEnvKeys: [],
+      potentialMismatches: [],
+    };
+    const result = WiringMatrixSchema.parse(wiring);
+    expect(result.potentialMismatches).toHaveLength(0);
+  });
+});
+
+describe('SearchMetadataSchema', () => {
+  it('should validate search metadata', () => {
+    const meta = {
+      serenaUsed: true,
+      serenaRetries: 1,
+      serenaErrors: ['timeout'],
+      fallbackUsed: true,
+      fallbackTool: 'grep',
+      searchQueries: ['find_symbol UserService'],
+    };
+    const result = SearchMetadataSchema.parse(meta);
+    expect(result.serenaUsed).toBe(true);
+    expect(result.serenaRetries).toBe(1);
+  });
+
+  it('should require all fields', () => {
+    expect(() => SearchMetadataSchema.parse({ serenaUsed: true })).toThrow();
+  });
+});
+
+describe('AuditFindingSchema', () => {
+  const validFinding = {
+    id: 'AUD-001',
+    category: 'test-coverage',
+    severity: 'major',
+    title: 'No tests for auth module',
+    description: 'The authentication module has zero test files.',
+    evidence: [{ file: 'src/auth/login.ts', description: 'No test file found' }],
+    recommendation: 'Add unit tests for auth handlers',
+    autoFixable: false,
+  };
+
+  it('should validate a complete finding', () => {
+    const result = AuditFindingSchema.parse(validFinding);
+    expect(result.id).toBe('AUD-001');
+    expect(result.autoFixable).toBe(false);
+  });
+
+  it('should reject missing required fields', () => {
+    const { recommendation, ...incomplete } = validFinding;
+    expect(() => AuditFindingSchema.parse(incomplete)).toThrow();
+  });
+
+  it('should reject invalid severity', () => {
+    expect(() =>
+      AuditFindingSchema.parse({ ...validFinding, severity: 'high' })
+    ).toThrow();
+  });
+});
+
+describe('RecoveryTaskSchema', () => {
+  it('should require appTarget', () => {
+    const task = {
+      name: 'Fix CORS config',
+      description: 'Update backend CORS settings',
+      findingIds: ['AUD-003'],
+      acceptanceCriteria: ['CORS allows frontend origin'],
+      appTarget: 'backend',
+    };
+    const result = RecoveryTaskSchema.parse(task);
+    expect(result.appTarget).toBe('backend');
+  });
+
+  it('should reject missing appTarget', () => {
+    const task = {
+      name: 'Fix something',
+      description: 'A task',
+      findingIds: ['AUD-001'],
+      acceptanceCriteria: ['Fixed'],
+    };
+    expect(() => RecoveryTaskSchema.parse(task)).toThrow();
+  });
+});
+
+describe('AuditModeOptionsSchema', () => {
+  it('should apply defaults', () => {
+    const result = AuditModeOptionsSchema.parse({ projectDir: '/tmp/proj' });
+    expect(result.depth).toBe(2);
+    expect(result.runTests).toBe(true);
+    expect(result.strict).toBe(false);
+    expect(result.format).toBe('both');
+    expect(result.autoRecover).toBe(true);
+    expect(result.target).toBe('all');
+  });
+
+  it('should accept overrides', () => {
+    const result = AuditModeOptionsSchema.parse({
+      projectDir: '/tmp/proj',
+      depth: 3,
+      strict: true,
+      target: 'frontend',
+    });
+    expect(result.depth).toBe(3);
+    expect(result.strict).toBe(true);
+    expect(result.target).toBe('frontend');
+  });
+
+  it('should reject depth out of range', () => {
+    expect(() =>
+      AuditModeOptionsSchema.parse({ projectDir: '/tmp/proj', depth: 5 })
+    ).toThrow();
+  });
+});

package/tests/types/database-runtime.test.ts

@@ -0,0 +1,158 @@
+/**
+ * Tests for database runtime types and schemas
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  SetupStepResultSchema,
+  SetupResultSchema,
+  ReadinessCheckSchema,
+  ReadinessResultSchema,
+} from '../../src/types/database-runtime.js';
+
+describe('SetupStepResultSchema', () => {
+  it('should accept a valid successful step result', () => {
+    const result = SetupStepResultSchema.safeParse({
+      step: 'check_connection',
+      success: true,
+      message: 'Database connection verified',
+      durationMs: 150,
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept a failed step result with error', () => {
+    const result = SetupStepResultSchema.safeParse({
+      step: 'apply_migrations',
+      success: false,
+      message: 'Migration failed',
+      durationMs: 3000,
+      error: 'alembic upgrade head returned exit code 1',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject invalid step names', () => {
+    const result = SetupStepResultSchema.safeParse({
+      step: 'invalid_step',
+      success: true,
+      message: 'ok',
+      durationMs: 0,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('should reject missing required fields', () => {
+    const result = SetupStepResultSchema.safeParse({
+      step: 'check_connection',
+      success: true,
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('SetupResultSchema', () => {
+  it('should accept a successful pipeline result', () => {
+    const result = SetupResultSchema.safeParse({
+      success: true,
+      steps: [
+        { step: 'check_connection', success: true, message: 'ok', durationMs: 100 },
+        { step: 'apply_migrations', success: true, message: 'ok', durationMs: 200 },
+      ],
+      totalDurationMs: 300,
+      finalStatus: 'ready',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept a failed pipeline result with error', () => {
+    const result = SetupResultSchema.safeParse({
+      success: false,
+      steps: [
+        { step: 'check_connection', success: false, message: 'fail', durationMs: 50, error: 'timeout' },
+      ],
+      totalDurationMs: 50,
+      finalStatus: 'error',
+      error: 'timeout',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept empty steps array', () => {
+    const result = SetupResultSchema.safeParse({
+      success: false,
+      steps: [],
+      totalDurationMs: 0,
+      finalStatus: 'error',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject invalid finalStatus', () => {
+    const result = SetupResultSchema.safeParse({
+      success: true,
+      steps: [],
+      totalDurationMs: 0,
+      finalStatus: 'complete',
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('ReadinessCheckSchema', () => {
+  it('should accept all severity levels', () => {
+    for (const severity of ['critical', 'warning', 'info'] as const) {
+      const result = ReadinessCheckSchema.safeParse({
+        name: 'Test Check',
+        passed: true,
+        message: 'Check passed',
+        severity,
+      });
+      expect(result.success).toBe(true);
+    }
+  });
+
+  it('should reject invalid severity', () => {
+    const result = ReadinessCheckSchema.safeParse({
+      name: 'Test',
+      passed: true,
+      message: 'ok',
+      severity: 'error',
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('ReadinessResultSchema', () => {
+  it('should accept a healthy result with checks', () => {
+    const result = ReadinessResultSchema.safeParse({
+      healthy: true,
+      checks: [
+        { name: 'DB Connection', passed: true, message: 'Connected', severity: 'critical' },
+        { name: 'pgvector', passed: true, message: 'Available', severity: 'warning' },
+      ],
+      timestamp: '2024-01-01T00:00:00Z',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept an unhealthy result', () => {
+    const result = ReadinessResultSchema.safeParse({
+      healthy: false,
+      checks: [
+        { name: 'DB Connection', passed: false, message: 'Cannot connect', severity: 'critical' },
+      ],
+      timestamp: '2024-01-01T00:00:00Z',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept empty checks array', () => {
+    const result = ReadinessResultSchema.safeParse({
+      healthy: true,
+      checks: [],
+      timestamp: '2024-01-01T00:00:00Z',
+    });
+    expect(result.success).toBe(true);
+  });
+});

package/tests/types/database.test.ts

@@ -0,0 +1,187 @@
+/**
+ * Tests for database types and schemas
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  DbStatusSchema,
+  DbModeSchema,
+  DbProviderSchema,
+  BackendOrmSchema,
+  DbSetupStepSchema,
+  DbConfigSchema,
+  DEFAULT_DB_CONFIG,
+} from '../../src/types/database.js';
+
+describe('DbStatusSchema', () => {
+  it('should accept all valid status values', () => {
+    const validStatuses = ['unconfigured', 'configured', 'applying', 'ready', 'error'];
+    for (const status of validStatuses) {
+      expect(DbStatusSchema.safeParse(status).success).toBe(true);
+    }
+  });
+
+  it('should reject invalid status values', () => {
+    expect(DbStatusSchema.safeParse('pending').success).toBe(false);
+    expect(DbStatusSchema.safeParse('active').success).toBe(false);
+    expect(DbStatusSchema.safeParse('').success).toBe(false);
+    expect(DbStatusSchema.safeParse(123).success).toBe(false);
+  });
+});
+
+describe('DbModeSchema', () => {
+  it('should accept valid modes', () => {
+    expect(DbModeSchema.safeParse('local_docker').success).toBe(true);
+    expect(DbModeSchema.safeParse('managed').success).toBe(true);
+  });
+
+  it('should reject unconfigured and unknown values', () => {
+    expect(DbModeSchema.safeParse('unconfigured').success).toBe(false);
+    expect(DbModeSchema.safeParse('cloud').success).toBe(false);
+    expect(DbModeSchema.safeParse('').success).toBe(false);
+  });
+});
+
+describe('DbProviderSchema', () => {
+  it('should accept valid providers', () => {
+    expect(DbProviderSchema.safeParse('neon').success).toBe(true);
+    expect(DbProviderSchema.safeParse('supabase').success).toBe(true);
+    expect(DbProviderSchema.safeParse('other').success).toBe(true);
+  });
+
+  it('should reject unknown providers', () => {
+    expect(DbProviderSchema.safeParse('aws').success).toBe(false);
+  });
+});
+
+describe('BackendOrmSchema', () => {
+  it('should accept valid ORM values', () => {
+    expect(BackendOrmSchema.safeParse('sqlalchemy').success).toBe(true);
+    expect(BackendOrmSchema.safeParse('prisma').success).toBe(true);
+    expect(BackendOrmSchema.safeParse('drizzle').success).toBe(true);
+  });
+
+  it('should reject unknown ORM values', () => {
+    expect(BackendOrmSchema.safeParse('typeorm').success).toBe(false);
+  });
+});
+
+describe('DbConfigSchema', () => {
+  it('should accept a full config with all fields', () => {
+    const config = {
+      designed: true,
+      mode: 'local_docker',
+      vectorRequired: true,
+      status: 'ready',
+      lastError: undefined,
+      migrationsApplied: 3,
+      readinessCheckedAt: '2024-01-01T00:00:00Z',
+    };
+    const result = DbConfigSchema.safeParse(config);
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept a minimal config without optional mode', () => {
+    const config = {
+      designed: true,
+      vectorRequired: true,
+      status: 'unconfigured',
+      migrationsApplied: 0,
+    };
+    const result = DbConfigSchema.safeParse(config);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.mode).toBeUndefined();
+    }
+  });
+
+  it('should allow mode set with status unconfigured (valid during transitions)', () => {
+    const config = {
+      designed: true,
+      mode: 'managed',
+      vectorRequired: false,
+      status: 'unconfigured',
+      migrationsApplied: 0,
+    };
+    const result = DbConfigSchema.safeParse(config);
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject config with invalid status', () => {
+    const config = {
+      designed: true,
+      vectorRequired: true,
+      status: 'broken',
+      migrationsApplied: 0,
+    };
+    expect(DbConfigSchema.safeParse(config).success).toBe(false);
+  });
+
+  it('should reject config missing required fields', () => {
+    const config = { designed: true };
+    expect(DbConfigSchema.safeParse(config).success).toBe(false);
+  });
+});
+
+describe('DEFAULT_DB_CONFIG', () => {
+  it('should have correct initial values', () => {
+    expect(DEFAULT_DB_CONFIG.designed).toBe(true);
+    expect(DEFAULT_DB_CONFIG.status).toBe('unconfigured');
+    expect(DEFAULT_DB_CONFIG.vectorRequired).toBe(true);
+    expect(DEFAULT_DB_CONFIG.migrationsApplied).toBe(0);
+  });
+
+  it('should not have mode set (absent until user configures)', () => {
+    expect(DEFAULT_DB_CONFIG.mode).toBeUndefined();
+  });
+
+  it('should parse through DbConfigSchema successfully', () => {
+    const result = DbConfigSchema.safeParse(DEFAULT_DB_CONFIG);
+    expect(result.success).toBe(true);
+  });
+});
+
+describe('DbSetupStepSchema', () => {
+  it('should accept all setup steps', () => {
+    const steps = [
+      'check_connection',
+      'ensure_extensions',
+      'apply_migrations',
+      'seed_minimal',
+      'readiness_tests',
+      'mark_ready',
+    ];
+    for (const step of steps) {
+      expect(DbSetupStepSchema.safeParse(step).success).toBe(true);
+    }
+  });
+});
+
+describe('ProjectStateSchema backward compatibility', () => {
+  it('should parse existing state without dbConfig field', async () => {
+    // Import ProjectStateSchema to verify backward compat
+    const { ProjectStateSchema } = await import('../../src/types/workflow.js');
+
+    const existingState = {
+      id: 'test-id',
+      name: 'test-project',
+      idea: 'Build something',
+      language: 'fullstack',
+      openaiModel: 'gpt-4o',
+      phase: 'plan',
+      status: 'pending',
+      milestones: [],
+      currentMilestone: null,
+      currentTask: null,
+      consensusHistory: [],
+      createdAt: '2024-01-01T00:00:00Z',
+      updatedAt: '2024-01-01T00:00:00Z',
+    };
+
+    const result = ProjectStateSchema.safeParse(existingState);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.dbConfig).toBeUndefined();
+    }
+  });
+});