edsger 0.76.0 → 0.78.0

package/dist/phases/run-sheet/index.js

@@ -1,392 +0,0 @@
-/**
- * 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), and hands the template + repo to the Claude Agent SDK
- * which reads the diff and produces the run sheet Markdown. The result
- * is upserted 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.
- */
-import { closeSync, mkdirSync, openSync, readdirSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync, } from 'fs';
-import { join } from 'path';
-import { getGitHubConfigByProduct } from '../../api/github.js';
-import { getProduct } from '../../api/products.js';
-import { getRelease } from '../../api/releases.js';
-import { getRunSheetByRelease, upsertRunSheet, } from '../../api/run-sheets.js';
-import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cleanupIssueRepo, cloneIssueRepo, ensureWorkspaceDir, getIssueRepoPath, isSafeGitRef, syncRepoToRef, } from '../../workspace/workspace-manager.js';
-import { getDefaultBranchHead } from '../release-sync/github.js';
-import { generateRunSheetWithAgent } from './agent.js';
-// Stale locks (e.g. left behind by a crashed or SIGKILLed CLI) are
-// considered abandoned after this many ms.
-const LOCK_STALE_MS = 15 * 60 * 1000;
-function writeLockFile(fd) {
-    const payload = { pid: process.pid, ts: Date.now() };
-    writeFileSync(fd, JSON.stringify(payload));
-    closeSync(fd);
-}
-function tryCreateLock(lockPath) {
-    try {
-        const fd = openSync(lockPath, 'wx');
-        writeLockFile(fd);
-        return true;
-    }
-    catch (err) {
-        if (err.code === 'EEXIST') {
-            return false;
-        }
-        throw err;
-    }
-}
-function isLockStale(lockPath) {
-    try {
-        const raw = readFileSync(lockPath, 'utf-8').trim();
-        let ts;
-        try {
-            ;
-            ({ ts } = JSON.parse(raw));
-        }
-        catch {
-            ts = Number(raw);
-        }
-        return !Number.isFinite(ts) || Date.now() - ts > LOCK_STALE_MS;
-    }
-    catch {
-        // Lock vanished between exists-check and read — treat as not held.
-        return true;
-    }
-}
-/**
- * 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 function tryAcquireFileLock(lockPath) {
-    mkdirSync(join(lockPath, '..'), { recursive: true });
-    // Pass 1: clean acquisition.
-    if (tryCreateLock(lockPath)) {
-        return true;
-    }
-    // Pass 2: someone holds it — only steal if their lock is stale.
-    if (!isLockStale(lockPath)) {
-        return false;
-    }
-    // Try to steal. Best-effort unlink (another stealer may have beaten
-    // us); the O_EXCL create then arbitrates fairly.
-    try {
-        unlinkSync(lockPath);
-    }
-    catch {
-        // Already gone — fine, race the create below.
-    }
-    return tryCreateLock(lockPath);
-}
-/** Exported for unit tests; not part of the public CLI surface. */
-export function releaseFileLock(lockPath) {
-    try {
-        unlinkSync(lockPath);
-    }
-    catch {
-        // Best-effort — lock will expire via LOCK_STALE_MS anyway.
-    }
-}
-// A `run-sheet-<release-id>` workspace whose lock is stale and whose
-// dir hasn't been touched for this long is considered abandoned. 30 days
-// is long enough to keep caches warm across normal release cadences,
-// short enough that disk usage doesn't grow unboundedly.
-const WORKSPACE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
-/**
- * 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 function pruneStaleRunSheetWorkspaces(workspaceRoot, now = Date.now(), maxAgeMs = WORKSPACE_MAX_AGE_MS) {
-    const removed = [];
-    let entries;
-    try {
-        entries = readdirSync(workspaceRoot);
-    }
-    catch {
-        return { removed };
-    }
-    for (const entry of entries) {
-        if (!entry.startsWith('run-sheet-')) {
-            continue;
-        }
-        const entryPath = join(workspaceRoot, entry);
-        const lockPath = `${entryPath}.lock`;
-        let ageMs;
-        try {
-            const stat = statSync(entryPath);
-            if (!stat.isDirectory()) {
-                continue;
-            }
-            ageMs = now - stat.mtimeMs;
-        }
-        catch {
-            continue;
-        }
-        if (ageMs < maxAgeMs) {
-            continue;
-        }
-        // Don't delete a dir with a live lock — another CLI is mid-run.
-        try {
-            readFileSync(lockPath, 'utf-8');
-            if (!isLockStale(lockPath)) {
-                continue;
-            }
-        }
-        catch {
-            // Lock missing — safe to delete.
-        }
-        try {
-            rmSync(entryPath, { recursive: true, force: true });
-            try {
-                unlinkSync(lockPath);
-            }
-            catch {
-                // Lock file may not exist; that's fine.
-            }
-            removed.push(entry);
-        }
-        catch (err) {
-            logWarning(`Could not prune stale workspace ${entry}: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    return { removed };
-}
-/** Exported for unit tests; not part of the public CLI surface. */
-export function runSheetIsFresh(existing, template, tag) {
-    if (!existing || !existing.content) {
-        return false;
-    }
-    if (existing.template_snapshot !== template) {
-        return false;
-    }
-    const meta = existing.metadata ?? {};
-    if (meta.tag !== tag) {
-        return false;
-    }
-    if (meta.clone_error) {
-        return false;
-    }
-    if (meta.agent_error) {
-        return false;
-    }
-    // Drafts are rendered from the default branch HEAD, which moves. Always
-    // regenerate so the agent sees current code.
-    if (meta.is_draft) {
-        return false;
-    }
-    return true;
-}
-// eslint-disable-next-line complexity -- orchestration with cache, clone, lock, agent
-export async function runRunSheet(options) {
-    const { releaseId, force, verbose } = options;
-    let release;
-    try {
-        release = await getRelease(releaseId, verbose);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-            status: 'error',
-            releaseId,
-            summary: `Failed to load release: ${message}`,
-        };
-    }
-    if (!isSafeGitRef(release.tag)) {
-        return {
-            status: 'error',
-            releaseId,
-            releaseTag: release.tag,
-            summary: `Unsafe release tag: ${release.tag}`,
-        };
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- mcp product shape is open
-    const product = (await getProduct(release.product_id, verbose));
-    const template = product?.run_sheet_template;
-    if (!template || !template.trim()) {
-        return {
-            status: 'error',
-            releaseId,
-            releaseTag: release.tag,
-            summary: 'Product has no run_sheet_template configured. Set one in product settings.',
-        };
-    }
-    // Short-circuit cache: identical template + tag, no prior clone / agent error.
-    if (!force) {
-        const existing = await getRunSheetByRelease(releaseId, verbose).catch(() => null);
-        if (existing && runSheetIsFresh(existing, template, release.tag)) {
-            logInfo(`Run sheet for ${release.tag} is already up-to-date (template unchanged).`);
-            return {
-                status: 'cached',
-                releaseId,
-                releaseTag: release.tag,
-                runSheetId: existing.id,
-                summary: 'Cached (no change since last render)',
-                cloneError: null,
-            };
-        }
-    }
-    const gh = await getGitHubConfigByProduct(release.product_id, verbose);
-    const repoConfigured = gh.configured && gh.token && gh.owner && gh.repo;
-    const repoFullName = gh.owner && gh.repo ? `${gh.owner}/${gh.repo}` : null;
-    let repoDir = null;
-    let cloneError = null;
-    let lockPath = null;
-    // Draft mode: the release's tag doesn't exist on GitHub yet (e.g. a
-    // Maven SNAPSHOT being planned pre-cut). We still want to produce a
-    // useful run sheet, so we fall back to the default branch HEAD.
-    let isDraft = false;
-    let draftBaseRef = null;
-    if (repoConfigured && gh.owner && gh.repo && gh.token) {
-        const { owner, repo, token } = gh;
-        // Serialise concurrent CLI invocations for the *same release* by
-        // taking a file lock next to the clone dir.
-        const workspaceRoot = ensureWorkspaceDir();
-        const pruned = pruneStaleRunSheetWorkspaces(workspaceRoot);
-        if (pruned.removed.length > 0) {
-            logInfo(`Pruned ${pruned.removed.length} stale run-sheet workspace(s).`);
-        }
-        const workspaceName = `run-sheet-${release.id}`;
-        const repoPathAhead = getIssueRepoPath(workspaceRoot, workspaceName);
-        lockPath = `${repoPathAhead}.lock`;
-        if (!tryAcquireFileLock(lockPath)) {
-            return {
-                status: 'error',
-                releaseId: release.id,
-                releaseTag: release.tag,
-                summary: 'Another run-sheet generation is in progress for this release. Wait for it to finish or retry.',
-            };
-        }
-        try {
-            const { repoPath } = cloneIssueRepo(workspaceRoot, workspaceName, owner, repo, token);
-            repoDir = repoPath;
-            // SNAPSHOT releases have no GitHub release object backing them, so
-            // `published_at` is null. Use that as a free local signal to skip
-            // the tag-checkout entirely.
-            const expectDraft = release.published_at === null;
-            if (expectDraft) {
-                logInfo(`Tag ${release.tag} not yet cut (no published_at) — generating draft run sheet from default branch.`);
-                try {
-                    const { branch } = await getDefaultBranchHead(owner, repo, token);
-                    syncRepoToRef(repoPath, { branch }, token);
-                    isDraft = true;
-                    draftBaseRef = branch;
-                }
-                catch (fallbackErr) {
-                    cloneError = `Could not check out default branch for draft run sheet: ${fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)}`;
-                    logWarning(cloneError);
-                }
-            }
-            else {
-                try {
-                    syncRepoToRef(repoPath, { tag: release.tag }, token);
-                }
-                catch (err) {
-                    const tagErr = err instanceof Error ? err.message : String(err);
-                    logWarning(`Tag ${release.tag} checkout failed — falling back to default branch.`);
-                    try {
-                        const { branch } = await getDefaultBranchHead(owner, repo, token);
-                        syncRepoToRef(repoPath, { branch }, token);
-                        isDraft = true;
-                        draftBaseRef = branch;
-                        cloneError = `Tag ${release.tag} could not be checked out; fell back to default branch ${branch}. (${tagErr})`;
-                    }
-                    catch (fallbackErr) {
-                        cloneError = `Could not checkout tag ${release.tag} or fall back to default branch: ${fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)}`;
-                        logWarning(cloneError);
-                    }
-                }
-            }
-        }
-        catch (err) {
-            cloneError = err instanceof Error ? err.message : String(err);
-            logWarning(`Clone failed: ${cloneError}`);
-        }
-    }
-    else {
-        cloneError = 'Product is not linked to a GitHub repository';
-    }
-    try {
-        const agentResult = await generateRunSheetWithAgent({
-            product: {
-                name: product?.name ?? 'Unknown product',
-                github_repository_full_name: repoFullName,
-            },
-            release: {
-                tag: release.tag,
-                name: release.name,
-                body: release.body,
-                url: release.url,
-                published_at: release.published_at,
-                previous_tag: release.previous_tag,
-                previous_published_at: release.previous_published_at,
-            },
-            template,
-            repoDir,
-            isDraft,
-            draftBaseRef,
-            verbose,
-        });
-        const saved = await upsertRunSheet({
-            release_id: release.id,
-            content: agentResult.content,
-            title: `Run Sheet — ${product?.name ?? ''} ${release.tag}`.trim(),
-            template_snapshot: template,
-            metadata: {
-                clone_error: cloneError,
-                repo: repoFullName,
-                tag: release.tag,
-                is_draft: isDraft,
-                draft_base_ref: draftBaseRef,
-                model: agentResult.model,
-                agent_turns: agentResult.turns,
-                agent_subtype: agentResult.subtype,
-                agent_error: agentResult.error,
-            },
-            generated_at: new Date().toISOString(),
-        }, verbose);
-        logSuccess(`Generated run sheet for ${release.tag}`);
-        cleanupIssueRepo(repoDir ?? undefined);
-        return {
-            status: 'success',
-            releaseId: release.id,
-            releaseTag: release.tag,
-            runSheetId: saved.id,
-            summary: `Rendered ${agentResult.content.length} characters (${agentResult.turns} agent turn(s))`,
-            cloneError,
-            isDraft,
-            agentTurns: agentResult.turns,
-            model: agentResult.model,
-        };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        logError(`Run-sheet generation failed: ${message}`);
-        return {
-            status: 'error',
-            releaseId: release.id,
-            releaseTag: release.tag,
-            summary: `Run-sheet generation failed: ${message}`,
-        };
-    }
-    finally {
-        if (lockPath) {
-            releaseFileLock(lockPath);
-        }
-    }
-}

package/dist/phases/screen-flow/index.d.ts

@@ -1,26 +0,0 @@
-/**
- * screen-flow phase: clone the product's repo, ask Claude to map every
- * user-facing screen and the transitions between them into a structured
- * ScreenFlowExtraction, then persist the result to diagrams / diagram_nodes /
- * diagram_edges (rows tagged `type = 'screen'`) via the Supabase SDK.
- *
- * Companion to find-architecture / find-bugs / find-features. Same workspace
- * pattern, but writes to its own tables rather than filing issues.
- */
-export interface ScreenFlowOptions {
-    /** Product-scoped flow. Mutually exclusive with `repoId`. */
-    productId?: string;
-    /** Repo-only flow: a single repositories row, no product context. */
-    repoId?: string;
-    diagramId: string;
-    guidance?: string;
-    verbose?: boolean;
-}
-export interface ScreenFlowResult {
-    status: 'success' | 'error';
-    message: string;
-    nodesCreated?: number;
-    edgesCreated?: number;
-    summary?: string;
-}
-export declare function runScreenFlowPhase(options: ScreenFlowOptions): Promise<ScreenFlowResult>;