edsger 0.43.0 → 0.45.0

package/dist/phases/release-sync/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/release-sync/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/release-sync/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Release sync: reconcile the `releases` table with GitHub releases for a
+ * product. Writes a `pending` row for each release we discover (latest +
+ * previous + any unreleased snapshot version). Does NOT generate smoke-test
+ * cases — that is handled per-release by `phases/smoke-test` once the user
+ * opts in from the release detail page.
+ */
+import { type EdsgerConfig } from '../../types/index.js';
+export interface ReleaseSyncOptions {
+    productId: string;
+    verbose?: boolean;
+}
+export interface ReleaseSyncResult {
+    status: 'success' | 'error';
+    productId: string;
+    summary: string;
+    /** Releases that were created or updated during this sync. */
+    syncedReleases?: {
+        id: string;
+        tag: string;
+        isSnapshot: boolean;
+    }[];
+}
+export declare function runReleaseSync(options: ReleaseSyncOptions, _config: EdsgerConfig): Promise<ReleaseSyncResult>;

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

@@ -0,0 +1,147 @@
+/**
+ * Release sync: reconcile the `releases` table with GitHub releases for a
+ * product. Writes a `pending` row for each release we discover (latest +
+ * previous + any unreleased snapshot version). Does NOT generate smoke-test
+ * cases — that is handled per-release by `phases/smoke-test` once the user
+ * opts in from the release detail page.
+ */
+import { getGitHubConfigByProduct } from '../../api/github.js';
+import { getReleaseByTag, upsertRelease, } from '../../api/releases.js';
+import { logInfo, logSuccess, logWarning } from '../../utils/logger.js';
+import { cloneFeatureRepo, ensureWorkspaceDir, syncRepoToRef, } from '../../workspace/workspace-manager.js';
+import { fetchLatestTwoReleases, getDefaultBranchHead, } from './github.js';
+import { detectSnapshotVersion, isPlausibleSnapshotTag } from './snapshot.js';
+/**
+ * Upsert a release row as `pending` only when it doesn't already exist.
+ * Preserves `ready` / `failed` / `generating` status on existing rows so
+ * repeated syncs don't clobber smoke-test progress.
+ */
+async function ensureReleaseRow(args, verbose) {
+    const existing = await getReleaseByTag(args.productId, args.tag, verbose);
+    if (existing) {
+        return { release: existing, created: false };
+    }
+    const release = await upsertRelease({
+        product_id: args.productId,
+        tag: args.tag,
+        name: args.githubRelease?.name ?? null,
+        body: args.githubRelease?.body ?? null,
+        url: args.githubRelease?.html_url ?? null,
+        published_at: args.githubRelease?.published_at ?? null,
+        previous_tag: args.previousTag,
+        previous_published_at: args.previousPublishedAt,
+        status: 'pending',
+    }, verbose);
+    return { release, created: true };
+}
+// eslint-disable-next-line complexity -- orchestration across GitHub + DB + snapshot
+export async function runReleaseSync(options, _config) {
+    const { productId, verbose } = options;
+    if (verbose) {
+        logInfo(`Starting release sync for product: ${productId}`);
+    }
+    const gh = await getGitHubConfigByProduct(productId, verbose);
+    if (!gh.configured || !gh.token || !gh.owner || !gh.repo) {
+        return {
+            status: 'error',
+            productId,
+            summary: gh.message ||
+                'Product is not connected to a GitHub repository. Connect it in Product Settings.',
+        };
+    }
+    const releases = await fetchLatestTwoReleases(gh.owner, gh.repo, gh.token);
+    const { latest, previous } = releases;
+    if (verbose) {
+        logInfo(`Latest GitHub release: ${latest.tag_name}, previous: ${previous?.tag_name ?? '(none)'}`);
+    }
+    const synced = [];
+    // Always reflect the latest GitHub release.
+    const latestRow = await ensureReleaseRow({
+        productId,
+        tag: latest.tag_name,
+        previousTag: previous?.tag_name ?? null,
+        previousPublishedAt: previous?.published_at ?? null,
+        githubRelease: latest,
+    }, verbose);
+    synced.push({
+        id: latestRow.release.id,
+        tag: latestRow.release.tag,
+        isSnapshot: false,
+    });
+    if (latestRow.created) {
+        logInfo(`Synced release ${latest.tag_name}`);
+    }
+    // Reflect the previous GitHub release so the UI can show history, even
+    // if smoke-test was never run against it.
+    if (previous) {
+        const previousRow = await ensureReleaseRow({
+            productId,
+            tag: previous.tag_name,
+            previousTag: null,
+            previousPublishedAt: null,
+            githubRelease: previous,
+        }, verbose);
+        synced.push({
+            id: previousRow.release.id,
+            tag: previousRow.release.tag,
+            isSnapshot: false,
+        });
+        if (previousRow.created) {
+            logInfo(`Synced release ${previous.tag_name}`);
+        }
+    }
+    // Snapshot detection: clone the repo at the default branch tip and ask
+    // the agent whether there's an unreleased version ahead of `latest`.
+    let cwd;
+    try {
+        const workspaceRoot = ensureWorkspaceDir();
+        const { repoPath } = cloneFeatureRepo(workspaceRoot, `release-sync-${productId}`, gh.owner, gh.repo, gh.token);
+        cwd = repoPath;
+    }
+    catch (err) {
+        logWarning(`Could not clone repo for snapshot detection: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (cwd) {
+        try {
+            const { branch } = await getDefaultBranchHead(gh.owner, gh.repo, gh.token);
+            syncRepoToRef(cwd, { branch }, gh.token);
+            const detection = await detectSnapshotVersion({
+                cwd,
+                latestReleaseTag: latest.tag_name,
+                config: _config,
+                verbose,
+            });
+            if (detection.snapshot_tag &&
+                isPlausibleSnapshotTag(detection.snapshot_tag, latest.tag_name)) {
+                const snapshotRow = await ensureReleaseRow({
+                    productId,
+                    tag: detection.snapshot_tag,
+                    previousTag: latest.tag_name,
+                    previousPublishedAt: latest.published_at ?? null,
+                    githubRelease: null,
+                }, verbose);
+                synced.push({
+                    id: snapshotRow.release.id,
+                    tag: snapshotRow.release.tag,
+                    isSnapshot: true,
+                });
+                if (snapshotRow.created) {
+                    logInfo(`Detected unreleased snapshot ${detection.snapshot_tag} (${detection.source ?? 'unknown source'})`);
+                }
+            }
+            else if (verbose) {
+                logInfo(`No snapshot version ahead of ${latest.tag_name}`);
+            }
+        }
+        catch (err) {
+            logWarning(`Snapshot detection skipped: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    logSuccess(`Synced ${synced.length} release${synced.length === 1 ? '' : 's'}`);
+    return {
+        status: 'success',
+        productId,
+        summary: `Synced ${synced.length} release${synced.length === 1 ? '' : 's'} from GitHub`,
+        syncedReleases: synced,
+    };
+}

package/dist/phases/release-sync/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>;

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

@@ -0,0 +1,159 @@
+/**
+ * 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 { query } from '@anthropic-ai/claude-agent-sdk';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { findBalancedJsonObject } from '../../utils/json-extract.js';
+import { logDebug, logInfo } from '../../utils/logger.js';
+export function buildSnapshotDetectionPrompt(latestReleaseTag) {
+    return `You are inspecting a code repository to decide whether an unreleased "snapshot" version is being prepared.
+
+The most recent shipped release on GitHub is tagged: **${latestReleaseTag}**
+
+Your job:
+
+1. Read the repository's primary version source. In priority order:
+   - package.json "version" field (JS/TS projects)
+   - Cargo.toml [package] version (Rust)
+   - pyproject.toml [project] / [tool.poetry] version (Python)
+   - pom.xml <version> (Java / Maven)
+   - VERSION file (plain text)
+2. Read CHANGELOG.md / HISTORY.md / RELEASES.md for an [Unreleased] or similarly labelled section.
+3. Run \`git tag --list\` and \`git tag --sort=-creatordate | head -5\` to look for tags newer than ${latestReleaseTag} that have not yet been cut as GitHub releases.
+
+Then decide:
+- If the primary version source is strictly greater than ${latestReleaseTag} (accounting for "v" prefixes and semver prerelease suffixes like \`-SNAPSHOT\`, \`-rc.1\`, \`-next.0\`), OR there is a newer unreleased git tag, report that string as \`snapshot_tag\`.
+- Otherwise report \`snapshot_tag: null\`.
+- Do NOT invent a version. Use the exact string from the source file. Preserve the repo's existing tag convention (e.g. if releases are \`v1.2.3\` but package.json says \`1.2.3\`, return \`v1.2.3\`).
+
+Respond with ONLY a JSON object — no prose, no markdown fences:
+
+{
+  "snapshot_tag": "v2.0.0" | null,
+  "source": "package.json" | "Cargo.toml" | "pyproject.toml" | "pom.xml" | "VERSION" | "CHANGELOG" | "git_tag" | null,
+  "reasoning": "<one sentence>"
+}`;
+}
+export function parseSnapshotDetection(raw) {
+    let body = raw.trim();
+    const fence = body.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fence) {
+        body = fence[1].trim();
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        const object = findBalancedJsonObject(body);
+        if (!object) {
+            throw new Error('No JSON object found in snapshot-detection output');
+        }
+        parsed = JSON.parse(object);
+    }
+    if (typeof parsed !== 'object' || parsed === null) {
+        throw new Error('Snapshot detection returned non-object response');
+    }
+    const obj = parsed;
+    const rawTag = obj.snapshot_tag;
+    const snapshotTag = typeof rawTag === 'string' && rawTag.trim().length > 0
+        ? rawTag.trim()
+        : null;
+    const source = typeof obj.source === 'string' ? obj.source : null;
+    const reasoning = typeof obj.reasoning === 'string' ? obj.reasoning : '(no reasoning given)';
+    return { snapshot_tag: snapshotTag, source, reasoning };
+}
+/**
+ * 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 function isPlausibleSnapshotTag(candidate, latestReleaseTag) {
+    if (candidate === latestReleaseTag) {
+        return false;
+    }
+    if (candidate.length === 0 || candidate.length > 100) {
+        return false;
+    }
+    if (/\s/.test(candidate)) {
+        return false;
+    }
+    if (/^[-.]/.test(candidate) ||
+        candidate.includes('..') ||
+        candidate.includes('@{')) {
+        return false;
+    }
+    return /^[A-Za-z0-9._\-+/@]+$/.test(candidate);
+}
+function userMessage(content) {
+    return { type: 'user', message: { role: 'user', content } };
+}
+// eslint-disable-next-line @typescript-eslint/require-await -- async generator required by SDK interface
+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) {
+        logInfo(`Detecting snapshot version ahead of ${latestReleaseTag}...`);
+    }
+    let lastAssistant = '';
+    let detection = null;
+    for await (const message of query({
+        prompt: makePrompt(buildSnapshotDetectionPrompt(latestReleaseTag)),
+        options: {
+            systemPrompt: {
+                type: 'preset',
+                preset: 'claude_code',
+            },
+            model: DEFAULT_MODEL,
+            maxTurns: 10,
+            permissionMode: 'bypassPermissions',
+            cwd,
+        },
+    })) {
+        if (message.type === 'assistant' && message.message?.content) {
+            for (const content of message.message.content) {
+                if (content.type === 'text') {
+                    lastAssistant += `${content.text}\n`;
+                    logDebug(content.text, verbose);
+                }
+            }
+        }
+        if (message.type === 'result') {
+            const text = ('result' in message ? message.result : '') || lastAssistant;
+            try {
+                detection = parseSnapshotDetection(text);
+            }
+            catch (err) {
+                if (verbose) {
+                    logDebug(`Snapshot detection parse error: ${err instanceof Error ? err.message : String(err)}`, verbose);
+                }
+            }
+        }
+    }
+    if (!detection) {
+        return {
+            snapshot_tag: null,
+            source: null,
+            reasoning: 'Could not parse detection response',
+        };
+    }
+    // Validate the proposed tag before returning.
+    if (detection.snapshot_tag !== null &&
+        !isPlausibleSnapshotTag(detection.snapshot_tag, latestReleaseTag)) {
+        if (verbose) {
+            logInfo(`Rejecting implausible snapshot tag: ${JSON.stringify(detection.snapshot_tag)}`);
+        }
+        return {
+            ...detection,
+            snapshot_tag: null,
+        };
+    }
+    return detection;
+}

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

@@ -0,0 +1,39 @@
+/**
+ * Run-sheet generation for a release.
+ *
+ * Given a release, fetches the product's `run_sheet_template`, clones the
+ * repo at the release tag (reusing the workspace layout used by
+ * smoke-test), renders placeholders, and upserts the result to the
+ * `run_sheets` table.
+ *
+ * Release tags are immutable, so if an existing run sheet has the same
+ * template_snapshot + tag and no clone error, we short-circuit without
+ * re-cloning. Pass `{ force: true }` to regenerate anyway.
+ */
+export interface RunSheetOptions {
+    releaseId: string;
+    force?: boolean;
+    verbose?: boolean;
+}
+export interface RunSheetResult {
+    status: 'success' | 'error' | 'cached';
+    releaseId: string;
+    releaseTag?: string;
+    summary: string;
+    runSheetId?: string;
+    missingPlaceholders?: string[];
+    cloneError?: string | null;
+    commitsTruncated?: boolean;
+}
+/**
+ * Atomic-create a `.lock` file alongside the workspace dir. Returns
+ * true if we acquired the lock, false if another CLI instance holds a
+ * fresh one. Stale locks (> LOCK_STALE_MS old) are stolen via a single
+ * unlink + create pair; concurrent stealers race fairly via O_EXCL on
+ * the second create.
+ */
+/** Exported for unit tests; not part of the public CLI surface. */
+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;
+export declare function runRunSheet(options: RunSheetOptions): Promise<RunSheetResult>;