popeye-cli 1.5.0 → 1.6.0

package/tests/upgrade/handlers.test.ts

@@ -0,0 +1,162 @@
+/**
+ * Tests for upgrade handler content context builder
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { buildUpgradeContentContext } from '../../src/upgrade/handlers.js';
+
+// Mock external dependencies to isolate unit behavior
+vi.mock('../../src/generators/website-context.js', () => ({
+  buildWebsiteContext: vi.fn(),
+  resolveBrandAssets: vi.fn(),
+  validateWebsiteContext: vi.fn(),
+}));
+
+vi.mock('../../src/generators/workspace-root.js', () => ({
+  resolveWorkspaceRoot: vi.fn(),
+}));
+
+vi.mock('../../src/workflow/website-strategy.js', () => ({
+  loadWebsiteStrategy: vi.fn(),
+}));
+
+vi.mock('../../src/state/persistence.js', () => ({
+  loadState: vi.fn(),
+  saveState: vi.fn(),
+}));
+
+import { buildWebsiteContext, resolveBrandAssets, validateWebsiteContext } from '../../src/generators/website-context.js';
+import { resolveWorkspaceRoot } from '../../src/generators/workspace-root.js';
+import { loadWebsiteStrategy } from '../../src/workflow/website-strategy.js';
+import { loadState } from '../../src/state/persistence.js';
+
+const mockBuildWebsiteContext = vi.mocked(buildWebsiteContext);
+const mockResolveBrandAssets = vi.mocked(resolveBrandAssets);
+const mockValidateWebsiteContext = vi.mocked(validateWebsiteContext);
+const mockResolveWorkspaceRoot = vi.mocked(resolveWorkspaceRoot);
+const mockLoadWebsiteStrategy = vi.mocked(loadWebsiteStrategy);
+const mockLoadState = vi.mocked(loadState);
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'popeye-handlers-test-'));
+  vi.clearAllMocks();
+
+  // Default mock returns
+  mockBuildWebsiteContext.mockResolvedValue({
+    productName: 'TestProject',
+    features: [{ title: 'Feature 1', description: 'A great feature' }],
+    rawDocs: '# Test docs',
+  });
+  mockResolveBrandAssets.mockResolvedValue({
+    logoSource: null,
+    faviconSource: null,
+    targets: [],
+  });
+  mockResolveWorkspaceRoot.mockResolvedValue(tmpDir);
+  mockLoadWebsiteStrategy.mockResolvedValue(null);
+  mockLoadState.mockResolvedValue(null);
+  mockValidateWebsiteContext.mockReturnValue({
+    passed: true,
+    issues: [],
+    warnings: [],
+    contentScore: 100,
+  });
+});
+
+afterEach(async () => {
+  await fs.rm(tmpDir, { recursive: true, force: true });
+});
+
+describe('buildUpgradeContentContext', () => {
+  it('should build context from user docs and return features', async () => {
+    const { context, warning } = await buildUpgradeContentContext(tmpDir, 'TestProject');
+
+    expect(warning).toBeUndefined();
+    expect(context).toBeDefined();
+    expect(context!.productName).toBe('TestProject');
+    expect(context!.features).toHaveLength(1);
+    expect(context!.features[0].title).toBe('Feature 1');
+
+    // Verify buildWebsiteContext was called with correct args
+    expect(mockBuildWebsiteContext).toHaveBeenCalledWith(tmpDir, 'TestProject');
+  });
+
+  it('should apply brand context from state when available', async () => {
+    mockLoadState.mockResolvedValue({
+      name: 'TestProject',
+      language: 'all',
+      brandContext: {
+        primaryColor: '#2563EB',
+        logoPath: '/path/to/logo.png',
+      },
+    } as any);
+
+    const { context } = await buildUpgradeContentContext(tmpDir, 'TestProject');
+
+    expect(context!.brand).toBeDefined();
+    expect(context!.brand!.primaryColor).toBe('#2563EB');
+    expect(context!.brand!.logoPath).toBe('/path/to/logo.png');
+  });
+
+  it('should load website strategy when available', async () => {
+    const mockStrategy = {
+      icp: { title: 'Developer', painPoints: ['slow builds'] },
+      messaging: { headline: 'Build faster', subheadline: 'Ship more' },
+    };
+    mockLoadWebsiteStrategy.mockResolvedValue({
+      strategy: mockStrategy as any,
+      metadata: { inputHash: 'abc', generatedAt: '2024-01-01', version: '1.0' },
+    });
+
+    const { context } = await buildUpgradeContentContext(tmpDir, 'TestProject');
+
+    expect(context!.strategy).toBeDefined();
+    expect(context!.strategy).toBe(mockStrategy);
+    expect(mockLoadWebsiteStrategy).toHaveBeenCalledWith(tmpDir);
+  });
+
+  it('should resolve brand assets using workspace root', async () => {
+    const wsRoot = '/resolved/workspace/root';
+    mockResolveWorkspaceRoot.mockResolvedValue(wsRoot);
+
+    const { context } = await buildUpgradeContentContext(tmpDir, 'TestProject');
+
+    expect(context).toBeDefined();
+    expect(mockResolveWorkspaceRoot).toHaveBeenCalledWith(tmpDir);
+    expect(mockResolveBrandAssets).toHaveBeenCalledWith(wsRoot, context!.brand);
+  });
+
+  it('should return warning on error without crashing', async () => {
+    mockBuildWebsiteContext.mockRejectedValue(new Error('Docs directory not found'));
+
+    const { context, warning } = await buildUpgradeContentContext(tmpDir, 'TestProject');
+
+    expect(context).toBeUndefined();
+    expect(warning).toBe('Docs directory not found');
+  });
+
+  it('should handle non-Error throws gracefully', async () => {
+    mockBuildWebsiteContext.mockRejectedValue('unexpected string error');
+
+    const { context, warning } = await buildUpgradeContentContext(tmpDir, 'TestProject');
+
+    expect(context).toBeUndefined();
+    expect(warning).toBe('Unknown error building website context');
+  });
+
+  it('should work when no state or strategy exists', async () => {
+    // Default mocks already return null for state and strategy
+    const { context, warning } = await buildUpgradeContentContext(tmpDir, 'TestProject');
+
+    expect(warning).toBeUndefined();
+    expect(context).toBeDefined();
+    expect(context!.strategy).toBeUndefined();
+    // Brand should still be whatever buildWebsiteContext returns
+    expect(context!.productName).toBe('TestProject');
+  });
+});

package/tests/workflow/auto-fix-bundler.test.ts

@@ -0,0 +1,242 @@
+/**
+ * Tests for auto-fix-bundler: CSS/PostCSS/Tailwind/webpack error parsing and config discovery
+ */
+
+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 {
+  parseBundlerErrors,
+  findRelatedConfigs,
+  parseMultiFileResponse,
+} from '../../src/workflow/auto-fix-bundler.js';
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'popeye-bundler-'));
+});
+
+afterEach(async () => {
+  await fs.rm(tempDir, { recursive: true, force: true });
+});
+
+describe('parseBundlerErrors', () => {
+  it('should parse Tailwind CSS "class does not exist" errors', () => {
+    const output = `./src/app/globals.css:1:1
+Syntax error: /Users/test/project/apps/website/src/app/globals.css The \`bg-background\` class does not exist. If \`bg-background\` is a custom class, make sure it is defined within a \`@layer\` directive.
+
+> 1 | @tailwind base;
+    | ^
+  2 | @tailwind components;
+  3 | @tailwind utilities;`;
+
+    const errors = parseBundlerErrors(output);
+
+    expect(errors.length).toBeGreaterThanOrEqual(1);
+    // Should find either the css pattern or the file:line:col pattern
+    const cssError = errors.find(e => e.type === 'css' || e.type === 'syntax');
+    expect(cssError).toBeDefined();
+    expect(cssError!.message).toContain('bg-background');
+  });
+
+  it('should parse CSS syntax error with absolute path', () => {
+    const output = `Syntax error: /Users/test/apps/website/src/globals.css The \`text-foreground\` class does not exist. If \`text-foreground\` is a custom class, make sure it is defined within a \`@layer\` directive.
+
+Some other lines here.`;
+
+    const errors = parseBundlerErrors(output);
+
+    expect(errors.length).toBe(1);
+    expect(errors[0].type).toBe('css');
+    expect(errors[0].file).toContain('globals.css');
+    expect(errors[0].message).toContain('text-foreground');
+  });
+
+  it('should parse module not found errors', () => {
+    const output = `Module not found: Can't resolve '@acme/design-tokens/tailwind' in '/Users/test/apps/website'
+
+https://nextjs.org/docs/messages/module-not-found
+
+Import trace for requested module:
+./src/app/globals.css`;
+
+    const errors = parseBundlerErrors(output);
+
+    expect(errors.length).toBeGreaterThanOrEqual(1);
+    const moduleError = errors.find(e => e.type === 'module-not-found');
+    expect(moduleError).toBeDefined();
+    expect(moduleError!.message).toContain('@acme/design-tokens/tailwind');
+  });
+
+  it('should parse file:line:col reference for non-TS files', () => {
+    const output = `./src/app/globals.css:1:1
+Syntax error: Something went wrong with the CSS processing.
+
+> 1 | @tailwind base;
+    | ^`;
+
+    const errors = parseBundlerErrors(output);
+
+    expect(errors.length).toBeGreaterThanOrEqual(1);
+    const refError = errors.find(e => e.type === 'syntax');
+    expect(refError).toBeDefined();
+    expect(refError!.file).toContain('globals.css');
+    expect(refError!.line).toBe(1);
+    expect(refError!.column).toBe(1);
+  });
+
+  it('should parse webpack build failure with import traces', () => {
+    const output = `Build failed because of webpack errors
+
+Import trace for requested module:
+./src/app/globals.css
+./src/components/Layout.tsx`;
+
+    const errors = parseBundlerErrors(output);
+
+    expect(errors.length).toBeGreaterThanOrEqual(1);
+    expect(errors.some(e => e.file.includes('globals.css'))).toBe(true);
+  });
+
+  it('should strip ANSI color codes before parsing', () => {
+    const output = `\x1b[31mSyntax error: /path/to/file.css The \`bg-primary\` class does not exist.\x1b[0m`;
+
+    const errors = parseBundlerErrors(output);
+
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toContain('bg-primary');
+  });
+
+  it('should de-duplicate errors from the same file', () => {
+    const output = `Syntax error: /path/to/globals.css The \`bg-background\` class does not exist.
+
+Syntax error: /path/to/globals.css The \`bg-background\` class does not exist.`;
+
+    const errors = parseBundlerErrors(output);
+
+    // Should de-duplicate by file
+    expect(errors.length).toBe(1);
+  });
+
+  it('should return empty array for TypeScript-only errors', () => {
+    const output = `src/index.ts(10,5): error TS2304: Cannot find name 'foo'
+src/utils.ts(25,12): error TS2339: Property 'bar' does not exist`;
+
+    const errors = parseBundlerErrors(output);
+
+    expect(errors.length).toBe(0);
+  });
+
+  it('should return empty array for generic npm errors', () => {
+    const output = `npm ERR! code ELIFECYCLE
+npm ERR! errno 1
+npm ERR! Exit status 1`;
+
+    const errors = parseBundlerErrors(output);
+
+    expect(errors.length).toBe(0);
+  });
+
+  it('should return empty array for empty output', () => {
+    expect(parseBundlerErrors('')).toEqual([]);
+  });
+});
+
+describe('findRelatedConfigs', () => {
+  it('should find tailwind and postcss configs in app directory', async () => {
+    const appDir = path.join(tempDir, 'apps', 'website');
+    await fs.mkdir(appDir, { recursive: true });
+    await fs.writeFile(path.join(appDir, 'tailwind.config.ts'), 'export default {}');
+    await fs.writeFile(path.join(appDir, 'postcss.config.js'), 'module.exports = {}');
+
+    const configs = await findRelatedConfigs(tempDir, 'apps/website/src/globals.css');
+
+    expect(configs.length).toBeGreaterThanOrEqual(2);
+    expect(configs.some(c => c.path.includes('tailwind.config.ts'))).toBe(true);
+    expect(configs.some(c => c.path.includes('postcss.config.js'))).toBe(true);
+  });
+
+  it('should search project root as well', async () => {
+    await fs.writeFile(path.join(tempDir, 'package.json'), '{"name": "test"}');
+
+    const configs = await findRelatedConfigs(tempDir, 'src/globals.css');
+
+    expect(configs.some(c => c.path.includes('package.json'))).toBe(true);
+  });
+
+  it('should return empty array when no configs exist', async () => {
+    const configs = await findRelatedConfigs(tempDir, 'src/globals.css');
+
+    expect(configs).toEqual([]);
+  });
+
+  it('should cap config file content at 4000 chars', async () => {
+    const largeContent = 'x'.repeat(10000);
+    await fs.writeFile(path.join(tempDir, 'package.json'), largeContent);
+
+    const configs = await findRelatedConfigs(tempDir, 'src/globals.css');
+
+    const pkg = configs.find(c => c.path.includes('package.json'));
+    expect(pkg).toBeDefined();
+    expect(pkg!.content.length).toBeLessThanOrEqual(4000);
+  });
+});
+
+describe('parseMultiFileResponse', () => {
+  it('should parse single file response', () => {
+    const response = `FILE: /path/to/tailwind.config.ts
+\`\`\`typescript
+import type { Config } from 'tailwindcss';
+export default { content: [] } satisfies Config;
+\`\`\``;
+
+    const results = parseMultiFileResponse(response);
+
+    expect(results.length).toBe(1);
+    expect(results[0].targetPath).toBe('/path/to/tailwind.config.ts');
+    expect(results[0].content).toContain('tailwindcss');
+  });
+
+  it('should parse multiple file responses', () => {
+    const response = `I'll fix both files:
+
+FILE: /path/to/tailwind.config.ts
+\`\`\`
+export default { colors: { background: 'hsl(var(--background))' } };
+\`\`\`
+
+FILE: /path/to/globals.css
+\`\`\`
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+\`\`\``;
+
+    const results = parseMultiFileResponse(response);
+
+    expect(results.length).toBe(2);
+    expect(results[0].targetPath).toContain('tailwind.config.ts');
+    expect(results[1].targetPath).toContain('globals.css');
+  });
+
+  it('should skip files with very short content', () => {
+    const response = `FILE: /path/to/file.ts
+\`\`\`
+tiny
+\`\`\``;
+
+    const results = parseMultiFileResponse(response);
+
+    expect(results.length).toBe(0);
+  });
+
+  it('should return empty array for unparseable response', () => {
+    const response = `I'm not sure how to fix this error.`;
+
+    const results = parseMultiFileResponse(response);
+
+    expect(results.length).toBe(0);
+  });
+});

package/tests/workflow/plan-mode.test.ts

@@ -3,7 +3,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { parsePlanMilestones } from '../../src/workflow/plan-mode.js';
+import { parsePlanMilestones, parseTaskTag, tagToAppTarget } from '../../src/workflow/plan-mode.js';
 
 describe('parsePlanMilestones', () => {
   describe('with explicit task markers', () => {
@@ -195,6 +195,76 @@ Description: Build the main API endpoints
     });
   });
 
+  describe('app tag handling', () => {
+    it('should extract tasks with [WEB] tags', () => {
+      const plan = `
+## Milestone 1: Website Branding
+
+### Task 1.1 [WEB]: Update root layout with Gateco branding
+- **Description**: Replace default branding with Gateco colors and logo
+
+### Task 1.2 [WEB]: Create hero section component
+- **Description**: Build the landing page hero with CTA
+`;
+
+      const milestones = parsePlanMilestones(plan);
+      const allTasks = milestones.flatMap(m => m.tasks);
+
+      expect(allTasks.length).toBeGreaterThanOrEqual(2);
+      const taskNames = allTasks.map(t => t.name.toLowerCase());
+      expect(taskNames.some(n => n.includes('update root layout'))).toBe(true);
+      expect(taskNames.some(n => n.includes('create hero section'))).toBe(true);
+    });
+
+    it('should extract tasks with [INT] tags', () => {
+      const plan = `
+## Milestone 3: Integration
+
+### Task 3.1 [INT]: Wire frontend auth to backend API
+- **Description**: Connect the frontend login form to the backend auth endpoint
+
+### Task 3.2 [INT]: Set up end-to-end test suite
+- **Description**: Create E2E tests covering the full auth flow
+`;
+
+      const milestones = parsePlanMilestones(plan);
+      const allTasks = milestones.flatMap(m => m.tasks);
+
+      expect(allTasks.length).toBeGreaterThanOrEqual(2);
+      const taskNames = allTasks.map(t => t.name.toLowerCase());
+      expect(taskNames.some(n => n.includes('wire frontend auth'))).toBe(true);
+      expect(taskNames.some(n => n.includes('set up end-to-end'))).toBe(true);
+    });
+
+    it('should extract tasks with mixed app tags across milestones', () => {
+      const plan = `
+## Milestone 1: Setup
+
+### Task 1.1 [FE]: Create React component library
+- **Description**: Scaffold shared components
+
+### Task 1.2 [BE]: Implement REST API endpoints
+- **Description**: Build core API
+
+### Task 1.3 [WEB]: Build marketing landing page
+- **Description**: Create the public-facing website
+
+### Task 1.4 [INT]: Configure CI/CD pipeline
+- **Description**: Set up automated deployment
+`;
+
+      const milestones = parsePlanMilestones(plan);
+      const allTasks = milestones.flatMap(m => m.tasks);
+
+      expect(allTasks.length).toBeGreaterThanOrEqual(4);
+      const taskNames = allTasks.map(t => t.name.toLowerCase());
+      expect(taskNames.some(n => n.includes('create react component'))).toBe(true);
+      expect(taskNames.some(n => n.includes('implement rest api'))).toBe(true);
+      expect(taskNames.some(n => n.includes('build marketing landing'))).toBe(true);
+      expect(taskNames.some(n => n.includes('configure ci/cd'))).toBe(true);
+    });
+  });
+
   describe('fallback behavior', () => {
     it('should create a default milestone when no tasks found', () => {
       const plan = `
@@ -211,3 +281,43 @@ The project will do various things but no specific implementation steps are list
     });
   });
 });
+
+describe('parseTaskTag', () => {
+  it('should return WEB for [WEB] tagged tasks', () => {
+    expect(parseTaskTag('[WEB]: Update root layout')).toBe('WEB');
+    expect(parseTaskTag('[web]: Update root layout')).toBe('WEB');
+  });
+
+  it('should return FE, BE, INT for their respective tags', () => {
+    expect(parseTaskTag('[FE]: Create component')).toBe('FE');
+    expect(parseTaskTag('[BE]: Build API')).toBe('BE');
+    expect(parseTaskTag('[INT]: Wire frontend to backend')).toBe('INT');
+  });
+
+  it('should return undefined for untagged tasks', () => {
+    expect(parseTaskTag('Create component')).toBeUndefined();
+    expect(parseTaskTag('Build API endpoints')).toBeUndefined();
+  });
+
+  it('should return undefined for unknown tags', () => {
+    expect(parseTaskTag('[UNKNOWN]: Some task')).toBeUndefined();
+  });
+});
+
+describe('tagToAppTarget', () => {
+  it('should map WEB to website', () => {
+    expect(tagToAppTarget('WEB')).toBe('website');
+  });
+
+  it('should map FE to frontend', () => {
+    expect(tagToAppTarget('FE')).toBe('frontend');
+  });
+
+  it('should map BE to backend', () => {
+    expect(tagToAppTarget('BE')).toBe('backend');
+  });
+
+  it('should map INT to unified', () => {
+    expect(tagToAppTarget('INT')).toBe('unified');
+  });
+});

package/tests/workflow/website-strategy.test.ts

@@ -11,6 +11,7 @@ import {
   loadWebsiteStrategy,
   formatStrategyForPlanContext,
   isStrategyStale,
+  packProductContext,
 } from '../../src/workflow/website-strategy.js';
 import type {
   WebsiteStrategyDocument,
@@ -189,3 +190,57 @@ describe('isStrategyStale', () => {
     expect(loaded!.strategy.messaging.headline).toBe('Ship Code 10x Faster');
   });
 });
+
+describe('packProductContext', () => {
+  it('preserves high-priority docs (spec, pricing) within budget', () => {
+    const context = [
+      '--- random-notes.md ---',
+      'Some random notes about the project.',
+      '',
+      '--- product-spec.md ---',
+      '# Product Specification\nThis is the product specification.',
+      '',
+      '--- pricing.md ---',
+      '# Pricing\nFree, Pro, Enterprise tiers.',
+      '',
+      '--- color-scheme.md ---',
+      '# Colors\nPrimary: #2563EB',
+    ].join('\n');
+
+    const packed = packProductContext(context, 500);
+
+    // Spec should come first (priority 1)
+    const specIndex = packed.indexOf('product-spec.md');
+    const pricingIndex = packed.indexOf('pricing.md');
+    const randomIndex = packed.indexOf('random-notes.md');
+
+    expect(specIndex).toBeGreaterThanOrEqual(0);
+    expect(pricingIndex).toBeGreaterThanOrEqual(0);
+    // Spec should appear before random notes (or random notes may be cut)
+    if (randomIndex >= 0) {
+      expect(specIndex).toBeLessThan(randomIndex);
+    }
+  });
+
+  it('handles context without headers gracefully', () => {
+    const context = 'Just raw text without any headers';
+
+    const packed = packProductContext(context, 100);
+
+    expect(packed).toBe(context);
+  });
+
+  it('respects budget limit', () => {
+    const largeContext = [
+      '--- spec.md ---',
+      'x'.repeat(5000),
+      '',
+      '--- pricing.md ---',
+      'y'.repeat(5000),
+    ].join('\n');
+
+    const packed = packProductContext(largeContext, 1000);
+
+    expect(packed.length).toBeLessThanOrEqual(1100); // Some tolerance for headers
+  });
+});