chromium-helper/dist/api.d.ts

CLI tool for searching and exploring Chromium source code via Google's official APIs

export interface SearchResult {
    file: string;
    line: number;
    content: string;
    url: string;
    type?: string;
}
export interface XRefResult {
    signature: string;
    definition?: SearchResult;
    declaration?: SearchResult;
    references: SearchResult[];
    overrides: SearchResult[];
    calls: SearchResult[];
}
export declare class ChromiumSearchError extends Error {
    cause?: Error | undefined;
    constructor(message: string, cause?: Error | undefined);
}
export declare class GerritAPIError extends Error {
    statusCode?: number | undefined;
    cause?: Error | undefined;
    constructor(message: string, statusCode?: number | undefined, cause?: Error | undefined);
}
export interface SearchCodeParams {
    query: string;
    caseSensitive?: boolean;
    language?: string;
    filePattern?: string;
    searchType?: 'content' | 'function' | 'class' | 'symbol' | 'comment';
    excludeComments?: boolean;
    limit?: number;
}
export interface GetFileParams {
    filePath: string;
    lineStart?: number;
    lineEnd?: number;
}
export interface GetGerritCLCommentsParams {
    clNumber: string;
    patchset?: number;
    includeResolved?: boolean;
}
export interface GetGerritCLDiffParams {
    clNumber: string;
    patchset?: number;
    filePath?: string;
}
export interface GetGerritPatchsetFileParams {
    clNumber: string;
    filePath: string;
    patchset?: number;
}
export interface SearchCommitsParams {
    query: string;
    author?: string;
    since?: string;
    until?: string;
    limit?: number;
}
export interface ParsedOwnersFile {
    path: string;
    directOwners: string[];
    perFileRules: Array<{
        pattern: string;
        owners: string[];
    }>;
    fileIncludes: string[];
    includeDirectives: string[];
    noParent: boolean;
    hasWildcard: boolean;
}
export interface ReviewerCandidate {
    email: string;
    coverageScore: number;
    activityScore: number;
    combinedScore: number;
    canReviewFiles: string[];
    recentCommits: number;
    lastCommitDate: string | null;
}
export interface ReviewerSuggestion {
    clNumber: string;
    subject: string;
    changedFiles: string[];
    suggestedReviewers: ReviewerCandidate[];
    optimalSet: ReviewerCandidate[];
    uncoveredFiles: string[];
    analysisDetails: {
        filesAnalyzed: number;
        ownersFilesFetched: number;
        commitHistoryFetched: number;
        activityMonths: number;
    };
}
export interface SuggestReviewersParams {
    clNumber: string;
    patchset?: number;
    maxReviewers?: number;
    activityMonths?: number;
    excludeReviewers?: string[];
    fast?: boolean;
}
export declare class ChromiumAPI {
    private apiKey;
    private cache;
    private debugMode;
    constructor(apiKey?: string);
    setDebugMode(enabled: boolean): void;
    private debug;
    searchCode(params: SearchCodeParams): Promise<SearchResult[]>;
    findSymbol(symbol: string, filePath?: string): Promise<{
        symbol: string;
        symbolResults: SearchResult[];
        classResults: SearchResult[];
        functionResults: SearchResult[];
        usageResults: SearchResult[];
        estimatedUsageCount?: number;
    }>;
    getFile(params: GetFileParams): Promise<{
        filePath: string;
        content: string;
        totalLines: number;
        displayedLines: number;
        lineStart?: number;
        lineEnd?: number;
        browserUrl: string;
        source?: string;
        githubUrl?: string;
        webrtcUrl?: string;
    }>;
    getGerritCLStatus(clNumber: string): Promise<any>;
    getGerritCLComments(params: GetGerritCLCommentsParams): Promise<any>;
    getGerritCLDiff(params: GetGerritCLDiffParams): Promise<any>;
    getGerritPatchsetFile(params: GetGerritPatchsetFileParams): Promise<any>;
    getGerritCLTrybotStatus(params: {
        clNumber: string;
        patchset?: number;
        failedOnly?: boolean;
    }): Promise<any>;
    private extractLuciVerifierUrls;
    private fetchLuciRunDetails;
    private parseLuciHtmlImproved;
    private extractBotStatus;
    private checkForStatus;
    private getStatusCounts;
    findOwners(filePath: string): Promise<{
        filePath: string;
        ownerFiles: Array<{
            path: string;
            content: string;
            browserUrl: string;
        }>;
    }>;
    searchCommits(params: SearchCommitsParams): Promise<any>;
    getIssue(issueId: string): Promise<any>;
    private callChromiumSearchAPI;
    private parseChromiumAPIResponse;
    private extractCLNumber;
    private extractIssueId;
    private getFileExtension;
    private extractIssueInfo;
    private getStatusText;
    private getPriorityText;
    private getTypeText;
    private getSeverityText;
    private extractUserInfo;
    private formatTimestamp;
    private extractRelatedCLs;
    private extractRelatedCLsFromString;
    private extractIssueFromHTML;
    private extractIssueWithBrowser;
    private parseBatchAPIResponses;
    private getIssueDirectAPI;
    private parseResponseData;
    private extractCommentsAndIssueText;
    private parseCommentsArray;
    private parseCommentStructure;
    private extractContentFromStructure;
    private cleanupCommentContent;
    private extractCLReferencesFromText;
    private extractEventsData;
    private parseEventsArray;
    private parseEventComment;
    private extractIssueMetadata;
    private extractNestedProtobufValue;
    private extractUserFromProtobuf;
    private extractCommentsFromEventsData;
    private extractIssueDataFromBatchArray;
    private isEmptyMigrationComment;
    getPdfiumGerritCLStatus(clNumber: string): Promise<any>;
    getPdfiumGerritCLComments(params: GetGerritCLCommentsParams): Promise<any>;
    getPdfiumGerritCLDiff(params: GetGerritCLDiffParams): Promise<any>;
    getPdfiumGerritPatchsetFile(params: GetGerritPatchsetFileParams): Promise<any>;
    getPdfiumGerritCLTrybotStatus(params: {
        clNumber: string;
        patchset?: number;
        failedOnly?: boolean;
    }): Promise<any>;
    private extractPdfiumLuciVerifierUrls;
    searchIssues(query: string, options?: {
        limit?: number;
        startIndex?: number;
    }): Promise<any>;
    private parseIssueSearchResults;
    private parseIssueFromProtobufArray;
    private getIssueStatusFromNumber;
    private getIssueTypeFromNumber;
    private looksLikeIssueObject;
    private looksLikeIssueData;
    private extractIssuesFromArray;
    private parseIssueFromNestedArray;
    private normalizeIssueSearchResult;
    listFolder(folderPath: string): Promise<any>;
    private listV8FolderViaGitHub;
    private listWebRTCFolderViaGitiles;
    private getV8FileViaGitHub;
    private getWebRTCFileViaGitiles;
    listGerritCLs(params: {
        query?: string;
        authCookie: string;
        limit?: number;
    }): Promise<any>;
    listPdfiumGerritCLs(params: {
        query?: string;
        authCookie: string;
        limit?: number;
    }): Promise<any>;
    /**
     * Get bot errors from a Gerrit CL
     */
    getGerritCLBotErrors(params: {
        clNumber: string;
        patchset?: number;
        failedOnly?: boolean;
        botFilter?: string;
    }): Promise<any>;
    /**
     * Parse CI build URL to extract project, bucket, builder, and build number
     */
    private parseCIBuildUrl;
    /**
     * Fetch detailed test snippet (including stack traces) from ResultDB
     */
    private fetchTestSnippet;
    /**
     * Get build errors from CI Chromium build URL or Build ID
     */
    getCIBuildErrors(buildUrlOrNumber: string): Promise<any>;
    getFileBlame(filePath: string, lineNumber?: number): Promise<any>;
    getFileHistory(filePath: string, limit?: number): Promise<any>;
    getPathContributors(path: string, limit?: number): Promise<any>;
    /**
     * Parse OWNERS file content into structured data
     */
    private parseOwnersFileEnhanced;
    /**
     * Check if a filename matches an OWNERS per-file pattern
     */
    private matchesPerFilePattern;
    /**
     * Get contributors to a file within a time period
     */
    getFileContributorsSince(filePath: string, sinceMonths?: number): Promise<Map<string, {
        count: number;
        lastDate: string;
    }>>;
    /**
     * Suggest optimal reviewers for a CL based on OWNERS and activity
     */
    suggestReviewersForCL(params: SuggestReviewersParams): Promise<ReviewerSuggestion>;
}
//# sourceMappingURL=api.d.ts.map