autoagent-cli/dist/utils/patterns.js

Run autonomous AI agents using Claude or Gemini for task execution

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.isRateLimitOrUsageError = exports.PatternMatcher = exports.ERROR_PATTERNS = exports.PROVIDER_PATTERNS = exports.RATE_LIMIT_PATTERNS = exports.USAGE_LIMIT_PATTERNS = void 0;
exports.USAGE_LIMIT_PATTERNS = {
    CLAUDE_TIMESTAMPED: /Claude AI usage limit reached\|(\d+)/i,
    GENERIC_TIMESTAMPED: /usage limit reached\|(\d+)/i,
    USAGE_LIMIT: /usage limit/i,
    ANY_USAGE_LIMIT: /usage limit[^|]*\|?\d*/i
};
exports.RATE_LIMIT_PATTERNS = {
    WITH_RETRY_AFTER: /rate limit.*retry[- ]?after[: ]+(\d+)/i,
    RATE_LIMIT: /rate limit/i,
    TOO_MANY_REQUESTS: /too many requests/i,
    QUOTA_EXCEEDED: /quota exceeded/i
};
exports.PROVIDER_PATTERNS = {
    ISSUE_NUMBER: /(\d+)-/,
    VERSION_COMMAND: /--version/,
    FILE_CHANGES: /(?:modified|created|updated|changed):\s*([^\n]+)/gi
};
exports.ERROR_PATTERNS = {
    ERROR_INDICATORS: /(?:error|failed|exception|traceback):/i,
    NETWORK_ERRORS: /(?:timeout|connection|network)/i,
    AUTH_ERRORS: /(?:unauthorized|forbidden|authentication)/i,
    NOT_FOUND_ERRORS: /not found/i
};
class PatternMatcher {
    static extractUsageLimitTimestamp(message) {
        const match = message.match(exports.USAGE_LIMIT_PATTERNS.CLAUDE_TIMESTAMPED) ||
            message.match(exports.USAGE_LIMIT_PATTERNS.GENERIC_TIMESTAMPED);
        if (match?.[1] !== undefined && match[1] !== '') {
            const timestamp = parseInt(match[1], 10);
            return isNaN(timestamp) ? undefined : timestamp;
        }
        return undefined;
    }
    static extractRetryAfter(message) {
        const match = message.match(exports.RATE_LIMIT_PATTERNS.WITH_RETRY_AFTER);
        if (match?.[1] !== undefined && match[1] !== '') {
            const seconds = parseInt(match[1], 10);
            return isNaN(seconds) ? undefined : seconds;
        }
        return undefined;
    }
    static extractIssueNumber(filePath) {
        const match = filePath.match(exports.PROVIDER_PATTERNS.ISSUE_NUMBER);
        return match?.[1] !== undefined && match[1] !== '' ? parseInt(match[1], 10) : 0;
    }
    static extractChangedFiles(output) {
        const matches = Array.from(output.matchAll(exports.PROVIDER_PATTERNS.FILE_CHANGES));
        return matches.map(match => match[1]?.trim()).filter((file) => Boolean(file));
    }
    static isUsageLimitError(message) {
        return exports.USAGE_LIMIT_PATTERNS.USAGE_LIMIT.test(message);
    }
    static isRateLimitError(message) {
        return exports.RATE_LIMIT_PATTERNS.RATE_LIMIT.test(message) ||
            exports.RATE_LIMIT_PATTERNS.TOO_MANY_REQUESTS.test(message) ||
            exports.RATE_LIMIT_PATTERNS.QUOTA_EXCEEDED.test(message);
    }
    static isLimitError(message) {
        return this.isUsageLimitError(message) || this.isRateLimitError(message);
    }
    static hasErrorIndicators(output) {
        return exports.ERROR_PATTERNS.ERROR_INDICATORS.test(output);
    }
    static isRetryableError(message) {
        const lowerMessage = message.toLowerCase();
        if (this.isLimitError(message)) {
            return true;
        }
        if (exports.ERROR_PATTERNS.AUTH_ERRORS.test(lowerMessage) ||
            exports.ERROR_PATTERNS.NOT_FOUND_ERRORS.test(lowerMessage)) {
            return false;
        }
        if (exports.ERROR_PATTERNS.NETWORK_ERRORS.test(lowerMessage)) {
            return true;
        }
        return true;
    }
    static isVersionCommand(args) {
        return args.some(arg => exports.PROVIDER_PATTERNS.VERSION_COMMAND.test(arg));
    }
}
exports.PatternMatcher = PatternMatcher;
const isRateLimitOrUsageError = (message) => PatternMatcher.isLimitError(message);
exports.isRateLimitOrUsageError = isRateLimitOrUsageError;