@clinebot/core 0.0.0

package/dist/auth/types.d.ts

@@ -0,0 +1,72 @@
+export interface OAuthPrompt {
+    message: string;
+    defaultValue?: string;
+}
+export interface OAuthCredentials {
+    access: string;
+    refresh: string;
+    /**
+     * Expiration timestamp in milliseconds since epoch.
+     */
+    expires: number;
+    /**
+     * Optional provider-specific account identifier.
+     */
+    accountId?: string;
+    /**
+     * Optional email for display/telemetry.
+     */
+    email?: string;
+    /**
+     * Provider-specific metadata (user info, provider hint, etc).
+     */
+    metadata?: Record<string, unknown>;
+}
+export interface OAuthLoginCallbacks {
+    onAuth: (info: {
+        url: string;
+        instructions?: string;
+    }) => void;
+    onPrompt: (prompt: OAuthPrompt) => Promise<string>;
+    onProgress?: (message: string) => void;
+    onManualCodeInput?: () => Promise<string>;
+}
+export interface OAuthProviderInterface {
+    id: string;
+    name: string;
+    usesCallbackServer: boolean;
+    login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials>;
+    refreshToken(credentials: OAuthCredentials): Promise<OAuthCredentials>;
+    getApiKey(credentials: OAuthCredentials): string;
+}
+export type OcaMode = "internal" | "external";
+export interface OcaOAuthEnvironmentConfig {
+    clientId: string;
+    idcsUrl: string;
+    scopes: string;
+    baseUrl: string;
+}
+export interface OcaOAuthConfig {
+    internal: OcaOAuthEnvironmentConfig;
+    external: OcaOAuthEnvironmentConfig;
+}
+export interface OcaClientMetadata {
+    client?: string;
+    clientVersion?: string;
+    clientIde?: string;
+    clientIdeVersion?: string;
+}
+export interface OcaOAuthProviderOptions {
+    config?: Partial<OcaOAuthConfig>;
+    mode?: OcaMode | (() => OcaMode);
+    callbackPath?: string;
+    callbackPorts?: number[];
+    requestTimeoutMs?: number;
+    refreshBufferMs?: number;
+    retryableTokenGraceMs?: number;
+}
+export interface OcaTokenResolution {
+    forceRefresh?: boolean;
+    refreshBufferMs?: number;
+    retryableTokenGraceMs?: number;
+}

package/dist/auth/utils.d.ts

@@ -0,0 +1,32 @@
+import type { OAuthCallbackPayload } from "./server.js";
+import type { OAuthCredentials } from "./types.js";
+export declare function getProofKey(): Promise<{
+    verifier: string;
+    challenge: string;
+}>;
+export declare function normalizeBaseUrl(value: string): string;
+export declare function resolveUrl(baseUrl: string, path: string): string;
+export type ParsedAuthorizationInput = {
+    code?: string;
+    state?: string;
+    provider?: string;
+};
+export type ParseAuthorizationInputOptions = {
+    includeProvider?: boolean;
+    allowHashCodeState?: boolean;
+};
+export declare function parseAuthorizationInput(input: string, options?: ParseAuthorizationInputOptions): ParsedAuthorizationInput;
+export declare function decodeJwtPayload(token?: string): Record<string, unknown> | null;
+export declare function parseOAuthError(text: string): {
+    code?: string;
+    message?: string;
+};
+export declare function isCredentialLikelyExpired(credentials: Pick<OAuthCredentials, "expires">, refreshBufferMs: number): boolean;
+export declare function resolveAuthorizationCodeInput(input: {
+    waitForCallback: () => Promise<OAuthCallbackPayload | null>;
+    cancelWait: () => void;
+    onManualCodeInput?: () => Promise<string>;
+    parseOptions?: ParseAuthorizationInputOptions;
+}): Promise<ParsedAuthorizationInput & {
+    error?: string;
+}>;

package/dist/chat/chat-schema.d.ts

@@ -0,0 +1,145 @@
+import { z } from "zod";
+export declare const ChatSessionConfigSchema: z.ZodObject<{
+    workspaceRoot: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    provider: z.ZodString;
+    model: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
+        act: "act";
+        plan: "plan";
+    }>>;
+    apiKey: z.ZodString;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    rules: z.ZodOptional<z.ZodString>;
+    maxIterations: z.ZodOptional<z.ZodNumber>;
+    enableTools: z.ZodBoolean;
+    enableSpawn: z.ZodBoolean;
+    enableTeams: z.ZodBoolean;
+    autoApproveTools: z.ZodOptional<z.ZodBoolean>;
+    teamName: z.ZodString;
+    missionStepInterval: z.ZodNumber;
+    missionTimeIntervalMs: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ChatSessionStatusSchema: z.ZodEnum<{
+    error: "error";
+    idle: "idle";
+    starting: "starting";
+    running: "running";
+    stopping: "stopping";
+    completed: "completed";
+    cancelled: "cancelled";
+    failed: "failed";
+}>;
+export declare const ChatMessageRoleSchema: z.ZodEnum<{
+    error: "error";
+    user: "user";
+    assistant: "assistant";
+    tool: "tool";
+    system: "system";
+    status: "status";
+}>;
+export declare const ChatMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    sessionId: z.ZodNullable<z.ZodString>;
+    role: z.ZodEnum<{
+        error: "error";
+        user: "user";
+        assistant: "assistant";
+        tool: "tool";
+        system: "system";
+        status: "status";
+    }>;
+    content: z.ZodString;
+    createdAt: z.ZodNumber;
+    meta: z.ZodOptional<z.ZodObject<{
+        stream: z.ZodOptional<z.ZodEnum<{
+            stdout: "stdout";
+            stderr: "stderr";
+        }>>;
+        toolName: z.ZodOptional<z.ZodString>;
+        iteration: z.ZodOptional<z.ZodNumber>;
+        agentId: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+        hookEventName: z.ZodOptional<z.ZodString>;
+        inputTokens: z.ZodOptional<z.ZodNumber>;
+        outputTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ChatSummarySchema: z.ZodObject<{
+    toolCalls: z.ZodNumber;
+    tokensIn: z.ZodNumber;
+    tokensOut: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ChatViewStateSchema: z.ZodObject<{
+    sessionId: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        error: "error";
+        idle: "idle";
+        starting: "starting";
+        running: "running";
+        stopping: "stopping";
+        completed: "completed";
+        cancelled: "cancelled";
+        failed: "failed";
+    }>;
+    config: z.ZodObject<{
+        workspaceRoot: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        provider: z.ZodString;
+        model: z.ZodString;
+        mode: z.ZodDefault<z.ZodEnum<{
+            act: "act";
+            plan: "plan";
+        }>>;
+        apiKey: z.ZodString;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        rules: z.ZodOptional<z.ZodString>;
+        maxIterations: z.ZodOptional<z.ZodNumber>;
+        enableTools: z.ZodBoolean;
+        enableSpawn: z.ZodBoolean;
+        enableTeams: z.ZodBoolean;
+        autoApproveTools: z.ZodOptional<z.ZodBoolean>;
+        teamName: z.ZodString;
+        missionStepInterval: z.ZodNumber;
+        missionTimeIntervalMs: z.ZodNumber;
+    }, z.core.$strip>;
+    messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sessionId: z.ZodNullable<z.ZodString>;
+        role: z.ZodEnum<{
+            error: "error";
+            user: "user";
+            assistant: "assistant";
+            tool: "tool";
+            system: "system";
+            status: "status";
+        }>;
+        content: z.ZodString;
+        createdAt: z.ZodNumber;
+        meta: z.ZodOptional<z.ZodObject<{
+            stream: z.ZodOptional<z.ZodEnum<{
+                stdout: "stdout";
+                stderr: "stderr";
+            }>>;
+            toolName: z.ZodOptional<z.ZodString>;
+            iteration: z.ZodOptional<z.ZodNumber>;
+            agentId: z.ZodOptional<z.ZodString>;
+            conversationId: z.ZodOptional<z.ZodString>;
+            hookEventName: z.ZodOptional<z.ZodString>;
+            inputTokens: z.ZodOptional<z.ZodNumber>;
+            outputTokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    rawTranscript: z.ZodString;
+    error: z.ZodNullable<z.ZodString>;
+    summary: z.ZodObject<{
+        toolCalls: z.ZodNumber;
+        tokensIn: z.ZodNumber;
+        tokensOut: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ChatSessionConfig = z.infer<typeof ChatSessionConfigSchema>;
+export type ChatSessionStatus = z.infer<typeof ChatSessionStatusSchema>;
+export type ChatMessage = z.infer<typeof ChatMessageSchema>;
+export type ChatSummary = z.infer<typeof ChatSummarySchema>;
+export type ChatViewState = z.infer<typeof ChatViewStateSchema>;

package/dist/default-tools/constants.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Constants for Default Tools
+ *
+ * Tool name constants and utility arrays.
+ */
+import type { DefaultToolName } from "./types.js";
+/**
+ * Constants for default tool names
+ */
+export declare const DefaultToolNames: {
+    readonly READ_FILES: "read_files";
+    readonly SEARCH_CODEBASE: "search_codebase";
+    readonly RUN_COMMANDS: "run_commands";
+    readonly FETCH_WEB_CONTENT: "fetch_web_content";
+    readonly APPLY_PATCH: "apply_patch";
+    readonly EDITOR: "editor";
+    readonly SKILLS: "skills";
+    readonly ASK: "ask_question";
+};
+/**
+ * Array of all default tool names
+ */
+export declare const ALL_DEFAULT_TOOL_NAMES: DefaultToolName[];

package/dist/default-tools/definitions.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Default Tool Definitions
+ *
+ * Factory functions for creating the default tools.
+ */
+import { type Tool } from "@clinebot/agents";
+import { type ApplyPatchInput, type AskQuestionInput, type EditFileInput, type FetchWebContentInput, type ReadFilesInput, type RunCommandsInput, type SearchCodebaseInput, type SkillsInput } from "./schemas.js";
+import type { ApplyPatchExecutor, AskQuestionExecutor, BashExecutor, CreateDefaultToolsOptions, DefaultToolsConfig, EditorExecutor, FileReadExecutor, SearchExecutor, SkillsExecutor, ToolOperationResult, WebFetchExecutor } from "./types.js";
+/**
+ * Create the read_files tool
+ *
+ * Reads the content of one or more files from the filesystem.
+ */
+export declare function createReadFilesTool(executor: FileReadExecutor, config?: Pick<DefaultToolsConfig, "fileReadTimeoutMs">): Tool<ReadFilesInput, ToolOperationResult[]>;
+/**
+ * Create the search_codebase tool
+ *
+ * Performs regex pattern searches across the codebase.
+ */
+export declare function createSearchTool(executor: SearchExecutor, config?: Pick<DefaultToolsConfig, "cwd" | "searchTimeoutMs">): Tool<SearchCodebaseInput, ToolOperationResult[]>;
+/**
+ * Create the run_commands tool
+ *
+ * Executes shell commands in the project directory.
+ */
+export declare function createBashTool(executor: BashExecutor, config?: Pick<DefaultToolsConfig, "cwd" | "bashTimeoutMs">): Tool<RunCommandsInput, ToolOperationResult[]>;
+/**
+ * Create the fetch_web_content tool
+ *
+ * Fetches content from URLs and analyzes them using provided prompts.
+ */
+export declare function createWebFetchTool(executor: WebFetchExecutor, config?: Pick<DefaultToolsConfig, "webFetchTimeoutMs">): Tool<FetchWebContentInput, ToolOperationResult[]>;
+/**
+ * Create the apply_patch tool
+ *
+ * Applies the legacy Cline patch format to one or more files.
+ */
+export declare function createApplyPatchTool(executor: ApplyPatchExecutor, config?: Pick<DefaultToolsConfig, "cwd" | "applyPatchTimeoutMs">): Tool<ApplyPatchInput, ToolOperationResult>;
+/**
+ * Create the editor tool
+ *
+ * Supports controlled filesystem edits with create, replace, and insert commands.
+ */
+export declare function createEditorTool(executor: EditorExecutor, config?: Pick<DefaultToolsConfig, "cwd" | "editorTimeoutMs">): Tool<EditFileInput, ToolOperationResult>;
+/**
+ * Create the skills tool
+ *
+ * Invokes a configured skill by name and optional arguments.
+ */
+export declare function createSkillsTool(executor: SkillsExecutor, config?: Pick<DefaultToolsConfig, "skillsTimeoutMs">): Tool<SkillsInput, string>;
+/**
+ * Create the ask_question tool
+ *
+ * Asks the user a single clarifying question with 2-5 selectable options.
+ */
+export declare function createAskQuestionTool(executor: AskQuestionExecutor, config?: Pick<DefaultToolsConfig, "askQuestionTimeoutMs">): Tool<AskQuestionInput, string>;
+/**
+ * Create a set of default tools for an agent
+ *
+ * This function creates the default tools based on the provided configuration
+ * and executors. Only tools that are enabled AND have an executor provided
+ * will be included in the returned array.
+ *
+ * @example
+ * ```typescript
+ * import { Agent } from "@clinebot/agents"
+ * import { createDefaultTools } from "@clinebot/core/server"
+ * import * as fs from "fs/promises"
+ * import { exec } from "child_process"
+ *
+ * const tools = createDefaultTools({
+ *   executors: {
+ *     readFile: async (path) => fs.readFile(path, "utf-8"),
+ *     bash: async (cmd, cwd) => {
+ *       return new Promise((resolve, reject) => {
+ *         exec(cmd, { cwd }, (err, stdout, stderr) => {
+ *           if (err) reject(new Error(stderr || err.message))
+ *           else resolve(stdout)
+ *         })
+ *       })
+ *     },
+ *   },
+ *   enableReadFiles: true,
+ *   enableBash: true,
+ *   enableSearch: false, // Disabled
+ *   enableWebFetch: false, // Disabled
+ *   cwd: "/path/to/project",
+ * })
+ *
+ * const agent = new Agent({
+ *   // ... provider config
+ *   tools,
+ * })
+ * ```
+ */
+export declare function createDefaultTools(options: CreateDefaultToolsOptions): Tool[];

package/dist/default-tools/executors/apply-patch-parser.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Apply Patch parser and patch model types.
+ *
+ * This parser supports the Cline apply_patch format used by the legacy runtime.
+ */
+export declare const PATCH_MARKERS: {
+    readonly BEGIN: "*** Begin Patch";
+    readonly END: "*** End Patch";
+    readonly ADD: "*** Add File: ";
+    readonly UPDATE: "*** Update File: ";
+    readonly DELETE: "*** Delete File: ";
+    readonly MOVE: "*** Move to: ";
+    readonly SECTION: "@@";
+    readonly END_FILE: "*** End of File";
+};
+export declare const BASH_WRAPPERS: readonly ["%%bash", "apply_patch", "EOF", "```"];
+export declare enum PatchActionType {
+    ADD = "add",
+    DELETE = "delete",
+    UPDATE = "update"
+}
+export interface PatchChunk {
+    origIndex: number;
+    delLines: string[];
+    insLines: string[];
+}
+export interface PatchAction {
+    type: PatchActionType;
+    newFile?: string;
+    chunks: PatchChunk[];
+    movePath?: string;
+}
+export interface PatchWarning {
+    path: string;
+    chunkIndex?: number;
+    message: string;
+    context?: string;
+}
+export interface Patch {
+    actions: Record<string, PatchAction>;
+    warnings?: PatchWarning[];
+}
+export declare class DiffError extends Error {
+    constructor(message: string);
+}
+export declare class PatchParser {
+    private readonly lines;
+    private readonly currentFiles;
+    private patch;
+    private index;
+    private fuzz;
+    private currentPath?;
+    constructor(lines: string[], currentFiles: Record<string, string>);
+    parse(): {
+        patch: Patch;
+        fuzz: number;
+    };
+    private addWarning;
+    private skipBeginSentinel;
+    private hasMoreLines;
+    private isEndMarker;
+    private parseNextAction;
+    private checkDuplicate;
+    private parseUpdate;
+    private parseUpdateFile;
+    private parseDelete;
+    private parseAdd;
+}

package/dist/default-tools/executors/apply-patch.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Apply Patch Executor
+ *
+ * Built-in implementation for the legacy apply_patch format.
+ */
+import type { ApplyPatchExecutor } from "../types.js";
+/**
+ * Options for the apply_patch executor
+ */
+export interface ApplyPatchExecutorOptions {
+    /**
+     * File encoding used for read/write operations
+     * @default "utf-8"
+     */
+    encoding?: BufferEncoding;
+    /**
+     * Restrict relative-path file operations to paths inside cwd.
+     * Absolute paths are always accepted as-is.
+     * @default true
+     */
+    restrictToCwd?: boolean;
+}
+/**
+ * Create an apply_patch executor using Node.js fs module.
+ */
+export declare function createApplyPatchExecutor(options?: ApplyPatchExecutorOptions): ApplyPatchExecutor;

package/dist/default-tools/executors/bash.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Bash Executor
+ *
+ * Built-in implementation for running shell commands using Node.js spawn.
+ */
+import type { BashExecutor } from "../types.js";
+/**
+ * Options for the bash executor
+ */
+export interface BashExecutorOptions {
+    /**
+     * Shell to use for execution
+     * @default "/bin/bash" on Unix, "cmd.exe" on Windows
+     */
+    shell?: string;
+    /**
+     * Timeout for command execution in milliseconds
+     * @default 30000 (30 seconds)
+     */
+    timeoutMs?: number;
+    /**
+     * Maximum output size in bytes
+     * @default 1_000_000 (1MB)
+     */
+    maxOutputBytes?: number;
+    /**
+     * Environment variables to add/override
+     */
+    env?: Record<string, string>;
+    /**
+     * Whether to combine stdout and stderr
+     * @default true
+     */
+    combineOutput?: boolean;
+}
+/**
+ * Create a bash executor using Node.js spawn
+ *
+ * @example
+ * ```typescript
+ * const bash = createBashExecutor({
+ *   timeoutMs: 60000, // 1 minute timeout
+ *   shell: "/bin/zsh",
+ * })
+ *
+ * const output = await bash("ls -la", "/path/to/project", context)
+ * ```
+ */
+export declare function createBashExecutor(options?: BashExecutorOptions): BashExecutor;

package/dist/default-tools/executors/editor.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Editor Executor
+ *
+ * Built-in implementation for filesystem editing operations.
+ */
+import type { EditorExecutor } from "../types.js";
+/**
+ * Options for the editor executor
+ */
+export interface EditorExecutorOptions {
+    /**
+     * File encoding used for read/write operations
+     * @default "utf-8"
+     */
+    encoding?: BufferEncoding;
+    /**
+     * Restrict relative-path file operations to paths inside cwd.
+     * Absolute paths are always accepted as-is.
+     * @default true
+     */
+    restrictToCwd?: boolean;
+    /**
+     * Maximum number of diff lines in str_replace output
+     * @default 200
+     */
+    maxDiffLines?: number;
+}
+/**
+ * Create an editor executor using Node.js fs module
+ */
+export declare function createEditorExecutor(options?: EditorExecutorOptions): EditorExecutor;

package/dist/default-tools/executors/file-read.d.ts

@@ -0,0 +1,40 @@
+/**
+ * File Read Executor
+ *
+ * Built-in implementation for reading files using Node.js fs module.
+ */
+import type { FileReadExecutor } from "../types.js";
+/**
+ * Options for the file read executor
+ */
+export interface FileReadExecutorOptions {
+    /**
+     * Maximum file size to read in bytes
+     * @default 10_000_000 (10MB)
+     */
+    maxFileSizeBytes?: number;
+    /**
+     * File encoding
+     * @default "utf-8"
+     */
+    encoding?: BufferEncoding;
+    /**
+     * Whether to include line numbers in output
+     * @default false
+     */
+    includeLineNumbers?: boolean;
+}
+/**
+ * Create a file read executor using Node.js fs module
+ *
+ * @example
+ * ```typescript
+ * const readFile = createFileReadExecutor({
+ *   maxFileSizeBytes: 5_000_000, // 5MB limit
+ *   includeLineNumbers: true,
+ * })
+ *
+ * const content = await readFile("/path/to/file.ts", context)
+ * ```
+ */
+export declare function createFileReadExecutor(options?: FileReadExecutorOptions): FileReadExecutor;

package/dist/default-tools/executors/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Built-in Executor Implementations
+ *
+ * This module provides ready-to-use implementations of the tool executors
+ * using Node.js built-in modules. These can be used directly or as references
+ * for custom implementations.
+ */
+import type { ToolExecutors } from "../types.js";
+export { type ApplyPatchExecutorOptions, createApplyPatchExecutor, } from "./apply-patch.js";
+export { type BashExecutorOptions, createBashExecutor } from "./bash.js";
+export { createEditorExecutor, type EditorExecutorOptions } from "./editor.js";
+export { createFileReadExecutor, type FileReadExecutorOptions, } from "./file-read.js";
+export { createSearchExecutor, type SearchExecutorOptions } from "./search.js";
+export { createWebFetchExecutor, type WebFetchExecutorOptions, } from "./web-fetch.js";
+/**
+ * Options for creating default executors
+ */
+export interface DefaultExecutorsOptions {
+    fileRead?: import("./file-read.js").FileReadExecutorOptions;
+    search?: import("./search.js").SearchExecutorOptions;
+    bash?: import("./bash.js").BashExecutorOptions;
+    webFetch?: import("./web-fetch.js").WebFetchExecutorOptions;
+    applyPatch?: import("./apply-patch.js").ApplyPatchExecutorOptions;
+    editor?: import("./editor.js").EditorExecutorOptions;
+}
+/**
+ * Create all default executors with optional configuration
+ *
+ * @example
+ * ```typescript
+ * import { createDefaultTools, createDefaultExecutors } from "@clinebot/core/server"
+ *
+ * const executors = createDefaultExecutors({
+ *   bash: { timeoutMs: 60000 },
+ *   search: { maxResults: 50 },
+ * })
+ *
+ * const tools = createDefaultTools({
+ *   executors,
+ *   cwd: "/path/to/project",
+ * })
+ * ```
+ */
+export declare function createDefaultExecutors(options?: DefaultExecutorsOptions): ToolExecutors;

package/dist/default-tools/executors/search.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Search Executor
+ *
+ * Built-in implementation for searching the codebase using regex.
+ */
+import type { SearchExecutor } from "../types.js";
+/**
+ * Options for the search executor
+ */
+export interface SearchExecutorOptions {
+    /**
+     * File extensions to include in search (without dot)
+     * @default common code extensions
+     */
+    includeExtensions?: string[];
+    /**
+     * Directories to exclude from search
+     * @default ["node_modules", ".git", "dist", "build", ".next", "coverage"]
+     */
+    excludeDirs?: string[];
+    /**
+     * Maximum number of results to return
+     * @default 100
+     */
+    maxResults?: number;
+    /**
+     * Number of context lines before and after match
+     * @default 2
+     */
+    contextLines?: number;
+    /**
+     * Maximum depth to traverse
+     * @default 20
+     */
+    maxDepth?: number;
+}
+/**
+ * Create a search executor using regex pattern matching
+ *
+ * @example
+ * ```typescript
+ * const search = createSearchExecutor({
+ *   maxResults: 50,
+ *   contextLines: 3,
+ * })
+ *
+ * const results = await search("function\\s+handleClick", "/path/to/project", context)
+ * ```
+ */
+export declare function createSearchExecutor(options?: SearchExecutorOptions): SearchExecutor;