@renseiai/plugin-linear 0.8.6

package/dist/src/retry.d.ts

@@ -0,0 +1,59 @@
+import type { RetryConfig } from './types.js';
+/**
+ * Default retry configuration
+ */
+export declare const DEFAULT_RETRY_CONFIG: Required<RetryConfig>;
+/**
+ * Sleep utility for async delays
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Calculate delay for a given retry attempt with exponential backoff
+ */
+export declare function calculateDelay(attempt: number, config: Required<RetryConfig>): number;
+/**
+ * Retry context passed to callbacks
+ */
+export interface RetryContext {
+    attempt: number;
+    maxRetries: number;
+    lastError?: Error;
+    delay: number;
+}
+/**
+ * Callback for retry events
+ */
+export type RetryCallback = (context: RetryContext) => void;
+/**
+ * Options for withRetry function
+ */
+export interface WithRetryOptions {
+    config?: RetryConfig;
+    onRetry?: RetryCallback;
+    shouldRetry?: (error: unknown) => boolean;
+    /**
+     * Optional callback to extract a rate-limit delay (in ms) from an error.
+     * When provided and returns a positive number, that delay is used instead
+     * of the standard exponential backoff for that retry attempt.
+     */
+    getRetryAfterMs?: (error: unknown) => number | null;
+    /**
+     * Optional callback invoked when a rate limit is detected (getRetryAfterMs
+     * returned a value). Use this to penalize a shared token bucket so other
+     * concurrent callers also back off.
+     */
+    onRateLimited?: (retryAfterMs: number) => void;
+}
+/**
+ * Execute an async function with exponential backoff retry logic.
+ *
+ * When `getRetryAfterMs` is provided and returns a positive delay for an
+ * error, that delay is used instead of exponential backoff. This allows
+ * honoring HTTP 429 Retry-After headers from upstream APIs.
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options?: WithRetryOptions): Promise<T>;
+/**
+ * Create a retry wrapper with pre-configured options
+ */
+export declare function createRetryWrapper(defaultOptions?: WithRetryOptions): <T>(fn: () => Promise<T>, options?: WithRetryOptions) => Promise<T>;
+//# sourceMappingURL=retry.d.ts.map

package/dist/src/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/retry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAG7C;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAMtD,CAAA;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,GAC5B,MAAM,CAIR;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,KAAK,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,EAAE,YAAY,KAAK,IAAI,CAAA;AAE3D;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,OAAO,CAAC,EAAE,aAAa,CAAA;IACvB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAA;IACzC;;;;OAIG;IACH,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,GAAG,IAAI,CAAA;IACnD;;;;OAIG;IACH,aAAa,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,IAAI,CAAA;CAC/C;AAED;;;;;;GAMG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAC/B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,CAAC,CAAC,CA4CZ;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,cAAc,GAAE,gBAAqB,IACrD,CAAC,EAChB,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,UAAU,gBAAgB,KACzB,OAAO,CAAC,CAAC,CAAC,CAUd"}

package/dist/src/retry.js

@@ -0,0 +1,82 @@
+import { isRetryableError } from './errors.js';
+/**
+ * Default retry configuration
+ */
+export const DEFAULT_RETRY_CONFIG = {
+    maxRetries: 3,
+    initialDelayMs: 1000,
+    backoffMultiplier: 2,
+    maxDelayMs: 10000,
+    retryableStatusCodes: [429, 500, 502, 503, 504],
+};
+/**
+ * Sleep utility for async delays
+ */
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Calculate delay for a given retry attempt with exponential backoff
+ */
+export function calculateDelay(attempt, config) {
+    const delay = config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt);
+    return Math.min(delay, config.maxDelayMs);
+}
+/**
+ * Execute an async function with exponential backoff retry logic.
+ *
+ * When `getRetryAfterMs` is provided and returns a positive delay for an
+ * error, that delay is used instead of exponential backoff. This allows
+ * honoring HTTP 429 Retry-After headers from upstream APIs.
+ */
+export async function withRetry(fn, options = {}) {
+    const config = {
+        ...DEFAULT_RETRY_CONFIG,
+        ...options.config,
+    };
+    const shouldRetry = options.shouldRetry ??
+        ((error) => isRetryableError(error, config.retryableStatusCodes));
+    let lastError = new Error('Unknown error');
+    for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt === config.maxRetries || !shouldRetry(error)) {
+                throw lastError;
+            }
+            // Check for rate-limit-specific delay (Retry-After)
+            const retryAfterMs = options.getRetryAfterMs?.(error) ?? null;
+            const delay = retryAfterMs ?? calculateDelay(attempt, config);
+            if (retryAfterMs !== null && options.onRateLimited) {
+                options.onRateLimited(retryAfterMs);
+            }
+            if (options.onRetry) {
+                options.onRetry({
+                    attempt,
+                    maxRetries: config.maxRetries,
+                    lastError,
+                    delay,
+                });
+            }
+            await sleep(delay);
+        }
+    }
+    throw lastError;
+}
+/**
+ * Create a retry wrapper with pre-configured options
+ */
+export function createRetryWrapper(defaultOptions = {}) {
+    return function (fn, options) {
+        return withRetry(fn, {
+            ...defaultOptions,
+            ...options,
+            config: {
+                ...defaultOptions.config,
+                ...options?.config,
+            },
+        });
+    };
+}

package/dist/src/retry.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=retry.test.d.ts.map

package/dist/src/retry.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.test.d.ts","sourceRoot":"","sources":["../../src/retry.test.ts"],"names":[],"mappings":""}

package/dist/src/retry.test.js

@@ -0,0 +1,266 @@
+import { describe, it, expect, vi } from 'vitest';
+import { calculateDelay, withRetry, createRetryWrapper, DEFAULT_RETRY_CONFIG, } from './retry.js';
+// Use very short delays to avoid real waits in tests
+const fastConfig = {
+    maxRetries: 3,
+    initialDelayMs: 1,
+    backoffMultiplier: 2,
+    maxDelayMs: 1,
+    retryableStatusCodes: [429, 500, 502, 503, 504],
+};
+// ============================================================================
+// calculateDelay
+// ============================================================================
+describe('calculateDelay', () => {
+    const config = {
+        maxRetries: 3,
+        initialDelayMs: 1000,
+        backoffMultiplier: 2,
+        maxDelayMs: 10000,
+        retryableStatusCodes: [429, 500, 502, 503, 504],
+    };
+    it('returns initialDelayMs for attempt 0', () => {
+        expect(calculateDelay(0, config)).toBe(1000);
+    });
+    it('returns initialDelayMs * backoffMultiplier for attempt 1', () => {
+        expect(calculateDelay(1, config)).toBe(2000);
+    });
+    it('returns initialDelayMs * backoffMultiplier^2 for attempt 2', () => {
+        expect(calculateDelay(2, config)).toBe(4000);
+    });
+    it('caps at maxDelayMs', () => {
+        // attempt 4 would be 1000 * 2^4 = 16000, but max is 10000
+        expect(calculateDelay(4, config)).toBe(10000);
+    });
+    it('works with custom config values', () => {
+        const custom = {
+            maxRetries: 5,
+            initialDelayMs: 500,
+            backoffMultiplier: 3,
+            maxDelayMs: 20000,
+            retryableStatusCodes: [],
+        };
+        // attempt 0: 500
+        expect(calculateDelay(0, custom)).toBe(500);
+        // attempt 1: 500 * 3 = 1500
+        expect(calculateDelay(1, custom)).toBe(1500);
+        // attempt 2: 500 * 9 = 4500
+        expect(calculateDelay(2, custom)).toBe(4500);
+        // attempt 3: 500 * 27 = 13500
+        expect(calculateDelay(3, custom)).toBe(13500);
+        // attempt 4: 500 * 81 = 40500, capped at 20000
+        expect(calculateDelay(4, custom)).toBe(20000);
+    });
+});
+// ============================================================================
+// withRetry
+// ============================================================================
+describe('withRetry', () => {
+    it('succeeds on first attempt without retrying', async () => {
+        const fn = vi.fn().mockResolvedValue('ok');
+        const result = await withRetry(fn, { config: fastConfig });
+        expect(result).toBe('ok');
+        expect(fn).toHaveBeenCalledTimes(1);
+    });
+    it('succeeds on 2nd attempt after 1 failure', async () => {
+        const fn = vi
+            .fn()
+            .mockRejectedValueOnce(new Error('ECONNRESET'))
+            .mockResolvedValue('ok');
+        const result = await withRetry(fn, {
+            config: fastConfig,
+            shouldRetry: () => true,
+        });
+        expect(result).toBe('ok');
+        expect(fn).toHaveBeenCalledTimes(2);
+    });
+    it('succeeds on nth attempt', async () => {
+        const fn = vi
+            .fn()
+            .mockRejectedValueOnce(new Error('fail 1'))
+            .mockRejectedValueOnce(new Error('fail 2'))
+            .mockRejectedValueOnce(new Error('fail 3'))
+            .mockResolvedValue('ok');
+        const result = await withRetry(fn, {
+            config: fastConfig,
+            shouldRetry: () => true,
+        });
+        expect(result).toBe('ok');
+        expect(fn).toHaveBeenCalledTimes(4);
+    });
+    it('throws after exhausting all retries', async () => {
+        const fn = vi.fn().mockRejectedValue(new Error('persistent failure'));
+        await expect(withRetry(fn, {
+            config: { ...fastConfig, maxRetries: 2 },
+            shouldRetry: () => true,
+        })).rejects.toThrow('persistent failure');
+        // attempt 0, 1, 2 = 3 calls total
+        expect(fn).toHaveBeenCalledTimes(3);
+    });
+    it('calls onRetry callback on each retry', async () => {
+        const onRetry = vi.fn();
+        const fn = vi
+            .fn()
+            .mockRejectedValueOnce(new Error('fail 1'))
+            .mockRejectedValueOnce(new Error('fail 2'))
+            .mockResolvedValue('ok');
+        await withRetry(fn, {
+            config: fastConfig,
+            shouldRetry: () => true,
+            onRetry,
+        });
+        expect(onRetry).toHaveBeenCalledTimes(2);
+        // First retry: attempt 0
+        expect(onRetry).toHaveBeenNthCalledWith(1, {
+            attempt: 0,
+            maxRetries: fastConfig.maxRetries,
+            lastError: expect.objectContaining({ message: 'fail 1' }),
+            delay: expect.any(Number),
+        });
+        // Second retry: attempt 1
+        expect(onRetry).toHaveBeenNthCalledWith(2, {
+            attempt: 1,
+            maxRetries: fastConfig.maxRetries,
+            lastError: expect.objectContaining({ message: 'fail 2' }),
+            delay: expect.any(Number),
+        });
+    });
+    it('respects custom shouldRetry predicate and stops retrying when false', async () => {
+        const fn = vi
+            .fn()
+            .mockRejectedValueOnce(new Error('retryable'))
+            .mockRejectedValueOnce(new Error('not retryable'))
+            .mockResolvedValue('ok');
+        const shouldRetry = vi
+            .fn()
+            .mockReturnValueOnce(true)
+            .mockReturnValueOnce(false);
+        await expect(withRetry(fn, { config: fastConfig, shouldRetry })).rejects.toThrow('not retryable');
+        expect(fn).toHaveBeenCalledTimes(2);
+        expect(shouldRetry).toHaveBeenCalledTimes(2);
+    });
+    it('does not retry when shouldRetry returns false for specific error', async () => {
+        const fn = vi.fn().mockRejectedValue(new Error('fatal'));
+        await expect(withRetry(fn, {
+            config: fastConfig,
+            shouldRetry: () => false,
+        })).rejects.toThrow('fatal');
+        expect(fn).toHaveBeenCalledTimes(1);
+    });
+    it('uses getRetryAfterMs delay when provided', async () => {
+        const onRetry = vi.fn();
+        const fn = vi
+            .fn()
+            .mockRejectedValueOnce(new Error('rate limited'))
+            .mockResolvedValue('ok');
+        await withRetry(fn, {
+            config: fastConfig,
+            shouldRetry: () => true,
+            getRetryAfterMs: () => 5,
+            onRetry,
+        });
+        expect(fn).toHaveBeenCalledTimes(2);
+        // The delay should be the value from getRetryAfterMs (5), not the calculated backoff
+        expect(onRetry).toHaveBeenCalledWith(expect.objectContaining({ delay: 5 }));
+    });
+    it('calls onRateLimited when getRetryAfterMs returns a value', async () => {
+        const onRateLimited = vi.fn();
+        const fn = vi
+            .fn()
+            .mockRejectedValueOnce(new Error('rate limited'))
+            .mockResolvedValue('ok');
+        await withRetry(fn, {
+            config: fastConfig,
+            shouldRetry: () => true,
+            getRetryAfterMs: () => 42,
+            onRateLimited,
+        });
+        expect(onRateLimited).toHaveBeenCalledTimes(1);
+        expect(onRateLimited).toHaveBeenCalledWith(42);
+    });
+    it('does not call onRateLimited when getRetryAfterMs returns null', async () => {
+        const onRateLimited = vi.fn();
+        const fn = vi
+            .fn()
+            .mockRejectedValueOnce(new Error('network error'))
+            .mockResolvedValue('ok');
+        await withRetry(fn, {
+            config: fastConfig,
+            shouldRetry: () => true,
+            getRetryAfterMs: () => null,
+            onRateLimited,
+        });
+        expect(onRateLimited).not.toHaveBeenCalled();
+    });
+    it('wraps non-Error thrown values into Error objects', async () => {
+        const fn = vi.fn().mockRejectedValue('string error');
+        await expect(withRetry(fn, {
+            config: { ...fastConfig, maxRetries: 0 },
+            shouldRetry: () => true,
+        })).rejects.toThrow('string error');
+    });
+});
+// ============================================================================
+// createRetryWrapper
+// ============================================================================
+describe('createRetryWrapper', () => {
+    it('creates a wrapper that uses default options', async () => {
+        const onRetry = vi.fn();
+        const retryFn = createRetryWrapper({
+            config: fastConfig,
+            shouldRetry: () => true,
+            onRetry,
+        });
+        const fn = vi
+            .fn()
+            .mockRejectedValueOnce(new Error('fail'))
+            .mockResolvedValue('ok');
+        const result = await retryFn(fn);
+        expect(result).toBe('ok');
+        expect(onRetry).toHaveBeenCalledTimes(1);
+    });
+    it('allows overriding defaults per call', async () => {
+        const defaultOnRetry = vi.fn();
+        const callOnRetry = vi.fn();
+        const retryFn = createRetryWrapper({
+            config: fastConfig,
+            shouldRetry: () => true,
+            onRetry: defaultOnRetry,
+        });
+        const fn = vi
+            .fn()
+            .mockRejectedValueOnce(new Error('fail'))
+            .mockResolvedValue('ok');
+        await retryFn(fn, { onRetry: callOnRetry });
+        // Per-call onRetry should override the default
+        expect(callOnRetry).toHaveBeenCalledTimes(1);
+        expect(defaultOnRetry).not.toHaveBeenCalled();
+    });
+    it('merges config from defaults and per-call overrides', async () => {
+        const onRetry = vi.fn();
+        const retryFn = createRetryWrapper({
+            config: { ...fastConfig, maxRetries: 5 },
+            shouldRetry: () => true,
+            onRetry,
+        });
+        const fn = vi.fn().mockRejectedValue(new Error('fail'));
+        // Override maxRetries to 1 per call
+        await expect(retryFn(fn, { config: { maxRetries: 1 } })).rejects.toThrow('fail');
+        // 2 calls: attempt 0 + attempt 1
+        expect(fn).toHaveBeenCalledTimes(2);
+    });
+});
+// ============================================================================
+// DEFAULT_RETRY_CONFIG
+// ============================================================================
+describe('DEFAULT_RETRY_CONFIG', () => {
+    it('has expected default values', () => {
+        expect(DEFAULT_RETRY_CONFIG).toEqual({
+            maxRetries: 3,
+            initialDelayMs: 1000,
+            backoffMultiplier: 2,
+            maxDelayMs: 10000,
+            retryableStatusCodes: [429, 500, 502, 503, 504],
+        });
+    });
+});

package/dist/src/tools/deployment-bridge.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Deployment Status Checker
+ *
+ * Queries GitHub commit status API for Vercel deployment state.
+ * Used to verify deployments before QA/acceptance work can proceed.
+ *
+ * Self-contained — no dependency on @renseiai/agentfactory core.
+ * Originally in packages/core/src/deployment/deployment-checker.ts;
+ * duplicated here to keep the linear plugin fully decoupled from core.
+ */
+export interface DeploymentStatus {
+    app: string;
+    state: 'success' | 'pending' | 'error' | 'failure';
+    description: string;
+    targetUrl: string | null;
+    context: string;
+}
+export interface DeploymentCheckResult {
+    allSucceeded: boolean;
+    anyFailed: boolean;
+    anyPending: boolean;
+    statuses: DeploymentStatus[];
+    commitSha: string;
+    overallState: string;
+}
+interface DeploymentCheckOptions {
+    owner?: string;
+    repo?: string;
+    timeout?: number;
+}
+export declare function checkPRDeploymentStatus(prNumber: number, options?: DeploymentCheckOptions): Promise<DeploymentCheckResult | null>;
+export declare function formatDeploymentStatus(result: DeploymentCheckResult): string;
+export {};
+//# sourceMappingURL=deployment-bridge.d.ts.map

package/dist/src/tools/deployment-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployment-bridge.d.ts","sourceRoot":"","sources":["../../../src/tools/deployment-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAOH,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAA;IAClD,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,YAAY,EAAE,OAAO,CAAA;IACrB,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,QAAQ,EAAE,gBAAgB,EAAE,CAAA;IAC5B,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,UAAU,sBAAsB;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AA2FD,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAIvC;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,qBAAqB,GAAG,MAAM,CAmD5E"}

package/dist/src/tools/deployment-bridge.js

@@ -0,0 +1,122 @@
+/**
+ * Deployment Status Checker
+ *
+ * Queries GitHub commit status API for Vercel deployment state.
+ * Used to verify deployments before QA/acceptance work can proceed.
+ *
+ * Self-contained — no dependency on @renseiai/agentfactory core.
+ * Originally in packages/core/src/deployment/deployment-checker.ts;
+ * duplicated here to keep the linear plugin fully decoupled from core.
+ */
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+const DEFAULT_OPTIONS = {
+    owner: 'renseiai',
+    repo: 'agentfactory',
+    timeout: 30000,
+};
+function parseAppName(context) {
+    const match = context.match(/Vercel\s*[–-]\s*(.+)/);
+    return match ? match[1].trim() : context;
+}
+function isSuccessfulSkip(description) {
+    return description.toLowerCase().includes('skipped') &&
+        description.toLowerCase().includes('not affected');
+}
+function normalizeState(state, description) {
+    if (isSuccessfulSkip(description))
+        return 'success';
+    switch (state.toLowerCase()) {
+        case 'success': return 'success';
+        case 'pending': return 'pending';
+        case 'failure': return 'failure';
+        case 'error': return 'error';
+        default: return 'pending';
+    }
+}
+async function getPRHeadSha(prNumber, options = {}) {
+    const { owner, repo, timeout } = { ...DEFAULT_OPTIONS, ...options };
+    try {
+        const { stdout } = await execAsync(`gh api repos/${owner}/${repo}/pulls/${prNumber} --jq '.head.sha'`, { timeout });
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function checkDeploymentStatus(commitSha, options = {}) {
+    const { owner, repo, timeout } = { ...DEFAULT_OPTIONS, ...options };
+    const { stdout } = await execAsync(`gh api repos/${owner}/${repo}/commits/${commitSha}/status`, { timeout });
+    const response = JSON.parse(stdout);
+    const allStatuses = response.statuses || [];
+    const vercelStatuses = allStatuses.filter((s) => s.context.toLowerCase().includes('vercel'));
+    const deploymentStatuses = vercelStatuses.map((s) => ({
+        app: parseAppName(s.context),
+        state: normalizeState(s.state, s.description || ''),
+        description: s.description || '',
+        targetUrl: s.target_url,
+        context: s.context,
+    }));
+    const allSucceeded = deploymentStatuses.length > 0 &&
+        deploymentStatuses.every((s) => s.state === 'success');
+    const anyFailed = deploymentStatuses.some((s) => s.state === 'failure' || s.state === 'error');
+    const anyPending = deploymentStatuses.some((s) => s.state === 'pending');
+    return {
+        allSucceeded,
+        anyFailed,
+        anyPending,
+        statuses: deploymentStatuses,
+        commitSha,
+        overallState: response.state || 'unknown',
+    };
+}
+export async function checkPRDeploymentStatus(prNumber, options = {}) {
+    const commitSha = await getPRHeadSha(prNumber, options);
+    if (!commitSha)
+        return null;
+    return checkDeploymentStatus(commitSha, options);
+}
+export function formatDeploymentStatus(result) {
+    const lines = [];
+    lines.push(`## Deployment Status Check`);
+    lines.push(``);
+    lines.push(`**Commit:** \`${result.commitSha.slice(0, 7)}\``);
+    lines.push(`**Overall State:** ${result.overallState}`);
+    lines.push(``);
+    if (result.statuses.length === 0) {
+        lines.push(`No Vercel deployments found for this commit.`);
+        return lines.join('\n');
+    }
+    lines.push(`| App | State | Description |`);
+    lines.push(`|-----|-------|-------------|`);
+    for (const status of result.statuses) {
+        const stateEmoji = {
+            success: '\u2705',
+            pending: '\u23F3',
+            failure: '\u274C',
+            error: '\u274C',
+        }[status.state];
+        const url = status.targetUrl
+            ? `[${status.app}](${status.targetUrl})`
+            : status.app;
+        lines.push(`| ${url} | ${stateEmoji} ${status.state} | ${status.description} |`);
+    }
+    lines.push(``);
+    if (result.anyFailed) {
+        lines.push(`### \u274C Deployment Failed`);
+        lines.push(``);
+        lines.push(`One or more Vercel deployments failed. QA/acceptance cannot proceed until deployments succeed.`);
+    }
+    else if (result.anyPending) {
+        lines.push(`### \u23F3 Deployment Pending`);
+        lines.push(``);
+        lines.push(`One or more Vercel deployments are still in progress.`);
+    }
+    else if (result.allSucceeded) {
+        lines.push(`### \u2705 All Deployments Succeeded`);
+        lines.push(``);
+        lines.push(`All Vercel deployments have completed successfully.`);
+    }
+    return lines.join('\n');
+}

package/dist/src/tools/linear-plugin.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Linear Tool Plugin
+ *
+ * Exposes all Linear CLI commands as typed, in-process agent tools.
+ * Agents call these directly instead of shelling out to `pnpm af-linear`.
+ *
+ * Moved from packages/core/src/tools/plugins/linear.ts to keep
+ * Linear-specific tool code in the Linear package.
+ */
+import { type SdkMcpToolDefinition } from '@anthropic-ai/claude-agent-sdk';
+/** A plugin that contributes agent tools from CLI functionality */
+export interface ToolPlugin {
+    name: string;
+    description: string;
+    createTools(context: ToolPluginContext): SdkMcpToolDefinition<any>[];
+}
+/** Context passed to plugins during tool creation */
+export interface ToolPluginContext {
+    env: Record<string, string>;
+    cwd: string;
+}
+export declare const linearPlugin: ToolPlugin;
+//# sourceMappingURL=linear-plugin.d.ts.map

package/dist/src/tools/linear-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear-plugin.d.ts","sourceRoot":"","sources":["../../../src/tools/linear-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAQ,KAAK,oBAAoB,EAAE,MAAM,gCAAgC,CAAA;AAQhF,mEAAmE;AACnE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,OAAO,EAAE,iBAAiB,GAAG,oBAAoB,CAAC,GAAG,CAAC,EAAE,CAAA;CACrE;AAED,qDAAqD;AACrD,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3B,GAAG,EAAE,MAAM,CAAA;CACZ;AAsOD,eAAO,MAAM,YAAY,EAAE,UAU1B,CAAA"}