edsger 0.45.1 → 0.47.0

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/index.js

@@ -27,9 +27,8 @@ async function* prompt(analysisPrompt) {
  * then uses AI to produce a PR split plan saved to the database.
  * Human review is expected before running the pr-execution phase.
  */
-export const splitFeatureIntoPRs = async (options, config
 // eslint-disable-next-line complexity
-) => {
+export const splitFeatureIntoPRs = async (options, config) => {
     const { featureId, verbose, replaceExisting } = options;
     if (verbose) {
         logInfo(`Starting PR splitting for feature ID: ${featureId}`);

package/dist/phases/release-sync/github.d.ts

@@ -23,6 +23,7 @@ export interface CompareFile {
 }
 export interface CompareCommit {
     sha: string;
+    html_url?: string;
     commit: {
         message: string;
         author?: {
@@ -45,6 +46,17 @@ export declare function getDefaultBranchHead(owner: string, repo: string, token:
     sha: string;
 }>;
 export declare function fetchCompare(owner: string, repo: string, base: string, head: string, token: string): Promise<CompareResponse>;
+/**
+ * Paginated commit list for base...head. Unlike `fetchCompare` (single
+ * page, capped at ~250 by GitHub), this loops pages until exhausted or
+ * the caller-specified cap is hit. We don't need file patches here —
+ * run-sheet just wants the commit list — so we ignore `data.files`.
+ */
+export declare function fetchAllCompareCommits(owner: string, repo: string, base: string, head: string, token: string, maxPages?: number): Promise<{
+    commits: CompareCommit[];
+    truncated: boolean;
+    totalCommits: number;
+}>;
 export declare function buildDiffDigest(compare: CompareResponse): string;
 export declare function summariseStats(compare: CompareResponse): {
     files_changed: number;

package/dist/phases/release-sync/github.js

@@ -50,6 +50,7 @@ export async function fetchCompare(owner, repo, base, head, token) {
         })),
         commits: (data.commits ?? []).map((c) => ({
             sha: c.sha,
+            html_url: c.html_url ?? undefined,
             commit: {
                 message: c.commit?.message ?? '',
                 author: c.commit?.author
@@ -59,6 +60,44 @@ export async function fetchCompare(owner, repo, base, head, token) {
         })),
     };
 }
+/**
+ * Paginated commit list for base...head. Unlike `fetchCompare` (single
+ * page, capped at ~250 by GitHub), this loops pages until exhausted or
+ * the caller-specified cap is hit. We don't need file patches here —
+ * run-sheet just wants the commit list — so we ignore `data.files`.
+ */
+export async function fetchAllCompareCommits(owner, repo, base, head, token, maxPages = 8) {
+    const gh = octokit(token);
+    const perPage = 100;
+    const out = [];
+    let totalCommits = 0;
+    for (let page = 1; page <= maxPages; page++) {
+        const { data } = await gh.repos.compareCommits({
+            owner,
+            repo,
+            base,
+            head,
+            per_page: perPage,
+            page,
+        });
+        totalCommits = data.total_commits ?? totalCommits;
+        const batch = (data.commits ?? []).map((c) => ({
+            sha: c.sha,
+            html_url: c.html_url ?? undefined,
+            commit: {
+                message: c.commit?.message ?? '',
+                author: c.commit?.author
+                    ? { name: c.commit.author.name ?? undefined }
+                    : null,
+            },
+        }));
+        out.push(...batch);
+        if (batch.length < perPage) {
+            return { commits: out, truncated: false, totalCommits };
+        }
+    }
+    return { commits: out, truncated: out.length < totalCommits, totalCommits };
+}
 export function buildDiffDigest(compare) {
     const lines = [];
     lines.push(`Total commits: ${compare.total_commits}`);

package/dist/phases/release-sync/snapshot.js

@@ -96,7 +96,6 @@ function userMessage(content) {
 async function* makePrompt(text) {
     yield userMessage(text);
 }
-// eslint-disable-next-line complexity -- agent loop with message-type handling
 export async function detectSnapshotVersion(options) {
     const { cwd, latestReleaseTag, verbose } = options;
     if (verbose) {

package/dist/phases/run-sheet/index.d.ts

@@ -23,7 +23,9 @@ export interface RunSheetResult {
     runSheetId?: string;
     missingPlaceholders?: string[];
     cloneError?: string | null;
+    commitsError?: string | null;
     commitsTruncated?: boolean;
+    isDraft?: boolean;
 }
 /**
  * Atomic-create a `.lock` file alongside the workspace dir. Returns
@@ -36,4 +38,17 @@ export interface RunSheetResult {
 export declare function tryAcquireFileLock(lockPath: string): boolean;
 /** Exported for unit tests; not part of the public CLI surface. */
 export declare function releaseFileLock(lockPath: string): void;
+/**
+ * Delete `run-sheet-*` workspaces that are both:
+ *   - not currently locked (lock file missing or stale), AND
+ *   - older than WORKSPACE_MAX_AGE_MS by mtime.
+ *
+ * Best-effort: any error on a single entry is logged and skipped so a
+ * corrupt dir doesn't block the current generation.
+ *
+ * Exported for unit tests.
+ */
+export declare function pruneStaleRunSheetWorkspaces(workspaceRoot: string, now?: number, maxAgeMs?: number): {
+    removed: string[];
+};
 export declare function runRunSheet(options: RunSheetOptions): Promise<RunSheetResult>;