edsger 0.36.2 → 0.37.0

package/dist/services/feature-branches.js

@@ -0,0 +1,205 @@
+/**
+ * Feature Branches service for pipeline integration
+ * Allows phases to manage feature branches via MCP
+ */
+import { callMcpEndpoint } from '../api/mcp-client.js';
+/**
+ * List all branches for a feature
+ */
+export async function getFeatureBranches(options) {
+    const { featureId, verbose } = options;
+    if (verbose) {
+        console.log(`📋 Fetching feature branches for feature: ${featureId}`);
+    }
+    const result = (await callMcpEndpoint('feature_branches/list', {
+        feature_id: featureId,
+    }));
+    const branches = result?.feature_branches || [];
+    if (verbose) {
+        console.log(`✅ Found ${branches.length} feature branches`);
+    }
+    return branches;
+}
+/**
+ * Get the current active branch for a feature
+ */
+export async function getCurrentBranch(options) {
+    const { featureId, verbose } = options;
+    if (verbose) {
+        console.log(`📋 Getting current branch for feature: ${featureId}`);
+    }
+    const result = (await callMcpEndpoint('feature_branches/current', {
+        feature_id: featureId,
+    }));
+    return result?.current_branch || null;
+}
+/**
+ * Create feature branches
+ */
+export async function createFeatureBranches(options, branches) {
+    const { featureId, verbose } = options;
+    if (verbose) {
+        console.log(`📋 Creating ${branches.length} feature branches for feature: ${featureId}`);
+    }
+    const result = (await callMcpEndpoint('feature_branches/create', {
+        feature_id: featureId,
+        branches: branches,
+    }));
+    const createdBranches = result?.created_branches || [];
+    if (verbose) {
+        console.log(`✅ Created ${createdBranches.length} feature branches`);
+        createdBranches.forEach((b, idx) => {
+            console.log(`   ${idx + 1}. ${b.name} (status: ${b.status})`);
+        });
+    }
+    return createdBranches;
+}
+/**
+ * Update a feature branch
+ */
+export async function updateFeatureBranch(branchId, updates, verbose) {
+    if (verbose) {
+        console.log(`📋 Updating feature branch: ${branchId}`);
+    }
+    const result = (await callMcpEndpoint('feature_branches/update', {
+        branch_id: branchId,
+        ...updates,
+    }));
+    if (verbose) {
+        console.log(`✅ Feature branch updated successfully`);
+    }
+    return result?.feature_branch;
+}
+/**
+ * Clear all branches for a feature (used before re-planning)
+ */
+export async function clearFeatureBranches(options, force = false) {
+    const { featureId, verbose } = options;
+    if (verbose) {
+        console.log(`📋 Clearing feature branches for feature: ${featureId}`);
+    }
+    const result = (await callMcpEndpoint('feature_branches/clear', {
+        feature_id: featureId,
+        force: force,
+    }));
+    const deletedCount = result?.deleted_count || 0;
+    if (verbose) {
+        console.log(`✅ Cleared ${deletedCount} feature branches`);
+    }
+    return deletedCount;
+}
+/**
+ * Format feature branches for context (to include in prompts)
+ */
+export function formatBranchesForContext(branches) {
+    if (!branches || branches.length === 0) {
+        return 'No feature branches defined yet.';
+    }
+    const branchList = branches
+        .map((b, idx) => {
+        const statusEmoji = b.status === 'merged'
+            ? '✅'
+            : b.status === 'in_progress'
+                ? '🔄'
+                : b.status === 'ready_for_review'
+                    ? '👀'
+                    : b.status === 'closed'
+                        ? '❌'
+                        : '⏳';
+        return `${idx + 1}. **${b.name}** ${statusEmoji}
+   - Status: ${b.status}
+   - Branch: ${b.branch_name || 'Not created'}
+   - PR: ${b.pull_request_url || 'Not created'}
+   - Description: ${b.description || 'No description'}`;
+    })
+        .join('\n\n');
+    return `# Feature Branches
+
+${branchList}
+
+Total: ${branches.length} branches
+Merged: ${branches.filter((b) => b.status === 'merged').length}
+In Progress: ${branches.filter((b) => b.status === 'in_progress').length}
+Pending: ${branches.filter((b) => b.status === 'pending').length}`;
+}
+/**
+ * Check if feature has multiple branches planned
+ */
+export async function hasMultipleBranches(options) {
+    const branches = await getFeatureBranches(options);
+    return branches.length > 1;
+}
+/**
+ * Get next pending branch to work on
+ */
+export async function getNextPendingBranch(options) {
+    const branches = await getFeatureBranches(options);
+    return branches.find((b) => b.status === 'pending') || null;
+}
+/**
+ * Check if all branches are completed
+ */
+export async function allBranchesCompleted(options) {
+    const branches = await getFeatureBranches(options);
+    if (branches.length === 0)
+        return true;
+    return branches.every((b) => b.status === 'merged' || b.status === 'closed');
+}
+/**
+ * Get the base branch information for a feature branch.
+ * Returns:
+ * - If base_branch_id is set and that branch is merged: use main
+ * - If base_branch_id is set and that branch is not merged: use that branch's branch_name
+ * - If base_branch_id is null: use main
+ */
+export async function getBaseBranchInfo(branch, allBranches, mainBranch = 'main') {
+    // No base branch - start from main
+    if (!branch.base_branch_id) {
+        return {
+            baseBranch: mainBranch,
+            needsRebase: false,
+            baseBranchMerged: true,
+        };
+    }
+    // Find the base branch
+    const baseBranch = allBranches.find((b) => b.id === branch.base_branch_id);
+    if (!baseBranch) {
+        // Base branch not found - fall back to main
+        return {
+            baseBranch: mainBranch,
+            needsRebase: false,
+            baseBranchMerged: true,
+        };
+    }
+    // Check if base branch is merged
+    if (baseBranch.status === 'merged') {
+        // Base branch is merged to main - we should base on main and rebase if needed
+        return { baseBranch: mainBranch, needsRebase: true, baseBranchMerged: true };
+    }
+    // Base branch is not merged - we should base on that branch
+    if (!baseBranch.branch_name) {
+        // Base branch doesn't have a git branch yet - fall back to main
+        return {
+            baseBranch: mainBranch,
+            needsRebase: false,
+            baseBranchMerged: false,
+        };
+    }
+    return {
+        baseBranch: baseBranch.branch_name,
+        needsRebase: false,
+        baseBranchMerged: false,
+    };
+}
+/**
+ * Get branch by ID
+ */
+export async function getBranchById(branchId, verbose) {
+    if (verbose) {
+        console.log(`📋 Fetching feature branch: ${branchId}`);
+    }
+    const result = (await callMcpEndpoint('feature_branches/get', {
+        branch_id: branchId,
+    }));
+    return result?.feature_branch || null;
+}

package/dist/services/video/device-frames.d.ts

@@ -3,7 +3,7 @@
  * Wraps raw screenshots in realistic device mockups (MacBook, iPhone, browser window).
  */
 /** Supported device frame types */
-export type DeviceFrameType = 'macbook' | 'iphone' | 'browser' | 'none';
+export type DeviceFrameType = 'macbook' | 'iphone' | 'ipad' | 'browser' | 'none';
 /** Device presets with recommended viewport sizes */
 export declare const DEVICE_PRESETS: Record<Exclude<DeviceFrameType, 'none'>, {
     viewportWidth: number;

package/dist/services/video/device-frames.js

@@ -6,6 +6,7 @@
 export const DEVICE_PRESETS = {
     macbook: { viewportWidth: 1280, viewportHeight: 800, label: 'MacBook Pro' },
     iphone: { viewportWidth: 390, viewportHeight: 844, label: 'iPhone 15 Pro' },
+    ipad: { viewportWidth: 1024, viewportHeight: 1366, label: 'iPad Pro 12.9"' },
     browser: {
         viewportWidth: 1280,
         viewportHeight: 720,
@@ -27,6 +28,8 @@ export function generateDeviceFrameHtml(screenshotDataUrl, deviceType, options)
             return generateMacBookFrame(screenshotDataUrl, background, shadow, canvasWidth ?? 1600, canvasHeight ?? 1000);
         case 'iphone':
             return generateIPhoneFrame(screenshotDataUrl, background, shadow, canvasWidth ?? 800, canvasHeight ?? 1200);
+        case 'ipad':
+            return generateIPadFrame(screenshotDataUrl, background, shadow, canvasWidth ?? 900, canvasHeight ?? 1200);
         case 'browser':
             return generateBrowserFrame({
                 screenshotDataUrl,
@@ -59,7 +62,7 @@ function generateMacBookFrame(screenshotDataUrl, background, shadow, canvasWidth
   }
   .macbook {
     position: relative;
-    width: 1340px;
+    width: 84%;
   }
   .screen {
     background: #1a1a1a;
@@ -148,7 +151,7 @@ function generateIPhoneFrame(screenshotDataUrl, background, shadow, canvasWidth,
   }
   .iphone {
     position: relative;
-    width: 430px;
+    width: 86%;
     background: #1a1a1a;
     border-radius: 54px;
     padding: 16px;
@@ -246,6 +249,81 @@ function generateIPhoneFrame(screenshotDataUrl, background, shadow, canvasWidth,
 </body>
 </html>`;
 }
+function generateIPadFrame(screenshotDataUrl, background, shadow, canvasWidth, canvasHeight) {
+    return `<!DOCTYPE html>
+<html>
+<head>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body {
+    width: ${canvasWidth}px;
+    height: ${canvasHeight}px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: ${background};
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+    overflow: hidden;
+  }
+  .ipad {
+    position: relative;
+    width: 78%;
+    background: #1a1a1a;
+    border-radius: 28px;
+    padding: 14px;
+    ${shadow ? 'box-shadow: 0 30px 80px rgba(0,0,0,0.5), inset 0 0 0 2px #333;' : ''}
+  }
+  .ipad-inner {
+    background: #000;
+    border-radius: 18px;
+    overflow: hidden;
+    position: relative;
+  }
+  .front-camera {
+    position: absolute;
+    top: 8px;
+    left: 50%;
+    transform: translateX(-50%);
+    width: 8px;
+    height: 8px;
+    background: #1a1a2a;
+    border-radius: 50%;
+    z-index: 10;
+  }
+  .screen-content {
+    position: relative;
+  }
+  .screen-content img {
+    width: 100%;
+    display: block;
+    border-radius: 18px;
+  }
+  .home-indicator {
+    position: absolute;
+    bottom: 6px;
+    left: 50%;
+    transform: translateX(-50%);
+    width: 160px;
+    height: 5px;
+    background: rgba(255,255,255,0.3);
+    border-radius: 3px;
+    z-index: 10;
+  }
+</style>
+</head>
+<body>
+  <div class="ipad">
+    <div class="ipad-inner">
+      <div class="front-camera"></div>
+      <div class="screen-content">
+        <img src="${screenshotDataUrl}" alt="screenshot" />
+      </div>
+      <div class="home-indicator"></div>
+    </div>
+  </div>
+</body>
+</html>`;
+}
 function generateBrowserFrame(opts) {
     const { screenshotDataUrl, background, shadow, title, url, canvasWidth, canvasHeight, } = opts;
     return `<!DOCTYPE html>
@@ -264,7 +342,7 @@ function generateBrowserFrame(opts) {
     overflow: hidden;
   }
   .browser {
-    width: 1400px;
+    width: 88%;
     background: #fff;
     border-radius: 12px;
     overflow: hidden;

package/dist/services/video/index.d.ts

@@ -46,7 +46,7 @@ export interface VideoGenerationOptions {
 }
 /**
  * Check system dependencies for video generation.
- * Returns a list of missing dependencies.
+ * Auto-installs Playwright if missing. Returns a list of still-missing dependencies.
  */
 export declare function checkVideoDependencies(): Promise<string[]>;
 /**

package/dist/services/video/index.js

@@ -5,22 +5,28 @@
 import { mkdir, rm } from 'fs/promises';
 import { join } from 'path';
 import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
+import { ensureFFmpeg, ensurePlaywright } from '../../utils/validation.js';
 import { captureStaticScreenshots, getVideoTempDir, isPlaywrightAvailable, } from './screenshot-generator.js';
 import { generateNarration } from './tts-generator.js';
 import { assembleVideo, isFfmpegAvailable } from './video-assembler.js';
 import { saveVideoMetadata, uploadGrowthVideo } from './video-uploader.js';
 /**
  * Check system dependencies for video generation.
- * Returns a list of missing dependencies.
+ * Auto-installs Playwright if missing. Returns a list of still-missing dependencies.
  */
 export async function checkVideoDependencies() {
     const missing = [];
-    if (!isFfmpegAvailable()) {
-        missing.push('ffmpeg (install: brew install ffmpeg / apt install ffmpeg)');
+    try {
+        ensureFFmpeg(isFfmpegAvailable);
+    }
+    catch {
+        missing.push('ffmpeg (auto-install failed — install manually: brew install ffmpeg / apt install ffmpeg)');
+    }
+    try {
+        await ensurePlaywright(isPlaywrightAvailable);
     }
-    const playwrightReady = await isPlaywrightAvailable();
-    if (!playwrightReady) {
-        missing.push('playwright (install: npm install playwright && npx playwright install chromium)');
+    catch {
+        missing.push('playwright (auto-install failed — run: npm install playwright && npx playwright install chromium)');
     }
     return missing;
 }

package/dist/services/video/screenshot-generator.js

@@ -7,6 +7,7 @@ import { mkdir, readFile } from 'fs/promises';
 import { tmpdir } from 'os';
 import { join } from 'path';
 import { logError, logInfo, logWarning } from '../../utils/logger.js';
+import { ensurePlaywright } from '../../utils/validation.js';
 import { generateDeviceFrameHtml, } from './device-frames.js';
 /**
  * Dynamically load Playwright's chromium launcher.
@@ -101,10 +102,8 @@ async function applyDeviceFrame(screenshotPath, scene, browser, verbose) {
  * Requires Playwright to be installed: npm install playwright
  */
 export async function captureScreenshots(scenes, options, verbose) {
-    const chromium = await loadChromium();
-    if (!chromium) {
-        throw new Error('Playwright is not installed. Install it with: npm install playwright && npx playwright install chromium');
-    }
+    await ensurePlaywright(isPlaywrightAvailable);
+    const chromium = (await loadChromium());
     const { baseUrl, outputDir, viewportWidth = 1280, viewportHeight = 720, fullPage = false, } = options;
     // Ensure output directory exists
     await mkdir(outputDir, { recursive: true });
@@ -194,10 +193,8 @@ export async function captureScreenshots(scenes, options, verbose) {
  * Creates screenshots from pre-built HTML templates with mock data.
  */
 export async function captureStaticScreenshots(scenes, outputDir, htmlTemplates, verbose) {
-    const chromium = await loadChromium();
-    if (!chromium) {
-        throw new Error('Playwright is not installed. Install it with: npm install playwright && npx playwright install chromium');
-    }
+    await ensurePlaywright(isPlaywrightAvailable);
+    const chromium = (await loadChromium());
     await mkdir(outputDir, { recursive: true });
     if (verbose) {
         logInfo(`Rendering ${scenes.length} static HTML scenes`);

package/dist/services/video/video-assembler.js

@@ -6,6 +6,7 @@ import { execFileSync, execSync } from 'child_process';
 import { mkdir, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { logError, logInfo, logWarning } from '../../utils/logger.js';
+import { ensureFFmpeg } from '../../utils/validation.js';
 import { getAudioDuration } from './tts-generator.js';
 /**
  * Check if ffmpeg is available on the system
@@ -146,12 +147,7 @@ async function simpleConcatenate(segmentPaths, outputPath, tempDir, verbose) {
  */
 // eslint-disable-next-line complexity -- sequential video assembly with scene processing and ffmpeg orchestration
 export async function assembleVideo(scenes, audioFiles, options, verbose) {
-    if (!isFfmpegAvailable()) {
-        throw new Error('ffmpeg is not installed. Install it:\n' +
-            '  macOS: brew install ffmpeg\n' +
-            '  Ubuntu: sudo apt install ffmpeg\n' +
-            '  Windows: choco install ffmpeg');
-    }
+    ensureFFmpeg(isFfmpegAvailable);
     const { outputPath, width: optWidth, height: optHeight, fps = 30, codec = 'libx264', preset = 'medium', crossfadeDuration = 0.5, } = options;
     // Ensure output directory exists
     const outputDir = join(outputPath, '..');

package/dist/types/index.d.ts

@@ -41,6 +41,8 @@ export interface CliOptions {
     refactor?: boolean;
     init?: boolean;
     growthAnalysis?: string;
+    growthGuidance?: string;
+    growthAnalysisId?: string;
     productLevel?: boolean;
     concurrency?: number;
     watchTasks?: string;

package/dist/utils/validation.d.ts

@@ -21,6 +21,15 @@ export declare const validateMCPEnvironment: () => {
  */
 export declare const validateCommandEnvironment: (options: CliOptions) => ValidationResult;
 /**
- * Check if required dependencies are installed
+ * Ensure Playwright is installed, auto-installing if necessary.
+ * Installs the npm package and Chromium browser when missing.
  */
-export declare const validateRequirements: (checkFunction: () => Promise<boolean>, errorMessage: string) => Promise<void>;
+export declare const ensurePlaywright: (checkFunction: () => Promise<boolean>) => Promise<void>;
+/**
+ * Ensure an npm package is installed, auto-installing if necessary.
+ */
+export declare const ensureNpmPackage: (checkFunction: () => Promise<boolean>, packageName: string) => Promise<void>;
+/**
+ * Ensure ffmpeg is installed, auto-installing via Homebrew on macOS if possible.
+ */
+export declare const ensureFFmpeg: (checkFunction: () => boolean) => void;

package/dist/utils/validation.js

@@ -1,6 +1,7 @@
+import { execSync } from 'child_process';
 import { getMcpServerUrl, getMcpToken } from '../auth/auth-store.js';
 import { loadConfig, validateConfig } from '../config.js';
-import { logInfo } from './logger.js';
+import { logInfo, logWarning } from './logger.js';
 /**
  * Common configuration validation for all CLI commands
  */
@@ -49,11 +50,97 @@ export const validateCommandEnvironment = (options) => {
     };
 };
 /**
- * Check if required dependencies are installed
+ * Ensure Playwright is installed, auto-installing if necessary.
+ * Installs the npm package and Chromium browser when missing.
  */
-export const validateRequirements = async (checkFunction, errorMessage) => {
-    const hasRequirements = await checkFunction();
-    if (!hasRequirements) {
-        throw new Error(errorMessage);
+export const ensurePlaywright = async (checkFunction) => {
+    if (await checkFunction()) {
+        return;
     }
+    logWarning('Playwright is not installed. Installing automatically (this may take a minute)...');
+    try {
+        logInfo('  Installing playwright package...');
+        execSync('npm install playwright', { stdio: 'inherit' });
+        logInfo('  Installing Chromium browser...');
+        execSync('npx playwright install chromium', { stdio: 'inherit' });
+    }
+    catch {
+        throw new Error('Failed to auto-install Playwright.\n\n' +
+            '  Please install it manually:\n\n' +
+            '    npm install playwright\n' +
+            '    npx playwright install chromium\n\n' +
+            '  Then re-run this command. Use --listings-only to skip screenshots.');
+    }
+    // Verify installation succeeded
+    if (!(await checkFunction())) {
+        throw new Error('Playwright was installed but is still not available.\n\n' +
+            '  Try installing manually:\n\n' +
+            '    npm install playwright\n' +
+            '    npx playwright install chromium\n\n' +
+            '  Then re-run this command. Use --listings-only to skip screenshots.');
+    }
+    logInfo('  Playwright installed successfully!');
+};
+/**
+ * Ensure an npm package is installed, auto-installing if necessary.
+ */
+export const ensureNpmPackage = async (checkFunction, packageName) => {
+    if (await checkFunction()) {
+        return;
+    }
+    logWarning(`${packageName} is not installed. Installing automatically...`);
+    try {
+        execSync(`npm install ${packageName}`, { stdio: 'inherit' });
+    }
+    catch {
+        throw new Error(`Failed to auto-install ${packageName}.\n\n` +
+            `  Please install it manually:\n\n` +
+            `    npm install ${packageName}`);
+    }
+    if (!(await checkFunction())) {
+        throw new Error(`${packageName} was installed but is still not available.\n\n` +
+            `  Try installing manually:\n\n` +
+            `    npm install ${packageName}`);
+    }
+    logInfo(`  ${packageName} installed successfully!`);
+};
+/**
+ * Ensure ffmpeg is installed, auto-installing via Homebrew on macOS if possible.
+ */
+export const ensureFFmpeg = (checkFunction) => {
+    if (checkFunction()) {
+        return;
+    }
+    // Attempt auto-install on macOS via Homebrew
+    if (process.platform === 'darwin') {
+        try {
+            execSync('which brew', { stdio: 'ignore' });
+        }
+        catch {
+            throw new Error('ffmpeg is not installed and Homebrew was not found.\n\n' +
+                '  Install Homebrew first (https://brew.sh), then run:\n\n' +
+                '    brew install ffmpeg');
+        }
+        logWarning('ffmpeg is not installed. Installing via Homebrew (this may take a few minutes)...');
+        try {
+            execSync('brew install ffmpeg', { stdio: 'inherit' });
+        }
+        catch {
+            throw new Error('Failed to auto-install ffmpeg via Homebrew.\n\n' +
+                '  Please install it manually:\n\n' +
+                '    brew install ffmpeg');
+        }
+        if (!checkFunction()) {
+            throw new Error('ffmpeg was installed but is still not available.\n\n' +
+                '  Try installing manually:\n\n' +
+                '    brew install ffmpeg');
+        }
+        logInfo('  ffmpeg installed successfully!');
+        return;
+    }
+    // Non-macOS: provide platform-specific instructions
+    throw new Error('ffmpeg is not installed. Install it:\n' +
+        '  Ubuntu/Debian: sudo apt install ffmpeg\n' +
+        '  Fedora: sudo dnf install ffmpeg\n' +
+        '  Windows: choco install ffmpeg');
 };

package/dist/workflow-runner/config/phase-configs.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Phase configurations for the pipeline runner
+ */
+import { PhaseConfig } from '../../types/pipeline.js';
+export declare const phaseConfigs: readonly PhaseConfig[];