popeye-cli 1.4.7 → 1.6.0

package/tests/cli/project-naming.test.ts

@@ -0,0 +1,136 @@
+/**
+ * Tests for project naming logic
+ * Verifies CWD-aware naming, doc-derived names, 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 {
+  generateProjectName,
+  generateProjectNameFromIdea,
+  extractNameFromDocs,
+} from '../../src/cli/interactive.js';
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'popeye-naming-'));
+});
+
+afterEach(async () => {
+  await fs.rm(tmpDir, { recursive: true, force: true });
+});
+
+describe('generateProjectNameFromIdea', () => {
+  it('should extract explicit project name patterns', () => {
+    // "named" pattern extracts the word after it
+    expect(generateProjectNameFromIdea("Create an app named 'Gateco'")).toBe('gateco');
+    // "called" pattern extracts the word after it
+    expect(generateProjectNameFromIdea('Build something called TodoApp')).toBe('todo-app');
+  });
+
+  it('should extract CamelCase project names', () => {
+    // Without "for" keyword that triggers the explicit pattern, CamelCase is detected
+    expect(generateProjectNameFromIdea('Build TodoMaster with style')).toBe('todo-master');
+  });
+
+  it('should filter out action words from prompt text', () => {
+    // "read all files" should NOT produce "read-all-files" since those are stop words
+    const result = generateProjectNameFromIdea('read all files');
+    expect(result).not.toBe('read-all-files');
+    // Meaningful word extraction filters all three, but the fallback takes first 2 raw words
+    expect(result).toBe('read-all');
+  });
+
+  it('should extract meaningful words when no explicit name found', () => {
+    const result = generateProjectNameFromIdea('secure enterprise authentication system');
+    expect(result).toBe('secure-enterprise-authentication');
+  });
+
+  it('should return my-project as last resort', () => {
+    expect(generateProjectNameFromIdea('')).toBe('my-project');
+  });
+});
+
+describe('extractNameFromDocs', () => {
+  it('should extract product name from markdown heading', async () => {
+    const docPath = path.join(tmpDir, 'Gateco-spec.md');
+    await fs.writeFile(docPath, '# Gateco\n\nSome description here.');
+
+    const name = await extractNameFromDocs(tmpDir);
+    expect(name).toBe('Gateco');
+  });
+
+  it('should skip README files', async () => {
+    await fs.writeFile(path.join(tmpDir, 'README.md'), '# MyProject\n\nDescription.');
+
+    const name = await extractNameFromDocs(tmpDir);
+    expect(name).toBeNull();
+  });
+
+  it('should return null when no docs found', async () => {
+    const name = await extractNameFromDocs(tmpDir);
+    expect(name).toBeNull();
+  });
+
+  it('should return null for non-existent directory', async () => {
+    const name = await extractNameFromDocs('/nonexistent/path/123456');
+    expect(name).toBeNull();
+  });
+
+  it('should ignore generic headings', async () => {
+    // "Home" is too short, but length >= 3 so it would pass... let's test with a generic dir name
+    await fs.writeFile(path.join(tmpDir, 'spec.md'), '# Src\n\nDescription.');
+
+    const name = await extractNameFromDocs(tmpDir);
+    // "Src" is in GENERIC_DIR_NAMES
+    expect(name).toBeNull();
+  });
+});
+
+describe('generateProjectName (CWD-aware)', () => {
+  it('should prefer doc-derived name over CWD basename', async () => {
+    const projectDir = path.join(tmpDir, 'SomeDir');
+    await fs.mkdir(projectDir, { recursive: true });
+    await fs.writeFile(
+      path.join(projectDir, 'product-spec.md'),
+      '# Gateco\n\nA security layer for AI.'
+    );
+
+    const name = await generateProjectName('read all files', projectDir);
+    expect(name).toBe('gateco');
+  });
+
+  it('should use CWD basename when no docs found', async () => {
+    const projectDir = path.join(tmpDir, 'MyAwesomeApp');
+    await fs.mkdir(projectDir, { recursive: true });
+
+    const name = await generateProjectName('read all files', projectDir);
+    expect(name).toBe('my-awesome-app');
+  });
+
+  it('should skip generic CWD names and fall back to idea', async () => {
+    const projectDir = path.join(tmpDir, 'Projects');
+    await fs.mkdir(projectDir, { recursive: true });
+
+    // "Projects" is a generic dir name, so falls back to idea extraction
+    // The idea contains "named SuperApp" pattern -> extracts "SuperApp"
+    const name = await generateProjectName('Build an app named SuperApp', projectDir);
+    expect(name).toBe('super-app');
+  });
+
+  it('should fall back to idea extraction when no CWD provided', async () => {
+    const name = await generateProjectName('Build an app called Gateco');
+    expect(name).toBe('gateco');
+  });
+
+  it('should handle CamelCase CWD basenames', async () => {
+    const projectDir = path.join(tmpDir, 'MyGateco');
+    await fs.mkdir(projectDir, { recursive: true });
+
+    const name = await generateProjectName('some idea', projectDir);
+    expect(name).toBe('my-gateco');
+  });
+});

package/tests/generators/doc-parser.test.ts

@@ -0,0 +1,121 @@
+/**
+ * Tests for doc-parser module
+ * Verifies feature extraction, dev-task filtering, docs-first priority
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  extractFeatures,
+  extractProductName,
+  extractTagline,
+  extractDescription,
+  extractPrimaryColor,
+  extractPricing,
+  isSuspiciousProductName,
+} from '../../src/generators/doc-parser.js';
+
+describe('extractFeatures', () => {
+  it('extracts features from docs bullet list', () => {
+    const docs = `# Product\n## Features\n- **Fast Search** - Lightning fast search\n- **Auth** - Built-in authentication`;
+    const features = extractFeatures(docs);
+    expect(features.length).toBeGreaterThanOrEqual(2);
+    expect(features[0].title).toBe('Fast Search');
+  });
+
+  it('extracts from docs before specification', () => {
+    const docs = `# Product\n## Features\n- **Real Feature** - From docs`;
+    const spec = `## Features\n- Implement login page\n- Fix CSS bug`;
+    const features = extractFeatures(docs, spec);
+    // Should use docs features, not spec dev tasks
+    expect(features[0].title).toBe('Real Feature');
+  });
+
+  it('falls back to specification when docs have no features', () => {
+    const docs = `# Product\n## About\nJust a description.`;
+    const spec = `## Core Design Principles\n1. **Vector DB agnostic**\n2. **Embedding agnostic**`;
+    const features = extractFeatures(docs, spec);
+    expect(features.length).toBeGreaterThanOrEqual(2);
+    expect(features[0].title).toContain('Vector DB');
+  });
+
+  it('filters out dev-task verbs', () => {
+    const docs = `# Tasks\n## Features\n- Implement user auth\n- Fix broken login\n- **Real Feature** - Does real stuff\n- Refactor database layer`;
+    const features = extractFeatures(docs);
+    // Dev tasks should be filtered out
+    expect(features.some(f => f.title.startsWith('Implement'))).toBe(false);
+    expect(features.some(f => f.title.startsWith('Fix'))).toBe(false);
+    expect(features.some(f => f.title.startsWith('Refactor'))).toBe(false);
+    // Real feature should remain
+    expect(features.some(f => f.title === 'Real Feature')).toBe(true);
+  });
+
+  it('returns empty when no feature sections exist', () => {
+    const docs = `# README\nJust a readme file.`;
+    const features = extractFeatures(docs);
+    expect(features).toEqual([]);
+  });
+
+  it('limits features to 6', () => {
+    const items = Array.from({ length: 10 }, (_, i) => `- **Feature ${i + 1}** - Description ${i + 1}`).join('\n');
+    const docs = `## Features\n${items}`;
+    const features = extractFeatures(docs);
+    expect(features.length).toBeLessThanOrEqual(6);
+  });
+});
+
+describe('extractProductName', () => {
+  it('extracts from "# Name -- tagline" heading', () => {
+    const docs = '# Gateco -- Permission-Aware Retrieval';
+    expect(extractProductName(docs)).toBe('Gateco');
+  });
+
+  it('picks shortest name when multiple headings', () => {
+    const docs = '# Gateco -- main product\n# Gateco UI Color System -- colors';
+    expect(extractProductName(docs)).toBe('Gateco');
+  });
+
+  it('returns undefined when no match', () => {
+    expect(extractProductName('Just some text')).toBeUndefined();
+  });
+});
+
+describe('extractPrimaryColor', () => {
+  it('extracts accent-primary token', () => {
+    const docs = '| `accent-primary` | `#2563EB` | Primary CTA |';
+    expect(extractPrimaryColor(docs)).toBe('#2563EB');
+  });
+
+  it('skips dark background colors', () => {
+    const docs = '| bg | #0F172A |\n| accent-primary | #2563EB |';
+    expect(extractPrimaryColor(docs)).toBe('#2563EB');
+  });
+});
+
+describe('isSuspiciousProductName', () => {
+  it('flags directory-like names', () => {
+    expect(isSuspiciousProductName('my-cool-project')).toBe(true);
+    expect(isSuspiciousProductName('my-app')).toBe(true);
+  });
+
+  it('allows real product names', () => {
+    expect(isSuspiciousProductName('Gateco')).toBe(false);
+    expect(isSuspiciousProductName('SuperApp')).toBe(false);
+  });
+});
+
+describe('extractPricing', () => {
+  it('extracts pricing tiers from markdown table', () => {
+    const docs = `## Pricing\n| Plan | Price |\n|---|---|\n| Free | Free |\n| Pro | $99/month minimum |\n| Enterprise | Custom pricing |`;
+    const tiers = extractPricing(docs);
+    expect(tiers).toBeDefined();
+    expect(tiers!.length).toBe(3);
+    expect(tiers![0].name).toContain('Free');
+    expect(tiers![1].price).toBe('$99');
+    expect(tiers![2].price).toBe('Custom');
+  });
+
+  it('returns undefined when no pricing found', () => {
+    const docs = '# Product\nJust a product.';
+    expect(extractPricing(docs)).toBeUndefined();
+  });
+});

package/tests/generators/frontend-design-analyzer.test.ts

@@ -0,0 +1,90 @@
+/**
+ * Tests for frontend design language analyzer
+ * Verifies CSS variable extraction, component library detection, and tailwind parsing
+ */
+
+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 { analyzeFrontendDesign } from '../../src/generators/frontend-design-analyzer.js';
+
+describe('analyzeFrontendDesign', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'popeye-fe-design-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns null when no frontend app directory exists', async () => {
+    const result = await analyzeFrontendDesign(tmpDir);
+
+    expect(result).toBeNull();
+  });
+
+  it('extracts CSS custom properties from index.css', async () => {
+    const frontendDir = path.join(tmpDir, 'apps', 'frontend', 'src');
+    await fs.mkdir(frontendDir, { recursive: true });
+    await fs.writeFile(
+      path.join(frontendDir, 'index.css'),
+      `:root {
+  --primary: 222.2 47.4% 11.2%;
+  --radius: 0.5rem;
+}
+
+.dark {
+  --primary: 210 40% 98%;
+}
+`
+    );
+    // Need package.json for component lib detection
+    await fs.writeFile(
+      path.join(tmpDir, 'apps', 'frontend', 'package.json'),
+      JSON.stringify({ dependencies: { '@shadcn/ui': '^1.0.0' } })
+    );
+
+    const result = await analyzeFrontendDesign(tmpDir);
+
+    expect(result).not.toBeNull();
+    expect(result!.primaryColor).toBeDefined();
+    expect(result!.borderRadius).toBe('0.5rem');
+    expect(result!.darkMode).toBe(true);
+    expect(result!.source).toBe('css-variables');
+  });
+
+  it('detects shadcn component library from package.json', async () => {
+    const frontendDir = path.join(tmpDir, 'apps', 'frontend');
+    await fs.mkdir(frontendDir, { recursive: true });
+    await fs.writeFile(
+      path.join(frontendDir, 'package.json'),
+      JSON.stringify({
+        dependencies: { '@shadcn/ui': '^1.0.0', react: '^18.0.0' },
+      })
+    );
+
+    const result = await analyzeFrontendDesign(tmpDir);
+
+    expect(result).not.toBeNull();
+    expect(result!.componentLibrary).toBe('shadcn');
+  });
+
+  it('detects MUI component library', async () => {
+    const frontendDir = path.join(tmpDir, 'apps', 'frontend');
+    await fs.mkdir(frontendDir, { recursive: true });
+    await fs.writeFile(
+      path.join(frontendDir, 'package.json'),
+      JSON.stringify({
+        dependencies: { '@mui/material': '^5.0.0', react: '^18.0.0' },
+      })
+    );
+
+    const result = await analyzeFrontendDesign(tmpDir);
+
+    expect(result).not.toBeNull();
+    expect(result!.componentLibrary).toBe('mui');
+  });
+});

package/tests/generators/quality-gate.test.ts

@@ -0,0 +1,183 @@
+/**
+ * Tests for website content quality gate
+ * Verifies that validateWebsiteContextOrThrow blocks generic websites
+ * and validateWebsiteContext returns structured soft validation results
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  validateWebsiteContextOrThrow,
+  validateWebsiteContext,
+} from '../../src/generators/website-context.js';
+import type { WebsiteContentContext } from '../../src/generators/website-context.js';
+
+function makeContext(overrides: Partial<WebsiteContentContext> = {}): WebsiteContentContext {
+  return {
+    productName: 'Gateco',
+    features: [
+      { title: 'Access Control', description: 'Fine-grained permissions' },
+      { title: 'Vector DB Agnostic', description: 'Works with any vector database' },
+    ],
+    rawDocs: '--- spec.md ---\n# Gateco\nLong enough content to pass validation threshold.\n' + 'x'.repeat(100),
+    strategy: {
+      icp: { primaryPersona: 'devs', painPoints: [], goals: [], objections: [] },
+      positioning: { category: 'Security', differentiators: [], valueProposition: 'Secure AI', proofPoints: [] },
+      messaging: { headline: 'h', subheadline: 's', elevatorPitch: 'e', longDescription: 'l' },
+      seoStrategy: { primaryKeywords: [], secondaryKeywords: [], longTailKeywords: [], titleTemplates: {}, metaDescriptions: {} },
+      siteArchitecture: { pages: [], navigation: [], footerSections: [] },
+      conversionStrategy: { primaryCta: { text: 'Go', href: '/' }, secondaryCta: { text: 'More', href: '/' }, trustSignals: [], socialProof: [], leadCapture: 'none' },
+      competitiveContext: { category: 'sec', competitors: [], differentiators: [] },
+    },
+    ...overrides,
+  };
+}
+
+describe('validateWebsiteContextOrThrow', () => {
+  it('passes validation with valid product context', () => {
+    const context = makeContext();
+
+    expect(() => validateWebsiteContextOrThrow(context, 'gateco')).not.toThrow();
+  });
+
+  it('throws on suspicious product name (directory-like)', () => {
+    const context = makeContext({ productName: 'read-all-files' });
+
+    expect(() => validateWebsiteContextOrThrow(context, 'read-all-files')).toThrow(
+      /looks like a directory name/
+    );
+  });
+
+  it('throws when no docs found', () => {
+    const context = makeContext({ rawDocs: '' });
+
+    expect(() => validateWebsiteContextOrThrow(context, 'test')).toThrow(
+      /No project documentation found/
+    );
+  });
+
+  it('throws when no features extracted', () => {
+    const context = makeContext({ features: [] });
+
+    expect(() => validateWebsiteContextOrThrow(context, 'test')).toThrow(
+      /No product features extracted/
+    );
+  });
+
+  it('includes POPEYE_DEBUG_WEBSITE hint in error message', () => {
+    const context = makeContext({ rawDocs: '' });
+
+    try {
+      validateWebsiteContextOrThrow(context, 'test');
+      expect.fail('Should have thrown');
+    } catch (error) {
+      expect((error as Error).message).toContain('POPEYE_DEBUG_WEBSITE=1');
+    }
+  });
+
+  it('still throws when passed is false from validateWebsiteContext', () => {
+    // Context with multiple blocking issues
+    const context = makeContext({
+      productName: 'my-app',
+      rawDocs: '',
+      features: [],
+      strategy: undefined,
+    });
+
+    expect(() => validateWebsiteContextOrThrow(context, 'my-app')).toThrow(
+      /Website generation blocked/
+    );
+  });
+});
+
+describe('validateWebsiteContext (soft mode)', () => {
+  it('returns passed=true with no issues for valid context', () => {
+    const context = makeContext({ tagline: 'Secure your AI' });
+    const result = validateWebsiteContext(context, 'gateco');
+
+    expect(result.passed).toBe(true);
+    expect(result.issues).toHaveLength(0);
+    expect(result.contentScore).toBeGreaterThanOrEqual(90);
+  });
+
+  it('returns warnings without marking passed=false', () => {
+    // Valid context but missing tagline triggers a warning, not an issue
+    const context = makeContext({ tagline: undefined });
+    const result = validateWebsiteContext(context, 'gateco');
+
+    expect(result.passed).toBe(true);
+    expect(result.warnings.length).toBeGreaterThan(0);
+    expect(result.warnings.some((w) => /tagline/i.test(w))).toBe(true);
+  });
+
+  it('detects default pricing fingerprint as a warning', () => {
+    const context = makeContext({
+      pricing: [
+        { name: 'Free', price: '$0', description: 'Basic', features: ['1 user'], cta: 'Start' },
+        { name: 'Pro', price: '$29', description: 'Team', features: ['10 users'], cta: 'Go', featured: true },
+        { name: 'Enterprise', price: 'Custom', description: 'Scale', features: ['Unlimited'], cta: 'Contact' },
+      ],
+    });
+    const result = validateWebsiteContext(context, 'gateco');
+
+    expect(result.passed).toBe(true);
+    expect(result.warnings.some((w) => /default values/i.test(w))).toBe(true);
+  });
+
+  it('does not flag custom pricing as default', () => {
+    const context = makeContext({
+      pricing: [
+        { name: 'Hobby', price: '$9', description: 'For side projects', features: ['5 APIs'], cta: 'Start' },
+        { name: 'Team', price: '$49', description: 'For teams', features: ['50 APIs'], cta: 'Go' },
+      ],
+    });
+    const result = validateWebsiteContext(context, 'gateco');
+
+    expect(result.warnings.some((w) => /default values/i.test(w))).toBe(false);
+  });
+
+  it('decreases contentScore with more defaults', () => {
+    const minimal = makeContext({
+      tagline: undefined,
+      description: undefined,
+      brand: undefined,
+    });
+    const rich = makeContext({
+      tagline: 'Secure your AI',
+      description: 'The best AI security platform',
+      brand: { primaryColor: '#3B82F6' },
+    });
+
+    const minResult = validateWebsiteContext(minimal, 'gateco');
+    const richResult = validateWebsiteContext(rich, 'gateco');
+
+    expect(richResult.contentScore).toBeGreaterThan(minResult.contentScore);
+  });
+
+  it('returns blocking issues for missing docs', () => {
+    const context = makeContext({ rawDocs: '' });
+    const result = validateWebsiteContext(context, 'test');
+
+    expect(result.passed).toBe(false);
+    expect(result.issues.some((i) => /documentation/i.test(i))).toBe(true);
+  });
+
+  it('warns about missing description', () => {
+    const context = makeContext({ description: undefined });
+    const result = validateWebsiteContext(context, 'gateco');
+
+    expect(result.warnings.some((w) => /description/i.test(w))).toBe(true);
+  });
+
+  it('clamps score to 0 when everything is wrong', () => {
+    const context: WebsiteContentContext = {
+      productName: 'my-app',
+      features: [],
+      rawDocs: '',
+      strategy: undefined,
+    };
+    const result = validateWebsiteContext(context, 'my-app');
+
+    expect(result.contentScore).toBe(0);
+    expect(result.passed).toBe(false);
+  });
+});

package/tests/generators/shared-packages.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Tests for shared-packages module
+ * Verifies color scale generation and brand color passthrough
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  generateColorScale,
+  generateDesignTokensPackage,
+} from '../../src/generators/shared-packages.js';
+
+describe('generateColorScale', () => {
+  it('generates 10-stop color scale from valid hex', () => {
+    const scale = generateColorScale('#2563EB');
+
+    expect(Object.keys(scale)).toEqual(['50', '100', '200', '300', '400', '500', '600', '700', '800', '900']);
+    // Lightest stop should be light, darkest should be dark
+    expect(scale['50']).toMatch(/^#[0-9a-f]{6}$/);
+    expect(scale['900']).toMatch(/^#[0-9a-f]{6}$/);
+    // The stops should vary (not all the same)
+    const uniqueColors = new Set(Object.values(scale));
+    expect(uniqueColors.size).toBeGreaterThan(5);
+  });
+
+  it('falls back to default sky-blue on invalid hex', () => {
+    const scale = generateColorScale('not-a-color');
+
+    // Should return the default sky-blue palette
+    expect(scale['500']).toBe('#0ea5e9');
+    expect(scale['600']).toBe('#0284c7');
+  });
+
+  it('handles hex with # prefix correctly', () => {
+    const withHash = generateColorScale('#FF0000');
+    const withoutHash = generateColorScale('#FF0000');
+
+    expect(withHash).toEqual(withoutHash);
+  });
+});
+
+describe('generateDesignTokensPackage', () => {
+  it('uses brand color when provided', () => {
+    const result = generateDesignTokensPackage('test-project', {
+      primaryColor: '#2563EB',
+    });
+
+    // Find the colors.ts file
+    const colorsFile = result.files.find((f) => f.path === 'src/colors.ts');
+    expect(colorsFile).toBeDefined();
+    // Should NOT contain the default sky-blue
+    expect(colorsFile!.content).not.toContain('#0ea5e9');
+  });
+
+  it('uses default sky-blue when no brand color provided', () => {
+    const result = generateDesignTokensPackage('test-project');
+
+    const colorsFile = result.files.find((f) => f.path === 'src/colors.ts');
+    expect(colorsFile).toBeDefined();
+    // Should contain default sky-blue values
+    expect(colorsFile!.content).toContain('#0ea5e9');
+  });
+
+  it('generates correct package structure', () => {
+    const result = generateDesignTokensPackage('my-project');
+
+    const paths = result.files.map((f) => f.path);
+    expect(paths).toContain('package.json');
+    expect(paths).toContain('tsconfig.json');
+    expect(paths).toContain('src/index.ts');
+    expect(paths).toContain('src/colors.ts');
+    expect(paths).toContain('src/typography.ts');
+    expect(paths).toContain('src/tailwind-preset.ts');
+  });
+
+  it('package.json contains correct name with scope', () => {
+    const result = generateDesignTokensPackage('gateco');
+
+    const pkgFile = result.files.find((f) => f.path === 'package.json');
+    expect(pkgFile).toBeDefined();
+    const pkg = JSON.parse(pkgFile!.content);
+    expect(pkg.name).toBe('@gateco/design-tokens');
+  });
+});