codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/extensions/tools/executors/web-fetch.ts

@@ -0,0 +1,259 @@
+/**
+ * Web Fetch Executor
+ *
+ * Built-in implementation for fetching web content using native fetch.
+ */
+
+import type { AgentToolContext } from "@cline/shared";
+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;
+}
+
+/**
+ * Extract text content from HTML
+ * Simple implementation - strips tags and normalizes whitespace
+ */
+function htmlToText(html: string): string {
+	return (
+		html
+			// Remove script and style elements
+			.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "")
+			.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "")
+			// Remove HTML comments
+			.replace(/<!--[\s\S]*?-->/g, "")
+			// Replace block elements with newlines
+			.replace(/<(p|div|br|hr|h[1-6]|li|tr)[^>]*>/gi, "\n")
+			// Remove all remaining tags
+			.replace(/<[^>]+>/g, " ")
+			// Decode HTML entities
+			.replace(/&nbsp;/g, " ")
+			.replace(/&amp;/g, "&")
+			.replace(/&lt;/g, "<")
+			.replace(/&gt;/g, ">")
+			.replace(/&quot;/g, '"')
+			.replace(/&#(\d+);/g, (_, n) => String.fromCharCode(parseInt(n, 10)))
+			// Normalize whitespace
+			.replace(/\s+/g, " ")
+			.replace(/\n\s+/g, "\n")
+			.replace(/\n{3,}/g, "\n\n")
+			.trim()
+	);
+}
+
+/**
+ * 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 function createWebFetchExecutor(
+	options: WebFetchExecutorOptions = {},
+): WebFetchExecutor {
+	const {
+		timeoutMs = 30000,
+		maxResponseBytes = 5_000_000,
+		userAgent = "Mozilla/5.0 (compatible; AgentBot/1.0)",
+		headers = {},
+		followRedirects = true,
+		// maxRedirects is available in options but native fetch handles it automatically
+	} = options;
+
+	return async (
+		url: string,
+		prompt: string,
+		context: AgentToolContext,
+	): Promise<string> => {
+		// Validate URL
+		let parsedUrl: URL;
+		try {
+			parsedUrl = new URL(url);
+		} catch {
+			throw new Error(`Invalid URL: ${url}`);
+		}
+
+		// Only allow http and https
+		if (!["http:", "https:"].includes(parsedUrl.protocol)) {
+			throw new Error(
+				`Invalid protocol: ${parsedUrl.protocol}. Only http and https are supported.`,
+			);
+		}
+
+		// Create abort controller for timeout
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), timeoutMs);
+		let contextAbortHandler: (() => void) | undefined;
+
+		// Combine with context abort signal
+		if (context.signal) {
+			contextAbortHandler = () => controller.abort();
+			context.signal.addEventListener("abort", contextAbortHandler);
+		}
+
+		try {
+			const response = await fetch(url, {
+				method: "GET",
+				headers: {
+					"User-Agent": userAgent,
+					Accept:
+						"text/html,application/xhtml+xml,application/xml;q=0.9,text/plain;q=0.8,*/*;q=0.7",
+					"Accept-Language": "en-US,en;q=0.9",
+					...headers,
+				},
+				redirect: followRedirects ? "follow" : "manual",
+				signal: controller.signal,
+			});
+
+			clearTimeout(timeout);
+
+			// Check for redirect limit (if we're checking manually)
+			if (!followRedirects && response.status >= 300 && response.status < 400) {
+				const location = response.headers.get("location");
+				return `Redirect to: ${location}`;
+			}
+
+			// Check response status
+			if (!response.ok) {
+				throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+			}
+
+			// Get content type
+			const contentType = response.headers.get("content-type") || "";
+
+			// Read response body with size limit
+			const reader = response.body?.getReader();
+			if (!reader) {
+				throw new Error("Failed to read response body");
+			}
+
+			const chunks: Uint8Array[] = [];
+			let totalSize = 0;
+
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+
+				totalSize += value.length;
+				if (totalSize > maxResponseBytes) {
+					reader.cancel();
+					throw new Error(
+						`Response too large: exceeded ${maxResponseBytes} bytes`,
+					);
+				}
+
+				chunks.push(value);
+			}
+
+			// Combine chunks
+			const buffer = new Uint8Array(totalSize);
+			let offset = 0;
+			for (const chunk of chunks) {
+				buffer.set(chunk, offset);
+				offset += chunk.length;
+			}
+
+			// Decode as text
+			const text = new TextDecoder("utf-8").decode(buffer);
+
+			// Process content based on type
+			let content: string;
+			if (
+				contentType.includes("text/html") ||
+				contentType.includes("application/xhtml")
+			) {
+				content = htmlToText(text);
+			} else if (contentType.includes("application/json")) {
+				try {
+					const json = JSON.parse(text);
+					content = JSON.stringify(json, null, 2);
+				} catch {
+					content = text;
+				}
+			} else {
+				content = text;
+			}
+
+			// Format output with metadata
+			const outputLines = [
+				`URL: ${url}`,
+				`Content-Type: ${contentType}`,
+				`Size: ${totalSize} bytes`,
+				``,
+				`--- Content ---`,
+				content.slice(0, 50000), // Limit content size for output
+			];
+
+			if (content.length > 50000) {
+				outputLines.push(
+					`\n[Content truncated: showing first 50000 of ${content.length} characters]`,
+				);
+			}
+
+			outputLines.push(``, `--- Analysis Request ---`, `Prompt: ${prompt}`);
+
+			return outputLines.join("\n");
+		} catch (error) {
+			clearTimeout(timeout);
+
+			if (error instanceof Error) {
+				if (error.name === "AbortError") {
+					throw new Error(`Request timed out after ${timeoutMs}ms`);
+				}
+				throw error;
+			}
+			throw new Error(`Fetch failed: ${String(error)}`);
+		} finally {
+			if (context.signal && contextAbortHandler) {
+				context.signal.removeEventListener("abort", contextAbortHandler);
+			}
+		}
+	};
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/extensions/tools/helpers.ts

@@ -0,0 +1,126 @@
+import { validateWithZod } from "@cline/shared";
+import {
+	type EditFileInput,
+	INPUT_ARG_CHAR_LIMIT,
+	type ReadFileRequest,
+	type StructuredCommandInput,
+	StructuredCommandsInputUnionSchema,
+} from "./schemas";
+
+/**
+ * Format an error into a string message
+ */
+export function formatError(error: unknown): string {
+	if (error instanceof Error) {
+		return error.message;
+	}
+	return String(error);
+}
+
+export function getEditorSizeError(input: EditFileInput): string | null {
+	if (
+		typeof input.old_text === "string" &&
+		input.old_text.length > INPUT_ARG_CHAR_LIMIT
+	) {
+		return `Editor input too large: old_text was ${input.old_text.length} characters, exceeding the recommended limit of ${INPUT_ARG_CHAR_LIMIT}. Split the edit into smaller tool calls so later tool calls are less likely to be truncated or time out.`;
+	}
+
+	if (input.new_text.length > INPUT_ARG_CHAR_LIMIT) {
+		return `Editor input too large: new_text was ${input.new_text.length} characters, exceeding the recommended limit of ${INPUT_ARG_CHAR_LIMIT}. Split the edit into smaller tool calls so later tool calls are less likely to be truncated or time out.`;
+	}
+
+	return null;
+}
+
+/**
+ * Create a timeout-wrapped promise
+ */
+export class TimeoutError extends Error {
+	readonly timeoutMs: number;
+
+	constructor(message: string, timeoutMs: number) {
+		super(message);
+		this.name = "TimeoutError";
+		this.timeoutMs = timeoutMs;
+	}
+}
+
+export function withTimeout<T>(
+	promise: Promise<T>,
+	ms: number,
+	message: string,
+): Promise<T> {
+	return Promise.race([
+		promise,
+		new Promise<never>((_, reject) => {
+			setTimeout(() => reject(new TimeoutError(message, ms)), ms);
+		}),
+	]);
+}
+
+export function formatReadFileQuery(request: ReadFileRequest): string {
+	const { path, start_line, end_line } = request;
+	if (start_line == null && end_line == null) {
+		return path;
+	}
+	const start = start_line ?? 1;
+	const end = end_line ?? "EOF";
+	return `${path}:${start}-${end}`;
+}
+
+export function getReadFileRangeError(request: ReadFileRequest): string | null {
+	const { start_line, end_line } = request;
+	if (start_line == null || end_line == null || start_line <= end_line) {
+		return null;
+	}
+
+	return `start_line must be less than or equal to end_line (received start_line: ${start_line}, end_line: ${end_line})`;
+}
+
+export function normalizeRunCommandsInput(
+	input: unknown,
+): Array<string | StructuredCommandInput> {
+	const validate = validateWithZod(StructuredCommandsInputUnionSchema, input);
+
+	if (typeof validate === "string") {
+		return [validate];
+	}
+
+	if (Array.isArray(validate)) {
+		return validate;
+	}
+
+	if ("commands" in validate) {
+		return Array.isArray(validate.commands)
+			? validate.commands
+			: [validate.commands];
+	}
+
+	if ("command" in validate) {
+		return "args" in validate ? [validate] : [validate.command];
+	}
+
+	if ("cmd" in validate) {
+		return [validate.cmd];
+	}
+
+	return [validate];
+}
+
+export function formatRunCommandQuery(
+	command: string | StructuredCommandInput,
+): string {
+	if (typeof command === "string") {
+		return command;
+	}
+
+	const args = command.args ?? [];
+	if (args.length === 0) {
+		return command.command;
+	}
+
+	const renderedArgs = args.map((arg) =>
+		/[\s"]/u.test(arg) ? JSON.stringify(arg) : arg,
+	);
+	return `${command.command} ${renderedArgs.join(" ")}`;
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/extensions/tools/index.ts

@@ -0,0 +1,183 @@
+/**
+ * Default Tools
+ *
+ * This module provides a set of configurable default tools for agents.
+ */
+
+// Zod Utilities
+export { validateWithZod, zodToJsonSchema } from "@cline/shared";
+// Constants
+export { ALL_DEFAULT_TOOL_NAMES, DefaultToolNames } from "./constants";
+// AgentTool Definitions
+export {
+	createApplyPatchTool,
+	createAskQuestionTool,
+	createBashTool,
+	createDefaultTools,
+	createEditorTool,
+	createReadFilesTool,
+	createSearchTool,
+	createSkillsTool,
+	createSubmitAndExitTool,
+	createWebFetchTool,
+	createWindowsShellTool,
+} from "./definitions";
+// Built-in Executors
+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";
+// Presets
+export {
+	createDefaultToolsWithPreset,
+	createToolPoliciesWithPreset,
+	resolveToolPresetName,
+	type ToolPolicyPresetName,
+	type ToolPresetName,
+	ToolPresets,
+} from "./presets";
+export {
+	type BuiltinToolAvailabilityContext,
+	getCoreAcpToolNames,
+	getCoreBuiltinToolCatalog,
+	getCoreDefaultEnabledToolIds,
+	getCoreHeadlessToolNames,
+	resolveCoreSelectedToolIds,
+	type ToolCatalogEntry,
+} from "./runtime";
+// Schemas
+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";
+// Types
+export type {
+	ApplyPatchExecutor,
+	AskQuestionExecutor,
+	BashExecutor,
+	CreateDefaultToolsOptions,
+	DefaultToolName,
+	DefaultToolsConfig,
+	EditorExecutor,
+	FileReadExecutor,
+	SearchExecutor,
+	SkillsExecutor,
+	SkillsExecutorSkillMetadata,
+	SkillsExecutorWithMetadata,
+	ToolExecutors,
+	ToolOperationResult,
+	VerifySubmitExecutor,
+	WebFetchExecutor,
+} from "./types";
+
+// =============================================================================
+// Convenience: Create Tools with Built-in Executors
+// =============================================================================
+
+import type { AgentTool } from "@cline/shared";
+import { createDefaultTools } from "./definitions";
+import {
+	createDefaultExecutors,
+	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 function createBuiltinTools(
+	options: CreateBuiltinToolsOptions = {},
+): AgentTool[] {
+	const {
+		executorOptions = {},
+		executors: executorOverrides,
+		...toolsConfig
+	} = options;
+
+	const executors = {
+		...createDefaultExecutors(executorOptions),
+		...(executorOverrides ?? {}),
+	};
+
+	return createDefaultTools({
+		...toolsConfig,
+		executors,
+	});
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/extensions/tools/model-tool-routing.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import {
+	DEFAULT_MODEL_TOOL_ROUTING_RULES,
+	resolveToolRoutingConfig,
+} from "./model-tool-routing";
+
+describe("model tool routing", () => {
+	it("applies default codex/gpt routing in act mode", () => {
+		const config = resolveToolRoutingConfig(
+			"openai",
+			"openai/gpt-5.4",
+			"act",
+			DEFAULT_MODEL_TOOL_ROUTING_RULES,
+		);
+
+		expect(config.enableApplyPatch).toBe(true);
+		expect(config.enableEditor).toBe(false);
+	});
+
+	it("does not apply default codex/gpt routing in plan mode", () => {
+		const config = resolveToolRoutingConfig(
+			"openai",
+			"openai/gpt-5.4",
+			"plan",
+			DEFAULT_MODEL_TOOL_ROUTING_RULES,
+		);
+
+		expect(config).toEqual({});
+	});
+
+	it("applies matching custom rules in order", () => {
+		const config = resolveToolRoutingConfig(
+			"anthropic",
+			"claude-sonnet-4-6",
+			"act",
+			[
+				{
+					name: "claude-editor-off",
+					mode: "act",
+					modelIdIncludes: ["claude"],
+					disableTools: ["editor"],
+				},
+				{
+					name: "claude-apply-patch-on",
+					mode: "act",
+					modelIdIncludes: ["claude"],
+					enableTools: ["apply_patch"],
+				},
+			],
+		);
+
+		expect(config.enableEditor).toBe(false);
+		expect(config.enableApplyPatch).toBe(true);
+	});
+
+	it("returns empty config when no rules match", () => {
+		const config = resolveToolRoutingConfig(
+			"anthropic",
+			"claude-sonnet-4-6",
+			"act",
+			[
+				{
+					mode: "act",
+					modelIdIncludes: ["gpt"],
+					enableTools: ["apply_patch"],
+				},
+			],
+		);
+
+		expect(config).toEqual({});
+	});
+
+	it("can match provider-only rules", () => {
+		const config = resolveToolRoutingConfig("openai", "o4-mini", "act", [
+			{
+				mode: "act",
+				providerIdIncludes: ["openai"],
+				enableTools: ["apply_patch"],
+				disableTools: ["editor"],
+			},
+		]);
+
+		expect(config.enableApplyPatch).toBe(true);
+		expect(config.enableEditor).toBe(false);
+	});
+});