codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/services/session-telemetry.ts

@@ -0,0 +1,89 @@
+import type { ITelemetryService } from "@cline/shared";
+import { resolveDocumentsExtensionPath } from "@cline/shared/storage";
+import { listHookConfigFiles } from "../hooks/hook-file-config";
+import type { CoreSessionConfig } from "../types/config";
+import {
+	captureHookDiscovery,
+	captureMentionFailed,
+	captureMentionSearchResults,
+	captureMentionUsed,
+	captureTaskCreated,
+	captureTaskRestarted,
+	type TelemetryAgentIdentityProperties,
+} from "./telemetry/core-events";
+import type { enrichPromptWithMentions } from "./workspace";
+
+/**
+ * Emits local-only session creation telemetry (task.created/restarted and
+ * hook discovery). The transport-agnostic `session.started` event is
+ * emitted from `ClineCore.start` so it fires for every backend (local,
+ * hub, remote) at the outer API boundary.
+ */
+export function emitSessionCreationTelemetry(
+	config: CoreSessionConfig,
+	sessionId: string,
+	isRestart: boolean,
+	workspacePath: string,
+	agentIdentity?: Partial<TelemetryAgentIdentityProperties>,
+): void {
+	if (isRestart) {
+		captureTaskRestarted(config.telemetry, {
+			ulid: sessionId,
+			apiProvider: config.providerId,
+			...agentIdentity,
+		});
+	} else {
+		captureTaskCreated(config.telemetry, {
+			ulid: sessionId,
+			apiProvider: config.providerId,
+			...agentIdentity,
+		});
+	}
+	captureHookDiscoveryTelemetry(config.telemetry, { workspacePath });
+}
+
+export function captureHookDiscoveryTelemetry(
+	telemetry: ITelemetryService | undefined,
+	options: { workspacePath: string },
+): void {
+	const globalHooksDir = resolveDocumentsExtensionPath("Hooks");
+	const entries = listHookConfigFiles(options.workspacePath);
+	const counts = new Map<string, { global: number; workspace: number }>();
+	for (const entry of entries) {
+		const hookName = entry.hookEventName ?? "unknown";
+		const current = counts.get(hookName) ?? { global: 0, workspace: 0 };
+		if (
+			entry.path === globalHooksDir ||
+			entry.path.startsWith(`${globalHooksDir}/`)
+		) {
+			current.global += 1;
+		} else {
+			current.workspace += 1;
+		}
+		counts.set(hookName, current);
+	}
+	for (const [hookName, count] of counts.entries()) {
+		captureHookDiscovery(telemetry, hookName, count.global, count.workspace);
+	}
+}
+
+export function emitMentionTelemetry(
+	telemetry: ITelemetryService | undefined,
+	enriched: Awaited<ReturnType<typeof enrichPromptWithMentions>>,
+): void {
+	for (const mention of enriched.mentions) {
+		captureMentionSearchResults(
+			telemetry,
+			mention,
+			enriched.matchedFiles.includes(mention) ? 1 : 0,
+			"file",
+			!enriched.matchedFiles.includes(mention),
+		);
+	}
+	for (const matched of enriched.matchedFiles) {
+		captureMentionUsed(telemetry, "file", matched.length);
+	}
+	for (const ignored of enriched.ignoredMentions) {
+		captureMentionFailed(telemetry, "file", "not_found", ignored);
+	}
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/services/storage/artifact-store.ts

@@ -0,0 +1 @@
+export type { ArtifactStore } from "../../types/storage";

codna/agent-core/vendor/cline/sdk/packages/core/src/services/storage/file-team-store.ts

@@ -0,0 +1,250 @@
+import {
+	appendFileSync,
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	renameSync,
+	writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import type { TeamRuntimeState, TeamTeammateSpec } from "@cline/shared";
+import { resolveTeamDataDir } from "@cline/shared/storage";
+import type { TeamEvent } from "../../extensions/tools/team";
+import type { TeamStore } from "../../types/storage";
+
+function nowIso(): string {
+	return new Date().toISOString();
+}
+
+function sanitizeTeamName(name: string): string {
+	return name
+		.toLowerCase()
+		.replace(/[^a-z0-9._-]+/g, "-")
+		.replace(/^-+|-+$/g, "");
+}
+
+function reviveTeamRuntimeStateDates(
+	state: TeamRuntimeState,
+): TeamRuntimeState {
+	return {
+		...state,
+		tasks: state.tasks.map((task) => ({
+			...task,
+			createdAt: new Date(task.createdAt),
+			updatedAt: new Date(task.updatedAt),
+		})),
+		mailbox: state.mailbox.map((message) => ({
+			...message,
+			sentAt: new Date(message.sentAt),
+			readAt: message.readAt ? new Date(message.readAt) : undefined,
+		})),
+		missionLog: state.missionLog.map((entry) => ({
+			...entry,
+			ts: new Date(entry.ts),
+		})),
+		runs: (state.runs ?? []).map((run) => ({
+			...run,
+			startedAt: new Date(run.startedAt),
+			endedAt: run.endedAt ? new Date(run.endedAt) : undefined,
+			nextAttemptAt: run.nextAttemptAt
+				? new Date(run.nextAttemptAt)
+				: undefined,
+			heartbeatAt: run.heartbeatAt ? new Date(run.heartbeatAt) : undefined,
+		})),
+		outcomes: (state.outcomes ?? []).map((outcome) => ({
+			...outcome,
+			createdAt: new Date(outcome.createdAt),
+			finalizedAt: outcome.finalizedAt
+				? new Date(outcome.finalizedAt)
+				: undefined,
+		})),
+		outcomeFragments: (state.outcomeFragments ?? []).map((fragment) => ({
+			...fragment,
+			createdAt: new Date(fragment.createdAt),
+			reviewedAt: fragment.reviewedAt
+				? new Date(fragment.reviewedAt)
+				: undefined,
+		})),
+	};
+}
+
+interface PersistedTeamEnvelope {
+	version: 1;
+	updatedAt: string;
+	teamState: TeamRuntimeState;
+	teammates: TeamTeammateSpec[];
+}
+
+export interface FileTeamStoreOptions {
+	teamDir?: string;
+}
+
+export interface TeamRuntimeLoadResult {
+	state?: TeamRuntimeState;
+	teammates: TeamTeammateSpec[];
+	interruptedRunIds: string[];
+}
+
+export class FileTeamStore implements TeamStore {
+	private readonly teamDirPath: string;
+
+	constructor(options: FileTeamStoreOptions = {}) {
+		this.teamDirPath = options.teamDir ?? resolveTeamDataDir();
+	}
+
+	init(): void {
+		this.ensureTeamDir();
+	}
+
+	listTeamNames(): string[] {
+		if (!existsSync(this.teamDirPath)) {
+			return [];
+		}
+		return readdirSync(this.teamDirPath, { withFileTypes: true })
+			.filter((entry) => entry.isDirectory())
+			.filter((entry) => existsSync(this.statePath(entry.name)))
+			.map((entry) => entry.name)
+			.sort();
+	}
+
+	readState(teamName: string): TeamRuntimeState | undefined {
+		const envelope = this.readEnvelope(teamName);
+		return envelope?.teamState
+			? reviveTeamRuntimeStateDates(envelope.teamState)
+			: undefined;
+	}
+
+	readHistory(teamName: string, limit = 200): unknown[] {
+		const historyPath = this.historyPath(teamName);
+		if (!existsSync(historyPath)) {
+			return [];
+		}
+		return readFileSync(historyPath, "utf8")
+			.split("\n")
+			.map((line) => line.trim())
+			.filter(Boolean)
+			.map((line) => {
+				try {
+					return JSON.parse(line) as unknown;
+				} catch {
+					return undefined;
+				}
+			})
+			.filter((item): item is unknown => item !== undefined)
+			.reverse()
+			.slice(0, limit);
+	}
+
+	loadRuntime(teamName: string): TeamRuntimeLoadResult {
+		const envelope = this.readEnvelope(teamName);
+		return {
+			state: envelope?.teamState
+				? reviveTeamRuntimeStateDates(envelope.teamState)
+				: undefined,
+			teammates: envelope?.teammates ?? [],
+			interruptedRunIds: [],
+		};
+	}
+
+	handleTeamEvent(teamName: string, event: TeamEvent): void {
+		this.ensureTeamSubdir(teamName);
+		appendFileSync(
+			this.historyPath(teamName),
+			`${JSON.stringify({ ts: nowIso(), eventType: event.type, payload: event })}\n`,
+			"utf8",
+		);
+	}
+
+	persistRuntime(
+		teamName: string,
+		state: TeamRuntimeState,
+		teammates: TeamTeammateSpec[],
+	): void {
+		this.ensureTeamSubdir(teamName);
+		const envelope: PersistedTeamEnvelope = {
+			version: 1,
+			updatedAt: nowIso(),
+			teamState: state,
+			teammates,
+		};
+		const path = this.statePath(teamName);
+		const tempPath = `${path}.tmp`;
+		writeFileSync(tempPath, `${JSON.stringify(envelope, null, 2)}\n`, "utf8");
+		renameSync(tempPath, path);
+	}
+
+	markInProgressRunsInterrupted(teamName: string, reason: string): string[] {
+		const envelope = this.readEnvelope(teamName);
+		if (!envelope?.teamState?.runs?.length) {
+			return [];
+		}
+		const interrupted = envelope.teamState.runs
+			.filter((run) => run.status === "queued" || run.status === "running")
+			.map((run) => run.id);
+		if (interrupted.length === 0) {
+			return [];
+		}
+		const endedAt = new Date();
+		envelope.teamState = {
+			...envelope.teamState,
+			runs: envelope.teamState.runs.map((run) =>
+				run.status === "queued" || run.status === "running"
+					? {
+							...run,
+							status: "interrupted",
+							error: reason,
+							endedAt,
+						}
+					: run,
+			),
+		};
+		this.persistRuntime(teamName, envelope.teamState, envelope.teammates);
+		return interrupted;
+	}
+
+	private ensureTeamDir(): string {
+		if (!existsSync(this.teamDirPath)) {
+			mkdirSync(this.teamDirPath, { recursive: true });
+		}
+		return this.teamDirPath;
+	}
+
+	private ensureTeamSubdir(teamName: string): string {
+		const path = join(this.ensureTeamDir(), sanitizeTeamName(teamName));
+		if (!existsSync(path)) {
+			mkdirSync(path, { recursive: true });
+		}
+		return path;
+	}
+
+	private statePath(teamName: string): string {
+		return join(this.ensureTeamDir(), sanitizeTeamName(teamName), "state.json");
+	}
+
+	private historyPath(teamName: string): string {
+		return join(
+			this.ensureTeamDir(),
+			sanitizeTeamName(teamName),
+			"task-history.jsonl",
+		);
+	}
+
+	private readEnvelope(teamName: string): PersistedTeamEnvelope | undefined {
+		const path = this.statePath(teamName);
+		if (!existsSync(path)) {
+			return undefined;
+		}
+		try {
+			const parsed = JSON.parse(
+				readFileSync(path, "utf8"),
+			) as PersistedTeamEnvelope;
+			if (parsed?.version === 1 && parsed.teamState) {
+				return parsed;
+			}
+		} catch {
+			// Ignore invalid persistence and fall back to undefined.
+		}
+		return undefined;
+	}
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/services/storage/index.ts

@@ -0,0 +1,11 @@
+export type { ArtifactStore } from "./artifact-store";
+export {
+	type MigrateLegacyProviderSettingsOptions,
+	type MigrateLegacyProviderSettingsResult,
+	migrateLegacyProviderSettings,
+} from "./provider-settings-legacy-migration";
+export { ProviderSettingsManager } from "./provider-settings-manager";
+export type { SessionStore } from "./session-store";
+export { SqliteSessionStore } from "./sqlite-session-store";
+export type { TeamStore } from "./team-store";
+export { SqliteTeamStore, type SqliteTeamStoreOptions } from "./team-store";