edsger 0.45.1 → 0.47.0

package/dist/phases/smoke-test/__tests__/agent.test.js

@@ -0,0 +1,84 @@
+/**
+ * Unit tests for smoke-test agent response parsing.
+ */
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { extractJson, findBalancedJsonObject } from '../agent.js';
+void describe('extractJson', () => {
+    void it('parses a plain JSON object', () => {
+        const raw = `{
+      "summary": "one thing changed",
+      "test_cases": [
+        { "name": "login still works", "description": "step 1", "is_critical": true }
+      ]
+    }`;
+        const parsed = extractJson(raw);
+        assert.strictEqual(parsed.summary, 'one thing changed');
+        assert.strictEqual(parsed.test_cases.length, 1);
+        assert.strictEqual(parsed.test_cases[0].is_critical, true);
+    });
+    void it('strips ```json fences', () => {
+        const raw = '```json\n{"summary":"x","test_cases":[{"name":"a","description":"b"}]}\n```';
+        const parsed = extractJson(raw);
+        assert.strictEqual(parsed.summary, 'x');
+        assert.strictEqual(parsed.test_cases[0].name, 'a');
+    });
+    void it('strips unlabeled fences', () => {
+        const raw = '```\n{"summary":"x","test_cases":[]}\n```';
+        const parsed = extractJson(raw);
+        assert.deepStrictEqual(parsed.test_cases, []);
+    });
+    void it('tolerates leading and trailing prose', () => {
+        const raw = `Here you go:
+{"summary":"x","test_cases":[{"name":"a","description":"b"}]}
+
+Hope that helps.`;
+        const parsed = extractJson(raw);
+        assert.strictEqual(parsed.summary, 'x');
+    });
+    void it('throws when test_cases is missing', () => {
+        assert.throws(() => extractJson('{"summary":"x"}'), /test_cases/);
+    });
+    void it('throws on invalid JSON', () => {
+        assert.throws(() => extractJson('not json'));
+    });
+    void it('picks the first balanced object when prose contains decoy braces', () => {
+        const raw = 'Note: { pseudo-json example } but the real answer is:\n' +
+            '{"summary":"x","test_cases":[{"name":"a","description":"b"}]}\n' +
+            'Let me know if you want changes.';
+        const parsed = extractJson(raw);
+        assert.strictEqual(parsed.summary, 'x');
+        assert.strictEqual(parsed.test_cases[0].name, 'a');
+    });
+    void it('preserves braces inside JSON string values', () => {
+        const raw = '{"summary":"changes to {pricing} and {checkout}","test_cases":[{"name":"n","description":"d"}]}';
+        const parsed = extractJson(raw);
+        assert.strictEqual(parsed.summary, 'changes to {pricing} and {checkout}');
+    });
+    void it('throws when test_cases is not an array', () => {
+        assert.throws(() => extractJson('{"summary":"x","test_cases":"nope"}'), /test_cases/);
+    });
+});
+void describe('findBalancedJsonObject', () => {
+    void it('returns null when there is no opening brace', () => {
+        assert.strictEqual(findBalancedJsonObject('no braces here'), null);
+    });
+    void it('returns the first balanced top-level object', () => {
+        assert.strictEqual(findBalancedJsonObject('prefix {"a": 1} and {"b": 2} suffix'), '{"a": 1}');
+    });
+    void it('handles nested braces', () => {
+        const text = 'xxx {"a": {"b": {"c": 1}}} yyy';
+        assert.strictEqual(findBalancedJsonObject(text), '{"a": {"b": {"c": 1}}}');
+    });
+    void it('ignores braces inside strings', () => {
+        const text = '{"msg": "this has { and } inside", "ok": true}';
+        assert.strictEqual(findBalancedJsonObject(text), text);
+    });
+    void it('handles escaped quotes inside strings', () => {
+        const text = '{"msg": "she said \\"hi\\" {not object}"}';
+        assert.strictEqual(findBalancedJsonObject(text), text);
+    });
+    void it('returns null on unbalanced input', () => {
+        assert.strictEqual(findBalancedJsonObject('{"a": 1'), null);
+    });
+});

package/dist/phases/smoke-test/__tests__/github.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Unit tests for smoke-test github helpers.
+ *
+ * Covers the pure functions that shape GitHub compare data into a
+ * prompt-ready digest. Network-facing functions (fetchLatestTwoReleases,
+ * fetchCompare) are exercised only indirectly — their output shape is
+ * fed through buildDiffDigest / summariseStats here.
+ */
+export {};

package/dist/phases/smoke-test/__tests__/github.test.js

@@ -0,0 +1,120 @@
+/**
+ * Unit tests for smoke-test github helpers.
+ *
+ * Covers the pure functions that shape GitHub compare data into a
+ * prompt-ready digest. Network-facing functions (fetchLatestTwoReleases,
+ * fetchCompare) are exercised only indirectly — their output shape is
+ * fed through buildDiffDigest / summariseStats here.
+ */
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { buildDiffDigest, summariseStats, } from '../github.js';
+function makeCompare(over = {}) {
+    return {
+        total_commits: 2,
+        commits: [
+            {
+                sha: '1111111aaaaaaaa',
+                commit: { message: 'feat: add checkout flow\n\nmore body', author: null },
+            },
+            {
+                sha: '2222222bbbbbbbb',
+                commit: { message: 'fix: null deref', author: { name: 'Ada' } },
+            },
+        ],
+        files: [
+            {
+                filename: 'src/checkout.ts',
+                status: 'modified',
+                additions: 10,
+                deletions: 2,
+                changes: 12,
+                patch: '@@ -1 +1 @@\n-old\n+new',
+            },
+            {
+                filename: 'src/util.ts',
+                status: 'added',
+                additions: 5,
+                deletions: 0,
+                changes: 5,
+            },
+        ],
+        ...over,
+    };
+}
+void describe('summariseStats', () => {
+    void it('sums additions, deletions, and file count', () => {
+        const stats = summariseStats(makeCompare());
+        assert.deepStrictEqual(stats, {
+            files_changed: 2,
+            additions: 15,
+            deletions: 2,
+            total_commits: 2,
+        });
+    });
+    void it('handles an empty diff', () => {
+        const stats = summariseStats({
+            total_commits: 0,
+            commits: [],
+            files: [],
+        });
+        assert.deepStrictEqual(stats, {
+            files_changed: 0,
+            additions: 0,
+            deletions: 0,
+            total_commits: 0,
+        });
+    });
+});
+void describe('buildDiffDigest', () => {
+    void it('includes commit subjects, file list, and patches', () => {
+        const digest = buildDiffDigest(makeCompare());
+        assert.match(digest, /Total commits: 2/);
+        assert.match(digest, /1111111 feat: add checkout flow/);
+        assert.match(digest, /2222222 fix: null deref/);
+        assert.match(digest, /modified src\/checkout\.ts \(\+10\/-2\)/);
+        assert.match(digest, /added src\/util\.ts \(\+5\/-0\)/);
+        assert.match(digest, /--- src\/checkout\.ts ---/);
+        assert.match(digest, /\+new/);
+    });
+    void it('truncates only the subject line of multi-line commit messages', () => {
+        const digest = buildDiffDigest(makeCompare());
+        // "more body" from the first commit's message body must not leak in.
+        assert.ok(!digest.includes('more body'));
+    });
+    void it('caps the patch budget and appends a truncation marker', () => {
+        const huge = 'x'.repeat(200_000);
+        const compare = makeCompare({
+            files: [
+                {
+                    filename: 'src/big.ts',
+                    status: 'modified',
+                    additions: 1,
+                    deletions: 0,
+                    changes: 1,
+                    patch: huge,
+                },
+            ],
+        });
+        const digest = buildDiffDigest(compare);
+        assert.match(digest, /\[truncated\]/);
+        // Even with a 200k patch, digest stays bounded by the internal budget.
+        assert.ok(digest.length < 200_000);
+    });
+    void it('skips files without patches in the patches section', () => {
+        const compare = makeCompare({
+            files: [
+                {
+                    filename: 'vendored.min.js',
+                    status: 'added',
+                    additions: 1,
+                    deletions: 0,
+                    changes: 1,
+                },
+            ],
+        });
+        const digest = buildDiffDigest(compare);
+        assert.ok(digest.includes('== Patches (truncated) =='));
+        assert.ok(!digest.includes('--- vendored.min.js ---'));
+    });
+});

package/dist/phases/smoke-test/__tests__/snapshot.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Unit tests for snapshot-detection pure helpers.
+ *
+ * The network / SDK path (`detectSnapshotVersion`) is not covered here
+ * — it's exercised end-to-end when the CLI runs — but the parser and
+ * the plausibility check are critical and easy to cover.
+ */
+export {};

package/dist/phases/smoke-test/__tests__/snapshot.test.js

@@ -0,0 +1,93 @@
+/**
+ * Unit tests for snapshot-detection pure helpers.
+ *
+ * The network / SDK path (`detectSnapshotVersion`) is not covered here
+ * — it's exercised end-to-end when the CLI runs — but the parser and
+ * the plausibility check are critical and easy to cover.
+ */
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { buildSnapshotDetectionPrompt, isPlausibleSnapshotTag, parseSnapshotDetection, } from '../snapshot.js';
+void describe('parseSnapshotDetection', () => {
+    void it('parses a clean JSON object', () => {
+        const raw = '{"snapshot_tag":"v2.0.0","source":"package.json","reasoning":"next ver"}';
+        const parsed = parseSnapshotDetection(raw);
+        assert.strictEqual(parsed.snapshot_tag, 'v2.0.0');
+        assert.strictEqual(parsed.source, 'package.json');
+        assert.match(parsed.reasoning, /next ver/);
+    });
+    void it('strips ```json fences', () => {
+        const raw = '```json\n{"snapshot_tag":"v1.0.1","source":"VERSION","reasoning":"x"}\n```';
+        const parsed = parseSnapshotDetection(raw);
+        assert.strictEqual(parsed.snapshot_tag, 'v1.0.1');
+    });
+    void it('tolerates leading and trailing prose', () => {
+        const raw = `I checked package.json:
+{"snapshot_tag":"v3.0.0","source":"package.json","reasoning":"bumped"}
+Done.`;
+        const parsed = parseSnapshotDetection(raw);
+        assert.strictEqual(parsed.snapshot_tag, 'v3.0.0');
+    });
+    void it('returns null snapshot_tag when model reports no snapshot', () => {
+        const raw = '{"snapshot_tag": null, "source": null, "reasoning": "version matches latest release"}';
+        const parsed = parseSnapshotDetection(raw);
+        assert.strictEqual(parsed.snapshot_tag, null);
+        assert.strictEqual(parsed.source, null);
+    });
+    void it('treats empty string snapshot_tag as null', () => {
+        const raw = '{"snapshot_tag":"","source":null,"reasoning":"nothing found"}';
+        const parsed = parseSnapshotDetection(raw);
+        assert.strictEqual(parsed.snapshot_tag, null);
+    });
+    void it('falls back to balanced-brace extraction for surrounding prose', () => {
+        const raw = 'Analysis: { could be v1 } — but the real answer is ' +
+            '{"snapshot_tag":"v1.2.0","source":"CHANGELOG","reasoning":"unreleased section present"}';
+        const parsed = parseSnapshotDetection(raw);
+        assert.strictEqual(parsed.snapshot_tag, 'v1.2.0');
+        assert.strictEqual(parsed.source, 'CHANGELOG');
+    });
+    void it('throws when no JSON object is present', () => {
+        assert.throws(() => parseSnapshotDetection('no json at all'), /JSON/);
+    });
+    void it('supplies default reasoning when missing', () => {
+        const raw = '{"snapshot_tag":"v1","source":"package.json"}';
+        const parsed = parseSnapshotDetection(raw);
+        assert.strictEqual(parsed.snapshot_tag, 'v1');
+        assert.strictEqual(parsed.reasoning, '(no reasoning given)');
+    });
+});
+void describe('isPlausibleSnapshotTag', () => {
+    void it('accepts normal version tags', () => {
+        assert.strictEqual(isPlausibleSnapshotTag('v2.0.0', 'v1.9.0'), true);
+        assert.strictEqual(isPlausibleSnapshotTag('2.0.0-rc.1', '1.9.0'), true);
+        assert.strictEqual(isPlausibleSnapshotTag('v1.2.3-SNAPSHOT', 'v1.2.2'), true);
+        assert.strictEqual(isPlausibleSnapshotTag('release/2.0', 'release/1.9'), true);
+    });
+    void it('rejects tags identical to the latest release', () => {
+        assert.strictEqual(isPlausibleSnapshotTag('v1.0.0', 'v1.0.0'), false);
+    });
+    void it('rejects empty or overlong tags', () => {
+        assert.strictEqual(isPlausibleSnapshotTag('', 'v1'), false);
+        assert.strictEqual(isPlausibleSnapshotTag('x'.repeat(101), 'v1'), false);
+    });
+    void it('rejects whitespace and shell metacharacters', () => {
+        assert.strictEqual(isPlausibleSnapshotTag('v 2', 'v1'), false);
+        assert.strictEqual(isPlausibleSnapshotTag('v2;rm -rf', 'v1'), false);
+        assert.strictEqual(isPlausibleSnapshotTag('v2$PATH', 'v1'), false);
+    });
+    void it('rejects leading dot or dash, double dot, @{ reflog', () => {
+        assert.strictEqual(isPlausibleSnapshotTag('.v2', 'v1'), false);
+        assert.strictEqual(isPlausibleSnapshotTag('-v2', 'v1'), false);
+        assert.strictEqual(isPlausibleSnapshotTag('v2..rc', 'v1'), false);
+        assert.strictEqual(isPlausibleSnapshotTag('v2@{1}', 'v1'), false);
+    });
+});
+void describe('buildSnapshotDetectionPrompt', () => {
+    void it('injects the latest release tag into the prompt', () => {
+        const prompt = buildSnapshotDetectionPrompt('v1.4.2');
+        assert.match(prompt, /v1\.4\.2/);
+        // Must ask for JSON output
+        assert.match(prompt, /JSON/);
+        assert.match(prompt, /snapshot_tag/);
+    });
+});

package/dist/phases/smoke-test/agent.js

@@ -66,11 +66,9 @@ export async function executeSmokeTestQuery(systemPrompt, userPrompt, config, ve
                     lastAssistant += `${content.text}\n`;
                     logDebug(content.text, verbose);
                 }
-                else if (content.type === 'tool_use') {
+                else if (content.type === 'tool_use' && verbose) {
                     const desc = content.input?.description || content.input?.command || 'Running...';
-                    if (verbose) {
-                        logInfo(`[Turn ${turnCount}] ${content.name}: ${typeof desc === 'string' ? desc.slice(0, 120) : 'Running...'}`);
-                    }
+                    logInfo(`[Turn ${turnCount}] ${content.name}: ${typeof desc === 'string' ? desc.slice(0, 120) : 'Running...'}`);
                 }
             }
         }

package/dist/phases/smoke-test/github.d.ts

@@ -0,0 +1,54 @@
+/**
+ * GitHub release helpers for smoke-test generation, implemented on top of
+ * @octokit/rest so we share retry / rate-limit / User-Agent behavior with the
+ * rest of the packages/edsger codebase.
+ */
+export interface GithubRelease {
+    id: number;
+    tag_name: string;
+    name: string | null;
+    body: string | null;
+    html_url: string;
+    published_at: string | null;
+    draft: boolean;
+    prerelease: boolean;
+}
+export interface CompareFile {
+    filename: string;
+    status: string;
+    additions: number;
+    deletions: number;
+    changes: number;
+    patch?: string;
+}
+export interface CompareCommit {
+    sha: string;
+    commit: {
+        message: string;
+        author?: {
+            name?: string;
+        } | null;
+    };
+}
+export interface CompareResponse {
+    total_commits: number;
+    files: CompareFile[];
+    commits: CompareCommit[];
+}
+export interface ReleasePair {
+    latest: GithubRelease;
+    previous: GithubRelease | null;
+}
+export declare function fetchLatestTwoReleases(owner: string, repo: string, token: string): Promise<ReleasePair>;
+export declare function getDefaultBranchHead(owner: string, repo: string, token: string): Promise<{
+    branch: string;
+    sha: string;
+}>;
+export declare function fetchCompare(owner: string, repo: string, base: string, head: string, token: string): Promise<CompareResponse>;
+export declare function buildDiffDigest(compare: CompareResponse): string;
+export declare function summariseStats(compare: CompareResponse): {
+    files_changed: number;
+    additions: number;
+    deletions: number;
+    total_commits: number;
+};

package/dist/phases/smoke-test/github.js

@@ -0,0 +1,101 @@
+/**
+ * GitHub release helpers for smoke-test generation, implemented on top of
+ * @octokit/rest so we share retry / rate-limit / User-Agent behavior with the
+ * rest of the packages/edsger codebase.
+ */
+import { Octokit } from '@octokit/rest';
+const MAX_PATCH_CHARS = 60_000;
+const MAX_COMMITS_INCLUDED = 40;
+function octokit(token) {
+    return new Octokit({ auth: token, userAgent: 'edsger-cli' });
+}
+export async function fetchLatestTwoReleases(owner, repo, token) {
+    const gh = octokit(token);
+    const { data } = await gh.repos.listReleases({ owner, repo, per_page: 10 });
+    const real = data.filter((r) => !r.draft);
+    if (real.length === 0) {
+        throw new Error(`Repository ${owner}/${repo} has no releases yet. Publish one first.`);
+    }
+    return { latest: real[0], previous: real[1] ?? null };
+}
+export async function getDefaultBranchHead(owner, repo, token) {
+    const gh = octokit(token);
+    const { data: repoInfo } = await gh.repos.get({ owner, repo });
+    const branch = repoInfo.default_branch;
+    const { data: branchInfo } = await gh.repos.getBranch({
+        owner,
+        repo,
+        branch,
+    });
+    return { branch, sha: branchInfo.commit.sha };
+}
+export async function fetchCompare(owner, repo, base, head, token) {
+    const gh = octokit(token);
+    const { data } = await gh.repos.compareCommits({
+        owner,
+        repo,
+        base,
+        head,
+    });
+    // Octokit returns a richer shape; narrow to the subset we consume.
+    return {
+        total_commits: data.total_commits ?? 0,
+        files: (data.files ?? []).map((f) => ({
+            filename: f.filename,
+            status: f.status,
+            additions: f.additions ?? 0,
+            deletions: f.deletions ?? 0,
+            changes: f.changes ?? 0,
+            patch: f.patch,
+        })),
+        commits: (data.commits ?? []).map((c) => ({
+            sha: c.sha,
+            commit: {
+                message: c.commit?.message ?? '',
+                author: c.commit?.author
+                    ? { name: c.commit.author.name ?? undefined }
+                    : null,
+            },
+        })),
+    };
+}
+export function buildDiffDigest(compare) {
+    const lines = [];
+    lines.push(`Total commits: ${compare.total_commits}`);
+    lines.push('\n== Commits ==');
+    for (const c of compare.commits.slice(0, MAX_COMMITS_INCLUDED)) {
+        const subject = (c.commit.message || '').split('\n')[0].slice(0, 200);
+        lines.push(`- ${c.sha.slice(0, 7)} ${subject}`);
+    }
+    lines.push('\n== Files ==');
+    for (const f of compare.files) {
+        lines.push(`- ${f.status} ${f.filename} (+${f.additions}/-${f.deletions})`);
+    }
+    lines.push('\n== Patches (truncated) ==');
+    let budget = MAX_PATCH_CHARS;
+    for (const f of compare.files) {
+        if (budget <= 0 || !f.patch) {
+            continue;
+        }
+        const header = `\n--- ${f.filename} ---\n`;
+        const piece = header + f.patch;
+        if (piece.length > budget) {
+            lines.push(piece.slice(0, budget));
+            lines.push('\n...[truncated]');
+            budget = 0;
+        }
+        else {
+            lines.push(piece);
+            budget -= piece.length;
+        }
+    }
+    return lines.join('\n');
+}
+export function summariseStats(compare) {
+    return {
+        files_changed: compare.files.length,
+        additions: compare.files.reduce((s, f) => s + f.additions, 0),
+        deletions: compare.files.reduce((s, f) => s + f.deletions, 0),
+        total_commits: compare.total_commits,
+    };
+}

package/dist/phases/smoke-test/index.js

@@ -17,7 +17,15 @@ import { buildSmokeTestUserPrompt, createSmokeTestSystemPrompt, } from './prompt
 function isSnapshotRelease(release) {
     return !release.published_at && !release.url;
 }
-// eslint-disable-next-line complexity -- orchestration spans GitHub + DB + AI
+function describeReleaseContext(release, isSnapshot) {
+    if (isSnapshot) {
+        return ` (snapshot ahead of ${release.previous_tag ?? 'first release'})`;
+    }
+    if (release.previous_tag) {
+        return ` (vs ${release.previous_tag})`;
+    }
+    return ' (first release)';
+}
 export async function runSmokeTest(options, config) {
     const { releaseId, verbose } = options;
     if (verbose) {
@@ -216,11 +224,8 @@ async function runSmokeTestInner(ctx) {
         diff_stats: diffStats,
         generation_error: null,
     }, verbose);
-    logSuccess(`Generated ${casesCount} smoke-test cases for ${release.tag}${isSnapshot
-        ? ` (snapshot ahead of ${release.previous_tag ?? 'first release'})`
-        : release.previous_tag
-            ? ` (vs ${release.previous_tag})`
-            : ' (first release)'}`);
+    const suffix = describeReleaseContext(release, isSnapshot);
+    logSuccess(`Generated ${casesCount} smoke-test cases for ${release.tag}${suffix}`);
     return {
         status: 'success',
         releaseId: release.id,

package/dist/phases/smoke-test/snapshot.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Snapshot detection: after the latest GitHub release already has a
+ * smoke-test plan, inspect the cloned repo for a yet-to-be-released
+ * "snapshot" version (next package.json version, an [Unreleased] entry
+ * in CHANGELOG, an unreleased git tag, etc.) so we can prepare the
+ * next smoke test before anyone cuts the tag on GitHub.
+ */
+import { type EdsgerConfig } from '../../types/index.js';
+export interface SnapshotDetection {
+    snapshot_tag: string | null;
+    source: string | null;
+    reasoning: string;
+}
+export declare function buildSnapshotDetectionPrompt(latestReleaseTag: string): string;
+export declare function parseSnapshotDetection(raw: string): SnapshotDetection;
+/**
+ * Very loose sanity check on a proposed snapshot tag. We reject tags
+ * that are obviously the same as the latest release or that contain
+ * characters that would break downstream git / GitHub API calls.
+ */
+export declare function isPlausibleSnapshotTag(candidate: string, latestReleaseTag: string): boolean;
+export declare function detectSnapshotVersion(options: {
+    cwd: string;
+    latestReleaseTag: string;
+    config: EdsgerConfig;
+    verbose?: boolean;
+}): Promise<SnapshotDetection>;