edsger 0.76.0 → 0.78.0

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

@@ -1,182 +0,0 @@
-import { execFileSync } from 'child_process';
-import { getGitHubConfig } from '../../api/github.js';
-import { getIssue } from '../../api/issues/index.js';
-import { getProduct } from '../../api/products.js';
-import { getBranches } from '../../services/branches.js';
-import { getPullRequests, } from '../../services/pull-requests.js';
-import { branchExists, remoteBranchExists, } from '../../utils/git-branch-manager.js';
-import { buildCredentialArgs } from '../../utils/git-push.js';
-import { getRepoForkInfo, resolveDefaultBranch, } from '../../utils/github-repo-info.js';
-import { logError, logInfo } from '../../utils/logger.js';
-/**
- * Get the dev branch name for an issue
- */
-function getDevBranchName(issueId) {
-    return `dev/${issueId}`;
-}
-/**
- * Get the HEAD SHA of a branch
- */
-function getBranchHeadSha(branchName) {
-    return execFileSync('git', ['rev-parse', branchName], {
-        encoding: 'utf-8',
-    }).trim();
-}
-/**
- * Get diff stat between two refs
- */
-function getDiffStat(baseRef, headRef) {
-    try {
-        return execFileSync('git', ['diff', '--stat', `${baseRef}...${headRef}`], {
-            encoding: 'utf-8',
-        }).trim();
-    }
-    catch {
-        return '';
-    }
-}
-/**
- * Get list of changed files between two refs
- */
-function getChangedFiles(baseRef, headRef) {
-    try {
-        const output = execFileSync('git', ['diff', '--name-only', `${baseRef}...${headRef}`], { encoding: 'utf-8' }).trim();
-        if (!output) {
-            return [];
-        }
-        return output.split('\n').filter((f) => f.length > 0);
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Determine the diff base ref for incremental re-runs
- * If existing PRs have last_synced_commit, use the earliest one
- * Otherwise use origin/<defaultBranch> (remote-tracking ref, always up-to-date after fetch)
- */
-function determineDiffBaseRef(existingPRs, defaultBranchRef, replaceExisting) {
-    if (replaceExisting || existingPRs.length === 0) {
-        return defaultBranchRef;
-    }
-    // Find the minimum last_synced_commit (earliest sync point)
-    const syncedCommits = existingPRs
-        .map((pr) => pr.last_synced_commit)
-        .filter((c) => c !== null);
-    if (syncedCommits.length === 0) {
-        return defaultBranchRef;
-    }
-    // All PRs should have been synced to the same commit
-    // Use the first one (they should all be equal after a successful sync)
-    return syncedCommits[0];
-}
-/**
- * Fetch all context information needed for PR splitting
- */
-// eslint-disable-next-line complexity -- assembles context from many data sources with fallback handling
-export async function fetchPRSplittingContext(issueId, verbose, replaceExisting) {
-    try {
-        if (verbose) {
-            logInfo(`Fetching PR splitting context for issue: ${issueId}`);
-        }
-        const devBranchName = getDevBranchName(issueId);
-        // Fetch database data and GitHub config in parallel (need token before remote branch check)
-        const [issue, existingBranches, existingPullRequests, githubConfig] = await Promise.all([
-            getIssue(issueId, verbose),
-            getBranches({ issueId, verbose }).catch(() => []),
-            getPullRequests({ issueId, verbose }).catch(() => []),
-            getGitHubConfig(issueId, verbose),
-        ]);
-        // Fetch latest remote refs (updates origin/main and all remote-tracking branches)
-        try {
-            const credArgs = buildCredentialArgs(githubConfig.token);
-            execFileSync('git', [...credArgs, 'fetch', 'origin'], {
-                encoding: 'utf-8',
-                stdio: 'pipe',
-            });
-            if (verbose) {
-                logInfo('✅ Fetched latest remote refs');
-            }
-        }
-        catch (error) {
-            if (verbose) {
-                logInfo(`⚠️  Could not fetch from origin: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        // Verify dev branch exists
-        const localExists = branchExists(devBranchName);
-        const remoteExists = !localExists && remoteBranchExists(devBranchName, githubConfig.token);
-        if (!localExists && !remoteExists) {
-            throw new Error(`Development branch '${devBranchName}' does not exist. ` +
-                `The issue must have code on the dev branch before PR splitting.`);
-        }
-        const product = await getProduct(issue.product_id, verbose);
-        // Detect fork status
-        let forkInfo = { isFork: false };
-        if (githubConfig.configured &&
-            githubConfig.token &&
-            githubConfig.owner &&
-            githubConfig.repo) {
-            try {
-                forkInfo = await getRepoForkInfo(githubConfig.token, githubConfig.owner, githubConfig.repo);
-                if (verbose) {
-                    logInfo(forkInfo.isFork
-                        ? `📌 Repository is a fork of ${forkInfo.upstream?.owner}/${forkInfo.upstream?.repo}`
-                        : `📌 Repository is not a fork`);
-                }
-            }
-            catch (error) {
-                if (verbose) {
-                    logError(`Failed to detect fork status: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        }
-        // Resolve the repo's default branch (handles non-main defaults and forks).
-        // Prefer the GitHub API value (already fetched in forkInfo above); fall back
-        // to the local symbolic-ref, then to literal 'main'.
-        const defaultBranch = resolveDefaultBranch(forkInfo.defaultBranch);
-        const defaultBranchRef = `origin/${defaultBranch}`;
-        // Determine diff range
-        const devRef = localExists ? devBranchName : `origin/${devBranchName}`;
-        const baseRef = determineDiffBaseRef(existingPullRequests, defaultBranchRef, replaceExisting);
-        const devBranchHeadSha = getBranchHeadSha(devRef);
-        // Check if there are new changes since last sync
-        if (baseRef !== defaultBranchRef && baseRef === devBranchHeadSha) {
-            if (verbose) {
-                logInfo(`No new changes since last sync (HEAD: ${devBranchHeadSha})`);
-            }
-        }
-        // Get diff information
-        const diffStat = getDiffStat(baseRef, devRef);
-        const changedFiles = getChangedFiles(baseRef, devRef);
-        if (verbose) {
-            logInfo(`✅ PR splitting context fetched successfully:`);
-            logInfo(`   Issue: ${issue.name}`);
-            logInfo(`   Product: ${product.name}`);
-            logInfo(`   Dev Branch: ${devBranchName}`);
-            logInfo(`   Dev Branch HEAD: ${devBranchHeadSha}`);
-            logInfo(`   Diff Base: ${baseRef}`);
-            logInfo(`   Changed Files: ${changedFiles.length}`);
-            logInfo(`   Existing Branches: ${existingBranches.length}`);
-            logInfo(`   Existing Pull Requests: ${existingPullRequests.length}`);
-            logInfo(`   GitHub: ${githubConfig.configured ? 'Configured' : 'Not configured'}`);
-        }
-        return {
-            issue,
-            product,
-            existing_branches: existingBranches,
-            existing_pull_requests: existingPullRequests,
-            diffStat,
-            changedFiles,
-            devBranchName,
-            devBranchHeadSha,
-            githubConfig,
-            forkInfo,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to fetch PR splitting context: ${errorMessage}`);
-        throw new Error(`Context fetch failed: ${errorMessage}`);
-    }
-}

package/dist/phases/pr-splitting/import-dep-validator.d.ts

@@ -1,67 +0,0 @@
-/**
- * Import dependency validator for PR splitting
- *
- * After the AI produces a PR split plan, this module analyzes import
- * dependencies between changed files and auto-fixes ordering violations
- * by moving dependency files to earlier PRs in the stack.
- */
-import { type PlannedPullRequest } from './index.js';
-/** A record of a file moved between PRs during auto-fix */
-export interface MovedFile {
-    file: string;
-    fromPR: string;
-    toPR: string;
-    reason: string;
-}
-/** Result of the validation + auto-fix pass */
-export interface ImportValidationResult {
-    /** Whether any files were moved between PRs */
-    modified: boolean;
-    /** The (potentially reordered) PR list */
-    pullRequests: PlannedPullRequest[];
-    /** Human-readable log of what was moved */
-    movedFiles: MovedFile[];
-}
-/**
- * Main entry point: validate and auto-fix import dependency ordering
- * across a planned PR stack.
- */
-export declare function validateAndFixImportDependencies(pullRequests: PlannedPullRequest[], changedFiles: string[], devBranchRef: string, verbose?: boolean): ImportValidationResult;
-/**
- * Read a file's contents from a git ref without checkout.
- * Returns empty string if file doesn't exist at that ref.
- */
-export declare function readFileAtRef(ref: string, filePath: string): string;
-/**
- * Parse all relative import/export specifiers from TypeScript/JavaScript source.
- * Returns deduplicated relative specifier strings (e.g., './utils', '../types').
- */
-export declare function parseImportSpecifiers(sourceCode: string): string[];
-/**
- * Resolve a relative import specifier to one of the changed files.
- * Handles extension resolution (.ts, .tsx, .js, .jsx) and /index variants.
- * Also handles .js→.ts mapping (ESM convention where imports use .js extension
- * but actual source files are .ts).
- * Returns the matched changed-file path or null.
- */
-export declare function resolveImportToChangedFile(specifier: string, importingFilePath: string, changedFilesSet: Set<string>): string | null;
-/**
- * Build a dependency graph: for each changed file, which other changed files it imports.
- */
-export declare function buildDependencyGraph(changedFiles: string[], devBranchRef: string): Map<string, Set<string>>;
-/**
- * Compute transitive closure: given a file, return all files it transitively depends on.
- * Handles cycles without infinite loops.
- */
-export declare function getTransitiveDependencies(file: string, graph: Map<string, Set<string>>): Set<string>;
-/**
- * Given PRs sorted by sequence and a dependency graph, detect violations
- * and auto-fix by moving files to earlier PRs.
- *
- * A violation occurs when file A (in PR N) imports from file B (in PR M, M > N).
- * Fix: move B to PR N so it's available when PR N's branch is created.
- */
-export declare function autoFixPROrdering(pullRequests: PlannedPullRequest[], dependencyGraph: Map<string, Set<string>>): {
-    pullRequests: PlannedPullRequest[];
-    movedFiles: MovedFile[];
-};

package/dist/phases/pr-splitting/import-dep-validator.js

@@ -1,255 +0,0 @@
-/**
- * Import dependency validator for PR splitting
- *
- * After the AI produces a PR split plan, this module analyzes import
- * dependencies between changed files and auto-fixes ordering violations
- * by moving dependency files to earlier PRs in the stack.
- */
-import { execFileSync } from 'child_process';
-import { dirname, join, normalize } from 'path';
-import { logInfo, logWarning } from '../../utils/logger.js';
-/**
- * Main entry point: validate and auto-fix import dependency ordering
- * across a planned PR stack.
- */
-export function validateAndFixImportDependencies(pullRequests, changedFiles, devBranchRef, verbose) {
-    const graph = buildDependencyGraph(changedFiles, devBranchRef);
-    const { pullRequests: fixed, movedFiles } = autoFixPROrdering(pullRequests, graph);
-    if (verbose && movedFiles.length > 0) {
-        logInfo(`\n🔧 Import dependency auto-fix: moved ${movedFiles.length} file(s)`);
-        for (const move of movedFiles) {
-            logInfo(`   ${move.file}: "${move.fromPR}" → "${move.toPR}"`);
-            logInfo(`      Reason: ${move.reason}`);
-        }
-    }
-    return {
-        modified: movedFiles.length > 0,
-        pullRequests: fixed,
-        movedFiles,
-    };
-}
-/**
- * Read a file's contents from a git ref without checkout.
- * Returns empty string if file doesn't exist at that ref.
- */
-export function readFileAtRef(ref, filePath) {
-    try {
-        return execFileSync('git', ['show', `${ref}:${filePath}`], {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-    }
-    catch {
-        return '';
-    }
-}
-const PARSABLE_EXTENSIONS = /\.(ts|tsx|js|jsx|mts|mjs|cts|cjs)$/;
-/**
- * Parse all relative import/export specifiers from TypeScript/JavaScript source.
- * Returns deduplicated relative specifier strings (e.g., './utils', '../types').
- */
-export function parseImportSpecifiers(sourceCode) {
-    const specifiers = [];
-    // 1. Static imports/exports with `from` clause:
-    //    import { X } from './path'
-    //    import X from './path'
-    //    import * as X from './path'
-    //    import type { X } from './path'
-    //    export { X } from './path'
-    //    export * from './path'
-    const fromPattern = /(?:import|export)\s[\s\S]*?\bfrom\s*['"]([^'"]+)['"]/g;
-    let match;
-    while ((match = fromPattern.exec(sourceCode)) !== null) {
-        specifiers.push(match[1]);
-    }
-    // 2. Side-effect imports: import './polyfill'
-    //    Must use line-start anchor to avoid matching "import X from '...'"
-    const sideEffectPattern = /^\s*import\s+['"]([^'"]+)['"]/gm;
-    while ((match = sideEffectPattern.exec(sourceCode)) !== null) {
-        specifiers.push(match[1]);
-    }
-    // 3. Dynamic imports: import('./path')
-    const dynamicPattern = /\bimport\(\s*['"]([^'"]+)['"]\s*\)/g;
-    while ((match = dynamicPattern.exec(sourceCode)) !== null) {
-        specifiers.push(match[1]);
-    }
-    // Deduplicate and filter to relative imports only
-    return [...new Set(specifiers)].filter((s) => s.startsWith('./') || s.startsWith('../'));
-}
-/** Extensions to try when resolving imports (order matters) */
-const EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
-const INDEX_SUFFIXES = EXTENSIONS.map((ext) => `/index${ext}`);
-/**
- * Resolve a relative import specifier to one of the changed files.
- * Handles extension resolution (.ts, .tsx, .js, .jsx) and /index variants.
- * Also handles .js→.ts mapping (ESM convention where imports use .js extension
- * but actual source files are .ts).
- * Returns the matched changed-file path or null.
- */
-export function resolveImportToChangedFile(specifier, importingFilePath, changedFilesSet) {
-    const importingDir = dirname(importingFilePath);
-    const resolved = normalize(join(importingDir, specifier));
-    // 1. Exact match (specifier already has extension)
-    if (changedFilesSet.has(resolved)) {
-        return resolved;
-    }
-    // 2. Try appending extensions: ./utils → ./utils.ts, ./utils.tsx, etc.
-    for (const ext of EXTENSIONS) {
-        const candidate = resolved + ext;
-        if (changedFilesSet.has(candidate)) {
-            return candidate;
-        }
-    }
-    // 3. Try as directory with index file: ./types → ./types/index.ts, etc.
-    for (const suffix of INDEX_SUFFIXES) {
-        const candidate = resolved + suffix;
-        if (changedFilesSet.has(candidate)) {
-            return candidate;
-        }
-    }
-    // 4. Handle .js/.jsx extension in specifier (ESM convention:
-    //    `import from './utils.js'` actually resolves to utils.ts at compile time)
-    if (/\.jsx?$/.test(resolved)) {
-        const withoutExt = resolved.replace(/\.jsx?$/, '');
-        for (const ext of EXTENSIONS) {
-            const candidate = withoutExt + ext;
-            if (changedFilesSet.has(candidate)) {
-                return candidate;
-            }
-        }
-    }
-    return null;
-}
-/**
- * Build a dependency graph: for each changed file, which other changed files it imports.
- */
-export function buildDependencyGraph(changedFiles, devBranchRef) {
-    const changedFilesSet = new Set(changedFiles);
-    const graph = new Map();
-    for (const filePath of changedFiles) {
-        const deps = new Set();
-        graph.set(filePath, deps);
-        if (!PARSABLE_EXTENSIONS.test(filePath)) {
-            continue;
-        }
-        const content = readFileAtRef(devBranchRef, filePath);
-        if (!content) {
-            continue;
-        }
-        const specifiers = parseImportSpecifiers(content);
-        for (const specifier of specifiers) {
-            const resolved = resolveImportToChangedFile(specifier, filePath, changedFilesSet);
-            if (resolved && resolved !== filePath) {
-                deps.add(resolved);
-            }
-        }
-    }
-    return graph;
-}
-/**
- * Compute transitive closure: given a file, return all files it transitively depends on.
- * Handles cycles without infinite loops.
- */
-export function getTransitiveDependencies(file, graph) {
-    const result = new Set();
-    const stack = [file];
-    while (stack.length > 0) {
-        const current = stack.pop();
-        if (current === undefined) {
-            continue;
-        }
-        const deps = graph.get(current);
-        if (!deps) {
-            continue;
-        }
-        for (const dep of deps) {
-            if (!result.has(dep)) {
-                result.add(dep);
-                stack.push(dep);
-            }
-        }
-    }
-    return result;
-}
-const MAX_FIX_ITERATIONS = 100;
-function moveDepToEarlierPR(options) {
-    const { dep, prIdx, sorted, fileToPRIndex, movedFiles, reason } = options;
-    const depPRIdx = fileToPRIndex.get(dep);
-    if (depPRIdx === undefined || depPRIdx <= prIdx) {
-        return false;
-    }
-    const sourcePR = sorted[depPRIdx];
-    const targetPR = sorted[prIdx];
-    const depFileEntry = sourcePR.files?.find((f) => f.path === dep);
-    if (!depFileEntry) {
-        return false;
-    }
-    sourcePR.files = sourcePR.files?.filter((f) => f.path !== dep) ?? [];
-    if (!targetPR.files) {
-        targetPR.files = [];
-    }
-    targetPR.files.push(depFileEntry);
-    fileToPRIndex.set(dep, prIdx);
-    movedFiles.push({
-        file: dep,
-        fromPR: `PR #${sourcePR.sequence} (${sourcePR.name})`,
-        toPR: `PR #${targetPR.sequence} (${targetPR.name})`,
-        reason,
-    });
-    return true;
-}
-/**
- * Given PRs sorted by sequence and a dependency graph, detect violations
- * and auto-fix by moving files to earlier PRs.
- *
- * A violation occurs when file A (in PR N) imports from file B (in PR M, M > N).
- * Fix: move B to PR N so it's available when PR N's branch is created.
- */
-export function autoFixPROrdering(pullRequests, dependencyGraph) {
-    const sorted = [...pullRequests].sort((a, b) => a.sequence - b.sequence);
-    const movedFiles = [];
-    // Deep-clone files arrays so we don't mutate the original
-    for (const pr of sorted) {
-        pr.files = pr.files ? [...pr.files] : [];
-    }
-    // Build mutable file → PR index mapping (0-based, lower = earlier)
-    const fileToPRIndex = new Map();
-    for (let i = 0; i < sorted.length; i++) {
-        for (const file of sorted[i].files ?? []) {
-            fileToPRIndex.set(file.path, i);
-        }
-    }
-    // Fixed-point loop: keep moving files until no more violations
-    let changed = true;
-    let iterations = 0;
-    while (changed && iterations < MAX_FIX_ITERATIONS) {
-        changed = false;
-        iterations++;
-        for (let prIdx = 0; prIdx < sorted.length; prIdx++) {
-            for (const file of sorted[prIdx].files ?? []) {
-                const transitiveDeps = getTransitiveDependencies(file.path, dependencyGraph);
-                for (const dep of transitiveDeps) {
-                    const moved = moveDepToEarlierPR({
-                        dep,
-                        prIdx,
-                        sorted,
-                        fileToPRIndex,
-                        movedFiles,
-                        reason: `imported by ${file.path}`,
-                    });
-                    // eslint-disable-next-line max-depth
-                    if (moved) {
-                        changed = true;
-                    }
-                }
-            }
-        }
-    }
-    // Warn about empty PRs
-    for (const pr of sorted) {
-        if (!pr.files || pr.files.length === 0) {
-            logWarning(`PR "${pr.name}" (seq ${pr.sequence}) has no files after import dependency auto-fix`);
-        }
-    }
-    return { pullRequests: sorted, movedFiles };
-}

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

@@ -1,36 +0,0 @@
-import { type EdsgerConfig } from '../../types/index.js';
-export interface PRSplittingOptions {
-    issueId: string;
-    verbose?: boolean;
-    replaceExisting?: boolean;
-}
-export interface PlannedPullRequest {
-    sequence: number;
-    name: string;
-    description: string;
-    branch_name?: string;
-    depends_on_branch_name?: string | null;
-    files?: {
-        path: string;
-        change_type: string;
-    }[];
-    scope?: string[];
-    acceptance_criteria?: string[];
-}
-export interface PRSplittingResult {
-    issueId: string;
-    pullRequests: PlannedPullRequest[];
-    status: 'success' | 'error';
-    summary: string;
-    rationale?: string;
-}
-/**
- * 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 declare const splitIssueIntoPRs: (options: PRSplittingOptions, config: EdsgerConfig) => Promise<PRSplittingResult>;
-export type { PRSplittingContext } from './context.js';
-export { fetchPRSplittingContext } from './context.js';