edsger 0.77.0 → 0.78.0

package/dist/services/branches.js

@@ -1,391 +0,0 @@
-/**
- * Branches service for pipeline integration
- * Allows phases to manage branches via MCP
- */
-import { callMcpEndpoint } from '../api/mcp-client.js';
-import { getSupabase, hasSupabaseSession } from '../supabase/client.js';
-import { logDebug, logInfo, logSuccess } from '../utils/logger.js';
-/**
- * List all branches for an issue
- */
-export async function getBranches(options) {
-    const { issueId, verbose } = options;
-    if (verbose) {
-        logInfo(`Fetching branches for issue: ${issueId}`);
-    }
-    let branches = null;
-    if (hasSupabaseSession()) {
-        try {
-            const { data, error } = await getSupabase()
-                .from('branches')
-                .select('*')
-                .eq('issue_id', issueId)
-                .order('created_at', { ascending: true });
-            if (error) {
-                throw new Error(error.message);
-            }
-            branches = (data || []);
-        }
-        catch {
-            // Fall through to MCP
-        }
-    }
-    if (!branches) {
-        const result = (await callMcpEndpoint('branches/list', {
-            issue_id: issueId,
-        }));
-        branches = result?.branches || [];
-    }
-    if (verbose) {
-        logSuccess(`Found ${branches.length} branches`);
-    }
-    return branches;
-}
-/**
- * Get the current active branch for an issue
- */
-export async function getCurrentBranch(options) {
-    const { issueId, verbose } = options;
-    if (verbose) {
-        logInfo(`Getting current branch for issue: ${issueId}`);
-    }
-    const result = (await callMcpEndpoint('branches/current', {
-        issue_id: issueId,
-    }));
-    return result?.current_branch || null;
-}
-/**
- * Create branches
- */
-export async function createBranches(options, branches) {
-    const { issueId, verbose } = options;
-    if (verbose) {
-        logInfo(`Creating ${branches.length} branches for issue: ${issueId}`);
-    }
-    let createdBranches = null;
-    if (hasSupabaseSession() && branches.length > 0) {
-        try {
-            const rows = branches.map((b) => ({ issue_id: issueId, ...b }));
-            const { data, error } = await getSupabase()
-                .from('branches')
-                .insert(rows)
-                .select();
-            if (error) {
-                throw new Error(error.message);
-            }
-            createdBranches = (data || []);
-        }
-        catch {
-            // Fall through to MCP
-        }
-    }
-    if (!createdBranches) {
-        const result = (await callMcpEndpoint('branches/create', {
-            issue_id: issueId,
-            branches,
-        }));
-        createdBranches = result?.created_branches || [];
-    }
-    if (verbose) {
-        logSuccess(`Created ${createdBranches.length} branches`);
-        createdBranches.forEach((b, idx) => {
-            logDebug(`   ${idx + 1}. ${b.name} (status: ${b.status})`, verbose);
-        });
-    }
-    return createdBranches;
-}
-/**
- * Update a branch
- */
-export async function updateBranch(branchId, updates, verbose) {
-    if (verbose) {
-        logInfo(`Updating branch: ${branchId}`);
-    }
-    let updated = null;
-    if (hasSupabaseSession()) {
-        try {
-            const { data, error } = await getSupabase()
-                .from('branches')
-                .update(updates)
-                .eq('id', branchId)
-                .select()
-                .single();
-            if (error) {
-                throw new Error(error.message);
-            }
-            updated = data ?? null;
-        }
-        catch {
-            // Fall through to MCP
-        }
-    }
-    if (!updated) {
-        const result = (await callMcpEndpoint('branches/update', {
-            branch_id: branchId,
-            ...updates,
-        }));
-        updated = result?.branch;
-    }
-    if (verbose) {
-        logSuccess(`Branch updated successfully`);
-    }
-    return updated;
-}
-/**
- * Clear all branches for an issue (used before re-planning)
- */
-export async function clearBranches(options, force = false) {
-    const { issueId, verbose } = options;
-    if (verbose) {
-        logInfo(`Clearing branches for issue: ${issueId}`);
-    }
-    const result = (await callMcpEndpoint('branches/clear', {
-        issue_id: issueId,
-        force,
-    }));
-    const deletedCount = result?.deleted_count || 0;
-    if (verbose) {
-        logSuccess(`Cleared ${deletedCount} branches`);
-    }
-    return deletedCount;
-}
-/**
- * Format branches for context (to include in prompts)
- */
-export function formatBranchesForContext(branches) {
-    if (!branches || branches.length === 0) {
-        return 'No branches defined yet.';
-    }
-    const getStatusEmoji = (status) => {
-        switch (status) {
-            case 'completed':
-                return '🏁';
-            case 'merged':
-                return '✅';
-            case 'refined':
-                return '🎯';
-            case 'reviewed':
-                return '📝';
-            case 'ready_for_review':
-                return '👀';
-            case 'in_progress':
-                return '🔄';
-            case 'closed':
-                return '❌';
-            case 'pending':
-            default:
-                return '⏳';
-        }
-    };
-    const branchList = branches
-        .map((b, idx) => {
-        const statusEmoji = getStatusEmoji(b.status);
-        return `${idx + 1}. **${b.name}** ${statusEmoji}
-   - Status: ${b.status}
-   - Branch: ${b.branch_name || 'Not created'}
-   - PR: ${b.pull_request_url || 'Not created'}
-   - Description: ${b.description || 'No description'}`;
-    })
-        .join('\n\n');
-    return `# Branches
-
-${branchList}
-
-Total: ${branches.length} branches
-Merged: ${branches.filter((b) => b.status === 'merged').length}
-In Progress: ${branches.filter((b) => b.status === 'in_progress').length}
-Pending: ${branches.filter((b) => b.status === 'pending').length}`;
-}
-/**
- * Check if issue has multiple branches planned
- */
-export async function hasMultipleBranches(options) {
-    const branches = await getBranches(options);
-    return branches.length > 1;
-}
-/**
- * Get next pending branch to work on
- */
-export async function getNextPendingBranch(options) {
-    const branches = await getBranches(options);
-    return branches.find((b) => b.status === 'pending') || null;
-}
-/**
- * Check if all branches are completed (feat merged to main)
- */
-export async function allBranchesCompleted(options) {
-    const branches = await getBranches(options);
-    if (branches.length === 0) {
-        return true;
-    }
-    return branches.every((b) => b.status === 'completed' || b.status === 'merged' || b.status === 'closed');
-}
-/**
- * Get the base branch information for a branch.
- *
- * Rebase strategies based on base branch status:
- * - no base_branch_id: create from main, no rebase (first branch in chain)
- * - completed (feat merged to main): rebase onto main using --onto dev/xxx
- * - merged (dev merged to feat): create from feat/xxx, rebase onto feat/xxx using --onto dev/xxx
- * - in_progress/pending: create from dev/xxx, no rebase (base on parent dev branch)
- *
- * For 'merged' status:
- * - New branches are created from feat/xxx (which contains squashed commits)
- * - Existing branches (created from dev/xxx) are rebased onto feat/xxx
- * - Uses --onto to skip commits inherited from parent's dev branch
- * - Rebase to main happens later when base branch becomes 'completed'
- */
-export function getBaseBranchInfo(branch, allBranches, mainBranch = 'main') {
-    // No base branch - start from main (first branch in chain)
-    if (!branch.base_branch_id) {
-        return {
-            baseBranch: mainBranch,
-            needsRebase: false,
-            baseBranchMerged: true,
-        };
-    }
-    // Find the base branch
-    const baseBranch = allBranches.find((b) => b.id === branch.base_branch_id);
-    if (!baseBranch) {
-        // Base branch not found - fall back to main
-        return {
-            baseBranch: mainBranch,
-            needsRebase: false,
-            baseBranchMerged: true,
-        };
-    }
-    // Check if base branch is completed (feat merged to main)
-    if (baseBranch.status === 'completed') {
-        // Base branch's feat was squash-merged to main. origin/feat/base was likely
-        // synced to origin/main during the base branch's code-implementation phase,
-        // so using feat/base as the --onto boundary would be a no-op.
-        //
-        // However, origin/dev/base (the parent's dev branch) is NOT synced to main
-        // and retains its original history. If the current branch was created from
-        // dev/base (which happens when the parent wasn't merged at creation time),
-        // using origin/dev/base as the --onto boundary correctly skips all inherited
-        // commits: git rebase --onto origin/main origin/dev/base
-        //
-        // baseBranchCompleted tells the conflict resolver to use "theirs" (main)
-        // for all conflicts as a safety net for any commits that survive the --onto.
-        if (baseBranch.branch_name) {
-            return {
-                baseBranch: mainBranch,
-                rebaseTargetBranch: mainBranch,
-                originalBaseBranch: baseBranch.branch_name, // dev/xxx - use parent's dev branch as --onto boundary
-                needsRebase: true,
-                baseBranchMerged: true,
-                baseBranchCompleted: true,
-            };
-        }
-        return {
-            baseBranch: mainBranch,
-            needsRebase: false,
-            baseBranchMerged: true,
-            baseBranchCompleted: true,
-        };
-    }
-    // Check if base branch is merged (dev merged to feat, but feat not yet merged to main)
-    if (baseBranch.status === 'merged') {
-        // Base branch's dev is squash-merged to feat, but feat is NOT yet merged to main.
-        // Two scenarios:
-        // 1. Creating new branch: create from feat/xxx (no rebase needed)
-        // 2. Existing branch created from dev/xxx: need --onto rebase to feat/xxx
-        //
-        // We set rebaseTargetBranch to feat/xxx (NOT main!) and originalBaseBranch to dev/xxx.
-        // This enables: git rebase --onto origin/feat/xxx origin/dev/xxx
-        // Which moves commits after dev/xxx onto feat/xxx.
-        if (!baseBranch.branch_name) {
-            return {
-                baseBranch: mainBranch,
-                needsRebase: false,
-                baseBranchMerged: true,
-            };
-        }
-        const featBranchName = baseBranch.branch_name.replace(/^dev\//, 'feat/');
-        return {
-            baseBranch: featBranchName, // Create new branches from feat/xxx
-            rebaseTargetBranch: featBranchName, // Rebase onto feat/xxx (NOT main!)
-            originalBaseBranch: baseBranch.branch_name, // dev/xxx - skip commits inherited from parent dev
-            needsRebase: true,
-            baseBranchMerged: true,
-        };
-    }
-    // Base branch is not merged - we should base on that branch
-    if (!baseBranch.branch_name) {
-        // Base branch doesn't have a git branch yet - fall back to main
-        return {
-            baseBranch: mainBranch,
-            needsRebase: false,
-            baseBranchMerged: false,
-        };
-    }
-    return {
-        baseBranch: baseBranch.branch_name,
-        needsRebase: false,
-        baseBranchMerged: false,
-    };
-}
-/**
- * Get branch by ID
- */
-export async function getBranchById(branchId, verbose) {
-    if (verbose) {
-        logInfo(`Fetching branch: ${branchId}`);
-    }
-    if (hasSupabaseSession()) {
-        try {
-            const { data, error } = await getSupabase()
-                .from('branches')
-                .select('*')
-                .eq('id', branchId)
-                .maybeSingle();
-            if (error) {
-                throw new Error(error.message);
-            }
-            return data ?? null;
-        }
-        catch {
-            // Fall through to MCP
-        }
-    }
-    const result = (await callMcpEndpoint('branches/get', {
-        branch_id: branchId,
-    }));
-    return result?.branch || null;
-}
-/**
- * Get the branch that is ready for review (for post-implementation phases)
- * Returns the first branch with status 'ready_for_review'
- */
-export async function getReadyForReviewBranch(options) {
-    const branches = await getBranches(options);
-    return branches.find((b) => b.status === 'ready_for_review') || null;
-}
-/**
- * Get the branch that has been reviewed (for code-refine phase)
- * Returns the first branch with status 'reviewed'
- */
-export async function getReviewedBranch(options) {
-    const branches = await getBranches(options);
-    return branches.find((b) => b.status === 'reviewed') || null;
-}
-/**
- * Get the branch that is in progress (in_progress or ready_for_review)
- * Useful for phases that need to work on the current active branch
- */
-export async function getActiveBranch(options) {
-    const branches = await getBranches(options);
-    // First try to find ready_for_review (after implementation)
-    const readyBranch = branches.find((b) => b.status === 'ready_for_review');
-    if (readyBranch) {
-        return readyBranch;
-    }
-    // Then try in_progress
-    const inProgressBranch = branches.find((b) => b.status === 'in_progress');
-    if (inProgressBranch) {
-        return inProgressBranch;
-    }
-    // Fall back to pending
-    return branches.find((b) => b.status === 'pending') || null;
-}

package/dist/services/checklist.d.ts

@@ -1,100 +0,0 @@
-/**
- * Checklist service for pipeline integration
- */
-import { type PipelinePhaseOptions } from '../types/pipeline.js';
-export type { PipelinePhaseOptions };
-export interface ChecklistItem {
-    id: string;
-    title: string;
-    description: string;
-    item_type: 'boolean' | 'text' | 'number' | 'select';
-    is_required: boolean;
-    sort_order: number;
-    config: Record<string, unknown>;
-}
-export interface Checklist {
-    id: string;
-    product_id: string;
-    issue_id: string | null;
-    name: string;
-    description: string | null;
-    role: string;
-    phases: string[];
-    is_active: boolean;
-    sort_order: number;
-    created_at: string;
-    updated_at: string;
-    items: ChecklistItem[];
-}
-export interface ChecklistValidation {
-    checklist_id: string;
-    checklist_name: string;
-    role: string;
-    is_completed: boolean;
-    completed_at: string | null;
-    status: 'not_started' | 'pending' | 'in_progress' | 'completed' | 'skipped';
-}
-export interface ChecklistPhaseContext {
-    phase: string;
-    issue_id: string;
-    checklists: Checklist[];
-}
-export interface ChecklistValidationResult {
-    phase: string;
-    issue_id: string;
-    all_completed: boolean;
-    checklists_validation: ChecklistValidation[];
-    summary: string;
-}
-/**
- * Fetch checklists for a specific phase
- */
-export declare function getChecklistsForPhase(options: PipelinePhaseOptions, phase: string): Promise<ChecklistPhaseContext>;
-/**
- * Validate checklist completion for a phase
- */
-export declare function validateChecklistsForPhase(options: PipelinePhaseOptions, phase: string): Promise<ChecklistValidationResult>;
-/**
- * Create checklist results (mark as started/in-progress)
- */
-export declare function createChecklistResult(options: PipelinePhaseOptions, checklistId: string, itemResults?: Record<string, unknown>[]): Promise<unknown>;
-/**
- * Strictly validate that all required checklists have results
- * Returns error if any checklists exist but don't have results
- */
-export declare function validateRequiredChecklistResults(options: PipelinePhaseOptions, phase: string, verbose?: boolean): Promise<{
-    success: boolean;
-    error?: string;
-    missingChecklists: string[];
-}>;
-/**
- * Create checklist item result
- */
-export declare function createChecklistItemResult(options: PipelinePhaseOptions, checklistItemId: string, isPassed: boolean, value?: unknown, notes?: string): Promise<unknown>;
-/**
- * Process checklist item results from phase JSON response and create MCP results
- */
-export declare function processChecklistItemResultsFromResponse(options: PipelinePhaseOptions, phase: string, checklistItemResults?: {
-    checklist_item_id: string;
-    is_passed: boolean;
-    value?: unknown;
-    notes?: string;
-}[], verbose?: boolean): Promise<{
-    created: number;
-    errors: string[];
-}>;
-/**
- * Process checklist results from phase JSON response and create MCP results
- */
-export declare function processChecklistResultsFromResponse(options: PipelinePhaseOptions, checklistResults?: {
-    checklist_id: string;
-    satisfied: boolean;
-    notes?: string;
-}[], verbose?: boolean): Promise<{
-    created: number;
-    errors: string[];
-}>;
-/**
- * Format checklist context as string for LLM consumption
- */
-export declare function formatChecklistsForContext(context: ChecklistPhaseContext): string;