@renseiai/agentfactory-linear 0.8.0

package/dist/src/checkbox-utils.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Checkbox Utilities
+ *
+ * Parse and update markdown checkboxes in Linear issue descriptions.
+ * Checkboxes follow the standard markdown format:
+ *   - [ ] Unchecked item
+ *   - [x] Checked item
+ */
+/**
+ * Represents a checkbox item parsed from markdown
+ */
+export interface CheckboxItem {
+    /** Zero-based index among all checkboxes in the document */
+    index: number;
+    /** Line number in the markdown (zero-based) */
+    line: number;
+    /** Whether the checkbox is checked */
+    checked: boolean;
+    /** The text content after the checkbox */
+    text: string;
+    /** Indentation level (number of leading spaces) */
+    indentLevel: number;
+    /** The raw line text */
+    raw: string;
+}
+/**
+ * Checkbox update specification
+ */
+export interface CheckboxUpdate {
+    /** Update checkbox by its index */
+    index?: number;
+    /** Update checkbox by matching text pattern */
+    textPattern?: string | RegExp;
+    /** New checked state */
+    checked: boolean;
+}
+/**
+ * Parse markdown and extract checkbox items
+ *
+ * @param markdown - The markdown content to parse
+ * @returns Array of checkbox items found in the markdown
+ */
+export declare function parseCheckboxes(markdown: string): CheckboxItem[];
+/**
+ * Update a checkbox by its index
+ *
+ * @param markdown - The markdown content
+ * @param index - The checkbox index to update
+ * @param checked - The new checked state
+ * @returns The updated markdown, or the original if checkbox not found
+ */
+export declare function updateCheckbox(markdown: string, index: number, checked: boolean): string;
+/**
+ * Update a checkbox by matching its text content
+ *
+ * @param markdown - The markdown content
+ * @param textPattern - String or regex to match against checkbox text
+ * @param checked - The new checked state
+ * @returns The updated markdown, or the original if no match found
+ */
+export declare function updateCheckboxByText(markdown: string, textPattern: string | RegExp, checked: boolean): string;
+/**
+ * Apply multiple checkbox updates at once
+ *
+ * @param markdown - The markdown content
+ * @param updates - Array of updates to apply
+ * @returns The updated markdown
+ */
+export declare function updateCheckboxes(markdown: string, updates: CheckboxUpdate[]): string;
+/**
+ * Check if markdown contains any checkboxes
+ *
+ * @param markdown - The markdown content to check
+ * @returns True if at least one checkbox is found
+ */
+export declare function hasCheckboxes(markdown: string): boolean;
+/**
+ * Get summary of checkbox states
+ *
+ * @param markdown - The markdown content
+ * @returns Object with counts of checked and unchecked items
+ */
+export declare function getCheckboxSummary(markdown: string): {
+    total: number;
+    checked: number;
+    unchecked: number;
+};
+//# sourceMappingURL=checkbox-utils.d.ts.map

package/dist/src/checkbox-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkbox-utils.d.ts","sourceRoot":"","sources":["../../src/checkbox-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAA;IACb,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAA;IACZ,sCAAsC;IACtC,OAAO,EAAE,OAAO,CAAA;IAChB,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAA;IACZ,mDAAmD;IACnD,WAAW,EAAE,MAAM,CAAA;IACnB,wBAAwB;IACxB,GAAG,EAAE,MAAM,CAAA;CACZ;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,mCAAmC;IACnC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC7B,wBAAwB;IACxB,OAAO,EAAE,OAAO,CAAA;CACjB;AAMD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,EAAE,CAuBhE;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,GACf,MAAM,CAaR;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAAG,MAAM,EAC5B,OAAO,EAAE,OAAO,GACf,MAAM,CAeR;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,cAAc,EAAE,GACxB,MAAM,CAYR;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGvD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG;IACpD,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;CAClB,CASA"}

package/dist/src/checkbox-utils.js

@@ -0,0 +1,120 @@
+/**
+ * Checkbox Utilities
+ *
+ * Parse and update markdown checkboxes in Linear issue descriptions.
+ * Checkboxes follow the standard markdown format:
+ *   - [ ] Unchecked item
+ *   - [x] Checked item
+ */
+// Regex to match markdown checkbox lines
+// Captures: (leading whitespace)(checkbox mark)(text content)
+const CHECKBOX_REGEX = /^(\s*)- \[([ xX])\] (.*)$/;
+/**
+ * Parse markdown and extract checkbox items
+ *
+ * @param markdown - The markdown content to parse
+ * @returns Array of checkbox items found in the markdown
+ */
+export function parseCheckboxes(markdown) {
+    const lines = markdown.split('\n');
+    const checkboxes = [];
+    let checkboxIndex = 0;
+    for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+        const line = lines[lineNum];
+        const match = line.match(CHECKBOX_REGEX);
+        if (match) {
+            const [, indent, mark, text] = match;
+            checkboxes.push({
+                index: checkboxIndex++,
+                line: lineNum,
+                indentLevel: indent.length,
+                checked: mark.toLowerCase() === 'x',
+                text: text.trim(),
+                raw: line,
+            });
+        }
+    }
+    return checkboxes;
+}
+/**
+ * Update a checkbox by its index
+ *
+ * @param markdown - The markdown content
+ * @param index - The checkbox index to update
+ * @param checked - The new checked state
+ * @returns The updated markdown, or the original if checkbox not found
+ */
+export function updateCheckbox(markdown, index, checked) {
+    const checkboxes = parseCheckboxes(markdown);
+    const checkbox = checkboxes.find((c) => c.index === index);
+    if (!checkbox) {
+        return markdown;
+    }
+    const lines = markdown.split('\n');
+    const newCheckmark = checked ? 'x' : ' ';
+    lines[checkbox.line] = checkbox.raw.replace(/\[([ xX])\]/, `[${newCheckmark}]`);
+    return lines.join('\n');
+}
+/**
+ * Update a checkbox by matching its text content
+ *
+ * @param markdown - The markdown content
+ * @param textPattern - String or regex to match against checkbox text
+ * @param checked - The new checked state
+ * @returns The updated markdown, or the original if no match found
+ */
+export function updateCheckboxByText(markdown, textPattern, checked) {
+    const checkboxes = parseCheckboxes(markdown);
+    const pattern = typeof textPattern === 'string'
+        ? new RegExp(textPattern, 'i')
+        : textPattern;
+    const checkbox = checkboxes.find((c) => pattern.test(c.text));
+    if (!checkbox) {
+        return markdown;
+    }
+    return updateCheckbox(markdown, checkbox.index, checked);
+}
+/**
+ * Apply multiple checkbox updates at once
+ *
+ * @param markdown - The markdown content
+ * @param updates - Array of updates to apply
+ * @returns The updated markdown
+ */
+export function updateCheckboxes(markdown, updates) {
+    let result = markdown;
+    for (const update of updates) {
+        if (update.index !== undefined) {
+            result = updateCheckbox(result, update.index, update.checked);
+        }
+        else if (update.textPattern) {
+            result = updateCheckboxByText(result, update.textPattern, update.checked);
+        }
+    }
+    return result;
+}
+/**
+ * Check if markdown contains any checkboxes
+ *
+ * @param markdown - The markdown content to check
+ * @returns True if at least one checkbox is found
+ */
+export function hasCheckboxes(markdown) {
+    const lines = markdown.split('\n');
+    return lines.some((line) => CHECKBOX_REGEX.test(line));
+}
+/**
+ * Get summary of checkbox states
+ *
+ * @param markdown - The markdown content
+ * @returns Object with counts of checked and unchecked items
+ */
+export function getCheckboxSummary(markdown) {
+    const checkboxes = parseCheckboxes(markdown);
+    const checked = checkboxes.filter((c) => c.checked).length;
+    return {
+        total: checkboxes.length,
+        checked,
+        unchecked: checkboxes.length - checked,
+    };
+}

package/dist/src/circuit-breaker.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Circuit Breaker for Linear API calls
+ *
+ * Prevents wasting rate limit quota on requests that are guaranteed to fail
+ * (e.g., expired OAuth tokens, revoked access). Implements the standard
+ * closed → open → half-open state machine.
+ *
+ * State machine:
+ *   closed    → all calls proceed; auth failures increment counter;
+ *               at threshold → open
+ *   open      → all calls throw CircuitOpenError immediately (zero quota);
+ *               after resetTimeoutMs → half-open
+ *   half-open → one probe call allowed; success → closed;
+ *               failure → open (with exponential backoff on reset timeout)
+ */
+import { CircuitOpenError } from './errors.js';
+import type { CircuitBreakerConfig, CircuitBreakerStrategy } from './types.js';
+export type CircuitState = 'closed' | 'open' | 'half-open';
+export declare const DEFAULT_CIRCUIT_BREAKER_CONFIG: Required<CircuitBreakerConfig>;
+export declare class CircuitBreaker implements CircuitBreakerStrategy {
+    private _state;
+    private consecutiveFailures;
+    private openedAt;
+    private currentResetTimeoutMs;
+    private probeInFlight;
+    private readonly config;
+    constructor(config?: Partial<CircuitBreakerConfig>);
+    get state(): CircuitState;
+    /**
+     * Check if a call is allowed to proceed.
+     * In half-open state, only one probe call is allowed at a time.
+     */
+    canProceed(): boolean;
+    /**
+     * Record a successful API call. Resets the circuit to closed.
+     */
+    recordSuccess(): void;
+    /**
+     * Record an auth failure. May trip the circuit to open.
+     * Called after isAuthError() returns true, so the error is already vetted.
+     */
+    recordAuthFailure(_statusCode?: number): void;
+    /**
+     * Check if an error is an auth/rate-limit error that should count as a circuit failure.
+     *
+     * Detects:
+     * - HTTP status codes in authErrorCodes (400, 401, 403)
+     * - Linear GraphQL RATELIMITED error code in response body
+     * - Linear SDK error objects with nested error details
+     */
+    isAuthError(error: unknown): boolean;
+    /**
+     * Extract the status code from an auth error, or 0 if not determinable.
+     */
+    extractStatusCode(error: unknown): number;
+    /**
+     * Reset the circuit breaker to closed state.
+     */
+    reset(): void;
+    /**
+     * Get diagnostic info for logging/monitoring.
+     */
+    getStatus(): {
+        state: CircuitState;
+        consecutiveFailures: number;
+        currentResetTimeoutMs: number;
+        msSinceOpened: number | null;
+    };
+    /**
+     * Create a CircuitOpenError with current diagnostic info.
+     */
+    createOpenError(): CircuitOpenError;
+    private trip;
+    private shouldTransitionToHalfOpen;
+}
+//# sourceMappingURL=circuit-breaker.d.ts.map

package/dist/src/circuit-breaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuit-breaker.d.ts","sourceRoot":"","sources":["../../src/circuit-breaker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAE9E,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAA;AAE1D,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,oBAAoB,CAMzE,CAAA;AAED,qBAAa,cAAe,YAAW,sBAAsB;IAC3D,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,mBAAmB,CAAI;IAC/B,OAAO,CAAC,QAAQ,CAAI;IACpB,OAAO,CAAC,qBAAqB,CAAQ;IACrC,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;gBAE3C,MAAM,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC;IAKlD,IAAI,KAAK,IAAI,YAAY,CAOxB;IAED;;;OAGG;IACH,UAAU,IAAI,OAAO;IAgBrB;;OAEG;IACH,aAAa,IAAI,IAAI;IASrB;;;OAGG;IACH,iBAAiB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI;IAmB7C;;;;;;;OAOG;IACH,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAyBpC;;OAEG;IACH,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM;IAKzC;;OAEG;IACH,KAAK,IAAI,IAAI;IAOb;;OAEG;IACH,SAAS,IAAI;QACX,KAAK,EAAE,YAAY,CAAA;QACnB,mBAAmB,EAAE,MAAM,CAAA;QAC3B,qBAAqB,EAAE,MAAM,CAAA;QAC7B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;KAC7B;IASD;;OAEG;IACH,eAAe,IAAI,gBAAgB;IAgBnC,OAAO,CAAC,IAAI;IAKZ,OAAO,CAAC,0BAA0B;CAGnC"}

package/dist/src/circuit-breaker.js

@@ -0,0 +1,229 @@
+/**
+ * Circuit Breaker for Linear API calls
+ *
+ * Prevents wasting rate limit quota on requests that are guaranteed to fail
+ * (e.g., expired OAuth tokens, revoked access). Implements the standard
+ * closed → open → half-open state machine.
+ *
+ * State machine:
+ *   closed    → all calls proceed; auth failures increment counter;
+ *               at threshold → open
+ *   open      → all calls throw CircuitOpenError immediately (zero quota);
+ *               after resetTimeoutMs → half-open
+ *   half-open → one probe call allowed; success → closed;
+ *               failure → open (with exponential backoff on reset timeout)
+ */
+import { CircuitOpenError } from './errors.js';
+export const DEFAULT_CIRCUIT_BREAKER_CONFIG = {
+    failureThreshold: 2,
+    resetTimeoutMs: 60_000,
+    maxResetTimeoutMs: 300_000,
+    backoffMultiplier: 2,
+    authErrorCodes: [400, 401, 403],
+};
+export class CircuitBreaker {
+    _state = 'closed';
+    consecutiveFailures = 0;
+    openedAt = 0;
+    currentResetTimeoutMs;
+    probeInFlight = false;
+    config;
+    constructor(config) {
+        this.config = { ...DEFAULT_CIRCUIT_BREAKER_CONFIG, ...config };
+        this.currentResetTimeoutMs = this.config.resetTimeoutMs;
+    }
+    get state() {
+        // Check if open circuit should transition to half-open
+        if (this._state === 'open' && this.shouldTransitionToHalfOpen()) {
+            this._state = 'half-open';
+            this.probeInFlight = false;
+        }
+        return this._state;
+    }
+    /**
+     * Check if a call is allowed to proceed.
+     * In half-open state, only one probe call is allowed at a time.
+     */
+    canProceed() {
+        const currentState = this.state; // triggers open → half-open check
+        switch (currentState) {
+            case 'closed':
+                return true;
+            case 'open':
+                return false;
+            case 'half-open':
+                // Allow exactly one probe call
+                if (this.probeInFlight)
+                    return false;
+                this.probeInFlight = true;
+                return true;
+        }
+    }
+    /**
+     * Record a successful API call. Resets the circuit to closed.
+     */
+    recordSuccess() {
+        this.consecutiveFailures = 0;
+        this.probeInFlight = false;
+        if (this._state !== 'closed') {
+            this._state = 'closed';
+            this.currentResetTimeoutMs = this.config.resetTimeoutMs;
+        }
+    }
+    /**
+     * Record an auth failure. May trip the circuit to open.
+     * Called after isAuthError() returns true, so the error is already vetted.
+     */
+    recordAuthFailure(_statusCode) {
+        this.probeInFlight = false;
+        this.consecutiveFailures++;
+        if (this._state === 'half-open') {
+            // Probe failed — reopen with exponential backoff
+            this.trip();
+            this.currentResetTimeoutMs = Math.min(this.currentResetTimeoutMs * this.config.backoffMultiplier, this.config.maxResetTimeoutMs);
+            return;
+        }
+        if (this.consecutiveFailures >= this.config.failureThreshold) {
+            this.trip();
+        }
+    }
+    /**
+     * Check if an error is an auth/rate-limit error that should count as a circuit failure.
+     *
+     * Detects:
+     * - HTTP status codes in authErrorCodes (400, 401, 403)
+     * - Linear GraphQL RATELIMITED error code in response body
+     * - Linear SDK error objects with nested error details
+     */
+    isAuthError(error) {
+        if (typeof error !== 'object' || error === null)
+            return false;
+        const err = error;
+        // Check HTTP status code
+        const statusCode = extractStatusCode(err);
+        if (statusCode !== null && this.config.authErrorCodes.includes(statusCode)) {
+            return true;
+        }
+        // Check for Linear GraphQL RATELIMITED error
+        if (isGraphQLRateLimited(err)) {
+            return true;
+        }
+        // Check error message for known auth failure patterns
+        const message = err.message ?? '';
+        if (/access denied|unauthorized|forbidden/i.test(message)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Extract the status code from an auth error, or 0 if not determinable.
+     */
+    extractStatusCode(error) {
+        if (typeof error !== 'object' || error === null)
+            return 0;
+        return extractStatusCode(error) ?? 0;
+    }
+    /**
+     * Reset the circuit breaker to closed state.
+     */
+    reset() {
+        this._state = 'closed';
+        this.consecutiveFailures = 0;
+        this.probeInFlight = false;
+        this.currentResetTimeoutMs = this.config.resetTimeoutMs;
+    }
+    /**
+     * Get diagnostic info for logging/monitoring.
+     */
+    getStatus() {
+        return {
+            state: this.state,
+            consecutiveFailures: this.consecutiveFailures,
+            currentResetTimeoutMs: this.currentResetTimeoutMs,
+            msSinceOpened: this.openedAt > 0 ? Date.now() - this.openedAt : null,
+        };
+    }
+    /**
+     * Create a CircuitOpenError with current diagnostic info.
+     */
+    createOpenError() {
+        const timeRemaining = Math.max(0, this.currentResetTimeoutMs - (Date.now() - this.openedAt));
+        return new CircuitOpenError(`Circuit breaker is open — Linear API calls blocked for ${Math.ceil(timeRemaining / 1000)}s. ` +
+            `${this.consecutiveFailures} consecutive auth failures detected.`, timeRemaining);
+    }
+    // ---------------------------------------------------------------------------
+    // Private
+    // ---------------------------------------------------------------------------
+    trip() {
+        this._state = 'open';
+        this.openedAt = Date.now();
+    }
+    shouldTransitionToHalfOpen() {
+        return Date.now() - this.openedAt >= this.currentResetTimeoutMs;
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Extract HTTP status code from various error shapes
+ */
+function extractStatusCode(err) {
+    // Direct status/statusCode property
+    if (typeof err.status === 'number')
+        return err.status;
+    if (typeof err.statusCode === 'number')
+        return err.statusCode;
+    // Nested in response
+    const response = err.response;
+    if (response) {
+        if (typeof response.status === 'number')
+            return response.status;
+        if (typeof response.statusCode === 'number')
+            return response.statusCode;
+    }
+    return null;
+}
+/**
+ * Check if the error contains a Linear GraphQL RATELIMITED error code.
+ *
+ * Linear returns HTTP 200 with a GraphQL error body when rate-limited:
+ * { errors: [{ extensions: { code: 'RATELIMITED' } }] }
+ */
+function isGraphQLRateLimited(err) {
+    // Check error.extensions.code directly (Linear SDK error shape)
+    const extensions = err.extensions;
+    if (extensions?.code === 'RATELIMITED')
+        return true;
+    // Check nested errors array (raw GraphQL response shape)
+    const errors = err.errors;
+    if (Array.isArray(errors)) {
+        for (const gqlError of errors) {
+            const ext = gqlError.extensions;
+            if (ext?.code === 'RATELIMITED')
+                return true;
+        }
+    }
+    // Check response body for GraphQL errors
+    const response = err.response;
+    if (response) {
+        const body = response.body;
+        const data = response.data;
+        const target = body ?? data;
+        if (target) {
+            const bodyErrors = target.errors;
+            if (Array.isArray(bodyErrors)) {
+                for (const gqlError of bodyErrors) {
+                    const ext = gqlError.extensions;
+                    if (ext?.code === 'RATELIMITED')
+                        return true;
+                }
+            }
+        }
+    }
+    // Check error message as last resort
+    const message = err.message ?? '';
+    if (message.includes('RATELIMITED'))
+        return true;
+    return false;
+}

package/dist/src/circuit-breaker.test.d.ts

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

package/dist/src/circuit-breaker.test.d.ts.map

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