codna 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,32 @@
+export {
+	upsertWorkspaceInfo,
+	type WorkspaceInfo,
+	type WorkspaceManifest,
+	WorkspaceManifestSchema,
+} from "@cline/shared";
+export type {
+	WorkspaceManager,
+	WorkspaceManagerEvent,
+} from "../services/workspace/workspace-manager";
+export { InMemoryWorkspaceManager } from "../services/workspace/workspace-manager";
+export {
+	generateWorkspaceInfo,
+	normalizeWorkspacePath,
+} from "../services/workspace/workspace-manifest";
+export {
+	deriveSubsessionStatus,
+	makeSubSessionId,
+	makeTeamTaskSubSessionId,
+	sanitizeSessionToken,
+} from "./models/session-graph";
+export type { SessionManifest } from "./models/session-manifest";
+export type {
+	CreateRootSessionWithArtifactsInput,
+	RootSessionArtifacts,
+	SessionRow,
+} from "./models/session-row";
+export { CoreSessionService } from "./services/session-service";
+export {
+	FileTeamPersistenceStore,
+	type FileTeamPersistenceStoreOptions,
+} from "./stores/team-persistence-store";

codna/agent-core/vendor/cline/sdk/packages/core/src/session/models/session-graph.ts

@@ -0,0 +1,92 @@
+import { nanoid } from "nanoid";
+import type { HookEventPayload } from "../../hooks";
+import type { SessionStatus } from "../../types/common";
+
+export function sanitizeSessionToken(value: string): string {
+	return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+
+export function makeSubSessionId(
+	rootSessionId: string,
+	agentId: string,
+): string {
+	const root = sanitizeSessionToken(rootSessionId);
+	const agent = sanitizeSessionToken(agentId);
+	const joined = `${root}__${agent}`;
+	return joined.length > 180 ? joined.slice(0, 180) : joined;
+}
+
+export function makeTeamTaskSubSessionId(
+	rootSessionId: string,
+	agentId: string,
+): string {
+	const root = sanitizeSessionToken(rootSessionId);
+	const agent = sanitizeSessionToken(agentId);
+	return `${root}__teamtask__${agent}__${nanoid(6)}`;
+}
+
+export function parseTeamTaskSubSessionId(
+	sessionId: string,
+): { rootSessionId: string; agentId: string; teamTaskId: string } | null {
+	const marker = "__teamtask__";
+	const markerIndex = sessionId.indexOf(marker);
+	if (markerIndex <= 0) {
+		return null;
+	}
+	const rootSessionId = sessionId.slice(0, markerIndex);
+	const remainder = sessionId.slice(markerIndex + marker.length);
+	const lastSeparator = remainder.lastIndexOf("__");
+	if (lastSeparator <= 0) {
+		return null;
+	}
+	const agentId = remainder.slice(0, lastSeparator);
+	const teamTaskId = remainder.slice(lastSeparator + 2);
+	if (!rootSessionId || !agentId || !teamTaskId) {
+		return null;
+	}
+	return { rootSessionId, agentId, teamTaskId };
+}
+
+export function parseSubSessionId(
+	sessionId: string,
+): { rootSessionId: string; agentId: string } | null {
+	if (parseTeamTaskSubSessionId(sessionId)) {
+		return null;
+	}
+	const separator = "__";
+	const separatorIndex = sessionId.indexOf(separator);
+	if (separatorIndex <= 0) {
+		return null;
+	}
+	const rootSessionId = sessionId.slice(0, separatorIndex);
+	const agentId = sessionId.slice(separatorIndex + separator.length);
+	if (!rootSessionId || !agentId) {
+		return null;
+	}
+	return { rootSessionId, agentId };
+}
+
+export function deriveSubsessionStatus(event: HookEventPayload): SessionStatus {
+	switch (event.hookName) {
+		case "agent_end":
+			return "completed";
+		case "agent_error":
+			return "failed";
+		case "session_shutdown": {
+			const reason = String(event.reason ?? "").toLowerCase();
+			if (
+				reason.includes("cancel") ||
+				reason.includes("abort") ||
+				reason.includes("interrupt")
+			) {
+				return "cancelled";
+			}
+			if (reason.includes("fail") || reason.includes("error")) {
+				return "failed";
+			}
+			return "completed";
+		}
+		default:
+			return "running";
+	}
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/session/models/session-manifest.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { SESSION_STATUSES } from "../../types/common";
+
+const SessionStatusSchema = z.enum(SESSION_STATUSES);
+
+export const SessionManifestSchema = z.object({
+	version: z.literal(1),
+	session_id: z.string().min(1),
+	source: z.string().min(1),
+	pid: z.number().int(),
+	started_at: z.string().min(1),
+	ended_at: z.string().min(1).optional(),
+	exit_code: z.number().int().nullable().optional(),
+	status: SessionStatusSchema,
+	interactive: z.boolean(),
+	provider: z.string().min(1),
+	model: z.string().min(1),
+	cwd: z.string().min(1),
+	workspace_root: z.string().min(1),
+	team_name: z.string().min(1).optional(),
+	enable_tools: z.boolean(),
+	enable_spawn: z.boolean(),
+	enable_teams: z.boolean(),
+	prompt: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	messages_path: z.string().min(1).optional(),
+});
+
+export type SessionManifest = z.infer<typeof SessionManifestSchema>;

codna/agent-core/vendor/cline/sdk/packages/core/src/session/models/session-row.ts

@@ -0,0 +1,199 @@
+import type { TeamTeammateSpec } from "@cline/shared";
+import type { AgentTeamsRuntime } from "../../extensions/tools/team";
+import type { SessionSource, SessionStatus } from "../../types/common";
+import type { SessionManifest } from "./session-manifest";
+
+export interface SessionRow {
+	sessionId: string;
+	source: string;
+	pid: number;
+	startedAt: string;
+	endedAt?: string | null;
+	exitCode?: number | null;
+	status: SessionStatus;
+	statusLock: number;
+	interactive: boolean;
+	provider: string;
+	model: string;
+	cwd: string;
+	workspaceRoot: string;
+	teamName?: string | null;
+	enableTools: boolean;
+	enableSpawn: boolean;
+	enableTeams: boolean;
+	parentSessionId?: string | null;
+	parentAgentId?: string | null;
+	agentId?: string | null;
+	conversationId?: string | null;
+	isSubagent: boolean;
+	prompt?: string | null;
+	metadata?: Record<string, unknown> | null;
+	hookPath?: string;
+	messagesPath?: string | null;
+	updatedAt: string;
+}
+
+export interface CreateRootSessionInput {
+	sessionId: string;
+	source: SessionSource;
+	pid: number;
+	startedAt: string;
+	interactive: boolean;
+	provider: string;
+	model: string;
+	cwd: string;
+	workspaceRoot: string;
+	teamName?: string;
+	enableTools: boolean;
+	enableSpawn: boolean;
+	enableTeams: boolean;
+	prompt?: string;
+	metadata?: Record<string, unknown>;
+	messagesPath: string;
+}
+
+export interface CreateRootSessionWithArtifactsInput {
+	sessionId: string;
+	source: SessionSource;
+	pid: number;
+	interactive: boolean;
+	provider: string;
+	model: string;
+	cwd: string;
+	workspaceRoot: string;
+	teamName?: string;
+	enableTools: boolean;
+	enableSpawn: boolean;
+	enableTeams: boolean;
+	prompt?: string;
+	metadata?: Record<string, unknown>;
+	startedAt?: string;
+}
+
+export interface RootSessionArtifacts {
+	manifestPath: string;
+	messagesPath: string;
+	manifest: SessionManifest;
+}
+
+export interface UpsertSubagentInput {
+	agentId: string;
+	parentAgentId: string;
+	conversationId: string;
+	prompt?: string;
+	rootSessionId?: string;
+}
+
+/** SELECT clause that aliases snake_case columns to camelCase SessionRow keys. */
+export const SESSION_SELECT_COLUMNS = `
+	session_id    AS sessionId,
+	source,
+	pid,
+	started_at    AS startedAt,
+	ended_at      AS endedAt,
+	exit_code     AS exitCode,
+	status,
+	status_lock   AS statusLock,
+	interactive,
+	provider,
+	model,
+	cwd,
+	workspace_root AS workspaceRoot,
+	team_name      AS teamName,
+	enable_tools   AS enableTools,
+	enable_spawn   AS enableSpawn,
+	enable_teams   AS enableTeams,
+	parent_session_id AS parentSessionId,
+	parent_agent_id   AS parentAgentId,
+	agent_id       AS agentId,
+	conversation_id AS conversationId,
+	is_subagent    AS isSubagent,
+	prompt,
+	metadata_json  AS metadata,
+	hook_path       AS hookPath,
+	messages_path   AS messagesPath,
+	updated_at      AS updatedAt`;
+
+export function patchSqliteRow(raw: Record<string, unknown>): SessionRow {
+	raw.interactive = raw.interactive === 1;
+	raw.enableTools = raw.enableTools === 1;
+	raw.enableSpawn = raw.enableSpawn === 1;
+	raw.enableTeams = raw.enableTeams === 1;
+	raw.isSubagent = raw.isSubagent === 1;
+	const meta = raw.metadata;
+	if (typeof meta === "string" && meta.trim()) {
+		try {
+			const parsed = JSON.parse(meta) as unknown;
+			raw.metadata =
+				parsed && typeof parsed === "object" && !Array.isArray(parsed)
+					? parsed
+					: null;
+		} catch {
+			raw.metadata = null;
+		}
+	} else {
+		raw.metadata = null;
+	}
+	return raw as unknown as SessionRow;
+}
+
+export function stringifyMetadata(
+	metadata: Record<string, unknown> | null | undefined,
+): string | null {
+	if (!metadata || Object.keys(metadata).length === 0) return null;
+	return JSON.stringify(metadata);
+}
+
+export type TeamRuntimeState = ReturnType<AgentTeamsRuntime["exportState"]>;
+
+export interface PersistedTeamEnvelope {
+	version: 1;
+	updatedAt: string;
+	teamState: TeamRuntimeState;
+	teammates: TeamTeammateSpec[];
+}
+
+export function reviveTeamStateDates(
+	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,
+		})),
+	};
+}

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

@@ -0,0 +1,284 @@
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	renameSync,
+	writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import type { BasicLogger } from "@cline/shared";
+import { resolveSessionDataDir } from "@cline/shared/storage";
+import type { SessionMessagesArtifactUploader } from "../../types/session";
+import type { SessionRow } from "../models/session-row";
+import type {
+	PersistedSessionUpdateInput,
+	SessionPersistenceAdapter,
+} from "./persistence-service";
+import { UnifiedSessionPersistenceService } from "./persistence-service";
+
+interface FileSessionIndex {
+	version: 1;
+	sessions: Record<string, SessionRow>;
+}
+
+interface FileSpawnRequest {
+	id: number;
+	rootSessionId: string;
+	parentAgentId: string;
+	task?: string;
+	systemPrompt?: string;
+	createdAt: string;
+	consumedAt?: string;
+}
+
+interface FileSpawnQueue {
+	version: 1;
+	nextId: number;
+	requests: FileSpawnRequest[];
+}
+
+function nowIso(): string {
+	return new Date().toISOString();
+}
+
+function atomicWriteJson(path: string, value: unknown): void {
+	const tempPath = `${path}.tmp`;
+	writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+	renameSync(tempPath, path);
+}
+
+class FileSessionPersistenceAdapter implements SessionPersistenceAdapter {
+	constructor(
+		private readonly sessionsDirPath: string = resolveSessionDataDir(),
+	) {}
+
+	ensureSessionsDir(): string {
+		if (!existsSync(this.sessionsDirPath)) {
+			mkdirSync(this.sessionsDirPath, { recursive: true });
+		}
+		return this.sessionsDirPath;
+	}
+
+	private indexPath(): string {
+		return join(this.ensureSessionsDir(), "sessions.index.json");
+	}
+
+	private spawnQueuePath(): string {
+		return join(this.ensureSessionsDir(), "subagent-spawn-queue.json");
+	}
+
+	private readIndex(): FileSessionIndex {
+		const path = this.indexPath();
+		if (!existsSync(path)) {
+			return { version: 1, sessions: {} };
+		}
+		try {
+			const parsed = JSON.parse(readFileSync(path, "utf8")) as FileSessionIndex;
+			if (parsed?.version === 1 && parsed.sessions) {
+				return parsed;
+			}
+		} catch {
+			// Ignore invalid persistence and fall back to an empty index.
+		}
+		return { version: 1, sessions: {} };
+	}
+
+	private writeIndex(index: FileSessionIndex): void {
+		atomicWriteJson(this.indexPath(), index);
+	}
+
+	private readQueue(): FileSpawnQueue {
+		const path = this.spawnQueuePath();
+		if (!existsSync(path)) {
+			return { version: 1, nextId: 1, requests: [] };
+		}
+		try {
+			const parsed = JSON.parse(readFileSync(path, "utf8")) as FileSpawnQueue;
+			if (
+				parsed?.version === 1 &&
+				typeof parsed.nextId === "number" &&
+				Array.isArray(parsed.requests)
+			) {
+				return parsed;
+			}
+		} catch {
+			// Ignore invalid persistence and fall back to an empty queue.
+		}
+		return { version: 1, nextId: 1, requests: [] };
+	}
+
+	private writeQueue(queue: FileSpawnQueue): void {
+		atomicWriteJson(this.spawnQueuePath(), queue);
+	}
+
+	async upsertSession(row: SessionRow): Promise<void> {
+		const index = this.readIndex();
+		index.sessions[row.sessionId] = row;
+		this.writeIndex(index);
+	}
+
+	async getSession(sessionId: string): Promise<SessionRow | undefined> {
+		return this.readIndex().sessions[sessionId];
+	}
+
+	async listSessions(options: {
+		limit: number;
+		parentSessionId?: string;
+		status?: string;
+	}): Promise<SessionRow[]> {
+		return Object.values(this.readIndex().sessions)
+			.filter((row) =>
+				options.parentSessionId !== undefined
+					? row.parentSessionId === options.parentSessionId
+					: true,
+			)
+			.filter((row) =>
+				options.status !== undefined ? row.status === options.status : true,
+			)
+			.sort((a, b) => b.startedAt.localeCompare(a.startedAt))
+			.slice(0, options.limit);
+	}
+
+	async updateSession(
+		input: PersistedSessionUpdateInput,
+	): Promise<{ updated: boolean; statusLock: number }> {
+		const index = this.readIndex();
+		const existing = index.sessions[input.sessionId];
+		if (!existing) {
+			return { updated: false, statusLock: 0 };
+		}
+		if (
+			input.expectedStatusLock !== undefined &&
+			existing.statusLock !== input.expectedStatusLock
+		) {
+			return { updated: false, statusLock: existing.statusLock };
+		}
+
+		const nextStatusLock =
+			input.expectedStatusLock !== undefined
+				? input.expectedStatusLock + 1
+				: existing.statusLock;
+		const next: SessionRow = {
+			...existing,
+			status: input.status ?? existing.status,
+			endedAt:
+				input.endedAt !== undefined
+					? input.endedAt
+					: (existing.endedAt ?? null),
+			exitCode:
+				input.exitCode !== undefined
+					? input.exitCode
+					: (existing.exitCode ?? null),
+			prompt:
+				input.prompt !== undefined ? input.prompt : (existing.prompt ?? null),
+			metadata:
+				input.metadata !== undefined
+					? (input.metadata ?? null)
+					: (existing.metadata ?? null),
+			parentSessionId:
+				input.parentSessionId !== undefined
+					? (input.parentSessionId ?? null)
+					: (existing.parentSessionId ?? null),
+			parentAgentId:
+				input.parentAgentId !== undefined
+					? (input.parentAgentId ?? null)
+					: (existing.parentAgentId ?? null),
+			agentId:
+				input.agentId !== undefined
+					? (input.agentId ?? null)
+					: (existing.agentId ?? null),
+			conversationId:
+				input.conversationId !== undefined
+					? (input.conversationId ?? null)
+					: (existing.conversationId ?? null),
+			statusLock: nextStatusLock,
+			isSubagent:
+				input.setRunning || input.parentSessionId !== undefined
+					? true
+					: existing.isSubagent,
+			updatedAt: nowIso(),
+		};
+
+		if (input.setRunning) {
+			next.status = "running";
+			next.endedAt = null;
+			next.exitCode = null;
+		}
+
+		index.sessions[input.sessionId] = next;
+		this.writeIndex(index);
+		return { updated: true, statusLock: next.statusLock };
+	}
+
+	async deleteSession(sessionId: string, cascade: boolean): Promise<boolean> {
+		const index = this.readIndex();
+		const existing = index.sessions[sessionId];
+		if (!existing) {
+			return false;
+		}
+		delete index.sessions[sessionId];
+		if (cascade) {
+			for (const row of Object.values(index.sessions)) {
+				if (row.parentSessionId === sessionId) {
+					delete index.sessions[row.sessionId];
+				}
+			}
+		}
+		this.writeIndex(index);
+		return true;
+	}
+
+	async enqueueSpawnRequest(input: {
+		rootSessionId: string;
+		parentAgentId: string;
+		task?: string;
+		systemPrompt?: string;
+	}): Promise<void> {
+		const queue = this.readQueue();
+		queue.requests.push({
+			id: queue.nextId,
+			rootSessionId: input.rootSessionId,
+			parentAgentId: input.parentAgentId,
+			task: input.task,
+			systemPrompt: input.systemPrompt,
+			createdAt: nowIso(),
+		});
+		queue.nextId += 1;
+		this.writeQueue(queue);
+	}
+
+	async claimSpawnRequest(
+		rootSessionId: string,
+		parentAgentId: string,
+	): Promise<string | undefined> {
+		const queue = this.readQueue();
+		const request = queue.requests.find(
+			(item) =>
+				item.rootSessionId === rootSessionId &&
+				item.parentAgentId === parentAgentId &&
+				!item.consumedAt,
+		);
+		if (!request) {
+			return undefined;
+		}
+		request.consumedAt = nowIso();
+		this.writeQueue(queue);
+		return request.task;
+	}
+}
+
+export class FileSessionService extends UnifiedSessionPersistenceService {
+	constructor(
+		sessionsDir?: string,
+		options: {
+			messagesArtifactUploader?: SessionMessagesArtifactUploader;
+			logger?: BasicLogger;
+		} = {},
+	) {
+		super(new FileSessionPersistenceAdapter(sessionsDir), options);
+	}
+
+	override ensureSessionsDir(): string {
+		return super.ensureSessionsDir();
+	}
+}