edsger 0.76.0 → 0.78.0

package/dist/phases/autonomous/prompts.js

@@ -1,31 +0,0 @@
-/**
- * Prompts for the autonomous development phase
- */
-import { resolveSkill, substituteVariables, } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export const createAutonomousSystemPrompt = async (issueId, projectDir) => {
-    const skill = await resolveSkill('phase/autonomous', {
-        projectDir,
-    });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/autonomous');
-    }
-    let { prompt } = skill;
-    prompt = substituteVariables(prompt, { ISSUE_ID: issueId });
-    return `${prompt}
-
-${OUTPUT_CONTRACTS['autonomous']}`;
-};
-export function createAutonomousUserPrompt(issueDescription) {
-    return `## Objective
-
-${issueDescription}
-
-## Instructions
-
-Analyze the current state of the codebase. Based on the objective above, decide the next most valuable step to move toward the goal. Implement the change, verify it works, and commit it.
-
-Focus on ONE coherent, well-scoped change. Make real progress toward the objective.
-
-Begin by analyzing the codebase to understand the current state and decide your next step.`;
-}

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

@@ -1,14 +0,0 @@
-import { type ProductInfo } from '../../api/products.js';
-import { type Branch } from '../../services/branches.js';
-import type { IssueInfo, TestCase, UserStory } from '../../types/issues.js';
-export interface BranchPlanningContext {
-    issue: IssueInfo;
-    product: ProductInfo;
-    user_stories: UserStory[];
-    test_cases: TestCase[];
-    existing_branches: Branch[];
-}
-/**
- * Fetch all context information needed for branch planning via MCP endpoints
- */
-export declare function fetchBranchPlanningContext(issueId: string, verbose?: boolean): Promise<BranchPlanningContext>;

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

@@ -1,43 +0,0 @@
-import { getIssue, getTestCases, getUserStories, } from '../../api/issues/index.js';
-import { getProduct } from '../../api/products.js';
-import { getBranches } from '../../services/branches.js';
-import { logError, logInfo } from '../../utils/logger.js';
-/**
- * Fetch all context information needed for branch planning via MCP endpoints
- */
-export async function fetchBranchPlanningContext(issueId, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Fetching branch planning context for issue: ${issueId}`);
-        }
-        // Fetch all required data in parallel for better performance
-        const [issue, userStories, testCases, existingBranches] = await Promise.all([
-            getIssue(issueId, verbose),
-            getUserStories(issueId, verbose),
-            getTestCases(issueId, verbose),
-            getBranches({ issueId, verbose }).catch(() => []),
-        ]);
-        const product = await getProduct(issue.product_id, verbose);
-        if (verbose) {
-            logInfo(`✅ Branch planning context fetched successfully:`);
-            logInfo(`   Issue: ${issue.name}`);
-            logInfo(`   Product: ${product.name}`);
-            logInfo(`   User Stories: ${userStories.length}`);
-            logInfo(`   Test Cases: ${testCases.length}`);
-            logInfo(`   Technical Design: ${issue.technical_design ? 'Yes' : 'No'}`);
-            logInfo(`   Existing Branches: ${existingBranches.length}`);
-        }
-        return {
-            issue,
-            product,
-            user_stories: userStories,
-            test_cases: testCases,
-            existing_branches: existingBranches,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to fetch branch planning context: ${errorMessage}`);
-        throw new Error(`Context fetch failed: ${errorMessage}`);
-    }
-}

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

@@ -1,25 +0,0 @@
-import { type EdsgerConfig } from '../../types/index.js';
-export interface BranchPlanningOptions {
-    issueId: string;
-    verbose?: boolean;
-    replaceExisting?: boolean;
-}
-export interface PlannedBranch {
-    name: string;
-    description: string;
-    branch_name?: string;
-    depends_on?: string[];
-    depends_on_branch_name?: string | null;
-    scope?: string[];
-    acceptance_criteria?: string[];
-}
-export interface BranchPlanningResult {
-    issueId: string;
-    branches: PlannedBranch[];
-    status: 'success' | 'error';
-    summary: string;
-    rationale?: string;
-}
-export declare const planIssueBranches: (options: BranchPlanningOptions, config: EdsgerConfig) => Promise<BranchPlanningResult>;
-export type { BranchPlanningContext } from './context.js';
-export { fetchBranchPlanningContext } from './context.js';

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;
-}