edsger 0.39.2 → 0.39.3

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,331 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { autoFixPROrdering, getTransitiveDependencies, parseImportSpecifiers, resolveImportToChangedFile, } from '../import-dep-validator.js';
+// ============================================================
+// parseImportSpecifiers
+// ============================================================
+void describe('parseImportSpecifiers', () => {
+    void it('parses named imports', () => {
+        const result = parseImportSpecifiers(`import { foo } from './utils'`);
+        assert.deepStrictEqual(result, ['./utils']);
+    });
+    void it('parses default imports', () => {
+        const result = parseImportSpecifiers(`import foo from './utils'`);
+        assert.deepStrictEqual(result, ['./utils']);
+    });
+    void it('parses namespace imports', () => {
+        const result = parseImportSpecifiers(`import * as foo from './utils'`);
+        assert.deepStrictEqual(result, ['./utils']);
+    });
+    void it('parses side-effect imports', () => {
+        const result = parseImportSpecifiers(`import './polyfill'`);
+        assert.deepStrictEqual(result, ['./polyfill']);
+    });
+    void it('parses type-only imports', () => {
+        const result = parseImportSpecifiers(`import type { Foo } from './types'`);
+        assert.deepStrictEqual(result, ['./types']);
+    });
+    void it('parses re-exports', () => {
+        const result = parseImportSpecifiers(`export { foo } from './utils'`);
+        assert.deepStrictEqual(result, ['./utils']);
+    });
+    void it('parses star re-exports', () => {
+        const result = parseImportSpecifiers(`export * from './utils'`);
+        assert.deepStrictEqual(result, ['./utils']);
+    });
+    void it('parses dynamic imports', () => {
+        const result = parseImportSpecifiers(`const m = import('./lazy')`);
+        assert.deepStrictEqual(result, ['./lazy']);
+    });
+    void it('parses multiple imports', () => {
+        const source = `
+import { foo } from './utils'
+import Bar from '../components/Bar'
+import type { Baz } from './types'
+`;
+        const result = parseImportSpecifiers(source);
+        assert.deepStrictEqual(result, ['./utils', '../components/Bar', './types']);
+    });
+    void it('filters out non-relative imports', () => {
+        const source = `
+import { X } from 'lodash'
+import React from 'react'
+import { Y } from './local'
+import { Z } from '@scope/package'
+`;
+        const result = parseImportSpecifiers(source);
+        assert.deepStrictEqual(result, ['./local']);
+    });
+    void it('parses multiline imports', () => {
+        const source = `import {
+  foo,
+  bar,
+  baz
+} from './utils'`;
+        const result = parseImportSpecifiers(source);
+        assert.deepStrictEqual(result, ['./utils']);
+    });
+    void it('deduplicates specifiers', () => {
+        const source = `
+import { foo } from './utils'
+import { bar } from './utils'
+`;
+        const result = parseImportSpecifiers(source);
+        assert.deepStrictEqual(result, ['./utils']);
+    });
+    void it('handles .js extension in specifier', () => {
+        const result = parseImportSpecifiers(`import { X } from './utils.js'`);
+        assert.deepStrictEqual(result, ['./utils.js']);
+    });
+    void it('returns empty for empty source', () => {
+        assert.deepStrictEqual(parseImportSpecifiers(''), []);
+    });
+    void it('returns empty for non-relative only', () => {
+        const source = `import express from 'express'`;
+        assert.deepStrictEqual(parseImportSpecifiers(source), []);
+    });
+    void it('parses export default from', () => {
+        const result = parseImportSpecifiers(`export { default as X } from './module'`);
+        assert.deepStrictEqual(result, ['./module']);
+    });
+});
+// ============================================================
+// resolveImportToChangedFile
+// ============================================================
+void describe('resolveImportToChangedFile', () => {
+    void it('resolves exact match with extension', () => {
+        const changed = new Set(['src/utils.ts']);
+        const result = resolveImportToChangedFile('./utils.ts', 'src/app.ts', changed);
+        assert.strictEqual(result, 'src/utils.ts');
+    });
+    void it('infers .ts extension', () => {
+        const changed = new Set(['src/utils.ts']);
+        const result = resolveImportToChangedFile('./utils', 'src/app.ts', changed);
+        assert.strictEqual(result, 'src/utils.ts');
+    });
+    void it('infers .tsx extension', () => {
+        const changed = new Set(['src/Component.tsx']);
+        const result = resolveImportToChangedFile('./Component', 'src/app.ts', changed);
+        assert.strictEqual(result, 'src/Component.tsx');
+    });
+    void it('resolves index file', () => {
+        const changed = new Set(['src/types/index.ts']);
+        const result = resolveImportToChangedFile('./types', 'src/app.ts', changed);
+        assert.strictEqual(result, 'src/types/index.ts');
+    });
+    void it('resolves .js to .ts (ESM convention)', () => {
+        const changed = new Set(['src/utils.ts']);
+        const result = resolveImportToChangedFile('./utils.js', 'src/app.ts', changed);
+        assert.strictEqual(result, 'src/utils.ts');
+    });
+    void it('resolves parent directory traversal', () => {
+        const changed = new Set(['src/shared/helpers.ts']);
+        const result = resolveImportToChangedFile('../shared/helpers', 'src/components/Button.ts', changed);
+        assert.strictEqual(result, 'src/shared/helpers.ts');
+    });
+    void it('resolves double parent traversal', () => {
+        const changed = new Set(['src/utils.ts']);
+        const result = resolveImportToChangedFile('../../utils', 'src/features/explore/App.ts', changed);
+        assert.strictEqual(result, 'src/utils.ts');
+    });
+    void it('returns null for non-changed file', () => {
+        const changed = new Set(['src/other.ts']);
+        const result = resolveImportToChangedFile('./utils', 'src/app.ts', changed);
+        assert.strictEqual(result, null);
+    });
+    void it('returns null for external package import path', () => {
+        // This shouldn't happen since parseImportSpecifiers filters these,
+        // but test defensive behavior
+        const changed = new Set(['src/utils.ts']);
+        const result = resolveImportToChangedFile('./nonexistent', 'src/app.ts', changed);
+        assert.strictEqual(result, null);
+    });
+    void it('prefers .ts over .tsx when both exist', () => {
+        const changed = new Set(['src/utils.ts', 'src/utils.tsx']);
+        const result = resolveImportToChangedFile('./utils', 'src/app.ts', changed);
+        assert.strictEqual(result, 'src/utils.ts');
+    });
+});
+// ============================================================
+// getTransitiveDependencies
+// ============================================================
+void describe('getTransitiveDependencies', () => {
+    void it('returns direct dependency', () => {
+        const graph = new Map([
+            ['A', new Set(['B'])],
+            ['B', new Set()],
+        ]);
+        const result = getTransitiveDependencies('A', graph);
+        assert.deepStrictEqual(result, new Set(['B']));
+    });
+    void it('returns transitive dependencies', () => {
+        const graph = new Map([
+            ['A', new Set(['B'])],
+            ['B', new Set(['C'])],
+            ['C', new Set()],
+        ]);
+        const result = getTransitiveDependencies('A', graph);
+        assert.deepStrictEqual(result, new Set(['B', 'C']));
+    });
+    void it('handles diamond dependency', () => {
+        const graph = new Map([
+            ['A', new Set(['B', 'C'])],
+            ['B', new Set(['D'])],
+            ['C', new Set(['D'])],
+            ['D', new Set()],
+        ]);
+        const result = getTransitiveDependencies('A', graph);
+        assert.deepStrictEqual(result, new Set(['B', 'C', 'D']));
+    });
+    void it('handles cycles without infinite loop', () => {
+        const graph = new Map([
+            ['A', new Set(['B'])],
+            ['B', new Set(['A'])],
+        ]);
+        const result = getTransitiveDependencies('A', graph);
+        assert.deepStrictEqual(result, new Set(['B', 'A']));
+    });
+    void it('returns empty set for no dependencies', () => {
+        const graph = new Map([['A', new Set()]]);
+        const result = getTransitiveDependencies('A', graph);
+        assert.deepStrictEqual(result, new Set());
+    });
+    void it('returns empty set for unknown file', () => {
+        const graph = new Map();
+        const result = getTransitiveDependencies('unknown', graph);
+        assert.deepStrictEqual(result, new Set());
+    });
+});
+// ============================================================
+// autoFixPROrdering
+// ============================================================
+function makePR(sequence, name, files, dependsOn) {
+    return {
+        sequence,
+        name,
+        description: name,
+        branch_name: `pr/feat/${sequence}-${name.toLowerCase().replace(/\s/g, '-')}`,
+        depends_on_branch_name: dependsOn ?? null,
+        files: files.map((f) => ({ path: f, change_type: 'modified' })),
+    };
+}
+void describe('autoFixPROrdering', () => {
+    void it('returns unchanged when no violations', () => {
+        const prs = [
+            makePR(1, 'Foundation', ['src/utils.ts']),
+            makePR(2, 'Components', ['src/app.ts'], 'pr/feat/1-foundation'),
+        ];
+        // app.ts depends on utils.ts, and utils.ts is in PR 1 (earlier) — OK
+        const graph = new Map([
+            ['src/app.ts', new Set(['src/utils.ts'])],
+            ['src/utils.ts', new Set()],
+        ]);
+        const result = autoFixPROrdering(prs, graph);
+        assert.strictEqual(result.movedFiles.length, 0);
+        assert.strictEqual(result.pullRequests[0].files?.length, 1);
+        assert.strictEqual(result.pullRequests[1].files?.length, 1);
+    });
+    void it('moves dependency from later PR to earlier PR', () => {
+        const prs = [
+            makePR(1, 'Components', ['src/app.ts']),
+            makePR(2, 'Utils', ['src/utils.ts'], 'pr/feat/1-components'),
+        ];
+        // app.ts (PR 1) depends on utils.ts (PR 2) — violation!
+        const graph = new Map([
+            ['src/app.ts', new Set(['src/utils.ts'])],
+            ['src/utils.ts', new Set()],
+        ]);
+        const result = autoFixPROrdering(prs, graph);
+        assert.strictEqual(result.movedFiles.length, 1);
+        assert.strictEqual(result.movedFiles[0].file, 'src/utils.ts');
+        // utils.ts should now be in PR 1
+        const pr1Files = result.pullRequests[0].files?.map((f) => f.path) ?? [];
+        assert.ok(pr1Files.includes('src/utils.ts'));
+        assert.ok(pr1Files.includes('src/app.ts'));
+        // PR 2 should be empty
+        assert.strictEqual(result.pullRequests[1].files?.length, 0);
+    });
+    void it('handles transitive dependency moves', () => {
+        const prs = [
+            makePR(1, 'App', ['src/app.ts']),
+            makePR(2, 'Service', ['src/service.ts'], 'pr/feat/1-app'),
+            makePR(3, 'Utils', ['src/utils.ts'], 'pr/feat/2-service'),
+        ];
+        // app.ts → service.ts → utils.ts (chain across 3 PRs)
+        const graph = new Map([
+            ['src/app.ts', new Set(['src/service.ts'])],
+            ['src/service.ts', new Set(['src/utils.ts'])],
+            ['src/utils.ts', new Set()],
+        ]);
+        const result = autoFixPROrdering(prs, graph);
+        // Both service.ts and utils.ts should move to PR 1
+        const pr1Files = result.pullRequests[0].files?.map((f) => f.path) ?? [];
+        assert.ok(pr1Files.includes('src/app.ts'));
+        assert.ok(pr1Files.includes('src/service.ts'));
+        assert.ok(pr1Files.includes('src/utils.ts'));
+    });
+    void it('moves dep to earliest PR that needs it', () => {
+        const prs = [
+            makePR(1, 'PR1', ['src/a.ts']),
+            makePR(2, 'PR2', ['src/b.ts'], 'pr/feat/1-pr1'),
+            makePR(3, 'PR3', ['src/utils.ts'], 'pr/feat/2-pr2'),
+        ];
+        // Both a.ts (PR 1) and b.ts (PR 2) import utils.ts (PR 3)
+        const graph = new Map([
+            ['src/a.ts', new Set(['src/utils.ts'])],
+            ['src/b.ts', new Set(['src/utils.ts'])],
+            ['src/utils.ts', new Set()],
+        ]);
+        const result = autoFixPROrdering(prs, graph);
+        // utils.ts should move to PR 1 (earliest needer)
+        const pr1Files = result.pullRequests[0].files?.map((f) => f.path) ?? [];
+        assert.ok(pr1Files.includes('src/utils.ts'));
+    });
+    void it('handles no dependencies at all', () => {
+        const prs = [
+            makePR(1, 'PR1', ['src/a.ts']),
+            makePR(2, 'PR2', ['src/b.ts'], 'pr/feat/1-pr1'),
+        ];
+        const graph = new Map([
+            ['src/a.ts', new Set()],
+            ['src/b.ts', new Set()],
+        ]);
+        const result = autoFixPROrdering(prs, graph);
+        assert.strictEqual(result.movedFiles.length, 0);
+    });
+    void it('handles single PR with all files', () => {
+        const prs = [makePR(1, 'Everything', ['src/a.ts', 'src/b.ts', 'src/c.ts'])];
+        const graph = new Map([
+            ['src/a.ts', new Set(['src/b.ts'])],
+            ['src/b.ts', new Set(['src/c.ts'])],
+            ['src/c.ts', new Set()],
+        ]);
+        const result = autoFixPROrdering(prs, graph);
+        assert.strictEqual(result.movedFiles.length, 0);
+    });
+    void it('does not mutate original PR files arrays', () => {
+        const originalFiles = [{ path: 'src/app.ts', change_type: 'modified' }];
+        const prs = [
+            {
+                sequence: 1,
+                name: 'PR1',
+                description: 'PR1',
+                files: originalFiles,
+            },
+            {
+                sequence: 2,
+                name: 'PR2',
+                description: 'PR2',
+                files: [{ path: 'src/utils.ts', change_type: 'modified' }],
+            },
+        ];
+        const graph = new Map([
+            ['src/app.ts', new Set(['src/utils.ts'])],
+            ['src/utils.ts', new Set()],
+        ]);
+        autoFixPROrdering(prs, graph);
+        // Original files array should not be modified
+        assert.strictEqual(originalFiles.length, 1);
+        assert.strictEqual(originalFiles[0].path, 'src/app.ts');
+    });
+});

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

@@ -0,0 +1,67 @@
+/**
+ * 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

@@ -0,0 +1,236 @@
+/**
+ * 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();
+        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;
+/**
+ * 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++) {
+            const pr = sorted[prIdx];
+            for (const file of pr.files ?? []) {
+                const transitiveDeps = getTransitiveDependencies(file.path, dependencyGraph);
+                for (const dep of transitiveDeps) {
+                    const depPRIdx = fileToPRIndex.get(dep);
+                    if (depPRIdx === undefined || depPRIdx <= prIdx)
+                        continue;
+                    // Violation: dep is in a later PR but needed here
+                    const sourcePR = sorted[depPRIdx];
+                    const targetPR = sorted[prIdx];
+                    const depFileEntry = sourcePR.files?.find((f) => f.path === dep);
+                    if (!depFileEntry)
+                        continue;
+                    // Move from source to target
+                    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: `imported by ${file.path}`,
+                    });
+                    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.js

@@ -5,6 +5,7 @@ import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services
 import { clearPullRequests, createPullRequests, } from '../../services/pull-requests.js';
 import { logDebug, logError, logInfo } from '../../utils/logger.js';
 import { fetchPRSplittingContext } from './context.js';
+import { validateAndFixImportDependencies } from './import-dep-validator.js';
 import { buildErrorResult, buildNoChangeResult, buildSuccessResult, sortPRsByDependency, validatePlannedPRs, } from './outcome.js';
 import { createImprovementPrompt, createPRSplittingPromptWithContext, createPRSplittingSystemPrompt, formatContextForPrompt, formatExistingPRsForPrompt, } from './prompts.js';
 function userMessage(content) {
@@ -130,9 +131,12 @@ export const splitFeatureIntoPRs = async (options, config
             return buildErrorResult(featureId, `Invalid PR plan: ${validation.errors.join(', ')}`);
         }
         const sortedPRs = sortPRsByDependency(result.pullRequests);
+        // Validate and auto-fix import dependency ordering
+        const importFixResult = validateAndFixImportDependencies(sortedPRs, context.changedFiles, context.devBranchName, verbose);
+        const finalPRs = importFixResult.pullRequests;
         if (verbose) {
-            logInfo(`\n✅ ${sortedPRs.length} PRs planned:`);
-            sortedPRs.forEach((pr) => {
+            logInfo(`\n✅ ${finalPRs.length} PRs planned:`);
+            finalPRs.forEach((pr) => {
                 logInfo(`   ${pr.sequence}. ${pr.name} (${pr.branch_name})`);
                 if (pr.files) {
                     logInfo(`      Files: ${pr.files.map((f) => f.path).join(', ')}`);
@@ -149,7 +153,7 @@ export const splitFeatureIntoPRs = async (options, config
         // Save PR plan to database
         const prInputs = [];
         const prBranchNameToId = new Map();
-        for (const pr of sortedPRs) {
+        for (const pr of finalPRs) {
             let basePrId;
             if (pr.depends_on_branch_name) {
                 basePrId = prBranchNameToId.get(pr.depends_on_branch_name);
@@ -179,15 +183,16 @@ export const splitFeatureIntoPRs = async (options, config
             phase: 'pr_splitting',
             result: 'success',
             metadata: {
-                prs_planned: sortedPRs.length,
-                pr_names: sortedPRs.map((pr) => pr.name),
+                prs_planned: finalPRs.length,
+                pr_names: finalPRs.map((pr) => pr.name),
+                import_deps_fixed: importFixResult.movedFiles.length,
                 mode: isIncrementalUpdate ? 'incremental_update' : 'new_planning',
                 feedbacks_addressed: feedbacksContext?.feedbacks.length || 0,
                 timestamp: new Date().toISOString(),
             },
         }, verbose);
-        return buildSuccessResult(featureId, sortedPRs, result.summary ||
-            `Split feature into ${sortedPRs.length} pull requests for review`, result.rationale);
+        return buildSuccessResult(featureId, finalPRs, result.summary ||
+            `Split feature into ${finalPRs.length} pull requests for review`, result.rationale);
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);

package/dist/skills/phase/pr-execution/SKILL.md

@@ -21,6 +21,7 @@ You will receive a PR plan with file assignments. Each PR specifies a **base bra
 ## Stacked Branches
 
 PRs form a dependency chain (stacked PRs):
+
 - **First PR** (no dependency): branches from `main`
 - **Dependent PRs**: branch from the PR they depend on
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.39.2",
+  "version": "0.39.3",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"