edsger 0.2.5 → 0.2.7

package/dist/phases/bug-fixing/analyzer.js

@@ -1,5 +1,6 @@
 import { query } from '@anthropic-ai/claude-code';
 import { logInfo, logError } from '../../utils/logger.js';
+import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { fetchBugFixingContext, formatContextForPrompt, } from './context-fetcher.js';
 function userMessage(content) {
     return {
@@ -23,8 +24,25 @@ export const fixTestFailures = async (options, config) => {
             logInfo('Fetching bug fixing context via MCP endpoints...');
         }
         const context = await fetchBugFixingContext(mcpServerUrl, mcpToken, featureId, verbose);
+        // Fetch feedbacks for bug fixing phase
+        let feedbacksInfo;
+        try {
+            const feedbacksContext = await getFeedbacksForPhase({ featureId, mcpServerUrl, mcpToken, verbose }, 'bug_fixing');
+            if (feedbacksContext.feedbacks.length > 0) {
+                feedbacksInfo = formatFeedbacksForContext(feedbacksContext);
+                if (verbose) {
+                    logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to bug fixing context`);
+                }
+            }
+        }
+        catch (error) {
+            // Don't fail if feedbacks fetch fails - just log and continue
+            if (verbose) {
+                logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
+            }
+        }
         const systemPrompt = createSystemPrompt(config);
-        const bugFixPrompt = createBugFixPromptWithContext(featureId, testErrors, attemptNumber, context);
+        const bugFixPrompt = createBugFixPromptWithContext(featureId, testErrors, attemptNumber, context, feedbacksInfo);
         let lastAssistantResponse = '';
         let structuredFixResult = null;
         if (verbose) {
@@ -208,8 +226,12 @@ You MUST end your response with a JSON object containing the bug fix results in
 
 Focus on systematic bug fixing based on the provided context and test failure information.`;
 }
-function createBugFixPromptWithContext(featureId, testErrors, attemptNumber, context) {
-    const contextInfo = formatContextForPrompt(context, testErrors);
+function createBugFixPromptWithContext(featureId, testErrors, attemptNumber, context, feedbacksInfo) {
+    let contextInfo = formatContextForPrompt(context, testErrors);
+    // Add feedbacks context to the bug fixing prompt
+    if (feedbacksInfo) {
+        contextInfo = contextInfo + '\n\n' + feedbacksInfo;
+    }
     return `Fix the test failures for feature: ${featureId} (Attempt ${attemptNumber})
 
 ${contextInfo}

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

@@ -1,6 +1,7 @@
 import { query } from '@anthropic-ai/claude-code';
 import { logInfo, logError } from '../../utils/logger.js';
 import { formatChecklistsForContext, } from '../../services/checklist.js';
+import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { fetchCodeImplementationContext, formatContextForPrompt, } from './context-fetcher.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 import { performVerificationCycle, buildImplementationResult, buildVerificationFailureResult, buildNoResultsError, } from './analyzer-helpers.js';
@@ -27,8 +28,25 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
             logInfo('Fetching code implementation context via MCP endpoints...');
         }
         const context = await fetchCodeImplementationContext(mcpServerUrl, mcpToken, featureId, verbose);
+        // Fetch feedbacks for code implementation phase
+        let feedbacksInfo;
+        try {
+            const feedbacksContext = await getFeedbacksForPhase({ featureId, mcpServerUrl, mcpToken, verbose }, 'code_implementation');
+            if (feedbacksContext.feedbacks.length > 0) {
+                feedbacksInfo = formatFeedbacksForContext(feedbacksContext);
+                if (verbose) {
+                    logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to implementation context`);
+                }
+            }
+        }
+        catch (error) {
+            // Don't fail if feedbacks fetch fails - just log and continue
+            if (verbose) {
+                logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
+            }
+        }
         const systemPrompt = createSystemPrompt(config, baseBranch, mcpServerUrl, mcpToken, featureId);
-        const initialImplementationPrompt = createImplementationPromptWithContext(featureId, context, baseBranch, checklistContext, verbose);
+        const initialImplementationPrompt = createImplementationPromptWithContext(featureId, context, baseBranch, checklistContext, verbose, feedbacksInfo);
         const maxIterations = options.maxVerificationIterations || 10;
         let currentIteration = 0;
         let currentPrompt = initialImplementationPrompt;
@@ -429,14 +447,18 @@ IMPORTANT: In the checklist context, look for lines that say "ID: [UUID]" in the
 
 Remember: Quality over speed. It's better to implement correctly than to rush and create bugs.`;
 };
-const createImplementationPromptWithContext = (featureId, context, baseBranch, checklistContext, verbose) => {
+const createImplementationPromptWithContext = (featureId, context, baseBranch, checklistContext, verbose, feedbacksInfo) => {
     const contextInfo = formatContextForPrompt(context);
-    // Add checklist context to the implementation prompt
     let finalContextInfo = contextInfo;
+    // Add feedbacks context to the implementation prompt
+    if (feedbacksInfo) {
+        finalContextInfo = finalContextInfo + '\n\n' + feedbacksInfo;
+    }
+    // Add checklist context to the implementation prompt
     let checklistInstructions = '';
     if (checklistContext && checklistContext.checklists.length > 0) {
         const checklistInfo = formatChecklistsForContext(checklistContext);
-        finalContextInfo = contextInfo + '\n\n' + checklistInfo;
+        finalContextInfo = finalContextInfo + '\n\n' + checklistInfo;
         // DEBUG: Log checklist context details
         console.log('=== DEBUG: Checklist Context for Code Implementation ===');
         console.log('Number of checklists:', checklistContext.checklists.length);
@@ -601,9 +623,7 @@ async function pushToRemote(branchName, verbose) {
                 return { success: true };
             }
             catch (retryError) {
-                const errorMessage = retryError instanceof Error
-                    ? retryError.message
-                    : String(retryError);
+                const errorMessage = retryError instanceof Error ? retryError.message : String(retryError);
                 return {
                     success: false,
                     error: errorMessage,

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

@@ -3,6 +3,7 @@ import { fetchFeatureAnalysisContext, } from './context-fetcher.js';
 import { formatFeatureAnalysisContext } from '../../prompts/formatters.js';
 import { createFeatureAnalysisSystemPrompt, createFeatureAnalysisPromptWithContext, } from '../../prompts/feature-analysis.js';
 import { formatChecklistsForContext, } from '../../services/checklist.js';
+import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { executeAnalysisQuery, performVerificationCycle, saveAnalysisArtifactsAsDraft, updateArtifactsToReady, deleteArtifacts, buildAnalysisResult, buildVerificationFailureResult, buildNoResultsError, } from './analyzer-helpers.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 export const analyzeFeatureWithMCP = async (options, config, checklistContext) => {
@@ -165,11 +166,28 @@ async function prepareAnalysisContext(mcpServerUrl, mcpToken, featureId, checkli
             logInfo(`  - ${img.url} -> ${img.localPath}`);
         });
     }
-    // Add checklist context to the analysis prompt
     let finalContextInfo = contextInfo;
+    // Add feedbacks context to the analysis prompt
+    try {
+        const feedbacksContext = await getFeedbacksForPhase({ featureId, mcpServerUrl, mcpToken, verbose }, 'feature-analysis');
+        if (feedbacksContext.feedbacks.length > 0) {
+            const feedbacksInfo = formatFeedbacksForContext(feedbacksContext);
+            finalContextInfo = finalContextInfo + '\n\n' + feedbacksInfo;
+            if (verbose) {
+                logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to context`);
+            }
+        }
+    }
+    catch (error) {
+        // Don't fail if feedbacks fetch fails - just log and continue
+        if (verbose) {
+            logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    // Add checklist context to the analysis prompt
     if (checklistContext && checklistContext.checklists.length > 0) {
         const checklistInfo = formatChecklistsForContext(checklistContext);
-        finalContextInfo = contextInfo + '\n\n' + checklistInfo;
+        finalContextInfo = finalContextInfo + '\n\n' + checklistInfo;
         if (verbose) {
             logInfo(`Added ${checklistContext.checklists.length} checklists to analysis context`);
         }

package/dist/phases/functional-testing/analyzer.js

@@ -1,6 +1,7 @@
 import { query } from '@anthropic-ai/claude-code';
 import { logInfo, logError } from '../../utils/logger.js';
 import { formatChecklistsForContext, } from '../../services/checklist.js';
+import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { saveFunctionalTestResultsWithRetry } from './http-fallback.js';
 import { fetchFunctionalTestingContext, formatContextForPrompt, } from './context-fetcher.js';
 import { updateFeatureStatus } from '../../api/features/index.js';
@@ -27,8 +28,25 @@ export const runFunctionalTesting = async (options, config, checklistContext) =>
             logInfo('Fetching feature testing context via MCP endpoints...');
         }
         const context = await fetchFunctionalTestingContext(mcpServerUrl, mcpToken, featureId, verbose);
+        // Fetch feedbacks for functional testing phase
+        let feedbacksInfo;
+        try {
+            const feedbacksContext = await getFeedbacksForPhase({ featureId, mcpServerUrl, mcpToken, verbose }, 'functional_testing');
+            if (feedbacksContext.feedbacks.length > 0) {
+                feedbacksInfo = formatFeedbacksForContext(feedbacksContext);
+                if (verbose) {
+                    logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to testing context`);
+                }
+            }
+        }
+        catch (error) {
+            // Don't fail if feedbacks fetch fails - just log and continue
+            if (verbose) {
+                logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
+            }
+        }
         const systemPrompt = createSystemPrompt(config, mcpServerUrl, mcpToken, featureId);
-        const testingPrompt = createTestingPromptWithContext(featureId, context, checklistContext, verbose);
+        const testingPrompt = createTestingPromptWithContext(featureId, context, checklistContext, verbose, feedbacksInfo);
         let lastAssistantResponse = '';
         let structuredTestResult = null;
         let testStatus = 'testing_failed';
@@ -475,13 +493,17 @@ IMPORTANT: In the checklist context, look for lines that say "ID: [UUID]" in the
 
 Focus on systematic testing based on the provided context information.${mcpInstructions}`;
 };
-const createTestingPromptWithContext = (featureId, context, checklistContext, verbose) => {
+const createTestingPromptWithContext = (featureId, context, checklistContext, verbose, feedbacksInfo) => {
     const contextInfo = formatContextForPrompt(context);
-    // Add checklist context to the testing prompt
     let finalContextInfo = contextInfo;
+    // Add feedbacks context to the testing prompt
+    if (feedbacksInfo) {
+        finalContextInfo = finalContextInfo + '\n\n' + feedbacksInfo;
+    }
+    // Add checklist context to the testing prompt
     if (checklistContext && checklistContext.checklists.length > 0) {
         const checklistInfo = formatChecklistsForContext(checklistContext);
-        finalContextInfo = contextInfo + '\n\n' + checklistInfo;
+        finalContextInfo = finalContextInfo + '\n\n' + checklistInfo;
         if (verbose) {
             logInfo(`Added ${checklistContext.checklists.length} checklists to testing context`);
         }

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

@@ -6,6 +6,7 @@ import { updateTechnicalDesign } from '../../api/features/index.js';
 import { formatTechnicalDesignContext } from '../../prompts/formatters.js';
 import { createTechnicalDesignSystemPrompt, createTechnicalDesignPromptWithContext, } from '../../prompts/technical-design.js';
 import { formatChecklistsForContext, } from '../../services/checklist.js';
+import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { performVerificationCycle, buildDesignResult, buildVerificationFailureResult, buildNoResultsError, } from './analyzer-helpers.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 function userMessage(content) {
@@ -155,20 +156,59 @@ async function prepareDesignContext(mcpServerUrl, mcpToken, featureId, checklist
             logInfo(`  - ${img.url} -> ${img.localPath}`);
         });
     }
-    // Add checklist context to the design prompt
     let finalContextInfo = contextInfo;
+    let hasFeedbacks = false;
+    // Check if there's existing technical design
+    const existingTechnicalDesign = context.feature.technical_design;
+    const hasExistingDesign = !!existingTechnicalDesign && existingTechnicalDesign.trim().length > 0;
+    // Add existing technical design to context if it exists
+    if (hasExistingDesign && verbose) {
+        logInfo('📋 Found existing technical design - will perform incremental update if feedbacks exist');
+    }
+    // Add feedbacks context to the design prompt
+    try {
+        const feedbacksContext = await getFeedbacksForPhase({ featureId, mcpServerUrl, mcpToken, verbose }, 'technical-design');
+        if (feedbacksContext.feedbacks.length > 0) {
+            hasFeedbacks = true;
+            const feedbacksInfo = formatFeedbacksForContext(feedbacksContext);
+            finalContextInfo = finalContextInfo + '\n\n' + feedbacksInfo;
+            if (verbose) {
+                logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to design context`);
+            }
+        }
+    }
+    catch (error) {
+        // Don't fail if feedbacks fetch fails - just log and continue
+        if (verbose) {
+            logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    // Add checklist context to the design prompt
     if (checklistContext && checklistContext.checklists.length > 0) {
         const checklistInfo = formatChecklistsForContext(checklistContext);
-        finalContextInfo = contextInfo + '\n\n' + checklistInfo;
+        finalContextInfo = finalContextInfo + '\n\n' + checklistInfo;
         if (verbose) {
             logInfo(`Added ${checklistContext.checklists.length} checklists to design context`);
         }
     }
-    const designPrompt = createTechnicalDesignPromptWithContext(featureId, finalContextInfo);
+    // Decide on prompt mode based on existing design and feedbacks
+    const isIncrementalUpdate = hasExistingDesign && hasFeedbacks;
+    if (isIncrementalUpdate && verbose) {
+        logInfo('🔄 Mode: Incremental Update (existing design + feedbacks)');
+    }
+    else if (hasExistingDesign && verbose) {
+        logInfo('🔄 Mode: Full Redesign (existing design but no feedbacks)');
+    }
+    else if (verbose) {
+        logInfo('✨ Mode: New Design (no existing design)');
+    }
+    const designPrompt = createTechnicalDesignPromptWithContext(featureId, finalContextInfo, existingTechnicalDesign, isIncrementalUpdate);
     return {
         featureName: context.feature.name,
         featureDescription: context.feature.description || undefined,
         designPrompt,
+        hasExistingDesign,
+        hasFeedbacks,
     };
 }
 /**

package/dist/prompts/technical-design.d.ts

@@ -1,3 +1,3 @@
 import { EdsgerConfig } from '../types/index.js';
 export declare const createTechnicalDesignSystemPrompt: (_config: EdsgerConfig, mcpServerUrl?: string, mcpToken?: string, featureId?: string) => string;
-export declare const createTechnicalDesignPromptWithContext: (featureId: string, contextInfo: string) => string;
+export declare const createTechnicalDesignPromptWithContext: (featureId: string, contextInfo: string, existingTechnicalDesign?: string | null, isIncrementalUpdate?: boolean) => string;

package/dist/prompts/technical-design.js

@@ -89,11 +89,58 @@ IMPORTANT: In the checklist context, look for lines that say "ID: [UUID]" in the
 
 Focus on systematic technical design based on the provided context information.${mcpInstructions}`;
 };
-export const createTechnicalDesignPromptWithContext = (featureId, contextInfo) => {
-    return `Generate a comprehensive technical design for feature ID: ${featureId}
+export const createTechnicalDesignPromptWithContext = (featureId, contextInfo, existingTechnicalDesign, isIncrementalUpdate = false) => {
+    // If incremental update mode (existing design + feedbacks), create focused update prompt
+    if (isIncrementalUpdate && existingTechnicalDesign) {
+        return `Update the technical design for feature ID: ${featureId} based on human feedbacks
+
+## Current Technical Design
+
+${existingTechnicalDesign}
+
+## Context and Feedbacks
 
 ${contextInfo}
 
+## IMPORTANT: Incremental Update Mode
+
+You are in **INCREMENTAL UPDATE** mode. This means:
+
+1. **DO NOT redesign from scratch** - The current technical design is already approved
+2. **Focus ONLY on the feedbacks provided** - Address each feedback point specifically
+3. **Make targeted modifications** - Only change the sections that feedbacks request
+4. **Preserve approved sections** - Keep all parts of the design that are not mentioned in feedbacks
+5. **Track changes** - In your summary, clearly indicate what was modified and why
+
+## Update Instructions
+
+Follow this focused approach:
+
+1. **Review Current Design**: Carefully read the existing technical design above
+2. **Analyze Feedbacks**: Understand what specific changes are requested in the feedbacks
+3. **Make Targeted Updates**:
+   - Address each feedback point one by one
+   - Modify only the relevant sections of the design
+   - Preserve the structure and content of unchanged sections
+4. **Verify Completeness**: Ensure all feedbacks have been addressed
+
+## Important Notes
+- This is NOT a full redesign - only update what feedbacks specifically request
+- Maintain consistency with the existing design's structure and style
+- If a feedback is unclear, make your best interpretation and note it in recommendations
+- Keep all approved content that is not mentioned in feedbacks
+- Your summary should list each feedback addressed and the changes made
+
+Begin by reviewing the feedbacks and identifying which sections of the current design need updates.`;
+    }
+    // Default mode: full design (either new design or full redesign)
+    const designMode = existingTechnicalDesign
+        ? 'Update and improve the existing technical design, or redesign if needed'
+        : 'Generate a comprehensive technical design';
+    return `${designMode} for feature ID: ${featureId}
+
+${existingTechnicalDesign ? `## Existing Technical Design\n\n${existingTechnicalDesign}\n\n` : ''}${contextInfo}
+
 ## Technical Design Instructions
 
 Follow this systematic approach:
@@ -122,7 +169,7 @@ Follow this systematic approach:
 - Focus on creating detailed architectural specifications
 - Consider the user stories to understand what needs to be built
 - Use test cases to inform testing strategy and validation approaches
-- Build upon existing technical design if available, or create from scratch
+${existingTechnicalDesign ? '- Build upon or improve the existing technical design provided above' : '- Create a complete new technical design from scratch'}
 - Consider integration with existing systems and architecture
 - Address scalability, maintainability, and performance requirements
 

package/dist/services/feedbacks.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Feedbacks service for pipeline integration
+ * Provides human-guided feedbacks to influence Claude Code behavior in each phase
+ */
+import { PipelinePhaseOptions } from '../types/pipeline.js';
+export type { PipelinePhaseOptions };
+export type FeedbackType = 'requirement' | 'constraint' | 'preference' | 'context' | 'quality_criteria';
+export interface Feedback {
+    id: string;
+    feature_id: string | null;
+    product_id: string | null;
+    phase: string;
+    feedback_type: FeedbackType;
+    title: string;
+    content: string;
+    priority: number;
+    is_active: boolean;
+    created_by: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface FeedbacksContext {
+    phase: string;
+    feature_id: string;
+    feedbacks: Feedback[];
+}
+/**
+ * Fetch feedbacks for a specific phase
+ * Includes both feature-level and product-level feedbacks
+ */
+export declare function getFeedbacksForPhase(options: PipelinePhaseOptions, phase: string): Promise<FeedbacksContext>;
+/**
+ * Format feedbacks context as string for LLM consumption
+ */
+export declare function formatFeedbacksForContext(context: FeedbacksContext): string;

package/dist/services/feedbacks.js

@@ -0,0 +1,142 @@
+/**
+ * Feedbacks service for pipeline integration
+ * Provides human-guided feedbacks to influence Claude Code behavior in each phase
+ */
+/**
+ * Fetch feedbacks for a specific phase
+ * Includes both feature-level and product-level feedbacks
+ */
+export async function getFeedbacksForPhase(options, phase) {
+    const { mcpServerUrl, mcpToken, featureId, verbose } = options;
+    // Convert phase name from hyphen to underscore format for database compatibility
+    // e.g., 'feature-analysis' -> 'feature_analysis'
+    const dbPhase = phase.replace(/-/g, '_');
+    if (verbose) {
+        console.log(`🔍 Fetching feedbacks: phase="${phase}" (db: "${dbPhase}"), feature_id="${featureId}"`);
+    }
+    const response = await fetch(`${mcpServerUrl}/mcp`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${mcpToken}`,
+        },
+        body: JSON.stringify({
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'feedbacks/get',
+            params: {
+                feature_id: featureId,
+                phase: dbPhase,
+            },
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to fetch feedbacks for phase "${phase}": ${response.status} ${response.statusText}. Response: ${errorText}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+        throw new Error(`MCP Error for phase "${phase}": ${data.error.message || JSON.stringify(data.error)}`);
+    }
+    // Handle empty result gracefully
+    if (!data.result) {
+        return {
+            phase,
+            feature_id: featureId,
+            feedbacks: [],
+        };
+    }
+    return data.result;
+}
+/**
+ * Format feedbacks context as string for LLM consumption
+ */
+export function formatFeedbacksForContext(context) {
+    if (!context.feedbacks || context.feedbacks.length === 0) {
+        return '';
+    }
+    // Group feedbacks by type
+    const grouped = groupBy(context.feedbacks, 'feedback_type');
+    const sections = [];
+    // Requirements
+    if (grouped.requirement && grouped.requirement.length > 0) {
+        sections.push(`## 📋 Additional Requirements\n\n${formatFeedbacksList(grouped.requirement)}`);
+    }
+    // Constraints
+    if (grouped.constraint && grouped.constraint.length > 0) {
+        sections.push(`## 🚫 Constraints\n\n${formatFeedbacksList(grouped.constraint)}`);
+    }
+    // Preferences
+    if (grouped.preference && grouped.preference.length > 0) {
+        sections.push(`## 💡 Preferences\n\n${formatFeedbacksList(grouped.preference)}`);
+    }
+    // Context
+    if (grouped.context && grouped.context.length > 0) {
+        sections.push(`## 🔍 Additional Context\n\n${formatFeedbacksList(grouped.context)}`);
+    }
+    // Quality Criteria
+    if (grouped.quality_criteria && grouped.quality_criteria.length > 0) {
+        sections.push(`## ✅ Quality Criteria\n\n${formatFeedbacksList(grouped.quality_criteria)}`);
+    }
+    const phaseDisplay = context.phase.replace(/_/g, '-');
+    return `
+---
+
+# 🎯 Human Feedbacks for ${phaseDisplay} Phase
+
+These feedbacks have been provided by the development team to guide your work in this phase. They represent domain knowledge, business constraints, and quality expectations that must be incorporated into your analysis and outputs.
+
+${sections.join('\n\n')}
+
+---
+
+**IMPORTANT**: These human-provided feedbacks are MANDATORY and take precedence over default behavior. Please ensure your work:
+- ✅ Satisfies ALL requirements listed above
+- ✅ Respects ALL constraints
+- ✅ Incorporates stated preferences where possible
+- ✅ Considers the additional context provided
+- ✅ Meets ALL quality criteria
+
+If any feedback conflicts with checklist items or other requirements, prioritize the human feedbacks and note any conflicts in your response.
+`;
+}
+/**
+ * Format a list of feedbacks with priority ordering
+ */
+function formatFeedbacksList(feedbacks) {
+    // Sort by priority (highest first)
+    const sorted = [...feedbacks].sort((a, b) => b.priority - a.priority);
+    return sorted
+        .map((feedback, idx) => {
+        const priorityBadge = getPriorityBadge(feedback.priority);
+        return `### ${idx + 1}. ${feedback.title} ${priorityBadge}\n\n${feedback.content}\n`;
+    })
+        .join('\n');
+}
+/**
+ * Get priority badge emoji
+ */
+function getPriorityBadge(priority) {
+    if (priority >= 9)
+        return '🔴'; // Critical
+    if (priority >= 7)
+        return '🟠'; // High
+    if (priority >= 5)
+        return '🟡'; // Medium
+    if (priority >= 3)
+        return '🟢'; // Low
+    return '⚪'; // Minimal
+}
+/**
+ * Group array of objects by a key
+ */
+function groupBy(array, key) {
+    return array.reduce((result, item) => {
+        const groupKey = String(item[key]);
+        if (!result[groupKey]) {
+            result[groupKey] = [];
+        }
+        result[groupKey].push(item);
+        return result;
+    }, {});
+}

package/package.json

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