edsger 0.76.0 → 0.78.0

package/dist/types/llm-responses.d.ts

@@ -1,114 +0,0 @@
-/**
- * Types for structured responses parsed from LLM output.
- *
- * These define the expected shape of JSON returned by Claude in each phase.
- * Since LLM output is inherently untyped, callers should still validate
- * before trusting these shapes — but having the types makes the codebase
- * safer and easier to refactor.
- */
-export interface LLMAnalysisResult {
-    execution_plan?: string;
-    summary?: string;
-    status?: string;
-}
-export interface LLMUserStoriesResult {
-    created_user_stories?: {
-        title: string;
-        description: string;
-        acceptance_criteria?: string[];
-    }[];
-    deleted_user_story_ids?: string[];
-    deletion_reasons?: Record<string, string>;
-    summary?: string;
-    status?: string;
-}
-export interface LLMTestCasesResult {
-    created_test_cases?: {
-        name: string;
-        description: string;
-        is_critical?: boolean;
-        steps?: string[];
-    }[];
-    deleted_test_case_ids?: string[];
-    deletion_reasons?: Record<string, string>;
-    summary?: string;
-    status?: string;
-}
-export interface LLMTechnicalDesignResult {
-    technical_design: string;
-    summary?: string;
-    status?: string;
-}
-export interface LLMImplementationResult {
-    status: string;
-    summary?: string;
-    implementation_result?: {
-        status: string;
-        summary: string;
-        files_changed?: string[];
-        checklist_item_results?: {
-            checklist_item_id: string;
-            is_passed: boolean;
-            value?: unknown;
-            notes?: string;
-        }[];
-    };
-    checklist_item_results?: {
-        checklist_item_id: string;
-        is_passed: boolean;
-        value?: unknown;
-        notes?: string;
-    }[];
-}
-export interface LLMCodeReviewResult {
-    status: string;
-    summary?: string;
-    review_comments?: {
-        path: string;
-        line?: number;
-        body: string;
-        severity?: 'critical' | 'major' | 'minor' | 'suggestion';
-    }[];
-    checklist_item_results?: {
-        checklist_item_id: string;
-        is_passed: boolean;
-        value?: unknown;
-        notes?: string;
-    }[];
-}
-export interface LLMCodeRefineResult {
-    status: string;
-    summary?: string;
-    files_changed?: string[];
-    checklist_item_results?: {
-        checklist_item_id: string;
-        is_passed: boolean;
-        value?: unknown;
-        notes?: string;
-    }[];
-}
-export interface LLMBugFixResult {
-    status: string;
-    summary?: string;
-    filesFixed?: string[];
-    message?: string;
-}
-export interface LLMBranchPlanResult {
-    branches?: {
-        name: string;
-        description: string;
-        files?: string[];
-    }[];
-    summary?: string;
-    status?: string;
-}
-export interface LLMPRSplitResult {
-    pull_requests?: {
-        name: string;
-        description: string;
-        files?: string[];
-        sequence: number;
-    }[];
-    summary?: string;
-    status?: string;
-}

package/dist/types/llm-responses.js

@@ -1,9 +0,0 @@
-/**
- * Types for structured responses parsed from LLM output.
- *
- * These define the expected shape of JSON returned by Claude in each phase.
- * Since LLM output is inherently untyped, callers should still validate
- * before trusting these shapes — but having the types makes the codebase
- * safer and easier to refactor.
- */
-export {};

package/dist/types/pipeline.d.ts

@@ -1,28 +0,0 @@
-/**
- * Type definitions for pipeline execution
- */
-import { type ChecklistPhaseContext } from '../services/checklist.js';
-import { type EdsgerConfig } from './index.js';
-export type ExecutionMode = 'full_pipeline' | 'only_issue_analysis' | 'only_user_stories_analysis' | 'only_test_cases_analysis' | 'only_technical_design' | 'only_branch_planning' | 'only_code_implementation' | 'only_pr_splitting' | 'only_pr_execution' | 'only_functional_testing' | 'only_code_refine' | 'only_code_review' | 'from_issue_analysis' | 'from_user_stories_analysis' | 'from_test_cases_analysis' | 'from_technical_design' | 'from_branch_planning' | 'from_code_implementation' | 'from_pr_splitting' | 'from_pr_execution' | 'from_functional_testing' | 'from_code_review' | 'custom' | 'autonomous';
-export type WorkflowPhaseStatus = 'pending' | 'completed';
-export interface WorkflowPhase {
-    phase: string;
-    status: WorkflowPhaseStatus;
-    executed_at?: string;
-}
-export type IssueWorkflow = WorkflowPhase[];
-export interface PipelinePhaseOptions {
-    readonly issueId: string;
-    readonly verbose?: boolean;
-}
-export interface PipelineResult {
-    readonly issueId: string;
-    readonly phase: string;
-    readonly status: 'success' | 'error' | 'blocked';
-    readonly message: string;
-    readonly data?: unknown;
-}
-export interface PhaseConfig {
-    readonly name: string;
-    readonly execute: (options: PipelinePhaseOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<unknown>;
-}

package/dist/types/pipeline.js

@@ -1,4 +0,0 @@
-/**
- * Type definitions for pipeline execution
- */
-export {};

package/dist/updater/auto-updater.d.ts

@@ -1,39 +0,0 @@
-/**
- * Auto Updater - Checks for and applies CLI updates automatically
- *
- * Issues:
- * - Checks npm registry for latest version
- * - Compares with current version
- * - Updates the package globally
- * - New issue workers automatically use the updated code (fork-based architecture)
- */
-/**
- * Get the latest published version from npm registry
- */
-export declare function getLatestVersion(): string | null;
-/**
- * Check if an update is available
- */
-export declare function checkForUpdate(): {
-    available: boolean;
-    currentVersion: string;
-    latestVersion: string | null;
-};
-/**
- * Perform the update by running npm install -g
- * Note: may require elevated permissions on some systems
- */
-export declare function performUpdate(): boolean;
-/**
- * Check for updates and apply if available
- * This is the main function called periodically
- */
-export declare function checkAndUpdate(): void;
-/**
- * Start the periodic update checker
- */
-export declare function startAutoUpdateChecker(): void;
-/**
- * Stop the periodic update checker
- */
-export declare function stopAutoUpdateChecker(): void;

package/dist/updater/auto-updater.js

@@ -1,134 +0,0 @@
-/**
- * Auto Updater - Checks for and applies CLI updates automatically
- *
- * Issues:
- * - Checks npm registry for latest version
- * - Compares with current version
- * - Updates the package globally
- * - New issue workers automatically use the updated code (fork-based architecture)
- */
-import { execSync } from 'child_process';
-import { getVersion, resetVersionCache } from '../constants.js';
-import { logError, logInfo, logSuccess, logWarning } from '../utils/logger.js';
-/** How often to check for updates (in milliseconds) - every 5 minutes */
-const UPDATE_CHECK_INTERVAL = 5 * 60 * 1000;
-let updateCheckTimer;
-/**
- * Get the latest published version from npm registry
- */
-export function getLatestVersion() {
-    try {
-        const result = execSync('npm view edsger version', {
-            encoding: 'utf-8',
-            stdio: 'pipe',
-            timeout: 15_000,
-        }).trim();
-        return result || null;
-    }
-    catch (error) {
-        logWarning(`Failed to check latest version: ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}
-/**
- * Compare two semver version strings
- * Returns: -1 if a < b, 0 if a == b, 1 if a > b
- */
-function compareVersions(a, b) {
-    const partsA = a.split('.').map(Number);
-    const partsB = b.split('.').map(Number);
-    for (let i = 0; i < 3; i++) {
-        const numA = partsA[i] || 0;
-        const numB = partsB[i] || 0;
-        if (numA < numB) {
-            return -1;
-        }
-        if (numA > numB) {
-            return 1;
-        }
-    }
-    return 0;
-}
-/**
- * Check if an update is available
- */
-export function checkForUpdate() {
-    const currentVersion = getVersion();
-    const latestVersion = getLatestVersion();
-    if (!latestVersion) {
-        return { available: false, currentVersion, latestVersion: null };
-    }
-    const available = compareVersions(currentVersion, latestVersion) < 0;
-    return { available, currentVersion, latestVersion };
-}
-/**
- * Perform the update by running npm install -g
- * Note: may require elevated permissions on some systems
- */
-export function performUpdate() {
-    logInfo('Updating edsger to the latest version...');
-    try {
-        execSync('npm install -g edsger@latest', {
-            stdio: 'pipe',
-            timeout: 120_000,
-        });
-        // Reset the cached version so it picks up the new one
-        resetVersionCache();
-        const newVersion = getVersion();
-        logSuccess(`Updated to v${newVersion}`);
-        return true;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (message.includes('EACCES') || message.includes('permission')) {
-            logWarning('Update failed: permission denied. Try running with sudo or fix npm permissions.');
-        }
-        else {
-            logError(`Update failed: ${message}`);
-        }
-        return false;
-    }
-}
-/**
- * Check for updates and apply if available
- * This is the main function called periodically
- */
-export function checkAndUpdate() {
-    try {
-        const { available, currentVersion, latestVersion } = checkForUpdate();
-        if (available && latestVersion) {
-            logInfo(`Update available: v${currentVersion} -> v${latestVersion}`);
-            const success = performUpdate();
-            if (success) {
-                logSuccess('Update applied. New issue workers will use the updated version automatically.');
-            }
-        }
-        else {
-            logInfo(`Version check: v${currentVersion} is up to date${latestVersion ? ` (latest: v${latestVersion})` : ' (registry check failed)'}`);
-        }
-    }
-    catch (error) {
-        logWarning(`Update check failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Start the periodic update checker
- */
-export function startAutoUpdateChecker() {
-    logInfo(`Auto-update checker enabled (checking every ${UPDATE_CHECK_INTERVAL / 60000} minutes)`);
-    // Check immediately on start (in next tick to not block startup)
-    setTimeout(() => checkAndUpdate(), 0);
-    // Then check periodically
-    updateCheckTimer = setInterval(() => {
-        checkAndUpdate();
-    }, UPDATE_CHECK_INTERVAL);
-}
-/**
- * Stop the periodic update checker
- */
-export function stopAutoUpdateChecker() {
-    if (updateCheckTimer) {
-        clearInterval(updateCheckTimer);
-        updateCheckTimer = undefined;
-    }
-}

package/dist/utils/conflict-resolver.d.ts

@@ -1,49 +0,0 @@
-/**
- * Conflict Resolver
- * Uses Claude agent to complete the entire rebase process including conflict resolution
- */
-/**
- * Configuration for conflict resolution
- */
-export interface ConflictResolverConfig {
-    model?: string;
-    verbose?: boolean;
-    maxTurns?: number;
-    issueBranch?: string;
-    baseBranch?: string;
-    /**
-     * Original base branch before squash merge.
-     * When provided, this indicates the rebase was started with --onto
-     * to only replay commits after this branch.
-     */
-    originalBaseBranch?: string;
-    /**
-     * When true, the base branch's feat was already squash-merged to main.
-     * All conflicts should be resolved by accepting "theirs" (main's version)
-     * so duplicate commits from the base branch become empty and get dropped.
-     */
-    baseBranchCompleted?: boolean;
-}
-/**
- * Result of conflict resolution
- */
-export interface ConflictResolutionResult {
-    success: boolean;
-    resolvedFiles: string[];
-    failedFiles: string[];
-    error?: string;
-}
-/**
- * Resolve all conflicts by letting Claude complete the entire rebase process
- *
- * This function gives Claude full control to:
- * 1. Examine the conflict state
- * 2. Read and understand conflicting files
- * 3. Edit files to resolve conflicts
- * 4. Stage resolved files and continue rebase
- * 5. Repeat until rebase is complete
- *
- * @param config - Configuration for conflict resolution
- * @returns Result of the conflict resolution
- */
-export declare function resolveConflictsWithAgent(config?: ConflictResolverConfig): Promise<ConflictResolutionResult>;

package/dist/utils/conflict-resolver.js

@@ -1,201 +0,0 @@
-/**
- * Conflict Resolver
- * Uses Claude agent to complete the entire rebase process including conflict resolution
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { abortRebase, getConflictFiles, getCurrentBranch, isRebaseInProgress, } from './git-branch-manager.js';
-import { logError, logInfo } from './logger.js';
-/**
- * Extract the last text message from assistant content
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function extractLastTextMessage(content) {
-    if (typeof content === 'string') {
-        return content;
-    }
-    if (Array.isArray(content)) {
-        for (const block of content) {
-            if (block.type === 'text') {
-                return block.text;
-            }
-        }
-    }
-    return '';
-}
-/**
- * Create a prompt generator for the Claude agent
- */
-function* createPromptGenerator(prompt) {
-    yield {
-        type: 'user',
-        message: { role: 'user', content: prompt },
-    };
-}
-/**
- * Create a system prompt for conflict resolution
- */
-function createConflictResolutionSystemPrompt(baseBranchCompleted) {
-    const basePrompt = `You are a skilled software engineer completing a git rebase operation that has conflicts.
-
-Your task is to resolve ALL merge conflicts and complete the rebase successfully.
-
-WORKFLOW:
-1. First, run "git status" to see the current state and identify all conflicting files
-2. For each conflicting file:
-   a. Read the file to see the conflict markers
-   b. Understand the intent of both sides (ours vs theirs)
-   c. Use the Edit tool to resolve the conflict - merge changes intelligently
-   d. Run "git add <file>" to stage the resolved file
-3. After ALL conflicts are resolved, run "git rebase --continue"
-4. If more conflicts appear from subsequent commits, repeat steps 1-3
-5. Continue until the rebase is complete (no more rebase in progress)`;
-    const resolutionRules = baseBranchCompleted
-        ? `
-CONFLICT RESOLUTION RULES:
-- The base branch has already been squash-merged to main. The conflicts are caused by
-  old commits from the base branch being replayed on top of main which already has those changes.
-- For EVERY conflict, accept "theirs" (main's version) by running: git checkout --theirs <file> && git add <file>
-- This will make the duplicate commits empty, and git rebase will automatically drop them.
-- Do NOT try to merge changes intelligently - main already has the final correct version.
-- After resolving all conflicts with --theirs, run "git rebase --continue"
-- If git says "No changes - did you forget to use 'git add'?", run "git rebase --skip" to skip the empty commit`
-        : `
-CONFLICT RESOLUTION RULES:
-- Remove ALL conflict markers (<<<<<<, =======, >>>>>>>)
-- Merge changes intelligently - don't just pick one side
-- Preserve functionality from both sides when possible
-- If changes are truly incompatible, prefer theirs (incoming) as it's usually newer
-- Ensure the resulting code is syntactically correct
-- DO NOT add comments explaining the merge`;
-    return `${basePrompt + resolutionRules}
-
-IMPORTANT:
-- Use "git status" to check progress
-- Use the Read tool to examine conflicting files
-- Use the Edit tool to fix conflicts (remove markers, merge content)
-- Use Bash for git commands (git add, git rebase --continue)
-- Keep working until "git status" shows no rebase in progress
-- If you encounter an error you cannot resolve, explain what went wrong`;
-}
-/**
- * Create the initial prompt describing the rebase task
- */
-function createRebaseTaskPrompt(issueBranch, baseBranch, conflictFiles, originalBaseBranch) {
-    let context = `A git rebase operation is in progress and has encountered conflicts.
-
-## Current Situation
-- Issue branch: ${issueBranch}
-- Rebasing onto: ${baseBranch}`;
-    if (originalBaseBranch) {
-        context += `
-- Original base branch: ${originalBaseBranch}
-- Note: This is a rebase after squash-merge. The base branch (${originalBaseBranch}) was squash-merged
-  into ${baseBranch}. We used "git rebase --onto" to only replay commits that are new relative to
-  ${originalBaseBranch}. The "theirs" side in conflicts comes from ${baseBranch} (the squashed code).`;
-    }
-    context += `
-- Conflicting files: ${conflictFiles.length > 0 ? conflictFiles.join(', ') : '(run git status to see)'}
-
-## Your Task
-Complete the rebase by resolving all conflicts. Use git status, read the conflicting files, edit them to resolve conflicts, stage with git add, and continue the rebase.
-
-Start by running "git status" to see the current state.`;
-    return context;
-}
-/**
- * Resolve all conflicts by letting Claude complete the entire rebase process
- *
- * This function gives Claude full control to:
- * 1. Examine the conflict state
- * 2. Read and understand conflicting files
- * 3. Edit files to resolve conflicts
- * 4. Stage resolved files and continue rebase
- * 5. Repeat until rebase is complete
- *
- * @param config - Configuration for conflict resolution
- * @returns Result of the conflict resolution
- */
-// eslint-disable-next-line complexity -- orchestration function with conflict detection, agent resolution, and cleanup
-export async function resolveConflictsWithAgent(config = {}) {
-    const { model = 'sonnet', verbose, maxTurns = 100, issueBranch, baseBranch, originalBaseBranch, baseBranchCompleted, } = config;
-    const _resolvedFiles = [];
-    if (verbose) {
-        logInfo(`\n🔧 Starting automatic conflict resolution with Claude agent...`);
-    }
-    // Get initial conflict information
-    const currentBranch = issueBranch || getCurrentBranch();
-    const targetBranch = baseBranch || 'main';
-    const initialConflictFiles = getConflictFiles();
-    if (verbose) {
-        logInfo(`   Issue branch: ${currentBranch}`);
-        logInfo(`   Rebasing onto: ${targetBranch}`);
-        if (originalBaseBranch) {
-            logInfo(`   Original base (--onto): ${originalBaseBranch}`);
-        }
-        logInfo(`   Initial conflicts: ${initialConflictFiles.length} file(s)`);
-    }
-    const systemPrompt = createConflictResolutionSystemPrompt(baseBranchCompleted);
-    const userPrompt = createRebaseTaskPrompt(currentBranch, targetBranch, initialConflictFiles, originalBaseBranch);
-    try {
-        let lastMessage = '';
-        for await (const message of query({
-            prompt: createPromptGenerator(userPrompt),
-            options: {
-                systemPrompt: {
-                    type: 'preset',
-                    preset: 'claude_code',
-                    append: systemPrompt,
-                },
-                model,
-                maxTurns,
-                permissionMode: 'bypassPermissions',
-            },
-        })) {
-            if (verbose && message.type === 'assistant' && message.message?.content) {
-                lastMessage = extractLastTextMessage(message.message.content);
-            }
-        }
-        // Check if rebase completed successfully
-        if (!isRebaseInProgress()) {
-            if (verbose) {
-                logInfo(`✅ Rebase completed successfully`);
-            }
-            // Get the list of files that were resolved (approximate from initial conflicts)
-            return {
-                success: true,
-                resolvedFiles: initialConflictFiles,
-                failedFiles: [],
-            };
-        }
-        // Rebase still in progress - something went wrong
-        const remainingConflicts = getConflictFiles();
-        if (verbose) {
-            logError(`❌ Rebase still in progress with ${remainingConflicts.length} conflicts`);
-            if (lastMessage) {
-                logError(`   Last message: ${lastMessage.substring(0, 200)}...`);
-            }
-        }
-        abortRebase(verbose);
-        return {
-            success: false,
-            resolvedFiles: [],
-            failedFiles: remainingConflicts,
-            error: `Rebase not completed. Remaining conflicts: ${remainingConflicts.join(', ')}`,
-        };
-    }
-    catch (error) {
-        if (verbose) {
-            logError(`❌ Error during conflict resolution: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        // Try to abort rebase to leave repo in clean state
-        if (isRebaseInProgress()) {
-            abortRebase(verbose);
-        }
-        return {
-            success: false,
-            resolvedFiles: [],
-            failedFiles: getConflictFiles(),
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}

package/dist/utils/formatters.d.ts

@@ -1,42 +0,0 @@
-import { type CodeImplementationContext } from '../phases/code-implementation/context.js';
-import { type FunctionalTestingContext } from '../phases/functional-testing/context-fetcher.js';
-import { type IssueAnalysisContext } from '../phases/issue-analysis/context.js';
-import { type TechnicalDesignContext } from '../phases/technical-design/context.js';
-import type { TestCase, UserStory } from '../types/issues.js';
-import { type DownloadedImage } from './image-downloader.js';
-/**
- * Format user stories for display in prompts
- */
-export declare function formatUserStories(stories: UserStory[]): string;
-/**
- * Format test cases for display in prompts
- */
-export declare function formatTestCases(cases: TestCase[]): string;
-/**
- * Format technical design context for Claude Code prompts
- */
-export declare function formatTechnicalDesignContext(context: TechnicalDesignContext): Promise<{
-    content: string;
-    downloadedImages: DownloadedImage[];
-}>;
-/**
- * Format issue analysis context for Claude Code prompts
- */
-export declare function formatIssueAnalysisContext(context: IssueAnalysisContext): Promise<{
-    content: string;
-    downloadedImages: DownloadedImage[];
-}>;
-/**
- * Format code implementation context for Claude Code prompts
- */
-export declare function formatCodeImplementationContext(context: CodeImplementationContext): Promise<{
-    content: string;
-    downloadedImages: DownloadedImage[];
-}>;
-/**
- * Format functional testing context for Claude Code prompts
- */
-export declare function formatFunctionalTestingContext(context: FunctionalTestingContext): Promise<{
-    content: string;
-    downloadedImages: DownloadedImage[];
-}>;