edsger 0.76.0 → 0.78.0

package/dist/phases/pr-splitting/index.js

@@ -1,413 +0,0 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logIssuePhaseEvent } from '../../services/audit-logs.js';
-import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
-import { clearPullRequests, createPullRequests, updatePullRequest, } from '../../services/pull-requests.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-import { fetchPRSplittingContext } from './context.js';
-import { validateAndFixImportDependencies } from './import-dep-validator.js';
-import { buildErrorResult, buildNoChangeResult, buildSuccessResult, sortPRsByDependency, validatePlannedPRs, } from './outcome.js';
-import { createImprovementPrompt, createPRSplittingPromptWithContext, createPRSplittingSystemPrompt, formatContextForPrompt, formatExistingPRsForPrompt, } from './prompts.js';
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content },
-    };
-}
-async function* prompt(analysisPrompt) {
-    yield userMessage(analysisPrompt);
-    await new Promise((res) => {
-        setTimeout(res, 10000);
-    });
-}
-/**
- * PR Splitting Phase: Analyze diff and create PR split plan
- *
- * This phase analyzes the actual code diff between dev/{issueId} and main,
- * then uses AI to produce a PR split plan saved to the database.
- * Human review is expected before running the pr-execution phase.
- */
-export const splitIssueIntoPRs = async (options, config) => {
-    const { issueId, verbose, replaceExisting } = options;
-    if (verbose) {
-        logInfo(`Starting PR splitting for issue ID: ${issueId}`);
-    }
-    try {
-        // Log phase start
-        await logIssuePhaseEvent({
-            issueId,
-            eventType: 'phase_started',
-            phase: 'pr_splitting',
-            result: 'info',
-            metadata: {
-                replace_existing: replaceExisting || false,
-                timestamp: new Date().toISOString(),
-            },
-        }, verbose);
-        // Fetch context (includes git diff from dev/{issueId} vs main)
-        const context = await fetchPRSplittingContext(issueId, verbose, replaceExisting);
-        if (context.changedFiles.length === 0) {
-            if (verbose) {
-                logInfo('No code changes detected between dev branch and main.');
-            }
-            return buildNoChangeResult(issueId, context.existing_pull_requests.length);
-        }
-        // Fetch feedbacks for pr-splitting phase
-        let feedbacksContext = null;
-        let hasFeedbacks = false;
-        try {
-            feedbacksContext = await getFeedbacksForPhase({ issueId, verbose }, 'pr-splitting');
-            hasFeedbacks = feedbacksContext.feedbacks.length > 0;
-            if (verbose) {
-                logInfo(`📋 Feedbacks fetched: ${feedbacksContext.feedbacks.length} feedbacks found`);
-            }
-        }
-        catch (error) {
-            if (verbose) {
-                logError(`Failed to fetch feedbacks: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        // Determine operation mode
-        const hasExistingPRs = context.existing_pull_requests.length > 0;
-        const isIncrementalUpdate = hasExistingPRs && hasFeedbacks && !replaceExisting;
-        // Check if existing PRs already planned and no feedback
-        if (hasExistingPRs && !hasFeedbacks && !replaceExisting) {
-            if (verbose) {
-                logInfo(`Issue already has ${context.existing_pull_requests.length} PRs planned. No feedbacks to address.`);
-                logInfo('Use replaceExisting: true to re-plan.');
-            }
-            return buildNoChangeResult(issueId, context.existing_pull_requests.length);
-        }
-        if (verbose) {
-            logInfo('\n📋 PR Splitting Mode:');
-            logInfo(`   - Has existing PRs: ${hasExistingPRs}`);
-            logInfo(`   - Has feedbacks: ${hasFeedbacks}`);
-            logInfo(`   - Replace existing: ${replaceExisting || false}`);
-            logInfo(`   - Mode: ${isIncrementalUpdate ? '🔄 Incremental Update' : '✨ New Planning'}`);
-            logInfo(`   - Changed files: ${context.changedFiles.length}`);
-        }
-        // Clear existing PRs if replacing
-        if (replaceExisting && hasExistingPRs) {
-            if (verbose) {
-                logInfo(`Clearing ${context.existing_pull_requests.length} existing PRs for full re-plan...`);
-            }
-            await clearPullRequests({ issueId, verbose }, true);
-        }
-        // ==============================
-        // Diff Analysis with AI Agent
-        // ==============================
-        if (verbose) {
-            logInfo('\n🔍 Analyzing code diff with AI...');
-        }
-        const contextInfo = formatContextForPrompt(context.issue, context.product, context.existing_branches);
-        const existingPRsInfo = formatExistingPRsForPrompt(context.existing_pull_requests);
-        const systemPrompt = await createPRSplittingSystemPrompt(config, issueId, undefined, verbose);
-        let userPrompt;
-        if (isIncrementalUpdate && feedbacksContext) {
-            if (verbose) {
-                logInfo('\n🎯 Feedbacks that will be addressed:');
-                feedbacksContext.feedbacks.forEach((fb, idx) => {
-                    logInfo(`   ${idx + 1}. [${fb.feedback_type}] ${fb.title}`);
-                });
-            }
-            const feedbacksInfo = await formatFeedbacksForContext(feedbacksContext);
-            const currentPlanInfo = existingPRsInfo || 'No existing PR plan documented.';
-            userPrompt = createImprovementPrompt(feedbacksInfo, currentPlanInfo);
-            userPrompt = `${userPrompt}\n\n## Issue Context\n\n${contextInfo}`;
-        }
-        else {
-            userPrompt = createPRSplittingPromptWithContext(issueId, contextInfo, existingPRsInfo, context.diffStat, context.changedFiles);
-        }
-        // Execute agent query
-        const result = await executeAgentQuery(userPrompt, systemPrompt, config, verbose);
-        if (!result || !result.pullRequests || result.pullRequests.length === 0) {
-            return buildErrorResult(issueId, 'No pull requests were generated');
-        }
-        // Validate PRs
-        const validation = validatePlannedPRs(result.pullRequests);
-        if (!validation.valid) {
-            return buildErrorResult(issueId, `Invalid PR plan: ${validation.errors.join(', ')}`);
-        }
-        const sortedPRs = sortPRsByDependency(result.pullRequests);
-        // Validate and auto-fix import dependency ordering
-        const importFixResult = validateAndFixImportDependencies(sortedPRs, context.changedFiles, context.devBranchName, verbose);
-        const finalPRs = importFixResult.pullRequests;
-        if (verbose) {
-            logInfo(`\n✅ ${finalPRs.length} PRs planned:`);
-            finalPRs.forEach((pr) => {
-                logInfo(`   ${pr.sequence}. ${pr.name} (${pr.branch_name})`);
-                if (pr.files) {
-                    logInfo(`      Files: ${pr.files.map((f) => f.path).join(', ')}`);
-                }
-            });
-        }
-        // Clear existing PRs for incremental update before creating new ones
-        if (isIncrementalUpdate && hasExistingPRs) {
-            if (verbose) {
-                logInfo(`🔄 Clearing existing PRs for incremental update...`);
-            }
-            await clearPullRequests({ issueId, verbose: false }, true);
-        }
-        // Save PR plan to database
-        // Step 1: Create all PRs without base_pr_id (batch)
-        const prInputs = finalPRs.map((pr) => ({
-            sequence: pr.sequence,
-            name: pr.name,
-            description: pr.description,
-            branch_name: pr.branch_name,
-            files: pr.files,
-        }));
-        const createdPRRecords = await createPullRequests({ issueId, verbose: false }, prInputs);
-        // Step 2: Build branch_name → ID map from created records
-        const prBranchNameToId = new Map();
-        createdPRRecords.forEach((createdPR) => {
-            if (createdPR.branch_name) {
-                prBranchNameToId.set(createdPR.branch_name, createdPR.id);
-            }
-        });
-        // Step 3: Update base_pr_id for PRs with dependencies
-        for (const pr of finalPRs) {
-            if (!pr.depends_on_branch_name || !pr.branch_name) {
-                continue;
-            }
-            const basePrId = prBranchNameToId.get(pr.depends_on_branch_name);
-            const thisPrId = prBranchNameToId.get(pr.branch_name);
-            if (basePrId && thisPrId) {
-                await updatePullRequest(thisPrId, { base_pr_id: basePrId }, false);
-            }
-        }
-        if (verbose) {
-            logInfo(`\n📝 Saved ${createdPRRecords.length} PR records to database. Awaiting human review before execution.`);
-        }
-        // Log phase completion
-        await logIssuePhaseEvent({
-            issueId,
-            eventType: 'phase_completed',
-            phase: 'pr_splitting',
-            result: 'success',
-            metadata: {
-                prs_planned: finalPRs.length,
-                pr_names: finalPRs.map((pr) => pr.name),
-                import_deps_fixed: importFixResult.movedFiles.length,
-                mode: isIncrementalUpdate ? 'incremental_update' : 'new_planning',
-                feedbacks_addressed: feedbacksContext?.feedbacks.length || 0,
-                timestamp: new Date().toISOString(),
-            },
-        }, verbose);
-        return buildSuccessResult(issueId, finalPRs, result.summary ||
-            `Split issue into ${finalPRs.length} pull requests for review`, result.rationale);
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`PR splitting failed: ${errorMessage}`);
-        await logIssuePhaseEvent({
-            issueId,
-            eventType: 'phase_failed',
-            phase: 'pr_splitting',
-            result: 'error',
-            metadata: {
-                error: errorMessage,
-                timestamp: new Date().toISOString(),
-            },
-        }, verbose);
-        return buildErrorResult(issueId, errorMessage);
-    }
-};
-/**
- * Execute an agent query and parse the result
- */
-async function executeAgentQuery(userPrompt, systemPrompt, config, verbose) {
-    let lastAssistantResponse = '';
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let structuredResult = null;
-    let executionSessionId = '';
-    if (verbose) {
-        logInfo('🤖 Starting PR splitting agent query...');
-    }
-    for await (const message of query({
-        prompt: prompt(userPrompt),
-        options: {
-            systemPrompt: {
-                type: 'preset',
-                preset: 'claude_code',
-                append: systemPrompt,
-            },
-            model: DEFAULT_MODEL,
-            maxTurns: 500,
-            permissionMode: 'bypassPermissions',
-        },
-    })) {
-        if (verbose) {
-            logInfo(`   Received message type: ${message.type}`);
-        }
-        if (message.type === 'assistant' && message.message?.content) {
-            for (const content of message.message.content) {
-                if (content.type === 'text') {
-                    lastAssistantResponse += `${content.text}\n`;
-                    logDebug(`🤖 ${content.text}`, verbose);
-                }
-                else if (content.type === 'tool_use') {
-                    const input = (content.input ?? {});
-                    logDebug(`🔧 ${content.name}: ${input.description ?? 'Running...'}`, verbose);
-                }
-            }
-        }
-        if (message.type === 'result') {
-            executionSessionId = message.session_id || executionSessionId;
-            if (message.subtype === 'success') {
-                logInfo('\n📋 PR splitting completed, parsing results...');
-                try {
-                    const responseText = message.result || lastAssistantResponse;
-                    structuredResult = parseJsonResponse(responseText, verbose);
-                }
-                catch (error) {
-                    logError(`Failed to parse result: ${error}`);
-                }
-            }
-            else {
-                logError(`\n⚠️ PR splitting incomplete: ${message.subtype}`);
-            }
-        }
-    }
-    if (!structuredResult) {
-        return null;
-    }
-    return {
-        pullRequests: structuredResult.pullRequests || [],
-        summary: structuredResult.summary,
-        rationale: structuredResult.rationale,
-        execution_session_id: executionSessionId || undefined,
-    };
-}
-/**
- * Extract a balanced JSON object starting from a given index using brace counting.
- * Handles nested braces and strings with escaped characters correctly.
- */
-/**
- * Find the opening { before a keyword index and try to parse a PR result from it
- */
-function findJsonObjectBefore(responseText, keywordIndex) {
-    for (let i = keywordIndex - 1; i >= 0; i--) {
-        if (responseText[i] !== '{') {
-            continue;
-        }
-        const jsonStr = extractBalancedJson(responseText, i);
-        if (jsonStr) {
-            const result = tryParsePRResult(jsonStr);
-            if (result && result.pullRequests.length > 0) {
-                return result;
-            }
-        }
-        break;
-    }
-    return null;
-}
-function extractBalancedJson(text, startIndex) {
-    if (text[startIndex] !== '{') {
-        return null;
-    }
-    let braceCount = 0;
-    let inString = false;
-    let escape = false;
-    for (let i = startIndex; i < text.length; i++) {
-        const ch = text[i];
-        if (escape) {
-            escape = false;
-            continue;
-        }
-        if (ch === '\\' && inString) {
-            escape = true;
-            continue;
-        }
-        if (ch === '"') {
-            inString = !inString;
-            continue;
-        }
-        if (inString) {
-            continue;
-        }
-        if (ch === '{') {
-            braceCount++;
-        }
-        else if (ch === '}') {
-            braceCount--;
-            if (braceCount === 0) {
-                return text.substring(startIndex, i + 1);
-            }
-        }
-    }
-    return null;
-}
-/**
- * Try to parse a JSON string and extract PR splitting result
- */
-function tryParsePRResult(jsonStr) {
-    try {
-        const parsed = JSON.parse(jsonStr);
-        if (parsed.pr_splitting_result) {
-            return {
-                pullRequests: parsed.pr_splitting_result.pull_requests || [],
-                summary: parsed.pr_splitting_result.summary,
-                rationale: parsed.pr_splitting_result.rationale,
-            };
-        }
-        if (parsed.pull_requests) {
-            return {
-                pullRequests: parsed.pull_requests,
-                summary: parsed.summary,
-                rationale: parsed.rationale,
-            };
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Parse JSON response from Claude
- * Handles: JSON in code blocks, raw JSON mixed with markdown, pure JSON
- */
-function parseJsonResponse(responseText, verbose) {
-    // Strategy 1: Find JSON code blocks and try each one (handles multiple code blocks)
-    const codeBlockRegex = /```(?:json)?\s*\n([\s\S]*?)\n\s*```/g;
-    let match;
-    while ((match = codeBlockRegex.exec(responseText)) !== null) {
-        const content = match[1].trim();
-        if (content.startsWith('{')) {
-            const result = tryParsePRResult(content);
-            if (result && result.pullRequests.length > 0) {
-                return result;
-            }
-        }
-    }
-    // Strategy 2: Find "pr_splitting_result" and extract the enclosing JSON object
-    // Walk backwards from the keyword to find the outermost opening brace
-    const keyword = '"pr_splitting_result"';
-    const keywordIndex = responseText.indexOf(keyword);
-    if (keywordIndex !== -1) {
-        const result = findJsonObjectBefore(responseText, keywordIndex);
-        if (result) {
-            return result;
-        }
-    }
-    // Strategy 3: Find any { that starts a JSON object with "pull_requests" key
-    const pullRequestsKeyword = '"pull_requests"';
-    const prIndex = responseText.indexOf(pullRequestsKeyword);
-    if (prIndex !== -1) {
-        const result = findJsonObjectBefore(responseText, prIndex);
-        if (result) {
-            return result;
-        }
-    }
-    // Strategy 4: Try to parse the entire response as JSON
-    const result = tryParsePRResult(responseText.trim());
-    if (result) {
-        return result;
-    }
-    if (verbose) {
-        logError(`Failed to extract PR splitting JSON from response (length: ${responseText.length})`);
-    }
-    return null;
-}
-export { fetchPRSplittingContext } from './context.js';

package/dist/phases/pr-splitting/outcome.d.ts

@@ -1,24 +0,0 @@
-import { type PlannedPullRequest, type PRSplittingResult } from './index.js';
-/**
- * Build a successful PR splitting result
- */
-export declare function buildSuccessResult(issueId: string, pullRequests: PlannedPullRequest[], summary: string, rationale?: string): PRSplittingResult;
-/**
- * Build an error result
- */
-export declare function buildErrorResult(issueId: string, errorMessage: string): PRSplittingResult;
-/**
- * Build a result when no changes are needed
- */
-export declare function buildNoChangeResult(issueId: string, existingPRCount: number): PRSplittingResult;
-/**
- * Validate planned pull requests
- */
-export declare function validatePlannedPRs(prs: PlannedPullRequest[]): {
-    valid: boolean;
-    errors: string[];
-};
-/**
- * Sort pull requests by dependency order (topological sort based on depends_on_branch_name)
- */
-export declare function sortPRsByDependency(prs: PlannedPullRequest[]): PlannedPullRequest[];

package/dist/phases/pr-splitting/outcome.js

@@ -1,114 +0,0 @@
-/**
- * Build a successful PR splitting result
- */
-export function buildSuccessResult(issueId, pullRequests, summary, rationale) {
-    return {
-        issueId,
-        pullRequests,
-        status: 'success',
-        summary,
-        rationale,
-    };
-}
-/**
- * Build an error result
- */
-export function buildErrorResult(issueId, errorMessage) {
-    return {
-        issueId,
-        pullRequests: [],
-        status: 'error',
-        summary: `PR splitting failed: ${errorMessage}`,
-    };
-}
-/**
- * Build a result when no changes are needed
- */
-export function buildNoChangeResult(issueId, existingPRCount) {
-    return {
-        issueId,
-        pullRequests: [],
-        status: 'success',
-        summary: `Issue already has ${existingPRCount} pull requests planned. No changes needed.`,
-    };
-}
-/**
- * Validate planned pull requests
- */
-export function validatePlannedPRs(prs) {
-    const errors = [];
-    if (!prs || prs.length === 0) {
-        errors.push('No pull requests defined');
-        return { valid: false, errors };
-    }
-    // Check for required fields
-    prs.forEach((pr, idx) => {
-        if (!pr.name) {
-            errors.push(`PR ${idx + 1}: Missing name`);
-        }
-        if (!pr.description) {
-            errors.push(`PR ${idx + 1}: Missing description`);
-        }
-        if (pr.sequence === undefined || pr.sequence === null) {
-            errors.push(`PR ${idx + 1}: Missing sequence`);
-        }
-    });
-    // Check for duplicate sequences
-    const sequences = prs.map((pr) => pr.sequence);
-    const uniqueSequences = new Set(sequences);
-    if (sequences.length !== uniqueSequences.size) {
-        errors.push('Duplicate sequence numbers found');
-    }
-    // Check for circular dependencies via branch names
-    const branchNames = new Set(prs.map((pr) => pr.branch_name).filter(Boolean));
-    prs.forEach((pr) => {
-        if (pr.depends_on_branch_name) {
-            if (!branchNames.has(pr.depends_on_branch_name) &&
-                pr.depends_on_branch_name !== '') {
-                errors.push(`PR "${pr.name}": depends on unknown branch "${pr.depends_on_branch_name}"`);
-            }
-            if (pr.depends_on_branch_name === pr.branch_name) {
-                errors.push(`PR "${pr.name}": cannot depend on itself`);
-            }
-        }
-    });
-    return { valid: errors.length === 0, errors };
-}
-/**
- * Sort pull requests by dependency order (topological sort based on depends_on_branch_name)
- */
-export function sortPRsByDependency(prs) {
-    const result = [];
-    const visited = new Set();
-    const visiting = new Set();
-    const prByBranchName = new Map();
-    prs.forEach((pr) => {
-        if (pr.branch_name) {
-            prByBranchName.set(pr.branch_name, pr);
-        }
-    });
-    function visit(pr) {
-        if (visited.has(pr.sequence)) {
-            return;
-        }
-        if (visiting.has(pr.sequence)) {
-            // Circular dependency - fall back to sequence order
-            return;
-        }
-        visiting.add(pr.sequence);
-        // Visit dependency first
-        if (pr.depends_on_branch_name) {
-            const dep = prByBranchName.get(pr.depends_on_branch_name);
-            if (dep) {
-                visit(dep);
-            }
-        }
-        visiting.delete(pr.sequence);
-        visited.add(pr.sequence);
-        result.push(pr);
-    }
-    // Visit in sequence order as a tiebreaker
-    const sorted = [...prs].sort((a, b) => a.sequence - b.sequence);
-    sorted.forEach((pr) => visit(pr));
-    return result;
-}

package/dist/phases/pr-splitting/prompts.d.ts

@@ -1,43 +0,0 @@
-import { type EdsgerConfig } from '../../types/index.js';
-/**
- * Create the system prompt for PR splitting: Diff analysis and PR planning
- */
-export declare function createPRSplittingSystemPrompt(config: EdsgerConfig, issueId: string, projectDir?: string, verbose?: boolean): Promise<string>;
-/**
- * Create the user prompt with diff context for PR splitting
- */
-export declare function createPRSplittingPromptWithContext(issueId: string, contextInfo: string, existingPRsInfo: string, diffStat: string, changedFiles: string[]): string;
-/**
- * Format the context information for the prompt
- */
-export declare function formatContextForPrompt(issue: {
-    name: string;
-    description?: string | null;
-    technical_design?: string | null;
-}, product: {
-    name: string;
-    description?: string | null;
-}, branches: {
-    name: string;
-    description?: string | null;
-    branch_name?: string | null;
-    status: string;
-}[]): string;
-/**
- * Format existing pull requests for the prompt
- */
-export declare function formatExistingPRsForPrompt(pullRequests: {
-    sequence: number;
-    name: string;
-    description?: string | null;
-    branch_name?: string | null;
-    status: string;
-    files?: {
-        path: string;
-        change_type: string;
-    }[] | null;
-}[]): string;
-/**
- * Create improvement prompt for re-planning based on feedback
- */
-export declare function createImprovementPrompt(feedback: string, currentPlan: string): string;