edsger 0.45.0 → 0.46.0

package/dist/config/__tests__/feature-status.test.js

@@ -1,111 +0,0 @@
-/**
- * Unit tests for feature status configuration
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { PHASE_STATUS_MAP, STATUS_PROGRESSION_ORDER, } from '../feature-status.js';
-void describe('Feature Status Configuration', () => {
-    void describe('STATUS_PROGRESSION_ORDER', () => {
-        void it('should start with backlog and end with archived', () => {
-            assert.strictEqual(STATUS_PROGRESSION_ORDER[0], 'backlog', 'First status should be backlog');
-            assert.strictEqual(STATUS_PROGRESSION_ORDER[STATUS_PROGRESSION_ORDER.length - 1], 'archived', 'Last status should be archived');
-        });
-        void it('should be readonly', () => {
-            // This test ensures the configuration is properly typed as readonly
-            // TypeScript will catch attempts to modify the array at compile time
-            assert.ok(Array.isArray(STATUS_PROGRESSION_ORDER));
-            assert.ok(STATUS_PROGRESSION_ORDER.length > 0);
-        });
-        void it('should maintain logical workflow order', () => {
-            const criticalOrder = [
-                'backlog',
-                'ready_for_ai',
-                'feature_analysis',
-                'technical_design',
-                'code_implementation',
-                'shipped',
-            ];
-            let lastIndex = -1;
-            for (const status of criticalOrder) {
-                const currentIndex = STATUS_PROGRESSION_ORDER.indexOf(status);
-                assert.ok(currentIndex > lastIndex, `${status} should come after the previous critical status`);
-                lastIndex = currentIndex;
-            }
-        });
-    });
-    void describe('PHASE_STATUS_MAP', () => {
-        void it('should map all expected phases', () => {
-            const expectedPhases = [
-                'feature-analysis',
-                'feature-analysis-verification',
-                'technical-design',
-                'technical-design-verification',
-                'code-implementation',
-                'code-implementation-verification',
-                'code-refine',
-                'code-refine-verification',
-                'bug-fixing',
-                'code-review',
-                'pull-request',
-                'functional-testing',
-                'testing-in-progress',
-                'testing-passed',
-                'testing-failed',
-            ];
-            for (const phase of expectedPhases) {
-                assert.ok(phase in PHASE_STATUS_MAP, `Should have mapping for phase: ${phase}`);
-            }
-        });
-        void it('should map phases to valid statuses', () => {
-            for (const [phase, status] of Object.entries(PHASE_STATUS_MAP)) {
-                assert.ok(STATUS_PROGRESSION_ORDER.includes(status), `Phase ${phase} maps to valid status ${status}`);
-            }
-        });
-        void it('should use kebab-case for multi-word phase names and snake_case for multi-word status names', () => {
-            for (const [phase, status] of Object.entries(PHASE_STATUS_MAP)) {
-                // Phase names should not contain underscores
-                assert.ok(!phase.includes('_'), `Phase name ${phase} should not contain underscores`);
-                // Status names should not contain hyphens
-                assert.ok(!status.includes('-'), `Status name ${status} should not contain hyphens`);
-                // Multi-word phase names should use hyphens
-                if (phase.split('-').length > 1) {
-                    assert.ok(phase.includes('-'), `Multi-word phase name ${phase} should use kebab-case`);
-                }
-                // Multi-word status names should use underscores
-                if (status.split('_').length > 1) {
-                    assert.ok(status.includes('_'), `Multi-word status name ${status} should use snake_case`);
-                }
-            }
-        });
-        void it('should maintain consistency with phase naming conventions', () => {
-            // Test some specific mappings to ensure they follow expected patterns
-            assert.strictEqual(PHASE_STATUS_MAP['feature-analysis'], 'feature_analysis', 'feature-analysis should map to feature_analysis');
-            assert.strictEqual(PHASE_STATUS_MAP['technical-design-verification'], 'technical_design_verification', 'technical-design-verification should map to technical_design_verification');
-            assert.strictEqual(PHASE_STATUS_MAP['code-implementation'], 'code_implementation', 'code-implementation should map to code_implementation');
-        });
-        void it('should be readonly', () => {
-            // Ensure the mapping is properly configured as readonly
-            assert.ok(typeof PHASE_STATUS_MAP === 'object');
-            assert.ok(Object.keys(PHASE_STATUS_MAP).length > 0);
-        });
-    });
-    void describe('Integration Tests', () => {
-        void it('should have all mapped statuses in progression order', () => {
-            const mappedStatuses = Object.values(PHASE_STATUS_MAP);
-            for (const status of mappedStatuses) {
-                assert.ok(STATUS_PROGRESSION_ORDER.includes(status), `Mapped status ${status} should be in progression order`);
-            }
-        });
-        void it('should not have gaps in critical workflow phases', () => {
-            const workflowPhases = [
-                'feature-analysis',
-                'technical-design',
-                'code-implementation',
-                'functional-testing',
-            ];
-            for (const phase of workflowPhases) {
-                assert.ok(phase in PHASE_STATUS_MAP, `Critical workflow phase ${phase} should be mapped`);
-            }
-        });
-    });
-});

package/dist/errors/__tests__/index.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Unit tests for Edsger error classification system
- */
-export {};

package/dist/errors/__tests__/index.test.js

@@ -1,349 +0,0 @@
-/**
- * Unit tests for Edsger error classification system
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { ApiError, AuthError, ConfigError, EdsgerError, GitHubError, LLMParseError, PhaseError, ValidationError, WorkerCrashError, WorkerTimeoutError, } from '../index.js';
-// ---- EdsgerError (base) ----
-void describe('EdsgerError', () => {
-    void it('should set name to EdsgerError', () => {
-        const err = new EdsgerError('API_ERROR', 'test message');
-        assert.strictEqual(err.name, 'EdsgerError');
-    });
-    void it('should store the error code', () => {
-        const err = new EdsgerError('AUTH_ERROR', 'unauthorized');
-        assert.strictEqual(err.code, 'AUTH_ERROR');
-    });
-    void it('should store the message', () => {
-        const err = new EdsgerError('CONFIG_ERROR', 'missing field');
-        assert.strictEqual(err.message, 'missing field');
-    });
-    void it('should be an instance of Error', () => {
-        const err = new EdsgerError('API_ERROR', 'test');
-        assert.ok(err instanceof Error);
-    });
-    void it('should preserve cause when provided via options', () => {
-        const cause = new Error('root cause');
-        const err = new EdsgerError('API_ERROR', 'wrapped', { cause });
-        assert.strictEqual(err.cause, cause);
-    });
-});
-// ---- EdsgerError.from ----
-void describe('EdsgerError.from', () => {
-    void it('should wrap an Error, preserving its message and cause chain', () => {
-        const original = new Error('connection refused');
-        const wrapped = EdsgerError.from('API_ERROR', 'fetch failed', original);
-        assert.strictEqual(wrapped.code, 'API_ERROR');
-        assert.strictEqual(wrapped.message, 'fetch failed: connection refused');
-        assert.strictEqual(wrapped.cause, original);
-    });
-    void it('should wrap a string thrown value', () => {
-        const wrapped = EdsgerError.from('CONFIG_ERROR', 'init', 'bad config');
-        assert.strictEqual(wrapped.code, 'CONFIG_ERROR');
-        assert.strictEqual(wrapped.message, 'init: bad config');
-        assert.strictEqual(wrapped.cause, undefined);
-    });
-    void it('should wrap an unknown thrown value by stringifying it', () => {
-        const wrapped = EdsgerError.from('VALIDATION_ERROR', 'parse', 42);
-        assert.strictEqual(wrapped.message, 'parse: 42');
-        assert.strictEqual(wrapped.cause, undefined);
-    });
-    void it('should wrap null thrown value', () => {
-        const wrapped = EdsgerError.from('API_ERROR', 'unexpected', null);
-        assert.strictEqual(wrapped.message, 'unexpected: null');
-        assert.strictEqual(wrapped.cause, undefined);
-    });
-    void it('should wrap undefined thrown value', () => {
-        const wrapped = EdsgerError.from('API_ERROR', 'unexpected', undefined);
-        assert.strictEqual(wrapped.message, 'unexpected: undefined');
-        assert.strictEqual(wrapped.cause, undefined);
-    });
-});
-// ---- ApiError ----
-void describe('ApiError', () => {
-    void it('should set name to ApiError', () => {
-        const err = new ApiError('/api/features', 'not found', 404);
-        assert.strictEqual(err.name, 'ApiError');
-    });
-    void it('should have code API_ERROR', () => {
-        const err = new ApiError('/api/features', 'error');
-        assert.strictEqual(err.code, 'API_ERROR');
-    });
-    void it('should store endpoint and statusCode', () => {
-        const err = new ApiError('/api/products', 'server error', 500);
-        assert.strictEqual(err.endpoint, '/api/products');
-        assert.strictEqual(err.statusCode, 500);
-    });
-    void it('should allow statusCode to be undefined', () => {
-        const err = new ApiError('/api/test', 'network error');
-        assert.strictEqual(err.statusCode, undefined);
-    });
-    void it('should be an instance of EdsgerError', () => {
-        const err = new ApiError('/api/test', 'error');
-        assert.ok(err instanceof EdsgerError);
-    });
-    void it('should be an instance of Error', () => {
-        const err = new ApiError('/api/test', 'error');
-        assert.ok(err instanceof Error);
-    });
-});
-// ---- GitHubError ----
-void describe('GitHubError', () => {
-    void it('should set name to GitHubError', () => {
-        const err = new GitHubError('rate limited');
-        assert.strictEqual(err.name, 'GitHubError');
-    });
-    void it('should have code GITHUB_ERROR', () => {
-        const err = new GitHubError('error');
-        assert.strictEqual(err.code, 'GITHUB_ERROR');
-    });
-    void it('should store owner, repo, and statusCode from details', () => {
-        const err = new GitHubError('forbidden', {
-            owner: 'acme',
-            repo: 'widget',
-            statusCode: 403,
-        });
-        assert.strictEqual(err.owner, 'acme');
-        assert.strictEqual(err.repo, 'widget');
-        assert.strictEqual(err.statusCode, 403);
-    });
-    void it('should default detail fields to undefined', () => {
-        const err = new GitHubError('error');
-        assert.strictEqual(err.owner, undefined);
-        assert.strictEqual(err.repo, undefined);
-        assert.strictEqual(err.statusCode, undefined);
-    });
-    void it('should be an instance of EdsgerError', () => {
-        const err = new GitHubError('error');
-        assert.ok(err instanceof EdsgerError);
-    });
-});
-// ---- AuthError ----
-void describe('AuthError', () => {
-    void it('should set name to AuthError', () => {
-        const err = new AuthError('token expired');
-        assert.strictEqual(err.name, 'AuthError');
-    });
-    void it('should have code AUTH_ERROR', () => {
-        const err = new AuthError('invalid');
-        assert.strictEqual(err.code, 'AUTH_ERROR');
-    });
-    void it('should be an instance of EdsgerError', () => {
-        const err = new AuthError('test');
-        assert.ok(err instanceof EdsgerError);
-    });
-});
-// ---- ConfigError ----
-void describe('ConfigError', () => {
-    void it('should set name to ConfigError', () => {
-        const err = new ConfigError('missing value');
-        assert.strictEqual(err.name, 'ConfigError');
-    });
-    void it('should have code CONFIG_ERROR', () => {
-        const err = new ConfigError('bad config');
-        assert.strictEqual(err.code, 'CONFIG_ERROR');
-    });
-    void it('should store the field name', () => {
-        const err = new ConfigError('missing API key', 'apiKey');
-        assert.strictEqual(err.field, 'apiKey');
-    });
-    void it('should default field to undefined', () => {
-        const err = new ConfigError('error');
-        assert.strictEqual(err.field, undefined);
-    });
-    void it('should be an instance of EdsgerError', () => {
-        const err = new ConfigError('test');
-        assert.ok(err instanceof EdsgerError);
-    });
-});
-// ---- PhaseError ----
-void describe('PhaseError', () => {
-    void it('should set name to PhaseError', () => {
-        const err = new PhaseError('code_implementation', 'feat-1', 'compile error');
-        assert.strictEqual(err.name, 'PhaseError');
-    });
-    void it('should have code PHASE_ERROR', () => {
-        const err = new PhaseError('testing', 'feat-1', 'test failed');
-        assert.strictEqual(err.code, 'PHASE_ERROR');
-    });
-    void it('should store phase, featureId, and iteration', () => {
-        const err = new PhaseError('analysis', 'feat-42', 'timeout', 3);
-        assert.strictEqual(err.phase, 'analysis');
-        assert.strictEqual(err.featureId, 'feat-42');
-        assert.strictEqual(err.iteration, 3);
-    });
-    void it('should default iteration to undefined', () => {
-        const err = new PhaseError('design', 'feat-1', 'error');
-        assert.strictEqual(err.iteration, undefined);
-    });
-    void it('should be an instance of EdsgerError', () => {
-        const err = new PhaseError('design', 'feat-1', 'error');
-        assert.ok(err instanceof EdsgerError);
-    });
-});
-// ---- LLMParseError ----
-void describe('LLMParseError', () => {
-    void it('should set name to LLMParseError', () => {
-        const err = new LLMParseError('invalid JSON');
-        assert.strictEqual(err.name, 'LLMParseError');
-    });
-    void it('should have code LLM_PARSE_ERROR', () => {
-        const err = new LLMParseError('parse error');
-        assert.strictEqual(err.code, 'LLM_PARSE_ERROR');
-    });
-    void it('should store rawResponse when provided', () => {
-        const err = new LLMParseError('bad json', '{"incomplete');
-        assert.strictEqual(err.rawResponse, '{"incomplete');
-    });
-    void it('should default rawResponse to undefined', () => {
-        const err = new LLMParseError('error');
-        assert.strictEqual(err.rawResponse, undefined);
-    });
-    void it('should truncate rawResponse to 2000 characters', () => {
-        const longResponse = 'x'.repeat(5000);
-        const err = new LLMParseError('too long', longResponse);
-        assert.strictEqual(err.rawResponse?.length, 2000);
-    });
-    void it('should not truncate rawResponse that is exactly 2000 characters', () => {
-        const response = 'y'.repeat(2000);
-        const err = new LLMParseError('exact', response);
-        assert.strictEqual(err.rawResponse?.length, 2000);
-        assert.strictEqual(err.rawResponse, response);
-    });
-    void it('should not truncate rawResponse shorter than 2000 characters', () => {
-        const response = 'short response';
-        const err = new LLMParseError('ok', response);
-        assert.strictEqual(err.rawResponse, response);
-    });
-    void it('should be an instance of EdsgerError', () => {
-        const err = new LLMParseError('test');
-        assert.ok(err instanceof EdsgerError);
-    });
-});
-// ---- WorkerTimeoutError ----
-void describe('WorkerTimeoutError', () => {
-    void it('should set name to WorkerTimeoutError', () => {
-        const err = new WorkerTimeoutError('feat-1', 30000);
-        assert.strictEqual(err.name, 'WorkerTimeoutError');
-    });
-    void it('should have code WORKER_TIMEOUT', () => {
-        const err = new WorkerTimeoutError('feat-1', 60000);
-        assert.strictEqual(err.code, 'WORKER_TIMEOUT');
-    });
-    void it('should store featureId and timeoutMs', () => {
-        const err = new WorkerTimeoutError('feat-abc', 120000);
-        assert.strictEqual(err.featureId, 'feat-abc');
-        assert.strictEqual(err.timeoutMs, 120000);
-    });
-    void it('should format message with seconds', () => {
-        const err = new WorkerTimeoutError('feat-1', 90000);
-        assert.strictEqual(err.message, 'Worker for feature feat-1 timed out after 90s');
-    });
-    void it('should round fractional seconds', () => {
-        const err = new WorkerTimeoutError('feat-1', 90500);
-        assert.strictEqual(err.message, 'Worker for feature feat-1 timed out after 91s');
-    });
-    void it('should be an instance of EdsgerError', () => {
-        const err = new WorkerTimeoutError('feat-1', 1000);
-        assert.ok(err instanceof EdsgerError);
-    });
-});
-// ---- WorkerCrashError ----
-void describe('WorkerCrashError', () => {
-    void it('should set name to WorkerCrashError', () => {
-        const err = new WorkerCrashError('feat-1', 1);
-        assert.strictEqual(err.name, 'WorkerCrashError');
-    });
-    void it('should have code WORKER_CRASH', () => {
-        const err = new WorkerCrashError('feat-1', 1);
-        assert.strictEqual(err.code, 'WORKER_CRASH');
-    });
-    void it('should store featureId and exitCode', () => {
-        const err = new WorkerCrashError('feat-99', 137);
-        assert.strictEqual(err.featureId, 'feat-99');
-        assert.strictEqual(err.exitCode, 137);
-    });
-    void it('should format message with exit code', () => {
-        const err = new WorkerCrashError('feat-1', 1);
-        assert.strictEqual(err.message, 'Worker for feature feat-1 crashed with exit code 1');
-    });
-    void it('should handle null exit code', () => {
-        const err = new WorkerCrashError('feat-1', null);
-        assert.strictEqual(err.exitCode, null);
-        assert.strictEqual(err.message, 'Worker for feature feat-1 crashed with exit code null');
-    });
-    void it('should be an instance of EdsgerError', () => {
-        const err = new WorkerCrashError('feat-1', 1);
-        assert.ok(err instanceof EdsgerError);
-    });
-});
-// ---- ValidationError ----
-void describe('ValidationError', () => {
-    void it('should set name to ValidationError', () => {
-        const err = new ValidationError('invalid input', ['name', 'email']);
-        assert.strictEqual(err.name, 'ValidationError');
-    });
-    void it('should have code VALIDATION_ERROR', () => {
-        const err = new ValidationError('bad data');
-        assert.strictEqual(err.code, 'VALIDATION_ERROR');
-    });
-    void it('should store the fields array', () => {
-        const err = new ValidationError('missing fields', ['name', 'email']);
-        assert.deepStrictEqual(err.fields, ['name', 'email']);
-    });
-    void it('should default fields to empty array', () => {
-        const err = new ValidationError('error');
-        assert.deepStrictEqual(err.fields, []);
-    });
-    void it('should be an instance of EdsgerError', () => {
-        const err = new ValidationError('test');
-        assert.ok(err instanceof EdsgerError);
-    });
-});
-// ---- Cross-cutting: instanceof chain ----
-void describe('instanceof chain', () => {
-    void it('ApiError should be instanceof EdsgerError and Error', () => {
-        const err = new ApiError('/test', 'err');
-        assert.ok(err instanceof ApiError);
-        assert.ok(err instanceof EdsgerError);
-        assert.ok(err instanceof Error);
-    });
-    void it('GitHubError should be instanceof EdsgerError and Error', () => {
-        const err = new GitHubError('err');
-        assert.ok(err instanceof GitHubError);
-        assert.ok(err instanceof EdsgerError);
-        assert.ok(err instanceof Error);
-    });
-    void it('PhaseError should be instanceof EdsgerError and Error', () => {
-        const err = new PhaseError('analysis', 'f-1', 'err');
-        assert.ok(err instanceof PhaseError);
-        assert.ok(err instanceof EdsgerError);
-        assert.ok(err instanceof Error);
-    });
-    void it('WorkerTimeoutError should be instanceof EdsgerError and Error', () => {
-        const err = new WorkerTimeoutError('f-1', 1000);
-        assert.ok(err instanceof WorkerTimeoutError);
-        assert.ok(err instanceof EdsgerError);
-        assert.ok(err instanceof Error);
-    });
-    void it('ApiError should NOT be instanceof GitHubError', () => {
-        const err = new ApiError('/test', 'err');
-        assert.ok(!(err instanceof GitHubError));
-    });
-});
-// ---- Error cause chain preservation ----
-void describe('Error cause chain preservation', () => {
-    void it('should preserve a multi-level cause chain', () => {
-        const root = new Error('disk full');
-        const mid = new EdsgerError('API_ERROR', 'write failed', { cause: root });
-        const top = new ApiError('/api/save', 'save failed', 500, { cause: mid });
-        assert.strictEqual(top.cause, mid);
-        assert.strictEqual(top.cause.cause, root);
-    });
-    void it('EdsgerError.from should preserve cause from original error', () => {
-        const root = new Error('ECONNREFUSED');
-        const wrapped = EdsgerError.from('API_ERROR', 'network', root);
-        assert.strictEqual(wrapped.cause, root);
-        assert.strictEqual(wrapped.cause.message, 'ECONNREFUSED');
-    });
-});

package/dist/phases/app-store-generation/__tests__/agent.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Unit tests for app store agent result parsing.
- * Re-implements parseAppStoreResult inline (not exported from source).
- */
-export {};

package/dist/phases/app-store-generation/__tests__/agent.test.js

@@ -1,142 +0,0 @@
-/**
- * Unit tests for app store agent result parsing.
- * Re-implements parseAppStoreResult inline (not exported from source).
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-function parseAppStoreResult(responseText) {
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let jsonResult = null;
-        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-        if (jsonBlockMatch) {
-            jsonResult = JSON.parse(jsonBlockMatch[1]);
-        }
-        else {
-            jsonResult = JSON.parse(responseText);
-        }
-        if (jsonResult && jsonResult.app_store) {
-            return { appStore: jsonResult.app_store };
-        }
-        return { error: 'Invalid JSON structure: missing app_store key' };
-    }
-    catch (error) {
-        return {
-            error: `JSON parsing failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-void describe('parseAppStoreResult', () => {
-    void it('should parse valid JSON with app_store key', () => {
-        const input = JSON.stringify({
-            app_store: {
-                listings: { 'en-US': { app_name: 'Test App' } },
-                screenshots: [{ headline: 'Feature 1' }],
-            },
-        });
-        const result = parseAppStoreResult(input);
-        assert.ok(!result.error, 'should not have error');
-        assert.ok(result.appStore, 'should have appStore');
-        assert.strictEqual(result.appStore.listings['en-US'].app_name, 'Test App');
-        assert.strictEqual(result.appStore.screenshots.length, 1);
-    });
-    void it('should extract JSON from markdown code block', () => {
-        const input = `Here is the result:
-
-\`\`\`json
-{
-  "app_store": {
-    "listings": { "en-US": { "app_name": "My App" } },
-    "screenshots": []
-  }
-}
-\`\`\`
-
-That's the output.`;
-        const result = parseAppStoreResult(input);
-        assert.ok(!result.error, 'should not have error');
-        assert.strictEqual(result.appStore.listings['en-US'].app_name, 'My App');
-    });
-    void it('should return error for JSON without app_store key', () => {
-        const input = JSON.stringify({ listings: {}, screenshots: [] });
-        const result = parseAppStoreResult(input);
-        assert.ok(result.error, 'should have error');
-        assert.ok(result.error.includes('missing app_store key'), 'should mention missing key');
-    });
-    void it('should return error for invalid JSON', () => {
-        const result = parseAppStoreResult('not json at all');
-        assert.ok(result.error, 'should have error');
-        assert.ok(result.error.includes('JSON parsing failed'), 'should mention parsing failure');
-    });
-    void it('should return error for empty string', () => {
-        const result = parseAppStoreResult('');
-        assert.ok(result.error, 'should have error');
-    });
-    void it('should handle JSON with extra whitespace', () => {
-        const input = `  \n  { "app_store": { "listings": {} } }  \n  `;
-        const result = parseAppStoreResult(input);
-        assert.ok(!result.error, 'should not have error');
-        assert.ok(result.appStore, 'should have appStore');
-    });
-    void it('should parse nested app_store structure fully', () => {
-        const input = JSON.stringify({
-            app_store: {
-                listings: {
-                    'en-US': {
-                        app_name: 'Test',
-                        subtitle: 'Subtitle',
-                        description: 'Full desc',
-                        keywords: 'a,b,c',
-                        whats_new: 'New stuff',
-                    },
-                    'zh-CN': {
-                        app_name: '测试',
-                        description: '完整描述',
-                    },
-                },
-                screenshots: [
-                    {
-                        feature_highlight: 'Chat',
-                        headline: 'Real-time Chat',
-                        subheadline: 'Message anyone',
-                        background_gradient: 'linear-gradient(135deg, #667eea, #764ba2)',
-                        text_color: '#ffffff',
-                        device_frame: 'iphone',
-                        html_template: '<html><body>Mock</body></html>',
-                    },
-                    {
-                        feature_highlight: 'Dashboard',
-                        headline: 'Your Dashboard',
-                        device_frame: 'ipad',
-                        html_template: '<html><body>Dashboard</body></html>',
-                    },
-                ],
-            },
-        });
-        const result = parseAppStoreResult(input);
-        assert.ok(!result.error, 'should not have error');
-        assert.strictEqual(Object.keys(result.appStore.listings).length, 2, 'should have 2 locales');
-        assert.strictEqual(result.appStore.screenshots.length, 2, 'should have 2 screenshots');
-        assert.strictEqual(result.appStore.listings['zh-CN'].app_name, '测试');
-    });
-    void it('should handle code block with indented closing', () => {
-        const input = `\`\`\`json
-{ "app_store": { "listings": { "en-US": { "app_name": "Indented" } } } }
-  \`\`\``;
-        const result = parseAppStoreResult(input);
-        assert.ok(!result.error, 'should not have error');
-        assert.strictEqual(result.appStore.listings['en-US'].app_name, 'Indented');
-    });
-    void it('should prefer code block over surrounding text', () => {
-        const input = `Some preamble text
-
-\`\`\`json
-{ "app_store": { "listings": {} } }
-\`\`\`
-
-Some trailing text`;
-        const result = parseAppStoreResult(input);
-        assert.ok(!result.error, 'should extract from code block');
-        assert.ok(result.appStore, 'should have appStore from code block');
-    });
-});

package/dist/phases/app-store-generation/__tests__/context.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Unit tests for app store generation context formatting.
- */
-export {};