edsger 0.76.0 → 0.78.0

package/dist/phases/sync-github-issues/index.js

@@ -1,187 +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 { retry } from '@octokit/plugin-retry';
-import { throttling } from '@octokit/plugin-throttling';
-import { Octokit } from '@octokit/rest';
-import { logError, logInfo, logSuccess, logWarning } from '../../utils/logger.js';
-import { markExternalIssuesDeletedSince, upsertInBatches, } from '../sync-shared/mcp.js';
-import { acquireSyncGithubIssuesLock, updateSyncGithubIssuesState, } from './state.js';
-// The plugins use `@octokit/core` 7.x types, while @octokit/rest@20 hoists
-// to core 5.x at the workspace root — different OctokitPlugin shapes.
-// Runtime is fine; the cast tells TS to accept the plugin chain.
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- octokit version drift across the workspace
-const ResilientOctokit = Octokit.plugin(retry, throttling);
-/** GitHub list-issues max page size. */
-const PER_PAGE = 100;
-function isPullRequest(item) {
-    return item.pull_request !== undefined;
-}
-/** Build an Octokit instance with retry + throttling configured for sync. */
-function buildOctokit(token) {
-    return new ResilientOctokit({
-        auth: token,
-        // 3 retries with exponential backoff for 429 / 5xx. The default in
-        // @octokit/plugin-retry is 3, kept explicit so a future tweak is one
-        // grep away.
-        retry: { doNotRetry: [400, 401, 403, 404, 422] },
-        throttle: {
-            onRateLimit: (retryAfter, options) => {
-                logWarning(`GitHub rate limit hit on ${options.method ?? '?'} ${options.url ?? '?'} — retry in ${retryAfter}s`);
-                // Retry up to 2 times against rate limits before giving up.
-                return (options.request?.retryCount ?? 0) < 2;
-            },
-            onSecondaryRateLimit: (retryAfter, options) => {
-                logWarning(`GitHub secondary rate limit on ${options.method ?? '?'} ${options.url ?? '?'} — retry in ${retryAfter}s`);
-                return true;
-            },
-        },
-    });
-}
-/**
- * Pull every issue from the repo, paginated. Returns issues only (PRs
- * filtered out, since GitHub returns PRs through this endpoint too).
- */
-export async function fetchAllRepoIssues(octokit, owner, repo) {
-    const all = [];
-    let page = 1;
-    for (;;) {
-        const { data } = await octokit.request('GET /repos/{owner}/{repo}/issues', {
-            owner,
-            repo,
-            state: 'all',
-            per_page: PER_PAGE,
-            page,
-            filter: 'all',
-        });
-        if (data.length === 0) {
-            break;
-        }
-        for (const item of data) {
-            if (!isPullRequest(item)) {
-                all.push(item);
-            }
-        }
-        if (data.length < PER_PAGE) {
-            break;
-        }
-        page += 1;
-    }
-    return all;
-}
-function toUpsertInput(item) {
-    const sourceState = item.state === 'open' ? 'open' : 'closed';
-    return {
-        sourceId: String(item.number),
-        name: item.title,
-        description: item.body ?? null,
-        sourceUrl: item.html_url,
-        sourceState,
-        sourceUpdatedAt: item.updated_at,
-        sourceData: {
-            number: item.number,
-            state: item.state,
-            updated_at: item.updated_at,
-            html_url: item.html_url,
-        },
-        initialStatus: sourceState === 'open' ? 'backlog' : 'archived',
-    };
-}
-export async function syncGithubIssues(options) {
-    const { productId, githubToken, owner, repo, verbose } = options;
-    const lock = acquireSyncGithubIssuesLock(productId);
-    if (!lock) {
-        return {
-            status: 'error',
-            message: 'Another GitHub sync is already running for this product',
-        };
-    }
-    // Capture the cutoff BEFORE any mutating work. The deletion sweep at
-    // the end uses this to identify rows we didn't touch in this run.
-    const syncStartedAt = new Date().toISOString();
-    try {
-        updateSyncGithubIssuesState(productId, {
-            lastAttemptedAt: syncStartedAt,
-        });
-        logInfo(`Syncing GitHub issues for ${owner}/${repo} → product ${productId}`);
-        const octokit = buildOctokit(githubToken);
-        const remoteIssues = await fetchAllRepoIssues(octokit, owner, repo);
-        logInfo(`Fetched ${remoteIssues.length} issues from GitHub`);
-        if (verbose) {
-            // Note: the listing is purely informational. We deliberately don't
-            // pre-load existing rows for diff purposes — the RPC does that
-            // server-side per row, with the right hash logic.
-            logInfo(`Will upsert ${remoteIssues.length} issues in batches`);
-        }
-        const inputs = remoteIssues.map(toUpsertInput);
-        const { result, failedBatches } = await upsertInBatches(productId, 'github', inputs, (error, batchIndex) => {
-            logError(`Batch ${batchIndex} failed: ${error.message}`);
-        });
-        let deletedCount = 0;
-        if (failedBatches === 0) {
-            // All batches succeeded — safe to sweep stale rows.
-            deletedCount = await markExternalIssuesDeletedSince(productId, 'github', syncStartedAt);
-        }
-        else {
-            logWarning(`Skipping deletion sweep: ${failedBatches} batch(es) failed; would risk wrongly flagging live issues as deleted`);
-        }
-        updateSyncGithubIssuesState(productId, {
-            lastSyncedAt: new Date().toISOString(),
-            lastRepoFullName: `${owner}/${repo}`,
-            lastError: failedBatches > 0
-                ? `${failedBatches} batch(es) failed during sync`
-                : undefined,
-        });
-        const summary = `created=${result.created} updated=${result.updated} refreshed=${result.refreshed} deleted=${deletedCount}${failedBatches > 0 ? ` (${failedBatches} batch(es) failed)` : ''}`;
-        if (failedBatches === 0) {
-            logSuccess(`GitHub sync complete: ${summary}`);
-        }
-        else {
-            logWarning(`GitHub sync completed with errors: ${summary}`);
-        }
-        return {
-            status: failedBatches === 0 ? 'success' : 'error',
-            message: summary,
-            repository: `${owner}/${repo}`,
-            fetchedCount: remoteIssues.length,
-            createdCount: result.created,
-            updatedCount: result.updated,
-            refreshedCount: result.refreshed,
-            deletedCount,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`GitHub sync failed: ${errorMessage}`);
-        updateSyncGithubIssuesState(productId, { lastError: errorMessage });
-        return {
-            status: 'error',
-            message: `GitHub sync failed: ${errorMessage}`,
-        };
-    }
-    finally {
-        lock.release();
-    }
-}

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

@@ -1,26 +0,0 @@
-/**
- * Per-product sync state for sync-github-issues. Stored at
- * `~/.edsger/sync-github-issues-state/<productId>.json`.
- *
- * The cursor is reserved for a future incremental-sync optimisation. The
- * current implementation does a full pull on every run because GitHub's
- * `since` filter doesn't surface deletions; we keep the field around so we
- * can add a hybrid (incremental updates + periodic full sweep) later
- * without another schema bump.
- */
-import { type LockHandle } from '../find-shared/scan-state.js';
-export type { LockHandle };
-export interface SyncGithubIssuesState {
-    /** ISO timestamp of the last successful sync. */
-    lastSyncedAt?: string;
-    /** ISO timestamp we last attempted (success or fail). */
-    lastAttemptedAt?: string;
-    /** Last error message, if the most recent run failed. */
-    lastError?: string;
-    /** GitHub repo we last synced from, as "owner/repo". */
-    lastRepoFullName?: string;
-}
-export declare const loadSyncGithubIssuesState: (productId: string) => SyncGithubIssuesState;
-export declare const saveSyncGithubIssuesState: (productId: string, state: SyncGithubIssuesState) => void;
-export declare const updateSyncGithubIssuesState: (productId: string, patch: Partial<SyncGithubIssuesState>) => SyncGithubIssuesState;
-export declare const acquireSyncGithubIssuesLock: (productId: string, staleAfterMs?: number) => LockHandle | null;

package/dist/phases/sync-github-issues/state.js

@@ -1,18 +0,0 @@
-/**
- * Per-product sync state for sync-github-issues. Stored at
- * `~/.edsger/sync-github-issues-state/<productId>.json`.
- *
- * The cursor is reserved for a future incremental-sync optimisation. The
- * current implementation does a full pull on every run because GitHub's
- * `since` filter doesn't surface deletions; we keep the field around so we
- * can add a hybrid (incremental updates + periodic full sweep) later
- * without another schema bump.
- */
-import { createScanStateModule, } from '../find-shared/scan-state.js';
-const m = createScanStateModule({
-    dirName: 'sync-github-issues-state',
-});
-export const loadSyncGithubIssuesState = m.load;
-export const saveSyncGithubIssuesState = m.save;
-export const updateSyncGithubIssuesState = m.update;
-export const acquireSyncGithubIssuesLock = m.acquireLock;

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

@@ -1,35 +0,0 @@
-/**
- * Shared types for sync-github-issues. Kept in their own file so the diff
- * helper can import them without dragging in MCP/Octokit deps (matters for
- * unit tests and tree-shaking).
- */
-/**
- * Subset of the GitHub Issues API response we actually care about.
- * Defined locally so unit tests don't need @octokit installed.
- */
-export interface GitHubIssueLite {
-    number: number;
-    title: string;
-    body: string | null | undefined;
-    state: 'open' | 'closed' | string;
-    html_url: string;
-    updated_at: string;
-    /** Present iff GitHub returned this row as a Pull Request, not an Issue. */
-    pull_request?: unknown;
-}
-export interface SyncResult {
-    status: 'success' | 'error';
-    message: string;
-    /** owner/repo we synced from. */
-    repository?: string;
-    /** Total issues fetched from GitHub (after PR filter). */
-    fetchedCount?: number;
-    /** New rows inserted locally. */
-    createdCount?: number;
-    /** Existing rows whose remote payload had advanced and were updated. */
-    updatedCount?: number;
-    /** Existing rows whose source_state was refreshed without payload change. */
-    refreshedCount?: number;
-    /** Rows we flagged as deleted because they no longer exist on GitHub. */
-    deletedCount?: number;
-}

package/dist/phases/sync-github-issues/types.js

@@ -1,6 +0,0 @@
-/**
- * Shared types for sync-github-issues. Kept in their own file so the diff
- * helper can import them without dragging in MCP/Octokit deps (matters for
- * unit tests and tree-shaking).
- */
-export {};

package/dist/phases/sync-github-pull-requests/index.d.ts

@@ -1,23 +0,0 @@
-/**
- * sync-github-pull-requests phase: pull every pull request from a repository's
- * connected GitHub repo and mirror them into the `pull_requests` table scoped
- * by `repository_id`. Deterministic — no Claude Agent SDK; plain Octokit plus
- * the user's RLS-scoped Supabase session.
- *
- * Idempotent: rows are keyed on (repository_id, pull_request_number). New PRs
- * are inserted, and the GitHub-owned fields (status/title/description) of
- * already-synced PRs are refreshed. Re-running never duplicates a PR.
- */
-import { Octokit } from '@octokit/rest';
-import { type GitHubPullRequestLite, type SyncPullRequestsResult } from './types.js';
-export interface SyncGithubPullRequestsOptions {
-    repositoryId: string;
-    /** GitHub installation token (or PAT). */
-    githubToken: string;
-    owner: string;
-    repo: string;
-    verbose?: boolean;
-}
-/** Pull every pull request from the repo, paginated (state=all). */
-export declare function fetchAllRepoPullRequests(octokit: Octokit, owner: string, repo: string): Promise<GitHubPullRequestLite[]>;
-export declare function syncGithubPullRequests(options: SyncGithubPullRequestsOptions): Promise<SyncPullRequestsResult>;

package/dist/phases/sync-github-pull-requests/index.js

@@ -1,210 +0,0 @@
-/**
- * sync-github-pull-requests phase: pull every pull request from a repository's
- * connected GitHub repo and mirror them into the `pull_requests` table scoped
- * by `repository_id`. Deterministic — no Claude Agent SDK; plain Octokit plus
- * the user's RLS-scoped Supabase session.
- *
- * Idempotent: rows are keyed on (repository_id, pull_request_number). New PRs
- * are inserted, and the GitHub-owned fields (status/title/description) of
- * already-synced PRs are refreshed. Re-running never duplicates a PR.
- */
-import { retry } from '@octokit/plugin-retry';
-import { throttling } from '@octokit/plugin-throttling';
-import { Octokit } from '@octokit/rest';
-import { ensureSupabaseSession, getSupabase } from '../../supabase/client.js';
-import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { acquireSyncGithubPullRequestsLock, updateSyncGithubPullRequestsState, } from './state.js';
-// The plugins use `@octokit/core` 7.x types, while @octokit/rest@20 hoists
-// to core 5.x at the workspace root. Runtime is fine; the cast tells TS to
-// accept the plugin chain (same pattern as sync-github-issues).
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- octokit version drift across the workspace
-const ResilientOctokit = Octokit.plugin(retry, throttling);
-/** GitHub list-pulls max page size. */
-const PER_PAGE = 100;
-/** Build an Octokit instance with retry + throttling configured for sync. */
-function buildOctokit(token) {
-    return new ResilientOctokit({
-        auth: token,
-        retry: { doNotRetry: [400, 401, 403, 404, 422] },
-        throttle: {
-            onRateLimit: (retryAfter, options) => {
-                logWarning(`GitHub rate limit hit on ${options.method ?? '?'} ${options.url ?? '?'} — retry in ${retryAfter}s`);
-                return (options.request?.retryCount ?? 0) < 2;
-            },
-            onSecondaryRateLimit: (retryAfter, options) => {
-                logWarning(`GitHub secondary rate limit on ${options.method ?? '?'} ${options.url ?? '?'} — retry in ${retryAfter}s`);
-                return true;
-            },
-        },
-    });
-}
-/** Pull every pull request from the repo, paginated (state=all). */
-export async function fetchAllRepoPullRequests(octokit, owner, repo) {
-    const all = [];
-    let page = 1;
-    for (;;) {
-        const { data } = await octokit.request('GET /repos/{owner}/{repo}/pulls', {
-            owner,
-            repo,
-            state: 'all',
-            per_page: PER_PAGE,
-            page,
-            sort: 'created',
-            direction: 'asc',
-        });
-        if (data.length === 0) {
-            break;
-        }
-        all.push(...data);
-        if (data.length < PER_PAGE) {
-            break;
-        }
-        page += 1;
-    }
-    return all;
-}
-/** Map a GitHub PR's open/closed/merged state to our PR status enum. */
-function toStatus(pr) {
-    if (pr.merged_at) {
-        return 'merged';
-    }
-    if (pr.state === 'closed') {
-        return 'closed';
-    }
-    return 'pr_opened';
-}
-export async function syncGithubPullRequests(options) {
-    const { repositoryId, githubToken, owner, repo, verbose } = options;
-    // Guard against two concurrent syncs of the same repo racing into duplicate
-    // inserts (the unique index would reject the loser, but failing fast is
-    // friendlier than surfacing a constraint error).
-    const lock = acquireSyncGithubPullRequestsLock(repositoryId);
-    if (!lock) {
-        return {
-            status: 'error',
-            message: 'Another GitHub pull request sync is already running for this repository',
-        };
-    }
-    try {
-        updateSyncGithubPullRequestsState(repositoryId, {
-            lastAttemptedAt: new Date().toISOString(),
-        });
-        const ready = await ensureSupabaseSession();
-        if (!ready) {
-            return {
-                status: 'error',
-                message: 'Supabase session unavailable. Sign in to the Edsger desktop app to authorize the CLI.',
-            };
-        }
-        const supabase = getSupabase();
-        logInfo(`Syncing GitHub pull requests for ${owner}/${repo} → repository ${repositoryId}`);
-        const octokit = buildOctokit(githubToken);
-        const remotePRs = await fetchAllRepoPullRequests(octokit, owner, repo);
-        logInfo(`Fetched ${remotePRs.length} pull requests from GitHub`);
-        // Existing repo-scoped PRs, keyed by GitHub PR number, so we never create
-        // a duplicate of one that was synced in a previous run.
-        const { data: existingRows, error: existingError } = await supabase
-            .from('pull_requests')
-            .select('id, pull_request_number, status, name, description')
-            .eq('repository_id', repositoryId);
-        if (existingError) {
-            throw new Error(`Failed to read existing pull requests: ${existingError.message}`);
-        }
-        const existingByNumber = new Map();
-        for (const row of existingRows ?? []) {
-            if (row.pull_request_number !== null) {
-                existingByNumber.set(row.pull_request_number, {
-                    id: row.id,
-                    status: row.status,
-                    name: row.name,
-                    description: row.description,
-                });
-            }
-        }
-        const toInsert = [];
-        const toUpdate = [];
-        for (const pr of remotePRs) {
-            const status = toStatus(pr);
-            const existing = existingByNumber.get(pr.number);
-            if (!existing) {
-                toInsert.push({
-                    repository_id: repositoryId,
-                    sequence: pr.number,
-                    name: pr.title,
-                    description: pr.body ?? null,
-                    branch_name: pr.head?.ref ?? null,
-                    pull_request_url: pr.html_url,
-                    pull_request_number: pr.number,
-                    status,
-                });
-                continue;
-            }
-            // Refresh GitHub-owned fields when they drift (e.g. PR got merged/closed).
-            const patch = {};
-            if (existing.status !== status) {
-                patch.status = status;
-            }
-            if (existing.name !== pr.title) {
-                patch.name = pr.title;
-            }
-            if ((existing.description ?? null) !== (pr.body ?? null)) {
-                patch.description = pr.body ?? null;
-            }
-            if (Object.keys(patch).length > 0) {
-                toUpdate.push({ id: existing.id, patch });
-            }
-        }
-        let createdCount = 0;
-        if (toInsert.length > 0) {
-            const { error: insertError } = await supabase
-                .from('pull_requests')
-                .insert(toInsert);
-            if (insertError) {
-                throw new Error(`Failed to insert pull requests: ${insertError.message}`);
-            }
-            createdCount = toInsert.length;
-            if (verbose) {
-                logInfo(`Inserted ${createdCount} new pull requests`);
-            }
-        }
-        let updatedCount = 0;
-        for (const { id, patch } of toUpdate) {
-            const { error: updateError } = await supabase
-                .from('pull_requests')
-                .update({ ...patch, updated_at: new Date().toISOString() })
-                .eq('id', id);
-            if (updateError) {
-                logWarning(`Failed to refresh pull request ${id}: ${updateError.message}`);
-                continue;
-            }
-            updatedCount++;
-        }
-        const summary = `fetched=${remotePRs.length} created=${createdCount} updated=${updatedCount}`;
-        logSuccess(`GitHub PR sync complete: ${summary}`);
-        updateSyncGithubPullRequestsState(repositoryId, {
-            lastSyncedAt: new Date().toISOString(),
-            lastRepoFullName: `${owner}/${repo}`,
-            lastError: undefined,
-        });
-        return {
-            status: 'success',
-            message: summary,
-            repository: `${owner}/${repo}`,
-            fetchedCount: remotePRs.length,
-            createdCount,
-            updatedCount,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`GitHub PR sync failed: ${errorMessage}`);
-        updateSyncGithubPullRequestsState(repositoryId, { lastError: errorMessage });
-        return {
-            status: 'error',
-            message: `GitHub PR sync failed: ${errorMessage}`,
-        };
-    }
-    finally {
-        lock.release();
-    }
-}

package/dist/phases/sync-github-pull-requests/state.d.ts

@@ -1,24 +0,0 @@
-/**
- * Per-repository sync state for sync-github-pull-requests. Stored at
- * `~/.edsger/sync-github-pull-requests-state/<repositoryId>.json`.
- *
- * The lock guards against two concurrent syncs of the same repository racing
- * each other into duplicate inserts. State fields track the last run for
- * diagnostics and a future incremental-sync optimisation.
- */
-import { type LockHandle } from '../find-shared/scan-state.js';
-export type { LockHandle };
-export interface SyncGithubPullRequestsState {
-    /** ISO timestamp of the last successful sync. */
-    lastSyncedAt?: string;
-    /** ISO timestamp we last attempted (success or fail). */
-    lastAttemptedAt?: string;
-    /** Last error message, if the most recent run failed. */
-    lastError?: string;
-    /** GitHub repo we last synced from, as "owner/repo". */
-    lastRepoFullName?: string;
-}
-export declare const loadSyncGithubPullRequestsState: (productId: string) => SyncGithubPullRequestsState;
-export declare const saveSyncGithubPullRequestsState: (productId: string, state: SyncGithubPullRequestsState) => void;
-export declare const updateSyncGithubPullRequestsState: (productId: string, patch: Partial<SyncGithubPullRequestsState>) => SyncGithubPullRequestsState;
-export declare const acquireSyncGithubPullRequestsLock: (productId: string, staleAfterMs?: number) => LockHandle | null;

package/dist/phases/sync-github-pull-requests/state.js

@@ -1,16 +0,0 @@
-/**
- * Per-repository sync state for sync-github-pull-requests. Stored at
- * `~/.edsger/sync-github-pull-requests-state/<repositoryId>.json`.
- *
- * The lock guards against two concurrent syncs of the same repository racing
- * each other into duplicate inserts. State fields track the last run for
- * diagnostics and a future incremental-sync optimisation.
- */
-import { createScanStateModule, } from '../find-shared/scan-state.js';
-const m = createScanStateModule({
-    dirName: 'sync-github-pull-requests-state',
-});
-export const loadSyncGithubPullRequestsState = m.load;
-export const saveSyncGithubPullRequestsState = m.save;
-export const updateSyncGithubPullRequestsState = m.update;
-export const acquireSyncGithubPullRequestsLock = m.acquireLock;

package/dist/phases/sync-github-pull-requests/types.d.ts

@@ -1,22 +0,0 @@
-/** Minimal shape of a GitHub pull request from the list endpoint. */
-export interface GitHubPullRequestLite {
-    number: number;
-    title: string;
-    body: string | null;
-    html_url: string;
-    state: string;
-    draft?: boolean;
-    merged_at: string | null;
-    updated_at: string;
-    head: {
-        ref: string;
-    };
-}
-export interface SyncPullRequestsResult {
-    status: 'success' | 'error';
-    message: string;
-    repository?: string;
-    fetchedCount?: number;
-    createdCount?: number;
-    updatedCount?: number;
-}

package/dist/phases/sync-github-pull-requests/types.js

@@ -1 +0,0 @@
-export {};

package/dist/phases/sync-org-repos/index.d.ts

@@ -1,28 +0,0 @@
-/**
- * Phase: sync-org-repos
- *
- * Fetches all repositories from a GitHub organization via the Edsger GitHub
- * App (server-side, through the MCP `github/org_repos` endpoint), then upserts
- * a row into the team-scoped `repositories` table for each repo. Products are
- * NOT created here — a product is a higher-level grouping that a user links one
- * or more repositories to afterwards.
- *
- * Repos are listed with a short-lived GitHub App installation token minted on
- * the server, so this no longer depends on the user's machine having the `gh`
- * CLI installed, authenticated, and on PATH. Forks and archived repos are
- * filtered out server-side.
- */
-export interface SyncOrgReposResult {
-    status: 'success' | 'error';
-    message: string;
-    total: number;
-    created: number;
-    skipped: number;
-    repos?: string[];
-}
-export declare function syncOrgRepos(opts: {
-    teamId: string;
-    orgLogin: string;
-    userId: string;
-    verbose?: boolean;
-}): Promise<SyncOrgReposResult>;