popeye-cli 1.4.7 → 1.6.0

package/tests/generators/website-pricing.test.ts

@@ -0,0 +1,98 @@
+/**
+ * Tests for website-pricing module
+ * Verifies pricing page generation with tiers, comparison table, and FAQ
+ */
+
+import { describe, it, expect } from 'vitest';
+import { generateWebsitePricingPage } from '../../src/generators/templates/website-pricing.js';
+import type { WebsiteContentContext } from '../../src/generators/website-context.js';
+
+function makeContext(): WebsiteContentContext {
+  return {
+    productName: 'Gateco',
+    features: [],
+    rawDocs: 'docs',
+    pricing: [
+      {
+        name: 'Free',
+        price: 'Free',
+        period: '',
+        description: 'Dev & POC',
+        features: ['Basic access', 'Community support'],
+        cta: 'Get started',
+        featured: false,
+      },
+      {
+        name: 'Pro',
+        price: '$99',
+        period: '/month',
+        description: 'Production workloads',
+        features: ['Basic access', 'Priority support', 'Advanced analytics'],
+        cta: 'Start free trial',
+        featured: true,
+      },
+      {
+        name: 'Enterprise',
+        price: 'Custom',
+        period: '',
+        description: 'Regulated environments',
+        features: ['Basic access', 'Priority support', 'Advanced analytics', 'SLA guarantee'],
+        cta: 'Contact sales',
+        featured: false,
+      },
+    ],
+  };
+}
+
+describe('generateWebsitePricingPage', () => {
+  it('generates page with tier cards', () => {
+    const code = generateWebsitePricingPage('gateco', makeContext());
+    expect(code).toContain('Free');
+    expect(code).toContain('$99');
+    expect(code).toContain('Custom');
+  });
+
+  it('includes monthly/annual toggle', () => {
+    const code = generateWebsitePricingPage('gateco', makeContext());
+    expect(code).toContain('Annual');
+    expect(code).toContain('Save 20%');
+    expect(code).toContain('useState(false)');
+  });
+
+  it('marks featured tier as Most Popular', () => {
+    const code = generateWebsitePricingPage('gateco', makeContext());
+    expect(code).toContain('Most Popular');
+  });
+
+  it('includes feature comparison table when tiers have features', () => {
+    const code = generateWebsitePricingPage('gateco', makeContext());
+    expect(code).toContain('Compare plans');
+    expect(code).toContain('Basic access');
+  });
+
+  it('includes pricing FAQ', () => {
+    const code = generateWebsitePricingPage('gateco', makeContext());
+    expect(code).toContain('Pricing FAQ');
+    expect(code).toContain('switch plans');
+    expect(code).toContain('free trial');
+  });
+
+  it('includes enterprise CTA section', () => {
+    const code = generateWebsitePricingPage('gateco', makeContext());
+    expect(code).toContain('custom plan');
+    expect(code).toContain('/contact');
+  });
+
+  it('renders single H1', () => {
+    const code = generateWebsitePricingPage('gateco', makeContext());
+    const h1Count = (code.match(/<h1/g) || []).length;
+    expect(h1Count).toBe(1);
+  });
+
+  it('generates defaults when no pricing provided', () => {
+    const code = generateWebsitePricingPage('gateco');
+    expect(code).toContain('Starter');
+    expect(code).toContain('Pro');
+    expect(code).toContain('Enterprise');
+  });
+});

package/tests/generators/website-sections.test.ts

@@ -0,0 +1,245 @@
+/**
+ * Tests for website-sections module
+ * Verifies FAQ, Stats (no fake numbers), HowItWorks, PainPoints
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  mapFeatureIcon,
+  isNumericMetric,
+  generatePainPointsSection,
+  generateDifferentiatorsSection,
+  generateHowItWorksSection,
+  generateStatsSection,
+  generateSocialProofSection,
+  generateFaqSection,
+  buildFaqItemsDeclaration,
+  generateFaqItemComponent,
+  generatePricingTeaserSection,
+} from '../../src/generators/templates/website-sections.js';
+import type { WebsiteStrategyDocument } from '../../src/types/website-strategy.js';
+
+function makeStrategy(overrides?: Partial<WebsiteStrategyDocument>): WebsiteStrategyDocument {
+  return {
+    icp: { primaryPersona: 'devs', painPoints: ['No ACL', 'Slow queries'], goals: [], objections: ['Is it secure?'] },
+    positioning: {
+      category: 'Security',
+      differentiators: ['Zero-trust', 'DB agnostic'],
+      valueProposition: 'Secure AI access',
+      proofPoints: ['SOC2 compliant', '10K+ queries/sec', '99.9% uptime'],
+    },
+    messaging: { headline: 'h', subheadline: 's', elevatorPitch: 'e', longDescription: 'l' },
+    seoStrategy: { primaryKeywords: [], secondaryKeywords: [], longTailKeywords: [], titleTemplates: {}, metaDescriptions: {} },
+    siteArchitecture: { pages: [{ path: '/', title: 'Home', purpose: '', pageType: 'landing', sections: ['Sign Up', 'Configure', 'Deploy'], seoKeywords: [], conversionGoal: '' }], navigation: [], footerSections: [] },
+    conversionStrategy: { primaryCta: { text: 'Go', href: '/' }, secondaryCta: { text: 'More', href: '/' }, trustSignals: [], socialProof: ['Great tool!'], leadCapture: 'none' },
+    competitiveContext: { category: 'sec', competitors: [], differentiators: [] },
+    ...overrides,
+  };
+}
+
+describe('mapFeatureIcon', () => {
+  it('maps security-related features to Shield icon', () => {
+    expect(mapFeatureIcon('Access Control')).toBe('Shield');
+    expect(mapFeatureIcon('Authentication')).toBe('Shield');
+  });
+
+  it('maps search features to Search icon', () => {
+    expect(mapFeatureIcon('Vector Search')).toBe('Search');
+  });
+
+  it('returns Star for unknown features', () => {
+    expect(mapFeatureIcon('Something Unique')).toBe('Star');
+  });
+});
+
+describe('isNumericMetric', () => {
+  it('detects numeric metrics', () => {
+    expect(isNumericMetric('10K+ queries/sec')).toBe(true);
+    expect(isNumericMetric('99.9% uptime')).toBe(true);
+    expect(isNumericMetric('500+ customers')).toBe(true);
+  });
+
+  it('rejects qualitative metrics', () => {
+    expect(isNumericMetric('SOC2 compliant')).toBe(false);
+    expect(isNumericMetric('Enterprise ready')).toBe(false);
+    expect(isNumericMetric('Audit-ready')).toBe(false);
+  });
+});
+
+describe('generatePainPointsSection', () => {
+  it('renders pain points from strategy', () => {
+    const { jsx, info } = generatePainPointsSection(makeStrategy());
+    expect(jsx).toContain('No ACL');
+    expect(jsx).toContain('Slow queries');
+    expect(info.dataSource).toBe('strategy');
+    expect(info.itemCount).toBe(2);
+  });
+
+  it('skips when no pain points', () => {
+    const strategy = makeStrategy({ icp: { primaryPersona: 'devs', painPoints: [], goals: [], objections: [] } });
+    const { jsx, info } = generatePainPointsSection(strategy);
+    expect(jsx).toBe('');
+    expect(info.dataSource).toBe('skipped');
+  });
+});
+
+describe('generateDifferentiatorsSection', () => {
+  it('renders differentiators with value proposition heading', () => {
+    const { jsx, info } = generateDifferentiatorsSection(makeStrategy());
+    expect(jsx).toContain('Secure AI access');
+    expect(jsx).toContain('Zero-trust');
+    expect(info.dataSource).toBe('strategy');
+  });
+
+  it('skips when no differentiators', () => {
+    const strategy = makeStrategy({
+      positioning: { category: 'x', differentiators: [], valueProposition: '', proofPoints: [] },
+    });
+    const { jsx, info } = generateDifferentiatorsSection(strategy);
+    expect(jsx).toBe('');
+    expect(info.dataSource).toBe('skipped');
+  });
+});
+
+describe('generateHowItWorksSection', () => {
+  it('renders with strategy sections', () => {
+    const { jsx, info } = generateHowItWorksSection(makeStrategy());
+    expect(jsx).toContain('How it works');
+    expect(info.dataSource).toBe('strategy');
+    expect(info.itemCount).toBe(3);
+  });
+
+  it('uses defaults when no strategy', () => {
+    const { jsx, info } = generateHowItWorksSection(undefined);
+    expect(jsx).toContain('Sign Up');
+    expect(jsx).toContain('Configure');
+    expect(jsx).toContain('Deploy');
+    expect(info.dataSource).toBe('defaults');
+  });
+});
+
+describe('generateStatsSection', () => {
+  it('renders numeric metrics as stats and qualitative as badges', () => {
+    const { jsx, info } = generateStatsSection(makeStrategy());
+
+    // Numeric: rendered as big stat
+    expect(jsx).toContain('10K+ queries/sec');
+    expect(jsx).toContain('99.9% uptime');
+
+    // Qualitative: rendered as badge
+    expect(jsx).toContain('SOC2 compliant');
+
+    expect(info.dataSource).toBe('strategy');
+    expect(info.itemCount).toBe(3);
+  });
+
+  it('does NOT fabricate numeric stats from qualitative data', () => {
+    const strategy = makeStrategy({
+      positioning: {
+        category: 'x',
+        differentiators: [],
+        valueProposition: '',
+        proofPoints: ['Audit-ready', 'HIPAA compliant'],
+      },
+    });
+    const { jsx } = generateStatsSection(strategy);
+
+    // Should NOT contain fabricated numbers
+    expect(jsx).not.toContain('10K+');
+    expect(jsx).not.toContain('99.9%');
+    // Should contain qualitative badges
+    expect(jsx).toContain('Audit-ready');
+    expect(jsx).toContain('HIPAA compliant');
+  });
+
+  it('skips when no proof points', () => {
+    const strategy = makeStrategy({
+      positioning: { category: 'x', differentiators: [], valueProposition: '', proofPoints: [] },
+    });
+    const { jsx, info } = generateStatsSection(strategy);
+    expect(jsx).toBe('');
+    expect(info.dataSource).toBe('skipped');
+  });
+});
+
+describe('generateSocialProofSection', () => {
+  it('renders social proof quotes', () => {
+    const { jsx, info } = generateSocialProofSection(makeStrategy());
+    expect(jsx).toContain('Great tool!');
+    expect(info.dataSource).toBe('strategy');
+  });
+
+  it('skips when empty', () => {
+    const strategy = makeStrategy({
+      conversionStrategy: {
+        primaryCta: { text: 'Go', href: '/' },
+        secondaryCta: { text: 'More', href: '/' },
+        trustSignals: [],
+        socialProof: [],
+        leadCapture: 'none',
+      },
+    });
+    const { jsx, info } = generateSocialProofSection(strategy);
+    expect(jsx).toBe('');
+    expect(info.dataSource).toBe('skipped');
+  });
+});
+
+describe('generateFaqSection', () => {
+  it('renders FAQ from objections', () => {
+    const { jsx, info, needsClientDirective } = generateFaqSection(makeStrategy());
+    // FAQ section JSX references faqItems via runtime mapping
+    expect(jsx).toContain('FaqItem');
+    expect(jsx).toContain('faqItems.map');
+    expect(info.dataSource).toBe('strategy');
+    expect(needsClientDirective).toBe(true);
+  });
+
+  it('builds FAQ items declaration with objection content', () => {
+    const decl = buildFaqItemsDeclaration(makeStrategy());
+    expect(decl).toContain('Is it secure?');
+    expect(decl).toContain('faqItems');
+  });
+
+  it('includes keyboard-accessible accordion in FaqItem component', () => {
+    const component = generateFaqItemComponent();
+    expect(component).toContain('aria-expanded');
+    expect(component).toContain('onClick');
+  });
+
+  it('skips when no objections', () => {
+    const strategy = makeStrategy({
+      icp: { primaryPersona: 'devs', painPoints: [], goals: [], objections: [] },
+    });
+    const { jsx, info } = generateFaqSection(strategy);
+    expect(jsx).toBe('');
+    expect(info.dataSource).toBe('skipped');
+  });
+});
+
+describe('generatePricingTeaserSection', () => {
+  it('renders teaser when pricing exists', () => {
+    const { jsx, info } = generatePricingTeaserSection({
+      productName: 'Test',
+      features: [],
+      rawDocs: '',
+      pricing: [
+        { name: 'Free', price: 'Free', description: 'Basic', features: [], cta: 'Start' },
+        { name: 'Pro', price: '$99', period: '/mo', description: 'Full', features: [], cta: 'Buy', featured: true },
+      ],
+    });
+    expect(jsx).toContain('$99');
+    expect(jsx).toContain('View full pricing');
+    expect(info.dataSource).toBe('docs');
+  });
+
+  it('skips when no pricing', () => {
+    const { jsx, info } = generatePricingTeaserSection({
+      productName: 'Test',
+      features: [],
+      rawDocs: '',
+    });
+    expect(jsx).toBe('');
+    expect(info.dataSource).toBe('skipped');
+  });
+});

package/tests/generators/website-seo-quality.test.ts

@@ -0,0 +1,246 @@
+/**
+ * SEO + accessibility quality gate tests
+ * Validates that generated website pages have proper SEO tags,
+ * heading hierarchy, JSON-LD, OpenGraph, and accessibility attributes
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  generateWebsiteLandingPage,
+  generateWebsiteLayout,
+  generateWebsitePricingPage,
+} from '../../src/generators/templates/website.js';
+import {
+  generateJsonLdComponent,
+  generateEnhancedSitemap,
+  generate404Page,
+  generate500Page,
+  generateWebManifest,
+  generateMetaHelper,
+} from '../../src/generators/templates/website-seo.js';
+import {
+  generateWebsiteHeader,
+  generateWebsiteFooter,
+} from '../../src/generators/templates/website-components.js';
+import type { WebsiteContentContext } from '../../src/generators/website-context.js';
+import type { WebsiteStrategyDocument } from '../../src/types/website-strategy.js';
+
+const mockStrategy: WebsiteStrategyDocument = {
+  icp: {
+    primaryPersona: 'Engineering managers at mid-size companies',
+    painPoints: ['Slow deployments', 'Poor visibility'],
+    goals: ['Ship faster', 'Better monitoring'],
+    objections: ['Learning curve', 'Migration cost'],
+  },
+  positioning: {
+    category: 'Developer Tools',
+    differentiators: ['AI-powered', 'Zero config'],
+    valueProposition: 'Deploy 10x faster with AI-powered CI/CD',
+    proofPoints: ['Used by 500+ teams'],
+  },
+  messaging: {
+    headline: 'Ship Code 10x Faster',
+    subheadline: 'AI-Powered CI/CD for Modern Teams',
+    elevatorPitch: 'Deploy with confidence using AI that learns your codebase.',
+    longDescription: 'An AI-powered CI/CD platform that analyzes your codebase and optimizes build pipelines automatically.',
+  },
+  seoStrategy: {
+    primaryKeywords: ['CI/CD', 'deployment automation', 'AI DevOps'],
+    secondaryKeywords: ['continuous integration', 'deployment pipeline'],
+    longTailKeywords: ['AI-powered CI/CD platform', 'automated deployment tool'],
+    titleTemplates: { home: 'Ship Code 10x Faster', pricing: 'Plans & Pricing' },
+    metaDescriptions: { home: 'AI-powered CI/CD platform', pricing: 'Simple, transparent pricing' },
+  },
+  siteArchitecture: {
+    pages: [
+      { path: '/', title: 'Home', purpose: 'conversion', pageType: 'landing', sections: ['hero', 'features'], seoKeywords: ['ci/cd'], conversionGoal: 'sign up' },
+      { path: '/pricing', title: 'Pricing', purpose: 'pricing', pageType: 'pricing', sections: ['tiers'], seoKeywords: ['pricing'], conversionGoal: 'start trial' },
+      { path: '/docs', title: 'Docs', purpose: 'education', pageType: 'docs', sections: ['getting-started'], seoKeywords: ['docs'], conversionGoal: 'adopt' },
+    ],
+    navigation: [
+      { label: 'Features', href: '/#features' },
+      { label: 'Pricing', href: '/pricing' },
+      { label: 'Docs', href: '/docs' },
+    ],
+    footerSections: [
+      { title: 'Product', links: [{ label: 'Features', href: '/#features' }] },
+      { title: 'Legal', links: [{ label: 'Privacy', href: '/privacy' }] },
+    ],
+  },
+  conversionStrategy: {
+    primaryCta: { text: 'Start Free Trial', href: '/pricing' },
+    secondaryCta: { text: 'Read Docs', href: '/docs' },
+    trustSignals: ['SOC 2 Compliant', 'GDPR Ready'],
+    socialProof: ['Used by 500+ engineering teams worldwide'],
+    leadCapture: 'webhook',
+  },
+  competitiveContext: {
+    category: 'CI/CD',
+    competitors: ['CircleCI', 'GitHub Actions'],
+    differentiators: ['AI-powered pipeline optimization'],
+  },
+};
+
+const mockContext: WebsiteContentContext = {
+  productName: 'DeployAI',
+  tagline: 'Ship Code 10x Faster',
+  description: 'An AI-powered CI/CD platform.',
+  features: [
+    { title: 'AI Optimization', description: 'Automatically optimize build pipelines' },
+    { title: 'Zero Config', description: 'Works out of the box' },
+    { title: 'Real-time Monitoring', description: 'Full observability' },
+  ],
+  brand: { primaryColor: '#2563EB' },
+  rawDocs: '',
+  strategy: mockStrategy,
+};
+
+describe('SEO Quality Gates', () => {
+  it('layout has title and description metadata', () => {
+    const layout = generateWebsiteLayout('deploy-ai', mockContext);
+    expect(layout).toContain('title:');
+    expect(layout).toContain('description:');
+    expect(layout).toContain('DeployAI');
+  });
+
+  it('landing page has exactly one H1 tag', () => {
+    const page = generateWebsiteLandingPage('deploy-ai', mockContext);
+    const h1Matches = page.match(/<h1[\s>]/g);
+    expect(h1Matches).toHaveLength(1);
+  });
+
+  it('landing page includes JSON-LD script via component', () => {
+    const page = generateWebsiteLandingPage('deploy-ai', mockContext);
+    expect(page).toContain('JsonLd');
+    expect(page).toContain('ORG_SCHEMA');
+    expect(page).toContain('PRODUCT_SCHEMA');
+  });
+
+  it('landing page includes OpenGraph meta via layout', () => {
+    const layout = generateWebsiteLayout('deploy-ai', mockContext);
+    expect(layout).toContain('openGraph');
+    expect(layout).toContain('twitter');
+  });
+
+  it('layout includes metadataBase for canonical URLs', () => {
+    const layout = generateWebsiteLayout('deploy-ai', mockContext);
+    expect(layout).toContain('metadataBase');
+    expect(layout).toContain('NEXT_PUBLIC_SITE_URL');
+  });
+
+  it('sitemap includes all strategy pages', () => {
+    const sitemap = generateEnhancedSitemap('deploy-ai', mockStrategy);
+    expect(sitemap).toContain('/pricing');
+    expect(sitemap).toContain('/docs');
+    // Landing page has empty path
+    expect(sitemap).toContain('baseUrl');
+  });
+
+  it('landing page uses strategy headline not generic text', () => {
+    const page = generateWebsiteLandingPage('deploy-ai', mockContext);
+    expect(page).toContain('Ship Code 10x Faster');
+    expect(page).not.toContain('Welcome to');
+  });
+
+  it('landing page includes trust signals when strategy provides them', () => {
+    const page = generateWebsiteLandingPage('deploy-ai', mockContext);
+    expect(page).toContain('SOC 2 Compliant');
+    expect(page).toContain('GDPR Ready');
+  });
+
+  it('landing page includes social proof when strategy provides it', () => {
+    const page = generateWebsiteLandingPage('deploy-ai', mockContext);
+    expect(page).toContain('500+ engineering teams');
+  });
+
+  it('pricing page has proper H1 tag', () => {
+    const page = generateWebsitePricingPage('deploy-ai', mockContext);
+    const h1Matches = page.match(/<h1[\s>]/g);
+    expect(h1Matches).toHaveLength(1);
+  });
+
+  it('pricing page includes enterprise CTA', () => {
+    const page = generateWebsitePricingPage('deploy-ai', mockContext);
+    expect(page).toContain('Need a custom plan');
+    expect(page).toContain('/contact');
+  });
+});
+
+describe('Accessibility Quality Gates', () => {
+  it('logo image has alt text in header', () => {
+    const contextWithLogo: WebsiteContentContext = {
+      ...mockContext,
+      brandAssets: {
+        logoPath: '/path/to/logo.svg',
+        logoOutputPath: 'public/brand/logo.svg',
+      },
+    };
+    const header = generateWebsiteHeader('deploy-ai', contextWithLogo, mockStrategy);
+    expect(header).toContain('alt="DeployAI"');
+  });
+
+  it('CTA buttons have accessible text', () => {
+    const page = generateWebsiteLandingPage('deploy-ai', mockContext);
+    expect(page).toContain('Start Free Trial');
+    expect(page).toContain('Read Docs');
+  });
+
+  it('heading hierarchy is sequential (no h1 -> h3 skip)', () => {
+    const page = generateWebsiteLandingPage('deploy-ai', mockContext);
+    // After h1, should use h2 (not h3)
+    const headings = [...page.matchAll(/<h(\d)/g)].map(m => parseInt(m[1], 10));
+    for (let i = 1; i < headings.length; i++) {
+      // Each heading should not skip more than 1 level
+      expect(headings[i] - headings[i - 1]).toBeLessThanOrEqual(1);
+    }
+  });
+
+  it('mobile menu button has aria-label', () => {
+    const header = generateWebsiteHeader('deploy-ai', mockContext, mockStrategy);
+    expect(header).toContain('aria-label');
+    expect(header).toContain('aria-expanded');
+  });
+
+  it('404 page has back-to-home link', () => {
+    const page = generate404Page('deploy-ai', mockContext);
+    expect(page).toContain('href="/"');
+    expect(page).toContain('DeployAI');
+  });
+
+  it('500 page has try-again action', () => {
+    const page = generate500Page('deploy-ai');
+    expect(page).toContain('reset()');
+    expect(page).toContain('Try again');
+  });
+});
+
+describe('SEO Component Quality', () => {
+  it('JsonLd component renders structured data', () => {
+    const component = generateJsonLdComponent();
+    expect(component).toContain('application/ld+json');
+    expect(component).toContain('dangerouslySetInnerHTML');
+  });
+
+  it('web manifest has correct structure', () => {
+    const manifest = generateWebManifest('deploy-ai', mockContext);
+    const parsed = JSON.parse(manifest);
+    expect(parsed.name).toBe('DeployAI');
+    expect(parsed.theme_color).toBe('#2563EB');
+    expect(parsed.icons).toHaveLength(3);
+    expect(parsed.display).toBe('standalone');
+  });
+
+  it('meta helper generates canonical URLs', () => {
+    const helper = generateMetaHelper('deploy-ai', mockStrategy);
+    expect(helper).toContain('canonical');
+    expect(helper).toContain('NEXT_PUBLIC_SITE_URL');
+    expect(helper).toContain('CI/CD');
+  });
+
+  it('footer includes all strategy sections', () => {
+    const footer = generateWebsiteFooter('deploy-ai', mockContext, mockStrategy);
+    expect(footer).toContain('Product');
+    expect(footer).toContain('Legal');
+    expect(footer).toContain('Privacy');
+  });
+});

package/tests/generators/workspace-root.test.ts

@@ -0,0 +1,105 @@
+/**
+ * Tests for workspace root detection
+ * Verifies .popeye/ detection, workspaces in package.json, and fallback behavior
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { resolveWorkspaceRoot, getScanDirectories } from '../../src/generators/workspace-root.js';
+
+describe('resolveWorkspaceRoot', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'popeye-ws-root-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('detects .popeye/ directory as workspace root', async () => {
+    // Create nested structure: tmpDir/project/.popeye/ with cwd = tmpDir/project/sub
+    const projectDir = path.join(tmpDir, 'project');
+    const subDir = path.join(projectDir, 'sub');
+    await fs.mkdir(path.join(projectDir, '.popeye'), { recursive: true });
+    await fs.mkdir(subDir, { recursive: true });
+
+    const root = await resolveWorkspaceRoot(subDir);
+
+    expect(root).toBe(projectDir);
+  });
+
+  it('detects package.json with workspaces field', async () => {
+    const projectDir = path.join(tmpDir, 'monorepo');
+    const subDir = path.join(projectDir, 'apps', 'website');
+    await fs.mkdir(subDir, { recursive: true });
+    await fs.writeFile(
+      path.join(projectDir, 'package.json'),
+      JSON.stringify({ name: 'root', workspaces: ['apps/*', 'packages/*'] })
+    );
+
+    const root = await resolveWorkspaceRoot(subDir);
+
+    expect(root).toBe(projectDir);
+  });
+
+  it('falls back to cwd when no workspace indicators found', async () => {
+    const cwd = path.join(tmpDir, 'standalone');
+    await fs.mkdir(cwd, { recursive: true });
+
+    const root = await resolveWorkspaceRoot(cwd);
+
+    expect(root).toBe(cwd);
+  });
+
+  it('detects turbo.json or pnpm-workspace.yaml', async () => {
+    const projectDir = path.join(tmpDir, 'turborepo');
+    const subDir = path.join(projectDir, 'apps', 'web');
+    await fs.mkdir(subDir, { recursive: true });
+    await fs.writeFile(path.join(projectDir, 'turbo.json'), '{}');
+
+    const root = await resolveWorkspaceRoot(subDir);
+
+    expect(root).toBe(projectDir);
+  });
+});
+
+describe('getScanDirectories', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'popeye-scan-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('includes workspace root, parent, and subdirectories', async () => {
+    const projectDir = path.join(tmpDir, 'project');
+    await fs.mkdir(path.join(projectDir, '.popeye'), { recursive: true });
+    await fs.mkdir(path.join(projectDir, 'docs'), { recursive: true });
+    await fs.mkdir(path.join(projectDir, 'brand'), { recursive: true });
+
+    const dirs = await getScanDirectories(projectDir);
+
+    expect(dirs).toContain(projectDir);
+    expect(dirs).toContain(tmpDir); // parent
+    expect(dirs).toContain(path.join(projectDir, 'docs'));
+    expect(dirs).toContain(path.join(projectDir, 'brand'));
+  });
+
+  it('deduplicates directories', async () => {
+    const projectDir = path.join(tmpDir, 'project');
+    await fs.mkdir(projectDir, { recursive: true });
+
+    const dirs = await getScanDirectories(projectDir);
+
+    // No duplicates
+    const unique = new Set(dirs);
+    expect(unique.size).toBe(dirs.length);
+  });
+});