codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/algenta/server/utils.ts

@@ -0,0 +1,508 @@
+import fs from "node:fs";
+import type { IncomingMessage } from "node:http";
+import path from "node:path";
+import { redactSecrets } from "../proofs";
+import type { CanonicalEvent, SessionRecord } from "./contracts";
+
+const MAX_PROMPT_FILE_HINTS = 6;
+const MAX_TARGET_EXCERPTS = 1;
+const MAX_TARGET_EXCERPT_BYTES = 200_000;
+const MAX_TARGET_EXCERPT_RADIUS = 12;
+const MAX_TARGET_EXCERPT_LINES = 32;
+const MAX_CONTEXT_ENTRIES = 2;
+const MAX_EVIDENCE_ITEMS = 3;
+const MAX_SNIPPET_LINES = 24;
+const MAX_SNIPPET_CHARS = 1_600;
+
+interface IssueTargetHint {
+	path: string;
+	line?: number;
+}
+
+export function nowIso(): string {
+	return new Date().toISOString();
+}
+
+export function asRecord(value: unknown): Record<string, unknown> {
+	return value && typeof value === "object" && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: {};
+}
+
+export function optionalString(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed ? trimmed : undefined;
+}
+
+export function requiredString(value: unknown, fieldName: string): string {
+	const resolved = optionalString(value);
+	if (!resolved) {
+		throw new Error(`${fieldName} is required.`);
+	}
+	return resolved;
+}
+
+export function booleanValue(value: unknown, defaultValue = false): boolean {
+	return typeof value === "boolean" ? value : defaultValue;
+}
+
+export function stringArray(value: unknown): string[] {
+	if (!Array.isArray(value)) return [];
+	return value
+		.map((entry) => optionalString(entry))
+		.filter((entry): entry is string => Boolean(entry));
+}
+
+function uniqueStrings(entries: string[]): string[] {
+	const seen = new Set<string>();
+	const output: string[] = [];
+	for (const entry of entries) {
+		if (seen.has(entry)) continue;
+		seen.add(entry);
+		output.push(entry);
+	}
+	return output;
+}
+
+function looksLikeRepositoryPath(value: string): boolean {
+	if (!/[/.]/.test(value)) return false;
+	if (!/[A-Za-z]/.test(value)) return false;
+	return /^[A-Za-z0-9_./@+-]+$/.test(value);
+}
+
+function normalizeRepositoryPathCandidate(value: string): string | null {
+	const trimmed = value.trim().replace(/^file:\/\//i, "");
+	const stripped = trimmed
+		.replace(/^[`"'(<\[]+/, "")
+		.replace(/[`"')>\].,:;]+$/, "");
+	if (!stripped) return null;
+	const forwardSlashes = stripped.replace(/\\/g, "/").replace(/^\.\//, "");
+	if (!looksLikeRepositoryPath(forwardSlashes)) return null;
+	if (path.posix.isAbsolute(forwardSlashes)) return null;
+	const normalized = path.posix.normalize(forwardSlashes);
+	if (!normalized || normalized === "." || normalized === "..") return null;
+	if (normalized.startsWith("../") || normalized.includes("/../")) return null;
+	return normalized;
+}
+
+function resolveRepositoryFile(
+	workingDir: string,
+	repositoryPath: string,
+): string | null {
+	const normalized = normalizeRepositoryPathCandidate(repositoryPath);
+	if (!normalized) return null;
+	const root = path.resolve(workingDir);
+	const absolute = path.resolve(root, normalized);
+	const relative = path.relative(root, absolute);
+	if (
+		relative === "" ||
+		relative === ".." ||
+		relative.startsWith(`..${path.sep}`) ||
+		path.isAbsolute(relative)
+	) {
+		return null;
+	}
+	return absolute;
+}
+
+function addIssueTargetHint(
+	output: Map<string, IssueTargetHint>,
+	pathCandidate: string,
+	lineCandidate?: string,
+): void {
+	const normalized = normalizeRepositoryPathCandidate(pathCandidate);
+	if (!normalized) return;
+	const existing = output.get(normalized);
+	const parsedLine =
+		typeof lineCandidate === "string" && /^\d+$/.test(lineCandidate)
+			? Number.parseInt(lineCandidate, 10)
+			: undefined;
+	if (!existing) {
+		output.set(normalized, {
+			path: normalized,
+			...(parsedLine && parsedLine > 0 ? { line: parsedLine } : {}),
+		});
+		return;
+	}
+	if (!existing.line && parsedLine && parsedLine > 0) {
+		existing.line = parsedLine;
+	}
+}
+
+export function extractIssueTargetHints(issueText: string | undefined): IssueTargetHint[] {
+	if (!issueText) return [];
+	const output = new Map<string, IssueTargetHint>();
+	for (const match of issueText.matchAll(/\b[Ff]ile\s+["'`]([^"'`\n]+)["'`]\s*,\s*line\s+(\d+)/g)) {
+		addIssueTargetHint(output, match[1] || "", match[2]);
+	}
+	for (const match of issueText.matchAll(/`([^`\n]+)`/g)) {
+		addIssueTargetHint(output, match[1] || "");
+	}
+	for (const match of issueText.matchAll(/\b((?=[A-Za-z0-9_./-]*[A-Za-z])[A-Za-z0-9_./-]+\.[A-Za-z0-9_-]+)(?::(\d+))?\b/g)) {
+		addIssueTargetHint(output, match[1] || "", match[2]);
+	}
+	return [...output.values()];
+}
+
+function filterExistingIssueTargets(
+	hints: IssueTargetHint[],
+	workingDir: string | undefined,
+): IssueTargetHint[] {
+	if (!workingDir || hints.length === 0) return hints;
+	const existing = hints.filter((hint) => {
+		const resolved = resolveRepositoryFile(workingDir, hint.path);
+		return Boolean(resolved && fs.existsSync(resolved));
+	});
+	return existing.length > 0 ? existing : hints;
+}
+
+function trimMultilineText(
+	value: string,
+	limits: { maxLines: number; maxChars: number },
+): string {
+	const lines = value.replace(/\r\n/g, "\n").trimEnd().split("\n");
+	const slicedLines = lines.slice(0, limits.maxLines);
+	const joined = slicedLines.join("\n");
+	if (joined.length <= limits.maxChars) return joined;
+	return `${joined.slice(0, Math.max(0, limits.maxChars - 14)).trimEnd()}\n[truncated]`;
+}
+
+function formatTargetExcerpt(
+	workingDir: string,
+	hint: IssueTargetHint,
+): string | null {
+	const absolute = resolveRepositoryFile(workingDir, hint.path);
+	if (!absolute) return null;
+	let fd: number | null = null;
+	try {
+		fd = fs.openSync(absolute, "r");
+		const stat = fs.fstatSync(fd);
+		if (stat.size > MAX_TARGET_EXCERPT_BYTES) return null;
+		const source = fs.readFileSync(fd, "utf8");
+		const lines = source.replace(/\r\n/g, "\n").split("\n");
+		if (lines.length === 0) return null;
+		const focusLine =
+			typeof hint.line === "number" && hint.line > 0
+				? Math.min(hint.line, lines.length)
+				: undefined;
+		const windowStart = focusLine
+			? Math.max(1, focusLine - MAX_TARGET_EXCERPT_RADIUS)
+			: 1;
+		const desiredEnd = windowStart + MAX_TARGET_EXCERPT_LINES - 1;
+		const windowEnd = Math.min(lines.length, desiredEnd);
+		const excerpt = lines
+			.slice(windowStart - 1, windowEnd)
+			.map((line, index) => {
+				const lineNumber = windowStart + index;
+				return `${String(lineNumber).padStart(6)}\t${line}`;
+			})
+			.join("\n")
+			.trimEnd();
+		if (!excerpt) return null;
+		const headerLines = [`FILE ${hint.path}:${windowStart}-${windowEnd}`];
+		if (focusLine) {
+			headerLines.push(`focus_line: ${focusLine}`);
+		}
+		if (windowEnd === lines.length) {
+			headerLines.push("excerpt_reaches_eof: yes");
+		}
+		headerLines.push(excerpt);
+		return headerLines.join("\n");
+	} catch {
+		return null;
+	} finally {
+		if (fd !== null) fs.closeSync(fd);
+	}
+}
+
+function candidateContextEntries(
+	value: unknown,
+): Array<Record<string, unknown>> {
+	if (!Array.isArray(value)) return [];
+	return value.filter(
+		(entry): entry is Record<string, unknown> =>
+			Boolean(entry) && typeof entry === "object" && !Array.isArray(entry),
+	);
+}
+
+function selectContextEntries(
+	value: unknown,
+	explicitTargets: string[],
+): Array<Record<string, unknown>> {
+	const entries = candidateContextEntries(value);
+	if (entries.length === 0) return [];
+	const targetSet = new Set(explicitTargets);
+	const filtered =
+		targetSet.size > 0
+			? entries.filter((entry) => targetSet.has(optionalString(entry.file_path) || ""))
+			: entries;
+	return filtered.slice(0, MAX_CONTEXT_ENTRIES);
+}
+
+function formatContextEntry(entry: Record<string, unknown>): string | null {
+	const filePath = optionalString(entry.file_path);
+	const numberedSource = optionalString(entry.numbered_source);
+	if (!filePath || !numberedSource) return null;
+	const symbolName = optionalString(entry.symbol_name);
+	const startLine =
+		typeof entry.start_line === "number" ? Math.trunc(entry.start_line) : null;
+	const endLine =
+		typeof entry.end_line === "number" ? Math.trunc(entry.end_line) : null;
+	const diagnostics = stringArray(entry.touching_diagnostics).slice(0, 3);
+	const imports = stringArray(entry.nearest_imports).slice(0, 5);
+	const headerParts = [`FILE ${filePath}`];
+	if (symbolName) headerParts.push(`symbol=${symbolName}`);
+	if (startLine && endLine) headerParts.push(`lines=${startLine}-${endLine}`);
+	const lines = [headerParts.join(" ")];
+	if (diagnostics.length > 0) {
+		lines.push(`diagnostics: ${diagnostics.join(" | ")}`);
+	}
+	if (imports.length > 0) {
+		lines.push(`imports: ${imports.join(", ")}`);
+	}
+	lines.push(trimMultilineText(numberedSource, { maxLines: 80, maxChars: 6_000 }));
+	return lines.join("\n");
+}
+
+function selectEvidenceItems(
+	value: unknown,
+	explicitTargets: string[],
+): Array<Record<string, unknown>> {
+	const entries = candidateContextEntries(value);
+	if (entries.length === 0) return [];
+	const targetSet = new Set(explicitTargets);
+	const filtered =
+		targetSet.size > 0
+			? entries.filter((entry) => targetSet.has(optionalString(entry.file_path) || ""))
+			: entries;
+	return filtered.slice(0, MAX_EVIDENCE_ITEMS);
+}
+
+function formatEvidenceItem(entry: Record<string, unknown>): string | null {
+	const filePath = optionalString(entry.file_path);
+	if (!filePath) return null;
+	const symbolName = optionalString(entry.symbol_name);
+	const snippet = optionalString(entry.snippet);
+	const reasons = [
+		optionalString(entry.reason),
+		optionalString(entry.rationale),
+		optionalString(entry.match_reason),
+	]
+		.filter((value): value is string => Boolean(value))
+		.slice(0, 1);
+	const diagnostics = [
+		optionalString(entry.diagnostic),
+		optionalString(entry.message),
+	]
+		.filter((value): value is string => Boolean(value))
+		.slice(0, 1);
+	const header = symbolName ? `FILE ${filePath} symbol=${symbolName}` : `FILE ${filePath}`;
+	const lines = [header];
+	if (reasons.length > 0) {
+		lines.push(`reason: ${reasons[0]}`);
+	}
+	if (diagnostics.length > 0) {
+		lines.push(`diagnostic: ${diagnostics[0]}`);
+	}
+	if (snippet && snippet !== "[full source in context_bundle]") {
+		lines.push(trimMultilineText(snippet, {
+			maxLines: MAX_SNIPPET_LINES,
+			maxChars: MAX_SNIPPET_CHARS,
+		}));
+	}
+	return lines.join("\n");
+}
+
+function hasTierOneATelysContext(input: Record<string, unknown>): boolean {
+	return (
+		optionalString(input.localization_tier) === "tier_1a_path_hinted_telys" &&
+		candidateContextEntries(input.context_bundle).length > 0
+	);
+}
+
+function promptFileHints(
+	issueText: string | undefined,
+	injectedContext: Record<string, unknown>,
+	workingDir: string | undefined,
+): string[] {
+	const explicitTargets = filterExistingIssueTargets(
+		extractIssueTargetHints(issueText),
+		workingDir,
+	).map((hint) => hint.path);
+	if (explicitTargets.length > 0) {
+		return explicitTargets.slice(0, MAX_PROMPT_FILE_HINTS);
+	}
+	const suspects = stringArray(injectedContext.suspect_files)
+		.map((entry) => normalizeRepositoryPathCandidate(entry))
+		.filter((entry): entry is string => Boolean(entry));
+	return uniqueStrings(suspects).slice(0, MAX_PROMPT_FILE_HINTS);
+}
+
+export function serializeInjectedContext(
+	value: unknown,
+	options: { issueText?: string; workingDir: string },
+): string {
+	if (typeof value === "string") {
+		return value.trim();
+	}
+	const input = asRecord(value);
+	const explicitHints = filterExistingIssueTargets(
+		extractIssueTargetHints(options.issueText),
+		options.workingDir,
+	);
+	const explicitTargets = explicitHints.map((hint) => hint.path);
+	const sections: string[] = [];
+	if (explicitTargets.length > 0) {
+		sections.push(
+			["TARGET FILES", ...explicitTargets.map((filePath) => `- ${filePath}`)].join(
+				"\n",
+			),
+		);
+	}
+	const excerptHints = hasTierOneATelysContext(input)
+		? explicitHints.filter((hint) => typeof hint.line === "number" && hint.line > 0)
+		: explicitHints;
+	const excerpts = excerptHints
+		.slice(0, MAX_TARGET_EXCERPTS)
+		.map((hint) => formatTargetExcerpt(options.workingDir, hint))
+		.filter((entry): entry is string => Boolean(entry));
+	if (excerpts.length > 0) {
+		sections.push(`TARGET FILE EXCERPTS\n${excerpts.join("\n\n")}`);
+	}
+	const contextEntries = selectContextEntries(input.context_bundle, explicitTargets)
+		.map((entry) => formatContextEntry(entry))
+		.filter((entry): entry is string => Boolean(entry));
+	if (contextEntries.length > 0) {
+		sections.push(`CONTEXT BUNDLE\n${contextEntries.join("\n\n")}`);
+	}
+	const evidenceItems = selectEvidenceItems(input.evidence_items, explicitTargets)
+		.map((entry) => formatEvidenceItem(entry))
+		.filter((entry): entry is string => Boolean(entry));
+	if (evidenceItems.length > 0) {
+		sections.push(`SUPPORTING EVIDENCE\n${evidenceItems.join("\n\n")}`);
+	}
+	if (sections.length > 0) {
+		return sections.join("\n\n").trim();
+	}
+	const fallbackFiles = promptFileHints(
+		options.issueText,
+		input,
+		options.workingDir,
+	);
+	if (fallbackFiles.length > 0) {
+		return ["RANKED FILES", ...fallbackFiles.map((filePath) => `- ${filePath}`)].join(
+			"\n",
+		);
+	}
+	return "";
+}
+
+export function ensureEnumValue<T extends string>(
+	value: unknown,
+	values: readonly T[],
+	fieldName: string,
+	defaultValue: T,
+): T {
+	const resolved = optionalString(value);
+	if (!resolved) return defaultValue;
+	if (!values.includes(resolved as T)) {
+		throw new Error(`${fieldName} must be one of: ${values.join(", ")}.`);
+	}
+	return resolved as T;
+}
+
+export function normalizeLimits(
+	value: unknown,
+): { maxIterations?: number; timeoutMs?: number } {
+	const input = asRecord(value);
+	const maxIterationsRaw =
+		input.maxIterations ?? input.max_iterations ?? input.max_turns;
+	const timeoutRaw = input.timeoutMs ?? input.timeout_ms;
+	const maxIterations =
+		typeof maxIterationsRaw === "number" && Number.isFinite(maxIterationsRaw)
+			? Math.max(1, Math.trunc(maxIterationsRaw))
+			: undefined;
+	const timeoutMs =
+		typeof timeoutRaw === "number" && Number.isFinite(timeoutRaw)
+			? Math.max(1, Math.trunc(timeoutRaw))
+			: undefined;
+	return {
+		...(maxIterations ? { maxIterations } : {}),
+		...(timeoutMs ? { timeoutMs } : {}),
+	};
+}
+
+export function buildPrompt(payload: Record<string, unknown>): string {
+	if (typeof payload.prompt === "string" && payload.prompt.trim()) {
+		return payload.prompt.trim();
+	}
+	const task = asRecord(payload.task_spec);
+	const injectedContext = asRecord(payload.injected_context);
+	const issue = optionalString(task.issue_text) || "(see the evidence bundle)";
+	const targets = promptFileHints(
+		issue,
+		injectedContext,
+		optionalString(payload.working_dir),
+	);
+	const lines = ["Fix this repository issue:", issue];
+	if (targets.length > 0) {
+		if (
+			filterExistingIssueTargets(
+				extractIssueTargetHints(issue),
+				optionalString(payload.working_dir),
+			).length > 0
+		) {
+			lines.push(
+				`Explicit target file${targets.length > 1 ? "s" : ""}: ${targets.join(", ")}.`,
+			);
+			lines.push(
+				`Edit ${targets.length > 1 ? "only those files" : "that file"} directly unless the evidence bundle proves another file must change.`,
+			);
+		} else {
+			lines.push(`Likely file${targets.length > 1 ? "s" : ""}: ${targets.join(", ")}.`);
+		}
+	}
+	lines.push("Make the minimal correct change with your file-editing tools, then stop.");
+	return lines.join("\n");
+}
+
+export function createIdempotencyKey(session: SessionRecord): string | null {
+	if (!session.idempotencyKey) return null;
+	return [session.channel, session.repositoryScope, session.idempotencyKey].join(":");
+}
+
+export function sessionOwnerForRequest(request: IncomingMessage): string {
+	return (
+		optionalString(request.headers["x-session-owner"]) ||
+		optionalString(request.headers["x-owner"]) ||
+		"anonymous"
+	);
+}
+
+export function matchesOwner(request: IncomingMessage, session: SessionRecord): boolean {
+	return sessionOwnerForRequest(request) === session.owner;
+}
+
+export function updateSessionTimestamp(session: SessionRecord): void {
+	session.updatedAt = nowIso();
+}
+
+export function appendSessionEvent(
+	session: SessionRecord,
+	eventType: string,
+	payload: Record<string, unknown>,
+): CanonicalEvent {
+	const event: CanonicalEvent = {
+		schema_version: "cline-session-event/v1",
+		event_id: `evt_${session.sessionId}_${session.events.length + 1}`,
+		event_index: session.events.length + 1,
+		session_id: session.sessionId,
+		observed_at: nowIso(),
+		event_type: eventType,
+		payload: redactSecrets(payload) as Record<string, unknown>,
+	};
+	session.events.push(event);
+	updateSessionTimestamp(session);
+	return event;
+}

codna/agent-core/vendor/cline/algenta/task-policy.ts

@@ -0,0 +1,82 @@
+export type AgentTaskKind = "fix" | "triage";
+
+export interface TaskPolicyArgs {
+	prompt: string;
+	injected_context?: string;
+	suppress_exploration?: boolean;
+	tool_profile?: string;
+	task_kind?: AgentTaskKind;
+	engine?: { enabled?: boolean };
+}
+
+export const EXPLORATION_TOOLS = [
+	"read_files",
+	"search_codebase",
+	"fetch_web_content",
+	"ask_question",
+];
+
+export const SHELL_TOOLS = ["run_commands"];
+
+export const WRITE_TOOLS = new Set(["editor", "apply_patch"]);
+
+export const EXACT_RESTORE_SHELL_ONLY_DISABLED_TOOLS = [
+	...EXPLORATION_TOOLS,
+	"editor",
+	"apply_patch",
+	"skills",
+	"localize",
+	"graph_query",
+	"simulate_patch",
+] as const;
+
+const EXACT_RESTORE_MARKERS = [
+	/Restore it exactly with:\s*git restore --source [^\n]+ -- [^\n]+/i,
+	/\bgit restore --source [^\n]+ -- [^\n]+/i,
+] as const;
+
+function exactRestorePromptText(
+	args: Pick<TaskPolicyArgs, "prompt" | "injected_context">,
+): string {
+	return [args.prompt, args.injected_context]
+		.filter((value): value is string => typeof value === "string" && value.trim().length > 0)
+		.join("\n");
+}
+
+export function hasExactRestoreContract(
+	args: Pick<TaskPolicyArgs, "prompt" | "injected_context">,
+): boolean {
+	const text = exactRestorePromptText(args);
+	if (!text) return false;
+	const hasTargetFile = /(?:^|\n)(?:Target file:|Explicit target file:)\s+/im.test(text);
+	const hasOriginalReference =
+		/Original valid git head:/i.test(text) ||
+		/Reference the exact original content with:/i.test(text);
+	const hasRestoreCommand = EXACT_RESTORE_MARKERS.some((pattern) => pattern.test(text));
+	const hasRestoreHelper =
+		/Benchmark restore helper artifact:/i.test(text) ||
+		/exact fallback restore command:/i.test(text);
+	return hasTargetFile && (hasRestoreCommand || (hasOriginalReference && hasRestoreHelper));
+}
+
+export function suppressedToolsForArgs(
+	args: Pick<TaskPolicyArgs, "tool_profile" | "suppress_exploration">,
+): string[] {
+	switch (args.tool_profile) {
+		case "no_exploration_no_shell":
+			return [...EXPLORATION_TOOLS, ...SHELL_TOOLS];
+		case "no_exploration_local_validation":
+			return [...EXPLORATION_TOOLS];
+		default:
+			return args.suppress_exploration ? [...EXPLORATION_TOOLS] : [];
+	}
+}
+
+export function exactRestoreDisablesPatchTools(args: TaskPolicyArgs): boolean {
+	const disabledTools = suppressedToolsForArgs(args);
+	return hasExactRestoreContract(args) && !disabledTools.includes("run_commands");
+}
+
+export function exactRestoreShellOnlyTools(args: TaskPolicyArgs): boolean {
+	return exactRestoreDisablesPatchTools(args) && !args.engine?.enabled;
+}