edsger 0.77.0 → 0.79.0

package/dist/phases/recipes/prompts.js

@@ -1,105 +0,0 @@
-/**
- * Prompts for the recipes phase.
- *
- * Agent's job: explore the cloned product repo and identify each non-trivial
- * CAPABILITY the product implements ("AI video generation", "PDF export",
- * "real-time presence", "Stripe subscription billing", etc.) and document
- * HOW the capability is built — which services / tools / libraries are
- * chained together. NOT a tech-stack inventory.
- *
- * The agent is fed the team's existing recipes (compact form: id + name +
- * summary + services) and must, for each capability it identifies, pick one
- * of:
- *   - link_recipe   — existing recipe describes this capability correctly,
- *                     just record this product uses it
- *   - update_recipe — existing recipe is close but the agent has better /
- *                     more accurate info from this repo; overwrite
- *   - create_recipe — no existing recipe matches; new entry
- *   - unlink_recipe — this product was previously linked to a recipe that
- *                     is no longer present in the repo
- *
- * Submission is via MCP tool calls only — no fenced JSON.
- */
-export function createRecipesSystemPrompt() {
-    return `You are a senior staff engineer cataloguing the IMPLEMENTATION RECIPES a product uses.
-
-The current working directory is a fresh clone of the product's repository. Use Glob/Grep/Read (and Bash for git/log when helpful) to explore it before writing.
-
-## What is a "recipe"?
-
-A recipe describes ONE non-trivial capability the product delivers, and HOW it is built: which services, libraries, tools, and techniques are chained together to make it work end-to-end.
-
-Good recipe names: "AI video generation", "PDF export with custom fonts", "Real-time collaborative editing", "Stripe subscription billing with proration", "GitHub OAuth device flow".
-Bad recipe names: "React frontend", "TypeScript", "Tailwind", "Authentication" (too vague).
-
-A recipe is the WHAT + HOW pair. The WHAT is the user-facing capability. The HOW is the specific stack of services chained to deliver it. Two products can implement the same capability with the same stack — that is one recipe, linked from both products. Two products that implement "OCR" but one uses Tesseract and the other uses PaddleOCR are TWO different recipes (same capability name, different services).
-
-## Output protocol
-
-The MCP server exposes these tools — use them, do NOT paste content as fenced code:
-
-1. \`get_recipe_detail({ recipe_id })\` — fetch the full content of an existing recipe when you need to decide whether to link, update, or create. The prompt only gives you names + summaries + services to keep your context small.
-
-2. \`create_recipe({ name, summary, content, services, evidence })\` — register a brand-new recipe in the team library AND link this product to it.
-
-3. \`update_recipe({ recipe_id, summary?, content?, services?, evidence })\` — overwrite an existing recipe with better information you discovered in this repo AND link this product to it. Use when the existing recipe is broadly correct but lacks detail / has outdated services / has a vague summary.
-
-4. \`link_recipe({ recipe_id, evidence })\` — just link this product to an existing recipe that already describes the capability accurately. The recipe's content is not touched.
-
-5. \`unlink_recipe({ recipe_id })\` — drop a previously-linked recipe that the agent has confirmed is NO LONGER present in this repo (capability was removed, or the previous scan was wrong). Only unlink things in the "Currently linked to this product" list.
-
-Call exactly one of create / update / link for each capability you identify. Call unlink at the end for any previously-linked recipe you could not corroborate. When you are done with every capability and every unlink, end your turn — no summary message, no JSON dump.
-
-## Rules
-
-- \`services\` is a SORTED list of canonical service / tool / library names ("ElevenLabs", "ffmpeg", "Whisper", "Stripe", "Resend"). Sort alphabetically so equivalent recipes compare cleanly. Don't include language/framework names ("React", "Node") unless they're the actual differentiator.
-- \`content\` is markdown. Aim for 200–800 words per recipe. Structure: a short intro sentence, then numbered steps describing the flow, then a "Files" subsection with relative paths (e.g. \`src/services/video/encoder.ts\`).
-- \`evidence\` is one paragraph of plain text saying where in THIS product's repo the recipe shows up: file paths, key entry points. Used to help reviewers verify the link.
-- Don't invent capabilities. If the repo is small or only does one thing, emit one recipe — don't pad.
-- Prefer LINK over UPDATE over CREATE in that order. Reuse the team library aggressively; the whole point is cross-product visibility into the same recipe.
-- When the same capability is implemented with a clearly different stack, that's a NEW recipe even if the name collides. Disambiguate the name (\"PDF export (Puppeteer)\" vs \"PDF export (pdf-lib)\") so the team can tell them apart.`;
-}
-export function createRecipesUserPrompt(ctx) {
-    const lines = [];
-    lines.push(`# Product: ${ctx.productName}`);
-    if (ctx.productDescription) {
-        lines.push('');
-        lines.push('## Description');
-        lines.push(ctx.productDescription);
-    }
-    if (ctx.guidance && ctx.guidance.trim()) {
-        lines.push('');
-        lines.push('## Reviewer guidance (focus or exclusions)');
-        lines.push(ctx.guidance.trim());
-    }
-    lines.push('');
-    lines.push('## Existing recipes in this team');
-    if (ctx.teamRecipes.length === 0) {
-        lines.push('(none — every recipe you identify will be a `create_recipe`.)');
-    }
-    else {
-        lines.push('Prefer `link_recipe` / `update_recipe` over `create_recipe` when one of these matches the capability you found. Call `get_recipe_detail` if you need to see the full content before deciding.');
-        lines.push('');
-        for (const r of ctx.teamRecipes) {
-            const svc = r.services.length > 0 ? ` services=[${r.services.join(', ')}]` : '';
-            const sum = r.summary ? ` — ${r.summary}` : '';
-            lines.push(`- id=${r.id} "${r.name}"${svc}${sum}`);
-        }
-    }
-    lines.push('');
-    lines.push('## Currently linked to this product');
-    if (ctx.existingLinks.length === 0) {
-        lines.push('(none)');
-    }
-    else {
-        lines.push('If you confirm any of these is no longer present in the repo, call `unlink_recipe` with its id.');
-        lines.push('');
-        for (const l of ctx.existingLinks) {
-            lines.push(`- id=${l.recipeId} "${l.name}"`);
-        }
-    }
-    lines.push('');
-    lines.push('## Task');
-    lines.push('Explore the cloned repository, identify every non-trivial capability the product delivers, and for each call exactly one of `create_recipe` / `update_recipe` / `link_recipe`. Then call `unlink_recipe` for any previously-linked recipe you could not corroborate. End your turn when done.');
-    return lines.join('\n');
-}

package/dist/phases/recipes/types.d.ts

@@ -1,42 +0,0 @@
-/**
- * Shapes the recipes MCP tools accept and return. The Zod schemas live in
- * mcp-server.ts; these plain TS types are what the rest of the phase
- * (orchestrator, persistence helpers, tests) consumes so they don't have
- * to inflate Zod into their dependency graph.
- */
-export interface RecipeSummary {
-    id: string;
-    name: string;
-    summary: string | null;
-    services: string[];
-}
-export interface RecipeDetail extends RecipeSummary {
-    content: string | null;
-}
-export interface CreateRecipeArgs {
-    name: string;
-    summary: string;
-    content: string;
-    services: string[];
-    evidence: string;
-}
-export interface UpdateRecipeArgs {
-    recipeId: string;
-    summary?: string;
-    content?: string;
-    services?: string[];
-    evidence: string;
-}
-export interface LinkRecipeArgs {
-    recipeId: string;
-    evidence: string;
-}
-export interface UnlinkRecipeArgs {
-    recipeId: string;
-}
-export declare const RECIPE_SUMMARY_MAX = 500;
-export declare const RECIPE_CONTENT_MAX = 50000;
-export declare const RECIPE_NAME_MAX = 200;
-export declare const RECIPE_SERVICES_MAX = 20;
-export declare const RECIPE_SERVICE_NAME_MAX = 80;
-export declare const RECIPE_EVIDENCE_MAX = 4000;

package/dist/phases/recipes/types.js

@@ -1,16 +0,0 @@
-/**
- * Shapes the recipes MCP tools accept and return. The Zod schemas live in
- * mcp-server.ts; these plain TS types are what the rest of the phase
- * (orchestrator, persistence helpers, tests) consumes so they don't have
- * to inflate Zod into their dependency graph.
- */
-// Defensive caps mirroring the DB CHECK constraints from
-// 20260521000000_create_recipes.sql. Keeping the limits here lets the MCP
-// tool reject oversized output with an actionable error message instead of
-// getting a Postgres constraint violation.
-export const RECIPE_SUMMARY_MAX = 500;
-export const RECIPE_CONTENT_MAX = 50_000;
-export const RECIPE_NAME_MAX = 200;
-export const RECIPE_SERVICES_MAX = 20;
-export const RECIPE_SERVICE_NAME_MAX = 80;
-export const RECIPE_EVIDENCE_MAX = 4000;

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

@@ -1,66 +0,0 @@
-/**
- * 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;
-    html_url?: 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>;
-/**
- * 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;
-    additions: number;
-    deletions: number;
-    total_commits: number;
-};

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

@@ -1,140 +0,0 @@
-/**
- * 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,
-            html_url: c.html_url ?? undefined,
-            commit: {
-                message: c.commit?.message ?? '',
-                author: c.commit?.author
-                    ? { name: c.commit.author.name ?? undefined }
-                    : null,
-            },
-        })),
-    };
-}
-/**
- * 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}`);
-    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

@@ -1,24 +0,0 @@
-/**
- * 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

@@ -1,156 +0,0 @@
-/**
- * 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 { cleanupIssueRepo, cloneIssueRepo, 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;
-    let syncSucceeded = false;
-    try {
-        try {
-            const workspaceRoot = ensureWorkspaceDir();
-            const { repoPath } = cloneIssueRepo(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'}`);
-        syncSucceeded = true;
-        return {
-            status: 'success',
-            productId,
-            summary: `Synced ${synced.length} release${synced.length === 1 ? '' : 's'} from GitHub`,
-            syncedReleases: synced,
-        };
-    }
-    finally {
-        if (syncSucceeded) {
-            cleanupIssueRepo(cwd);
-        }
-    }
-}

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

@@ -1,27 +0,0 @@
-/**
- * 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>;