@codeyam/codeyam-cli 0.1.29 → 0.1.31

package/codeyam-cli/src/utils/__tests__/editorRoadmap.test.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-import { readRoadmap, writeRoadmap, getDefaultRoadmap, sanitizeRoadmapData, checkAutoDetections, countJournalEntries, getRecentJournalEntries, } from "../editorRoadmap.js";
+import { readRoadmap, writeRoadmap, getDefaultRoadmap, sanitizeRoadmapData, checkAutoDetections, countJournalEntries, getRecentJournalEntries, generateServiceDeployTasks, } from "../editorRoadmap.js";
 let tmpDir;
 beforeEach(() => {
     tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'roadmap-test-'));
@@ -14,11 +14,16 @@ afterEach(() => {
 describe('getDefaultRoadmap', () => {
     it('returns plan and deploy arrays with predefined tasks', () => {
         const defaults = getDefaultRoadmap();
-        expect(defaults.plan.length).toBeGreaterThanOrEqual(5);
+        expect(defaults.plan.length).toBeGreaterThanOrEqual(3);
         expect(defaults.deploy.length).toBeGreaterThanOrEqual(5);
         expect(defaults.plan.every((t) => !t.completed)).toBe(true);
         expect(defaults.deploy.every((t) => !t.completed)).toBe(true);
     });
+    it('deploy-hosting has autoDetect key in defaults', () => {
+        const defaults = getDefaultRoadmap();
+        const hosting = defaults.deploy.find((t) => t.id === 'deploy-hosting');
+        expect(hosting?.autoDetect).toBe('hosting-configured');
+    });
     it('returns fresh copies on each call', () => {
         const a = getDefaultRoadmap();
         const b = getDefaultRoadmap();
@@ -112,6 +117,21 @@ describe('sanitizeRoadmapData', () => {
         expect(result.plan.length).toBeGreaterThan(0);
         expect(result.deploy.length).toBeGreaterThan(0);
     });
+    it('patches autoDetect onto existing deploy-hosting tasks from defaults', () => {
+        // Simulates an existing roadmap.json that was saved before autoDetect was added
+        const result = sanitizeRoadmapData({
+            plan: [],
+            deploy: [
+                {
+                    id: 'deploy-hosting',
+                    label: 'Set up hosting provider',
+                    completed: false,
+                },
+            ],
+        });
+        const hosting = result.deploy.find((t) => t.id === 'deploy-hosting');
+        expect(hosting?.autoDetect).toBe('hosting-configured');
+    });
 });
 // ── checkAutoDetections ─────────────────────────────────────────────────
 describe('checkAutoDetections', () => {
@@ -210,6 +230,87 @@ describe('checkAutoDetections', () => {
         expect(result[0].completed).toBe(false);
         expect(result[0].completedAt).toBeUndefined();
     });
+    it('marks hosting-configured when config has hosting.provider', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({ hosting: { provider: 'railway' } }));
+        const todos = [
+            {
+                id: 'deploy-hosting',
+                label: 'Set up hosting provider',
+                completed: false,
+                autoDetect: 'hosting-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(true);
+        expect(result[0].completedAt).toBeDefined();
+    });
+    it('does not mark hosting-configured when hosting.provider is missing', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({ hosting: {} }));
+        const todos = [
+            {
+                id: 'deploy-hosting',
+                label: 'Set up hosting provider',
+                completed: false,
+                autoDetect: 'hosting-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(false);
+    });
+    it('does not mark hosting-configured when no hosting field exists', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({}));
+        const todos = [
+            {
+                id: 'deploy-hosting',
+                label: 'Set up hosting provider',
+                completed: false,
+                autoDetect: 'hosting-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(false);
+    });
+    it('does not mark hosting-configured for vercel without projectId', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({ hosting: { provider: 'vercel' } }));
+        const todos = [
+            {
+                id: 'deploy-hosting',
+                label: 'Set up hosting provider',
+                completed: false,
+                autoDetect: 'hosting-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(false);
+    });
+    it('marks hosting-configured for vercel with projectId', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            hosting: { provider: 'vercel', vercelProjectId: 'prj_123' },
+        }));
+        const todos = [
+            {
+                id: 'deploy-hosting',
+                label: 'Set up hosting provider',
+                completed: false,
+                autoDetect: 'hosting-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(true);
+    });
+    it('marks hosting-configured for non-vercel providers with just provider name', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({ hosting: { provider: 'railway' } }));
+        const todos = [
+            {
+                id: 'deploy-hosting',
+                label: 'Set up hosting provider',
+                completed: false,
+                autoDetect: 'hosting-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(true);
+    });
     it('handles unknown autoDetect keys gracefully', () => {
         const todos = [
             {
@@ -377,6 +478,13 @@ describe('getRecentJournalEntries', () => {
             title: 'Add checkout page',
             time: '2026-03-30T10:00:00Z',
             type: 'feature',
+            description: 'Built the checkout flow',
+            userPrompt: undefined,
+            scenarioScreenshots: undefined,
+            modifiedFiles: undefined,
+            entityChangeStatus: undefined,
+            commitSha: 'abc123',
+            commitMessage: 'Add checkout page',
         });
     });
     it('defaults limit to 3', () => {
@@ -395,4 +503,606 @@ describe('getRecentJournalEntries', () => {
         expect(result).toHaveLength(3);
     });
 });
+// ── generateServiceDeployTasks ─────────────────────────────────────────
+describe('generateServiceDeployTasks', () => {
+    it('returns empty array when tech stack has no services with envKeys', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                languages: [{ name: 'TypeScript', url: '', description: '' }],
+                frameworks: [{ name: 'Next.js', url: '', description: '' }],
+                libraries: [{ name: 'Tailwind', url: '', description: '' }],
+            },
+        }));
+        const tasks = generateServiceDeployTasks(tmpDir);
+        expect(tasks).toEqual([]);
+    });
+    it('returns empty array when no tech stack exists', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({}));
+        const tasks = generateServiceDeployTasks(tmpDir);
+        expect(tasks).toEqual([]);
+    });
+    it('returns empty array when config.json does not exist', () => {
+        const tasks = generateServiceDeployTasks(tmpDir);
+        expect(tasks).toEqual([]);
+    });
+    it('generates tasks for databases with envKeys', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                databases: [
+                    {
+                        name: 'Neon',
+                        url: 'https://neon.tech',
+                        description: 'Serverless PostgreSQL',
+                        envKeys: ['DATABASE_URL', 'DIRECT_URL'],
+                    },
+                ],
+            },
+        }));
+        const tasks = generateServiceDeployTasks(tmpDir);
+        expect(tasks).toHaveLength(1);
+        expect(tasks[0].id).toBe('deploy-svc-neon');
+        expect(tasks[0].label).toBe('Set up Neon');
+        expect(tasks[0].autoDetect).toBe('svc-envkeys-neon');
+        expect(tasks[0].serviceRef).toEqual({
+            name: 'Neon',
+            category: 'databases',
+        });
+        expect(tasks[0].completed).toBe(false);
+    });
+    it('generates tasks for services with envKeys', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                services: [
+                    {
+                        name: 'Stripe',
+                        url: 'https://stripe.com',
+                        description: 'Payments',
+                        envKeys: ['STRIPE_SECRET_KEY', 'STRIPE_PUBLISHABLE_KEY'],
+                    },
+                ],
+            },
+        }));
+        const tasks = generateServiceDeployTasks(tmpDir);
+        expect(tasks).toHaveLength(1);
+        expect(tasks[0].id).toBe('deploy-svc-stripe');
+        expect(tasks[0].label).toBe('Set up Stripe');
+        expect(tasks[0].serviceRef).toEqual({
+            name: 'Stripe',
+            category: 'services',
+        });
+    });
+    it('generates tasks for infrastructure with envKeys', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                infrastructure: [
+                    {
+                        name: 'AWS S3',
+                        url: 'https://aws.amazon.com/s3',
+                        description: 'Object storage',
+                        envKeys: ['AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY'],
+                    },
+                ],
+            },
+        }));
+        const tasks = generateServiceDeployTasks(tmpDir);
+        expect(tasks).toHaveLength(1);
+        expect(tasks[0].id).toBe('deploy-svc-aws-s3');
+        expect(tasks[0].label).toBe('Set up AWS S3');
+    });
+    it('skips services with empty envKeys arrays', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                services: [
+                    {
+                        name: 'Stripe',
+                        url: '',
+                        description: '',
+                        envKeys: ['STRIPE_KEY'],
+                    },
+                    {
+                        name: 'SomeLib',
+                        url: '',
+                        description: '',
+                        envKeys: [],
+                    },
+                ],
+            },
+        }));
+        const tasks = generateServiceDeployTasks(tmpDir);
+        expect(tasks).toHaveLength(1);
+        expect(tasks[0].id).toBe('deploy-svc-stripe');
+    });
+    it('generates multiple tasks across categories', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                databases: [
+                    {
+                        name: 'PostgreSQL',
+                        url: '',
+                        description: '',
+                        envKeys: ['DATABASE_URL'],
+                    },
+                ],
+                services: [
+                    {
+                        name: 'Resend',
+                        url: '',
+                        description: '',
+                        envKeys: ['RESEND_API_KEY'],
+                    },
+                ],
+            },
+        }));
+        const tasks = generateServiceDeployTasks(tmpDir);
+        expect(tasks).toHaveLength(2);
+        const ids = tasks.map((t) => t.id);
+        expect(ids).toContain('deploy-svc-postgresql');
+        expect(ids).toContain('deploy-svc-resend');
+    });
+});
+// ── readRoadmap with dynamic service tasks ────────────────────────────
+describe('readRoadmap with dynamic service tasks', () => {
+    it('includes dynamic service tasks in deploy list', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                services: [
+                    {
+                        name: 'Stripe',
+                        url: '',
+                        description: '',
+                        envKeys: ['STRIPE_KEY'],
+                    },
+                ],
+            },
+        }));
+        const data = readRoadmap(tmpDir);
+        const stripeTask = data.deploy.find((t) => t.id === 'deploy-svc-stripe');
+        expect(stripeTask).toBeDefined();
+        expect(stripeTask.label).toBe('Set up Stripe');
+    });
+    it('inserts service tasks after deploy-hosting and before deploy-env-vars', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                services: [
+                    {
+                        name: 'Stripe',
+                        url: '',
+                        description: '',
+                        envKeys: ['STRIPE_KEY'],
+                    },
+                ],
+            },
+        }));
+        const data = readRoadmap(tmpDir);
+        const ids = data.deploy.map((t) => t.id);
+        const hostingIdx = ids.indexOf('deploy-hosting');
+        const envVarsIdx = ids.indexOf('deploy-env-vars');
+        const stripeIdx = ids.indexOf('deploy-svc-stripe');
+        expect(hostingIdx).toBeGreaterThanOrEqual(0);
+        expect(envVarsIdx).toBeGreaterThanOrEqual(0);
+        expect(stripeIdx).toBeGreaterThan(hostingIdx);
+        expect(stripeIdx).toBeLessThan(envVarsIdx);
+    });
+    it('preserves completion status of persisted service tasks', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                services: [
+                    {
+                        name: 'Stripe',
+                        url: '',
+                        description: '',
+                        envKeys: ['STRIPE_KEY'],
+                    },
+                ],
+            },
+        }));
+        // Write roadmap with stripe task already completed
+        const defaults = getDefaultRoadmap();
+        defaults.deploy.push({
+            id: 'deploy-svc-stripe',
+            label: 'Set up Stripe',
+            completed: true,
+            completedAt: '2026-03-30T00:00:00Z',
+            autoDetect: 'svc-envkeys-stripe',
+        });
+        writeRoadmap(tmpDir, defaults);
+        const data = readRoadmap(tmpDir);
+        const stripeTask = data.deploy.find((t) => t.id === 'deploy-svc-stripe');
+        expect(stripeTask).toBeDefined();
+        expect(stripeTask.completed).toBe(true);
+        expect(stripeTask.completedAt).toBe('2026-03-30T00:00:00Z');
+    });
+});
+// ── Dynamic service auto-detection ────────────────────────────────────
+describe('dynamic service auto-detection', () => {
+    it('marks service task complete when all envKeys are in environmentVariables', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                services: [
+                    {
+                        name: 'Stripe',
+                        url: '',
+                        description: '',
+                        envKeys: ['STRIPE_SECRET_KEY', 'STRIPE_PUBLISHABLE_KEY'],
+                    },
+                ],
+            },
+            environmentVariables: [
+                { key: 'STRIPE_SECRET_KEY', value: 'sk_test_123' },
+                { key: 'STRIPE_PUBLISHABLE_KEY', value: 'pk_test_456' },
+            ],
+        }));
+        const todos = [
+            {
+                id: 'deploy-svc-stripe',
+                label: 'Set up Stripe',
+                completed: false,
+                autoDetect: 'svc-envkeys-stripe',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(true);
+        expect(result[0].completedAt).toBeDefined();
+    });
+    it('does not mark service task complete when some envKeys are missing', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                services: [
+                    {
+                        name: 'Stripe',
+                        url: '',
+                        description: '',
+                        envKeys: ['STRIPE_SECRET_KEY', 'STRIPE_PUBLISHABLE_KEY'],
+                    },
+                ],
+            },
+            environmentVariables: [
+                { key: 'STRIPE_SECRET_KEY', value: 'sk_test_123' },
+            ],
+        }));
+        const todos = [
+            {
+                id: 'deploy-svc-stripe',
+                label: 'Set up Stripe',
+                completed: false,
+                autoDetect: 'svc-envkeys-stripe',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(false);
+    });
+    it('does not mark service task complete when envKey has empty value', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                services: [
+                    {
+                        name: 'Stripe',
+                        url: '',
+                        description: '',
+                        envKeys: ['STRIPE_KEY'],
+                    },
+                ],
+            },
+            environmentVariables: [{ key: 'STRIPE_KEY', value: '' }],
+        }));
+        const todos = [
+            {
+                id: 'deploy-svc-stripe',
+                label: 'Set up Stripe',
+                completed: false,
+                autoDetect: 'svc-envkeys-stripe',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(false);
+    });
+    it('handles "name" field in environmentVariables (legacy format)', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                services: [
+                    {
+                        name: 'Stripe',
+                        url: '',
+                        description: '',
+                        envKeys: ['STRIPE_KEY'],
+                    },
+                ],
+            },
+            environmentVariables: [{ name: 'STRIPE_KEY', value: 'sk_test_123' }],
+        }));
+        const todos = [
+            {
+                id: 'deploy-svc-stripe',
+                label: 'Set up Stripe',
+                completed: false,
+                autoDetect: 'svc-envkeys-stripe',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(true);
+    });
+    it('un-completes service task when envKeys are removed from config', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                services: [
+                    {
+                        name: 'Stripe',
+                        url: '',
+                        description: '',
+                        envKeys: ['STRIPE_KEY'],
+                    },
+                ],
+            },
+            environmentVariables: [],
+        }));
+        const todos = [
+            {
+                id: 'deploy-svc-stripe',
+                label: 'Set up Stripe',
+                completed: true,
+                completedAt: '2026-01-01',
+                autoDetect: 'svc-envkeys-stripe',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(false);
+        expect(result[0].completedAt).toBeUndefined();
+    });
+});
+// ── env-vars-configured auto-detection ────────────────────────────────
+describe('env-vars-configured auto-detection', () => {
+    it('marks deploy-env-vars complete when all service envKeys are configured', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                databases: [
+                    { name: 'Supabase', url: '', description: '', envKeys: ['DB_URL'] },
+                ],
+                services: [
+                    {
+                        name: 'Stripe',
+                        url: '',
+                        description: '',
+                        envKeys: ['STRIPE_KEY'],
+                    },
+                ],
+            },
+            environmentVariables: [
+                { key: 'DB_URL', value: 'postgresql://...' },
+                { key: 'STRIPE_KEY', value: 'sk_test_123' },
+            ],
+        }));
+        const todos = [
+            {
+                id: 'deploy-env-vars',
+                label: 'Configure environment variables',
+                completed: false,
+                autoDetect: 'env-vars-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(true);
+    });
+    it('does not mark deploy-env-vars complete when some envKeys are missing', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                services: [
+                    {
+                        name: 'Stripe',
+                        url: '',
+                        description: '',
+                        envKeys: ['STRIPE_SECRET', 'STRIPE_PUBLIC'],
+                    },
+                ],
+            },
+            environmentVariables: [{ key: 'STRIPE_SECRET', value: 'sk_test_123' }],
+        }));
+        const todos = [
+            {
+                id: 'deploy-env-vars',
+                label: 'Configure environment variables',
+                completed: false,
+                autoDetect: 'env-vars-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(false);
+    });
+    it('marks deploy-env-vars complete when no services have envKeys', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                languages: [{ name: 'TypeScript', url: '', description: '' }],
+            },
+        }));
+        const todos = [
+            {
+                id: 'deploy-env-vars',
+                label: 'Configure environment variables',
+                completed: false,
+                autoDetect: 'env-vars-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(true);
+    });
+});
+// ── deploy-database defaults and auto-detection ─────────────────────
+describe('deploy-database', () => {
+    it('deploy-database has autoDetect key in defaults', () => {
+        const defaults = getDefaultRoadmap();
+        const db = defaults.deploy.find((t) => t.id === 'deploy-database');
+        expect(db).toBeDefined();
+        expect(db.autoDetect).toBe('database-configured');
+        expect(db.label).toBe('Set up hosted database');
+    });
+    it('deploy-database appears after deploy-hosting in defaults', () => {
+        const defaults = getDefaultRoadmap();
+        const ids = defaults.deploy.map((t) => t.id);
+        const hostingIdx = ids.indexOf('deploy-hosting');
+        const dbIdx = ids.indexOf('deploy-database');
+        expect(dbIdx).toBe(hostingIdx + 1);
+    });
+    it('marks database-configured when Supabase provider with projectRef and all env vars', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            database: {
+                provider: 'supabase',
+                supabaseProjectRef: 'xyzref',
+            },
+            environmentVariables: [
+                {
+                    key: 'NEXT_PUBLIC_SUPABASE_URL',
+                    value: 'https://xyzref.supabase.co',
+                },
+                { key: 'NEXT_PUBLIC_SUPABASE_ANON_KEY', value: 'eyJ...' },
+                { key: 'DATABASE_URL', value: 'postgresql://...' },
+            ],
+        }));
+        const todos = [
+            {
+                id: 'deploy-database',
+                label: 'Set up hosted database',
+                completed: false,
+                autoDetect: 'database-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(true);
+        expect(result[0].completedAt).toBeDefined();
+    });
+    it('does not mark database-configured when provider is missing', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({}));
+        const todos = [
+            {
+                id: 'deploy-database',
+                label: 'Set up hosted database',
+                completed: false,
+                autoDetect: 'database-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(false);
+    });
+    it('does not mark database-configured for Supabase without projectRef', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            database: { provider: 'supabase' },
+            environmentVariables: [
+                { key: 'NEXT_PUBLIC_SUPABASE_URL', value: 'https://x.supabase.co' },
+                { key: 'NEXT_PUBLIC_SUPABASE_ANON_KEY', value: 'key' },
+                { key: 'DATABASE_URL', value: 'postgresql://...' },
+            ],
+        }));
+        const todos = [
+            {
+                id: 'deploy-database',
+                label: 'Set up hosted database',
+                completed: false,
+                autoDetect: 'database-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(false);
+    });
+    it('does not mark database-configured for Supabase with missing env vars', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            database: {
+                provider: 'supabase',
+                supabaseProjectRef: 'xyzref',
+            },
+            environmentVariables: [
+                {
+                    key: 'NEXT_PUBLIC_SUPABASE_URL',
+                    value: 'https://xyzref.supabase.co',
+                },
+                // Missing ANON_KEY and DATABASE_URL
+            ],
+        }));
+        const todos = [
+            {
+                id: 'deploy-database',
+                label: 'Set up hosted database',
+                completed: false,
+                autoDetect: 'database-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(false);
+    });
+});
+// ── service task insertion with deploy-database ─────────────────────
+describe('service tasks insert after deploy-database', () => {
+    it('inserts service tasks after deploy-database and before deploy-env-vars', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                services: [
+                    {
+                        name: 'Stripe',
+                        url: '',
+                        description: '',
+                        envKeys: ['STRIPE_KEY'],
+                    },
+                ],
+            },
+        }));
+        const data = readRoadmap(tmpDir);
+        const ids = data.deploy.map((t) => t.id);
+        const dbIdx = ids.indexOf('deploy-database');
+        const envVarsIdx = ids.indexOf('deploy-env-vars');
+        const stripeIdx = ids.indexOf('deploy-svc-stripe');
+        expect(dbIdx).toBeGreaterThanOrEqual(0);
+        expect(stripeIdx).toBeGreaterThan(dbIdx);
+        expect(stripeIdx).toBeLessThan(envVarsIdx);
+    });
+});
+// ── Supabase exclusion from dynamic service tasks ────────────────────
+describe('generateServiceDeployTasks Supabase exclusion', () => {
+    it('excludes Supabase from generated service tasks', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                databases: [
+                    {
+                        name: 'Supabase',
+                        url: 'https://supabase.com',
+                        description: 'Hosted PostgreSQL',
+                        envKeys: [
+                            'NEXT_PUBLIC_SUPABASE_URL',
+                            'NEXT_PUBLIC_SUPABASE_ANON_KEY',
+                            'DATABASE_URL',
+                        ],
+                    },
+                ],
+                services: [
+                    {
+                        name: 'Stripe',
+                        url: '',
+                        description: '',
+                        envKeys: ['STRIPE_KEY'],
+                    },
+                ],
+            },
+        }));
+        const tasks = generateServiceDeployTasks(tmpDir);
+        // Supabase should be excluded (handled by deploy-database), Stripe should remain
+        expect(tasks).toHaveLength(1);
+        expect(tasks[0].id).toBe('deploy-svc-stripe');
+    });
+});
+// ── sanitizeRoadmapData preserves serviceRef ──────────────────────────
+describe('sanitizeRoadmapData with serviceRef', () => {
+    it('preserves serviceRef field on tasks', () => {
+        const result = sanitizeRoadmapData({
+            plan: [],
+            deploy: [
+                {
+                    id: 'deploy-svc-stripe',
+                    label: 'Set up Stripe',
+                    completed: false,
+                    autoDetect: 'svc-envkeys-stripe',
+                    serviceRef: { name: 'Stripe', category: 'services' },
+                },
+            ],
+        });
+        const task = result.deploy.find((t) => t.id === 'deploy-svc-stripe');
+        expect(task).toBeDefined();
+        expect(task.serviceRef).toEqual({ name: 'Stripe', category: 'services' });
+    });
+});
 //# sourceMappingURL=editorRoadmap.test.js.map