@clinebot/core 0.0.37 → 0.0.38

package/src/extensions/tools/team/projections.ts

@@ -1,283 +0,0 @@
-import type {
-	TeamOutcome,
-	TeamOutcomeFragment,
-	TeamProgressLifecycleEvent,
-	TeamProgressSummary,
-	TeamRuntimeState,
-} from "@clinebot/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(),
-	};
-}

package/src/extensions/tools/team/runtime.ts

@@ -1,54 +0,0 @@
-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";

package/src/extensions/tools/team/spawn-agent-tool.ts

@@ -1,201 +0,0 @@
-/**
- * Reusable spawn_agent tool for delegating tasks to sub-agents.
- */
-
-import {
-	type AgentConfig,
-	type AgentEvent,
-	type AgentHooks,
-	type AgentResult,
-	type BasicLogger,
-	createTool,
-	type HookErrorMode,
-	type ITelemetryService,
-	type Tool,
-	type ToolApprovalRequest,
-	type ToolApprovalResult,
-	type ToolContext,
-	type ToolPolicy,
-	zodToJsonSchema,
-} from "@clinebot/shared";
-import { z } from "zod";
-import {
-	createDelegatedAgent,
-	type DelegatedAgentConfigProvider,
-} from "./delegated-agent";
-
-type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
-type AgentFinishReason = AgentResult["finishReason"];
-
-export const SpawnAgentInputSchema = z.object({
-	systemPrompt: z
-		.string()
-		.describe("System prompt defining the sub-agent's behavior"),
-	task: z.string().describe("Task for the sub-agent to complete"),
-});
-
-export type SpawnAgentInput = z.infer<typeof SpawnAgentInputSchema>;
-
-export interface SpawnAgentOutput {
-	text: string;
-	iterations: number;
-	finishReason: AgentFinishReason;
-	usage: {
-		inputTokens: number;
-		outputTokens: number;
-	};
-}
-
-export interface SubAgentStartContext {
-	subAgentId: string;
-	conversationId: string;
-	parentAgentId: string;
-	input: SpawnAgentInput;
-}
-
-export interface SubAgentEndContext {
-	subAgentId: string;
-	conversationId: string;
-	parentAgentId: string;
-	input: SpawnAgentInput;
-	result?: SpawnAgentOutput;
-	error?: Error;
-}
-
-export interface SpawnAgentToolConfig {
-	configProvider: DelegatedAgentConfigProvider;
-	defaultMaxIterations?: number;
-	subAgentTools?: Tool[];
-	createSubAgentTools?: (
-		input: SpawnAgentInput,
-		context: ToolContext,
-	) => Tool[] | Promise<Tool[]>;
-	onSubAgentEvent?: (event: AgentEvent) => void;
-	/**
-	 * Lifecycle hooks forwarded to spawned sub-agent runs.
-	 */
-	hooks?: AgentHooks;
-	/**
-	 * Extension list forwarded to spawned sub-agent runs.
-	 */
-	extensions?: AgentExtension[];
-	/**
-	 * Error handling mode for forwarded lifecycle hooks.
-	 */
-	hookErrorMode?: HookErrorMode;
-	/**
-	 * Called after a sub-agent instance is created and before it starts running.
-	 * Errors are ignored so lifecycle observers cannot break task execution.
-	 */
-	onSubAgentStart?: (context: SubAgentStartContext) => void | Promise<void>;
-	/**
-	 * Called once a sub-agent run finishes (success or error).
-	 * Errors are ignored so lifecycle observers cannot break task execution.
-	 */
-	onSubAgentEnd?: (context: SubAgentEndContext) => void | Promise<void>;
-	/**
-	 * Optional per-tool policy for spawned sub-agents.
-	 */
-	toolPolicies?: Record<string, ToolPolicy>;
-	/**
-	 * Optional approval callback for spawned sub-agent tool calls.
-	 */
-	requestToolApproval?: (
-		request: ToolApprovalRequest,
-	) => Promise<ToolApprovalResult> | ToolApprovalResult;
-	/**
-	 * Optional logger forwarded to spawned sub-agent runs.
-	 */
-	logger?: BasicLogger;
-	telemetry?: ITelemetryService;
-}
-
-/**
- * Create a spawn_agent tool that can run a delegated task with a focused sub-agent.
- */
-export function createSpawnAgentTool(
-	config: SpawnAgentToolConfig,
-): Tool<SpawnAgentInput, SpawnAgentOutput> {
-	return createTool<SpawnAgentInput, SpawnAgentOutput>({
-		name: "spawn_agent",
-		description: `Spawn a sub-agent with a custom system prompt for specialized tasks. Use when delegating work that benefits from focused expertise.`,
-		inputSchema: zodToJsonSchema(SpawnAgentInputSchema),
-		execute: async (input, context) => {
-			const tools = config.createSubAgentTools
-				? await config.createSubAgentTools(input, context)
-				: (config.subAgentTools ?? []);
-
-			const subAgent = createDelegatedAgent({
-				kind: "subagent",
-				prompt: input.systemPrompt,
-				configProvider: config.configProvider,
-				tools,
-				maxIterations: config.defaultMaxIterations,
-				parentAgentId: context.agentId,
-				abortSignal: context.abortSignal,
-				onEvent: config.onSubAgentEvent,
-				hookErrorMode: config.hookErrorMode,
-				toolPolicies: config.toolPolicies,
-				requestToolApproval: config.requestToolApproval,
-			});
-			const subAgentId = subAgent.getAgentId();
-			const conversationId = subAgent.getConversationId();
-			const parentAgentId = context.agentId;
-			if (config.onSubAgentStart) {
-				try {
-					await config.onSubAgentStart({
-						subAgentId,
-						conversationId,
-						parentAgentId,
-						input,
-					});
-				} catch {
-					// Best-effort observer callback.
-				}
-			}
-			try {
-				const result = await subAgent.run(input.task);
-				const output: SpawnAgentOutput = {
-					text: result.text,
-					iterations: result.iterations,
-					finishReason: result.finishReason,
-					usage: {
-						inputTokens: result.usage.inputTokens,
-						outputTokens: result.usage.outputTokens,
-					},
-				};
-				if (config.onSubAgentEnd) {
-					try {
-						await config.onSubAgentEnd({
-							subAgentId,
-							conversationId,
-							parentAgentId,
-							input,
-							result: output,
-						});
-					} catch {
-						// Best-effort observer callback.
-					}
-				}
-				return output;
-			} catch (error) {
-				if (config.onSubAgentEnd) {
-					try {
-						await config.onSubAgentEnd({
-							subAgentId,
-							conversationId,
-							parentAgentId,
-							input,
-							error: error instanceof Error ? error : new Error(String(error)),
-						});
-					} catch {
-						// Best-effort observer callback.
-					}
-				}
-				throw error;
-			}
-		},
-		timeoutMs: 300000,
-		retryable: false,
-	});
-}

package/src/extensions/tools/team/subagent-prompts.ts

@@ -1,41 +0,0 @@
-import { buildClineSystemPrompt } from "@clinebot/shared";
-import type { DelegatedAgentRuntimeConfig } from "./delegated-agent";
-
-export function buildTeammateSystemPrompt(
-	prompt: string,
-	config: DelegatedAgentRuntimeConfig,
-): string {
-	const trimmedPrompt = prompt.trim();
-	if (config.providerId.toLowerCase() !== "cline") {
-		return trimmedPrompt;
-	}
-
-	return buildClineSystemPrompt({
-		ide: config.clineIdeName?.trim() || "Terminal",
-		workspaceRoot: config.cwd?.trim() || "/",
-		providerId: config.providerId,
-		rules: `# Team Teammate Role\n${trimmedPrompt}`,
-		platform: config.clinePlatform,
-		metadata: config.workspaceMetadata,
-	});
-}
-
-export function buildSubAgentSystemPrompt(
-	// The prompt provided when spawning the subagent
-	prompt: string,
-	config: DelegatedAgentRuntimeConfig,
-): string {
-	const trimmedPrompt = prompt.trim();
-	if (config.providerId.toLowerCase() !== "cline") {
-		return trimmedPrompt;
-	}
-
-	return buildClineSystemPrompt({
-		ide: config.clineIdeName || "Terminal",
-		workspaceRoot: config.cwd?.trim() || "/",
-		providerId: config.providerId,
-		overridePrompt: trimmedPrompt,
-		metadata: config.workspaceMetadata,
-		platform: config.clinePlatform,
-	});
-}