edsger 0.45.0 → 0.46.0

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

@@ -1,158 +0,0 @@
-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

@@ -1,6 +0,0 @@
-/**
- * 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

@@ -1,249 +0,0 @@
-/**
- * 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);
-    });
-});

package/dist/workspace/__tests__/workspace-manager.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * Unit tests for the pure helpers inside workspace-manager.
- *
- * syncRepoToRef / cloneFeatureRepo shell out to git and are exercised
- * end-to-end; only the validator is cheap to unit-test here.
- */
-export {};

package/dist/workspace/__tests__/workspace-manager.test.js

@@ -1,52 +0,0 @@
-/**
- * Unit tests for the pure helpers inside workspace-manager.
- *
- * syncRepoToRef / cloneFeatureRepo shell out to git and are exercised
- * end-to-end; only the validator is cheap to unit-test here.
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { isSafeGitRef } from '../workspace-manager.js';
-void describe('isSafeGitRef', () => {
-    void it('accepts common release / branch names', () => {
-        assert.strictEqual(isSafeGitRef('main'), true);
-        assert.strictEqual(isSafeGitRef('develop'), true);
-        assert.strictEqual(isSafeGitRef('v1.2.3'), true);
-        assert.strictEqual(isSafeGitRef('2024.01.15'), true);
-        assert.strictEqual(isSafeGitRef('release/2.0'), true);
-        assert.strictEqual(isSafeGitRef('v1.0.0-rc.1'), true);
-        assert.strictEqual(isSafeGitRef('v2@stable'), true);
-        assert.strictEqual(isSafeGitRef('feature/user-auth_v2'), true);
-    });
-    void it('rejects empty / overlong input', () => {
-        assert.strictEqual(isSafeGitRef(''), false);
-        assert.strictEqual(isSafeGitRef('x'.repeat(101)), false);
-    });
-    void it('rejects whitespace', () => {
-        assert.strictEqual(isSafeGitRef('v 1.0'), false);
-        assert.strictEqual(isSafeGitRef('main\n'), false);
-        assert.strictEqual(isSafeGitRef('\tmain'), false);
-    });
-    void it('rejects shell metacharacters', () => {
-        assert.strictEqual(isSafeGitRef('v1;rm -rf /'), false);
-        assert.strictEqual(isSafeGitRef('v1$PATH'), false);
-        assert.strictEqual(isSafeGitRef('v1`id`'), false);
-        assert.strictEqual(isSafeGitRef('v1|less'), false);
-        assert.strictEqual(isSafeGitRef('v1>out'), false);
-        assert.strictEqual(isSafeGitRef('v1*'), false);
-    });
-    void it('rejects refs that would confuse git itself', () => {
-        assert.strictEqual(isSafeGitRef('.hidden'), false);
-        assert.strictEqual(isSafeGitRef('-foo'), false);
-        assert.strictEqual(isSafeGitRef('v2..rc'), false);
-        assert.strictEqual(isSafeGitRef('HEAD@{1}'), false);
-    });
-    void it('rejects non-string input defensively', () => {
-        // @ts-expect-error testing runtime guard
-        assert.strictEqual(isSafeGitRef(null), false);
-        // @ts-expect-error testing runtime guard
-        assert.strictEqual(isSafeGitRef(undefined), false);
-        // @ts-expect-error testing runtime guard
-        assert.strictEqual(isSafeGitRef(123), false);
-    });
-});