edsger 0.77.0 → 0.79.0

package/dist/services/checklist.js

@@ -1,259 +0,0 @@
-/**
- * Checklist service for pipeline integration
- */
-import { callMcpEndpoint } from '../api/mcp-client.js';
-import { logDebug, logError, logInfo, logSuccess, logWarning, } from '../utils/logger.js';
-/**
- * Fetch checklists for a specific phase
- */
-export async function getChecklistsForPhase(options, phase) {
-    const { issueId } = options;
-    // Convert phase name from hyphen to underscore format for database compatibility
-    // e.g., 'issue-analysis' -> 'issue_analysis'
-    const dbPhase = phase.replace(/-/g, '_');
-    logInfo(`Fetching checklists: phase="${phase}" (db: "${dbPhase}"), issue_id="${issueId}"`);
-    const result = await callMcpEndpoint('checklists/phase', {
-        issue_id: issueId,
-        phase: dbPhase,
-    });
-    // Handle empty result gracefully
-    if (!result) {
-        return {
-            phase,
-            issue_id: issueId,
-            checklists: [],
-        };
-    }
-    return result;
-}
-/**
- * Validate checklist completion for a phase
- */
-export async function validateChecklistsForPhase(options, phase) {
-    const { issueId } = options;
-    // Convert phase name from hyphen to underscore format for database compatibility
-    const dbPhase = phase.replace(/-/g, '_');
-    const result = await callMcpEndpoint('checklists/validate', {
-        issue_id: issueId,
-        phase: dbPhase,
-    });
-    return result;
-}
-/**
- * Create checklist results (mark as started/in-progress)
- */
-export async function createChecklistResult(options, checklistId, itemResults) {
-    const { issueId } = options;
-    return await callMcpEndpoint('checklist_results/create', {
-        issue_id: issueId,
-        checklist_id: checklistId,
-        item_results: itemResults,
-    });
-}
-/**
- * Strictly validate that all required checklists have results
- * Returns error if any checklists exist but don't have results
- */
-export async function validateRequiredChecklistResults(options, phase, verbose) {
-    try {
-        // Get checklists for this phase
-        const checklistContext = await getChecklistsForPhase(options, phase);
-        // If no checklists exist for this phase, validation passes
-        if (!checklistContext.checklists ||
-            checklistContext.checklists.length === 0) {
-            if (verbose) {
-                logDebug(`No checklists found for phase ${phase} - validation passes`, verbose);
-            }
-            return { success: true, missingChecklists: [] };
-        }
-        // Validate checklist completion
-        const validation = await validateChecklistsForPhase(options, phase);
-        const missingChecklists = [];
-        // Check each checklist to ensure it has been addressed with results
-        for (const checklistValidation of validation.checklists_validation) {
-            // If checklist exists but has no result created (status is 'not_started')
-            if (checklistValidation.status === 'not_started') {
-                missingChecklists.push(checklistValidation.checklist_name);
-            }
-        }
-        if (missingChecklists.length > 0) {
-            const errorMsg = `Phase ${phase} has ${checklistContext.checklists.length} MANDATORY checklists but ${missingChecklists.length} are missing results. All checklists must be addressed. Missing: ${missingChecklists.join(', ')}`;
-            if (verbose) {
-                logError(errorMsg);
-            }
-            return {
-                success: false,
-                error: errorMsg,
-                missingChecklists,
-            };
-        }
-        if (verbose) {
-            logSuccess(`All ${validation.checklists_validation.length} mandatory checklists for phase ${phase} have been addressed`);
-        }
-        return { success: true, missingChecklists: [] };
-    }
-    catch (error) {
-        const errorMsg = `Failed to validate mandatory checklist compliance for phase ${phase}: ${error instanceof Error ? error.message : String(error)}`;
-        return {
-            success: false,
-            error: errorMsg,
-            missingChecklists: [],
-        };
-    }
-}
-/**
- * Create checklist item result
- */
-export async function createChecklistItemResult(options, checklistItemId, isPassed, value, notes) {
-    const { issueId } = options;
-    return await callMcpEndpoint('checklist_item_results/create', {
-        issue_id: issueId,
-        checklist_item_id: checklistItemId,
-        is_passed: isPassed,
-        value,
-        notes,
-    });
-}
-/**
- * Log individual checklist item results for debugging
- */
-function logChecklistItemResults(itemResults, verbose) {
-    for (const itemResult of itemResults) {
-        const status = itemResult.is_passed ? 'PASS' : 'FAIL';
-        logDebug(`  ${status} Item: ${String(itemResult.checklist_item_id)}`, verbose);
-        if (itemResult.notes) {
-            logDebug(`     Notes: ${String(itemResult.notes)}`, verbose);
-        }
-    }
-}
-/**
- * Process checklist item results from phase JSON response and create MCP results
- */
-export async function processChecklistItemResultsFromResponse(options, phase, checklistItemResults, verbose) {
-    const errors = [];
-    let created = 0;
-    if (!checklistItemResults || checklistItemResults.length === 0) {
-        if (verbose) {
-            logDebug('No checklist item results to process', verbose);
-        }
-        return { created, errors };
-    }
-    // Get current checklists to map checklist_item_id to checklist_id
-    const checklistContext = await getChecklistsForPhase(options, phase);
-    // Create a map from checklist_item_id to checklist_id
-    const itemToChecklistMap = new Map();
-    const checklistIds = new Set();
-    for (const checklist of checklistContext.checklists) {
-        checklistIds.add(checklist.id);
-        for (const item of checklist.items) {
-            itemToChecklistMap.set(item.id, checklist.id);
-        }
-    }
-    // Group checklist item results by checklist
-    const resultsByChecklist = new Map();
-    for (const result of checklistItemResults) {
-        const checklistId = itemToChecklistMap.get(result.checklist_item_id);
-        if (!checklistId) {
-            const errorMsg = `Could not find checklist for item ${result.checklist_item_id}`;
-            errors.push(errorMsg);
-            if (verbose) {
-                logError(errorMsg);
-            }
-            continue;
-        }
-        if (!resultsByChecklist.has(checklistId)) {
-            resultsByChecklist.set(checklistId, []);
-        }
-        const items = resultsByChecklist.get(checklistId);
-        items?.push({
-            checklist_item_id: result.checklist_item_id,
-            is_passed: result.is_passed,
-            value: result.value,
-            notes: result.notes,
-        });
-    }
-    // Create checklist results with item results for each checklist
-    for (const [checklistId, itemResults] of resultsByChecklist) {
-        try {
-            await createChecklistResult(options, checklistId, itemResults);
-            created += itemResults.length;
-            logInfo(`Created checklist result for ${checklistId} with ${itemResults.length} item results`);
-            logChecklistItemResults(itemResults, verbose);
-        }
-        catch (error) {
-            const errorMsg = `Failed to create checklist result for ${checklistId}: ${error instanceof Error ? error.message : String(error)}`;
-            errors.push(errorMsg);
-            if (verbose) {
-                logError(errorMsg);
-            }
-        }
-    }
-    return { created, errors };
-}
-/**
- * Process checklist results from phase JSON response and create MCP results
- */
-export async function processChecklistResultsFromResponse(options, checklistResults, verbose) {
-    const errors = [];
-    let created = 0;
-    if (!checklistResults || checklistResults.length === 0) {
-        if (verbose) {
-            logDebug('No checklist results to process', verbose);
-        }
-        return { created, errors };
-    }
-    for (const result of checklistResults) {
-        if (!result.satisfied) {
-            // For unsatisfied checklists, log and continue
-            logWarning(`Checklist ${result.checklist_id} marked as NOT satisfied`);
-            if (result.notes) {
-                logDebug(`   Reason: ${result.notes}`, verbose);
-            }
-            continue;
-        }
-        try {
-            await createChecklistResult(options, result.checklist_id);
-            created++;
-            logSuccess(`Created checklist result for: ${result.checklist_id}`);
-            if (result.notes) {
-                logDebug(`   Notes: ${result.notes}`, verbose);
-            }
-        }
-        catch (error) {
-            const errorMsg = `Failed to create checklist result for ${result.checklist_id}: ${error instanceof Error ? error.message : String(error)}`;
-            errors.push(errorMsg);
-            if (verbose) {
-                logError(errorMsg);
-            }
-        }
-    }
-    return { created, errors };
-}
-/**
- * Format checklist context as string for LLM consumption
- */
-export function formatChecklistsForContext(context) {
-    if (!context.checklists || context.checklists.length === 0) {
-        return `No checklists defined for phase: ${context.phase}`;
-    }
-    const sections = context.checklists
-        .map((checklist) => {
-        const itemsText = checklist.items
-            .map((item) => `  - **${item.title}** (ID: ${item.id})${item.is_required ? ' (required)' : ''}: ${item.description || 'No description'}`)
-            .join('\n');
-        const phasesLabel = checklist.phases?.length > 0
-            ? ` [Phases: ${checklist.phases.join(', ')}]`
-            : '';
-        return `**${checklist.name}** (${checklist.role})${phasesLabel}
-ID: ${checklist.id}
-${checklist.description || 'No description'}
-Items:
-${itemsText}`;
-    })
-        .join('\n\n');
-    return `# Checklists for ${context.phase} phase
-
-${sections}
-
-Please review these checklists and ensure your work addresses the relevant requirements for your role. These checklists will be used to validate the completion of this phase.`;
-}

package/dist/services/coaching/coaching-agent.d.ts

@@ -1,39 +0,0 @@
-/**
- * Coaching Agent
- * Analyzes the execution agent's self-rating and produces improvement suggestions.
- * Decides whether the execution agent should continue optimizing or move on.
- */
-import { type PhaseRating, type RatablePhase } from '../phase-ratings.js';
-/** Coaching agent's decision */
-export interface CoachingDecision {
-    /** Whether the execution agent should continue optimizing */
-    shouldContinue: boolean;
-    /** Specific, actionable improvement suggestions */
-    suggestions: string[];
-    /** Reasoning for the decision */
-    reasoning: string;
-    /** Priority areas to focus on (criteria names) */
-    focusAreas: string[];
-}
-export interface RunCoachingAgentParams {
-    phase: RatablePhase;
-    currentRating: PhaseRating;
-    previousRatings: PhaseRating[];
-    iteration: number;
-    sessionId?: string;
-    verbose?: boolean;
-}
-export interface CoachingAgentResult {
-    decision: CoachingDecision;
-    sessionId: string;
-}
-/**
- * Run the coaching agent to analyze a self-rating and produce a decision.
- * Maintains its own session for context continuity across iterations.
- */
-export declare function runCoachingAgent(params: RunCoachingAgentParams): Promise<CoachingAgentResult | null>;
-/**
- * Build the improvement prompt that will be sent to the execution agent,
- * based on the coaching agent's suggestions.
- */
-export declare function buildImprovementPrompt(decision: CoachingDecision, rating: PhaseRating, phase?: RatablePhase): string;

package/dist/services/coaching/coaching-agent.js

@@ -1,308 +0,0 @@
-/**
- * Coaching Agent
- * Analyzes the execution agent's self-rating and produces improvement suggestions.
- * Decides whether the execution agent should continue optimizing or move on.
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-/**
- * Extract text content from assistant message content array
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function extractTextContent(content) {
-    let text = '';
-    for (const item of content) {
-        if (item.type === 'text') {
-            text += item.text;
-        }
-    }
-    return text;
-}
-/** JSON output format templates per phase category.
- *
- * For issue_analysis the contract is two blocks (sentinel-delimited
- * markdown plan + a small JSON metadata block). The coaching agent
- * re-emits the same form so the parseAnalysisResult downstream can
- * pick up the improved plan without reformatting.
- */
-const PHASE_JSON_TEMPLATES = {
-    issue_analysis: `<<<EXECUTION_PLAN>>>
-# Execution Plan
-
-## Issue type
-<bug | feature | refactor | infra | spike | docs | hybrid>
-
-## Summary
-<2-3 sentences>
-
-## Artifacts (in execution order)
-
-### 1. <artifact-name>
-**Why**: <why this issue needs this artifact>
-**Success criteria**: <concrete, issue-specific>
-**Depends on**: <none | previous artifact name>
-
-## Risks / open questions
-- <thing a human should resolve>
-<<<END_EXECUTION_PLAN>>>
-
-\`\`\`json
-{
-  "analysis": {
-    "status": "success",
-    "summary": "..."
-  }
-}
-\`\`\``,
-    user_stories_analysis: `\`\`\`json
-{
-  "analysis": {
-    "created_user_stories": [{ "title": "...", "description": "..." }],
-    "summary": "..."
-  }
-}
-\`\`\``,
-    test_cases_analysis: `\`\`\`json
-{
-  "analysis": {
-    "created_test_cases": [{ "name": "...", "description": "...", "is_critical": true/false }],
-    "summary": "..."
-  }
-}
-\`\`\``,
-    technical_design: `\`\`\`json
-{
-  "technical_design_result": {
-    "issue_id": "...",
-    "status": "success",
-    "summary": "...",
-    "technical_design": "The COMPLETE improved technical design in markdown"
-  }
-}
-\`\`\``,
-};
-/** Build the coaching agent's system prompt */
-function buildCoachingSystemPrompt() {
-    return `You are a senior AI quality coach. Your job is to analyze an execution agent's self-rating and decide whether its output needs further improvement.
-
-Your goal is perfection — the target is 100/100 on all criteria.
-
-Rules:
-1. Be specific and actionable. Vague advice like "improve quality" is useless.
-2. Focus on the weakest criteria first — that's where the biggest gains are.
-3. If the agent scored itself too generously, call it out.
-4. Only recommend stopping when further optimization has diminishing returns — e.g., all criteria are 90+ and weaknesses are minor.
-5. Your suggestions must be concrete enough that the execution agent can act on them immediately.
-
-Respond with ONLY a JSON block.`;
-}
-/** Build the coaching analysis prompt */
-function buildCoachingPrompt(phase, rating, iteration, previousRatings) {
-    let prompt = `## Phase: ${phase} (iteration ${iteration})
-
-## Current Self-Rating
-- **Overall Score**: ${rating.score}/100
-- **Summary**: ${rating.summary}
-
-### Criteria Scores:
-${Object.entries(rating.criteria_scores)
-        .map(([k, v]) => `- ${k}: ${v.score}/100 — ${v.reason}`)
-        .join('\n')}
-
-### Strengths:
-${rating.strengths.map((s) => `- ${s}`).join('\n')}
-
-### Weaknesses:
-${rating.weaknesses.map((w) => `- ${w}`).join('\n')}`;
-    // Show improvement trend if we have previous ratings
-    if (previousRatings.length > 0) {
-        prompt += `\n\n## Improvement History`;
-        for (let i = 0; i < previousRatings.length; i++) {
-            const prev = previousRatings[i];
-            prompt += `\n- Iteration ${i + 1}: ${prev.score}/100`;
-        }
-        prompt += `\n- Iteration ${iteration} (current): ${rating.score}/100`;
-        // Detect stagnation
-        if (previousRatings.length >= 2) {
-            const last = previousRatings[previousRatings.length - 1];
-            const secondLast = previousRatings[previousRatings.length - 2];
-            if (Math.abs(rating.score - last.score) <= 2 &&
-                Math.abs(last.score - secondLast.score) <= 2) {
-                prompt += `\n\n⚠️ Score has been flat for 3 iterations. Consider whether the remaining gaps are addressable.`;
-            }
-        }
-    }
-    prompt += `\n\nAnalyze the rating and decide: should the agent continue optimizing, or is this good enough?
-
-\`\`\`json
-{
-  "coaching_decision": {
-    "should_continue": <true/false>,
-    "reasoning": "<why continue or stop>",
-    "focus_areas": ["<criteria to improve>"],
-    "suggestions": [
-      "<specific actionable suggestion 1>",
-      "<specific actionable suggestion 2>"
-    ]
-  }
-}
-\`\`\``;
-    return prompt;
-}
-/** Parse the coaching agent's response */
-function parseCoachingDecision(response, verbose) {
-    try {
-        const jsonMatch = response.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-        const jsonStr = jsonMatch ? jsonMatch[1] : response;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let parsed;
-        try {
-            parsed = JSON.parse(jsonStr);
-        }
-        catch {
-            const decisionMatch = jsonStr.match(/\{[\s\S]*"coaching_decision"[\s\S]*\}/);
-            if (decisionMatch) {
-                parsed = JSON.parse(decisionMatch[0]);
-            }
-            else {
-                throw new Error('No coaching_decision JSON found');
-            }
-        }
-        const decision = parsed.coaching_decision || parsed;
-        return {
-            shouldContinue: Boolean(decision.should_continue),
-            reasoning: String(decision.reasoning || ''),
-            focusAreas: Array.isArray(decision.focus_areas)
-                ? decision.focus_areas.map(String)
-                : [],
-            suggestions: Array.isArray(decision.suggestions)
-                ? decision.suggestions.map(String)
-                : [],
-        };
-    }
-    catch (error) {
-        logError(`Failed to parse coaching decision: ${error instanceof Error ? error.message : String(error)}`);
-        if (verbose) {
-            logDebug(`Raw response: ${response.substring(0, 500)}`, verbose);
-        }
-        return null;
-    }
-}
-/**
- * Run the coaching agent to analyze a self-rating and produce a decision.
- * Maintains its own session for context continuity across iterations.
- */
-// eslint-disable-next-line complexity -- agent loop with session management and message processing
-export async function runCoachingAgent(params) {
-    const { phase, currentRating, previousRatings, iteration, verbose } = params;
-    const coachingPrompt = buildCoachingPrompt(phase, currentRating, iteration, previousRatings);
-    if (verbose) {
-        logInfo(`🎯 Coaching agent analyzing iteration ${iteration} (score: ${currentRating.score}/100)...`);
-    }
-    let resultText = '';
-    let sessionId = params.sessionId || '';
-    try {
-        for await (const message of query({
-            prompt: coachingPrompt,
-            options: {
-                systemPrompt: buildCoachingSystemPrompt(),
-                model: DEFAULT_MODEL,
-                maxTurns: 1000,
-                permissionMode: 'bypassPermissions',
-                ...(params.sessionId ? { resume: params.sessionId } : {}),
-            },
-        })) {
-            if (message.type === 'assistant') {
-                resultText += extractTextContent(message.message?.content ?? []);
-                continue;
-            }
-            if (message.type === 'result') {
-                sessionId = message.session_id || sessionId;
-                if (message.subtype === 'success' && message.result) {
-                    resultText = message.result;
-                }
-            }
-        }
-        let decision = parseCoachingDecision(resultText, verbose);
-        if (!decision) {
-            // Retry once: resume session and ask for valid JSON
-            if (verbose) {
-                logInfo('🔄 Coaching agent returned invalid JSON. Retrying...');
-            }
-            let retryText = '';
-            for await (const message of query({
-                prompt: 'Your previous response was not valid JSON. Please respond with ONLY the JSON block in the exact format requested.',
-                options: {
-                    resume: sessionId,
-                    model: DEFAULT_MODEL,
-                    maxTurns: 1000,
-                    permissionMode: 'bypassPermissions',
-                },
-            })) {
-                if (message.type === 'assistant') {
-                    retryText += extractTextContent(message.message?.content ?? []);
-                    continue;
-                }
-                if (message.type !== 'result') {
-                    continue;
-                }
-                sessionId = message.session_id || sessionId;
-                if (message.subtype === 'success' && message.result) {
-                    retryText = message.result;
-                }
-            }
-            decision = parseCoachingDecision(retryText, verbose);
-            if (!decision) {
-                logError('Coaching agent failed to produce a valid decision after retry');
-                return null;
-            }
-        }
-        if (verbose) {
-            logInfo(`🎯 Coaching decision: ${decision.shouldContinue ? '🔄 Continue optimizing' : '✅ Good enough'}`);
-            logInfo(`   Reasoning: ${decision.reasoning}`);
-            if (decision.focusAreas.length > 0) {
-                logInfo(`   Focus areas: ${decision.focusAreas.join(', ')}`);
-            }
-            if (decision.suggestions.length > 0) {
-                decision.suggestions.forEach((s, i) => logInfo(`   ${i + 1}. ${s}`));
-            }
-        }
-        return { decision, sessionId };
-    }
-    catch (error) {
-        logError(`Coaching agent failed: ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}
-/**
- * Build the improvement prompt that will be sent to the execution agent,
- * based on the coaching agent's suggestions.
- */
-export function buildImprovementPrompt(decision, rating, phase) {
-    const jsonTemplate = phase ? PHASE_JSON_TEMPLATES[phase] : null;
-    let prompt = `Your previous output scored ${rating.score}/100. The target is 100/100.
-
-## Coaching Feedback
-
-${decision.reasoning}
-
-## Priority Focus Areas
-${decision.focusAreas.map((a) => `- **${a}**: score was ${rating.criteria_scores[a]?.score ?? '?'}/100`).join('\n')}
-
-## Specific Improvements Required
-${decision.suggestions.map((s, i) => `${i + 1}. ${s}`).join('\n')}
-
-## Your Weaknesses to Address
-${rating.weaknesses.map((w) => `- ${w}`).join('\n')}
-
-Now improve your output based on this feedback. Focus on the priority areas and address every suggestion above. Do not just make superficial changes — aim for substantive quality improvement.`;
-    if (jsonTemplate) {
-        prompt += `
-
-**CRITICAL**: Output your complete improved result in this exact JSON format:
-
-${jsonTemplate}`;
-    }
-    return prompt;
-}

package/dist/services/coaching/coaching-loop.d.ts

@@ -1,62 +0,0 @@
-/**
- * Coaching Loop Orchestrator
- * Orchestrates the execute → self-rate → coach → improve cycle.
- * The loop runs until the coaching agent decides to stop.
- * Stagnation safety: exits if score doesn't improve by MIN_IMPROVEMENT
- * over STAGNATION_WINDOW consecutive iterations.
- */
-import { type PhaseRating, type RatablePhase } from '../phase-ratings.js';
-import { type CoachingDecision } from './coaching-agent.js';
-import { type SelfRatingChecklistItem } from './self-rating.js';
-/**
- * Callback to persist the execution agent's improved output.
- * Each phase provides its own implementation (e.g. save design to DB).
- *
- * @param executionSessionId - the agent's session ID
- * @param responseText - the agent's full response text containing the improved output
- */
-export type OnImprovedCallback = (executionSessionId: string, responseText: string) => Promise<void>;
-/** Options for the coaching loop */
-export interface CoachingLoopOptions {
-    issueId: string;
-    phase: RatablePhase;
-    /** The initial execution session ID (from the first phase execution) */
-    executionSessionId: string;
-    /** Callback to persist improved output after each coaching iteration */
-    onImproved?: OnImprovedCallback;
-    /** Checklist items for self-rating context (so agent rates against actual quality gates) */
-    checklistItems?: SelfRatingChecklistItem[];
-    verbose?: boolean;
-}
-/** Result of the coaching loop */
-export interface CoachingLoopResult {
-    /** Final score after all coaching iterations */
-    finalScore: number;
-    /** Total coaching iterations performed */
-    iterations: number;
-    /** All ratings from each iteration */
-    ratings: PhaseRating[];
-    /** The execution agent's session ID (for verification to reference) */
-    executionSessionId: string;
-    /** The coaching agent's session ID */
-    coachingSessionId: string | null;
-    /** Final coaching decision */
-    finalDecision: CoachingDecision | null;
-    /** Why the loop exited */
-    exitReason: 'coaching_satisfied' | 'stagnation' | 'max_iterations' | 'self_rating_failed' | 'coaching_failed' | 'improvement_failed';
-}
-/**
- * Detect stagnation: score hasn't improved by MIN_IMPROVEMENT
- * over the last STAGNATION_WINDOW iterations.
- */
-export declare function isStagnant(ratings: PhaseRating[]): boolean;
-/**
- * Run the coaching loop:
- * 1. Ask execution agent to self-rate (resume session)
- * 2. Write rating to DB
- * 3. Check stagnation — force exit if score is flat
- * 4. Coaching agent analyzes → decide continue or stop
- * 5. If continue: send improvement prompt to execution agent, call onImproved → go to 1
- * 6. If stop: return result
- */
-export declare function runCoachingLoop(options: CoachingLoopOptions): Promise<CoachingLoopResult>;