edsger 0.76.0 → 0.78.0

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

@@ -1,265 +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 { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.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;
-}
-/**
- * Process assistant content and return accumulated text
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function processAssistantContent(content, verbose) {
-    let text = '';
-    for (const item of content) {
-        if (item.type === 'text') {
-            text += `${item.text}\n`;
-            logDebug(`🤖 ${item.text}`, verbose);
-        }
-        else if (item.type === 'tool_use') {
-            logDebug(`🔧 ${item.name}: ${item.input?.description || 'Running...'}`, verbose);
-        }
-    }
-    return text;
-}
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-import { createPhaseRating, updatePhaseRatingCoachingAnalysis, } from '../phase-ratings.js';
-import { buildImprovementPrompt, runCoachingAgent, } from './coaching-agent.js';
-import { buildSelfRatingPrompt, parseSelfRating, } from './self-rating.js';
-/** Minimum score improvement required over STAGNATION_WINDOW iterations */
-const MIN_IMPROVEMENT = 3;
-/** Number of consecutive iterations to check for stagnation */
-const STAGNATION_WINDOW = 3;
-/** Safety hard cap to prevent runaway loops (coaching agent decides when to stop, this is a failsafe) */
-const MAX_ITERATIONS = 50;
-/**
- * Detect stagnation: score hasn't improved by MIN_IMPROVEMENT
- * over the last STAGNATION_WINDOW iterations.
- */
-export function isStagnant(ratings) {
-    if (ratings.length < STAGNATION_WINDOW) {
-        return false;
-    }
-    const recent = ratings.slice(-STAGNATION_WINDOW);
-    const improvement = recent[recent.length - 1].score - recent[0].score;
-    return improvement < MIN_IMPROVEMENT;
-}
-/**
- * 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
- */
-// eslint-disable-next-line complexity -- coaching loop with rating, decision, and improvement cycles
-export async function runCoachingLoop(options) {
-    const { issueId, phase, onImproved, checklistItems, verbose } = options;
-    let { executionSessionId } = options;
-    let coachingSessionId = null;
-    const allRatings = [];
-    let iteration = 0;
-    let finalDecision = null;
-    let exitReason = 'coaching_satisfied';
-    if (verbose) {
-        logInfo(`\n🏋️ Starting coaching loop for ${phase}...`);
-    }
-    while (iteration < MAX_ITERATIONS) {
-        iteration++;
-        // Step 1: Ask execution agent to self-rate
-        if (verbose) {
-            logInfo(`\n📊 Coaching iteration ${iteration}: requesting self-rating...`);
-        }
-        const rating = await requestSelfRating(executionSessionId, phase, checklistItems, verbose);
-        if (!rating) {
-            logError(`Self-rating failed at iteration ${iteration}. Exiting coaching loop.`);
-            exitReason = 'self_rating_failed';
-            break;
-        }
-        if (verbose) {
-            logInfo(`📊 Self-rating: ${rating.score}/100 — ${rating.summary}`);
-        }
-        // Step 2: Write rating to DB (capture ID for coaching_analysis update)
-        const ratingId = await createPhaseRating({
-            issueId,
-            phase,
-            rating,
-            ratingType: 'ai_self',
-            iteration,
-            metadata: {
-                execution_session_id: executionSessionId,
-                coaching_session_id: coachingSessionId,
-            },
-        }, verbose);
-        allRatings.push(rating);
-        // Step 3: Stagnation check
-        if (isStagnant(allRatings)) {
-            if (verbose) {
-                logInfo(`\n⚠️ Stagnation detected: score improved < ${MIN_IMPROVEMENT} points over last ${STAGNATION_WINDOW} iterations. Exiting.`);
-            }
-            exitReason = 'stagnation';
-            break;
-        }
-        // Step 4: Coaching agent analyzes
-        const coachingResult = await runCoachingAgent({
-            phase,
-            currentRating: rating,
-            previousRatings: allRatings.slice(0, -1),
-            iteration,
-            sessionId: coachingSessionId || undefined,
-            verbose,
-        });
-        if (!coachingResult) {
-            logError(`Coaching agent failed at iteration ${iteration}. Exiting coaching loop.`);
-            exitReason = 'coaching_failed';
-            break;
-        }
-        coachingSessionId = coachingResult.sessionId;
-        finalDecision = coachingResult.decision;
-        // Step 4b: Write coaching analysis back to the rating record
-        if (ratingId) {
-            await updatePhaseRatingCoachingAnalysis(ratingId, {
-                should_continue: coachingResult.decision.shouldContinue,
-                reasoning: coachingResult.decision.reasoning,
-                focus_areas: coachingResult.decision.focusAreas,
-                suggestions: coachingResult.decision.suggestions,
-            }, verbose);
-        }
-        // Step 5: Decision
-        if (!coachingResult.decision.shouldContinue) {
-            if (verbose) {
-                logInfo(`\n✅ Coaching loop complete after ${iteration} iteration(s). Final score: ${rating.score}/100`);
-                logInfo(`   Reason: ${coachingResult.decision.reasoning}`);
-            }
-            exitReason = 'coaching_satisfied';
-            break;
-        }
-        // Step 6: Send improvement prompt to execution agent
-        if (verbose) {
-            logInfo(`\n🔄 Coaching agent requested improvement. Sending feedback to execution agent...`);
-        }
-        const improvementPrompt = buildImprovementPrompt(coachingResult.decision, rating, phase);
-        const improveResult = await sendImprovementToExecutionAgent(executionSessionId, improvementPrompt, verbose);
-        if (!improveResult) {
-            logError(`Execution agent failed to improve at iteration ${iteration}. Exiting coaching loop.`);
-            exitReason = 'improvement_failed';
-            break;
-        }
-        executionSessionId = improveResult.sessionId;
-        // Step 7: Persist improved output via callback
-        if (onImproved) {
-            try {
-                await onImproved(executionSessionId, improveResult.responseText);
-                if (verbose) {
-                    logDebug('💾 Improved output saved.', verbose);
-                }
-            }
-            catch (error) {
-                logError(`Failed to save improved output: ${error instanceof Error ? error.message : String(error)}`);
-                // Don't break — the improvement still happened in the agent's session
-            }
-        }
-    }
-    // Safety cap reached
-    if (iteration >= MAX_ITERATIONS) {
-        logError(`Coaching loop hit safety cap (${MAX_ITERATIONS} iterations). Exiting.`);
-        exitReason = 'max_iterations';
-    }
-    return {
-        finalScore: allRatings.length > 0 ? allRatings[allRatings.length - 1].score : 0,
-        iterations: iteration,
-        ratings: allRatings,
-        executionSessionId,
-        coachingSessionId,
-        finalDecision,
-        exitReason,
-    };
-}
-/**
- * Resume the execution agent's session and ask it to self-rate
- */
-async function requestSelfRating(sessionId, phase, checklistItems, verbose) {
-    const ratingPrompt = buildSelfRatingPrompt(phase, checklistItems);
-    let resultText = '';
-    try {
-        for await (const message of query({
-            prompt: ratingPrompt,
-            options: {
-                resume: sessionId,
-                model: DEFAULT_MODEL,
-                maxTurns: 1000,
-                permissionMode: 'bypassPermissions',
-            },
-        })) {
-            if (message.type === 'assistant') {
-                resultText += extractTextContent(message.message?.content ?? []);
-                continue;
-            }
-            if (message.type === 'result' &&
-                message.subtype === 'success' &&
-                message.result) {
-                resultText = message.result;
-            }
-        }
-        return parseSelfRating(resultText, phase, verbose);
-    }
-    catch (error) {
-        logError(`Self-rating request failed: ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}
-/**
- * Resume the execution agent's session and send improvement instructions.
- * Returns the session ID AND the agent's response text (so callers can extract improved output).
- */
-async function sendImprovementToExecutionAgent(sessionId, improvementPrompt, verbose) {
-    let newSessionId = sessionId;
-    let responseText = '';
-    try {
-        for await (const message of query({
-            prompt: improvementPrompt,
-            options: {
-                resume: sessionId,
-                model: DEFAULT_MODEL,
-                maxTurns: 1000,
-                permissionMode: 'bypassPermissions',
-            },
-        })) {
-            if (message.type === 'assistant') {
-                responseText += processAssistantContent(message.message?.content ?? [], verbose);
-                continue;
-            }
-            if (message.type === 'result') {
-                newSessionId = message.session_id || newSessionId;
-                if (message.subtype === 'success' && message.result) {
-                    responseText = message.result;
-                }
-                else if (message.subtype !== 'success') {
-                    logError(`Execution agent improvement incomplete: ${message.subtype}`);
-                    return null;
-                }
-            }
-        }
-        return { sessionId: newSessionId, responseText };
-    }
-    catch (error) {
-        logError(`Improvement request failed: ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}

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

@@ -1,8 +0,0 @@
-/**
- * Coaching Module
- * Self-rating, coaching agent, and coaching loop for AI quality improvement.
- */
-export { buildImprovementPrompt, type CoachingAgentResult, type CoachingDecision, runCoachingAgent, type RunCoachingAgentParams, } from './coaching-agent.js';
-export { type CoachingLoopOptions, type CoachingLoopResult, isStagnant, type OnImprovedCallback, runCoachingLoop, } from './coaching-loop.js';
-export { extractChecklistItems, type PhaseCoachingParams, type PhaseCoachingResult, runPhaseCoaching, } from './phase-coaching.js';
-export { buildSelfRatingPrompt, getCriteriaForPhase, parseSelfRating, type SelfRatingChecklistItem, } from './self-rating.js';

package/dist/services/coaching/index.js

@@ -1,8 +0,0 @@
-/**
- * Coaching Module
- * Self-rating, coaching agent, and coaching loop for AI quality improvement.
- */
-export { buildImprovementPrompt, runCoachingAgent, } from './coaching-agent.js';
-export { isStagnant, runCoachingLoop, } from './coaching-loop.js';
-export { extractChecklistItems, runPhaseCoaching, } from './phase-coaching.js';
-export { buildSelfRatingPrompt, getCriteriaForPhase, parseSelfRating, } from './self-rating.js';

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

@@ -1,47 +0,0 @@
-/**
- * Shared phase coaching integration helper.
- * Eliminates copy-paste coaching code across phases.
- *
- * Each phase calls runPhaseCoaching() between execute and verify.
- */
-import { type WithExecutionSessionId } from '../../types/index.js';
-import { type ChecklistPhaseContext } from '../checklist.js';
-import { type RatablePhase } from '../phase-ratings.js';
-import { type CoachingLoopResult, type OnImprovedCallback } from './coaching-loop.js';
-import { type SelfRatingChecklistItem } from './self-rating.js';
-/**
- * Extract checklist items from ChecklistPhaseContext for self-rating.
- */
-export declare function extractChecklistItems(checklistContext?: ChecklistPhaseContext | null): SelfRatingChecklistItem[] | undefined;
-export interface PhaseCoachingParams {
-    issueId: string;
-    phase: RatablePhase;
-    /** The phase result object containing execution_session_id */
-    phaseResult: WithExecutionSessionId;
-    /** Callback to persist improved output after each coaching iteration */
-    onImproved?: OnImprovedCallback;
-    /** Checklist items for self-rating context */
-    checklistItems?: SelfRatingChecklistItem[];
-    verbose?: boolean;
-}
-export interface PhaseCoachingResult {
-    /** Updated execution session ID (may change during coaching) */
-    executionSessionId: string;
-    /** Full coaching loop result, null if coaching was skipped */
-    coaching: CoachingLoopResult | null;
-}
-/**
- * Run coaching for a phase. Call this between execute and verify.
- *
- * If the phase result has no execution_session_id, coaching is skipped.
- *
- * Usage:
- *   const { executionSessionId } = await runPhaseCoaching({
- *     issueId,
- *     phase: 'technical_design',
- *     phaseResult: structuredResult,
- *     onImproved: async () => { ... re-save output ... },
- *     verbose,
- *   })
- */
-export declare function runPhaseCoaching(params: PhaseCoachingParams): Promise<PhaseCoachingResult>;

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

@@ -1,60 +0,0 @@
-/**
- * Shared phase coaching integration helper.
- * Eliminates copy-paste coaching code across phases.
- *
- * Each phase calls runPhaseCoaching() between execute and verify.
- */
-import { logInfo } from '../../utils/logger.js';
-import { runCoachingLoop, } from './coaching-loop.js';
-/**
- * Extract checklist items from ChecklistPhaseContext for self-rating.
- */
-export function extractChecklistItems(checklistContext) {
-    if (!checklistContext || checklistContext.checklists.length === 0) {
-        return undefined;
-    }
-    return checklistContext.checklists.flatMap((c) => c.items.map((item) => ({
-        id: item.id,
-        title: item.title,
-        description: item.description || undefined,
-    })));
-}
-/**
- * Run coaching for a phase. Call this between execute and verify.
- *
- * If the phase result has no execution_session_id, coaching is skipped.
- *
- * Usage:
- *   const { executionSessionId } = await runPhaseCoaching({
- *     issueId,
- *     phase: 'technical_design',
- *     phaseResult: structuredResult,
- *     onImproved: async () => { ... re-save output ... },
- *     verbose,
- *   })
- */
-export async function runPhaseCoaching(params) {
-    const { issueId, phase, phaseResult, onImproved, checklistItems, verbose } = params;
-    const executionSessionId = phaseResult.execution_session_id;
-    if (!executionSessionId) {
-        if (verbose) {
-            logInfo(`⏭️ Coaching skipped for ${phase}: no execution session ID`);
-        }
-        return { executionSessionId: '', coaching: null };
-    }
-    const coachingResult = await runCoachingLoop({
-        issueId,
-        phase,
-        executionSessionId,
-        onImproved,
-        checklistItems,
-        verbose,
-    });
-    if (verbose) {
-        logInfo(`🏋️ Coaching: ${coachingResult.iterations} iteration(s), score: ${coachingResult.finalScore}/100, exit: ${coachingResult.exitReason}`);
-    }
-    return {
-        executionSessionId: coachingResult.executionSessionId,
-        coaching: coachingResult,
-    };
-}

package/dist/services/coaching/self-rating.d.ts

@@ -1,26 +0,0 @@
-/**
- * Self-Rating Module
- * Asks the execution agent to rate its own output after completing a phase.
- * The agent evaluates against standard criteria and returns a structured rating.
- */
-import { type PhaseRating, type RatablePhase } from '../phase-ratings.js';
-/** Get the evaluation criteria for a given phase */
-export declare function getCriteriaForPhase(phase: RatablePhase): readonly string[];
-/** Checklist item for self-rating context */
-export interface SelfRatingChecklistItem {
-    id: string;
-    title: string;
-    description?: string;
-}
-/**
- * Build the self-rating prompt that will be sent to the execution agent
- * after it finishes its work. The agent should respond with a JSON block.
- *
- * If checklist items are provided, they are included so the agent rates
- * itself against the actual quality gates it will be verified against.
- */
-export declare function buildSelfRatingPrompt(phase: RatablePhase, checklistItems?: SelfRatingChecklistItem[]): string;
-/**
- * Parse a self-rating JSON response from the execution agent
- */
-export declare function parseSelfRating(response: string, phase: RatablePhase, verbose?: boolean): PhaseRating | null;

package/dist/services/coaching/self-rating.js

@@ -1,153 +0,0 @@
-/**
- * Self-Rating Module
- * Asks the execution agent to rate its own output after completing a phase.
- * The agent evaluates against standard criteria and returns a structured rating.
- */
-import { logDebug, logError } from '../../utils/logger.js';
-/** Criteria definitions per phase category */
-const COMMON_CRITERIA = [
-    'completeness',
-    'accuracy',
-    'quality',
-    'consistency',
-];
-const ANALYSIS_CRITERIA = [...COMMON_CRITERIA, 'coverage', 'clarity'];
-const DESIGN_CRITERIA = [
-    ...COMMON_CRITERIA,
-    'feasibility',
-    'scalability',
-    'maintainability',
-];
-const CODE_CRITERIA = [
-    ...COMMON_CRITERIA,
-    'readability',
-    'testability',
-    'performance',
-    'security',
-];
-/** Get the evaluation criteria for a given phase */
-export function getCriteriaForPhase(phase) {
-    switch (phase) {
-        case 'issue_analysis':
-        case 'user_stories_analysis':
-        case 'test_cases_analysis':
-            return ANALYSIS_CRITERIA;
-        case 'technical_design':
-        case 'branch_planning':
-            return DESIGN_CRITERIA;
-        case 'code_implementation':
-        case 'code_refine':
-        case 'pr_splitting':
-        case 'pr_execution':
-        case 'code_testing':
-        case 'functional_testing':
-        case 'code_review':
-        case 'autonomous':
-            return CODE_CRITERIA;
-        default:
-            return COMMON_CRITERIA;
-    }
-}
-/**
- * Build the self-rating prompt that will be sent to the execution agent
- * after it finishes its work. The agent should respond with a JSON block.
- *
- * If checklist items are provided, they are included so the agent rates
- * itself against the actual quality gates it will be verified against.
- */
-export function buildSelfRatingPrompt(phase, checklistItems) {
-    const criteria = getCriteriaForPhase(phase);
-    const criteriaList = criteria
-        .map((c) => `  - "${c}": { "score": <0-100>, "reason": "<one sentence>" }`)
-        .join('\n');
-    let checklistSection = '';
-    if (checklistItems && checklistItems.length > 0) {
-        const items = checklistItems
-            .map((item) => `- ${item.title}${item.description ? `: ${item.description}` : ''}`)
-            .join('\n');
-        checklistSection = `
-Also evaluate your output against these specific checklist requirements (these will be verified next):
-${items}
-
-Factor these requirements into your scores — if your output doesn't satisfy a requirement, reflect that in the relevant criteria score.
-`;
-    }
-    return `Now rate the quality of your own output. Be honest and critical — the goal is 100/100.
-${checklistSection}
-Evaluate your work on these criteria and respond with ONLY a JSON block:
-
-\`\`\`json
-{
-  "self_rating": {
-    "score": <overall score 0-100>,
-    "summary": "<2-3 sentences: what you did well and where you fell short>",
-    "criteria_scores": {
-${criteriaList}
-    },
-    "strengths": ["<strength 1>", "<strength 2>"],
-    "weaknesses": ["<weakness 1>", "<weakness 2>"]
-  }
-}
-\`\`\``;
-}
-/**
- * Parse a self-rating JSON response from the execution agent
- */
-export function parseSelfRating(response, phase, verbose) {
-    try {
-        // Extract JSON from markdown code block or raw response
-        const jsonMatch = response.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-        const jsonStr = jsonMatch ? jsonMatch[1] : response;
-        // Try to find self_rating object
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let parsed;
-        try {
-            parsed = JSON.parse(jsonStr);
-        }
-        catch {
-            // Try to extract JSON object containing self_rating
-            const selfRatingMatch = jsonStr.match(/\{[\s\S]*"self_rating"[\s\S]*\}/);
-            if (selfRatingMatch) {
-                parsed = JSON.parse(selfRatingMatch[0]);
-            }
-            else {
-                throw new Error('No self_rating JSON found in response');
-            }
-        }
-        const rating = parsed.self_rating || parsed;
-        // Validate score
-        const score = Number(rating.score);
-        if (Number.isNaN(score) || score < 0 || score > 100) {
-            throw new Error(`Invalid score: ${rating.score}`);
-        }
-        // Build criteria_scores with defaults for missing criteria
-        const criteria = getCriteriaForPhase(phase);
-        const criteriaScores = {};
-        for (const criterion of criteria) {
-            if (rating.criteria_scores?.[criterion]) {
-                criteriaScores[criterion] = {
-                    score: Number(rating.criteria_scores[criterion].score),
-                    reason: String(rating.criteria_scores[criterion].reason || ''),
-                };
-            }
-        }
-        return {
-            score: Math.round(score),
-            summary: String(rating.summary || ''),
-            criteria_scores: criteriaScores,
-            strengths: Array.isArray(rating.strengths)
-                ? rating.strengths.map(String)
-                : [],
-            weaknesses: Array.isArray(rating.weaknesses)
-                ? rating.weaknesses.map(String)
-                : [],
-        };
-    }
-    catch (error) {
-        logError(`Failed to parse self-rating: ${error instanceof Error ? error.message : String(error)}`);
-        if (verbose) {
-            logDebug(`Raw response: ${response.substring(0, 500)}`, verbose);
-        }
-        return null;
-    }
-}

package/dist/services/feedbacks.d.ts

@@ -1,57 +0,0 @@
-/**
- * Feedbacks service for pipeline integration
- * Provides human-guided feedbacks to influence Claude Code behavior in each phase
- */
-import { type PipelinePhaseOptions } from '../types/pipeline.js';
-export type { PipelinePhaseOptions };
-export type FeedbackType = 'requirement' | 'constraint' | 'preference' | 'context' | 'quality_criteria' | 'issue' | 'suggestion';
-export type FeedbackTargetType = 'phase' | 'line' | 'range';
-export type DocumentType = 'technical_design' | 'execution_plan' | 'code' | 'test_case' | 'user_story';
-export interface Feedback {
-    id: string;
-    issue_id: string | null;
-    product_id: string | null;
-    branch_id?: string | null;
-    user_story_id?: string | null;
-    test_case_id?: string | null;
-    phase: string;
-    feedback_type: FeedbackType;
-    title: string;
-    content: string;
-    priority: number;
-    is_active: boolean;
-    is_resolved?: boolean;
-    resolved_at?: string | null;
-    resolved_by?: string | null;
-    created_by: string;
-    created_at: string;
-    updated_at: string;
-    target_type?: FeedbackTargetType | null;
-    document_type?: DocumentType | null;
-    line_number?: number | null;
-    line_range_start?: number | null;
-    line_range_end?: number | null;
-    context_snippet?: string | null;
-}
-export interface FeedbacksContext {
-    phase: string;
-    issue_id: string;
-    branch_id?: string | null;
-    feedbacks: Feedback[];
-}
-/**
- * Fetch feedbacks for a specific phase
- * Includes both issue-level and product-level feedbacks
- * For multi-branch issues, can optionally filter by branch_id
- */
-export declare function getFeedbacksForPhase(options: PipelinePhaseOptions, phase: string, branchId?: string | null): Promise<FeedbacksContext>;
-/**
- * Format feedbacks context as string for LLM consumption
- * Downloads images from feedback content for Claude Code to view
- */
-export declare function formatFeedbacksForContext(context: FeedbacksContext): Promise<string>;
-/**
- * Mark feedbacks as resolved
- * Used after successful verification to track which feedbacks have been addressed
- */
-export declare function resolveFeedbacks(options: PipelinePhaseOptions, feedbackIds: string[], verbose?: boolean): Promise<void>;