popeye-cli 1.7.0 → 1.8.0

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();
+    }
+  });
+});

package/tests/workflow/db-setup-runner.test.ts

@@ -0,0 +1,211 @@
+/**
+ * Tests for database setup pipeline runner
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import {
+  readEnvFile,
+  parseMigrationPrereqs,
+  getPackageName,
+  resolveBackendDir,
+  computePostPipelineStatus,
+} from '../../src/workflow/db-setup-runner.js';
+import type { SetupResult } from '../../src/types/database-runtime.js';
+
+// Mock fs for controlled tests
+vi.mock('node:fs', async () => {
+  const actual = await vi.importActual('node:fs');
+  return {
+    ...actual,
+    promises: {
+      ...actual.promises,
+      readFile: vi.fn(),
+      readdir: vi.fn(),
+    },
+  };
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('readEnvFile', () => {
+  it('should parse key=value pairs from .env content', async () => {
+    vi.mocked(fs.readFile).mockResolvedValue(
+      'DEBUG=true\nDATABASE_URL=postgresql://localhost/db\nPOSTGRES_USER=postgres\n'
+    );
+
+    const result = await readEnvFile('/some/path/.env');
+    expect(result).toEqual({
+      DEBUG: 'true',
+      DATABASE_URL: 'postgresql://localhost/db',
+      POSTGRES_USER: 'postgres',
+    });
+  });
+
+  it('should skip comments and empty lines', async () => {
+    vi.mocked(fs.readFile).mockResolvedValue(
+      '# This is a comment\n\nDATABASE_URL=postgres://host/db\n# Another comment\n'
+    );
+
+    const result = await readEnvFile('/some/path/.env');
+    expect(result).toEqual({
+      DATABASE_URL: 'postgres://host/db',
+    });
+  });
+
+  it('should strip surrounding quotes from values', async () => {
+    vi.mocked(fs.readFile).mockResolvedValue(
+      'FOO="bar"\nBAZ=\'qux\'\n'
+    );
+
+    const result = await readEnvFile('/some/path/.env');
+    expect(result).toEqual({
+      FOO: 'bar',
+      BAZ: 'qux',
+    });
+  });
+
+  it('should return empty object when file does not exist', async () => {
+    vi.mocked(fs.readFile).mockRejectedValue(new Error('ENOENT'));
+
+    const result = await readEnvFile('/nonexistent/.env');
+    expect(result).toEqual({});
+  });
+
+  it('should handle values containing equals signs', async () => {
+    vi.mocked(fs.readFile).mockResolvedValue(
+      'DATABASE_URL=postgresql://user:pass@host/db?sslmode=require\n'
+    );
+
+    const result = await readEnvFile('/some/.env');
+    expect(result.DATABASE_URL).toBe('postgresql://user:pass@host/db?sslmode=require');
+  });
+});
+
+describe('parseMigrationPrereqs', () => {
+  it('should extract extension names from migration comments', async () => {
+    vi.mocked(fs.readdir).mockResolvedValue(['001_initial.py'] as any);
+    vi.mocked(fs.readFile).mockResolvedValue(
+      '"""\nInitial migration.\n\n# popeye:requires_extension=vector\n"""\nfrom alembic import op\n'
+    );
+
+    const result = await parseMigrationPrereqs('/project/apps/backend/migrations');
+    expect(result).toEqual(['vector']);
+  });
+
+  it('should handle multiple extensions across multiple files', async () => {
+    vi.mocked(fs.readdir).mockResolvedValue(['001_initial.py', '002_search.py'] as any);
+    vi.mocked(fs.readFile)
+      .mockResolvedValueOnce('# popeye:requires_extension=vector\n')
+      .mockResolvedValueOnce('# popeye:requires_extension=pg_trgm\n');
+
+    const result = await parseMigrationPrereqs('/project/apps/backend/migrations');
+    expect(result).toEqual(['vector', 'pg_trgm']);
+  });
+
+  it('should not duplicate extension names', async () => {
+    vi.mocked(fs.readdir).mockResolvedValue(['001_initial.py', '002_more.py'] as any);
+    vi.mocked(fs.readFile)
+      .mockResolvedValueOnce('# popeye:requires_extension=vector\n')
+      .mockResolvedValueOnce('# popeye:requires_extension=vector\n');
+
+    const result = await parseMigrationPrereqs('/project/apps/backend/migrations');
+    expect(result).toEqual(['vector']);
+  });
+
+  it('should return empty array when no extensions required', async () => {
+    vi.mocked(fs.readdir).mockResolvedValue(['001_initial.py'] as any);
+    vi.mocked(fs.readFile).mockResolvedValue('from alembic import op\n');
+
+    const result = await parseMigrationPrereqs('/project/apps/backend/migrations');
+    expect(result).toEqual([]);
+  });
+
+  it('should return empty array when directory does not exist', async () => {
+    vi.mocked(fs.readdir).mockRejectedValue(new Error('ENOENT'));
+
+    const result = await parseMigrationPrereqs('/nonexistent/migrations');
+    expect(result).toEqual([]);
+  });
+
+  it('should skip non-.py files', async () => {
+    vi.mocked(fs.readdir).mockResolvedValue(['README.md', '001_initial.py'] as any);
+    vi.mocked(fs.readFile).mockResolvedValue('# popeye:requires_extension=vector\n');
+
+    const result = await parseMigrationPrereqs('/project/migrations');
+    // readFile called only once (for .py file, not .md)
+    expect(fs.readFile).toHaveBeenCalledTimes(1);
+    expect(result).toEqual(['vector']);
+  });
+});
+
+describe('getPackageName', () => {
+  it('should derive snake_case name from project state', async () => {
+    vi.mocked(fs.readFile).mockResolvedValue(
+      JSON.stringify({ name: 'my-cool-project' })
+    );
+
+    const result = await getPackageName('/project');
+    expect(result).toBe('my_cool_project');
+  });
+
+  it('should strip non-alphanumeric characters', async () => {
+    vi.mocked(fs.readFile).mockResolvedValue(
+      JSON.stringify({ name: 'My-Project!@#' })
+    );
+
+    const result = await getPackageName('/project');
+    expect(result).toBe('my_project');
+  });
+
+  it('should return "backend" as fallback when state is unreadable', async () => {
+    vi.mocked(fs.readFile).mockRejectedValue(new Error('ENOENT'));
+
+    const result = await getPackageName('/nonexistent');
+    expect(result).toBe('backend');
+  });
+});
+
+describe('resolveBackendDir', () => {
+  it('should return apps/backend path', () => {
+    expect(resolveBackendDir('/project')).toBe(path.join('/project', 'apps', 'backend'));
+  });
+});
+
+describe('computePostPipelineStatus', () => {
+  it('should transition configured -> applying -> ready on success', () => {
+    const result: SetupResult = {
+      success: true,
+      steps: [],
+      totalDurationMs: 100,
+      finalStatus: 'ready',
+    };
+    expect(computePostPipelineStatus('configured', result)).toBe('ready');
+  });
+
+  it('should transition configured -> applying -> error on failure', () => {
+    const result: SetupResult = {
+      success: false,
+      steps: [],
+      totalDurationMs: 50,
+      finalStatus: 'error',
+      error: 'Connection refused',
+    };
+    expect(computePostPipelineStatus('configured', result)).toBe('error');
+  });
+
+  it('should throw when starting from unconfigured', () => {
+    const result: SetupResult = {
+      success: true,
+      steps: [],
+      totalDurationMs: 0,
+      finalStatus: 'ready',
+    };
+    expect(() => computePostPipelineStatus('unconfigured', result)).toThrow(
+      /Invalid DB status transition/
+    );
+  });
+});

package/tests/workflow/db-state-machine.test.ts

@@ -0,0 +1,117 @@
+/**
+ * Tests for database lifecycle state machine
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  canTransition,
+  transitionDbStatus,
+  getAvailableTransitions,
+} from '../../src/workflow/db-state-machine.js';
+
+describe('canTransition', () => {
+  it('should allow unconfigured -> configured', () => {
+    expect(canTransition('unconfigured', 'configured')).toBe(true);
+  });
+
+  it('should allow configured -> applying', () => {
+    expect(canTransition('configured', 'applying')).toBe(true);
+  });
+
+  it('should allow configured -> unconfigured (reset)', () => {
+    expect(canTransition('configured', 'unconfigured')).toBe(true);
+  });
+
+  it('should allow applying -> ready', () => {
+    expect(canTransition('applying', 'ready')).toBe(true);
+  });
+
+  it('should allow applying -> error', () => {
+    expect(canTransition('applying', 'error')).toBe(true);
+  });
+
+  it('should allow ready -> configured (reconfigure)', () => {
+    expect(canTransition('ready', 'configured')).toBe(true);
+  });
+
+  it('should allow ready -> unconfigured (reset)', () => {
+    expect(canTransition('ready', 'unconfigured')).toBe(true);
+  });
+
+  it('should allow error -> configured (retry)', () => {
+    expect(canTransition('error', 'configured')).toBe(true);
+  });
+
+  it('should allow error -> unconfigured (reset)', () => {
+    expect(canTransition('error', 'unconfigured')).toBe(true);
+  });
+
+  it('should reject unconfigured -> ready (skip steps)', () => {
+    expect(canTransition('unconfigured', 'ready')).toBe(false);
+  });
+
+  it('should reject unconfigured -> applying (must configure first)', () => {
+    expect(canTransition('unconfigured', 'applying')).toBe(false);
+  });
+
+  it('should reject ready -> applying (must reconfigure first)', () => {
+    expect(canTransition('ready', 'applying')).toBe(false);
+  });
+
+  it('should reject error -> ready (must reconfigure and reapply)', () => {
+    expect(canTransition('error', 'ready')).toBe(false);
+  });
+
+  it('should reject self-transitions', () => {
+    expect(canTransition('unconfigured', 'unconfigured')).toBe(false);
+    expect(canTransition('ready', 'ready')).toBe(false);
+    expect(canTransition('error', 'error')).toBe(false);
+  });
+});
+
+describe('transitionDbStatus', () => {
+  it('should return the target status on valid transition', () => {
+    expect(transitionDbStatus('unconfigured', 'configured')).toBe('configured');
+    expect(transitionDbStatus('configured', 'applying')).toBe('applying');
+    expect(transitionDbStatus('applying', 'ready')).toBe('ready');
+  });
+
+  it('should throw on invalid transition', () => {
+    expect(() => transitionDbStatus('unconfigured', 'ready')).toThrow(
+      /Invalid DB status transition/
+    );
+  });
+
+  it('should include available transitions in error message', () => {
+    expect(() => transitionDbStatus('unconfigured', 'ready')).toThrow(
+      /configured/
+    );
+  });
+});
+
+describe('getAvailableTransitions', () => {
+  it('should return [configured] for unconfigured', () => {
+    const transitions = getAvailableTransitions('unconfigured');
+    expect(transitions).toEqual(['configured']);
+  });
+
+  it('should return [applying, unconfigured] for configured', () => {
+    const transitions = getAvailableTransitions('configured');
+    expect(transitions).toEqual(['applying', 'unconfigured']);
+  });
+
+  it('should return [ready, error] for applying', () => {
+    const transitions = getAvailableTransitions('applying');
+    expect(transitions).toEqual(['ready', 'error']);
+  });
+
+  it('should return [configured, unconfigured] for ready', () => {
+    const transitions = getAvailableTransitions('ready');
+    expect(transitions).toEqual(['configured', 'unconfigured']);
+  });
+
+  it('should return [configured, unconfigured] for error', () => {
+    const transitions = getAvailableTransitions('error');
+    expect(transitions).toEqual(['configured', 'unconfigured']);
+  });
+});