codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/extensions/tools/team/projections.ts

@@ -0,0 +1,283 @@
+import type {
+	TeamOutcome,
+	TeamOutcomeFragment,
+	TeamProgressLifecycleEvent,
+	TeamProgressSummary,
+	TeamRuntimeState,
+} from "@cline/shared";
+import type { TeamEvent } from "./multi-agent";
+
+function toIsoNow(): string {
+	return new Date().toISOString();
+}
+
+function pct(numerator: number, denominator: number): number {
+	if (denominator <= 0) {
+		return 0;
+	}
+	return Math.round((numerator / denominator) * 100);
+}
+
+function collectMissingRequiredSections(
+	outcomes: TeamOutcome[],
+	fragments: TeamOutcomeFragment[],
+): string[] {
+	const approvedSections = new Set<string>();
+	for (const fragment of fragments) {
+		if (fragment.status === "reviewed") {
+			approvedSections.add(`${fragment.outcomeId}:${fragment.section}`);
+		}
+	}
+	const missing = new Set<string>();
+	for (const outcome of outcomes) {
+		if (outcome.status === "finalized") {
+			continue;
+		}
+		for (const section of outcome.requiredSections) {
+			if (!approvedSections.has(`${outcome.id}:${section}`)) {
+				missing.add(`${outcome.id}:${section}`);
+			}
+		}
+	}
+	return [...missing].sort((a, b) => a.localeCompare(b));
+}
+
+export function buildTeamProgressSummary(
+	teamName: string,
+	state: TeamRuntimeState,
+): TeamProgressSummary {
+	const membersByStatus: Record<"idle" | "running" | "stopped", number> = {
+		idle: 0,
+		running: 0,
+		stopped: 0,
+	};
+	const tasksByStatus: Record<
+		"pending" | "in_progress" | "blocked" | "completed",
+		number
+	> = {
+		pending: 0,
+		in_progress: 0,
+		blocked: 0,
+		completed: 0,
+	};
+	const runsByStatus: Record<
+		"queued" | "running" | "completed" | "failed" | "cancelled" | "interrupted",
+		number
+	> = {
+		queued: 0,
+		running: 0,
+		completed: 0,
+		failed: 0,
+		cancelled: 0,
+		interrupted: 0,
+	};
+	const outcomesByStatus: Record<"draft" | "in_review" | "finalized", number> =
+		{
+			draft: 0,
+			in_review: 0,
+			finalized: 0,
+		};
+	const fragmentsByStatus: Record<"draft" | "reviewed" | "rejected", number> = {
+		draft: 0,
+		reviewed: 0,
+		rejected: 0,
+	};
+
+	let leadCount = 0;
+	let teammateCount = 0;
+	for (const member of state.members) {
+		membersByStatus[member.status] += 1;
+		if (member.role === "lead") {
+			leadCount += 1;
+		} else {
+			teammateCount += 1;
+		}
+	}
+
+	const blockedTaskIds: string[] = [];
+	const readyTaskIds: string[] = [];
+	const completedTaskCount = state.tasks.filter(
+		(task) => task.status === "completed",
+	).length;
+	const taskById = new Map(state.tasks.map((task) => [task.id, task] as const));
+	for (const task of state.tasks) {
+		tasksByStatus[task.status] += 1;
+		if (task.status === "blocked") {
+			blockedTaskIds.push(task.id);
+			continue;
+		}
+		if (task.status !== "pending") {
+			continue;
+		}
+		const depsSatisfied = task.dependsOn.every((depId) => {
+			const dependency = taskById.get(depId);
+			return dependency?.status === "completed";
+		});
+		if (depsSatisfied) {
+			readyTaskIds.push(task.id);
+		}
+	}
+
+	const activeRunIds: string[] = [];
+	let latestRunId: string | undefined;
+	let latestRunTs = 0;
+	for (const run of state.runs) {
+		runsByStatus[run.status] += 1;
+		if (run.status === "queued" || run.status === "running") {
+			activeRunIds.push(run.id);
+		}
+		const startedAtTs = run.startedAt.getTime();
+		if (startedAtTs >= latestRunTs) {
+			latestRunTs = startedAtTs;
+			latestRunId = run.id;
+		}
+	}
+
+	for (const outcome of state.outcomes) {
+		outcomesByStatus[outcome.status] += 1;
+	}
+	for (const fragment of state.outcomeFragments) {
+		fragmentsByStatus[fragment.status] += 1;
+	}
+
+	return {
+		teamName,
+		updatedAt: toIsoNow(),
+		members: {
+			total: state.members.length,
+			byStatus: membersByStatus,
+			leadCount,
+			teammateCount,
+		},
+		tasks: {
+			total: state.tasks.length,
+			byStatus: tasksByStatus,
+			blockedTaskIds,
+			readyTaskIds,
+			completionPct: pct(completedTaskCount, state.tasks.length),
+		},
+		runs: {
+			total: state.runs.length,
+			byStatus: runsByStatus,
+			activeRunIds,
+			latestRunId,
+		},
+		outcomes: {
+			total: state.outcomes.length,
+			byStatus: outcomesByStatus,
+			finalizedPct: pct(outcomesByStatus.finalized, state.outcomes.length),
+			missingRequiredSections: collectMissingRequiredSections(
+				state.outcomes,
+				state.outcomeFragments,
+			),
+		},
+		fragments: {
+			total: state.outcomeFragments.length,
+			byStatus: fragmentsByStatus,
+		},
+	};
+}
+
+export function toTeamProgressLifecycleEvent(input: {
+	teamName: string;
+	sessionId: string;
+	event: TeamEvent;
+}): TeamProgressLifecycleEvent {
+	const { event } = input;
+	switch (event.type) {
+		case "team_task_updated":
+			return {
+				teamName: input.teamName,
+				sessionId: input.sessionId,
+				eventType: event.type,
+				ts: toIsoNow(),
+				taskId: event.task.id,
+				agentId: event.task.assignee ?? event.task.createdBy,
+			};
+		case "run_queued":
+		case "run_started":
+		case "run_completed":
+		case "run_failed":
+		case "run_cancelled":
+		case "run_interrupted":
+			return {
+				teamName: input.teamName,
+				sessionId: input.sessionId,
+				eventType: event.type,
+				ts: toIsoNow(),
+				runId: event.run.id,
+				taskId: event.run.taskId,
+				agentId: event.run.agentId,
+				message: event.run.error,
+			};
+		case "run_progress":
+			return {
+				teamName: input.teamName,
+				sessionId: input.sessionId,
+				eventType: event.type,
+				ts: toIsoNow(),
+				runId: event.run.id,
+				taskId: event.run.taskId,
+				agentId: event.run.agentId,
+				message: event.message,
+			};
+		case "outcome_created":
+		case "outcome_finalized":
+			return {
+				teamName: input.teamName,
+				sessionId: input.sessionId,
+				eventType: event.type,
+				ts: toIsoNow(),
+				outcomeId: event.outcome.id,
+			};
+		case "outcome_fragment_attached":
+		case "outcome_fragment_reviewed":
+			return {
+				teamName: input.teamName,
+				sessionId: input.sessionId,
+				eventType: event.type,
+				ts: toIsoNow(),
+				outcomeId: event.fragment.outcomeId,
+				fragmentId: event.fragment.id,
+				agentId: event.fragment.sourceAgentId,
+			};
+		case "team_message":
+			return {
+				teamName: input.teamName,
+				sessionId: input.sessionId,
+				eventType: event.type,
+				ts: toIsoNow(),
+				taskId: event.message.taskId,
+				agentId: event.message.fromAgentId,
+				message: event.message.subject,
+			};
+		case "team_mission_log":
+			return {
+				teamName: input.teamName,
+				sessionId: input.sessionId,
+				eventType: event.type,
+				ts: toIsoNow(),
+				taskId: event.entry.taskId,
+				agentId: event.entry.agentId,
+				message: event.entry.summary,
+			};
+		case "teammate_spawned":
+		case "teammate_shutdown":
+		case "task_start":
+		case "task_end":
+		case "agent_event":
+			return {
+				teamName: input.teamName,
+				sessionId: input.sessionId,
+				eventType: event.type,
+				ts: toIsoNow(),
+				agentId: event.agentId,
+			};
+	}
+	return {
+		teamName: input.teamName,
+		sessionId: input.sessionId,
+		eventType: (event as TeamEvent).type,
+		ts: toIsoNow(),
+	};
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/extensions/tools/team/runtime.ts

@@ -0,0 +1,54 @@
+export {
+	buildDelegatedAgentConfig,
+	createDelegatedAgent,
+	createDelegatedAgentConfigProvider,
+	type DelegatedAgentConfigProvider,
+	type DelegatedAgentConnectionConfig,
+	type DelegatedAgentKind,
+	type DelegatedAgentRuntimeConfig,
+} from "./delegated-agent";
+
+// =============================================================================
+// Spawn Agent Tool
+// =============================================================================
+
+export {
+	createSpawnAgentTool,
+	type SpawnAgentInput,
+	type SpawnAgentOutput,
+	type SpawnAgentToolConfig,
+	type SubAgentEndContext,
+	type SubAgentStartContext,
+} from "./spawn-agent-tool";
+
+// =============================================================================
+// Multi-Agent
+// =============================================================================
+
+export {
+	type AgentTask,
+	AgentTeam,
+	AgentTeamsRuntime,
+	type AgentTeamsRuntimeOptions,
+	createAgentTeam,
+	createWorkerReviewerTeam,
+	type SpawnTeammateOptions,
+	type TaskResult,
+	type TeamEvent,
+	type TeamMemberConfig,
+} from "./multi-agent";
+
+// =============================================================================
+// Team Tools
+// =============================================================================
+
+export {
+	type BootstrapAgentTeamsOptions,
+	type BootstrapAgentTeamsResult,
+	bootstrapAgentTeams,
+	type CreateAgentTeamsToolsOptions,
+	createAgentTeamsTools,
+	reviveTeamStateDates,
+	sanitizeTeamName,
+	type TeamTeammateRuntimeConfig,
+} from "./team-tools";

codna/agent-core/vendor/cline/sdk/packages/core/src/extensions/tools/team/spawn-agent-tool.test.ts

@@ -0,0 +1,378 @@
+import type { AgentConfig } from "@cline/shared";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createDelegatedAgentConfigProvider } from "./delegated-agent";
+
+type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
+
+const runMock = vi.fn();
+const getAgentIdMock = vi.fn(() => "sub-agent-1");
+const getConversationIdMock = vi.fn(() => "conv-sub-1");
+const agentConstructorSpy = vi.fn();
+
+vi.mock("../../../runtime/orchestration/session-runtime-orchestrator", () => {
+	return {
+		SessionRuntime: class MockSessionRuntime {
+			constructor(config: unknown) {
+				agentConstructorSpy(config);
+			}
+
+			getAgentId(): string {
+				return getAgentIdMock();
+			}
+
+			getConversationId(): string {
+				return getConversationIdMock();
+			}
+
+			subscribeEvents(): () => void {
+				return () => {};
+			}
+
+			async run(input: string): Promise<unknown> {
+				return runMock(input);
+			}
+		},
+	};
+});
+
+describe("createSpawnAgentTool", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("creates a sub-agent, forwards callbacks, and returns normalized output", async () => {
+		const { createSpawnAgentTool } = await import("./spawn-agent-tool.js");
+		runMock.mockResolvedValue({
+			text: "sub-agent result",
+			iterations: 2,
+			finishReason: "completed",
+			usage: { inputTokens: 11, outputTokens: 7 },
+		});
+
+		const onSubAgentStart = vi.fn();
+		const onSubAgentEnd = vi.fn();
+		const createSubAgentTools = vi.fn().mockResolvedValue([]);
+		const extensions = [
+			{
+				name: "sample-ext",
+				manifest: { capabilities: ["hooks"] },
+				hooks: { onEvent: vi.fn() },
+			} as AgentExtension,
+		];
+
+		const tool = createSpawnAgentTool({
+			configProvider: createDelegatedAgentConfigProvider({
+				providerId: "anthropic",
+				modelId: "mock-model",
+				extensions,
+			}),
+			defaultMaxIterations: 4,
+			createSubAgentTools,
+			onSubAgentStart,
+			onSubAgentEnd,
+		});
+
+		const output = await tool.execute(
+			{
+				systemPrompt: "You are focused",
+				task: "Do delegated work",
+			},
+			{
+				agentId: "parent-1",
+				conversationId: "conv-parent",
+				iteration: 3,
+			},
+		);
+
+		expect(createSubAgentTools).toHaveBeenCalledTimes(1);
+		expect(runMock).toHaveBeenCalledWith("Do delegated work");
+		expect(onSubAgentStart).toHaveBeenCalledTimes(1);
+		expect(onSubAgentEnd).toHaveBeenCalledTimes(1);
+		expect(output).toEqual({
+			text: "sub-agent result",
+			iterations: 2,
+			finishReason: "completed",
+			usage: {
+				inputTokens: 11,
+				outputTokens: 7,
+			},
+		});
+		expect(agentConstructorSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				parentAgentId: "parent-1",
+				maxIterations: 4,
+				extensions,
+			}),
+		);
+		expect(agentConstructorSpy).toHaveBeenCalledWith(
+			expect.not.objectContaining({
+				prepareTurn: expect.anything(),
+			}),
+		);
+	});
+
+	it("passes extension hooks through delegated config", async () => {
+		const { createSpawnAgentTool } = await import("./spawn-agent-tool.js");
+		runMock.mockResolvedValue({
+			text: "sub-agent result",
+			iterations: 1,
+			finishReason: "completed",
+			usage: { inputTokens: 1, outputTokens: 1 },
+		});
+
+		const extensions = [
+			{
+				name: "before-start-ext",
+				manifest: {
+					capabilities: ["hooks"],
+				},
+				hooks: { beforeModel: vi.fn() },
+			} as AgentExtension,
+		];
+
+		const tool = createSpawnAgentTool({
+			configProvider: createDelegatedAgentConfigProvider({
+				providerId: "anthropic",
+				modelId: "mock-model",
+				extensions,
+			}),
+			subAgentTools: [],
+		});
+
+		await tool.execute(
+			{
+				systemPrompt: "You are focused",
+				task: "Do delegated work",
+			},
+			{
+				agentId: "parent-1",
+				conversationId: "conv-parent",
+				iteration: 3,
+			},
+		);
+
+		expect(agentConstructorSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				extensions,
+			}),
+		);
+	});
+
+	it("propagates sub-agent errors and still reports onSubAgentEnd", async () => {
+		const { createSpawnAgentTool } = await import("./spawn-agent-tool.js");
+		runMock.mockRejectedValue(new Error("sub-agent failed"));
+		const onSubAgentEnd = vi.fn();
+
+		const tool = createSpawnAgentTool({
+			configProvider: createDelegatedAgentConfigProvider({
+				providerId: "anthropic",
+				modelId: "mock-model",
+			}),
+			subAgentTools: [],
+			onSubAgentEnd,
+		});
+
+		await expect(
+			tool.execute(
+				{
+					systemPrompt: "System",
+					task: "Fail task",
+				},
+				{
+					agentId: "parent-2",
+					conversationId: "conv-parent",
+					iteration: 1,
+				},
+			),
+		).rejects.toThrow("sub-agent failed");
+
+		expect(onSubAgentEnd).toHaveBeenCalledTimes(1);
+		expect(onSubAgentEnd).toHaveBeenCalledWith(
+			expect.objectContaining({
+				parentAgentId: "parent-2",
+				error: expect.any(Error),
+			}),
+		);
+	});
+
+	it("leaves maxIterations unset when neither input nor default is provided", async () => {
+		const { createSpawnAgentTool } = await import("./spawn-agent-tool.js");
+		runMock.mockResolvedValue({
+			text: "sub-agent result",
+			iterations: 1,
+			finishReason: "completed",
+			usage: { inputTokens: 1, outputTokens: 1 },
+		});
+
+		const tool = createSpawnAgentTool({
+			configProvider: createDelegatedAgentConfigProvider({
+				providerId: "anthropic",
+				modelId: "mock-model",
+			}),
+			subAgentTools: [],
+		});
+
+		await tool.execute(
+			{
+				systemPrompt: "System",
+				task: "Do task",
+			},
+			{
+				agentId: "parent-3",
+				conversationId: "conv-parent",
+				iteration: 1,
+			},
+		);
+
+		expect(agentConstructorSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				maxIterations: undefined,
+			}),
+		);
+	});
+
+	it("appends workspace metadata for cline sub-agents when missing", async () => {
+		const { createSpawnAgentTool } = await import("./spawn-agent-tool.js");
+		runMock.mockResolvedValue({
+			text: "ok",
+			iterations: 1,
+			finishReason: "completed",
+			usage: { inputTokens: 1, outputTokens: 1 },
+		});
+
+		const workspaceMetadata = `# Workspace Configuration
+{
+  "workspaces": {
+    "/repo/demo": {
+      "hint": "demo"
+    }
+  }
+}`;
+
+		const tool = createSpawnAgentTool({
+			configProvider: createDelegatedAgentConfigProvider({
+				providerId: "cline",
+				modelId: "anthropic/claude-sonnet-4.6",
+				cwd: "/repo/demo",
+				workspaceMetadata,
+			}),
+			subAgentTools: [],
+		});
+
+		await tool.execute(
+			{
+				systemPrompt: "You are a specialist teammate.",
+				task: "Investigate module boundaries",
+			},
+			{
+				agentId: "parent-4",
+				conversationId: "conv-parent",
+				iteration: 1,
+			},
+		);
+
+		expect(agentConstructorSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				systemPrompt: expect.stringContaining(workspaceMetadata),
+			}),
+		);
+	});
+
+	it("does not duplicate workspace metadata for cline sub-agents", async () => {
+		const { createSpawnAgentTool } = await import("./spawn-agent-tool.js");
+		runMock.mockResolvedValue({
+			text: "ok",
+			iterations: 1,
+			finishReason: "completed",
+			usage: { inputTokens: 1, outputTokens: 1 },
+		});
+
+		const inputSystemPrompt = `You are a specialist teammate.
+
+# Workspace Configuration
+{
+  "workspaces": {
+    "/repo/demo": {
+      "hint": "demo"
+    }
+  }
+}`;
+
+		const tool = createSpawnAgentTool({
+			configProvider: createDelegatedAgentConfigProvider({
+				providerId: "cline",
+				modelId: "anthropic/claude-sonnet-4.6",
+				cwd: "/repo/demo",
+				workspaceMetadata: "# Workspace Configuration\n{}",
+			}),
+			subAgentTools: [],
+		});
+
+		await tool.execute(
+			{
+				systemPrompt: inputSystemPrompt,
+				task: "Investigate module boundaries",
+			},
+			{
+				agentId: "parent-5",
+				conversationId: "conv-parent",
+				iteration: 1,
+			},
+		);
+
+		expect(agentConstructorSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				systemPrompt: inputSystemPrompt,
+			}),
+		);
+	});
+
+	it("resolves connection settings lazily at execution time", async () => {
+		const { createSpawnAgentTool } = await import("./spawn-agent-tool.js");
+		runMock.mockResolvedValue({
+			text: "ok",
+			iterations: 1,
+			finishReason: "completed",
+			usage: { inputTokens: 1, outputTokens: 1 },
+		});
+
+		const configProvider = createDelegatedAgentConfigProvider({
+			providerId: "cline",
+			modelId: "stale-model",
+			apiKey: "oauth-access-old",
+		});
+		const updateConnectionDefaults = vi.spyOn(
+			configProvider,
+			"updateConnectionDefaults",
+		);
+		configProvider.updateConnectionDefaults({
+			apiKey: "oauth-access-new",
+			modelId: "updated-model",
+		});
+
+		const tool = createSpawnAgentTool({
+			configProvider,
+			subAgentTools: [],
+		});
+
+		await tool.execute(
+			{
+				systemPrompt: "System",
+				task: "Do task",
+			},
+			{
+				agentId: "parent-6",
+				conversationId: "conv-parent",
+				iteration: 1,
+			},
+		);
+
+		expect(updateConnectionDefaults).toHaveBeenCalledTimes(1);
+		expect(agentConstructorSpy).toHaveBeenCalledWith(
+			expect.objectContaining({
+				apiKey: "oauth-access-new",
+				modelId: "updated-model",
+			}),
+		);
+	});
+});