@sctg/cline-core 3.84.0-beta.20260524130712

package/dist/extensions/plugin/plugin-loader.d.ts

@@ -0,0 +1,22 @@
+import type { AgentExtension, PluginSetupContext } from "@cline/shared";
+import type { PluginInitializationFailure, PluginInitializationWarning } from "./plugin-load-report";
+import { type PluginTargeting } from "./plugin-targeting";
+export interface LoadAgentPluginFromPathOptions {
+    exportName?: string;
+    cwd?: string;
+    useCache?: boolean;
+    session?: PluginSetupContext["session"];
+    client?: PluginSetupContext["client"];
+    user?: PluginSetupContext["user"];
+    workspaceInfo?: PluginSetupContext["workspaceInfo"];
+    automation?: PluginSetupContext["automation"];
+    logger?: PluginSetupContext["logger"];
+    telemetry?: PluginSetupContext["telemetry"];
+}
+export declare function loadAgentPluginFromPath(pluginPath: string, options?: LoadAgentPluginFromPathOptions): Promise<AgentExtension>;
+export declare function loadAgentPluginsFromPaths(pluginPaths: string[], options?: LoadAgentPluginFromPathOptions & PluginTargeting): Promise<AgentExtension[]>;
+export declare function loadAgentPluginsFromPathsWithDiagnostics(pluginPaths: string[], options?: LoadAgentPluginFromPathOptions & PluginTargeting): Promise<{
+    plugins: AgentExtension[];
+    failures: PluginInitializationFailure[];
+    warnings: PluginInitializationWarning[];
+}>;

package/dist/extensions/plugin/plugin-module-import.d.ts

@@ -0,0 +1,4 @@
+export interface ImportPluginModuleOptions {
+    useCache?: boolean;
+}
+export declare function importPluginModule(pluginPath: string, options?: ImportPluginModuleOptions): Promise<Record<string, unknown>>;

package/dist/extensions/plugin/plugin-sandbox.d.ts

@@ -0,0 +1,36 @@
+import type { AgentConfig, PluginSetupContext, WorkspaceInfo } from "@cline/shared";
+import type { PluginLoadDiagnostics } from "./plugin-load-report";
+import type { PluginTargeting } from "./plugin-targeting";
+export type SandboxedPluginSetupContext = Pick<PluginSetupContext, "session" | "client" | "user" | "workspaceInfo" | "logger">;
+export interface PluginSandboxOptions extends PluginTargeting {
+    pluginPaths: string[];
+    exportName?: string;
+    importTimeoutMs?: number;
+    hookTimeoutMs?: number;
+    contributionTimeoutMs?: number;
+    onEvent?: (event: {
+        name: string;
+        payload?: unknown;
+    }) => void;
+    /**
+     * The session's working directory. Forwarded to the sandbox subprocess so
+     * that `process.cwd()` returns the correct path inside the sandbox even
+     * when `--cwd` was passed without calling `process.chdir()` on the host.
+     */
+    cwd?: string;
+    /**
+     * Structured workspace and git metadata (branch, commit, remotes) generated
+     * at session startup. Forwarded to plugins via PluginSetupCtx.workspaceInfo
+     * so they can inspect git state without running their own commands.
+     */
+    workspaceInfo?: WorkspaceInfo;
+    session?: SandboxedPluginSetupContext["session"];
+    client?: SandboxedPluginSetupContext["client"];
+    user?: SandboxedPluginSetupContext["user"];
+    /** Enables a logger bridge that forwards sandbox log calls to the host. */
+    logger?: SandboxedPluginSetupContext["logger"];
+}
+export declare function loadSandboxedPlugins(options: PluginSandboxOptions): Promise<{
+    extensions: AgentConfig["extensions"];
+    shutdown: () => Promise<void>;
+} & PluginLoadDiagnostics>;

package/dist/extensions/plugin/plugin-targeting.d.ts

@@ -0,0 +1,6 @@
+import type { PluginManifest } from "@cline/shared";
+export interface PluginTargeting {
+    providerId?: string;
+    modelId?: string;
+}
+export declare function matchesPluginManifestTargeting(manifest: PluginManifest | undefined, targeting: PluginTargeting | undefined): boolean;

package/dist/extensions/plugin-sandbox-bootstrap.js

@@ -0,0 +1 @@
+import{createRequire as GG}from"node:module";var QG=GG(import.meta.url);import{normalizePluginManifest as jG}from"@cline/shared";import{existsSync as _,readFileSync as C}from"node:fs";import{builtinModules as UG,createRequire as b}from"node:module";import{dirname as M,extname as O,isAbsolute as XG,resolve as K}from"node:path";import{fileURLToPath as P}from"node:url";import{PLUGIN_FILE_EXTENSIONS as YG}from"@cline/shared";var h=M(P(import.meta.url)),ZG=b(import.meta.url),$G=K(h,"..","..","..","..",".."),S=WG($G),qG=["@cline/sdk","@cline/agents","@cline/core","@cline/core/hub","@cline/core/hub/daemon-entry","@cline/core/telemetry","@cline/llms","@cline/llms/browser","@cline/shared","@cline/shared/automation","@cline/shared/browser","@cline/shared/storage","@cline/shared/db","@cline/shared/types"],y=new Set(UG.flatMap((G)=>[G,G.replace(/^node:/,"")])),I=new Set(YG),KG=["development","node","import","require","default"];function WG(G){let Q={},U={"@cline/sdk":K(G,"packages/sdk/src/index.ts"),"@cline/agents":K(G,"packages/agents/src/index.ts"),"@cline/core":K(G,"packages/core/src/index.ts"),"@cline/llms":K(G,"packages/llms/src/index.ts"),"@cline/shared":K(G,"packages/shared/src/index.ts"),"@cline/shared/storage":K(G,"packages/shared/src/storage/index.ts"),"@cline/shared/db":K(G,"packages/shared/src/db/index.ts")};for(let[Y,Z]of Object.entries(U))if(_(Z))Q[Y]=Z;for(let Y of["agents","core","llms","shared"]){let Z=K(G,"packages",Y),$=K(Z,"package.json");if(!_($))continue;try{let X=JSON.parse(C($,"utf8"));if(typeof X.name!=="string"||!X.exports)continue;if(typeof X.exports==="string"){let q=K(Z,X.exports);if(_(q))Q[X.name]=q;continue}if(typeof X.exports!=="object")continue;for(let[q,w]of Object.entries(X.exports)){let A=_G(Z,w);if(!A)continue;let L=q==="."?X.name:`${X.name}/${q.replace(/^\.\//,"")}`;Q[L]=A}}catch{}}return Q}function _G(G,Q){let U=R(Q);if(!U)return null;let Y=m(G,U);for(let Z of Y)if(_(Z))return Z;return null}function R(G,Q=new Set){if(typeof G==="string")return G;if(!G||typeof G!=="object")return null;if(Q.has(G))return null;Q.add(G);let U=G;for(let Y of KG){let Z=R(U[Y],Q);if(Z)return Z}return null}function m(G,Q){let U=Q.replace(/^\.\//,""),Y=[K(G,Q)];if(U.startsWith("dist/")){let Z=U.replace(/^dist\//,"src/").replace(/\.(mjs|cjs|js)$/,"");return[K(G,`${Z}.ts`),K(G,`${Z}.tsx`),K(G,`${Z}.mts`),K(G,`${Z}.cts`),...Y]}return Y}function LG(G){return Object.fromEntries(Object.entries(G).sort(([Q],[U])=>U.length-Q.length))}function D(G){return!(G.startsWith(".")||G.startsWith("/")||G.startsWith("file:")||G.startsWith("data:")||G.startsWith("http:")||G.startsWith("https:"))}function J(G){if(G.startsWith("@")){let[Q,U]=G.split("/",3);return U?`${Q}/${U}`:G}return G.split("/",1)[0]??G}function wG(G){let Q=J(G);if(G===Q)return".";return`.${G.slice(Q.length)}`}function d(G){return J(G).startsWith("@cline/")}function V(G,Q){let U=J(Q),Y=M(G);while(!0){let Z=K(Y,"node_modules",U);if(_(Z)||_(K(Z,"package.json")))return!0;let $=K(Y,"..");if($===Y)return!1;Y=$}}function f(G){return T(G)!==null}function T(G){try{return ZG.resolve(G)}catch{}return AG(G)}function AG(G){let Q=J(G),U=u(Q);if(!U)return null;let Y=K(U,"package.json");try{let Z=JSON.parse(C(Y,"utf8")),$=wG(G),X=$==="."&&typeof Z.exports==="string"?Z.exports:Z.exports&&typeof Z.exports==="object"&&Object.hasOwn(Z.exports,$)?Z.exports[$]:void 0,q=R(X)??($==="."&&typeof Z.main==="string"?Z.main:null);if(!q)return null;let w=K(U,q),A=[w,...m(U,q).filter((L)=>L!==w)];for(let L of A)if(_(L))return L;return null}catch{return null}}function zG(){let G=[h],Q=process.env.CLINE_WRAPPER_PATH?.trim();if(Q)G.push(M(M(Q)));let U=process.execPath?.trim();if(U)G.push(M(U));return[...new Set(G.map((Y)=>K(Y)))]}function MG(G,Q){let U=G;while(!0){let Y=K(U,"package.json");if(_(Y))try{if(JSON.parse(C(Y,"utf8")).name===Q)return U}catch{}let Z=K(U,"node_modules",Q,"package.json");if(_(Z))return M(Z);let $=K(U,"..");if($===U)return null;U=$}}function u(G){for(let Q of zG()){let U=MG(Q,G);if(U)return U}return null}function FG(G){let U=M(G);for(let Y=0;Y<4;Y++){let Z=K(U,"package.json");if(_(Z))try{let X=JSON.parse(C(Z,"utf8"));return X!=null&&typeof X==="object"&&"cline"in X}catch{return!1}let $=K(U,"..");if($===U)return!1;U=$}return!1}function l(G,Q){let U=Q.startsWith("file:")?P(Q):XG(Q)?Q:K(M(G),Q);if(_(U)&&I.has(O(U)))return U;for(let Y of I){let Z=`${U}${Y}`;if(_(Z))return Z}for(let Y of I){let Z=K(U,`index${Y}`);if(_(Z))return Z}return null}function c(G){let Q=new Set,U=[/\bimport\s+(?:type\s+)?[^"'`]*?\bfrom\s*["'`]([^"'`]+)["'`]/g,/\bexport\s+[^"'`]*?\bfrom\s*["'`]([^"'`]+)["'`]/g,/\bimport\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g,/\brequire\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g];for(let Y of U)for(let Z of G.matchAll(Y)){let $=Z[1];if($)Q.add($)}return[...Q]}function JG(G){return O(G)!==".ts"}function g(G,Q,U=new Set){if(U.has(G)||!_(G))return;if(U.add(G),!I.has(O(G)))return;let Y=C(G,"utf8"),Z=JG(G);for(let $ of c(Y)){if($.startsWith("node:")||y.has($))continue;if(D($)){if(!Z)continue;if(Object.hasOwn(S,$)||Object.hasOwn(S,J($))||V(G,$)||d($)&&f($)||Q&&f($))continue;throw Error(`Cannot find module '${J($)}'`)}let X=l(G,$);if(X)g(X,Q,U)}}function n(G,Q=new Set,U=new Set){if(Q.has(G)||!_(G))return U;if(Q.add(G),!I.has(O(G)))return U;let Y=C(G,"utf8");for(let Z of c(Y)){if(U.add(Z),D(Z))continue;let $=l(G,Z);if($)n($,Q,U)}return U}function CG(G,Q){let U=b(G),Y={},Z=n(G),$=new Set(qG);for(let[X,q]of Object.entries(S)){try{U.resolve(X);continue}catch{}Y[X]=q}for(let X of Z)if(D(X)&&(d(X)||Q))$.add(X);for(let X of $){if(Object.hasOwn(Y,X)||V(G,X))continue;let q=T(X);if(q)Y[X]=q}if(!Q)return Y;for(let X of Z){if(!D(X)||Object.hasOwn(Y,X)||V(G,X)||X.startsWith("node:")||y.has(X))continue;let q=T(X);if(q)Y[X]=q}return Y}function IG(G){let Q=O(G);return Q===".ts"||Q===".tsx"||Q===".mts"||Q===".cts"}var F;function OG(){if(F!==void 0)return F;let G=u("jiti");if(!G)return F=null,null;let Q=K(G,"dist","babel.cjs");if(!_(Q))return F=null,null;try{let Y=b(Q)(Q);F=typeof Y==="function"?Y:null}catch{F=null}return F}async function o(G,Q={}){let U=!FG(G);g(G,U);let Y=CG(G,U),Z=LG(Y),$=await import("jiti"),X=typeof $==="function"?$:typeof $.default==="function"?$.default:void 0;if(!X)throw Error("Unable to load jiti");let q=Object.entries(Z).filter(([,W])=>IG(W)).map(([W])=>W),w=OG(),A=w?(W)=>w({...W,interopDefault:!0}):void 0;return await X(G,{alias:Z,cache:Q.useCache,requireCache:Q.useCache,esmResolve:!0,interopDefault:!1,nativeModules:[...y],transformModules:q,tryNative:!1,...A?{transform:A}:{}}).import(G,{})}function p(G,Q){if(!G)return!0;if(G.providerIds?.length){if(!Q?.providerId||!G.providerIds.includes(Q.providerId))return!1}if(G.modelIds?.length){if(!Q?.modelId||!G.modelIds.includes(Q.modelId))return!1}return!0}function z(G){return typeof G==="object"&&G!==null}function s(G){return Array.isArray(G)&&G.every((Q)=>typeof Q==="string")}function BG(G,Q){if(!z(G))throw Error(`Invalid plugin module: ${Q}`);if(typeof G.name!=="string"||!G.name)throw Error(`Invalid plugin name: ${Q}`);if(!z(G.manifest))throw Error(`Invalid plugin manifest: ${Q}`);if(Object.hasOwn(G.manifest,"providerIds")&&!s(G.manifest.providerIds))throw Error(`Invalid plugin manifest.providerIds: ${Q}`);if(Object.hasOwn(G.manifest,"modelIds")&&!s(G.manifest.modelIds))throw Error(`Invalid plugin manifest.modelIds: ${Q}`)}function DG(G){if(!z(G))throw Error("Plugin setup context must be an object");if(G.session!==void 0&&!z(G.session))throw Error("Plugin setup context session must be an object");if(G.client!==void 0&&!z(G.client))throw Error("Plugin setup context client must be an object");if(G.user!==void 0&&!z(G.user))throw Error("Plugin setup context user must be an object");if(G.workspaceInfo!==void 0&&!z(G.workspaceInfo))throw Error("Plugin setup context workspaceInfo must be an object");if(G.automation!==void 0&&!z(G.automation))throw Error("Plugin setup context automation must be an object");if(G.automation!==void 0&&typeof G.automation.ingestEvent!=="function")throw Error("Plugin setup context automation.ingestEvent must be a function");if(G.logger!==void 0&&!z(G.logger))throw Error("Plugin setup context logger must be an object")}var t=0,H=new Map,v=new Map;function HG(G){let Q=G instanceof Error?G.message:String(G),U=G instanceof Error?G.stack:void 0;return{message:Q,stack:U}}function k(G,Q,U,Y){if(!process.send)return;process.send({type:"response",id:G,ok:Q,result:U,error:Y})}function x(G,Q){if(!process.send)return;process.send({type:"event",name:G,payload:Q})}globalThis.__clinePluginHost={emitEvent:x};globalThis.__clineSessionEnv={cwd:void 0,workspaceInfo:void 0};function i(G){if(!G||typeof G!=="object")return{};return G}function NG(G){if(!G||typeof G!=="object")return;let Q={...G};if(Q.error instanceof Error)Q.error={name:Q.error.name,message:Q.error.message,stack:Q.error.stack};return Q}function EG(G){let Q=(U,Y,Z)=>{x("plugin_log",{level:U,pluginName:G,message:Y,metadata:NG(Z)})};return{debug:(U,Y)=>Q("debug",U,Y),log:(U,Y)=>Q("log",U,Y),error:(U,Y)=>Q("error",U,Y)}}function j(G,Q){let U=`${G}:${Q}`,Y=(v.get(U)??0)+1;return v.set(U,Y),`${G}_${Q}_${Y}`}function SG(G){let Q=typeof G.eventType==="string"?G.eventType.trim():"",U=typeof G.source==="string"?G.source.trim():"";if(!Q)throw Error("Automation event type contribution requires eventType");if(!U)throw Error("Automation event type contribution requires source");return{...G,eventType:Q,source:U,examples:G.examples?[...G.examples]:void 0,metadata:G.metadata?i(G.metadata):void 0}}function N(G){let Q=H.get(G);if(!Q)throw Error(`Unknown sandbox plugin id: ${G}`);return Q}async function VG(G){let Q;try{let U=await o(G.pluginPath);if(Q=U.default??U[G.exportName],BG(Q,G.pluginPath),Q.manifest=jG(Q.manifest),!p(Q.manifest,G.targeting))return{type:"skipped"};let Y={tools:[],commands:[],messageBuilders:[],providers:[],automationEventTypes:[],shortcuts:[],flags:[]},Z={tools:new Map,commands:new Map,messageBuilders:new Map},$={registerTool:(X)=>{let q=j(G.pluginId,"tool");Z.tools.set(q,X.execute),Y.tools.push({id:q,name:X.name,description:X.description,inputSchema:X.inputSchema,timeoutMs:X.timeoutMs,retryable:X.retryable})},registerCommand:(X)=>{let q=j(G.pluginId,"command");if(typeof X.handler==="function")Z.commands.set(q,X.handler);Y.commands.push({id:q,name:X.name,description:X.description})},registerMessageBuilder:(X)=>{let q=j(G.pluginId,"builder");Z.messageBuilders.set(q,X.build),Y.messageBuilders.push({id:q,name:X.name})},registerProvider:(X)=>{Y.providers.push({id:j(G.pluginId,"provider"),name:X.name,description:X.description,metadata:i(X.metadata)})},registerAutomationEventType:(X)=>{Y.automationEventTypes.push({id:j(G.pluginId,"automation_event"),...SG(X)})}};if(typeof Q.setup==="function")try{let X={...G.setupCtxBase,...G.loggerEnabled?{logger:EG(Q.name)}:{},...Q.manifest.capabilities.includes("automationEvents")?{automation:{ingestEvent:(q)=>{x("automation_event",q)}}}:{}};DG(X),await Q.setup($,X)}catch(X){return{type:"failure",failure:{pluginPath:G.pluginPath,pluginName:Q.name,phase:"setup",message:X instanceof Error?X.message:String(X),stack:X instanceof Error?X.stack:void 0}}}return{type:"loaded",state:{plugin:Q,handlers:Z},descriptor:{pluginId:G.pluginId,pluginPath:G.pluginPath,name:Q.name,manifest:Q.manifest,hooks:Q.hooks?Object.entries(Q.hooks).filter(([,X])=>typeof X==="function").map(([X])=>X):void 0,contributions:Y}}}catch(U){return{type:"failure",failure:{pluginPath:G.pluginPath,pluginName:Q?.name,phase:"load",message:U instanceof Error?U.message:String(U),stack:U instanceof Error?U.stack:void 0}}}}async function TG(G){if(H.clear(),t=0,v.clear(),G.cwd)try{process.chdir(G.cwd)}catch{}let Q=globalThis.__clineSessionEnv;if(Q)Q.cwd=G.cwd,Q.workspaceInfo=G.workspaceInfo;let U=[],Y=[],Z=[],$=G.exportName||"plugin",X=new Map,q={providerId:G.providerId,modelId:G.modelId},w={session:G.session,client:G.client,user:G.user,workspaceInfo:G.workspaceInfo},A=await Promise.all((G.pluginPaths||[]).map((L)=>{let W=`plugin_${++t}`;return VG({pluginPath:L,pluginId:W,exportName:$,targeting:q,setupCtxBase:w,loggerEnabled:G.loggerEnabled})}));for(let L of A){if(L.type==="skipped")continue;if(L.type==="failure"){Y.push(L.failure);continue}let{descriptor:W,state:r}=L,E=X.get(W.name);if(E!==void 0){let B=U[E];if(!B)X.delete(W.name);else{Z.push({type:"duplicate_plugin_override",pluginName:W.name,pluginPath:W.pluginPath,overriddenPluginPath:B.pluginPath,message:`Plugin "${W.name}" from ${W.pluginPath} overrides ${B.pluginPath}`}),H.delete(B.pluginId),U.splice(E,1),X.clear();for(let[a,e]of U.entries())X.set(e.name,a)}}H.set(W.pluginId,r),X.set(W.name,U.length),U.push(W)}return{plugins:U,failures:Y,warnings:Z}}async function bG(G){let U=N(G.pluginId).plugin.hooks?.[G.hookName];if(typeof U!=="function")return;return await U(G.payload)}async function yG(G){let U=N(G.pluginId).handlers.tools.get(G.contributionId);if(typeof U!=="function")throw Error("Unknown sandbox tool contribution");return await U(G.input,G.context)}async function RG(G){let U=N(G.pluginId).handlers.commands.get(G.contributionId);if(typeof U!=="function")return"";return await U(G.input)}async function kG(G){let U=N(G.pluginId).handlers.messageBuilders.get(G.contributionId);if(typeof U!=="function")return[];return await U(G.messages)}var vG={initialize:TG,invokeHook:bG,executeTool:yG,executeCommand:RG,buildMessages:kG};process.on("message",async(G)=>{if(!G||G.type!=="call")return;let Q=vG[G.method];if(!Q){k(G.id,!1,void 0,{message:`Unknown method: ${String(G.method)}`});return}try{let U=await Q(G.args||{});k(G.id,!0,U)}catch(U){k(G.id,!1,void 0,HG(U))}});

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;