edsger 0.39.2 → 0.40.0

package/dist/phases/pr-execution/__tests__/file-assigner.test.d.ts

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

package/dist/phases/pr-execution/__tests__/file-assigner.test.js

@@ -0,0 +1,294 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { applyAssignments, findUnassignedFiles, removeDeletedFilesFromPRs, } from '../file-assigner.js';
+function makePR(overrides) {
+    return {
+        feature_id: 'feat-1',
+        name: `PR ${overrides.sequence}`,
+        description: null,
+        branch_name: null,
+        base_pr_id: null,
+        pull_request_url: null,
+        pull_request_number: null,
+        compare_url: null,
+        status: 'pending',
+        last_synced_commit: null,
+        files: null,
+        created_by: 'user',
+        created_at: '2026-01-01',
+        updated_at: '2026-01-01',
+        ...overrides,
+    };
+}
+function cf(path, change_type = 'modified') {
+    return { path, change_type };
+}
+// ============================================================
+// findUnassignedFiles
+// ============================================================
+void describe('findUnassignedFiles', () => {
+    void it('returns all files when no PR has files', () => {
+        const prs = [makePR({ id: '1', sequence: 1, files: null })];
+        const result = findUnassignedFiles([cf('a.ts'), cf('b.ts')], prs);
+        assert.deepStrictEqual(result, [cf('a.ts'), cf('b.ts')]);
+    });
+    void it('returns empty when all files are assigned', () => {
+        const prs = [
+            makePR({
+                id: '1',
+                sequence: 1,
+                files: [
+                    { path: 'a.ts', change_type: 'modified' },
+                    { path: 'b.ts', change_type: 'added' },
+                ],
+            }),
+        ];
+        const result = findUnassignedFiles([cf('a.ts'), cf('b.ts', 'added')], prs);
+        assert.deepStrictEqual(result, []);
+    });
+    void it('returns only unassigned files', () => {
+        const prs = [
+            makePR({
+                id: '1',
+                sequence: 1,
+                files: [{ path: 'a.ts', change_type: 'modified' }],
+            }),
+            makePR({
+                id: '2',
+                sequence: 2,
+                files: [{ path: 'b.ts', change_type: 'added' }],
+            }),
+        ];
+        const result = findUnassignedFiles([cf('a.ts'), cf('b.ts'), cf('c.ts'), cf('d.ts', 'added')], prs);
+        assert.deepStrictEqual(result, [cf('c.ts'), cf('d.ts', 'added')]);
+    });
+    void it('handles PRs with empty files array', () => {
+        const prs = [
+            makePR({ id: '1', sequence: 1, files: [] }),
+            makePR({
+                id: '2',
+                sequence: 2,
+                files: [{ path: 'a.ts', change_type: 'modified' }],
+            }),
+        ];
+        const result = findUnassignedFiles([cf('a.ts'), cf('b.ts')], prs);
+        assert.deepStrictEqual(result, [cf('b.ts')]);
+    });
+    void it('returns empty for empty changed files', () => {
+        const prs = [
+            makePR({
+                id: '1',
+                sequence: 1,
+                files: [{ path: 'a.ts', change_type: 'modified' }],
+            }),
+        ];
+        const result = findUnassignedFiles([], prs);
+        assert.deepStrictEqual(result, []);
+    });
+    void it('handles files spread across multiple PRs', () => {
+        const prs = [
+            makePR({
+                id: '1',
+                sequence: 1,
+                files: [
+                    { path: 'src/auth/login.ts', change_type: 'modified' },
+                    { path: 'src/auth/session.ts', change_type: 'modified' },
+                ],
+            }),
+            makePR({
+                id: '2',
+                sequence: 2,
+                files: [
+                    { path: 'src/api/users.ts', change_type: 'added' },
+                    { path: 'src/api/roles.ts', change_type: 'added' },
+                ],
+            }),
+        ];
+        const changedFiles = [
+            cf('src/auth/login.ts'),
+            cf('src/auth/session.ts'),
+            cf('src/api/users.ts'),
+            cf('src/api/roles.ts'),
+            cf('src/auth/oauth.ts', 'added'),
+            cf('README.md'),
+        ];
+        const result = findUnassignedFiles(changedFiles, prs);
+        assert.deepStrictEqual(result, [
+            cf('src/auth/oauth.ts', 'added'),
+            cf('README.md'),
+        ]);
+    });
+});
+// ============================================================
+// applyAssignments
+// ============================================================
+void describe('applyAssignments', () => {
+    void it('merges new files into existing PR files', async () => {
+        const prs = [
+            makePR({
+                id: 'pr-1',
+                sequence: 1,
+                files: [{ path: 'a.ts', change_type: 'modified' }],
+            }),
+        ];
+        const unassigned = [cf('b.ts', 'added')];
+        const updates = [];
+        const mockUpdater = async (prId, u) => {
+            updates.push({ prId, files: u.files });
+        };
+        const count = await applyAssignments([{ file: 'b.ts', pr_id: 'pr-1' }], unassigned, prs, mockUpdater);
+        assert.strictEqual(count, 1);
+        assert.strictEqual(updates.length, 1);
+        assert.strictEqual(updates[0].prId, 'pr-1');
+        assert.deepStrictEqual(updates[0].files, [
+            { path: 'a.ts', change_type: 'modified' },
+            { path: 'b.ts', change_type: 'added' },
+        ]);
+    });
+    void it('deduplicates files already in PR', async () => {
+        const prs = [
+            makePR({
+                id: 'pr-1',
+                sequence: 1,
+                files: [{ path: 'a.ts', change_type: 'modified' }],
+            }),
+        ];
+        const unassigned = [cf('a.ts')];
+        const updates = [];
+        const mockUpdater = async (_prId, u) => {
+            updates.push({ files: u.files });
+        };
+        await applyAssignments([{ file: 'a.ts', pr_id: 'pr-1' }], unassigned, prs, mockUpdater);
+        // File list should not have duplicates
+        assert.deepStrictEqual(updates[0].files, [
+            { path: 'a.ts', change_type: 'modified' },
+        ]);
+    });
+    void it('skips unknown PR ids', async () => {
+        const prs = [makePR({ id: 'pr-1', sequence: 1, files: [] })];
+        const unassigned = [cf('x.ts', 'added')];
+        let called = false;
+        const mockUpdater = async () => {
+            called = true;
+        };
+        const count = await applyAssignments([{ file: 'x.ts', pr_id: 'unknown-id' }], unassigned, prs, mockUpdater);
+        assert.strictEqual(count, 0);
+        assert.strictEqual(called, false);
+    });
+    void it('uses change_type from git, not a hardcoded default', async () => {
+        const prs = [makePR({ id: 'pr-1', sequence: 1, files: [] })];
+        const unassigned = [cf('new.ts', 'added')];
+        const updates = [];
+        const mockUpdater = async (_prId, u) => {
+            updates.push({ files: u.files });
+        };
+        await applyAssignments([{ file: 'new.ts', pr_id: 'pr-1' }], unassigned, prs, mockUpdater);
+        assert.strictEqual(updates[0].files[0].change_type, 'added');
+    });
+    void it('distributes files to multiple PRs', async () => {
+        const prs = [
+            makePR({ id: 'pr-1', sequence: 1, files: [] }),
+            makePR({ id: 'pr-2', sequence: 2, files: [] }),
+        ];
+        const unassigned = [
+            cf('a.ts', 'added'),
+            cf('b.ts', 'modified'),
+        ];
+        const updates = [];
+        const mockUpdater = async (prId) => {
+            updates.push({ prId });
+        };
+        const count = await applyAssignments([
+            { file: 'a.ts', pr_id: 'pr-1' },
+            { file: 'b.ts', pr_id: 'pr-2' },
+        ], unassigned, prs, mockUpdater);
+        assert.strictEqual(count, 2);
+        assert.deepStrictEqual(updates.map((u) => u.prId), ['pr-1', 'pr-2']);
+    });
+    void it('handles updater failure gracefully', async () => {
+        const prs = [makePR({ id: 'pr-1', sequence: 1, files: [] })];
+        const unassigned = [cf('a.ts')];
+        const mockUpdater = async () => {
+            throw new Error('DB error');
+        };
+        const count = await applyAssignments([{ file: 'a.ts', pr_id: 'pr-1' }], unassigned, prs, mockUpdater);
+        assert.strictEqual(count, 0);
+    });
+});
+// ============================================================
+// removeDeletedFilesFromPRs
+// ============================================================
+void describe('removeDeletedFilesFromPRs', () => {
+    void it('removes deleted files from PR file lists', async () => {
+        const prs = [
+            makePR({
+                id: 'pr-1',
+                sequence: 1,
+                files: [
+                    { path: 'keep.ts', change_type: 'modified' },
+                    { path: 'gone.ts', change_type: 'added' },
+                ],
+            }),
+        ];
+        const changedFiles = [
+            cf('keep.ts'),
+            cf('gone.ts', 'deleted'),
+        ];
+        const updates = [];
+        const mockUpdater = async (prId, u) => {
+            updates.push({ prId, files: u.files });
+        };
+        const count = await removeDeletedFilesFromPRs(changedFiles, prs, mockUpdater);
+        assert.strictEqual(count, 1);
+        assert.deepStrictEqual(updates[0].files, [
+            { path: 'keep.ts', change_type: 'modified' },
+        ]);
+    });
+    void it('returns 0 when no files are deleted', async () => {
+        const prs = [
+            makePR({
+                id: 'pr-1',
+                sequence: 1,
+                files: [{ path: 'a.ts', change_type: 'modified' }],
+            }),
+        ];
+        let called = false;
+        const mockUpdater = async () => {
+            called = true;
+        };
+        const count = await removeDeletedFilesFromPRs([cf('a.ts')], prs, mockUpdater);
+        assert.strictEqual(count, 0);
+        assert.strictEqual(called, false);
+    });
+    void it('skips PRs with no matching deleted files', async () => {
+        const prs = [
+            makePR({
+                id: 'pr-1',
+                sequence: 1,
+                files: [{ path: 'a.ts', change_type: 'modified' }],
+            }),
+            makePR({
+                id: 'pr-2',
+                sequence: 2,
+                files: [{ path: 'b.ts', change_type: 'added' }],
+            }),
+        ];
+        const updates = [];
+        const mockUpdater = async (prId) => {
+            updates.push(prId);
+        };
+        await removeDeletedFilesFromPRs([cf('b.ts', 'deleted')], prs, mockUpdater);
+        // Only pr-2 should be updated
+        assert.deepStrictEqual(updates, ['pr-2']);
+    });
+    void it('handles PRs with null files', async () => {
+        const prs = [makePR({ id: 'pr-1', sequence: 1, files: null })];
+        let called = false;
+        const mockUpdater = async () => {
+            called = true;
+        };
+        const count = await removeDeletedFilesFromPRs([cf('a.ts', 'deleted')], prs, mockUpdater);
+        assert.strictEqual(count, 0);
+        assert.strictEqual(called, false);
+    });
+});

package/dist/phases/pr-execution/context.d.ts

@@ -8,6 +8,10 @@ export interface GitHubConfigInfo {
     repo?: string;
     message?: string;
 }
+export interface ChangedFileInfo {
+    path: string;
+    change_type: 'added' | 'modified' | 'deleted' | 'renamed';
+}
 export interface PRExecutionContext {
     feature: FeatureInfo;
     pullRequests: PullRequest[];
@@ -18,7 +22,7 @@ export interface PRExecutionContext {
     isIncrementalSync: boolean;
     lastSyncedCommit: string | null;
     diffStat: string;
-    changedFiles: string[];
+    changedFiles: ChangedFileInfo[];
 }
 /**
  * Fetch context for PR execution phase

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

@@ -32,22 +32,61 @@ function getDiffStat(baseRef, headRef) {
     }
 }
 /**
- * Get list of changed files between two refs
+ * Map git diff --name-status letter to a readable change type
+ */
+function parseGitStatus(status) {
+    switch (status[0]) {
+        case 'A':
+            return 'added';
+        case 'D':
+            return 'deleted';
+        case 'R':
+            return 'renamed';
+        default:
+            return 'modified';
+    }
+}
+/**
+ * Get list of changed files with their change types between two refs
  */
 function getChangedFiles(baseRef, headRef) {
     try {
-        const output = execSync(`git diff --name-only ${baseRef}...${headRef}`, {
+        const output = execSync(`git diff --name-status ${baseRef}...${headRef}`, {
             encoding: 'utf-8',
         }).trim();
         if (!output) {
             return [];
         }
-        return output.split('\n').filter((f) => f.length > 0);
+        return output
+            .split('\n')
+            .filter((line) => line.length > 0)
+            .map((line) => {
+            const [status, ...pathParts] = line.split('\t');
+            // For renames (R100\told\tnew), use the new path
+            const path = pathParts.length > 1 ? pathParts[1] : pathParts[0];
+            return { path, change_type: parseGitStatus(status) };
+        });
     }
     catch {
         return [];
     }
 }
+/**
+ * Check if a commit exists in the ancestry of a given ref.
+ * Returns false if the commit was orphaned (e.g. after a rebase).
+ */
+function isAncestor(commitSha, ref) {
+    try {
+        execSync(`git merge-base --is-ancestor ${commitSha} ${ref}`, {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Determine the common last_synced_commit from existing PRs
  * Returns null if any PR hasn't been synced yet (first run)
@@ -82,6 +121,27 @@ export async function fetchPRExecutionContext(featureId, verbose) {
             getPullRequests({ featureId, verbose }),
             getGitHubConfig(featureId, verbose),
         ]);
+        // Fetch latest remote refs and fast-forward local main
+        try {
+            const credArgs = buildCredentialArgs(githubConfig.token);
+            execFileSync('git', [...credArgs, 'fetch', 'origin'], {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+            execSync('git checkout main', { encoding: 'utf-8', stdio: 'pipe' });
+            execSync('git merge --ff-only origin/main', {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+            if (verbose) {
+                logInfo('✅ Local main synced with origin/main');
+            }
+        }
+        catch (error) {
+            if (verbose) {
+                logInfo(`⚠️  Could not sync main with origin: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
         // Verify dev branch exists
         const localExists = branchExists(devBranchName);
         const remoteExists = !localExists && remoteBranchExists(devBranchName, githubConfig.token);
@@ -95,10 +155,12 @@ export async function fetchPRExecutionContext(featureId, verbose) {
                 logInfo(`Fetching remote branch ${devBranchName}...`);
             }
             const credArgs = buildCredentialArgs(githubConfig.token);
-            execFileSync('git', [...credArgs, 'fetch', 'origin', devBranchName], {
-                encoding: 'utf-8',
-                stdio: 'pipe',
-            });
+            execFileSync('git', [
+                ...credArgs,
+                'fetch',
+                'origin',
+                `${devBranchName}:refs/remotes/origin/${devBranchName}`,
+            ], { encoding: 'utf-8', stdio: 'pipe' });
         }
         if (pullRequests.length === 0) {
             throw new Error('No PR plan found. Run the pr-splitting phase first to create a PR plan.');
@@ -126,8 +188,18 @@ export async function fetchPRExecutionContext(featureId, verbose) {
         // Determine sync mode
         const devRef = localExists ? devBranchName : `origin/${devBranchName}`;
         const devBranchHeadSha = getBranchHeadSha(devRef);
-        const lastSyncedCommit = getLastSyncedCommit(pullRequests);
-        const isIncrementalSync = lastSyncedCommit !== null;
+        let lastSyncedCommit = getLastSyncedCommit(pullRequests);
+        let isIncrementalSync = lastSyncedCommit !== null;
+        // If the branch was rebased, lastSyncedCommit is no longer in the history.
+        // Treat this as a full re-execution so downstream logic uses the correct
+        // prompt and skips incremental file-assignment against an invalid base.
+        if (isIncrementalSync && !isAncestor(lastSyncedCommit, devRef)) {
+            if (verbose) {
+                logInfo(`⚠️  Last synced commit ${lastSyncedCommit} is no longer in branch history (likely rebased). Treating as full re-execution.`);
+            }
+            lastSyncedCommit = null;
+            isIncrementalSync = false;
+        }
         // Get diff info: for incremental, diff from last sync; for first run, diff from main
         const diffBase = isIncrementalSync ? lastSyncedCommit : 'main';
         const diffStat = getDiffStat(diffBase, devRef);

package/dist/phases/pr-execution/file-assigner.d.ts

@@ -0,0 +1,45 @@
+/**
+ * File assignment for incremental sync.
+ *
+ * When new changes on the dev branch include files not covered by any
+ * existing PR's file list, this module asks an LLM to assign them to
+ * the most appropriate PR, then updates the PR records in the database.
+ */
+import { type PullRequest } from '../../services/pull-requests.js';
+import type { ChangedFileInfo } from './context.js';
+export interface FileAssignment {
+    file: string;
+    pr_id: string;
+}
+export interface FileAssignmentResult {
+    assignments: FileAssignment[];
+}
+/**
+ * Find changed files that are not covered by any PR's file list.
+ */
+export declare function findUnassignedFiles(changedFiles: ChangedFileInfo[], pullRequests: PullRequest[]): ChangedFileInfo[];
+/**
+ * Update PR records in the database with newly assigned files.
+ * Exported for testing via dependency injection of the updater function.
+ */
+export declare function applyAssignments(assignments: FileAssignment[], unassignedFiles: ChangedFileInfo[], pullRequests: PullRequest[], updater?: (prId: string, updates: {
+    files: {
+        path: string;
+        change_type: string;
+    }[];
+}, verbose?: boolean) => Promise<unknown>, verbose?: boolean): Promise<number>;
+/**
+ * Remove files that were deleted on the dev branch from PR file lists.
+ * Returns the number of PRs updated.
+ */
+export declare function removeDeletedFilesFromPRs(changedFiles: ChangedFileInfo[], pullRequests: PullRequest[], updater?: (prId: string, updates: {
+    files: {
+        path: string;
+        change_type: string;
+    }[];
+}, verbose?: boolean) => Promise<unknown>, verbose?: boolean): Promise<number>;
+/**
+ * Detect unassigned files and use LLM to assign them to existing PRs.
+ * Returns the number of files assigned, or 0 if none needed assignment.
+ */
+export declare function assignNewFilesToPRs(changedFiles: ChangedFileInfo[], pullRequests: PullRequest[], verbose?: boolean): Promise<number>;