@codeyam/codeyam-cli 0.1.0-staging.dbc742d → 0.1.0-staging.df25827

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

@@ -0,0 +1,1108 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { readRoadmap, writeRoadmap, getDefaultRoadmap, sanitizeRoadmapData, checkAutoDetections, countJournalEntries, getRecentJournalEntries, generateServiceDeployTasks, } from "../editorRoadmap.js";
+let tmpDir;
+beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'roadmap-test-'));
+    fs.mkdirSync(path.join(tmpDir, '.codeyam'), { recursive: true });
+});
+afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+// ── getDefaultRoadmap ───────────────────────────────────────────────────
+describe('getDefaultRoadmap', () => {
+    it('returns plan and deploy arrays with predefined tasks', () => {
+        const defaults = getDefaultRoadmap();
+        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();
+        a.plan[0].completed = true;
+        expect(b.plan[0].completed).toBe(false);
+    });
+});
+// ── readRoadmap / writeRoadmap ──────────────────────────────────────────
+describe('readRoadmap', () => {
+    it('returns defaults when file does not exist', () => {
+        const data = readRoadmap(tmpDir);
+        expect(data.plan.length).toBeGreaterThan(0);
+        expect(data.deploy.length).toBeGreaterThan(0);
+    });
+    it('reads back written data', () => {
+        const custom = getDefaultRoadmap();
+        custom.plan[0].completed = true;
+        custom.plan[0].completedAt = '2026-03-30T00:00:00Z';
+        writeRoadmap(tmpDir, custom);
+        const read = readRoadmap(tmpDir);
+        expect(read.plan[0].completed).toBe(true);
+        expect(read.plan[0].completedAt).toBe('2026-03-30T00:00:00Z');
+    });
+    it('returns defaults for malformed JSON', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'roadmap.json'), 'not json');
+        const data = readRoadmap(tmpDir);
+        expect(data.plan.length).toBeGreaterThan(0);
+    });
+});
+describe('writeRoadmap', () => {
+    it('creates .codeyam directory if missing', () => {
+        const freshDir = fs.mkdtempSync(path.join(os.tmpdir(), 'roadmap-fresh-'));
+        fs.mkdirSync(path.join(freshDir, '.codeyam'), { recursive: true });
+        writeRoadmap(freshDir, getDefaultRoadmap());
+        expect(fs.existsSync(path.join(freshDir, '.codeyam', 'roadmap.json'))).toBe(true);
+        fs.rmSync(freshDir, { recursive: true, force: true });
+    });
+});
+// ── sanitizeRoadmapData ─────────────────────────────────────────────────
+describe('sanitizeRoadmapData', () => {
+    it('returns defaults for null input', () => {
+        const result = sanitizeRoadmapData(null);
+        expect(result.plan.length).toBeGreaterThan(0);
+    });
+    it('returns defaults for non-object input', () => {
+        const result = sanitizeRoadmapData('hello');
+        expect(result.plan.length).toBeGreaterThan(0);
+    });
+    it('drops invalid entries from arrays', () => {
+        const result = sanitizeRoadmapData({
+            plan: [
+                { id: 'valid', label: 'Valid task', completed: false },
+                { noId: true },
+                null,
+                42,
+            ],
+            deploy: [],
+        });
+        // The custom valid entry is preserved; default tasks are merged in
+        expect(result.plan.find((t) => t.id === 'valid')).toBeDefined();
+        expect(result.plan.find((t) => t.id === 'valid').label).toBe('Valid task');
+    });
+    it('defaults completed to false when missing', () => {
+        const result = sanitizeRoadmapData({
+            plan: [{ id: 'a', label: 'A' }],
+            deploy: [],
+        });
+        expect(result.plan[0].completed).toBe(false);
+    });
+    it('preserves optional fields when valid', () => {
+        const result = sanitizeRoadmapData({
+            plan: [
+                {
+                    id: 'a',
+                    label: 'A',
+                    completed: true,
+                    completedAt: '2026-01-01',
+                    autoDetect: 'test-key',
+                    userCreated: true,
+                },
+            ],
+            deploy: [],
+        });
+        const task = result.plan.find((t) => t.id === 'a');
+        expect(task.completedAt).toBe('2026-01-01');
+        expect(task.autoDetect).toBe('test-key');
+        expect(task.userCreated).toBe(true);
+    });
+    it('uses defaults when plan/deploy are not arrays', () => {
+        const result = sanitizeRoadmapData({ plan: 'not array', deploy: 123 });
+        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', () => {
+    it('marks project-title-exists when config has projectTitle', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({ projectTitle: 'My App' }));
+        const todos = [
+            {
+                id: 'plan-project-name',
+                label: 'Define project name',
+                completed: false,
+                autoDetect: 'project-title-exists',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(true);
+        expect(result[0].completedAt).toBeDefined();
+    });
+    it('marks design-system-exists when file present', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'design-system.md'), '# Design');
+        const todos = [
+            {
+                id: 'plan-design-system',
+                label: 'Create design system',
+                completed: false,
+                autoDetect: 'design-system-exists',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(true);
+    });
+    it('does not mark design-system-exists when file missing', () => {
+        const todos = [
+            {
+                id: 'plan-design-system',
+                label: 'Create design system',
+                completed: false,
+                autoDetect: 'design-system-exists',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(false);
+    });
+    it('marks screen-sizes-configured when config has screen sizes', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            screenSizes: { Desktop: { width: 1280, height: 720 } },
+        }));
+        const todos = [
+            {
+                id: 'plan-screen-sizes',
+                label: 'Configure screen sizes',
+                completed: false,
+                autoDetect: 'screen-sizes-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(true);
+    });
+    it('marks scenarios-exist when editor-scenarios has JSON files', () => {
+        const scenariosDir = path.join(tmpDir, '.codeyam', 'editor-scenarios');
+        fs.mkdirSync(scenariosDir, { recursive: true });
+        fs.writeFileSync(path.join(scenariosDir, 'test.json'), '{}');
+        const todos = [
+            {
+                id: 'plan-initial-scenarios',
+                label: 'Create initial scenarios',
+                completed: false,
+                autoDetect: 'scenarios-exist',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(true);
+    });
+    it('leaves tasks without autoDetect unchanged', () => {
+        const todos = [
+            {
+                id: 'manual',
+                label: 'Manual task',
+                completed: false,
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(false);
+    });
+    it('un-completes auto-detect tasks when condition no longer met', () => {
+        const todos = [
+            {
+                id: 'plan-design-system',
+                label: 'Create design system',
+                completed: true,
+                completedAt: '2026-01-01',
+                autoDetect: 'design-system-exists',
+            },
+        ];
+        // No design-system.md file
+        const result = checkAutoDetections(tmpDir, todos);
+        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 = [
+            {
+                id: 'custom',
+                label: 'Custom',
+                completed: false,
+                autoDetect: 'unknown-checker',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(false);
+    });
+    it('marks tech-stack-configured when techStack has populated categories', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: {
+                languages: [{ name: 'TypeScript', version: '5' }],
+                frameworks: [{ name: 'Next.js', version: '15' }],
+            },
+        }));
+        const todos = [
+            {
+                id: 'plan-tech-stack',
+                label: 'Review tech stack',
+                completed: false,
+                autoDetect: 'tech-stack-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(true);
+    });
+    it('marks tech-stack-configured via webapps fallback', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            webapps: [{ path: '.', framework: 'Next' }],
+        }));
+        const todos = [
+            {
+                id: 'plan-tech-stack',
+                label: 'Review tech stack',
+                completed: false,
+                autoDetect: 'tech-stack-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(true);
+    });
+    it('does not mark tech-stack-configured when neither techStack nor webapps exist', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({}));
+        const todos = [
+            {
+                id: 'plan-tech-stack',
+                label: 'Review tech stack',
+                completed: false,
+                autoDetect: 'tech-stack-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(false);
+    });
+    it('does not mark tech-stack-configured for empty categories', () => {
+        fs.writeFileSync(path.join(tmpDir, '.codeyam', 'config.json'), JSON.stringify({
+            techStack: { languages: [], frameworks: [] },
+        }));
+        const todos = [
+            {
+                id: 'plan-tech-stack',
+                label: 'Review tech stack',
+                completed: false,
+                autoDetect: 'tech-stack-configured',
+            },
+        ];
+        const result = checkAutoDetections(tmpDir, todos);
+        expect(result[0].completed).toBe(false);
+    });
+});
+// ── countJournalEntries ─────────────────────────────────────────────────
+describe('countJournalEntries', () => {
+    it('returns 0 when journal does not exist', () => {
+        expect(countJournalEntries(tmpDir)).toBe(0);
+    });
+    it('counts entries from journal index', () => {
+        const journalDir = path.join(tmpDir, '.codeyam', 'journal');
+        fs.mkdirSync(journalDir, { recursive: true });
+        fs.writeFileSync(path.join(journalDir, 'index.json'), JSON.stringify({
+            entries: [
+                { date: '2026-03-29', time: '10:00', title: 'Entry 1' },
+                { date: '2026-03-30', time: '11:00', title: 'Entry 2' },
+                { date: '2026-03-30', time: '12:00', title: 'Entry 3' },
+            ],
+        }));
+        expect(countJournalEntries(tmpDir)).toBe(3);
+    });
+    it('returns 0 for malformed journal', () => {
+        const journalDir = path.join(tmpDir, '.codeyam', 'journal');
+        fs.mkdirSync(journalDir, { recursive: true });
+        fs.writeFileSync(path.join(journalDir, 'index.json'), 'not json');
+        expect(countJournalEntries(tmpDir)).toBe(0);
+    });
+});
+// ── getRecentJournalEntries ─────────────────────────────────────────────
+describe('getRecentJournalEntries', () => {
+    it('returns empty array when journal does not exist', () => {
+        expect(getRecentJournalEntries(tmpDir)).toEqual([]);
+    });
+    it('returns the 3 most recent entries (newest first)', () => {
+        const journalDir = path.join(tmpDir, '.codeyam', 'journal');
+        fs.mkdirSync(journalDir, { recursive: true });
+        fs.writeFileSync(path.join(journalDir, 'index.json'), JSON.stringify({
+            entries: [
+                { date: '2026-03-28', time: '2026-03-28T09:00:00Z', title: 'First' },
+                { date: '2026-03-29', time: '2026-03-29T10:00:00Z', title: 'Second' },
+                { date: '2026-03-29', time: '2026-03-29T14:00:00Z', title: 'Third' },
+                { date: '2026-03-30', time: '2026-03-30T11:00:00Z', title: 'Fourth' },
+                { date: '2026-03-30', time: '2026-03-30T15:00:00Z', title: 'Fifth' },
+            ],
+        }));
+        const result = getRecentJournalEntries(tmpDir, 3);
+        expect(result).toHaveLength(3);
+        // Newest first
+        expect(result[0].title).toBe('Fifth');
+        expect(result[1].title).toBe('Fourth');
+        expect(result[2].title).toBe('Third');
+    });
+    it('returns all entries when fewer than limit', () => {
+        const journalDir = path.join(tmpDir, '.codeyam', 'journal');
+        fs.mkdirSync(journalDir, { recursive: true });
+        fs.writeFileSync(path.join(journalDir, 'index.json'), JSON.stringify({
+            entries: [
+                {
+                    date: '2026-03-30',
+                    time: '2026-03-30T10:00:00Z',
+                    title: 'Only one',
+                },
+            ],
+        }));
+        const result = getRecentJournalEntries(tmpDir, 3);
+        expect(result).toHaveLength(1);
+        expect(result[0].title).toBe('Only one');
+    });
+    it('returns empty array for malformed journal', () => {
+        const journalDir = path.join(tmpDir, '.codeyam', 'journal');
+        fs.mkdirSync(journalDir, { recursive: true });
+        fs.writeFileSync(path.join(journalDir, 'index.json'), 'not json');
+        expect(getRecentJournalEntries(tmpDir)).toEqual([]);
+    });
+    it('includes title, time, and type fields in returned entries', () => {
+        const journalDir = path.join(tmpDir, '.codeyam', 'journal');
+        fs.mkdirSync(journalDir, { recursive: true });
+        fs.writeFileSync(path.join(journalDir, 'index.json'), JSON.stringify({
+            entries: [
+                {
+                    date: '2026-03-30',
+                    time: '2026-03-30T10:00:00Z',
+                    title: 'Add checkout page',
+                    type: 'feature',
+                    description: 'Built the checkout flow',
+                    scenarios: [],
+                    screenshot: null,
+                    commitSha: 'abc123',
+                    commitMessage: 'Add checkout page',
+                },
+            ],
+        }));
+        const result = getRecentJournalEntries(tmpDir, 3);
+        expect(result[0]).toEqual({
+            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', () => {
+        const journalDir = path.join(tmpDir, '.codeyam', 'journal');
+        fs.mkdirSync(journalDir, { recursive: true });
+        fs.writeFileSync(path.join(journalDir, 'index.json'), JSON.stringify({
+            entries: [
+                { date: '2026-03-28', time: '2026-03-28T09:00:00Z', title: 'A' },
+                { date: '2026-03-29', time: '2026-03-29T10:00:00Z', title: 'B' },
+                { date: '2026-03-29', time: '2026-03-29T14:00:00Z', title: 'C' },
+                { date: '2026-03-30', time: '2026-03-30T11:00:00Z', title: 'D' },
+                { date: '2026-03-30', time: '2026-03-30T15:00:00Z', title: 'E' },
+            ],
+        }));
+        const result = getRecentJournalEntries(tmpDir);
+        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