edsger 0.77.0 → 0.79.0

package/dist/phases/branch-planning/index.js

@@ -1,404 +0,0 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logIssuePhaseEvent } from '../../services/audit-logs.js';
-import { clearBranches, createBranches, } from '../../services/branches.js';
-import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-import { fetchBranchPlanningContext } from './context.js';
-import { buildErrorResult, buildNoChangeResult, buildSuccessResult, sortBranchesByDependency, validatePlannedBranches, } from './outcome.js';
-import { createBranchPlanningPromptWithContext, createBranchPlanningSystemPrompt, createImprovementPrompt, formatContextForPrompt, formatExistingBranchesForPrompt, } from './prompts.js';
-// 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;
-}
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content },
-    };
-}
-async function* prompt(analysisPrompt) {
-    yield userMessage(analysisPrompt);
-    await new Promise((res) => {
-        setTimeout(res, 10000);
-    });
-}
-/**
- * Fetch feedbacks for branch planning phase
- */
-async function fetchBranchPlanningFeedbacks(issueId, verbose) {
-    try {
-        const feedbacksContext = await getFeedbacksForPhase({ issueId, verbose }, 'branch-planning');
-        if (verbose) {
-            logInfo(`📋 Feedbacks fetched: ${feedbacksContext.feedbacks.length} feedbacks found`);
-        }
-        return feedbacksContext;
-    }
-    catch (error) {
-        if (verbose) {
-            logError(`Failed to fetch feedbacks: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return null;
-    }
-}
-/**
- * Log the planning mode decision
- */
-function logPlanningMode(opts) {
-    const { hasExistingBranches, hasFeedbacks, replaceExisting, isIncrementalUpdate, feedbacksContext, existingBranchCount, verbose, } = opts;
-    if (!verbose) {
-        return;
-    }
-    logInfo('\n📋 Branch Planning Mode Decision:');
-    logInfo(`   - Has existing branches: ${hasExistingBranches} (${existingBranchCount} branches)`);
-    logInfo(`   - Has feedbacks: ${hasFeedbacks} (${feedbacksContext?.feedbacks.length || 0} feedbacks)`);
-    logInfo(`   - Replace existing: ${replaceExisting || false}`);
-    const noChangeOrNew = hasExistingBranches && !replaceExisting
-        ? '✅ No Change Needed'
-        : '✨ New Planning';
-    logInfo(`   - Mode: ${isIncrementalUpdate ? '🔄 Incremental Update' : noChangeOrNew}`);
-}
-/**
- * Build user prompt based on mode (incremental vs new planning)
- */
-async function buildUserPrompt(opts) {
-    const { isIncrementalUpdate, feedbacksContext, existingBranchesInfo, contextInfo, issueId, verbose, } = opts;
-    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}`);
-                logInfo(`      ${fb.content.substring(0, 100)}${fb.content.length > 100 ? '...' : ''}`);
-            });
-        }
-        const feedbacksInfo = await formatFeedbacksForContext(feedbacksContext);
-        const currentPlanInfo = existingBranchesInfo || 'No existing branch plan documented.';
-        const systemPrompt = createImprovementPrompt(feedbacksInfo, currentPlanInfo);
-        return `${systemPrompt}\n\n## Issue Context\n\n${contextInfo}`;
-    }
-    return createBranchPlanningPromptWithContext(issueId, contextInfo, existingBranchesInfo || '');
-}
-/**
- * Create branches in database with proper dependencies
- */
-async function persistBranches(sortedBranches, issueId, verbose) {
-    const branchNameToId = new Map();
-    for (const branch of sortedBranches) {
-        let baseBranchId;
-        if (branch.depends_on_branch_name) {
-            baseBranchId = branchNameToId.get(branch.depends_on_branch_name);
-            if (!baseBranchId && verbose) {
-                logInfo(`   Note: Branch "${branch.name}" depends on "${branch.depends_on_branch_name}" but that branch wasn't found yet`);
-            }
-        }
-        const branchInput = {
-            name: branch.name,
-            description: branch.description,
-            branch_name: branch.branch_name,
-            base_branch_id: baseBranchId,
-            status: 'pending',
-        };
-        const [created] = await createBranches({ issueId, verbose: false }, [
-            branchInput,
-        ]);
-        if (created && branch.branch_name) {
-            branchNameToId.set(branch.branch_name, created.id);
-        }
-    }
-}
-export const planIssueBranches = async (options, config) => {
-    const { issueId, verbose, replaceExisting } = options;
-    if (verbose) {
-        logInfo(`Starting branch planning for issue ID: ${issueId}`);
-    }
-    try {
-        // Log phase start
-        await logIssuePhaseEvent({
-            issueId,
-            eventType: 'phase_started',
-            phase: 'branch_planning',
-            result: 'info',
-            metadata: {
-                replace_existing: replaceExisting || false,
-                timestamp: new Date().toISOString(),
-            },
-        }, verbose);
-        // Fetch context
-        const context = await fetchBranchPlanningContext(issueId, verbose);
-        // Fetch feedbacks for branch_planning phase
-        const feedbacksContext = await fetchBranchPlanningFeedbacks(issueId, verbose);
-        const hasFeedbacks = (feedbacksContext?.feedbacks.length || 0) > 0;
-        // Determine operation mode
-        const hasExistingBranches = context.existing_branches.length > 0;
-        const isIncrementalUpdate = hasExistingBranches && hasFeedbacks && !replaceExisting;
-        logPlanningMode({
-            hasExistingBranches,
-            hasFeedbacks,
-            replaceExisting,
-            isIncrementalUpdate,
-            feedbacksContext,
-            existingBranchCount: context.existing_branches.length,
-            verbose,
-        });
-        // Check if there are existing branches and no feedbacks - no change needed
-        if (hasExistingBranches && !hasFeedbacks && !replaceExisting) {
-            if (verbose) {
-                logInfo(`Issue already has ${context.existing_branches.length} branches planned and no feedbacks to address.`);
-                logInfo('Use replaceExisting: true to re-plan.');
-            }
-            return buildNoChangeResult(issueId, context.existing_branches.length);
-        }
-        // Clear existing branches if requested (full re-plan)
-        if (replaceExisting && hasExistingBranches) {
-            if (verbose) {
-                logInfo(`Clearing ${context.existing_branches.length} existing branches for full re-plan...`);
-            }
-            await clearBranches({ issueId, verbose }, true);
-        }
-        // Build the user prompt based on mode
-        const contextInfo = formatContextForPrompt(context.issue, context.product, context.user_stories, context.test_cases);
-        const existingBranchesInfo = formatExistingBranchesForPrompt(context.existing_branches);
-        const systemPrompt = await createBranchPlanningSystemPrompt(config, issueId, undefined, verbose);
-        const userPrompt = await buildUserPrompt({
-            isIncrementalUpdate,
-            feedbacksContext,
-            existingBranchesInfo,
-            contextInfo,
-            issueId,
-            verbose,
-        });
-        if (verbose) {
-            logInfo('Starting Claude Code query for branch planning...');
-        }
-        // Execute query
-        const result = await executeBranchPlanningQuery(userPrompt, systemPrompt, config, verbose);
-        if (!result || !result.branches || result.branches.length === 0) {
-            const errorMsg = 'No branches were generated';
-            logError(errorMsg);
-            return buildErrorResult(issueId, errorMsg);
-        }
-        // Validate branches
-        const validation = validatePlannedBranches(result.branches);
-        if (!validation.valid) {
-            const errorMsg = `Invalid branch plan: ${validation.errors.join(', ')}`;
-            logError(errorMsg);
-            return buildErrorResult(issueId, errorMsg);
-        }
-        // Sort branches by dependency
-        const sortedBranches = sortBranchesByDependency(result.branches);
-        // For incremental update mode, clear existing branches before creating new ones
-        if (isIncrementalUpdate && hasExistingBranches) {
-            if (verbose) {
-                logInfo(`🔄 Clearing ${context.existing_branches.length} existing branches for incremental update...`);
-            }
-            await clearBranches({ issueId, verbose: false }, true);
-        }
-        // Create branches in database with proper dependencies
-        await persistBranches(sortedBranches, issueId, verbose);
-        if (verbose) {
-            const modeLabel = isIncrementalUpdate ? '🔄 Updated' : '✅ Created';
-            logInfo(`${modeLabel} ${sortedBranches.length} issue branches`);
-            sortedBranches.forEach((b, idx) => {
-                logInfo(`   ${idx + 1}. ${b.name}`);
-                if (b.scope) {
-                    b.scope.forEach((s) => logInfo(`      - ${s}`));
-                }
-            });
-        }
-        // Log phase completion
-        await logIssuePhaseEvent({
-            issueId,
-            eventType: 'phase_completed',
-            phase: 'branch_planning',
-            result: 'success',
-            metadata: {
-                branches_created: sortedBranches.length,
-                branch_names: sortedBranches.map((b) => b.name),
-                mode: isIncrementalUpdate ? 'incremental_update' : 'new_planning',
-                feedbacks_addressed: feedbacksContext?.feedbacks.length || 0,
-                timestamp: new Date().toISOString(),
-            },
-        }, verbose);
-        const summaryPrefix = isIncrementalUpdate
-            ? `Updated branch plan based on ${feedbacksContext?.feedbacks.length || 0} feedbacks.`
-            : '';
-        return buildSuccessResult(issueId, sortedBranches, result.summary ||
-            `${summaryPrefix} ${sortedBranches.length} branches for incremental development`.trim(), result.rationale);
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Branch planning failed: ${errorMessage}`);
-        // Log phase failure
-        await logIssuePhaseEvent({
-            issueId,
-            eventType: 'phase_failed',
-            phase: 'branch_planning',
-            result: 'error',
-            metadata: {
-                error: errorMessage,
-                timestamp: new Date().toISOString(),
-            },
-        }, verbose);
-        return buildErrorResult(issueId, errorMessage);
-    }
-};
-/**
- * Execute the branch planning query and parse the result
- */
-async function executeBranchPlanningQuery(userPrompt, systemPrompt, config, verbose) {
-    let lastAssistantResponse = '';
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let structuredResult = null;
-    let executionSessionId = '';
-    if (verbose) {
-        logInfo('🤖 Starting branch planning agent query...');
-    }
-    // Use Claude Code SDK without MCP servers - all info is pre-fetched
-    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}`);
-        }
-        // Stream the planning process
-        if (message.type === 'assistant' && message.message?.content) {
-            lastAssistantResponse += processAssistantContent(message.message.content, verbose);
-        }
-        if (message.type === 'result') {
-            executionSessionId = message.session_id || executionSessionId;
-            if (message.subtype === 'success') {
-                logInfo('\n📋 Branch planning completed, parsing results...');
-                try {
-                    const responseText = message.result || lastAssistantResponse;
-                    structuredResult = parseJsonResponse(responseText, verbose);
-                }
-                catch (error) {
-                    logError(`Failed to parse branch planning result: ${error}`);
-                }
-            }
-            else {
-                logError(`\n⚠️ Branch planning incomplete: ${message.subtype}`);
-            }
-        }
-    }
-    if (!structuredResult) {
-        return null;
-    }
-    return {
-        branches: structuredResult.branches || [],
-        summary: structuredResult.summary,
-        rationale: structuredResult.rationale,
-        execution_session_id: executionSessionId || undefined,
-    };
-}
-/**
- * Extract branches from a parsed object containing branch_planning_result
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function extractBranchPlanResult(parsed) {
-    if (parsed.branch_planning_result) {
-        return {
-            branches: parsed.branch_planning_result.branches || [],
-            summary: parsed.branch_planning_result.summary,
-            rationale: parsed.branch_planning_result.rationale,
-        };
-    }
-    return null;
-}
-/**
- * Find the first complete JSON object in a string using brace-matching
- */
-function extractFirstJsonObject(text) {
-    let braceCount = 0;
-    let startIndex = -1;
-    for (let i = 0; i < text.length; i++) {
-        if (text[i] === '{') {
-            if (startIndex === -1) {
-                startIndex = i;
-            }
-            braceCount++;
-        }
-        else if (text[i] === '}') {
-            braceCount--;
-            if (braceCount === 0 && startIndex !== -1) {
-                return text.substring(startIndex, i + 1);
-            }
-        }
-    }
-    return null;
-}
-/**
- * Parse JSON response from Claude
- */
-function parseJsonResponse(responseText, verbose) {
-    // Try to extract JSON from markdown code block
-    const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-    if (jsonBlockMatch) {
-        try {
-            const parsed = JSON.parse(jsonBlockMatch[1]);
-            return extractBranchPlanResult(parsed) || parsed;
-        }
-        catch (e) {
-            if (verbose) {
-                logError(`Failed to parse JSON from code block: ${e}`);
-            }
-        }
-    }
-    // Try to find JSON object containing "branch_planning_result"
-    const resultMatch = responseText.match(/\{[\s\S]*"branch_planning_result"[\s\S]*\}/);
-    if (resultMatch) {
-        try {
-            const jsonStr = extractFirstJsonObject(responseText);
-            if (jsonStr) {
-                const parsed = JSON.parse(jsonStr);
-                const result = extractBranchPlanResult(parsed);
-                if (result) {
-                    return result;
-                }
-            }
-        }
-        catch (e) {
-            if (verbose) {
-                logError(`Failed to extract JSON from response: ${e}`);
-            }
-        }
-    }
-    // Try to parse the entire response as JSON
-    try {
-        const parsed = JSON.parse(responseText);
-        const result = extractBranchPlanResult(parsed);
-        if (result) {
-            return result;
-        }
-        if (parsed.branches) {
-            return parsed;
-        }
-    }
-    catch (e) {
-        if (verbose) {
-            logError(`Failed to parse response as JSON: ${e}`);
-        }
-    }
-    return null;
-}
-export { fetchBranchPlanningContext } from './context.js';

package/dist/phases/branch-planning/outcome.d.ts

@@ -1,28 +0,0 @@
-import { type BranchPlanningResult, type PlannedBranch } from './index.js';
-/**
- * Build a successful branch planning result
- */
-export declare function buildSuccessResult(issueId: string, branches: PlannedBranch[], summary: string, rationale?: string): BranchPlanningResult;
-/**
- * Build an error result
- */
-export declare function buildErrorResult(issueId: string, errorMessage: string): BranchPlanningResult;
-/**
- * Build a result when no changes are needed
- */
-export declare function buildNoChangeResult(issueId: string, existingBranchCount: number): BranchPlanningResult;
-/**
- * Build a result for a single-branch issue
- */
-export declare function buildSingleBranchResult(issueId: string, branch: PlannedBranch): BranchPlanningResult;
-/**
- * Validate planned branches
- */
-export declare function validatePlannedBranches(branches: PlannedBranch[]): {
-    valid: boolean;
-    errors: string[];
-};
-/**
- * Sort branches by dependency order (topological sort based on depends_on_branch_name)
- */
-export declare function sortBranchesByDependency(branches: PlannedBranch[]): PlannedBranch[];

package/dist/phases/branch-planning/outcome.js

@@ -1,115 +0,0 @@
-/**
- * Build a successful branch planning result
- */
-export function buildSuccessResult(issueId, branches, summary, rationale) {
-    return {
-        issueId,
-        branches,
-        status: 'success',
-        summary,
-        rationale,
-    };
-}
-/**
- * Build an error result
- */
-export function buildErrorResult(issueId, errorMessage) {
-    return {
-        issueId,
-        branches: [],
-        status: 'error',
-        summary: `Branch planning failed: ${errorMessage}`,
-    };
-}
-/**
- * Build a result when no changes are needed
- */
-export function buildNoChangeResult(issueId, existingBranchCount) {
-    return {
-        issueId,
-        branches: [],
-        status: 'success',
-        summary: `Issue already has ${existingBranchCount} branches planned. No changes needed.`,
-    };
-}
-/**
- * Build a result for a single-branch issue
- */
-export function buildSingleBranchResult(issueId, branch) {
-    return {
-        issueId,
-        branches: [branch],
-        status: 'success',
-        summary: 'Issue is small enough to be implemented in a single branch.',
-        rationale: 'The issue scope is limited and can be completed in a single pull request without exceeding reasonable review size.',
-    };
-}
-/**
- * Validate planned branches
- */
-export function validatePlannedBranches(branches) {
-    const errors = [];
-    if (!branches || branches.length === 0) {
-        errors.push('No branches defined');
-        return { valid: false, errors };
-    }
-    // Check for required fields
-    branches.forEach((branch, idx) => {
-        if (!branch.name) {
-            errors.push(`Branch ${idx + 1}: Missing name`);
-        }
-        if (!branch.description) {
-            errors.push(`Branch ${idx + 1}: Missing description`);
-        }
-    });
-    // Check for circular dependencies
-    const branchNames = new Set(branches.map((b) => b.name));
-    branches.forEach((branch) => {
-        if (branch.depends_on) {
-            branch.depends_on.forEach((dep) => {
-                if (!branchNames.has(dep) && dep !== '') {
-                    errors.push(`Branch "${branch.name}": depends on unknown branch "${dep}"`);
-                }
-                if (dep === branch.name) {
-                    errors.push(`Branch "${branch.name}": cannot depend on itself`);
-                }
-            });
-        }
-    });
-    return { valid: errors.length === 0, errors };
-}
-/**
- * Sort branches by dependency order (topological sort based on depends_on_branch_name)
- */
-export function sortBranchesByDependency(branches) {
-    // Do a topological sort based on dependencies
-    const result = [];
-    const visited = new Set();
-    const visiting = new Set();
-    const branchMap = new Map();
-    branches.forEach((b) => branchMap.set(b.name, b));
-    function visit(branch) {
-        if (visited.has(branch.name)) {
-            return;
-        }
-        if (visiting.has(branch.name)) {
-            // Circular dependency - fall back to sequence order
-            return;
-        }
-        visiting.add(branch.name);
-        // Visit dependencies first
-        if (branch.depends_on) {
-            branch.depends_on.forEach((depName) => {
-                const dep = branchMap.get(depName);
-                if (dep) {
-                    visit(dep);
-                }
-            });
-        }
-        visiting.delete(branch.name);
-        visited.add(branch.name);
-        result.push(branch);
-    }
-    branches.forEach((branch) => visit(branch));
-    return result;
-}

package/dist/phases/branch-planning/prompts.d.ts

@@ -1,41 +0,0 @@
-import { type EdsgerConfig } from '../../types/index.js';
-/**
- * Create the system prompt for branch planning
- */
-export declare function createBranchPlanningSystemPrompt(config: EdsgerConfig, issueId: string, projectDir?: string, verbose?: boolean): Promise<string>;
-/**
- * Create the user prompt with context for branch planning
- */
-export declare function createBranchPlanningPromptWithContext(issueId: string, contextInfo: string, existingBranchesInfo: 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;
-}, userStories: {
-    title: string;
-    description: string;
-}[], testCases: {
-    name: string;
-    description: string;
-    is_critical: boolean;
-}[]): string;
-/**
- * Format existing branches for the prompt
- */
-export declare function formatExistingBranchesForPrompt(branches: {
-    name: string;
-    description?: string | null;
-    branch_name?: string | null;
-    status: string;
-    created_at: string;
-}[]): string;
-/**
- * Create improvement prompt for re-planning
- */
-export declare function createImprovementPrompt(feedback: string, currentPlan: string): string;