edsger 0.2.2 → 0.2.3

package/dist/phases/code-implementation/analyzer.js

@@ -285,7 +285,7 @@ CRITICAL: Checklists are not optional suggestions - they are mandatory quality g
 **Important Rules**:
 1. **Git Workflow**:
    - ALWAYS pull latest changes from main before creating branch: git pull origin ${baseBranch} --rebase
-   - ALWAYS create a new branch before making changes: git checkout -b feature/<feature-id>
+   - ALWAYS create a new branch before making changes: git checkout -b dev/<feature-id>
    - Use descriptive commit messages that explain what and why
    - Handle pre-commit checks properly: fix issues first, use workarounds only when necessary
 
@@ -323,7 +323,7 @@ You MUST end your response with a JSON object containing the implementation resu
 {
   "implementation_result": {
     "feature_id": "FEATURE_ID_PLACEHOLDER",
-    "branch_name": "feature/FEATURE_ID",
+    "branch_name": "dev/FEATURE_ID",
     "files_modified": ["file1.ts", "file2.tsx"],
     "commit_hash": "abc123...",
     "summary": "Brief description of what was implemented",
@@ -409,7 +409,7 @@ Follow this systematic approach:
    \`git pull origin ${baseBranch} --rebase\`
 
 2. **CREATE BRANCH**: Create a new git branch from ${baseBranch}:
-   \`git checkout -b feature/${featureId}\`
+   \`git checkout -b dev/${featureId}\`
 
 2. **ANALYZE CODEBASE**: Study the existing codebase structure to understand:
    - Technology stack and architecture
@@ -459,7 +459,7 @@ const parseImplementationResponse = (response, featureId) => {
             if (parsed.implementation_result) {
                 const result = parsed.implementation_result;
                 return {
-                    branchName: result.branch_name || `feature/${featureId}`,
+                    branchName: result.branch_name || `dev/${featureId}`,
                     filesModified: result.files_modified || [],
                     commitHash: result.commit_hash || '',
                     summary: result.summary || '',

package/dist/phases/feature-analysis/analyzer.js

@@ -30,7 +30,13 @@ export const analyzeFeatureWithMCP = async (options, config, checklistContext) =
         }
         const context = await fetchFeatureAnalysisContext(mcpServerUrl, mcpToken, featureId, verbose);
         const systemPrompt = createFeatureAnalysisSystemPrompt(config, mcpServerUrl, mcpToken, featureId);
-        const contextInfo = formatFeatureAnalysisContext(context);
+        const { content: contextInfo, downloadedImages } = await formatFeatureAnalysisContext(context);
+        if (verbose && downloadedImages.length > 0) {
+            logInfo(`Downloaded ${downloadedImages.length} images for Claude Code:`);
+            downloadedImages.forEach((img) => {
+                logInfo(`  - ${img.url} -> ${img.localPath}`);
+            });
+        }
         // Add checklist context to the analysis prompt
         let finalContextInfo = contextInfo;
         if (checklistContext && checklistContext.checklists.length > 0) {

package/dist/phases/pull-request/creator.js

@@ -108,28 +108,28 @@ export async function createPullRequest(config, feature) {
         if (currentBranch.startsWith('dev/')) {
             const featureId = currentBranch.replace('dev/', '');
             targetBranch = `feat/${featureId}`;
-            // Create the feat/ branch from current dev/ branch
+            // Create the feat/ branch from base branch (main)
             if (verbose) {
-                console.log(`📝 Creating target branch: ${targetBranch} from ${currentBranch}`);
+                console.log(`📝 Creating target branch: ${targetBranch} from ${baseBranch}`);
             }
             try {
                 // Push current branch to remote first
                 pushBranch(currentBranch, verbose);
-                // Get the current branch SHA
-                const { data: branchData } = await octokit.repos.getBranch({
+                // Get the base branch (main) SHA to create feat/ branch from
+                const { data: baseBranchData } = await octokit.repos.getBranch({
                     owner,
                     repo,
-                    branch: currentBranch,
+                    branch: baseBranch,
                 });
-                // Create the feat/ branch
+                // Create the feat/ branch from main
                 await octokit.git.createRef({
                     owner,
                     repo,
                     ref: `refs/heads/${targetBranch}`,
-                    sha: branchData.commit.sha,
+                    sha: baseBranchData.commit.sha,
                 });
                 if (verbose) {
-                    console.log(`✅ Created target branch: ${targetBranch}`);
+                    console.log(`✅ Created target branch: ${targetBranch} from ${baseBranch}`);
                 }
             }
             catch (error) {

package/dist/phases/technical-design/analyzer.js

@@ -29,7 +29,13 @@ export const generateTechnicalDesign = async (options, config, checklistContext)
         }
         const context = await fetchTechnicalDesignContext(mcpServerUrl, mcpToken, featureId, verbose);
         const systemPrompt = createTechnicalDesignSystemPrompt(config, mcpServerUrl, mcpToken, featureId);
-        const contextInfo = formatTechnicalDesignContext(context);
+        const { content: contextInfo, downloadedImages } = await formatTechnicalDesignContext(context);
+        if (verbose && downloadedImages.length > 0) {
+            logInfo(`Downloaded ${downloadedImages.length} images for Claude Code:`);
+            downloadedImages.forEach((img) => {
+                logInfo(`  - ${img.url} -> ${img.localPath}`);
+            });
+        }
         // Add checklist context to the design prompt
         let finalContextInfo = contextInfo;
         if (checklistContext && checklistContext.checklists.length > 0) {

package/dist/prompts/formatters.d.ts

@@ -1,4 +1,5 @@
 import type { UserStory, TestCase } from '../types/features.js';
+import { type DownloadedImage } from '../utils/image-downloader.js';
 import { TechnicalDesignContext } from '../phases/technical-design/context-fetcher.js';
 import { FeatureAnalysisContext } from '../phases/feature-analysis/context-fetcher.js';
 import { CodeImplementationContext } from '../phases/code-implementation/context-fetcher.js';
@@ -14,16 +15,28 @@ export declare function formatTestCases(cases: TestCase[]): string;
 /**
  * Format technical design context for Claude Code prompts
  */
-export declare function formatTechnicalDesignContext(context: TechnicalDesignContext): string;
+export declare function formatTechnicalDesignContext(context: TechnicalDesignContext): Promise<{
+    content: string;
+    downloadedImages: DownloadedImage[];
+}>;
 /**
  * Format feature analysis context for Claude Code prompts
  */
-export declare function formatFeatureAnalysisContext(context: FeatureAnalysisContext): string;
+export declare function formatFeatureAnalysisContext(context: FeatureAnalysisContext): Promise<{
+    content: string;
+    downloadedImages: DownloadedImage[];
+}>;
 /**
  * Format code implementation context for Claude Code prompts
  */
-export declare function formatCodeImplementationContext(context: CodeImplementationContext): string;
+export declare function formatCodeImplementationContext(context: CodeImplementationContext): Promise<{
+    content: string;
+    downloadedImages: DownloadedImage[];
+}>;
 /**
  * Format functional testing context for Claude Code prompts
  */
-export declare function formatFunctionalTestingContext(context: FunctionalTestingContext): string;
+export declare function formatFunctionalTestingContext(context: FunctionalTestingContext): Promise<{
+    content: string;
+    downloadedImages: DownloadedImage[];
+}>;

package/dist/prompts/formatters.js

@@ -1,3 +1,4 @@
+import { downloadImagesForClaudeCode, } from '../utils/image-downloader.js';
 /**
  * Format user stories for display in prompts
  */
@@ -23,13 +24,19 @@ export function formatTestCases(cases) {
 /**
  * Format technical design context for Claude Code prompts
  */
-export function formatTechnicalDesignContext(context) {
-    return `# Technical Design Context
+export async function formatTechnicalDesignContext(context) {
+    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.feature.description || 'No description provided', context.feature.id // Use feature ID for directory naming
+    );
+    const content = `# Technical Design Context
 
 ## Feature Information
 - **ID**: ${context.feature.id}
 - **Name**: ${context.feature.name}
-- **Description**: ${context.feature.description || 'No description provided'}
+- **Description**:
+${processedMarkdown}
+
+${downloadedImages.length > 0 ? '**IMPORTANT**: The description contains images that have been downloaded locally. Please use the Read tool to view these images to fully understand the requirements.' : ''}
+
 - **Current Status**: ${context.feature.status}
 
 ## Product Information
@@ -49,17 +56,24 @@ ${context.feature.technical_design || 'No existing technical design found'}
 ---
 
 **Design Instructions**: Based on the above feature requirements, user stories, and test cases, create or enhance the comprehensive technical design. Focus on system architecture, component design, database schema, API specifications, security considerations, and implementation strategy.`;
+    return { content, downloadedImages };
 }
 /**
  * Format feature analysis context for Claude Code prompts
  */
-export function formatFeatureAnalysisContext(context) {
-    return `# Feature Analysis Context
+export async function formatFeatureAnalysisContext(context) {
+    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.feature.description || 'No description provided', context.feature.id // Use feature ID for directory naming
+    );
+    const content = `# Feature Analysis Context
 
 ## Feature Information
 - **ID**: ${context.feature.id}
 - **Name**: ${context.feature.name}
-- **Description**: ${context.feature.description || 'No description provided'}
+- **Description**:
+${processedMarkdown}
+
+${downloadedImages.length > 0 ? '**IMPORTANT**: The description contains images that have been downloaded locally. Please use the Read tool to view these images to fully understand the requirements.' : ''}
+
 - **Current Status**: ${context.feature.status}
 
 ## Product Information
@@ -79,17 +93,24 @@ ${context.feature.technical_design || 'No technical design available yet'}
 ---
 
 **Analysis Instructions**: Based on the above feature information and existing user stories/test cases, conduct comprehensive business analysis to identify gaps and create additional user stories and test cases that add business value.`;
+    return { content, downloadedImages };
 }
 /**
  * Format code implementation context for Claude Code prompts
  */
-export function formatCodeImplementationContext(context) {
-    return `# Code Implementation Context
+export async function formatCodeImplementationContext(context) {
+    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.feature.description || 'No description provided', context.feature.id // Use feature ID for directory naming
+    );
+    const content = `# Code Implementation Context
 
 ## Feature Information
 - **ID**: ${context.feature.id}
 - **Name**: ${context.feature.name}
-- **Description**: ${context.feature.description || 'No description provided'}
+- **Description**:
+${processedMarkdown}
+
+${downloadedImages.length > 0 ? '**IMPORTANT**: The description contains images that have been downloaded locally. Please use the Read tool to view these images to fully understand the requirements.' : ''}
+
 - **Current Status**: ${context.feature.status}
 
 ## Product Information
@@ -109,17 +130,24 @@ ${context.technical_design || 'No technical design available - implement based o
 ---
 
 **Implementation Instructions**: Based on the above requirements, user stories, test cases, and technical design, implement the complete feature functionality. Ensure all user stories are implemented and all test cases can pass.`;
+    return { content, downloadedImages };
 }
 /**
  * Format functional testing context for Claude Code prompts
  */
-export function formatFunctionalTestingContext(context) {
-    return `# Functional Testing Context
+export async function formatFunctionalTestingContext(context) {
+    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.feature.description || 'No description provided', context.feature.id // Use feature ID for directory naming
+    );
+    const content = `# Functional Testing Context
 
 ## Feature Information
 - **ID**: ${context.feature.id}
 - **Name**: ${context.feature.name}
-- **Description**: ${context.feature.description || 'No description provided'}
+- **Description**:
+${processedMarkdown}
+
+${downloadedImages.length > 0 ? '**IMPORTANT**: The description contains images that have been downloaded locally. Please use the Read tool to view these images to fully understand the requirements.' : ''}
+
 - **Current Status**: ${context.feature.status}
 
 ## Product Information
@@ -136,4 +164,5 @@ ${formatTestCases(context.test_cases)}
 ---
 
 **Testing Instructions**: The feature has been implemented. Execute comprehensive functional testing using headless Playwright to verify all user stories work correctly and all test cases pass. Test both positive and negative scenarios.`;
+    return { content, downloadedImages };
 }

package/dist/utils/image-downloader.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Downloaded image info
+ */
+export interface DownloadedImage {
+    url: string;
+    localPath: string;
+    alt: string;
+}
+/**
+ * Set current feature ID for image downloads
+ * Should be called at the start of pipeline execution
+ */
+export declare function setCurrentFeatureId(featureId: string): void;
+/**
+ * Reset image cache (useful for testing)
+ */
+export declare function resetImageCache(): void;
+/**
+ * Download images from URLs to temporary directory for Claude Code to read
+ * Uses cache to avoid downloading same image multiple times
+ *
+ * @param markdown - Markdown content with image URLs
+ * @param featureId - Feature ID for directory naming
+ */
+export declare function downloadImagesForClaudeCode(markdown: string, featureId?: string): Promise<{
+    processedMarkdown: string;
+    downloadedImages: DownloadedImage[];
+}>;
+/**
+ * Clean markdown by removing width attributes
+ */
+export declare function cleanMarkdownForClaudeCode(markdown: string): string;

package/dist/utils/image-downloader.js

@@ -0,0 +1,144 @@
+import { createWriteStream } from 'fs';
+import { mkdir, access } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { pipeline } from 'stream/promises';
+import { createHash } from 'crypto';
+import { logInfo, logError } from './logger.js';
+// Cache for downloaded images in current session
+// Key: image URL, Value: local path
+const imageCache = new Map();
+// Current feature ID for directory naming
+let currentFeatureId = null;
+/**
+ * Generate hash from URL to use as filename
+ * This ensures same URL always maps to same file
+ */
+function hashUrl(url) {
+    return createHash('md5').update(url).digest('hex');
+}
+/**
+ * Get or create temp directory for current feature
+ */
+function getTempDir(featureId) {
+    return join(tmpdir(), 'claude-code-images', `feature-${featureId}`);
+}
+/**
+ * Set current feature ID for image downloads
+ * Should be called at the start of pipeline execution
+ */
+export function setCurrentFeatureId(featureId) {
+    if (currentFeatureId !== featureId) {
+        // Clear cache when switching to different feature
+        imageCache.clear();
+        currentFeatureId = featureId;
+    }
+}
+/**
+ * Reset image cache (useful for testing)
+ */
+export function resetImageCache() {
+    imageCache.clear();
+    currentFeatureId = null;
+}
+/**
+ * Download images from URLs to temporary directory for Claude Code to read
+ * Uses cache to avoid downloading same image multiple times
+ *
+ * @param markdown - Markdown content with image URLs
+ * @param featureId - Feature ID for directory naming
+ */
+export async function downloadImagesForClaudeCode(markdown, featureId) {
+    if (!markdown) {
+        return { processedMarkdown: markdown, downloadedImages: [] };
+    }
+    // Use provided featureId or fall back to currentFeatureId or timestamp
+    const effectiveFeatureId = featureId || currentFeatureId || Date.now().toString();
+    // Extract all image URLs from markdown
+    const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)(?:\{width=\d+\})?/g;
+    const matches = Array.from(markdown.matchAll(imageRegex));
+    if (matches.length === 0) {
+        return { processedMarkdown: markdown, downloadedImages: [] };
+    }
+    // Create temp directory for this feature
+    const tempDir = getTempDir(effectiveFeatureId);
+    await mkdir(tempDir, { recursive: true });
+    const downloadedImages = [];
+    let processedMarkdown = markdown;
+    // Download each image (or use cached version)
+    for (let i = 0; i < matches.length; i++) {
+        const match = matches[i];
+        const alt = match[1] || '';
+        const url = match[2];
+        try {
+            // Check if image is already cached
+            let localPath = imageCache.get(url);
+            if (localPath) {
+                // Verify cached file still exists
+                try {
+                    await access(localPath);
+                    logInfo(`Using cached image: ${url}`);
+                }
+                catch {
+                    // Cached file no longer exists, remove from cache
+                    imageCache.delete(url);
+                    localPath = undefined;
+                }
+            }
+            if (!localPath) {
+                // Download image
+                logInfo(`Downloading image ${i + 1}/${matches.length}: ${url}`);
+                const response = await fetch(url);
+                if (!response.ok) {
+                    logError(`Failed to download image: ${response.statusText}`);
+                    continue;
+                }
+                // Determine file extension from URL or content-type
+                let extension = 'png';
+                const urlExt = url.split('.').pop()?.toLowerCase();
+                if (urlExt && ['jpg', 'jpeg', 'png', 'gif', 'webp'].includes(urlExt)) {
+                    extension = urlExt;
+                }
+                else {
+                    const contentType = response.headers.get('content-type');
+                    if (contentType?.includes('jpeg'))
+                        extension = 'jpg';
+                    else if (contentType?.includes('png'))
+                        extension = 'png';
+                    else if (contentType?.includes('gif'))
+                        extension = 'gif';
+                    else if (contentType?.includes('webp'))
+                        extension = 'webp';
+                }
+                // Use hash of URL as filename (ensures same URL = same file)
+                const urlHash = hashUrl(url);
+                const filename = `${urlHash}.${extension}`;
+                localPath = join(tempDir, filename);
+                // Use Node.js streams to save the file
+                const fileStream = createWriteStream(localPath);
+                if (response.body) {
+                    await pipeline(response.body, fileStream);
+                }
+                // Cache the downloaded image
+                imageCache.set(url, localPath);
+                logInfo(`Downloaded to: ${localPath}`);
+            }
+            downloadedImages.push({ url, localPath, alt });
+            // Replace URL with local path in markdown
+            processedMarkdown = processedMarkdown.replace(match[0], `![${alt}](${localPath})`);
+        }
+        catch (error) {
+            logError(`Failed to download image ${url}: ${error}`);
+        }
+    }
+    return { processedMarkdown, downloadedImages };
+}
+/**
+ * Clean markdown by removing width attributes
+ */
+export function cleanMarkdownForClaudeCode(markdown) {
+    if (!markdown)
+        return markdown;
+    // Remove {width=600} syntax to keep pure markdown
+    return markdown.replace(/!\[([^\]]*)\]\(([^)]+)\)\{width=\d+\}/g, '![$1]($2)');
+}

package/dist/utils/image-processor.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Convert HTML description to Markdown format
+ * Preserves image URLs so Claude Code can view them
+ */
+export declare function htmlToMarkdown(html: string): string;

package/dist/utils/image-processor.js

@@ -0,0 +1,55 @@
+/**
+ * Convert HTML description to Markdown format
+ * Preserves image URLs so Claude Code can view them
+ */
+export function htmlToMarkdown(html) {
+    if (!html)
+        return '';
+    return (html
+        // Convert images to markdown format with original URL
+        .replace(/<img[^>]+src="([^">]+)"[^>]*alt="([^">]*)"[^>]*>/gi, '![$2]($1)')
+        .replace(/<img[^>]+src="([^">]+)"[^>]*>/gi, '![]($1)')
+        // Convert links
+        .replace(/<a[^>]+href="([^">]+)"[^>]*>(.*?)<\/a>/gi, '[$2]($1)')
+        // Convert headings
+        .replace(/<h1[^>]*>(.*?)<\/h1>/gi, '\n# $1\n')
+        .replace(/<h2[^>]*>(.*?)<\/h2>/gi, '\n## $1\n')
+        .replace(/<h3[^>]*>(.*?)<\/h3>/gi, '\n### $1\n')
+        .replace(/<h4[^>]*>(.*?)<\/h4>/gi, '\n#### $1\n')
+        .replace(/<h5[^>]*>(.*?)<\/h5>/gi, '\n##### $1\n')
+        .replace(/<h6[^>]*>(.*?)<\/h6>/gi, '\n###### $1\n')
+        // Convert lists
+        .replace(/<ul[^>]*>/gi, '\n')
+        .replace(/<\/ul>/gi, '\n')
+        .replace(/<ol[^>]*>/gi, '\n')
+        .replace(/<\/ol>/gi, '\n')
+        .replace(/<li[^>]*>(.*?)<\/li>/gi, '- $1\n')
+        // Convert paragraphs
+        .replace(/<\/p>/gi, '\n\n')
+        .replace(/<p[^>]*>/gi, '')
+        // Convert line breaks
+        .replace(/<br\s*\/?>/gi, '\n')
+        // Convert text formatting
+        .replace(/<strong[^>]*>(.*?)<\/strong>/gi, '**$1**')
+        .replace(/<b[^>]*>(.*?)<\/b>/gi, '**$1**')
+        .replace(/<em[^>]*>(.*?)<\/em>/gi, '*$1*')
+        .replace(/<i[^>]*>(.*?)<\/i>/gi, '*$1*')
+        .replace(/<u[^>]*>(.*?)<\/u>/gi, '__$1__')
+        // Convert code
+        .replace(/<code[^>]*>(.*?)<\/code>/gi, '`$1`')
+        .replace(/<pre[^>]*>(.*?)<\/pre>/gi, '\n```\n$1\n```\n')
+        // Convert blockquotes
+        .replace(/<blockquote[^>]*>(.*?)<\/blockquote>/gi, '\n> $1\n')
+        // Remove remaining HTML tags
+        .replace(/<[^>]+>/g, '')
+        // Decode HTML entities
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&amp;/g, '&')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, ' ')
+        // Clean up extra whitespace
+        .replace(/\n{3,}/g, '\n\n')
+        .trim());
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "type": "module",
   "main": "dist/index.js",
   "bin": {