@cline/core 0.0.38-nightly.1778113663

package/dist/extensions/tools/constants.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Constants for Default Tools
+ *
+ * Tool name constants and utility arrays.
+ */
+import type { DefaultToolName } from "./types";
+/**
+ * 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";
+    readonly SUBMIT_AND_EXIT: "submit_and_exit";
+};
+/**
+ * Array of all default tool names
+ */
+export declare const ALL_DEFAULT_TOOL_NAMES: DefaultToolName[];

package/dist/extensions/tools/definitions.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Default AgentTool Definitions
+ *
+ * Factory functions for creating the default tools.
+ */
+import { type AgentTool } from "@cline/shared";
+import { type ApplyPatchInput, type AskQuestionInput, type EditFileInput, type FetchWebContentInput, type ReadFilesInput, type RunCommandsInput, type SearchCodebaseInput, type SkillsInput, type StructuredCommandInput, type SubmitInput } from "./schemas";
+import type { ApplyPatchExecutor, AskQuestionExecutor, BashExecutor, CreateDefaultToolsOptions, DefaultToolsConfig, EditorExecutor, FileReadExecutor, SearchExecutor, SkillsExecutorWithMetadata, ToolOperationResult, VerifySubmitExecutor, WebFetchExecutor } from "./types";
+/**
+ * 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">): AgentTool<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">): AgentTool<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">): AgentTool<RunCommandsInput, ToolOperationResult[]>;
+/**
+ * Create the run_commands tool
+ *
+ * Executes shell commands in the project directory.
+ */
+export declare function createWindowsShellTool(executor: BashExecutor, config?: Pick<DefaultToolsConfig, "cwd" | "bashTimeoutMs">): AgentTool<StructuredCommandInput, 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">): AgentTool<FetchWebContentInput, ToolOperationResult[]>;
+/**
+ * Create the apply_patch tool
+ *
+ * Applies the canonical apply_patch format to one or more files.
+ */
+export declare function createApplyPatchTool(executor: ApplyPatchExecutor, config?: Pick<DefaultToolsConfig, "cwd" | "applyPatchTimeoutMs">): AgentTool<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">): AgentTool<EditFileInput, ToolOperationResult>;
+/**
+ * Create the skills tool
+ *
+ * Invokes a configured skill by name and optional arguments.
+ */
+export declare function createSkillsTool(executor: SkillsExecutorWithMetadata, config?: Pick<DefaultToolsConfig, "skillsTimeoutMs">): AgentTool<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): AgentTool<AskQuestionInput, string>;
+export declare function createSubmitAndExitTool(executor: VerifySubmitExecutor, config?: Pick<DefaultToolsConfig, "submitTimeoutMs">): AgentTool<SubmitInput, 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, createDefaultTools } from "@cline/core"
+ * 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): AgentTool[];

package/dist/extensions/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/extensions/tools/executors/apply-patch.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Apply Patch Executor
+ *
+ * Built-in implementation for the documented GPT-5 apply_patch grammar.
+ * It accepts the freeform patch body directly and tolerates the legacy shell
+ * wrapper form used by older prompts.
+ */
+import type { ApplyPatchExecutor } from "../types";
+/**
+ * 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/extensions/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";
+/**
+ * Options for the bash executor
+ */
+export interface BashExecutorOptions {
+    /**
+     * Shell to use for execution
+     * @default "/bin/bash" on Unix, "powershell" 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/extensions/tools/executors/editor.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Editor Executor
+ *
+ * Built-in implementation for filesystem editing operations.
+ */
+import type { EditorExecutor } from "../types";
+/**
+ * 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/extensions/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";
+/**
+ * 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: "/path/to/file.ts" }, context)
+ * ```
+ */
+export declare function createFileReadExecutor(options?: FileReadExecutorOptions): FileReadExecutor;

package/dist/extensions/tools/executors/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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";
+import { type ApplyPatchExecutorOptions } from "./apply-patch";
+import { type BashExecutorOptions } from "./bash";
+import { type EditorExecutorOptions } from "./editor";
+import { type FileReadExecutorOptions } from "./file-read";
+import { type SearchExecutorOptions } from "./search";
+import { type WebFetchExecutorOptions } from "./web-fetch";
+export { type ApplyPatchExecutorOptions, createApplyPatchExecutor, } from "./apply-patch";
+export { type BashExecutorOptions, createBashExecutor, } from "./bash";
+export { createEditorExecutor, type EditorExecutorOptions } from "./editor";
+export { createFileReadExecutor, type FileReadExecutorOptions, } from "./file-read";
+export { createSearchExecutor, type SearchExecutorOptions } from "./search";
+export { createWebFetchExecutor, type WebFetchExecutorOptions, } from "./web-fetch";
+/**
+ * Options for creating default executors
+ */
+export interface DefaultExecutorsOptions {
+    fileRead?: FileReadExecutorOptions;
+    search?: SearchExecutorOptions;
+    bash?: BashExecutorOptions;
+    webFetch?: WebFetchExecutorOptions;
+    applyPatch?: ApplyPatchExecutorOptions;
+    editor?: EditorExecutorOptions;
+}
+/**
+ * Create all default executors with optional configuration
+ *
+ * @example
+ * ```typescript
+ * import { createDefaultTools, createDefaultExecutors } from "@cline/core"
+ *
+ * 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/extensions/tools/executors/search.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Search Executor
+ *
+ * Built-in implementation for searching the codebase using ripgrep (if available) or regex.
+ */
+import type { SearchExecutor } from "../types";
+/**
+ * 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;

package/dist/extensions/tools/executors/web-fetch.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Web Fetch Executor
+ *
+ * Built-in implementation for fetching web content using native fetch.
+ */
+import type { WebFetchExecutor } from "../types";
+/**
+ * Options for the web fetch executor
+ */
+export interface WebFetchExecutorOptions {
+    /**
+     * Timeout for fetch requests in milliseconds
+     * @default 30000 (30 seconds)
+     */
+    timeoutMs?: number;
+    /**
+     * Maximum response size in bytes
+     * @default 5_000_000 (5MB)
+     */
+    maxResponseBytes?: number;
+    /**
+     * User agent string
+     * @default "Mozilla/5.0 (compatible; AgentBot/1.0)"
+     */
+    userAgent?: string;
+    /**
+     * Additional headers
+     */
+    headers?: Record<string, string>;
+    /**
+     * Whether to follow redirects
+     * @default true
+     */
+    followRedirects?: boolean;
+    /**
+     * Maximum number of redirects to follow
+     * @default 5
+     */
+    maxRedirects?: number;
+}
+/**
+ * Create a web fetch executor using native fetch
+ *
+ * @example
+ * ```typescript
+ * const webFetch = createWebFetchExecutor({
+ *   timeoutMs: 15000,
+ *   maxResponseBytes: 2_000_000,
+ * })
+ *
+ * const content = await webFetch(
+ *   "https://docs.example.com/api",
+ *   "Extract the authentication section",
+ *   context
+ * )
+ * ```
+ */
+export declare function createWebFetchExecutor(options?: WebFetchExecutorOptions): WebFetchExecutor;

package/dist/extensions/tools/helpers.d.ts

@@ -0,0 +1,15 @@
+import { type EditFileInput, type ReadFileRequest, type StructuredCommandInput } from "./schemas";
+/**
+ * Format an error into a string message
+ */
+export declare function formatError(error: unknown): string;
+export declare function getEditorSizeError(input: EditFileInput): string | null;
+/**
+ * Create a timeout-wrapped promise
+ */
+export declare function withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T>;
+export declare function normalizeReadFileRequests(input: unknown): ReadFileRequest[];
+export declare function formatReadFileQuery(request: ReadFileRequest): string;
+export declare function getReadFileRangeError(request: ReadFileRequest): string | null;
+export declare function normalizeRunCommandsInput(input: unknown): Array<string | StructuredCommandInput>;
+export declare function formatRunCommandQuery(command: string | StructuredCommandInput): string;

package/dist/extensions/tools/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Default Tools
+ *
+ * This module provides a set of configurable default tools for agents.
+ */
+export { validateWithZod, zodToJsonSchema } from "@cline/shared";
+export { ALL_DEFAULT_TOOL_NAMES, DefaultToolNames } from "./constants";
+export { createApplyPatchTool, createAskQuestionTool, createBashTool, createDefaultTools, createEditorTool, createReadFilesTool, createSearchTool, createSkillsTool, createSubmitAndExitTool, createWebFetchTool, createWindowsShellTool, } from "./definitions";
+export { type ApplyPatchExecutorOptions, type BashExecutorOptions, createApplyPatchExecutor, createBashExecutor, createDefaultExecutors, createEditorExecutor, createFileReadExecutor, createSearchExecutor, createWebFetchExecutor, type DefaultExecutorsOptions, type EditorExecutorOptions, type FileReadExecutorOptions, type SearchExecutorOptions, type WebFetchExecutorOptions, } from "./executors/index";
+export { DEFAULT_MODEL_TOOL_ROUTING_RULES, resolveToolRoutingConfig, type ToolRoutingRule, } from "./model-tool-routing";
+export { createDefaultToolsWithPreset, createToolPoliciesWithPreset, resolveToolPresetName, type ToolPolicyPresetName, type ToolPresetName, ToolPresets, } from "./presets";
+export { type BuiltinToolAvailabilityContext, getCoreAcpToolNames, getCoreBuiltinToolCatalog, getCoreDefaultEnabledToolIds, getCoreHeadlessToolNames, resolveCoreSelectedToolIds, type ToolCatalogEntry, } from "./runtime";
+export { type ApplyPatchInput, ApplyPatchInputSchema, type AskQuestionInput, AskQuestionInputSchema, type EditFileInput, EditFileInputSchema, type FetchWebContentInput, FetchWebContentInputSchema, type ReadFileRequest, ReadFileRequestSchema, type ReadFilesInput, ReadFilesInputSchema, type RunCommandsInput, RunCommandsInputSchema, type SearchCodebaseInput, SearchCodebaseInputSchema, type SkillsInput, SkillsInputSchema, type SubmitInput, SubmitInputSchema, type WebFetchRequest, WebFetchRequestSchema, } from "./schemas";
+export { TEAM_TOOL_NAMES } from "./team/team-tools";
+export type { ApplyPatchExecutor, AskQuestionExecutor, BashExecutor, CreateDefaultToolsOptions, DefaultToolName, DefaultToolsConfig, EditorExecutor, FileReadExecutor, SearchExecutor, SkillsExecutor, SkillsExecutorSkillMetadata, SkillsExecutorWithMetadata, ToolExecutors, ToolOperationResult, VerifySubmitExecutor, WebFetchExecutor, } from "./types";
+import type { AgentTool } from "@cline/shared";
+import { type DefaultExecutorsOptions } from "./executors/index";
+import type { CreateDefaultToolsOptions, ToolExecutors } from "./types";
+/**
+ * Options for creating default tools with built-in executors
+ */
+export interface CreateBuiltinToolsOptions extends Omit<CreateDefaultToolsOptions, "executors"> {
+    /**
+     * Configuration for the built-in executors
+     */
+    executorOptions?: DefaultExecutorsOptions;
+    /**
+     * Optional executor overrides/additions for tools without built-ins
+     */
+    executors?: Partial<ToolExecutors>;
+}
+/**
+ * Create default tools with built-in Node.js executors
+ *
+ * This is a convenience function that creates the default tools with
+ * working implementations using Node.js built-in modules.
+ *
+ * @example
+ * ```typescript
+ * import { Agent, createBuiltinTools } from "@cline/core"
+ *
+ * const tools = createBuiltinTools({
+ *   cwd: "/path/to/project",
+ *   enableBash: true,
+ *   enableWebFetch: false, // Disable web fetching
+ *   executorOptions: {
+ *     bash: { timeoutMs: 60000 },
+ *   },
+ * })
+ *
+ * const agent = new Agent({
+ *   providerId: "anthropic",
+ *   modelId: "claude-sonnet-4-20250514",
+ *   systemPrompt: "You are a coding assistant.",
+ *   tools,
+ * })
+ * ```
+ */
+export declare function createBuiltinTools(options?: CreateBuiltinToolsOptions): AgentTool[];

package/dist/extensions/tools/model-tool-routing.d.ts

@@ -0,0 +1,33 @@
+import type { CoreAgentMode } from "../../types/config";
+import type { DefaultToolName, DefaultToolsConfig } from "./types";
+export interface ToolRoutingRule {
+    /**
+     * Optional rule label for debugging and logs.
+     */
+    name?: string;
+    /**
+     * Which mode the rule applies to.
+     * @default "any"
+     */
+    mode?: CoreAgentMode | "any";
+    /**
+     * Case-insensitive substrings that must match the model ID.
+     * When omitted/empty, the rule is not constrained by model ID.
+     */
+    modelIdIncludes?: string[];
+    /**
+     * Case-insensitive substrings that must match the provider ID.
+     * When omitted/empty, the rule is not constrained by provider ID.
+     */
+    providerIdIncludes?: string[];
+    /**
+     * Enable these tools when the rule matches.
+     */
+    enableTools?: DefaultToolName[];
+    /**
+     * Disable these tools when the rule matches.
+     */
+    disableTools?: DefaultToolName[];
+}
+export declare const DEFAULT_MODEL_TOOL_ROUTING_RULES: ToolRoutingRule[];
+export declare function resolveToolRoutingConfig(providerId: string, modelId: string, mode: CoreAgentMode, rules: ToolRoutingRule[] | undefined): Partial<DefaultToolsConfig>;