edsger 0.77.0 → 0.79.0

package/dist/phases/issue-analysis-verification/agent.js

@@ -1,124 +0,0 @@
-/**
- * Checklist verification agent for issue analysis
- * This agent independently reviews checklist compliance to ensure objectivity
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-import { createChecklistVerificationPrompt, createChecklistVerificationSystemPrompt, } from './prompts.js';
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function extractTextFromContent(content, verbose) {
-    let text = '';
-    for (const item of content) {
-        if (item.type === 'text') {
-            text += `${item.text}\n`;
-            logDebug(`🔍 ${item.text}`, verbose);
-        }
-    }
-    return text;
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function parseVerificationJson(responseText) {
-    try {
-        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const jsonResult = jsonBlockMatch
-            ? JSON.parse(jsonBlockMatch[1])
-            : JSON.parse(responseText);
-        if (jsonResult && jsonResult.verification) {
-            return jsonResult.verification;
-        }
-        throw new Error('Invalid verification JSON structure');
-    }
-    catch (error) {
-        logError(`Failed to parse verification result: ${error}`);
-        return null;
-    }
-}
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content },
-    };
-}
-// eslint-disable-next-line @typescript-eslint/require-await -- async generator required by SDK interface
-async function* prompt(verificationPrompt) {
-    yield userMessage(verificationPrompt);
-}
-/**
- * Verify execution plan quality against checklist requirements using an
- * independent AI agent. The agent reviews the plan markdown produced by
- * issue-analysis and decides whether each checklist item is satisfied.
- */
-export async function verifyChecklistCompliance(options, _config) {
-    const { checklistContext, analysisContext, executionPlan, verbose } = options;
-    const totalChecklistItems = checklistContext.checklists.reduce((sum, checklist) => sum + checklist.items.length, 0);
-    if (verbose) {
-        logInfo('🔍 Starting checklist verification...');
-        logInfo(`   Verifying ${totalChecklistItems} checklist items`);
-    }
-    const systemPrompt = await createChecklistVerificationSystemPrompt();
-    const verificationPrompt = createChecklistVerificationPrompt({
-        checklistContext,
-        analysisContext,
-        executionPlan,
-    });
-    let lastAssistantResponse = '';
-    let verificationResult = null;
-    if (verbose) {
-        logInfo('🤖 Starting verification agent query...');
-    }
-    // Use Claude Code SDK for verification
-    for await (const message of query({
-        prompt: prompt(verificationPrompt),
-        options: {
-            systemPrompt: {
-                type: 'preset',
-                preset: 'claude_code',
-                append: systemPrompt,
-            },
-            model: DEFAULT_MODEL,
-            maxTurns: 100,
-            permissionMode: 'bypassPermissions',
-        },
-    })) {
-        if (verbose) {
-            logInfo(`   Received message type: ${message.type}`);
-        }
-        // Capture assistant responses
-        if (message.type === 'assistant' && message.message?.content) {
-            lastAssistantResponse += extractTextFromContent(message.message.content, verbose);
-        }
-        if (message.type !== 'result') {
-            continue;
-        }
-        if (message.subtype === 'success') {
-            logInfo('\n✅ Verification completed, parsing results...');
-            verificationResult = parseVerificationJson(message.result || lastAssistantResponse);
-        }
-        else {
-            logError(`\n⚠️ Verification incomplete: ${message.subtype}`);
-        }
-    }
-    if (!verificationResult) {
-        throw new Error('No verification result received');
-    }
-    if (verbose) {
-        logInfo('\n📊 Verification Summary:');
-        logInfo(`   Total items: ${verificationResult.total_items}`);
-        logInfo(`   ✅ Confirmed: ${verificationResult.confirmed_count}`);
-        logInfo(`   ❌ Rejected: ${verificationResult.rejected_count}`);
-        logInfo(`   ⚠️  Uncertain: ${verificationResult.uncertain_count}`);
-        logInfo(`   Summary: ${verificationResult.summary}`);
-        if (verificationResult.rejected_count > 0) {
-            logInfo('\n❌ Rejected items:');
-            verificationResult.item_verifications
-                .filter((v) => v.verification_status === 'rejected')
-                .forEach((v) => {
-                logInfo(`   - ${v.checklist_item_id}`);
-                logInfo(`     Reason: ${v.verification_reason}`);
-            });
-        }
-    }
-    return verificationResult;
-}

package/dist/phases/issue-analysis-verification/index.d.ts

@@ -1,27 +0,0 @@
-import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import { type EdsgerConfig } from '../../types/index.js';
-import { type IssueAnalysisContext } from '../issue-analysis/context.js';
-import { type ChecklistVerificationResult } from './agent.js';
-interface VerificationCycleResult {
-    passed: boolean;
-    verificationResult: ChecklistVerificationResult | null;
-    nextPrompt?: string;
-}
-/**
- * Verify the execution plan against checklist requirements and decide whether
- * iteration should continue. This function only verifies — it does NOT mutate
- * issue state (the plan is persisted by the issue-analysis phase after the
- * cycle settles).
- */
-export interface IssueAnalysisVerificationOptions {
-    structuredAnalysisResult: Record<string, unknown>;
-    checklistContext: ChecklistPhaseContext | null;
-    context: IssueAnalysisContext;
-    config: EdsgerConfig;
-    currentIteration: number;
-    maxIterations: number;
-    issueId: string;
-    verbose?: boolean;
-}
-export declare function performVerificationCycle(opts: IssueAnalysisVerificationOptions): Promise<VerificationCycleResult>;
-export {};

package/dist/phases/issue-analysis-verification/index.js

@@ -1,79 +0,0 @@
-import { logIssueVerificationEvent } from '../../services/audit-logs.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { createImprovementPrompt } from '../issue-analysis/prompts.js';
-import { verifyChecklistCompliance, } from './agent.js';
-export async function performVerificationCycle(opts) {
-    const { structuredAnalysisResult, checklistContext, context, config, currentIteration, maxIterations, issueId, verbose, } = opts;
-    if (!checklistContext || checklistContext.checklists.length === 0) {
-        return { passed: true, verificationResult: null };
-    }
-    const executionPlan = typeof structuredAnalysisResult.execution_plan === 'string'
-        ? structuredAnalysisResult.execution_plan
-        : '';
-    if (verbose) {
-        logInfo('🔍 Starting plan verification...');
-    }
-    const verificationResult = await verifyChecklistCompliance({
-        checklistContext,
-        analysisContext: context,
-        executionPlan,
-        verbose,
-    }, config);
-    if (verificationResult.rejected_count === 0) {
-        if (verbose) {
-            logInfo(`✅ Plan verification passed: ${verificationResult.confirmed_count} confirmed, ${verificationResult.uncertain_count} uncertain`);
-        }
-        await logIssueVerificationEvent({
-            issueId,
-            phase: 'issue_analysis',
-            iteration: currentIteration,
-            result: 'success',
-            verificationData: {
-                confirmed_count: verificationResult.confirmed_count,
-                rejected_count: verificationResult.rejected_count,
-                uncertain_count: verificationResult.uncertain_count,
-                summary: verificationResult.summary,
-            },
-        }, verbose);
-        return { passed: true, verificationResult };
-    }
-    logError(`❌ Iteration ${currentIteration}: Plan verification FAILED - ${verificationResult.rejected_count} items rejected, ${verificationResult.uncertain_count} uncertain`);
-    await logIssueVerificationEvent({
-        issueId,
-        phase: 'issue_analysis',
-        iteration: currentIteration,
-        result: 'error',
-        verificationData: {
-            confirmed_count: verificationResult.confirmed_count,
-            rejected_count: verificationResult.rejected_count,
-            uncertain_count: verificationResult.uncertain_count,
-            rejected_items: verificationResult.item_verifications
-                .filter((item) => item.verification_status === 'rejected')
-                .map((item) => ({
-                checklist_item_id: item.checklist_item_id,
-                reason: item.verification_reason || 'No reason provided',
-                concerns: item.concerns || [],
-                improvement_suggestions: item.improvement_suggestions || [],
-            })),
-            uncertain_items: verificationResult.item_verifications
-                .filter((item) => item.verification_status === 'uncertain')
-                .map((item) => ({
-                checklist_item_id: item.checklist_item_id,
-                reason: item.verification_reason || 'No reason provided',
-                concerns: item.concerns || [],
-                improvement_suggestions: item.improvement_suggestions || [],
-            })),
-            summary: verificationResult.summary,
-            overall_suggestions: verificationResult.overall_suggestions || [],
-        },
-    }, verbose);
-    if (currentIteration < maxIterations) {
-        if (verbose) {
-            logInfo(`   Will retry with improvement feedback (${maxIterations - currentIteration} attempts remaining)`);
-        }
-        const nextPrompt = createImprovementPrompt(verificationResult, executionPlan);
-        return { passed: false, verificationResult, nextPrompt };
-    }
-    logError(`❌ Maximum iterations (${maxIterations}) reached. Plan verification still failing.`);
-    return { passed: false, verificationResult };
-}

package/dist/phases/issue-analysis-verification/prompts.d.ts

@@ -1,9 +0,0 @@
-import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import { type IssueAnalysisContext } from '../issue-analysis/context.js';
-export declare const createChecklistVerificationSystemPrompt: (projectDir?: string) => Promise<string>;
-export interface ChecklistVerificationPromptOptions {
-    checklistContext: ChecklistPhaseContext;
-    analysisContext: IssueAnalysisContext;
-    executionPlan: string;
-}
-export declare const createChecklistVerificationPrompt: (options: ChecklistVerificationPromptOptions) => string;

package/dist/phases/issue-analysis-verification/prompts.js

@@ -1,75 +0,0 @@
-import { resolveSkill } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export const createChecklistVerificationSystemPrompt = async (projectDir) => {
-    const skill = await resolveSkill('phase/issue-analysis-verification', {
-        projectDir,
-    });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/issue-analysis-verification');
-    }
-    return `${skill.prompt}\n\n${OUTPUT_CONTRACTS['issue-analysis-verification']}`;
-};
-export const createChecklistVerificationPrompt = (options) => {
-    const { checklistContext, analysisContext, executionPlan } = options;
-    const checklistItemsSection = checklistContext.checklists
-        .flatMap((checklist) => checklist.items.map((item) => {
-        return `### Checklist Item: ${item.title}
-**ID**: ${item.id}
-**Checklist**: ${checklist.name} (${checklist.role})
-**Requirement**: ${item.description}
-**Required**: ${item.is_required ? 'Yes' : 'No'}
-**Type**: ${item.item_type}
-`;
-    }))
-        .join('\n---\n');
-    const totalChecklistItems = checklistContext.checklists.reduce((sum, checklist) => sum + checklist.items.length, 0);
-    const planSection = executionPlan && executionPlan.trim().length > 0
-        ? executionPlan
-        : '**No execution plan was produced.**';
-    return `# Plan Verification Task
-
-You are verifying that the **execution plan** below satisfies the checklist requirements. The plan describes which artifacts the issue needs (user stories, test cases, technical design, etc.), in what order, with concrete success criteria. The artifacts themselves do not yet exist — you are reviewing the plan that will guide their creation.
-
-## Issue Context
-
-**Issue**: ${analysisContext.issue.name}
-**Issue ID**: ${analysisContext.issue.id}
-**Description**: ${analysisContext.issue.description || 'No description'}
-**Product**: ${analysisContext.product.name}
-
-## Execution Plan to Verify
-
-${planSection}
-
-## Checklist Requirements to Verify (${totalChecklistItems})
-
-${checklistItemsSection}
-
----
-
-## Your Verification Task
-
-For EACH checklist item above:
-
-1. **Understand the Requirement**: What does this checklist item require of a plan?
-2. **Examine the Plan**: Read the relevant section of the plan markdown above.
-3. **Decide Coverage**:
-   - Does the plan directly address this requirement?
-   - Are success criteria specific to this issue (not generic boilerplate)?
-   - Are dependencies and ordering correct?
-   - Are risks and open questions called out where relevant?
-   - Could a downstream agent execute the plan top-to-bottom without further planning?
-
-4. **Make Your Determination**:
-   - **CONFIRMED** (is_satisfied: true): The plan clearly and adequately satisfies this requirement
-   - **REJECTED** (is_satisfied: false): The requirement is not addressed, or addressed insufficiently
-   - **UNCERTAIN** (is_satisfied: false): The plan partially addresses the requirement but with gaps
-
-5. **Document Your Reasoning**: Cite specific sections of the plan in your verification_reason.
-
-6. **Provide Improvement Suggestions** (for rejected/uncertain items): suggest concrete plan changes — e.g., "Replace the generic success criterion in artifact 2 with one that names the specific endpoint", "Add a 'Risks' bullet for the unknown auth provider rollout". Do NOT suggest writing user stories or test cases yourself.
-
-Remember: you are verifying the plan document, not generated artifacts. Be thorough and fair.
-
-Provide your verification results in the required JSON format with improvement_suggestions for any rejected or uncertain items.`;
-};

package/dist/phases/output-contracts.d.ts

@@ -1,7 +0,0 @@
-/**
- * Output format contracts for each phase.
- * These define the JSON structure that LLM responses must follow.
- * They are appended to the SKILL.md prompt and are NOT user-overridable,
- * ensuring json-extractor.ts and llm-responses.ts can always parse the output.
- */
-export declare const OUTPUT_CONTRACTS: Record<string, string>;