codna 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,261 @@
+import type { CoreAgentMode } from "../../types/config";
+import {
+	DEFAULT_MODEL_TOOL_ROUTING_RULES,
+	resolveToolRoutingConfig,
+} from "./model-tool-routing";
+import { resolveToolPresetName, ToolPresets } from "./presets";
+import { createSpawnAgentTool } from "./team/spawn-agent-tool";
+import { TEAM_TOOL_NAMES } from "./team/team-tools";
+import type { DefaultToolsConfig } from "./types";
+
+export interface ToolCatalogEntry {
+	id: string;
+	description: string;
+	defaultEnabled: boolean;
+	headlessToolNames: string[];
+}
+
+export interface BuiltinToolAvailabilityContext {
+	mode?: CoreAgentMode;
+	providerId?: string;
+	modelId?: string;
+	enableSpawnAgent?: boolean;
+	enableAgentTeams?: boolean;
+	disabledToolIds?: ReadonlySet<string>;
+}
+
+type RuntimeToolCatalogEntry = Omit<ToolCatalogEntry, "defaultEnabled">;
+
+const BASE_TOOL_CATALOG: readonly RuntimeToolCatalogEntry[] = [
+	{
+		id: "read_files",
+		description:
+			"Read the full content of text or image files at the provided absolute paths, or return only an inclusive one-based line range when start_line/end_line are provided.",
+		headlessToolNames: ["read_files"],
+	},
+	{
+		id: "search_codebase",
+		description:
+			"Perform regex pattern searches across the codebase for code patterns, definitions, imports, and other text matches.",
+		headlessToolNames: ["search_codebase"],
+	},
+	{
+		id: "run_commands",
+		description:
+			"Run shell commands from the root of the workspace for listing files, checking git status, builds, tests, and similar tasks.",
+		headlessToolNames: ["run_commands"],
+	},
+	{
+		id: "editor",
+		description:
+			"Make controlled filesystem edits on text files with create, replace, and insert operations.",
+		headlessToolNames: ["editor"],
+	},
+	{
+		id: "fetch_web_content",
+		description:
+			"Fetch URL content and analyze it with a prompt describing what to extract.",
+		headlessToolNames: ["fetch_web_content"],
+	},
+	{
+		id: "skills",
+		description:
+			"Execute a configured skill within the main conversation when a matching skill exists for the task.",
+		headlessToolNames: ["skills"],
+	},
+	{
+		id: "ask_question",
+		description:
+			"Ask the user a single clarifying question with 2-5 selectable options.",
+		headlessToolNames: ["ask_question"],
+	},
+	{
+		id: "spawn_agent",
+		description: createSpawnAgentTool({ configProvider: {} as never })
+			.description,
+		headlessToolNames: ["spawn_agent"],
+	},
+	{
+		id: "teams",
+		description:
+			"Enable team collaboration tools for teammate management, task coordination, mailbox messaging, mission logs, and outcomes.",
+		headlessToolNames: [...TEAM_TOOL_NAMES],
+	},
+] as const;
+
+const TOOL_NAME_TO_FLAG: Partial<
+	Record<
+		string,
+		keyof Pick<
+			DefaultToolsConfig,
+			| "enableReadFiles"
+			| "enableSearch"
+			| "enableBash"
+			| "enableWebFetch"
+			| "enableApplyPatch"
+			| "enableEditor"
+			| "enableSkills"
+			| "enableAskQuestion"
+			| "enableSubmitAndExit"
+		>
+	>
+> = {
+	read_files: "enableReadFiles",
+	search_codebase: "enableSearch",
+	run_commands: "enableBash",
+	fetch_web_content: "enableWebFetch",
+	apply_patch: "enableApplyPatch",
+	editor: "enableEditor",
+	skills: "enableSkills",
+	ask_question: "enableAskQuestion",
+};
+
+function resolveContextMode(
+	mode?: BuiltinToolAvailabilityContext["mode"],
+): CoreAgentMode {
+	return mode === "plan" || mode === "yolo" ? mode : "act";
+}
+
+type ResolvedToolFlags = Pick<
+	DefaultToolsConfig,
+	| "enableReadFiles"
+	| "enableSearch"
+	| "enableBash"
+	| "enableWebFetch"
+	| "enableApplyPatch"
+	| "enableEditor"
+	| "enableSkills"
+	| "enableAskQuestion"
+	| "enableSubmitAndExit"
+> & {
+	enableSpawnAgent?: boolean;
+	enableAgentTeams?: boolean;
+};
+
+function resolvePresetFlags(context: BuiltinToolAvailabilityContext): {
+	mode: CoreAgentMode;
+	flags: ResolvedToolFlags;
+} {
+	const mode = resolveContextMode(context.mode);
+	const preset = ToolPresets[resolveToolPresetName({ mode })];
+	const routed = resolveToolRoutingConfig(
+		context.providerId ?? "",
+		context.modelId ?? "",
+		mode,
+		DEFAULT_MODEL_TOOL_ROUTING_RULES,
+	);
+	return {
+		mode,
+		flags: {
+			...preset,
+			...routed,
+			...(typeof context.enableSpawnAgent === "boolean"
+				? { enableSpawnAgent: context.enableSpawnAgent }
+				: {}),
+			...(typeof context.enableAgentTeams === "boolean"
+				? { enableAgentTeams: context.enableAgentTeams }
+				: {}),
+		},
+	};
+}
+
+function isEntryEnabledByDefault(
+	entryId: string,
+	context: BuiltinToolAvailabilityContext,
+): boolean {
+	if (context.disabledToolIds?.has(entryId)) {
+		return false;
+	}
+
+	const { flags } = resolvePresetFlags(context);
+	if (entryId === "spawn_agent") {
+		return flags.enableSpawnAgent === true;
+	}
+	if (entryId === "teams") {
+		return flags.enableAgentTeams === true;
+	}
+	if (entryId === "editor") {
+		return flags.enableEditor === true || flags.enableApplyPatch === true;
+	}
+
+	const flag = TOOL_NAME_TO_FLAG[entryId];
+	return flag ? flags[flag] === true : false;
+}
+
+function buildCatalogEntry(
+	entry: RuntimeToolCatalogEntry,
+	context: BuiltinToolAvailabilityContext,
+): ToolCatalogEntry {
+	if (entry.id === "editor") {
+		const { flags } = resolvePresetFlags(context);
+		const usesApplyPatch =
+			flags.enableApplyPatch === true && flags.enableEditor !== true;
+		return {
+			...entry,
+			defaultEnabled: isEntryEnabledByDefault(entry.id, context),
+			headlessToolNames: [usesApplyPatch ? "apply_patch" : "editor"],
+		};
+	}
+
+	return {
+		...entry,
+		defaultEnabled: isEntryEnabledByDefault(entry.id, context),
+	};
+}
+
+export function getCoreBuiltinToolCatalog(
+	context: BuiltinToolAvailabilityContext = {},
+): ToolCatalogEntry[] {
+	return BASE_TOOL_CATALOG.map((entry) => buildCatalogEntry(entry, context));
+}
+
+export function getCoreDefaultEnabledToolIds(
+	context: BuiltinToolAvailabilityContext = {},
+): string[] {
+	return getCoreBuiltinToolCatalog(context)
+		.filter((entry) => entry.defaultEnabled)
+		.map((entry) => entry.id);
+}
+
+export function resolveCoreSelectedToolIds(input: {
+	enabled: boolean;
+	allowlist?: string[];
+	availabilityContext?: BuiltinToolAvailabilityContext;
+}): Set<string> {
+	if (!input.enabled) {
+		return new Set();
+	}
+
+	const catalog = getCoreBuiltinToolCatalog(input.availabilityContext);
+	const known = new Set(catalog.map((entry) => entry.id));
+	if (!input.allowlist || input.allowlist.length === 0) {
+		return new Set(
+			catalog.filter((entry) => entry.defaultEnabled).map((entry) => entry.id),
+		);
+	}
+
+	for (const id of input.allowlist) {
+		if (!known.has(id)) {
+			throw new Error(
+				`Unknown tool "${id}". Available tools: ${catalog.map((entry) => entry.id).join(", ")}`,
+			);
+		}
+	}
+	return new Set(input.allowlist);
+}
+
+export function getCoreHeadlessToolNames(
+	selectedToolIds: ReadonlySet<string>,
+	context: BuiltinToolAvailabilityContext = {},
+): string[] {
+	return getCoreBuiltinToolCatalog(context)
+		.filter((entry) => selectedToolIds.has(entry.id))
+		.flatMap((entry) => entry.headlessToolNames);
+}
+
+export function getCoreAcpToolNames(
+	selectedToolIds: ReadonlySet<string>,
+	context: BuiltinToolAvailabilityContext = {},
+): string[] {
+	return getCoreHeadlessToolNames(selectedToolIds, context);
+}

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

@@ -0,0 +1,345 @@
+/**
+ * Zod Schemas for Default Tool Inputs
+ *
+ * These schemas define the input structure for each default tool
+ * and are used for both validation and JSON Schema generation.
+ */
+
+import { z } from "zod";
+
+export const INPUT_ARG_CHAR_LIMIT = 6000;
+
+/**
+ * Schema for read tool input
+ */
+const AbsolutePath = z
+	.string()
+	.describe("The absolute file path of a text file to read content from");
+
+export const ReadFileLineRangeSchema = z
+	.object({
+		start_line: z
+			.number()
+			.int()
+			.positive()
+			.nullable()
+			.optional()
+			.describe(
+				"Optional one-based starting line number to read from; use null or omit for the start of the file",
+			),
+		end_line: z
+			.number()
+			.int()
+			.positive()
+			.nullable()
+			.optional()
+			.describe(
+				"Optional one-based ending line number to read through; use null or omit for the end of the file",
+			),
+	})
+	.describe("Optional inclusive one-based file line range");
+
+export const ReadFileRequestSchema = z
+	.object({
+		path: AbsolutePath,
+		start_line: ReadFileLineRangeSchema.shape.start_line,
+		end_line: ReadFileLineRangeSchema.shape.end_line,
+	})
+	.describe(
+		"A file read request with optional inclusive one-based line bounds",
+	);
+
+/**
+ * Schema for read_files tool input
+ */
+export const ReadFilesInputSchema = z.object({
+	files: z
+		.array(ReadFileRequestSchema)
+		.describe(
+			"Array of file read requests. Omit start_line/end_line or set them to null to return the full file content boundaries; provide integers to return only that inclusive one-based line range. Prefer this tool over running terminal command to get file content for better performance and reliability.",
+		),
+});
+
+/**
+ * Union schema for read_files tool input, allowing either a single string, an array of strings, or the full object schema
+ */
+export const ReadFilesInputUnionSchema = z.union([
+	ReadFilesInputSchema,
+	ReadFileRequestSchema,
+	z.array(ReadFileRequestSchema),
+	z.array(z.string()),
+	z.string(),
+	z.object({ files: z.array(z.union([AbsolutePath, ReadFileRequestSchema])) }),
+	z.object({ files: ReadFileRequestSchema }),
+	z.object({ files: AbsolutePath }),
+	z.object({ file_paths: z.array(AbsolutePath) }),
+	z.object({ file_paths: z.string() }),
+	z.object({ paths: z.array(z.union([AbsolutePath, ReadFileRequestSchema])) }),
+	z.object({ paths: ReadFileRequestSchema }),
+	z.object({ paths: z.string() }),
+]);
+
+/**
+ * Schema for search_codebase tool input
+ */
+export const SearchCodebaseInputSchema = z.object({
+	queries: z
+		.array(z.string())
+		.describe("Array of regex search queries to execute"),
+});
+
+/**
+ * Union schema for search_codebase tool input, allowing either a single string, an array of strings, or the full object schema
+ */
+export const SearchCodebaseUnionInputSchema = z.union([
+	SearchCodebaseInputSchema,
+	z.array(z.string()),
+	z.string(),
+	z.object({ queries: z.string() }),
+]);
+
+const CommandInputSchema = z
+	.string()
+	.describe(
+		`The non-interactive shell command to execute - MUST keep input short and concise (within ${INPUT_ARG_CHAR_LIMIT * 2} characters) to avoid timeouts.`,
+	);
+
+/**
+ * Schema for run_commands tool input
+ */
+export const RunCommandsInputSchema = z.object({
+	commands: z
+		.array(CommandInputSchema)
+		.describe("Array of shell commands to execute"),
+});
+
+/**
+ * Union schema for run_commands tool input. More flexible.
+ */
+export const RunCommandsInputUnionSchema = z.union([
+	RunCommandsInputSchema,
+	z.object({ commands: CommandInputSchema }),
+	z.object({ command: CommandInputSchema }),
+	z.object({ cmd: CommandInputSchema }),
+	z.array(z.string()),
+	z.string(),
+]);
+
+export const StructuredCommandInputSchema = z.object({
+	command: z
+		.string()
+		.min(1)
+		.describe("The executable to run directly without shell parsing."),
+	args: z
+		.array(z.string())
+		.optional()
+		.describe("Optional argv list passed directly to the executable."),
+});
+
+export const StructuredCommandEntrySchema = z.union([
+	CommandInputSchema,
+	StructuredCommandInputSchema,
+]);
+/**
+ * Schema for run_commands tool input
+ */
+export const StructuredCommandsInputSchema = z.object({
+	commands: z
+		.array(StructuredCommandEntrySchema)
+		.describe(
+			"Array of commands to execute. Prefer structured { command, args } entries for portability; plain strings are still supported and are interpreted by the active shell.",
+		),
+});
+
+/**
+ * Union schema for run_commands tool input. More flexible.
+ */
+export const StructuredCommandsInputUnionSchema = z.union([
+	RunCommandsInputSchema,
+	StructuredCommandsInputSchema,
+	z.object({ commands: StructuredCommandEntrySchema }),
+	z.array(StructuredCommandInputSchema),
+	StructuredCommandInputSchema,
+	z.object({ command: CommandInputSchema }),
+	z.object({ cmd: CommandInputSchema }),
+	z.array(z.string()),
+	z.string(),
+]);
+
+/**
+ * Schema for a single web fetch request
+ */
+export const WebFetchRequestSchema = z.object({
+	url: z.string().describe("The URL to fetch"),
+	prompt: z.string().min(2).describe("Analysis prompt for the fetched content"),
+});
+
+/**
+ * Schema for fetch_web_content tool input
+ */
+export const FetchWebContentInputSchema = z.object({
+	requests: z
+		.array(WebFetchRequestSchema)
+		.describe("Array of the URLs for the web fetch requests"),
+});
+
+/**
+ * Schema for editor tool input
+ */
+export const EditFileInputSchema = z
+	.object({
+		path: z
+			.string()
+			.min(1)
+			.describe("The absolute file path for the action to be performed on"),
+		old_text: z
+			.string()
+			.nullable()
+			.optional()
+			.describe(
+				`Exact text to replace (must match exactly once). Omit this when creating a missing file or inserting via insert_line. Keep this at or below ${INPUT_ARG_CHAR_LIMIT} characters when possible; larger payloads should be split across multiple tool calls to avoid timeouts.`,
+			),
+		new_text: z
+			.string()
+			.describe(
+				`The new content to write when creating a missing file, the replacement text for edits, or the inserted text when insert_line is provided. Keep this at or below ${INPUT_ARG_CHAR_LIMIT} characters when possible; for large edits, use multiple calls with small chunks of old_text and new_text to iteratively edit the file.`,
+			),
+		insert_line: z
+			.number()
+			.int()
+			.nullable()
+			.optional()
+			.describe(
+				"Optional positive one-based boundary line. When provided, the tool inserts new_text before that line instead of performing a replacement edit; use line_count + 1 to append at EOF.",
+			),
+	})
+	.describe(
+		"Edit a text file by replacing old_text with new_text, create the file with new_text if it does not exist, or insert new_text at insert_line when insert_line is provided. Prefer using this tool for file edits over shell commands. IMPORTANT: large edits can time out, so use small chunks and multiple calls when possible.",
+	);
+
+/**
+ * Schema for apply_patch tool input
+ */
+export const ApplyPatchInputSchema = z
+	.object({
+		input: z
+			.string()
+			.min(1)
+			.describe(
+				"The freeform apply_patch payload in the canonical patch grammar (e.g *** Begin Patch, *** Update File:, @@, and *** End Patch).",
+			),
+	})
+	.describe(
+		"Modify or create a text file by applying patches using the canonical apply_patch diff grammar. Prefer sending the patch body directly rather than wrapping it in shell syntax. IMPORTANT: large patches can time out, so use small chunks and multiple calls when possible.",
+	);
+export const ApplyPatchInputUnionSchema = z.union([
+	ApplyPatchInputSchema,
+	z.string(),
+]);
+
+/**
+ * Schema for skills tool input
+ */
+export const SkillsInputSchema = z.object({
+	skill: z.string().min(1).describe("Name of the skill to execute."),
+	args: z
+		.string()
+		.nullable()
+		.optional()
+		.describe("Arguments for the skill; use null when omitted"),
+});
+
+/**
+ * Schema for ask_followup_question tool input
+ */
+export const AskQuestionInputSchema = z.object({
+	question: z
+		.string()
+		.min(1)
+		.describe(
+			'The single question to ask the user. E.g. "How can I help you?"',
+		),
+	options: z
+		.array(z.string().min(1))
+		.min(2)
+		.max(5)
+		.describe(
+			"Array of 2-5 user-selectable answer options for the single question",
+		),
+});
+
+export const SubmitInputSchema = z.object({
+	summary: z
+		.string()
+		.min(10)
+		.describe(
+			"Summarization of the investigation, steps taken, and resolution status to submit at the end of the session. Before submitting, read the problem again along with any provided test's assertions carefully and confirm your fix produces the expected output.",
+		),
+	verified: z
+		.boolean()
+		.describe(
+			`Have you verified that the issue is resolved to the best of your knowledge, including updating and creating all the requested files and items? 'True' if you have completed the investigation and taken all necessary steps to resolve the issue.\n'False' if you have done all you can but cannot resolve the issue or if you are stuck and cannot proceed further. =\nIMPORTANT: You must run the specific failing test(s) mentioned in the issue or test patch and include the test output in your reasoning. If the test still fails after your fix, you must revise. Do NOT submit with 'true' unless the test output shows the test passing.`,
+		),
+});
+
+// =============================================================================
+// Type Definitions (derived from Zod schemas)
+// =============================================================================
+
+/**
+ * Input for a single file read request
+ */
+export type ReadFileRequest = z.infer<typeof ReadFileRequestSchema>;
+
+/**
+ * Input for the read_files tool
+ */
+export type ReadFilesInput = z.infer<typeof ReadFilesInputSchema>;
+
+/**
+ * Input for the search_codebase tool
+ */
+export type SearchCodebaseInput = z.infer<typeof SearchCodebaseInputSchema>;
+
+/**
+ * Input for the run_commands tool
+ */
+export type RunCommandsInput = z.infer<typeof RunCommandsInputSchema>;
+export type StructuredCommandInput = z.infer<
+	typeof StructuredCommandInputSchema
+>;
+
+/**
+ * Web fetch request parameters
+ */
+export type WebFetchRequest = z.infer<typeof WebFetchRequestSchema>;
+
+/**
+ * Input for the fetch_web_content tool
+ */
+export type FetchWebContentInput = z.infer<typeof FetchWebContentInputSchema>;
+
+/**
+ * Input for the editor tool
+ */
+export type EditFileInput = z.infer<typeof EditFileInputSchema>;
+
+/**
+ * Input for the apply_patch tool
+ */
+export type ApplyPatchInput = z.infer<typeof ApplyPatchInputSchema>;
+
+/**
+ * Input for the skills tool
+ */
+export type SkillsInput = z.infer<typeof SkillsInputSchema>;
+
+/**
+ * Input for the ask_followup_question tool
+ */
+export type AskQuestionInput = z.infer<typeof AskQuestionInputSchema>;
+
+/**
+ * Input for the submit and exit tool
+ */
+export type SubmitInput = z.infer<typeof SubmitInputSchema>;