edsger 0.46.0 → 0.48.0

package/dist/services/phase-hooks/__tests__/hook-runner.test.js

@@ -0,0 +1,261 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { runHooksForPhase } from '../hook-runner.js';
+// ---- Helpers ----
+function makeBinding(overrides = {}) {
+    return {
+        id: 'hook-1',
+        product_id: 'prod-1',
+        phase: 'technical-design',
+        hook_point: 'after',
+        plugin_name: 'payload-cms',
+        skill_name: 'validate-schema',
+        on_failure: 'block',
+        config: {},
+        sort_order: 0,
+        enabled: true,
+        ...overrides,
+    };
+}
+function makeResult(binding, overrides = {}) {
+    return {
+        hookId: binding.id,
+        binding,
+        status: 'success',
+        message: 'OK',
+        duration_ms: 100,
+        ...overrides,
+    };
+}
+function makeContext(overrides = {}) {
+    return {
+        featureId: 'feat-1',
+        phase: 'technical-design',
+        hookPoint: 'after',
+        ...overrides,
+    };
+}
+function makeDeps(overrides = {}) {
+    return {
+        executeHook: (binding) => Promise.resolve(makeResult(binding)),
+        getCachedBindings: () => null,
+        getBindingsForPhase: () => [],
+        logHookEvent: () => Promise.resolve(),
+        ...overrides,
+    };
+}
+// ---- Tests ----
+void describe('runHooksForPhase', () => {
+    void it('returns empty results when no cached bindings', async () => {
+        const deps = makeDeps({ getCachedBindings: () => null });
+        const result = await runHooksForPhase(makeContext(), deps);
+        assert.deepStrictEqual(result, { results: [], blocked: false });
+    });
+    void it('returns empty results when cache has empty bindings', async () => {
+        const deps = makeDeps({
+            getCachedBindings: () => ({
+                productId: 'prod-1',
+                bindings: [],
+                fetchedAt: Date.now(),
+            }),
+        });
+        const result = await runHooksForPhase(makeContext(), deps);
+        assert.deepStrictEqual(result, { results: [], blocked: false });
+    });
+    void it('returns empty results when no bindings match the phase', async () => {
+        const cached = {
+            productId: 'prod-1',
+            bindings: [makeBinding({ phase: 'code-review' })],
+            fetchedAt: Date.now(),
+        };
+        const deps = makeDeps({
+            getCachedBindings: () => cached,
+            getBindingsForPhase: () => [], // no match
+        });
+        const result = await runHooksForPhase(makeContext(), deps);
+        assert.deepStrictEqual(result, { results: [], blocked: false });
+    });
+    void it('executes matching hooks and returns results', async () => {
+        const binding = makeBinding();
+        const cached = {
+            productId: 'prod-1',
+            bindings: [binding],
+            fetchedAt: Date.now(),
+        };
+        const executeCalls = [];
+        const deps = makeDeps({
+            getCachedBindings: () => cached,
+            getBindingsForPhase: () => [binding],
+            executeHook: (b) => {
+                executeCalls.push(b);
+                return Promise.resolve(makeResult(b));
+            },
+        });
+        const result = await runHooksForPhase(makeContext(), deps);
+        assert.strictEqual(result.results.length, 1);
+        assert.strictEqual(result.blocked, false);
+        assert.strictEqual(executeCalls.length, 1);
+        assert.strictEqual(executeCalls[0].id, 'hook-1');
+    });
+    void it('executes hooks in order (sequential)', async () => {
+        const b1 = makeBinding({ id: 'first', sort_order: 0 });
+        const b2 = makeBinding({ id: 'second', sort_order: 1 });
+        const cached = {
+            productId: 'prod-1',
+            bindings: [b1, b2],
+            fetchedAt: Date.now(),
+        };
+        const order = [];
+        const deps = makeDeps({
+            getCachedBindings: () => cached,
+            getBindingsForPhase: () => [b1, b2],
+            executeHook: (b) => {
+                order.push(b.id);
+                return Promise.resolve(makeResult(b));
+            },
+        });
+        await runHooksForPhase(makeContext(), deps);
+        assert.deepStrictEqual(order, ['first', 'second']);
+    });
+    void it('blocks on error with on_failure=block', async () => {
+        const b1 = makeBinding({ id: 'blocker', on_failure: 'block' });
+        const b2 = makeBinding({
+            id: 'after-blocker',
+            on_failure: 'block',
+            sort_order: 1,
+        });
+        const cached = {
+            productId: 'prod-1',
+            bindings: [b1, b2],
+            fetchedAt: Date.now(),
+        };
+        const executedIds = [];
+        const deps = makeDeps({
+            getCachedBindings: () => cached,
+            getBindingsForPhase: () => [b1, b2],
+            executeHook: (b) => {
+                executedIds.push(b.id);
+                if (b.id === 'blocker') {
+                    return Promise.resolve(makeResult(b, {
+                        status: 'error',
+                        message: 'Validation failed',
+                    }));
+                }
+                return Promise.resolve(makeResult(b));
+            },
+        });
+        const result = await runHooksForPhase(makeContext(), deps);
+        assert.strictEqual(result.blocked, true);
+        assert.strictEqual(result.results.length, 1); // only the blocker ran
+        assert.strictEqual(result.results[0].status, 'error');
+        assert.deepStrictEqual(executedIds, ['blocker']); // second hook never ran
+    });
+    void it('continues on error with on_failure=warn', async () => {
+        const b1 = makeBinding({ id: 'warner', on_failure: 'warn' });
+        const b2 = makeBinding({
+            id: 'after-warner',
+            on_failure: 'block',
+            sort_order: 1,
+        });
+        const cached = {
+            productId: 'prod-1',
+            bindings: [b1, b2],
+            fetchedAt: Date.now(),
+        };
+        const deps = makeDeps({
+            getCachedBindings: () => cached,
+            getBindingsForPhase: () => [b1, b2],
+            executeHook: (b) => {
+                if (b.id === 'warner') {
+                    return Promise.resolve(makeResult(b, {
+                        status: 'error',
+                        message: 'Non-critical issue',
+                    }));
+                }
+                return Promise.resolve(makeResult(b));
+            },
+        });
+        const result = await runHooksForPhase(makeContext(), deps);
+        assert.strictEqual(result.blocked, false);
+        assert.strictEqual(result.results.length, 2); // both ran
+        assert.strictEqual(result.results[0].status, 'error');
+        assert.strictEqual(result.results[1].status, 'success');
+    });
+    void it('continues silently on error with on_failure=skip', async () => {
+        const b1 = makeBinding({ id: 'skipper', on_failure: 'skip' });
+        const b2 = makeBinding({ id: 'after-skipper', sort_order: 1 });
+        const cached = {
+            productId: 'prod-1',
+            bindings: [b1, b2],
+            fetchedAt: Date.now(),
+        };
+        const deps = makeDeps({
+            getCachedBindings: () => cached,
+            getBindingsForPhase: () => [b1, b2],
+            executeHook: (b) => {
+                if (b.id === 'skipper') {
+                    return Promise.resolve(makeResult(b, { status: 'error', message: 'Ignored' }));
+                }
+                return Promise.resolve(makeResult(b));
+            },
+        });
+        const result = await runHooksForPhase(makeContext(), deps);
+        assert.strictEqual(result.blocked, false);
+        assert.strictEqual(result.results.length, 2);
+    });
+    void it('logs events for each hook execution', async () => {
+        const binding = makeBinding();
+        const cached = {
+            productId: 'prod-1',
+            bindings: [binding],
+            fetchedAt: Date.now(),
+        };
+        const logCalls = [];
+        const deps = makeDeps({
+            getCachedBindings: () => cached,
+            getBindingsForPhase: () => [binding],
+            logHookEvent: ({ result: r }) => {
+                logCalls.push(r.hookId);
+                return Promise.resolve();
+            },
+        });
+        await runHooksForPhase(makeContext(), deps);
+        assert.deepStrictEqual(logCalls, ['hook-1']);
+    });
+    void it('does not block when logHookEvent throws', async () => {
+        const binding = makeBinding();
+        const cached = {
+            productId: 'prod-1',
+            bindings: [binding],
+            fetchedAt: Date.now(),
+        };
+        const deps = makeDeps({
+            getCachedBindings: () => cached,
+            getBindingsForPhase: () => [binding],
+            logHookEvent: () => {
+                return Promise.reject(new Error('Logging failed'));
+            },
+        });
+        const result = await runHooksForPhase(makeContext(), deps);
+        // Should still succeed — logging failure is swallowed
+        assert.strictEqual(result.blocked, false);
+        assert.strictEqual(result.results.length, 1);
+    });
+    void it('handles skipped hooks (file not found) without blocking', async () => {
+        const binding = makeBinding({ on_failure: 'block' });
+        const cached = {
+            productId: 'prod-1',
+            bindings: [binding],
+            fetchedAt: Date.now(),
+        };
+        const deps = makeDeps({
+            getCachedBindings: () => cached,
+            getBindingsForPhase: () => [binding],
+            executeHook: (b) => Promise.resolve(makeResult(b, { status: 'skipped', message: 'Not found' })),
+        });
+        const result = await runHooksForPhase(makeContext(), deps);
+        // 'skipped' is not an error, so on_failure policy should not apply
+        assert.strictEqual(result.blocked, false);
+        assert.strictEqual(result.results[0].status, 'skipped');
+    });
+});

package/dist/services/phase-hooks/__tests__/plugin-loader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/phase-hooks/__tests__/plugin-loader.test.js

@@ -0,0 +1,158 @@
+import assert from 'node:assert';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, it } from 'node:test';
+import { getPluginCachePath, loadSkillFile, resolveSkillFilePaths, } from '../plugin-loader.js';
+// ---- resolveSkillFilePaths ----
+void describe('resolveSkillFilePaths', () => {
+    void it('returns skills/ path first, commands/ path second', () => {
+        const paths = resolveSkillFilePaths('payload-cms', 'validate-schema');
+        const cache = getPluginCachePath();
+        assert.strictEqual(paths.length, 2);
+        assert.strictEqual(paths[0], path.join(cache, 'payload-cms', 'skills', 'validate-schema', 'SKILL.md'));
+        assert.strictEqual(paths[1], path.join(cache, 'payload-cms', 'commands', 'validate-schema.md'));
+    });
+    void it('uses custom cacheDir when provided', () => {
+        const paths = resolveSkillFilePaths('my-plugin', 'my-skill', '/tmp/test-cache');
+        assert.ok(paths[0].startsWith('/tmp/test-cache/my-plugin'));
+    });
+});
+// ---- getPluginCachePath ----
+void describe('getPluginCachePath', () => {
+    void it('returns a path under home directory', () => {
+        const cachePath = getPluginCachePath();
+        assert.ok(cachePath.startsWith(os.homedir()));
+        assert.ok(cachePath.endsWith(path.join('.claude', 'plugins', 'cache')));
+    });
+});
+// ---- loadSkillFile ----
+void describe('loadSkillFile', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await import('node:fs/promises').then((fs) => fs.mkdtemp(path.join(os.tmpdir(), 'edsger-hook-test-')));
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    // -- Flat structure: cache/{pluginName}/skills/{skill}/SKILL.md --
+    void it('loads from flat structure', async () => {
+        const skillDir = path.join(tmpDir, 'my-plugin', 'skills', 'check');
+        await mkdir(skillDir, { recursive: true });
+        await writeFile(path.join(skillDir, 'SKILL.md'), '---\nmodel: sonnet\nmaxTurns: 10\n---\nCheck the code.');
+        const result = await loadSkillFile('my-plugin', 'check', false, tmpDir);
+        assert.ok(result);
+        assert.strictEqual(result.frontmatter.model, 'sonnet');
+        assert.strictEqual(result.frontmatter.maxTurns, 10);
+        assert.strictEqual(result.body, 'Check the code.');
+    });
+    // -- Nested structure: cache/{marketplace}/{plugin}/{version}/skills/... --
+    void it('loads from nested marketplace cache structure', async () => {
+        // Simulate: cache/edsger-local-ing/ing/1.0.0/skills/review-local/SKILL.md
+        const skillDir = path.join(tmpDir, 'edsger-local-ing', 'ing', '1.0.0', 'skills', 'review-local');
+        const manifestDir = path.join(tmpDir, 'edsger-local-ing', 'ing', '1.0.0', '.claude-plugin');
+        await mkdir(skillDir, { recursive: true });
+        await mkdir(manifestDir, { recursive: true });
+        await writeFile(path.join(skillDir, 'SKILL.md'), '---\ndescription: Review local changes\n---\nReview the diff.');
+        await writeFile(path.join(manifestDir, 'plugin.json'), JSON.stringify({ name: 'ing', version: '1.0.0' }));
+        // loadSkillFile('ing', 'review-local') should find it via manifest name match
+        const result = await loadSkillFile('ing', 'review-local', false, tmpDir);
+        assert.ok(result, 'Should find skill in nested structure');
+        assert.strictEqual(result.frontmatter.description, 'Review local changes');
+        assert.strictEqual(result.body, 'Review the diff.');
+    });
+    // -- Fallback to commands/ --
+    void it('falls back to commands/ when skills/ does not exist', async () => {
+        const commandsDir = path.join(tmpDir, 'legacy-plugin', 'commands');
+        await mkdir(commandsDir, { recursive: true });
+        await writeFile(path.join(commandsDir, 'deploy.md'), '---\ndescription: Deploy to staging\n---\nDeploy the branch.');
+        const result = await loadSkillFile('legacy-plugin', 'deploy', false, tmpDir);
+        assert.ok(result);
+        assert.strictEqual(result.frontmatter.description, 'Deploy to staging');
+    });
+    // -- Prefers skills/ over commands/ --
+    void it('prefers skills/ over commands/ when both exist', async () => {
+        const skillDir = path.join(tmpDir, 'dual-plugin', 'skills', 'check');
+        const cmdDir = path.join(tmpDir, 'dual-plugin', 'commands');
+        await mkdir(skillDir, { recursive: true });
+        await mkdir(cmdDir, { recursive: true });
+        await writeFile(path.join(skillDir, 'SKILL.md'), '---\nsource: skill\n---\nFrom skills/');
+        await writeFile(path.join(cmdDir, 'check.md'), '---\nsource: command\n---\nFrom commands/');
+        const result = await loadSkillFile('dual-plugin', 'check', false, tmpDir);
+        assert.ok(result);
+        assert.strictEqual(result.frontmatter.source, 'skill');
+    });
+    // -- Edge cases --
+    void it('handles SKILL.md with no frontmatter', async () => {
+        const skillDir = path.join(tmpDir, 'bare', 'skills', 'simple');
+        await mkdir(skillDir, { recursive: true });
+        await writeFile(path.join(skillDir, 'SKILL.md'), 'Plain instructions.');
+        const result = await loadSkillFile('bare', 'simple', false, tmpDir);
+        assert.ok(result);
+        assert.deepStrictEqual(result.frontmatter, {});
+        assert.strictEqual(result.body, 'Plain instructions.');
+    });
+    void it('handles SKILL.md with empty frontmatter', async () => {
+        const skillDir = path.join(tmpDir, 'empty-fm', 'skills', 'e');
+        await mkdir(skillDir, { recursive: true });
+        await writeFile(path.join(skillDir, 'SKILL.md'), '---\n---\nBody only.');
+        const result = await loadSkillFile('empty-fm', 'e', false, tmpDir);
+        assert.ok(result);
+        assert.deepStrictEqual(result.frontmatter, {});
+        assert.strictEqual(result.body, 'Body only.');
+    });
+    void it('returns null when plugin does not exist', async () => {
+        const result = await loadSkillFile('nonexistent', 'nope', false, tmpDir);
+        assert.strictEqual(result, null);
+    });
+    void it('trims body whitespace', async () => {
+        const skillDir = path.join(tmpDir, 'trim', 'skills', 'padded');
+        await mkdir(skillDir, { recursive: true });
+        await writeFile(path.join(skillDir, 'SKILL.md'), '---\n---\n\n  Padded.  \n\n');
+        const result = await loadSkillFile('trim', 'padded', false, tmpDir);
+        assert.ok(result);
+        assert.strictEqual(result.body, 'Padded.');
+    });
+    // -- Nested structure without manifest (match by directory name) --
+    void it('loads from nested structure when plugin dir name matches', async () => {
+        // cache/some-marketplace/my-tool/2.0.0/skills/scan/SKILL.md
+        const skillDir = path.join(tmpDir, 'some-marketplace', 'my-tool', '2.0.0', 'skills', 'scan');
+        await mkdir(skillDir, { recursive: true });
+        await writeFile(path.join(skillDir, 'SKILL.md'), '---\n---\nScan it.');
+        // Should find via subdirectory name matching pluginName
+        const result = await loadSkillFile('my-tool', 'scan', false, tmpDir);
+        assert.ok(result, 'Should find skill by directory name match');
+        assert.strictEqual(result.body, 'Scan it.');
+    });
+    // -- Nested structure: match by manifest name (dir name differs) --
+    void it('loads via manifest name when cache dir name differs from plugin name', async () => {
+        // cache/random-key/1.0.0/skills/deploy/SKILL.md
+        // cache/random-key/1.0.0/.claude-plugin/plugin.json → { "name": "deployer" }
+        // loadSkillFile('deployer', 'deploy') should find it by scanning manifest
+        const pluginRoot = path.join(tmpDir, 'random-key', '1.0.0');
+        const skillDir = path.join(pluginRoot, 'skills', 'deploy');
+        const manifestDir = path.join(pluginRoot, '.claude-plugin');
+        await mkdir(skillDir, { recursive: true });
+        await mkdir(manifestDir, { recursive: true });
+        await writeFile(path.join(skillDir, 'SKILL.md'), '---\ndescription: Deploy app\n---\nRun deploy.');
+        await writeFile(path.join(manifestDir, 'plugin.json'), JSON.stringify({ name: 'deployer', version: '1.0.0' }));
+        // 'deployer' doesn't appear in any directory name — only in manifest
+        const result = await loadSkillFile('deployer', 'deploy', false, tmpDir);
+        assert.ok(result, 'Should find skill via manifest name scan');
+        assert.strictEqual(result.frontmatter.description, 'Deploy app');
+        assert.strictEqual(result.body, 'Run deploy.');
+    });
+    void it('does not match manifest name of a different plugin', async () => {
+        // cache/some-key/1.0.0/.claude-plugin/plugin.json → { "name": "other-plugin" }
+        const pluginRoot = path.join(tmpDir, 'some-key', '1.0.0');
+        const skillDir = path.join(pluginRoot, 'skills', 'action');
+        const manifestDir = path.join(pluginRoot, '.claude-plugin');
+        await mkdir(skillDir, { recursive: true });
+        await mkdir(manifestDir, { recursive: true });
+        await writeFile(path.join(skillDir, 'SKILL.md'), '---\n---\nDo something.');
+        await writeFile(path.join(manifestDir, 'plugin.json'), JSON.stringify({ name: 'other-plugin' }));
+        // Looking for 'wrong-name' — should NOT match 'other-plugin'
+        const result = await loadSkillFile('wrong-name', 'action', false, tmpDir);
+        assert.strictEqual(result, null);
+    });
+});

package/dist/services/video/__tests__/video-pipeline.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Unit tests for the video generation pipeline.
+ * Tests pure logic functions that don't require external dependencies
+ * (Playwright, ffmpeg, TTS APIs).
+ */
+export {};

package/dist/services/video/__tests__/video-pipeline.test.js

@@ -0,0 +1,249 @@
+/**
+ * Unit tests for the video generation pipeline.
+ * Tests pure logic functions that don't require external dependencies
+ * (Playwright, ffmpeg, TTS APIs).
+ */
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+// ============================================================
+// HTML Template Validation (inline re-implementation for testing)
+// ============================================================
+function escapeHtml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+function validateHtmlTemplate(html) {
+    if (!html || html.trim().length < 50) {
+        return 'fallback';
+    }
+    const lower = html.toLowerCase();
+    if (!lower.includes('<html') &&
+        !lower.includes('<body') &&
+        !lower.includes('<div')) {
+        return 'fallback';
+    }
+    if (!lower.includes('<html')) {
+        return 'wrapped';
+    }
+    return 'valid';
+}
+void describe('HTML Template Validation', () => {
+    void it('should reject empty templates', () => {
+        assert.strictEqual(validateHtmlTemplate(''), 'fallback');
+        assert.strictEqual(validateHtmlTemplate(null), 'fallback');
+        assert.strictEqual(validateHtmlTemplate(undefined), 'fallback');
+    });
+    void it('should reject templates shorter than 50 characters', () => {
+        assert.strictEqual(validateHtmlTemplate('<div>short</div>'), 'fallback');
+        assert.strictEqual(validateHtmlTemplate('hello world'), 'fallback');
+    });
+    void it('should reject templates without HTML structure', () => {
+        const longText = 'This is just plain text without any HTML tags at all. '.repeat(3);
+        assert.strictEqual(validateHtmlTemplate(longText), 'fallback');
+    });
+    void it('should wrap partial HTML (has div but no html tag)', () => {
+        const partial = '<div class="container"><h1>Hello World</h1><p>This is a longer paragraph with enough content.</p></div>';
+        assert.strictEqual(validateHtmlTemplate(partial), 'wrapped');
+    });
+    void it('should accept complete HTML documents', () => {
+        const full = '<html><head><style>body{margin:0}</style></head><body><div>Content that is long enough</div></body></html>';
+        assert.strictEqual(validateHtmlTemplate(full), 'valid');
+    });
+    void it('should accept HTML with body but no html tag as wrapped', () => {
+        const bodyOnly = '<body><div class="app"><h1>Dashboard</h1><p>Metrics and analytics overview panel</p></div></body>';
+        assert.strictEqual(validateHtmlTemplate(bodyOnly), 'wrapped');
+    });
+});
+void describe('HTML Escaping', () => {
+    void it('should escape all dangerous characters', () => {
+        assert.strictEqual(escapeHtml('<script>alert("xss")</script>'), '&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;');
+    });
+    void it('should escape ampersands', () => {
+        assert.strictEqual(escapeHtml('A & B'), 'A &amp; B');
+    });
+    void it('should escape single quotes', () => {
+        assert.strictEqual(escapeHtml("it's"), 'it&#39;s');
+    });
+    void it('should handle empty strings', () => {
+        assert.strictEqual(escapeHtml(''), '');
+    });
+    void it('should not double-escape already escaped content', () => {
+        // First escape
+        const once = escapeHtml('<div>');
+        assert.strictEqual(once, '&lt;div&gt;');
+        // Double escaping should escape the ampersands
+        const twice = escapeHtml(once);
+        assert.strictEqual(twice, '&amp;lt;div&amp;gt;');
+    });
+});
+// ============================================================
+// Retry Logic
+// ============================================================
+void describe('Retry Backoff Calculation', () => {
+    // Re-implement the backoff formula for testing
+    function calculateBackoff(attempt, baseDelayMs) {
+        return baseDelayMs * Math.pow(2, attempt);
+    }
+    void it('should use exponential backoff', () => {
+        assert.strictEqual(calculateBackoff(0, 1000), 1000);
+        assert.strictEqual(calculateBackoff(1, 1000), 2000);
+        assert.strictEqual(calculateBackoff(2, 1000), 4000);
+        assert.strictEqual(calculateBackoff(3, 1000), 8000);
+    });
+    void it('should respect base delay', () => {
+        assert.strictEqual(calculateBackoff(0, 500), 500);
+        assert.strictEqual(calculateBackoff(1, 500), 1000);
+        assert.strictEqual(calculateBackoff(2, 500), 2000);
+    });
+});
+// ============================================================
+// Device Frame Auto-Detection
+// ============================================================
+void describe('Device Frame Auto-Detection', () => {
+    function autoDetectDeviceFrame(width, height) {
+        const aspectRatio = width / height;
+        if (aspectRatio < 0.7) {
+            return 'iphone';
+        }
+        return 'browser';
+    }
+    void it('should detect portrait mobile as iphone', () => {
+        assert.strictEqual(autoDetectDeviceFrame(390, 844), 'iphone');
+        assert.strictEqual(autoDetectDeviceFrame(375, 812), 'iphone');
+    });
+    void it('should detect landscape desktop as browser', () => {
+        assert.strictEqual(autoDetectDeviceFrame(1280, 720), 'browser');
+        assert.strictEqual(autoDetectDeviceFrame(1280, 800), 'browser');
+        assert.strictEqual(autoDetectDeviceFrame(1920, 1080), 'browser');
+    });
+    void it('should detect square-ish ratios as browser', () => {
+        assert.strictEqual(autoDetectDeviceFrame(800, 800), 'browser');
+        assert.strictEqual(autoDetectDeviceFrame(1024, 768), 'browser');
+    });
+});
+// ============================================================
+// Video Plan Extraction
+// ============================================================
+void describe('Video Plan Extraction', () => {
+    function extractVideoPlans(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    contentSuggestions) {
+        const plans = [];
+        for (let i = 0; i < contentSuggestions.length; i++) {
+            const suggestion = contentSuggestions[i];
+            const videoPlan = suggestion.video_plan;
+            if (videoPlan &&
+                videoPlan.should_generate_video &&
+                videoPlan.scenes?.length > 0) {
+                plans.push({ index: i, shouldGenerate: true });
+            }
+        }
+        return plans;
+    }
+    void it('should extract suggestions with video plans', () => {
+        const suggestions = [
+            {
+                title: 'Blog Post',
+                video_plan: { should_generate_video: false, scenes: [] },
+            },
+            {
+                title: 'Demo Video',
+                video_plan: { should_generate_video: true, scenes: [{ order: 1 }] },
+            },
+            { title: 'Tweet', video_plan: null },
+        ];
+        const plans = extractVideoPlans(suggestions);
+        assert.strictEqual(plans.length, 1);
+        assert.strictEqual(plans[0].index, 1);
+    });
+    void it('should ignore suggestions with empty scenes', () => {
+        const suggestions = [
+            {
+                title: 'Video',
+                video_plan: { should_generate_video: true, scenes: [] },
+            },
+        ];
+        const plans = extractVideoPlans(suggestions);
+        assert.strictEqual(plans.length, 0);
+    });
+    void it('should handle suggestions with no video plan', () => {
+        const suggestions = [
+            { title: 'Post 1' },
+            { title: 'Post 2', video_plan: undefined },
+        ];
+        const plans = extractVideoPlans(suggestions);
+        assert.strictEqual(plans.length, 0);
+    });
+});
+// ============================================================
+// Concurrency Limiter
+// ============================================================
+void describe('Concurrency Limiter', () => {
+    async function runWithConcurrencyLimit(tasks, limit) {
+        const results = new Array(tasks.length);
+        let nextIndex = 0;
+        async function runNext() {
+            while (nextIndex < tasks.length) {
+                const i = nextIndex++;
+                try {
+                    const value = await tasks[i]();
+                    results[i] = { status: 'fulfilled', value };
+                }
+                catch (reason) {
+                    results[i] = { status: 'rejected', reason };
+                }
+            }
+        }
+        const workers = Array.from({ length: Math.min(limit, tasks.length) }, () => runNext());
+        await Promise.all(workers);
+        return results;
+    }
+    void it('should process all tasks and preserve order', async () => {
+        const tasks = [
+            () => Promise.resolve('a'),
+            () => Promise.resolve('b'),
+            () => Promise.resolve('c'),
+        ];
+        const results = await runWithConcurrencyLimit(tasks, 2);
+        assert.strictEqual(results.length, 3);
+        assert.strictEqual(results[0].status, 'fulfilled');
+        assert.strictEqual(results[0].value, 'a');
+        assert.strictEqual(results[2].value, 'c');
+    });
+    void it('should handle rejected tasks without stopping others', async () => {
+        const tasks = [
+            () => Promise.resolve('ok'),
+            () => Promise.reject(new Error('fail')),
+            () => Promise.resolve('also ok'),
+        ];
+        const results = await runWithConcurrencyLimit(tasks, 2);
+        assert.strictEqual(results[0].status, 'fulfilled');
+        assert.strictEqual(results[1].status, 'rejected');
+        assert.strictEqual(results[2].status, 'fulfilled');
+    });
+    void it('should respect concurrency limit', async () => {
+        let maxConcurrent = 0;
+        let currentConcurrent = 0;
+        const tasks = Array.from({ length: 6 }, (_, i) => async () => {
+            currentConcurrent++;
+            if (currentConcurrent > maxConcurrent) {
+                maxConcurrent = currentConcurrent;
+            }
+            await new Promise((r) => {
+                setTimeout(r, 10);
+            });
+            currentConcurrent--;
+            return i;
+        });
+        await runWithConcurrencyLimit(tasks, 2);
+        assert.ok(maxConcurrent <= 2, `Max concurrent was ${maxConcurrent}, expected <= 2`);
+    });
+    void it('should handle empty task list', async () => {
+        const results = await runWithConcurrencyLimit([], 5);
+        assert.strictEqual(results.length, 0);
+    });
+});