edsger 0.77.0 → 0.78.0

package/dist/phases/sequence-diagram/types.d.ts

@@ -1,52 +0,0 @@
-/**
- * Sequence Diagram domain types.
- *
- * A SequenceParticipant is one lifeline in an interaction — an actor, a
- * service, a database, an external system, a queue, or an internal
- * component. A SequenceMessage is one ordered interaction between two
- * participants (a call, an async send, a return, or a self-message).
- *
- * A sequence diagram captures ONE scenario / flow of control (e.g. "user
- * checkout", "OAuth login"); the user's guidance picks the scenario. The CLI
- * extracts it from source code (call sites, handlers, SDK calls) and the
- * desktop renders participants as lifelines with the messages ordered by the
- * `order` field.
- *
- * Companion to DataNodeSchema / ErEntity: same flow-graph shape (nodes +
- * edges sharing the `diagrams` table storing the JSONB schema), different domain.
- */
-export type SequenceParticipantKind = 'actor' | 'service' | 'component' | 'database' | 'queue' | 'external';
-export interface SequenceParticipant {
-    /** Stable slug within the diagram (e.g. 'user', 'auth-service'). */
-    slug: string;
-    /** Human-readable name. */
-    name: string;
-    kind: SequenceParticipantKind;
-    /** Source file path (jump anchor) where the participant is defined. */
-    file?: string;
-    /** One-sentence description of the participant's role. */
-    description?: string;
-}
-/**
- * Message kinds describe the nature of the interaction arrow.
- */
-export type SequenceMessageKind = 'sync' | 'async' | 'return' | 'self';
-export interface SequenceMessage {
-    /** Sender participant slug. */
-    fromSlug: string;
-    /** Receiver participant slug. */
-    toSlug: string;
-    kind: SequenceMessageKind;
-    /** 1-based position of this message in the interaction timeline. */
-    order: number;
-    /** The call / message text ('POST /login', 'validateToken()', 'rows'). */
-    label?: string;
-    /** File + line where this call happens (for jump-to-code). */
-    sourceFile?: string;
-}
-export interface SequenceDiagramExtraction {
-    summary: string;
-    participants: SequenceParticipant[];
-    messages: SequenceMessage[];
-}
-export declare function isSequenceDiagramExtraction(value: unknown): value is SequenceDiagramExtraction;

package/dist/phases/sequence-diagram/types.js

@@ -1,93 +0,0 @@
-/**
- * Sequence Diagram domain types.
- *
- * A SequenceParticipant is one lifeline in an interaction — an actor, a
- * service, a database, an external system, a queue, or an internal
- * component. A SequenceMessage is one ordered interaction between two
- * participants (a call, an async send, a return, or a self-message).
- *
- * A sequence diagram captures ONE scenario / flow of control (e.g. "user
- * checkout", "OAuth login"); the user's guidance picks the scenario. The CLI
- * extracts it from source code (call sites, handlers, SDK calls) and the
- * desktop renders participants as lifelines with the messages ordered by the
- * `order` field.
- *
- * Companion to DataNodeSchema / ErEntity: same flow-graph shape (nodes +
- * edges sharing the `diagrams` table storing the JSONB schema), different domain.
- */
-// ============================================================================
-// Runtime validation for AI-produced extraction
-// ============================================================================
-const PARTICIPANT_KINDS = new Set([
-    'actor',
-    'service',
-    'component',
-    'database',
-    'queue',
-    'external',
-]);
-const MESSAGE_KINDS = new Set([
-    'sync',
-    'async',
-    'return',
-    'self',
-]);
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-function isSequenceParticipant(value) {
-    if (!isRecord(value)) {
-        return false;
-    }
-    if (typeof value.slug !== 'string' || value.slug.length === 0) {
-        return false;
-    }
-    if (typeof value.name !== 'string' || value.name.length === 0) {
-        return false;
-    }
-    if (typeof value.kind !== 'string' ||
-        !PARTICIPANT_KINDS.has(value.kind)) {
-        return false;
-    }
-    return true;
-}
-function isSequenceMessage(value) {
-    if (!isRecord(value)) {
-        return false;
-    }
-    if (typeof value.fromSlug !== 'string') {
-        return false;
-    }
-    if (typeof value.toSlug !== 'string') {
-        return false;
-    }
-    if (typeof value.kind !== 'string' ||
-        !MESSAGE_KINDS.has(value.kind)) {
-        return false;
-    }
-    if (typeof value.order !== 'number') {
-        return false;
-    }
-    return true;
-}
-export function isSequenceDiagramExtraction(value) {
-    if (!isRecord(value)) {
-        return false;
-    }
-    if (typeof value.summary !== 'string') {
-        return false;
-    }
-    if (!Array.isArray(value.participants)) {
-        return false;
-    }
-    if (!Array.isArray(value.messages)) {
-        return false;
-    }
-    if (!value.participants.every(isSequenceParticipant)) {
-        return false;
-    }
-    if (!value.messages.every(isSequenceMessage)) {
-        return false;
-    }
-    return true;
-}

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

@@ -1,12 +0,0 @@
-import { type EdsgerConfig } from '../../types/index.js';
-export interface GeneratedSmokeTestPlan {
-    summary: string;
-    test_cases: {
-        name: string;
-        description: string;
-        is_critical?: boolean;
-    }[];
-}
-/** @internal Exported for unit tests only. */
-export declare function extractJson(raw: string): GeneratedSmokeTestPlan;
-export declare function executeSmokeTestQuery(systemPrompt: string, userPrompt: string, config: EdsgerConfig, verbose?: boolean, cwd?: string): Promise<GeneratedSmokeTestPlan>;

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

@@ -1,93 +0,0 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { findBalancedJsonObject } from '../../utils/json-extract.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-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);
-}
-/** @internal Exported for unit tests only. */
-export function extractJson(raw) {
-    let body = raw.trim();
-    const fence = body.match(/```(?:json)?\s*([\s\S]*?)```/);
-    if (fence) {
-        body = fence[1].trim();
-    }
-    // Try parsing the whole body first — if the model returned clean JSON
-    // it round-trips without needing to slice.
-    let parsed;
-    try {
-        parsed = JSON.parse(body);
-    }
-    catch {
-        const object = findBalancedJsonObject(body);
-        if (!object) {
-            throw new Error('No JSON object found in model output');
-        }
-        parsed = JSON.parse(object);
-    }
-    if (typeof parsed !== 'object' ||
-        parsed === null ||
-        !Array.isArray(parsed.test_cases)) {
-        throw new Error('Model response is missing test_cases array');
-    }
-    return parsed;
-}
-// eslint-disable-next-line complexity -- agent loop with message type handling
-export async function executeSmokeTestQuery(systemPrompt, userPrompt, config, verbose, cwd) {
-    let lastAssistant = '';
-    let plan = null;
-    let parseError = null;
-    let turnCount = 0;
-    if (verbose) {
-        logInfo('Connecting to Claude Code for smoke-test generation...');
-    }
-    for await (const message of query({
-        prompt: makePrompt(userPrompt),
-        options: {
-            systemPrompt: {
-                type: 'preset',
-                preset: 'claude_code',
-                append: systemPrompt,
-            },
-            model: DEFAULT_MODEL,
-            maxTurns: 20,
-            permissionMode: 'bypassPermissions',
-            ...(cwd ? { cwd } : {}),
-        },
-    })) {
-        if (message.type === 'assistant' && message.message?.content) {
-            turnCount++;
-            for (const content of message.message.content) {
-                if (content.type === 'text') {
-                    lastAssistant += `${content.text}\n`;
-                    logDebug(content.text, verbose);
-                }
-                else if (content.type === 'tool_use' && verbose) {
-                    const input = (content.input ?? {});
-                    const desc = input.description ?? input.command ?? 'Running...';
-                    logInfo(`[Turn ${turnCount}] ${content.name}: ${typeof desc === 'string' ? desc.slice(0, 120) : 'Running...'}`);
-                }
-            }
-        }
-        if (message.type === 'result') {
-            const text = ('result' in message ? message.result : '') || lastAssistant;
-            try {
-                plan = extractJson(text);
-            }
-            catch (err) {
-                parseError = err instanceof Error ? err.message : String(err);
-            }
-            if (message.subtype !== 'success') {
-                logError(`Smoke-test query incomplete: ${message.subtype}`);
-            }
-        }
-    }
-    if (!plan) {
-        throw new Error(`Failed to parse smoke-test plan from model output: ${parseError ?? 'no result message received'}`);
-    }
-    return plan;
-}

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

@@ -1,22 +0,0 @@
-/**
- * Smoke-test generation for a single release row. Given a release that has
- * already been synced into the `releases` table (see `phases/release-sync`),
- * this phase clones the repo, diffs against the baseline, and asks Claude
- * to emit a JSON test plan, then persists the test cases and marks the
- * release `ready`.
- */
-import { type EdsgerConfig } from '../../types/index.js';
-export interface SmokeTestOptions {
-    releaseId: string;
-    verbose?: boolean;
-}
-export interface SmokeTestResult {
-    status: 'success' | 'error';
-    releaseId: string;
-    releaseTag?: string;
-    previousReleaseTag?: string | null;
-    casesCount?: number;
-    summary: string;
-    isSnapshot?: boolean;
-}
-export declare function runSmokeTest(options: SmokeTestOptions, config: EdsgerConfig): Promise<SmokeTestResult>;

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

@@ -1,241 +0,0 @@
-/**
- * Smoke-test generation for a single release row. Given a release that has
- * already been synced into the `releases` table (see `phases/release-sync`),
- * this phase clones the repo, diffs against the baseline, and asks Claude
- * to emit a JSON test plan, then persists the test cases and marks the
- * release `ready`.
- */
-import { getGitHubConfigByProduct } from '../../api/github.js';
-import { getProduct } from '../../api/products.js';
-import { clearReleaseTestCases, createReleaseTestCases, } from '../../api/release-test-cases.js';
-import { getRelease, updateRelease } from '../../api/releases.js';
-import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cleanupIssueRepo, cloneIssueRepo, ensureWorkspaceDir, syncRepoToRef, } from '../../workspace/workspace-manager.js';
-import { buildDiffDigest, fetchCompare, getDefaultBranchHead, summariseStats, } from '../release-sync/github.js';
-import { executeSmokeTestQuery } from './agent.js';
-import { buildSmokeTestUserPrompt, createSmokeTestSystemPrompt, } from './prompts.js';
-function isSnapshotRelease(release) {
-    return !release.published_at && !release.url;
-}
-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) {
-        logInfo(`Starting smoke-test generation for release: ${releaseId}`);
-    }
-    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}`,
-        };
-    }
-    const gh = await getGitHubConfigByProduct(release.product_id, verbose);
-    if (!gh.configured || !gh.token || !gh.owner || !gh.repo) {
-        return {
-            status: 'error',
-            releaseId,
-            summary: gh.message ||
-                'Product is not connected to a GitHub repository. Connect it in Product Settings.',
-        };
-    }
-    const ghResolved = { owner: gh.owner, repo: gh.repo, token: gh.token };
-    const isSnapshot = isSnapshotRelease(release);
-    // Mark release as generating up front so the UI reflects progress.
-    let markedGenerating = false;
-    try {
-        await updateRelease({ release_id: release.id, status: 'generating', generation_error: null }, verbose);
-        markedGenerating = true;
-    }
-    catch (err) {
-        logWarning(`Could not mark release as generating: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    try {
-        return await runSmokeTestInner({
-            release,
-            gh: ghResolved,
-            isSnapshot,
-            config,
-            verbose,
-        });
-    }
-    catch (err) {
-        // Safety net: an uncaught throw past the `generating` mark would leave the
-        // release row stuck. Flip it to `failed` so the UI isn't permanently stale.
-        const message = err instanceof Error ? err.message : String(err);
-        if (markedGenerating) {
-            try {
-                await updateRelease({
-                    release_id: release.id,
-                    status: 'failed',
-                    generation_error: `Unexpected error: ${message}`,
-                }, verbose);
-            }
-            catch {
-                // best effort
-            }
-        }
-        logError(`Smoke-test generation failed: ${message}`);
-        return {
-            status: 'error',
-            releaseId: release.id,
-            releaseTag: release.tag,
-            summary: message,
-        };
-    }
-}
-// eslint-disable-next-line complexity -- orchestration spans GitHub + DB + AI
-async function runSmokeTestInner(ctx) {
-    const { release, gh: ghResolved, isSnapshot, config, verbose } = ctx;
-    // Clone + checkout the ref Claude should read.
-    let cwd;
-    try {
-        const workspaceRoot = ensureWorkspaceDir();
-        const { repoPath } = cloneIssueRepo(workspaceRoot, `release-${release.product_id}`, ghResolved.owner, ghResolved.repo, ghResolved.token);
-        cwd = repoPath;
-    }
-    catch (err) {
-        logWarning(`Could not clone repo (continuing without code access): ${err instanceof Error ? err.message : String(err)}`);
-    }
-    // Decide the diff head. For shipped releases this is the release tag; for
-    // snapshots it's the default branch HEAD SHA.
-    let diffHead = release.tag;
-    if (cwd && isSnapshot) {
-        try {
-            const head = await getDefaultBranchHead(ghResolved.owner, ghResolved.repo, ghResolved.token);
-            syncRepoToRef(cwd, { branch: head.branch }, ghResolved.token);
-            diffHead = head.sha;
-        }
-        catch (err) {
-            logWarning(`Could not sync to default branch head: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    else if (cwd && !isSnapshot) {
-        try {
-            syncRepoToRef(cwd, { tag: release.tag }, ghResolved.token);
-        }
-        catch (err) {
-            logWarning(`Could not checkout release tag ${release.tag}, continuing on default ref: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    // Reset non-approved cases so the run is idempotent.
-    try {
-        await clearReleaseTestCases(release.id, verbose);
-    }
-    catch (err) {
-        logWarning(`Could not clear existing draft cases: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    // Fetch diff (skip if there is no baseline).
-    let diffDigest = '(No baseline to diff against — generate smoke tests covering the entire release notes.)';
-    let diffStats = {
-        files_changed: 0,
-        additions: 0,
-        deletions: 0,
-        total_commits: 0,
-    };
-    if (release.previous_tag) {
-        try {
-            const compare = await fetchCompare(ghResolved.owner, ghResolved.repo, release.previous_tag, diffHead, ghResolved.token);
-            diffDigest = buildDiffDigest(compare);
-            diffStats = summariseStats(compare);
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            await updateRelease({
-                release_id: release.id,
-                status: 'failed',
-                generation_error: `Failed to fetch diff: ${message}`,
-            }, verbose);
-            return {
-                status: 'error',
-                releaseId: release.id,
-                releaseTag: release.tag,
-                summary: `Failed to fetch diff: ${message}`,
-            };
-        }
-    }
-    // Pull product metadata for the prompt.
-    const product = await getProduct(release.product_id, verbose).catch(() => null);
-    const productName = product?.name ?? 'Unknown product';
-    const productDescription = product?.description ?? null;
-    // Run Claude to produce the test plan.
-    let plan;
-    try {
-        const systemPrompt = await createSmokeTestSystemPrompt(Boolean(cwd), cwd);
-        plan = await executeSmokeTestQuery(systemPrompt, buildSmokeTestUserPrompt({
-            productName,
-            productDescription,
-            latestTag: release.tag,
-            previousTag: release.previous_tag,
-            releaseNotes: release.body ?? null,
-            diffDigest,
-        }), config, verbose, cwd);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        await updateRelease({ release_id: release.id, status: 'failed', generation_error: message }, verbose);
-        logError(`Smoke-test generation failed: ${message}`);
-        return {
-            status: 'error',
-            releaseId: release.id,
-            releaseTag: release.tag,
-            summary: message,
-        };
-    }
-    let casesCount = 0;
-    try {
-        casesCount = await createReleaseTestCases(release.id, plan.test_cases.map((c) => ({
-            name: c.name,
-            description: c.description,
-            is_critical: c.is_critical ?? false,
-        })), verbose);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        await updateRelease({
-            release_id: release.id,
-            status: 'failed',
-            generation_error: `Failed to insert cases: ${message}`,
-        }, verbose);
-        return {
-            status: 'error',
-            releaseId: release.id,
-            releaseTag: release.tag,
-            summary: `Failed to insert cases: ${message}`,
-        };
-    }
-    await updateRelease({
-        release_id: release.id,
-        status: 'ready',
-        diff_summary: plan.summary,
-        diff_stats: diffStats,
-        generation_error: null,
-    }, verbose);
-    const suffix = describeReleaseContext(release, isSnapshot);
-    logSuccess(`Generated ${casesCount} smoke-test cases for ${release.tag}${suffix}`);
-    // Reached only on the success path — early returns above all signal failure
-    // and intentionally leave the workspace for inspection.
-    cleanupIssueRepo(cwd);
-    return {
-        status: 'success',
-        releaseId: release.id,
-        releaseTag: release.tag,
-        previousReleaseTag: release.previous_tag,
-        casesCount,
-        summary: plan.summary,
-        isSnapshot,
-    };
-}

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

@@ -1,15 +0,0 @@
-export interface SmokeTestPromptInput {
-    productName: string;
-    productDescription: string | null;
-    latestTag: string;
-    previousTag: string | null;
-    releaseNotes: string | null;
-    diffDigest: string;
-}
-/**
- * Load the smoke-test system prompt from the shared SKILL.md library.
- * Keeping the prompt in a skill file means it can also be consumed by
- * Claude Code, other agents, or edited by users in the desktop app.
- */
-export declare function createSmokeTestSystemPrompt(hasCodebase?: boolean, projectDir?: string): Promise<string>;
-export declare function buildSmokeTestUserPrompt(input: SmokeTestPromptInput): string;

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

@@ -1,35 +0,0 @@
-import { processConditionals, resolveSkill, } from '../../services/skill-resolver.js';
-/**
- * Load the smoke-test system prompt from the shared SKILL.md library.
- * Keeping the prompt in a skill file means it can also be consumed by
- * Claude Code, other agents, or edited by users in the desktop app.
- */
-export async function createSmokeTestSystemPrompt(hasCodebase = false, projectDir) {
-    const skill = await resolveSkill('phase/smoke-test', { projectDir });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/smoke-test');
-    }
-    return processConditionals(skill.prompt, { hasCodebase });
-}
-export function buildSmokeTestUserPrompt(input) {
-    const productBlock = input.productDescription
-        ? `Product: ${input.productName}\nDescription: ${input.productDescription}`
-        : `Product: ${input.productName}`;
-    const baseBlock = input.previousTag
-        ? `Previous release: ${input.previousTag}`
-        : 'Previous release: (none — this is the first release)';
-    const notesBlock = input.releaseNotes
-        ? `Release notes for ${input.latestTag}:\n${input.releaseNotes.slice(0, 4000)}`
-        : `Release notes for ${input.latestTag}: (none)`;
-    return `${productBlock}
-
-Release to ship: ${input.latestTag}
-${baseBlock}
-
-${notesBlock}
-
-Code changes between the two releases:
-${input.diffDigest}
-
-Produce the smoke-test plan as described in the system prompt.`;
-}

package/dist/phases/state-diagram/index.d.ts

@@ -1,15 +0,0 @@
-/**
- * state-diagram phase: map a state machine — states + transitions — for a
- * status lifecycle / workflow found in the code (status enums, XState
- * machines, approval flows, etc.). Persisted to the diagrams tables with
- * `type = 'state'`. Built on the shared diagram framework.
- */
-import { type DiagramPhaseResult } from '../diagram-shared/generate.js';
-export interface StateDiagramPhaseOptions {
-    productId?: string;
-    repoId?: string;
-    diagramId: string;
-    guidance?: string;
-    verbose?: boolean;
-}
-export declare function runStateDiagramPhase(options: StateDiagramPhaseOptions): Promise<DiagramPhaseResult>;

package/dist/phases/state-diagram/index.js

@@ -1,53 +0,0 @@
-/**
- * state-diagram phase: map a state machine — states + transitions — for a
- * status lifecycle / workflow found in the code (status enums, XState
- * machines, approval flows, etc.). Persisted to the diagrams tables with
- * `type = 'state'`. Built on the shared diagram framework.
- */
-import { z } from 'zod';
-import { generateDiagram, } from '../diagram-shared/generate.js';
-import { buildDiagramSystemPrompt, buildDiagramUserPrompt, } from '../diagram-shared/prompts.js';
-const stateNode = z.object({
-    slug: z.string().min(1),
-    name: z.string().min(1),
-    kind: z.enum(['initial', 'state', 'final', 'choice', 'composite']),
-    file: z.string().optional(),
-    description: z.string().optional(),
-    onEntry: z.string().optional(),
-    onExit: z.string().optional(),
-    activity: z.string().optional(),
-});
-const stateEdge = z.object({
-    fromSlug: z.string().min(1),
-    toSlug: z.string().min(1),
-    kind: z.enum(['transition']),
-    /** trigger [guard] / action, e.g. "submit [valid] / persist()". */
-    label: z.string().optional(),
-    sourceFile: z.string().optional(),
-});
-export function runStateDiagramPhase(options) {
-    return generateDiagram({
-        ...options,
-        workspaceKey: 'state-diagram',
-        fenceName: 'state_diagram',
-        nounPlural: 'states',
-        edgeNounPlural: 'transitions',
-        mcpConfig: {
-            name: 'state-diagram',
-            toolName: 'state_diagram',
-            summaryDescribe: '1-3 sentence narrative of what this state machine models and its lifecycle.',
-            nodesSchema: z.array(stateNode),
-            nodesDescribe: 'Every state: initial / state / final / choice / composite. slug MUST be unique.',
-            edgesSchema: z.array(stateEdge),
-            edgesDescribe: 'Transitions. label carries "trigger [guard] / action". Every fromSlug / toSlug MUST reference a state slug.',
-        },
-        buildSystemPrompt: (a) => buildDiagramSystemPrompt('phase/state-diagram', 'state-diagram', a),
-        buildUserPrompt: (a) => buildDiagramUserPrompt({
-            ...a,
-            task: 'Map the primary state machine for',
-            mcpName: 'state-diagram',
-            toolName: 'state_diagram',
-            process: 'Find the most important stateful lifecycle in the code: a status enum + the code that transitions it (order status, approval/review state, job/task state, an XState/state-machine definition, a wizard). Pick ONE machine (guidance may name it). Read the transition sites to capture each transition\'s trigger, guard, and action. Include exactly one `initial` pseudostate and the `final` state(s).',
-        }),
-    });
-}

package/dist/phases/sync-github-issues/index.d.ts

@@ -1,41 +0,0 @@
-/**
- * sync-github-issues phase: pull every issue from a product's connected
- * GitHub repo, mirror new ones into our local `issues` table, propagate
- * description/state changes (without clobbering user edits, see below),
- * and flag rows that disappeared remotely as deleted. Deterministic — no
- * Claude Agent SDK; this is plain Octokit + MCP.
- *
- * Production hardening over v1:
- *
- *   - Octokit retry + throttling plugins handle 429 / secondary rate limits
- *     and transient 5xx with exponential backoff.
- *   - Upserts are batched (MAX_BATCH_SIZE per round-trip) instead of one
- *     PostgREST call per issue. Cuts a 1000-issue sync from ~50s to <1s.
- *   - Deletion sweep is keyed on a sync-start timestamp cutoff, not a
- *     present_ids list, so special characters in source_id don't break
- *     anything and there's no URL length limit.
- *   - If any batch fails, we SKIP the deletion sweep — better to leave
- *     stale "deleted" flags missing than to wrongly mark live issues as
- *     deleted from a partial fetch.
- *
- * On every click we still fetch the full list (state=all) rather than
- * incremental with `since`, because GitHub's `since` filter doesn't
- * surface deletions. Future hybrid (incremental updates + periodic full
- * sweep) can plug into the per-product state file.
- */
-import { Octokit } from '@octokit/rest';
-import { type GitHubIssueLite, type SyncResult } from './types.js';
-export interface SyncGithubIssuesOptions {
-    productId: string;
-    /** GitHub installation token (or PAT). */
-    githubToken: string;
-    owner: string;
-    repo: string;
-    verbose?: boolean;
-}
-/**
- * Pull every issue from the repo, paginated. Returns issues only (PRs
- * filtered out, since GitHub returns PRs through this endpoint too).
- */
-export declare function fetchAllRepoIssues(octokit: Octokit, owner: string, repo: string): Promise<GitHubIssueLite[]>;
-export declare function syncGithubIssues(options: SyncGithubIssuesOptions): Promise<SyncResult>;