octocode-mcp 13.0.0 → 14.0.0

package/dist/bitbucket/client.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Bitbucket Client
+ *
+ * Manages Bitbucket Cloud client instances with caching and configuration.
+ * Uses @coderabbitai/bitbucket for typed API calls.
+ *
+ * @module bitbucket/client
+ */
+import { BitbucketCloud } from '@coderabbitai/bitbucket';
+type BitbucketClient = ReturnType<typeof BitbucketCloud.createBitbucketCloudClient>;
+interface ClientConfig {
+    token?: string;
+    host?: string;
+    username?: string;
+}
+export declare function getBitbucketClient(config?: ClientConfig): BitbucketClient;
+export declare function clearBitbucketClients(): void;
+export declare function clearBitbucketClient(config?: ClientConfig): void;
+export declare function getCachedDefaultBranch(projectId: string): string | undefined;
+export declare function cacheDefaultBranch(projectId: string, branch: string): void;
+export declare function clearDefaultBranchCache(): void;
+export declare function getAuthHeader(config?: ClientConfig): string;
+export {};

package/dist/bitbucket/codeSearch.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Bitbucket Code Search
+ *
+ * Search for code within a Bitbucket workspace.
+ * Bitbucket scopes code search to workspace level, not individual repos.
+ *
+ * @module bitbucket/codeSearch
+ */
+import type { BitbucketAPIResponse, BitbucketCodeSearchResult } from './types.js';
+interface BitbucketCodeSearchQuery {
+    workspace: string;
+    repoSlug?: string;
+    searchQuery: string;
+    path?: string;
+    filename?: string;
+    extension?: string;
+    page?: number;
+    limit?: number;
+}
+export declare function searchBitbucketCodeAPI(params: BitbucketCodeSearchQuery): Promise<BitbucketAPIResponse<BitbucketCodeSearchResult>>;
+export {};

package/dist/bitbucket/errors.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Bitbucket Error Handling
+ *
+ * Handles Bitbucket API errors and transforms them to standardized format.
+ *
+ * @module bitbucket/errors
+ */
+import type { BitbucketAPIError, BitbucketAPIResponse } from './types.js';
+export declare const BITBUCKET_ERROR_CODES: {
+    readonly RATE_LIMITED: {
+        readonly code: "BB_RATE_LIMITED";
+        readonly message: "Bitbucket API rate limit exceeded. Please wait before retrying.";
+    };
+    readonly UNAUTHORIZED: {
+        readonly code: "BB_UNAUTHORIZED";
+        readonly message: "Bitbucket authentication failed. Check your BITBUCKET_TOKEN.";
+    };
+    readonly FORBIDDEN: {
+        readonly code: "BB_FORBIDDEN";
+        readonly message: "Access denied. Check Bitbucket app password permissions.";
+    };
+    readonly NOT_FOUND: {
+        readonly code: "BB_NOT_FOUND";
+        readonly message: "Resource not found. Check the workspace, repo slug, and path.";
+    };
+    readonly BAD_REQUEST: {
+        readonly code: "BB_BAD_REQUEST";
+        readonly message: "Invalid request parameters.";
+    };
+    readonly SERVER_ERROR: {
+        readonly code: "BB_SERVER_ERROR";
+        readonly message: "Bitbucket server error. Please try again later.";
+    };
+    readonly NETWORK_ERROR: {
+        readonly code: "BB_NETWORK_ERROR";
+        readonly message: "Network error connecting to Bitbucket.";
+    };
+};
+export declare function handleBitbucketAPIError(error: unknown): BitbucketAPIError;
+export declare function createBitbucketError(message: string, status?: number, hints?: string[]): BitbucketAPIResponse<never>;
+export declare function isRateLimitError(error: BitbucketAPIError): boolean;
+export declare function extractRateLimitFromHeaders(headers: Headers): {
+    remaining?: number;
+    reset?: number;
+    retryAfter?: number;
+};

package/dist/bitbucket/fileContent.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Bitbucket File Content
+ *
+ * Retrieve file contents from Bitbucket repositories.
+ * Bitbucket returns raw text for file content (not JSON-wrapped).
+ *
+ * @module bitbucket/fileContent
+ */
+import type { BitbucketAPIResponse, BitbucketFileContentResult } from './types.js';
+interface BitbucketFileContentQuery {
+    workspace: string;
+    repoSlug: string;
+    path: string;
+    ref?: string;
+}
+export declare function fetchBitbucketFileContentAPI(params: BitbucketFileContentQuery): Promise<BitbucketAPIResponse<BitbucketFileContentResult>>;
+/**
+ * Resolve the default branch for a Bitbucket repository.
+ */
+export declare function getBitbucketDefaultBranch(workspace: string, repoSlug: string): Promise<string>;
+export {};

package/dist/bitbucket/pullRequestSearch.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Bitbucket Pull Request Search
+ *
+ * Search and retrieve pull requests from Bitbucket repositories.
+ *
+ * @module bitbucket/pullRequestSearch
+ */
+import type { BitbucketAPIResponse, BitbucketPullRequest, BitbucketPRComment, BitbucketDiffstatEntry } from './types.js';
+interface BitbucketPRSearchQuery {
+    workspace: string;
+    repoSlug: string;
+    prNumber?: number;
+    state?: 'OPEN' | 'MERGED' | 'DECLINED' | 'SUPERSEDED';
+    author?: string;
+    baseBranch?: string;
+    headBranch?: string;
+    sort?: string;
+    page?: number;
+    limit?: number;
+    withComments?: boolean;
+    withDiff?: boolean;
+    withDiffstat?: boolean;
+}
+interface BitbucketPRSearchResult {
+    pullRequests: BitbucketPullRequest[];
+    pagination: {
+        currentPage: number;
+        totalPages: number;
+        hasMore: boolean;
+        totalMatches?: number;
+    };
+    comments?: BitbucketPRComment[];
+    diff?: string;
+    diffstat?: BitbucketDiffstatEntry[];
+}
+interface BitbucketPRSupplementalData {
+    comments?: BitbucketPRComment[];
+    diff?: string;
+    diffstat?: BitbucketDiffstatEntry[];
+}
+export declare function searchBitbucketPRsAPI(params: BitbucketPRSearchQuery): Promise<BitbucketAPIResponse<BitbucketPRSearchResult>>;
+export declare function fetchBitbucketPRSupplementalData(params: BitbucketPRSearchQuery): Promise<BitbucketPRSupplementalData>;
+export {};

package/dist/bitbucket/repoSearch.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Bitbucket Repository Search
+ *
+ * List and search repositories within a Bitbucket workspace.
+ *
+ * @module bitbucket/repoSearch
+ */
+import type { BitbucketAPIResponse, BitbucketRepository } from './types.js';
+interface BitbucketRepoSearchQuery {
+    workspace: string;
+    keywords?: string[];
+    topics?: string[];
+    visibility?: string;
+    sort?: string;
+    page?: number;
+    limit?: number;
+}
+interface BitbucketRepoSearchResult {
+    repositories: BitbucketRepository[];
+    pagination: {
+        currentPage: number;
+        totalPages: number;
+        hasMore: boolean;
+        totalMatches?: number;
+    };
+}
+export declare function searchBitbucketReposAPI(params: BitbucketRepoSearchQuery): Promise<BitbucketAPIResponse<BitbucketRepoSearchResult>>;
+export {};

package/dist/bitbucket/repoStructure.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Bitbucket Repository Structure
+ *
+ * Browse repository tree structure on Bitbucket.
+ * Uses the same /src/{commit}/{path} endpoint with format=meta for directory listing.
+ *
+ * @module bitbucket/repoStructure
+ */
+import type { BitbucketAPIResponse, BitbucketTreeEntry } from './types.js';
+interface BitbucketRepoStructureQuery {
+    workspace: string;
+    repoSlug: string;
+    ref?: string;
+    path?: string;
+    depth?: number;
+    entriesPerPage?: number;
+    entryPageNumber?: number;
+}
+interface BitbucketRepoStructureResult {
+    entries: BitbucketTreeEntry[];
+    branch: string;
+    path: string;
+    pagination: {
+        currentPage: number;
+        totalPages: number;
+        hasMore: boolean;
+        totalMatches?: number;
+    };
+}
+export declare function viewBitbucketRepoStructureAPI(params: BitbucketRepoStructureQuery): Promise<BitbucketAPIResponse<BitbucketRepoStructureResult>>;
+export {};

package/dist/bitbucket/searchUtils.d.ts

@@ -0,0 +1,9 @@
+import type { BitbucketCodeSearchItem } from './types.js';
+interface BitbucketRepositoryIdentity {
+    workspace: string;
+    repoSlug: string;
+}
+export declare function parseBitbucketRepositoryIdentityFromUrl(href?: string): BitbucketRepositoryIdentity | undefined;
+export declare function getBitbucketRepositoryIdentity(item: BitbucketCodeSearchItem): BitbucketRepositoryIdentity | undefined;
+export declare function formatBitbucketRepositoryIdentity(identity?: BitbucketRepositoryIdentity): string;
+export {};

package/dist/bitbucket/types.d.ts

@@ -0,0 +1,220 @@
+/**
+ * Bitbucket API Types
+ *
+ * Types for Bitbucket Cloud REST API responses.
+ *
+ * @module bitbucket/types
+ */
+export interface BitbucketAPIError {
+    error: string;
+    status: number;
+    type: 'http' | 'network' | 'unknown';
+    rateLimitRemaining?: number;
+    /** Rate limit reset time in **seconds** (Unix timestamp from `x-ratelimit-reset` header). */
+    rateLimitReset?: number;
+    retryAfter?: number;
+    hints?: string[];
+}
+export type BitbucketAPIResponse<T> = {
+    data: T;
+    status: number;
+} | BitbucketAPIError;
+export interface BitbucketPaginatedResponse<T> {
+    values: T[];
+    page?: number;
+    pagelen?: number;
+    size?: number;
+    next?: string;
+    previous?: string;
+}
+interface BitbucketCodeSearchSegment {
+    text: string;
+    match?: boolean;
+}
+interface BitbucketCodeSearchLine {
+    line: number;
+    segments: BitbucketCodeSearchSegment[];
+}
+interface BitbucketCodeSearchContentMatch {
+    lines: BitbucketCodeSearchLine[];
+}
+export interface BitbucketCodeSearchItem {
+    type: string;
+    content_matches: BitbucketCodeSearchContentMatch[];
+    path_matches?: BitbucketCodeSearchContentMatch[];
+    file: {
+        path: string;
+        type: string;
+        links?: {
+            self?: {
+                href: string;
+            };
+        };
+    };
+}
+export interface BitbucketCodeSearchResult {
+    items: BitbucketCodeSearchItem[];
+    totalCount: number;
+    pagination: {
+        currentPage: number;
+        totalPages: number;
+        hasMore: boolean;
+        totalMatches?: number;
+    };
+}
+export interface BitbucketRepository {
+    uuid: string;
+    name: string;
+    full_name: string;
+    slug: string;
+    description: string;
+    is_private: boolean;
+    language: string;
+    mainbranch?: {
+        name: string;
+        type: string;
+    };
+    updated_on: string;
+    created_on: string;
+    size?: number;
+    forks_count?: number;
+    has_issues?: boolean;
+    has_wiki?: boolean;
+    links?: {
+        html?: {
+            href: string;
+        };
+        clone?: Array<{
+            href: string;
+            name: string;
+        }>;
+    };
+    project?: {
+        key: string;
+        name: string;
+    };
+    owner?: {
+        display_name: string;
+        username?: string;
+        uuid: string;
+    };
+}
+export interface BitbucketFileContentResult {
+    content: string;
+    path: string;
+    size: number;
+    ref: string;
+    encoding: 'utf-8';
+    lastCommitSha?: string;
+}
+export interface BitbucketTreeEntry {
+    type: 'commit_file' | 'commit_directory';
+    path: string;
+    size?: number;
+    commit?: {
+        hash: string;
+    };
+    links?: {
+        self?: {
+            href: string;
+        };
+    };
+}
+export interface BitbucketPullRequest {
+    id: number;
+    title: string;
+    description: string;
+    state: 'OPEN' | 'MERGED' | 'DECLINED' | 'SUPERSEDED';
+    author: {
+        display_name: string;
+        username?: string;
+        uuid: string;
+    };
+    source: {
+        branch: {
+            name: string;
+        };
+        commit?: {
+            hash: string;
+        };
+        repository?: {
+            full_name: string;
+        };
+    };
+    destination: {
+        branch: {
+            name: string;
+        };
+        commit?: {
+            hash: string;
+        };
+        repository?: {
+            full_name: string;
+        };
+    };
+    close_source_branch?: boolean;
+    created_on: string;
+    updated_on: string;
+    comment_count?: number;
+    task_count?: number;
+    merge_commit?: {
+        hash: string;
+    };
+    closed_by?: {
+        display_name: string;
+    };
+    links?: {
+        html?: {
+            href: string;
+        };
+        diff?: {
+            href: string;
+        };
+        diffstat?: {
+            href: string;
+        };
+        comments?: {
+            href: string;
+        };
+        commits?: {
+            href: string;
+        };
+    };
+    reviewers?: Array<{
+        display_name: string;
+        username?: string;
+        uuid: string;
+    }>;
+}
+export interface BitbucketPRComment {
+    id: number;
+    content: {
+        raw: string;
+        markup?: string;
+        html?: string;
+    };
+    user: {
+        display_name: string;
+        username?: string;
+    };
+    created_on: string;
+    updated_on: string;
+    inline?: {
+        from?: number;
+        to?: number;
+        path: string;
+    };
+}
+export interface BitbucketDiffstatEntry {
+    type: string;
+    status: 'added' | 'removed' | 'modified' | 'renamed';
+    old?: {
+        path: string;
+    };
+    new?: {
+        path: string;
+    };
+    lines_added: number;
+    lines_removed: number;
+}
+export {};

package/dist/bitbucketConfig.d.ts

@@ -0,0 +1,11 @@
+import type { BitbucketConfig, BitbucketTokenSourceType } from './types.js';
+export declare function getBitbucketConfig(): BitbucketConfig;
+export declare function getBitbucketToken(): string | null;
+/**
+ * Get the Bitbucket host URL.
+ * Priority: env var > config file > default
+ */
+export declare function getBitbucketHost(): string;
+export declare function getBitbucketUsername(): string | null;
+export declare function getBitbucketTokenSource(): BitbucketTokenSourceType;
+export declare function isBitbucketConfigured(): boolean;

package/dist/commands/BaseCommandBuilder.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Base command builder class for constructing safe shell commands
+ */
+/**
+ * Abstract base class for building command strings safely
+ */
+export declare abstract class BaseCommandBuilder {
+    protected command: string;
+    protected args: string[];
+    constructor(command: string);
+    /**
+     * Adds a flag (e.g., -r, -i)
+     */
+    addFlag(flag: string): this;
+    /**
+     * Adds an option with a value (e.g., -A 3)
+     */
+    protected addOption(option: string, value: string | number): this;
+    /**
+     * Adds a raw argument (will be validated but not escaped)
+     * Note: escaping is not needed when using spawn() which passes args directly
+     */
+    protected addArg(arg: string): this;
+    /**
+     * Builds the final command arguments array
+     */
+    build(): {
+        command: string;
+        args: string[];
+    };
+    /**
+     * Resets the builder to initial state
+     */
+    reset(): this;
+    /**
+     * Gets the current args (for debugging)
+     */
+    getArgs(): string[];
+}

package/dist/commands/FindCommandBuilder.d.ts

@@ -0,0 +1,73 @@
+import { BaseCommandBuilder } from './BaseCommandBuilder.js';
+import type { FindFilesQuery } from '@octocodeai/octocode-core';
+export declare class FindCommandBuilder extends BaseCommandBuilder {
+    private isMacOS;
+    private isLinux;
+    private isWindows;
+    constructor();
+    fromQuery(query: FindFilesQuery): this;
+    /**
+     * Builds the excludeDir prune block:
+     * ( -path "*\/dir" -o -path "*\/dir/*" ) -prune
+     * Repeated for each directory
+     */
+    private buildExcludeDirPrune;
+    /**
+     * Adds all filter options (type, names, size, time, etc.)
+     * These must come AFTER the prune block when excludeDir is used
+     */
+    private addFilters;
+    simple(path: string, name: string): this;
+    type(type: 'f' | 'd' | 'l'): this;
+    name(pattern: string): this;
+    iname(pattern: string): this;
+    maxDepth(depth: number): this;
+    minDepth(depth: number): this;
+    size(size: string): this;
+    mtime(time: string): this;
+    path(path: string): this;
+    /**
+     * Ensures regex patterns match against the full path.
+     *
+     * `find -regex` matches against the ENTIRE path (e.g. /Users/.../foo.test.ts),
+     * not just the filename. Users commonly provide filename-oriented patterns like
+     * `\.(test|spec)\.ts$` which silently return 0 results.
+     *
+     * This method prepends `.*` when the pattern doesn't already account for the
+     * full path, so `\.(test|spec)\.ts$` becomes `.*\.(test|spec)\.ts$` and works.
+     *
+     * Patterns that already start with `.*`, `/`, or `^` are left unchanged.
+     */
+    private normalizeRegexForFullPath;
+    /**
+     * Parses time string and returns appropriate find flag
+     * Hours use -mmin (minutes), days/weeks/months use -mtime (days)
+     */
+    private parseTimeString;
+    /**
+     * Parses access time string (similar to mtime but uses -atime/-amin)
+     */
+    private parseTimeStringAccess;
+    /**
+     * Normalizes size suffix for cross-platform compatibility.
+     *
+     * PLATFORM DIFFERENCES:
+     * - macOS BSD find: Only supports 'c' (bytes) and 'k' (kilobytes) - LOWERCASE ONLY
+     * - Linux GNU find: Supports 'c', 'w', 'b', 'k', 'K', 'M', 'G' (case-sensitive)
+     *
+     * BUG FIX HISTORY:
+     * Before: Users passing "10K" would get "find: -size: +10K: illegal trailing character" on macOS
+     * After:  "10K" is normalized to "10k", works on both macOS and Linux
+     *
+     * EXAMPLES:
+     * - "10K" → "10k" (kilobytes, normalized for macOS)
+     * - "10k" → "10k" (already lowercase)
+     * - "100" → "100" (bytes, no suffix)
+     * - "1M" → "1048576c" (megabytes converted to bytes for macOS compatibility)
+     * - "1G" → "1073741824c" (gigabytes converted to bytes for macOS compatibility)
+     *
+     * @param size - Size string like "10k", "10K", "1M", "1G", or raw number
+     * @returns Normalized size string compatible with both macOS and Linux
+     */
+    private normalizeSizeForPlatform;
+}

package/dist/commands/GrepCommandBuilder.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Command builder for grep (fallback when ripgrep is not available)
+ * Maps RipgrepQuery parameters to grep equivalents where possible
+ */
+import { BaseCommandBuilder } from './BaseCommandBuilder.js';
+import type { RipgrepQuery } from '@octocodeai/octocode-core';
+/**
+ * Features not supported by grep (will generate warnings)
+ */
+interface GrepUnsupportedFeatures {
+    smartCase: boolean;
+    multiline: boolean;
+    countMatches: boolean;
+    jsonOutput: boolean;
+    sortOptions: boolean;
+    threads: boolean;
+    mmap: boolean;
+    stats: boolean;
+    gitignore: boolean;
+}
+/**
+ * Check which features are unsupported when using grep
+ */
+export declare function getUnsupportedGrepFeatures(query: RipgrepQuery): GrepUnsupportedFeatures;
+/**
+ * Generate warnings for unsupported grep features
+ */
+export declare function getGrepFeatureWarnings(query: RipgrepQuery): string[];
+export declare class GrepCommandBuilder extends BaseCommandBuilder {
+    constructor();
+    /**
+     * Simple convenience method to set pattern and path with default flags
+     */
+    simple(pattern: string, path: string): this;
+    /**
+     * Enable case-insensitive search
+     */
+    caseInsensitive(): this;
+    /**
+     * Only show filenames with matches
+     */
+    filesOnly(): this;
+    /**
+     * Show context lines around matches
+     */
+    context(lines: number): this;
+    /**
+     * Include only files matching pattern
+     */
+    include(pattern: string): this;
+    /**
+     * Exclude files matching pattern
+     */
+    exclude(pattern: string): this;
+    /**
+     * Exclude directory from search
+     */
+    excludeDir(dir: string): this;
+    /**
+     * Treat pattern as fixed string (not regex)
+     */
+    fixedString(): this;
+    /**
+     * Build grep command from RipgrepQuery
+     * Maps compatible options and ignores unsupported ones
+     */
+    fromQuery(query: RipgrepQuery): this;
+}
+export {};

package/dist/commands/LsCommandBuilder.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Ls command builder for directory listing
+ */
+import { BaseCommandBuilder } from './BaseCommandBuilder.js';
+import type { ViewStructureQuery } from '@octocodeai/octocode-core';
+/**
+ * Builder for ls commands
+ */
+export declare class LsCommandBuilder extends BaseCommandBuilder {
+    constructor();
+    /**
+     * Builds an ls command from a view structure query
+     */
+    fromQuery(query: ViewStructureQuery): this;
+    /**
+     * Simple directory listing
+     */
+    simple(path: string): this;
+    /**
+     * Detailed listing with long format
+     */
+    detailed(): this;
+    /**
+     * Show hidden files
+     */
+    all(): this;
+    /**
+     * Human-readable file sizes
+     */
+    humanReadable(): this;
+    /**
+     * Recursive listing
+     */
+    recursive(): this;
+    /**
+     * Sort by size
+     */
+    sortBySize(): this;
+    /**
+     * Sort by time
+     */
+    sortByTime(): this;
+    /**
+     * Reverse sort order
+     */
+    reverse(): this;
+    /**
+     * Set the path to list
+     */
+    path(path: string): this;
+}