codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/hooks/checkpoint-hooks.ts

@@ -0,0 +1,291 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { promisify } from "node:util";
+import type { AgentHooks, BasicLogger } from "@cline/shared";
+
+const execFile = promisify(execFileCallback);
+
+export interface CheckpointEntry {
+	ref: string;
+	createdAt: number;
+	runCount: number;
+	kind?: "stash" | "commit";
+}
+
+export interface CheckpointMetadata {
+	latest: CheckpointEntry;
+	history: CheckpointEntry[];
+}
+
+type CreateCheckpointHooksOptions = {
+	cwd: string;
+	sessionId: string;
+	logger?: BasicLogger;
+	readSessionMetadata: () => Promise<Record<string, unknown> | undefined>;
+	writeSessionMetadata: (
+		metadata: Record<string, unknown>,
+	) => Promise<void> | void;
+	/**
+	 * Optional custom checkpoint implementation. When provided, the built-in
+	 * git stash/ref logic is skipped entirely and this function is called
+	 * instead. Return `undefined` to skip writing a checkpoint for that run.
+	 */
+	createCheckpoint?: (context: {
+		cwd: string;
+		sessionId: string;
+		runCount: number;
+	}) => Promise<CheckpointEntry | undefined> | CheckpointEntry | undefined;
+	/**
+	 * Starting value for the internal run counter. Use this when a session
+	 * is created with initial messages (e.g. after a checkpoint restore) so
+	 * that new checkpoint entries get runCount values that don't collide
+	 * with entries carried over from the source session.
+	 */
+	initialRunCount?: number;
+};
+
+function warn(logger: BasicLogger | undefined, message: string): void {
+	logger?.log(message, { severity: "warn" });
+}
+
+function readCheckpointMetadata(
+	metadata: Record<string, unknown> | undefined,
+): CheckpointMetadata | undefined {
+	const candidate = metadata?.checkpoint;
+	if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+		return undefined;
+	}
+	const record = candidate as Partial<CheckpointMetadata>;
+	if (!record.latest || !Array.isArray(record.history)) {
+		return undefined;
+	}
+	const latest = record.latest as Partial<CheckpointEntry>;
+	const history = record.history.filter(
+		(entry): entry is CheckpointEntry =>
+			!!entry &&
+			typeof entry === "object" &&
+			typeof (entry as Partial<CheckpointEntry>).ref === "string" &&
+			typeof (entry as Partial<CheckpointEntry>).createdAt === "number" &&
+			typeof (entry as Partial<CheckpointEntry>).runCount === "number",
+	);
+	if (
+		typeof latest.ref !== "string" ||
+		typeof latest.createdAt !== "number" ||
+		typeof latest.runCount !== "number"
+	) {
+		return undefined;
+	}
+	return {
+		latest: latest as CheckpointEntry,
+		history,
+	};
+}
+
+async function runGit(
+	cwd: string,
+	args: string[],
+): Promise<{ stdout: string; stderr: string }> {
+	const result = await execFile("git", ["-C", cwd, ...args], {
+		windowsHide: true,
+	});
+	return {
+		stdout: result.stdout.trim(),
+		stderr: result.stderr.trim(),
+	};
+}
+
+/**
+ * Deletes all private git refs under refs/cline/checkpoints/{sessionId}/ that
+ * were created by the checkpoint system to keep stash objects reachable.
+ * Errors are swallowed - if the cwd is not a git repo or the refs don't exist,
+ * the delete is a no-op.
+ */
+export async function deleteCheckpointRefs(
+	cwd: string | null | undefined,
+	sessionId: string,
+): Promise<void> {
+	if (!cwd) return;
+	const prefix = `refs/cline/checkpoints/${sessionId}/`;
+	try {
+		const { stdout } = await runGit(cwd, [
+			"for-each-ref",
+			"--format=%(refname)",
+			prefix,
+		]);
+		const refs = stdout.trim().split("\n").filter(Boolean);
+		await Promise.allSettled(
+			refs.map((ref) => runGit(cwd, ["update-ref", "-d", ref])),
+		);
+	} catch {
+		// Not a git repo or git not available - ignore.
+	}
+}
+
+export async function retainCheckpointRefs(
+	cwd: string | null | undefined,
+	sessionId: string,
+	checkpoints: readonly CheckpointEntry[],
+): Promise<void> {
+	if (!cwd || checkpoints.length === 0) return;
+	await Promise.allSettled(
+		checkpoints.map((entry) =>
+			runGit(cwd, [
+				"update-ref",
+				`refs/cline/checkpoints/${sessionId}/${entry.runCount}`,
+				entry.ref,
+			]),
+		),
+	);
+}
+
+function upsertCheckpointHistory(
+	history: readonly CheckpointEntry[],
+	entry: CheckpointEntry,
+): CheckpointEntry[] {
+	const existingIndex = history.findIndex(
+		(candidate) => candidate.runCount === entry.runCount,
+	);
+	if (existingIndex < 0) {
+		return [...history, entry];
+	}
+	return history.map((candidate, index) =>
+		index === existingIndex ? entry : candidate,
+	);
+}
+
+export function createCheckpointHooks(
+	options: CreateCheckpointHooksOptions,
+): AgentHooks {
+	let runCount = options.initialRunCount ?? 0;
+	let repoSupported: boolean | undefined;
+
+	const ensureGitRepository = async (): Promise<boolean> => {
+		if (repoSupported !== undefined) {
+			return repoSupported;
+		}
+		try {
+			const result = await runGit(options.cwd, [
+				"rev-parse",
+				"--is-inside-work-tree",
+			]);
+			repoSupported = result.stdout === "true";
+		} catch {
+			repoSupported = false;
+		}
+		return repoSupported;
+	};
+
+	const createCheckpoint = async (): Promise<CheckpointEntry | undefined> => {
+		if (options.createCheckpoint) {
+			return await options.createCheckpoint({
+				cwd: options.cwd,
+				sessionId: options.sessionId,
+				runCount,
+			});
+		}
+
+		if (!(await ensureGitRepository())) {
+			return undefined;
+		}
+
+		const createHeadCheckpoint = async (
+			warnPrefix: string,
+		): Promise<CheckpointEntry | undefined> => {
+			try {
+				const result = await runGit(options.cwd, ["rev-parse", "HEAD"]);
+				const ref = result.stdout.trim();
+				if (!ref) {
+					return undefined;
+				}
+				return {
+					ref,
+					createdAt: Date.now(),
+					runCount,
+					kind: "commit",
+				};
+			} catch (error) {
+				warn(
+					options.logger,
+					`${warnPrefix}: ${error instanceof Error ? error.message : String(error)}`,
+				);
+				return undefined;
+			}
+		};
+
+		const message = `cline checkpoint session=${options.sessionId} run=${runCount}`;
+		let ref = "";
+		try {
+			const result = await runGit(options.cwd, ["stash", "create", message]);
+			ref = result.stdout.trim();
+		} catch (error) {
+			warn(
+				options.logger,
+				`Checkpoint snapshot failed: ${error instanceof Error ? error.message : String(error)}`,
+			);
+			return createHeadCheckpoint("Checkpoint HEAD fallback failed");
+		}
+		if (!ref) {
+			return createHeadCheckpoint("Checkpoint HEAD fallback failed");
+		}
+
+		// Store the stash commit under a private ref namespace so it is
+		// invisible to the user's normal `git stash list` workflow.
+		// `refs/stash` is what populates that list; writing to any other
+		// ref path keeps the object reachable (GC-safe) without surfacing
+		// it to the user.  The raw SHA already works with `git stash apply`
+		// on the restore path, so no restore-side changes are needed.
+		const privateRef = `refs/cline/checkpoints/${options.sessionId}/${runCount}`;
+		try {
+			await runGit(options.cwd, ["update-ref", privateRef, ref]);
+		} catch (error) {
+			warn(
+				options.logger,
+				`Checkpoint store failed: ${error instanceof Error ? error.message : String(error)}`,
+			);
+			return undefined;
+		}
+
+		return {
+			ref,
+			createdAt: Date.now(),
+			runCount,
+			kind: "stash",
+		};
+	};
+
+	return {
+		beforeRun: async ({ snapshot }) => {
+			if (snapshot.parentAgentId != null) {
+				return undefined;
+			}
+			runCount += 1;
+			return undefined;
+		},
+		beforeModel: async ({ snapshot }) => {
+			if (
+				snapshot.parentAgentId != null ||
+				snapshot.iteration !== 1 ||
+				runCount < 1
+			) {
+				return undefined;
+			}
+			const entry = await createCheckpoint();
+			if (!entry) {
+				return undefined;
+			}
+			const metadata = await options.readSessionMetadata();
+			const existing = readCheckpointMetadata(metadata);
+			if (existing?.latest.ref === entry.ref) {
+				return undefined;
+			}
+			const history = upsertCheckpointHistory(existing?.history ?? [], entry);
+			await options.writeSessionMetadata({
+				...(metadata ?? {}),
+				checkpoint: {
+					latest: entry,
+					history,
+				} satisfies CheckpointMetadata,
+			});
+			return undefined;
+		},
+	};
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/hooks/hook-extension.ts

@@ -0,0 +1,15 @@
+import type { AgentExtension, AgentHooks } from "@cline/shared";
+
+export function createAgentHooksExtension(
+	name: string,
+	hooks: AgentHooks | undefined,
+): AgentExtension | undefined {
+	if (!hooks) {
+		return undefined;
+	}
+	return {
+		name,
+		manifest: { capabilities: ["hooks"] },
+		hooks,
+	};
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/hooks/hook-file-config.test.ts

@@ -0,0 +1,17 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { HookConfigFileName, toHookConfigFileName } from "./hook-file-config";
+
+describe("hook file config", () => {
+	afterEach(() => {
+		delete process.env.CLINE_DATA_DIR;
+	});
+
+	it("recognizes PowerShell hook files", () => {
+		expect(toHookConfigFileName("PreToolUse.ps1")).toBe(
+			HookConfigFileName.PreToolUse,
+		);
+		expect(toHookConfigFileName("TaskError.ps1")).toBe(
+			HookConfigFileName.TaskError,
+		);
+	});
+});

codna/agent-core/vendor/cline/sdk/packages/core/src/hooks/hook-file-config.ts

@@ -0,0 +1,117 @@
+import { existsSync, readdirSync } from "node:fs";
+import { basename, extname, join } from "node:path";
+import {
+	HOOKS_CONFIG_DIRECTORY_NAME,
+	resolveHooksConfigSearchPaths as resolveHooksConfigSearchPathsFromShared,
+} from "@cline/shared/storage";
+import type { HookEventName } from "./subprocess";
+
+export { HOOKS_CONFIG_DIRECTORY_NAME };
+
+export function resolveHooksConfigSearchPaths(
+	workspacePath?: string,
+): string[] {
+	return resolveHooksConfigSearchPathsFromShared(workspacePath);
+}
+
+export enum HookConfigFileName {
+	TaskStart = "TaskStart",
+	TaskResume = "TaskResume",
+	TaskCancel = "TaskCancel",
+	TaskComplete = "TaskComplete",
+	TaskError = "TaskError",
+	PreToolUse = "PreToolUse",
+	PostToolUse = "PostToolUse",
+	UserPromptSubmit = "UserPromptSubmit",
+	PreCompact = "PreCompact",
+	SessionShutdown = "SessionShutdown",
+}
+
+export const HOOK_CONFIG_FILE_EVENT_MAP: Readonly<
+	Record<HookConfigFileName, HookEventName | undefined>
+> = {
+	[HookConfigFileName.TaskStart]: "agent_start",
+	[HookConfigFileName.TaskResume]: "agent_resume",
+	[HookConfigFileName.TaskCancel]: "agent_abort",
+	[HookConfigFileName.TaskComplete]: "agent_end",
+	[HookConfigFileName.TaskError]: "agent_error",
+	[HookConfigFileName.PreToolUse]: "tool_call",
+	[HookConfigFileName.PostToolUse]: "tool_result",
+	[HookConfigFileName.UserPromptSubmit]: "prompt_submit",
+	[HookConfigFileName.PreCompact]: undefined,
+	[HookConfigFileName.SessionShutdown]: "session_shutdown",
+};
+
+const HOOK_CONFIG_FILE_LOOKUP = new Map<string, HookConfigFileName>(
+	Object.values(HookConfigFileName).map((name) => [name.toLowerCase(), name]),
+);
+
+const SUPPORTED_HOOK_FILE_EXTENSIONS = new Set([
+	"",
+	".sh",
+	".bash",
+	".zsh",
+	".js",
+	".mjs",
+	".cjs",
+	".ts",
+	".mts",
+	".cts",
+	".py",
+	".ps1",
+]);
+
+export function toHookConfigFileName(
+	fileName: string,
+): HookConfigFileName | undefined {
+	const extension = extname(fileName).toLowerCase();
+	if (!SUPPORTED_HOOK_FILE_EXTENSIONS.has(extension)) {
+		return undefined;
+	}
+	const key = basename(fileName, extension).trim().toLowerCase();
+	return HOOK_CONFIG_FILE_LOOKUP.get(key);
+}
+
+export interface HookConfigFileEntry {
+	fileName: HookConfigFileName;
+	hookEventName?: HookEventName;
+	path: string;
+}
+
+export function listHookConfigFiles(
+	workspacePath?: string,
+): HookConfigFileEntry[] {
+	const entries: HookConfigFileEntry[] = [];
+	const seen = new Set<string>();
+	const directories = resolveHooksConfigSearchPaths(workspacePath).filter(
+		(directory) => existsSync(directory),
+	);
+
+	for (const directory of directories) {
+		try {
+			for (const entry of readdirSync(directory, { withFileTypes: true })) {
+				if (!entry.isFile()) {
+					continue;
+				}
+				const fileName = toHookConfigFileName(entry.name);
+				if (!fileName) {
+					continue;
+				}
+				const path = join(directory, entry.name);
+				if (seen.has(path)) {
+					continue;
+				}
+				seen.add(path);
+				entries.push({
+					fileName,
+					hookEventName: HOOK_CONFIG_FILE_EVENT_MAP[fileName],
+					path,
+				});
+			}
+		} catch {
+			// Best-effort listing across config roots.
+		}
+	}
+
+	return entries.sort((a, b) => a.path.localeCompare(b.path));
+}