codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/runtime/orchestration/session-runtime.ts

@@ -0,0 +1,73 @@
+import type {
+	AgentConfig,
+	AgentHooks,
+	AgentResult,
+	AgentTool,
+	BasicLogger,
+	ITelemetryService,
+	RuntimeConfigExtensionKind,
+} from "@cline/shared";
+import type { UserInstructionConfigService } from "../../extensions/config";
+import type { ToolExecutors } from "../../extensions/tools";
+import type {
+	AgentTeamsRuntime,
+	DelegatedAgentConfigProvider,
+	TeamEvent,
+} from "../../extensions/tools/team";
+import type { WorkspaceManager } from "../../services/workspace/workspace-manager";
+import type { CoreSessionConfig } from "../../types/config";
+
+/**
+ * Internal structural alias for the lead-agent handle that
+ * {@link BuiltRuntime.registerLeadAgent} hands off to
+ * `runtime-builder.ts`. Narrowed to only the `.addTools()` surface the
+ * callback exercises; avoids depending on `@cline/agents`' `Agent`
+ * class during the PLAN.md §3.6 Step 5 type-only migration. When
+ * SessionRuntime is rebuilt in Step 6, this field is expected to be
+ * dropped entirely per §3.5 row #2.
+ */
+type LeadAgentHandle = {
+	addTools(tools: AgentTool[]): unknown;
+};
+
+export interface BuiltRuntime {
+	tools: AgentTool[];
+	hooks?: AgentHooks;
+	logger?: BasicLogger;
+	telemetry?: ITelemetryService;
+	teamRuntime?: AgentTeamsRuntime;
+	teamRestoredFromPersistence?: boolean;
+	delegatedAgentConfigProvider?: DelegatedAgentConfigProvider;
+	extensions?: AgentConfig["extensions"];
+	completionPolicy?: AgentConfig["completionPolicy"];
+	registerLeadAgent?: (agent: LeadAgentHandle) => void;
+	shutdown: (reason: string) => Promise<void> | void;
+}
+
+export interface RuntimeBuilderInput {
+	config: CoreSessionConfig;
+	hooks?: AgentHooks;
+	extensions?: AgentConfig["extensions"];
+	onTeamEvent?: (event: TeamEvent) => void;
+	createSpawnTool?: () => AgentTool;
+	onTeamRestored?: () => void;
+	userInstructionService?: UserInstructionConfigService;
+	pluginSkillDirectories?: ReadonlyArray<string>;
+	configExtensions?: RuntimeConfigExtensionKind[];
+	toolExecutors?: Partial<ToolExecutors>;
+	workspaceManager?: WorkspaceManager;
+	logger?: BasicLogger;
+	telemetry?: ITelemetryService;
+}
+
+export interface RuntimeBuilder {
+	build(input: RuntimeBuilderInput): Promise<BuiltRuntime> | BuiltRuntime;
+}
+
+export interface SessionRuntime {
+	start(config: CoreSessionConfig): Promise<{ sessionId: string }>;
+	send(sessionId: string, prompt: string): Promise<AgentResult | undefined>;
+	abort(sessionId: string, reason?: unknown): Promise<void>;
+	stop(sessionId: string): Promise<void>;
+	poll(): Promise<string[]>;
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/runtime/orchestration/user-input-builder.ts

@@ -0,0 +1,159 @@
+/**
+ * User-input / first-turn content assembler.
+ *
+ * Opens the first user content array for a turn, loading user file contents via
+ * the injected `userFileContentLoader`.
+ */
+
+import type * as LlmsProviders from "@cline/llms";
+
+export async function buildInitialUserContent(
+	userMessage: string,
+	userImages?: string[],
+	userFiles?: string[],
+	userFileContentLoader?: (path: string) => Promise<string>,
+): Promise<string | LlmsProviders.ContentBlock[]> {
+	const imageBlocks = buildImageBlocks(userImages);
+	const fileTextBlocks = await buildUserFileContentBlock(
+		userFiles,
+		userFileContentLoader,
+	);
+
+	if (imageBlocks.length === 0 && !fileTextBlocks) {
+		return userMessage;
+	}
+
+	const content: LlmsProviders.ContentBlock[] = [
+		{
+			type: "text",
+			text: userMessage,
+		},
+		...imageBlocks,
+	];
+	if (fileTextBlocks) {
+		content.push(...fileTextBlocks);
+	}
+	return content;
+}
+
+/**
+ * Normalize a user message shape into a plain string when possible.
+ *
+ * Accepts either a string or a LlmsProviders.Message; returns the best-effort
+ * concatenated plain-text body. Non-text content is ignored.
+ */
+export function normalizeUserMessage(
+	input: string | LlmsProviders.Message | undefined,
+): string {
+	if (input == null) {
+		return "";
+	}
+	if (typeof input === "string") {
+		return input;
+	}
+	const content = input.content;
+	if (typeof content === "string") {
+		return content;
+	}
+	if (!Array.isArray(content)) {
+		return "";
+	}
+	const textParts: string[] = [];
+	for (const block of content) {
+		if (block && typeof block === "object" && block.type === "text") {
+			const text = (block as { text?: unknown }).text;
+			if (typeof text === "string") {
+				textParts.push(text);
+			}
+		}
+	}
+	return textParts.join("\n");
+}
+
+function buildImageBlocks(userImages?: string[]): LlmsProviders.ImageContent[] {
+	if (!userImages || userImages.length === 0) {
+		return [];
+	}
+
+	const blocks: LlmsProviders.ImageContent[] = [];
+	for (const image of userImages) {
+		const block = parseDataUrlImage(image);
+		if (block) {
+			blocks.push(block);
+		}
+	}
+	return blocks;
+}
+
+function parseDataUrlImage(
+	image: string,
+): LlmsProviders.ImageContent | undefined {
+	const value = image.trim();
+	if (!value) {
+		return undefined;
+	}
+
+	const dataUrlMatch = value.match(/^data:([^;,]+);base64,(.+)$/);
+	if (dataUrlMatch) {
+		const mediaType = dataUrlMatch[1];
+		const data = dataUrlMatch[2];
+		if (!mediaType || !data) {
+			return undefined;
+		}
+		return {
+			type: "image",
+			mediaType,
+			data,
+		};
+	}
+
+	// Fallback: treat as plain base64 payload.
+	return {
+		type: "image",
+		mediaType: "image/png",
+		data: value,
+	};
+}
+
+async function buildUserFileContentBlock(
+	userFiles?: string[],
+	userFileContentLoader?: (path: string) => Promise<string>,
+): Promise<LlmsProviders.FileContent[] | undefined> {
+	if (!userFiles || userFiles.length === 0) {
+		return undefined;
+	}
+
+	const loader =
+		userFileContentLoader ??
+		(async () => {
+			throw new Error(
+				"File loading is not configured in this runtime. Provide userFileContentLoader to enable userFiles support.",
+			);
+		});
+
+	const contents = await Promise.all(
+		userFiles.map(async (filePath) => {
+			const normalizedPath = filePath.replace(/\\/g, "/");
+			try {
+				const content = await loader(filePath);
+				return {
+					type: "file",
+					path: normalizedPath,
+					content,
+				} satisfies LlmsProviders.FileContent;
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				return {
+					type: "file",
+					path: normalizedPath,
+					content: `Error fetching content: ${message}`,
+				} satisfies LlmsProviders.FileContent;
+			}
+		}),
+	);
+
+	if (contents.length === 0) {
+		return undefined;
+	}
+	return contents;
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/runtime/safety/loop-detection.ts

@@ -0,0 +1,162 @@
+/**
+ * Repeated tool-call loop detection.
+ *
+ * @see PLAN.md §3.1 — helpers moved from `packages/agents/src/context/loop-detection.ts`.
+ * @see PLAN.md §3.2.3 — public surface of `LoopDetectionTracker`.
+ *
+ * The pure helpers (`createLoopDetectionState`, `resetLoopDetectionState`,
+ * `toolCallSignature`, `checkRepeatedToolCall`) are ported verbatim. The
+ * `LoopDetectionTracker` class is a thin wrapper that owns a
+ * `LoopDetectionState` and exposes the `inspect()` / `reset()` surface that
+ * `SessionRuntime` installs as a `beforeTool` hook per §3.2.3.
+ */
+
+import type { LoopDetectionConfig } from "@cline/shared";
+
+// =============================================================================
+// Pure helpers (verbatim port)
+// =============================================================================
+
+export interface LoopDetectionState {
+	lastToolName: string;
+	lastToolSignature: string;
+	consecutiveIdenticalCount: number;
+}
+
+export function createLoopDetectionState(): LoopDetectionState {
+	return {
+		lastToolName: "",
+		lastToolSignature: "",
+		consecutiveIdenticalCount: 0,
+	};
+}
+
+export function resetLoopDetectionState(state: LoopDetectionState): void {
+	state.lastToolName = "";
+	state.lastToolSignature = "";
+	state.consecutiveIdenticalCount = 0;
+}
+
+function sortKeys(value: unknown): unknown {
+	if (value == null || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map(sortKeys);
+	const sorted: Record<string, unknown> = {};
+	for (const key of Object.keys(value as Record<string, unknown>).sort()) {
+		sorted[key] = sortKeys((value as Record<string, unknown>)[key]);
+	}
+	return sorted;
+}
+
+export function toolCallSignature(input: unknown): string {
+	if (input == null) return "null";
+	if (typeof input === "string") return input;
+	if (typeof input !== "object") return String(input);
+	try {
+		return JSON.stringify(sortKeys(input));
+	} catch {
+		return String(input);
+	}
+}
+
+export interface LoopCheckResult {
+	softWarning: boolean;
+	hardEscalation: boolean;
+}
+
+export function checkRepeatedToolCall(
+	state: LoopDetectionState,
+	toolName: string,
+	signature: string,
+	config: LoopDetectionConfig,
+): LoopCheckResult {
+	if (
+		toolName === state.lastToolName &&
+		signature === state.lastToolSignature
+	) {
+		state.consecutiveIdenticalCount++;
+	} else {
+		state.consecutiveIdenticalCount = 1;
+	}
+	state.lastToolName = toolName;
+	state.lastToolSignature = signature;
+
+	return {
+		softWarning: state.consecutiveIdenticalCount === config.softThreshold,
+		hardEscalation: state.consecutiveIdenticalCount >= config.hardThreshold,
+	};
+}
+
+// =============================================================================
+// Class wrapper (new — per PLAN.md §3.2.3)
+// =============================================================================
+
+/**
+ * Verdict returned by {@link LoopDetectionTracker.inspect}.
+ *
+ * - `"ok"`   — no repeated call detected.
+ * - `"soft"` — soft-warning threshold reached; SessionRuntime may surface a
+ *              recovery notice but should not block the call.
+ * - `"hard"` — hard-escalation threshold reached; SessionRuntime should
+ *              stop the run with the provided `message`.
+ */
+export interface LoopDetectionVerdict {
+	kind: "ok" | "soft" | "hard";
+	message?: string;
+}
+
+/** Minimal call shape the tracker needs; matches `AgentToolCallPart` subset. */
+export interface LoopDetectionCall {
+	name: string;
+	input: unknown;
+}
+
+const DEFAULT_CONFIG: LoopDetectionConfig = {
+	softThreshold: 3,
+	hardThreshold: 5,
+};
+
+/**
+ * Per-session repeated-tool-call detector.
+ *
+ * `SessionRuntime` owns the instance and installs a `beforeTool` hook
+ * (see `AgentRuntimeHooks.beforeTool`) that calls `inspect()` to decide
+ * whether to return `{ skip, stop, reason }`.
+ */
+export class LoopDetectionTracker {
+	private readonly config: LoopDetectionConfig;
+	private readonly state: LoopDetectionState = createLoopDetectionState();
+
+	constructor(config?: Partial<LoopDetectionConfig>) {
+		this.config = {
+			softThreshold: config?.softThreshold ?? DEFAULT_CONFIG.softThreshold,
+			hardThreshold: config?.hardThreshold ?? DEFAULT_CONFIG.hardThreshold,
+		};
+	}
+
+	inspect(call: LoopDetectionCall): LoopDetectionVerdict {
+		const signature = toolCallSignature(call.input);
+		const result = checkRepeatedToolCall(
+			this.state,
+			call.name,
+			signature,
+			this.config,
+		);
+		if (result.hardEscalation) {
+			return {
+				kind: "hard",
+				message: `Detected ${this.state.consecutiveIdenticalCount} consecutive identical calls to \`${call.name}\`; stopping to avoid a loop.`,
+			};
+		}
+		if (result.softWarning) {
+			return {
+				kind: "soft",
+				message: `Detected ${this.state.consecutiveIdenticalCount} consecutive identical calls to \`${call.name}\`; consider trying a different approach.`,
+			};
+		}
+		return { kind: "ok" };
+	}
+
+	reset(): void {
+		resetLoopDetectionState(this.state);
+	}
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/runtime/safety/mistake-tracker.ts

@@ -0,0 +1,221 @@
+/**
+ * Per-session consecutive-mistake tracker.
+ *
+ * @see PLAN.md §3.1 — wrapped around `recordMistake` moved from
+ *                    `packages/agents/src/api/error-handling.ts` lines 147–311.
+ * @see PLAN.md §3.2.3 — public surface of `MistakeTracker`.
+ *
+ * The pure procedural `recordMistake(input, deps)` becomes `record(input)`
+ * on the class; `consecutiveMistakes` is internal state. Other deps flow
+ * through the constructor instead.
+ *
+ * NOTE: the §3.2.3 constructor shape omits some fields (agentId,
+ * conversationId/runId getters, appendRecoveryNotice). They are retained
+ * here for log + notice parity per PLAN.md §3.4.3/§3.4.5. Step 8
+ * (`impl-runtime-porter`) may refactor once SessionRuntime is wired up.
+ */
+
+import type {
+	AgentEvent,
+	BasicLogMetadata,
+	ConsecutiveMistakeLimitContext,
+	ConsecutiveMistakeLimitDecision,
+} from "@cline/shared";
+
+/**
+ * Legacy-agents-style leveled log function. The sdk-re `BasicLogger`
+ * does not carry a level argument (§shared/logging/logger.ts); callers
+ * are expected to bridge via `metadata.severity` or dispatch to
+ * `debug`/`log`/`error`. `MistakeTracker` accepts a leveled callable
+ * here so Step 8 can plug in whichever bridging shape `SessionRuntime`
+ * ends up using.
+ */
+export type LeveledLog = (
+	level: "debug" | "info" | "warn" | "error",
+	message: string,
+	metadata?: BasicLogMetadata,
+) => void;
+
+export type MistakeReason =
+	| "api_error"
+	| "invalid_tool_call"
+	| "tool_execution_failed";
+
+export interface RecordMistakeInput {
+	iteration: number;
+	reason: MistakeReason;
+	details?: string;
+	/** When true, jump straight to maxConsecutiveMistakes instead of incrementing by 1. */
+	forceAtLimit?: boolean;
+}
+
+export type MistakeOutcome =
+	| { action: "continue"; guidance?: string }
+	| { action: "stop"; message: string; reason?: string };
+
+export interface MistakeTrackerOptions {
+	readonly maxConsecutiveMistakes: number;
+	readonly onLimitReached?: (
+		ctx: ConsecutiveMistakeLimitContext,
+	) =>
+		| Promise<ConsecutiveMistakeLimitDecision>
+		| ConsecutiveMistakeLimitDecision;
+	readonly emit: (event: AgentEvent) => void;
+	readonly log: LeveledLog;
+	readonly agentId: string;
+	readonly getConversationId: () => string;
+	readonly getActiveRunId: () => string;
+	readonly appendRecoveryNotice: (
+		message: string,
+		reason: MistakeReason,
+	) => void;
+}
+
+export class MistakeTracker {
+	private consecutiveMistakes = 0;
+	private readonly options: MistakeTrackerOptions;
+
+	constructor(options: MistakeTrackerOptions) {
+		this.options = options;
+	}
+
+	async record(input: RecordMistakeInput): Promise<MistakeOutcome> {
+		const max = this.options.maxConsecutiveMistakes;
+		const next = input.forceAtLimit && max ? max : this.consecutiveMistakes + 1;
+		this.consecutiveMistakes = next;
+
+		const errorMessage =
+			input.details?.trim() || `consecutive mistake (${input.reason})`;
+		this.options.emit({
+			type: "error",
+			error: new Error(errorMessage),
+			recoverable: true,
+			iteration: input.iteration,
+		});
+		this.options.log("warn", "Recorded consecutive mistake", {
+			agentId: this.options.agentId,
+			conversationId: this.options.getConversationId(),
+			runId: this.options.getActiveRunId(),
+			iteration: input.iteration,
+			reason: input.reason,
+			details: input.details,
+			consecutiveMistakes: next,
+			maxConsecutiveMistakes: this.options.maxConsecutiveMistakes,
+		});
+
+		if (!max || next < max) {
+			return { action: "continue" };
+		}
+
+		const decision = await resolveConsecutiveMistakeDecision(
+			{
+				iteration: input.iteration,
+				consecutiveMistakes: next,
+				maxConsecutiveMistakes: max,
+				reason: input.reason,
+				details: input.details,
+			},
+			this.options.onLimitReached,
+		);
+
+		if (decision.action === "continue") {
+			const guidance = decision.guidance?.trim();
+			if (guidance) {
+				this.options.appendRecoveryNotice(guidance, input.reason);
+			}
+			this.consecutiveMistakes = 0;
+			return { action: "continue", guidance };
+		}
+
+		return {
+			action: "stop",
+			reason: decision.reason?.trim() || undefined,
+			message: buildMistakeLimitStopMessage({
+				iteration: input.iteration,
+				consecutiveMistakes: next,
+				maxConsecutiveMistakes: max,
+				reason: input.reason,
+				details: input.details,
+				stopReason: decision.reason,
+			}),
+		};
+	}
+
+	reset(): void {
+		this.consecutiveMistakes = 0;
+	}
+
+	get value(): number {
+		return this.consecutiveMistakes;
+	}
+}
+
+// =============================================================================
+// Mistake Limit Stop Message (pure helper — ported verbatim)
+// =============================================================================
+
+export function buildMistakeLimitStopMessage(input: {
+	iteration: number;
+	consecutiveMistakes: number;
+	maxConsecutiveMistakes: number;
+	reason:
+		| "api_error"
+		| "invalid_tool_call"
+		| "completion_without_submit"
+		| "tool_execution_failed";
+	details?: string;
+	stopReason?: string;
+}): string {
+	const parts = [
+		`Stopped after ${input.consecutiveMistakes}/${input.maxConsecutiveMistakes} consecutive mistakes (${input.reason}) at iteration ${input.iteration}.`,
+	];
+	const details = input.details?.trim();
+	if (details) {
+		parts.push(`Error: ${details}`);
+	}
+	const stopReason = input.stopReason?.trim();
+	if (stopReason) {
+		parts.push(`Decision: ${stopReason}`);
+	}
+	parts.push(
+		"Session state was preserved. Send a new prompt to resume from the latest state.",
+	);
+	return parts.join(" ");
+}
+
+// =============================================================================
+// Consecutive Mistake Decision Resolution (pure helper — ported verbatim)
+// =============================================================================
+
+async function resolveConsecutiveMistakeDecision(
+	input: ConsecutiveMistakeLimitContext,
+	callback?: (
+		context: ConsecutiveMistakeLimitContext,
+	) =>
+		| Promise<ConsecutiveMistakeLimitDecision>
+		| ConsecutiveMistakeLimitDecision,
+): Promise<ConsecutiveMistakeLimitDecision> {
+	if (!callback) {
+		return {
+			action: "stop",
+			reason: `maximum consecutive mistakes reached (${input.maxConsecutiveMistakes})`,
+		};
+	}
+	try {
+		return await callback(input);
+	} catch (error) {
+		return {
+			action: "stop",
+			reason:
+				error instanceof Error
+					? error.message
+					: `maximum consecutive mistakes reached (${input.maxConsecutiveMistakes})`,
+		};
+	}
+}
+
+// TODO(PLAN.md Step 8): The `emit` channel currently accepts legacy `AgentEvent`
+// so the "recoverable error" event shape is preserved verbatim. When
+// `SessionRuntime` wires this up in Step 8, consider whether this should
+// emit an `AgentRuntimeEvent` (per the §3.2.3 signature proposal) and let
+// the bridge translate, or keep the direct legacy channel for notice parity.

codna/agent-core/vendor/cline/sdk/packages/core/src/runtime/safety/rules.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { mergeRulesForSystemPrompt } from "./rules";
+
+describe("mergeRulesForSystemPrompt", () => {
+	it("returns additional rules when watcher rules are absent", () => {
+		expect(mergeRulesForSystemPrompt(undefined, "inline rules")).toBe(
+			"inline rules",
+		);
+	});
+
+	it("returns watcher rules when inline rules are absent", () => {
+		expect(mergeRulesForSystemPrompt("watcher rules", undefined)).toBe(
+			"watcher rules",
+		);
+	});
+
+	it("appends inline rules after watcher rules", () => {
+		expect(mergeRulesForSystemPrompt("watcher rules", "inline rules")).toBe(
+			"watcher rules\n\ninline rules",
+		);
+	});
+});

codna/agent-core/vendor/cline/sdk/packages/core/src/runtime/safety/rules.ts

@@ -0,0 +1,49 @@
+import type {
+	RuleConfig,
+	UserInstructionConfigWatcher,
+} from "../../extensions/config/user-instruction-config-loader";
+
+export function isRuleEnabled(rule: RuleConfig): boolean {
+	return rule.disabled !== true;
+}
+
+export function formatRulesForSystemPrompt(
+	rules: ReadonlyArray<RuleConfig>,
+): string {
+	if (rules.length === 0) {
+		return "";
+	}
+
+	const renderedRules = rules
+		.map((rule) => `## ${rule.name}\n${rule.instructions}`)
+		.join("\n\n");
+	return `\n\n# Rules\n${renderedRules}`;
+}
+
+export function mergeRulesForSystemPrompt(
+	primaryRules?: string,
+	additionalRules?: string,
+): string | undefined {
+	const primary = primaryRules?.trim();
+	const additional = additionalRules?.trim();
+	if (primary && additional) {
+		return `${primary}\n\n${additional}`;
+	}
+	return primary || additional || undefined;
+}
+
+export function listEnabledRulesFromWatcher(
+	watcher: UserInstructionConfigWatcher,
+): RuleConfig[] {
+	const snapshot = watcher.getSnapshot("rule");
+	return [...snapshot.values()]
+		.map((record) => record.item as RuleConfig)
+		.filter(isRuleEnabled)
+		.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function loadRulesForSystemPromptFromWatcher(
+	watcher: UserInstructionConfigWatcher,
+): string {
+	return formatRulesForSystemPrompt(listEnabledRulesFromWatcher(watcher));
+}