npm - edsger - Versions diffs - 0.36.2 → 0.37.0 - Mend

edsger 0.36.2 → 0.37.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (127) hide show

package/dist/phases/app-store-generation/inter-font.js ADDED Viewed

@@ -0,0 +1,49 @@
+/**
+ * Inter font (variable weight) embedded as base64 WOFF2.
+ * Latin + Latin-ext subsets cover Western European languages.
+ * Font files are loaded from assets/ at runtime and cached in memory.
+ *
+ * Source: Google Fonts Inter v20, weights 100-900 (variable)
+ * Total size: ~130KB raw WOFF2 (Latin 47KB + Latin-ext 83KB)
+ *
+ * CJK limitation: Inter does not include Chinese, Japanese, or Korean
+ * glyphs. Text in these scripts falls back to the system font stack
+ * (-apple-system, BlinkMacSystemFont, etc.). To add CJK coverage,
+ * embed Noto Sans CJK subsets (~300-500KB per script), which is not
+ * included here to keep the composition payload reasonable.
+ */
+import { readFileSync } from 'fs';
+import { join } from 'path';
+const ASSETS_DIR = join(import.meta.dirname, 'assets');
+let cachedStyle = null;
+/**
+ * Returns a <style> block with @font-face declarations for Inter.
+ * Embed this in <head> to load Inter without any network requests.
+ * Font data is read from disk on first call and cached thereafter.
+ */
+export function getInterFontStyle() {
+    if (cachedStyle) {
+        return cachedStyle;
+    }
+    const latinB64 = readFileSync(join(ASSETS_DIR, 'inter-latin.woff2')).toString('base64');
+    const latinExtB64 = readFileSync(join(ASSETS_DIR, 'inter-latin-ext.woff2')).toString('base64');
+    cachedStyle = `<style>
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 100 900;
+  font-display: swap;
+  src: url(data:font/woff2;base64,${latinB64}) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 100 900;
+  font-display: swap;
+  src: url(data:font/woff2;base64,${latinExtB64}) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+</style>`;
+    return cachedStyle;
+}

package/dist/phases/app-store-generation/screenshot-composer.js CHANGED Viewed

@@ -11,6 +11,8 @@ import { tmpdir } from 'os';
 import { join } from 'path';
 import { generateDeviceFrameHtml, } from '../../services/video/device-frames.js';
 import { logError, logInfo, logWarning } from '../../utils/logger.js';
+import { ensurePlaywright } from '../../utils/validation.js';
+import { getInterFontStyle } from './inter-font.js';
 import { STORE_SCREENSHOT_SIZES } from './prompts.js';
 /**
  * Compose a single store screenshot for a specific device type
@@ -60,14 +62,18 @@ async function loadChromium() {
         return null;
     }
 }
+async function isPlaywrightAvailable() {
+    return (await loadChromium()) !== null;
+}
 /**
  * Map AI device_frame string to our DeviceFrameType
  */
 function mapDeviceFrame(frame) {
     switch (frame.toLowerCase()) {
         case 'iphone':
-        case 'ipad':
             return 'iphone';
+        case 'ipad':
+            return 'ipad';
         case 'macbook':
             return 'macbook';
         case 'browser':
@@ -76,17 +82,119 @@ function mapDeviceFrame(frame) {
             return 'iphone';
     }
 }
+/** Common named CSS colors likely in AI output. */
+const NAMED_COLORS = {
+    white: [255, 255, 255],
+    black: [0, 0, 0],
+    red: [255, 0, 0],
+    green: [0, 128, 0],
+    blue: [0, 0, 255],
+    yellow: [255, 255, 0],
+    cyan: [0, 255, 255],
+    magenta: [255, 0, 255],
+    gray: [128, 128, 128],
+    grey: [128, 128, 128],
+    orange: [255, 165, 0],
+    purple: [128, 0, 128],
+    pink: [255, 192, 203],
+};
+/**
+ * Parse a CSS color string to [R, G, B] (0-255 each).
+ * Supports hex (#rgb, #rrggbb, #rrggbbaa), rgb(), rgba(), and named colors.
+ */
+function parseColor(color) {
+    const s = color.trim().toLowerCase();
+    if (NAMED_COLORS[s]) {
+        return NAMED_COLORS[s];
+    }
+    const rgbMatch = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/.exec(s);
+    if (rgbMatch) {
+        return [parseInt(rgbMatch[1]), parseInt(rgbMatch[2]), parseInt(rgbMatch[3])];
+    }
+    const hexMatch = /^#?([0-9a-f]{3,8})$/i.exec(s);
+    if (!hexMatch) {
+        return null;
+    }
+    const h = hexMatch[1];
+    if (h.length === 3) {
+        return [
+            parseInt(h[0] + h[0], 16),
+            parseInt(h[1] + h[1], 16),
+            parseInt(h[2] + h[2], 16),
+        ];
+    }
+    if (h.length >= 6) {
+        return [
+            parseInt(h.slice(0, 2), 16),
+            parseInt(h.slice(2, 4), 16),
+            parseInt(h.slice(4, 6), 16),
+        ];
+    }
+    return null;
+}
+/**
+ * Relative luminance (0-1) per WCAG 2.x sRGB formula.
+ * Returns 1.0 for unparseable input — safe default that produces dark overlay.
+ */
+function colorLuminance(color) {
+    const rgb = parseColor(color);
+    if (!rgb) {
+        return 1.0;
+    }
+    const toLinear = (c) => {
+        const s = c / 255;
+        return s <= 0.04045 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+    };
+    return (0.2126 * toLinear(rgb[0]) +
+        0.7152 * toLinear(rgb[1]) +
+        0.0722 * toLinear(rgb[2]));
+}
+/** Hermite interpolation for smooth 0→1 transition. */
+function smoothstep(edge0, edge1, x) {
+    const t = Math.max(0, Math.min(1, (x - edge0) / (edge1 - edge0)));
+    return t * t * (3 - 2 * t);
+}
+/**
+ * Returns overlay/shadow rgba() values that contrast with the given text color.
+ * Uses smooth interpolation — strong at extremes, reduced for mid-range text
+ * to avoid hurting contrast in ambiguous cases.
+ */
+function contrastStyles(textColor) {
+    const lum = colorLuminance(textColor);
+    // Smooth 0→1: 0 = dark text, 1 = light text
+    const lightness = smoothstep(0.15, 0.65, lum);
+    // Overlay channel: black (0) for light text, white (255) for dark text
+    const ch = Math.round(255 * (1 - lightness));
+    // Certainty: 1 at extremes, 0 at the ambiguous middle
+    const certainty = Math.abs(lightness - 0.5) * 2;
+    // Base alphas — blend between dark-overlay and light-overlay presets
+    const baseOverlay = 0.25 * lightness + 0.2 * (1 - lightness);
+    const baseShadow = 0.35 * lightness + 0.4 * (1 - lightness);
+    const baseShadowLight = 0.25 * lightness + 0.3 * (1 - lightness);
+    // Scale by certainty — 50% minimum even at peak ambiguity
+    const scale = 0.5 + 0.5 * certainty;
+    const fmt = (alpha) => (alpha * scale).toFixed(2);
+    return {
+        overlayColor: `rgba(${ch},${ch},${ch},${fmt(baseOverlay)})`,
+        shadowColor: `rgba(${ch},${ch},${ch},${fmt(baseShadow)})`,
+        shadowColorLight: `rgba(${ch},${ch},${ch},${fmt(baseShadowLight)})`,
+    };
+}
 /**
  * Create composition HTML: gradient background + text overlay + device-framed screenshot
  */
 function createCompositionHtml(framedScreenshotDataUrl, spec, targetWidth, targetHeight) {
     const isPortrait = targetHeight > targetWidth;
     const textColor = spec.text_color || '#ffffff';
+    const fontStyle = getInterFontStyle();
+    const fontFamily = `'Inter', -apple-system, BlinkMacSystemFont, 'SF Pro Display', 'Segoe UI', sans-serif`;
+    const { overlayColor, shadowColor, shadowColorLight } = contrastStyles(textColor);
     if (isPortrait) {
         // Portrait: text at top, device below
         return `<!DOCTYPE html>
 <html>
 <head>
+${fontStyle}
 <style>
   * { margin: 0; padding: 0; box-sizing: border-box; }
   body {
@@ -97,35 +205,60 @@ function createCompositionHtml(framedScreenshotDataUrl, spec, targetWidth, targe
     flex-direction: column;
     align-items: center;
     justify-content: flex-start;
-    font-family: -apple-system, BlinkMacSystemFont, 'SF Pro Display', 'Segoe UI', sans-serif;
+    font-family: ${fontFamily};
     overflow: hidden;
   }
   .text-area {
-    padding: ${Math.round(targetHeight * 0.06)}px ${Math.round(targetWidth * 0.08)}px;
+    padding: ${Math.round(targetHeight * 0.05)}px ${Math.round(targetWidth * 0.08)}px;
     text-align: center;
     flex-shrink: 0;
+    max-height: 28%;
+    position: relative;
+  }
+  .text-area::after {
+    content: '';
+    position: absolute;
+    inset: 0;
+    background: linear-gradient(to bottom, ${overlayColor} 0%, transparent 100%);
+    border-radius: inherit;
+    pointer-events: none;
   }
   .headline {
-    font-size: ${Math.round(targetWidth * 0.07)}px;
+    font-size: ${Math.round(targetWidth * 0.1)}px;
     font-weight: 800;
     color: ${textColor};
     line-height: 1.15;
     letter-spacing: -0.02em;
     margin-bottom: ${Math.round(targetHeight * 0.01)}px;
+    text-shadow: 0 2px 12px ${shadowColor};
+    position: relative;
+    z-index: 1;
+    display: -webkit-box;
+    -webkit-line-clamp: 3;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
   }
   .subheadline {
-    font-size: ${Math.round(targetWidth * 0.035)}px;
+    font-size: ${Math.round(targetWidth * 0.05)}px;
     font-weight: 400;
     color: ${textColor};
     opacity: 0.85;
     line-height: 1.3;
+    text-shadow: 0 1px 8px ${shadowColorLight};
+    position: relative;
+    z-index: 1;
+    display: -webkit-box;
+    -webkit-line-clamp: 2;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
   }
   .device-area {
     flex: 1;
     display: flex;
-    align-items: flex-start;
+    align-items: center;
     justify-content: center;
     overflow: hidden;
+    min-height: 0;
     padding: 0 ${Math.round(targetWidth * 0.02)}px;
   }
   .device-area img {
@@ -148,6 +281,7 @@ function createCompositionHtml(framedScreenshotDataUrl, spec, targetWidth, targe
     return `<!DOCTYPE html>
 <html>
 <head>
+${fontStyle}
 <style>
   * { margin: 0; padding: 0; box-sizing: border-box; }
   body {
@@ -156,31 +290,60 @@ function createCompositionHtml(framedScreenshotDataUrl, spec, targetWidth, targe
     background: ${spec.background_gradient};
     display: flex;
     align-items: center;
-    font-family: -apple-system, BlinkMacSystemFont, 'SF Pro Display', 'Segoe UI', sans-serif;
+    font-family: ${fontFamily};
     overflow: hidden;
   }
   .text-area {
-    width: 40%;
+    flex: 0 1 auto;
+    min-width: 28%;
+    max-width: 44%;
     padding: 0 ${Math.round(targetWidth * 0.04)}px;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
     text-align: left;
+    position: relative;
+  }
+  .text-area::after {
+    content: '';
+    position: absolute;
+    inset: 0;
+    background: linear-gradient(to right, ${overlayColor} 0%, transparent 100%);
+    border-radius: inherit;
+    pointer-events: none;
   }
   .headline {
-    font-size: ${Math.round(targetWidth * 0.04)}px;
+    font-size: ${Math.round(targetWidth * 0.055)}px;
     font-weight: 800;
     color: ${textColor};
     line-height: 1.15;
     letter-spacing: -0.02em;
     margin-bottom: ${Math.round(targetHeight * 0.02)}px;
+    text-shadow: 0 2px 12px ${shadowColor};
+    position: relative;
+    z-index: 1;
+    display: -webkit-box;
+    -webkit-line-clamp: 3;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
   }
   .subheadline {
-    font-size: ${Math.round(targetWidth * 0.02)}px;
+    font-size: ${Math.round(targetWidth * 0.028)}px;
     font-weight: 400;
     color: ${textColor};
     opacity: 0.85;
     line-height: 1.4;
+    text-shadow: 0 1px 8px ${shadowColorLight};
+    position: relative;
+    z-index: 1;
+    display: -webkit-box;
+    -webkit-line-clamp: 2;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
   }
   .device-area {
-    width: 60%;
+    flex: 1 1 0;
+    min-width: 0;
     height: 100%;
     display: flex;
     align-items: center;
@@ -222,10 +385,8 @@ function escapeHtml(str) {
  * 3. Compose framed PNG + text overlay + gradient background at exact store dimensions → final PNG
  */
 export async function generateStoreScreenshots(specs, options) {
-    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 { productId, targetStore, locale: _locale, verbose } = options;
     const outputDir = join(tmpdir(), 'edsger-app-store-assets', productId);
     await mkdir(outputDir, { recursive: true });
@@ -242,10 +403,13 @@ export async function generateStoreScreenshots(specs, options) {
             logInfo(`Generating screenshot ${specIdx + 1}/${specs.length}: "${spec.headline}"`);
             // Step 1: Render the AI HTML template at a base viewport to get raw app mock
             const deviceFrame = mapDeviceFrame(spec.device_frame);
-            const isPhone = deviceFrame === 'iphone' || spec.device_frame === 'ipad';
+            const isPhone = deviceFrame === 'iphone';
+            const isTablet = deviceFrame === 'ipad';
             const baseViewport = isPhone
                 ? { width: 390, height: 844 }
-                : { width: 1280, height: 720 };
+                : isTablet
+                    ? { width: 1024, height: 1366 }
+                    : { width: 1280, height: 720 };
             let rawScreenshotBuffer;
             try {
                 const rawContext = await browser.newContext({
@@ -271,8 +435,8 @@ export async function generateStoreScreenshots(specs, options) {
             // Use tight canvas dimensions so the device fills most of the frame image.
             // This prevents excess padding that would make the device appear small in composition.
             const rawDataUrl = `data:image/png;base64,${rawScreenshotBuffer.toString('base64')}`;
-            const frameWidth = deviceFrame === 'iphone' ? 500 : 1600;
-            const frameHeight = deviceFrame === 'iphone' ? 1050 : 1000;
+            const frameWidth = deviceFrame === 'iphone' ? 500 : deviceFrame === 'ipad' ? 900 : 1600;
+            const frameHeight = deviceFrame === 'iphone' ? 1050 : deviceFrame === 'ipad' ? 1200 : 1000;
             const frameHtml = generateDeviceFrameHtml(rawDataUrl, deviceFrame, {
                 background: 'transparent',
                 shadow: true,

package/dist/phases/code-implementation/analyzer-helpers.d.ts ADDED Viewed

@@ -0,0 +1,28 @@
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+import { ChecklistVerificationResult } from '../code-implementation-verification/agent.js';
+import { CodeImplementationResult } from './index.js';
+export interface VerificationCycleResult {
+    passed: boolean;
+    verificationResult: ChecklistVerificationResult | null;
+    nextPrompt: string | null;
+}
+/**
+ * Perform a complete verification cycle:
+ * 1. Verify code implementation against checklist
+ * 2. Log results to audit logs
+ * 3. Create improvement prompt if verification failed
+ */
+export declare function performVerificationCycle(branchName: string, baseBranch: string, checklistContext: ChecklistPhaseContext | null, featureId: string, featureName: string, featureDescription: string | undefined, config: EdsgerConfig, currentIteration: number, maxIterations: number, verbose?: boolean): Promise<VerificationCycleResult>;
+/**
+ * Build successful implementation result
+ */
+export declare function buildImplementationResult(featureId: string, branchName: string, implementationSummary: string, filesModified: string[], commitHash: string, iterations: number, checklistResults?: any[], checklistItemResults?: any[]): CodeImplementationResult;
+/**
+ * Build verification failure result
+ */
+export declare function buildVerificationFailureResult(featureId: string, branchName: string, implementationSummary: string, filesModified: string[], commitHash: string, verificationResult: ChecklistVerificationResult, iterations: number): CodeImplementationResult;
+/**
+ * Build error result for no implementation
+ */
+export declare function buildNoResultsError(featureId: string, branchName: string): CodeImplementationResult;

package/dist/phases/code-implementation/analyzer-helpers.js ADDED Viewed

@@ -0,0 +1,177 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { logFeatureVerificationEvent } from '../../services/audit-logs.js';
+import { formatChecklistsForContext, processChecklistItemResultsFromResponse, } from '../../services/checklist.js';
+import { verifyCodeImplementationCompliance, } from '../code-implementation-verification/agent.js';
+import { createCodeImplementationImprovementPrompt } from './prompts.js';
+/**
+ * Perform a complete verification cycle:
+ * 1. Verify code implementation against checklist
+ * 2. Log results to audit logs
+ * 3. Create improvement prompt if verification failed
+ */
+export async function performVerificationCycle(branchName, baseBranch, checklistContext, featureId, featureName, featureDescription, config, currentIteration, maxIterations, verbose) {
+    // If no checklist, verification passes automatically
+    if (!checklistContext || checklistContext.checklists.length === 0) {
+        if (verbose) {
+            logInfo('ℹ️  No checklists to verify - skipping verification');
+        }
+        return {
+            passed: true,
+            verificationResult: null,
+            nextPrompt: null,
+        };
+    }
+    if (verbose) {
+        logInfo(`\n🔍 Verifying code implementation (iteration ${currentIteration}/${maxIterations})...`);
+    }
+    // Format checklist context for verification
+    const checklistInfo = formatChecklistsForContext(checklistContext);
+    // Perform verification
+    const verificationResult = await verifyCodeImplementationCompliance({
+        featureId,
+        branchName,
+        baseBranch,
+        featureName,
+        featureDescription,
+        checklistContext: checklistInfo,
+        verbose,
+    }, config);
+    // Determine if verification passed
+    const verificationPassed = verificationResult.rejected_count === 0;
+    // Log verification result
+    if (verificationPassed) {
+        if (verbose) {
+            logInfo(`✅ Code verification passed: ${verificationResult.confirmed_count} confirmed, ${verificationResult.uncertain_count} uncertain`);
+        }
+        await logFeatureVerificationEvent({
+            featureId,
+            phase: 'code_implementation',
+            iteration: currentIteration,
+            result: 'success',
+            verificationData: {
+                confirmed_count: verificationResult.confirmed_count,
+                rejected_count: verificationResult.rejected_count,
+                uncertain_count: verificationResult.uncertain_count,
+                summary: verificationResult.summary,
+            },
+        }, verbose);
+        // Create checklist results based on verification result
+        const checklistItemResults = verificationResult.item_verifications.map((item) => ({
+            checklist_item_id: item.checklist_item_id,
+            is_passed: item.is_satisfied && item.verification_status === 'confirmed',
+            value: item.verification_status,
+            notes: item.verification_reason || undefined,
+        }));
+        await processChecklistItemResultsFromResponse({ featureId }, 'code_implementation', checklistItemResults, verbose);
+    }
+    else {
+        logError(`❌ Iteration ${currentIteration}: Code verification FAILED - ${verificationResult.rejected_count} items rejected, ${verificationResult.uncertain_count} uncertain`);
+        await logFeatureVerificationEvent({
+            featureId,
+            phase: 'code_implementation',
+            iteration: currentIteration,
+            result: 'error',
+            verificationData: {
+                confirmed_count: verificationResult.confirmed_count,
+                rejected_count: verificationResult.rejected_count,
+                uncertain_count: verificationResult.uncertain_count,
+                rejected_items: verificationResult.item_verifications
+                    .filter((item) => item.verification_status === 'rejected')
+                    .map((item) => ({
+                    checklist_item_id: item.checklist_item_id,
+                    reason: item.verification_reason || 'No reason provided',
+                    concerns: item.concerns || [],
+                    improvement_suggestions: item.improvement_suggestions || [],
+                })),
+                uncertain_items: verificationResult.item_verifications
+                    .filter((item) => item.verification_status === 'uncertain')
+                    .map((item) => ({
+                    checklist_item_id: item.checklist_item_id,
+                    reason: item.verification_reason || 'No reason provided',
+                    concerns: item.concerns || [],
+                    improvement_suggestions: item.improvement_suggestions || [],
+                })),
+                summary: verificationResult.summary,
+                overall_suggestions: verificationResult.overall_suggestions || [],
+            },
+        }, verbose);
+    }
+    // If verification failed and we have iterations left, create improvement prompt
+    let nextPrompt = null;
+    if (!verificationPassed && currentIteration < maxIterations) {
+        nextPrompt = createCodeImplementationImprovementPrompt(verificationResult, branchName, baseBranch);
+        if (verbose) {
+            logInfo(`\n📝 Created improvement prompt for next iteration (${maxIterations - currentIteration} attempts remaining)`);
+        }
+    }
+    else if (!verificationPassed) {
+        // Max iterations reached - create checklist results based on final verification
+        if (verbose) {
+            logInfo(`\n📋 Creating checklist results for final iteration (max iterations reached)`);
+        }
+        // Create checklist results for all items (both passed and failed)
+        const checklistItemResults = verificationResult.item_verifications.map((item) => ({
+            checklist_item_id: item.checklist_item_id,
+            is_passed: item.is_satisfied && item.verification_status === 'confirmed',
+            value: item.verification_status,
+            notes: item.verification_reason || undefined,
+        }));
+        await processChecklistItemResultsFromResponse({ featureId }, 'code_implementation', checklistItemResults, verbose);
+    }
+    return {
+        passed: verificationPassed,
+        verificationResult,
+        nextPrompt,
+    };
+}
+/**
+ * Build successful implementation result
+ */
+export function buildImplementationResult(featureId, branchName, implementationSummary, filesModified, commitHash, iterations, checklistResults, checklistItemResults) {
+    return {
+        featureId,
+        branchName,
+        implementationSummary,
+        status: 'success',
+        message: 'Code implementation completed successfully',
+        filesModified,
+        commitHash,
+        data: {
+            checklist_results: checklistResults,
+            checklist_item_results: checklistItemResults,
+        },
+    };
+}
+/**
+ * Build verification failure result
+ */
+export function buildVerificationFailureResult(featureId, branchName, implementationSummary, filesModified, commitHash, verificationResult, iterations) {
+    return {
+        featureId,
+        branchName,
+        implementationSummary,
+        status: 'error',
+        message: `Code implementation verification failed after ${iterations} iterations. Code committed for manual review.`,
+        filesModified,
+        commitHash,
+        data: {
+            verification_failed: true,
+            verification_summary: verificationResult.summary,
+            rejected_count: verificationResult.rejected_count,
+            uncertain_count: verificationResult.uncertain_count,
+            improvement_suggestions: verificationResult.overall_suggestions || [],
+        },
+    };
+}
+/**
+ * Build error result for no implementation
+ */
+export function buildNoResultsError(featureId, branchName) {
+    return {
+        featureId,
+        branchName,
+        implementationSummary: null,
+        status: 'error',
+        message: 'Code implementation failed - no results produced',
+    };
+}

package/dist/phases/code-implementation/analyzer.d.ts ADDED Viewed

@@ -0,0 +1,32 @@
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+export interface CodeImplementationOptions {
+    featureId: string;
+    verbose?: boolean;
+    baseBranch?: string;
+    maxVerificationIterations?: number;
+}
+export interface CodeImplementationResult {
+    featureId: string;
+    branchName: string;
+    implementationSummary: string | null;
+    status: 'success' | 'error';
+    message: string;
+    filesModified?: string[];
+    commitHash?: string;
+    data?: {
+        checklist_results?: Array<{
+            checklist_id: string;
+            satisfied: boolean;
+            notes?: string;
+        }>;
+        checklist_item_results?: Array<{
+            checklist_item_id: string;
+            is_passed: boolean;
+            value?: any;
+            notes?: string;
+        }>;
+        [key: string]: any;
+    };
+}
+export declare const implementFeatureCode: (options: CodeImplementationOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<CodeImplementationResult>;