@clinebot/core 0.0.0

package/src/team/projections.ts

@@ -0,0 +1,285 @@
+import type {
+	TeamEvent,
+	TeamOutcome,
+	TeamOutcomeFragment,
+	TeamRuntimeState,
+} from "@clinebot/agents";
+import type {
+	TeamProgressLifecycleEvent,
+	TeamProgressSummary,
+} from "@clinebot/shared";
+
+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/types/common.ts

@@ -0,0 +1,14 @@
+import { SESSION_STATUS_VALUES } from "@clinebot/shared";
+
+export const SESSION_STATUSES = SESSION_STATUS_VALUES;
+
+export type SessionStatus = (typeof SESSION_STATUSES)[number];
+
+export enum SessionSource {
+	CLI = "cli",
+	CLI_SUBAGENT = "cli-subagent",
+	CORE = "core",
+	CORE_SUBAGENT = "core-subagent",
+	DESKTOP = "desktop",
+	DESKTOP_CHAT = "desktop-chat",
+}

package/src/types/config.ts

@@ -0,0 +1,64 @@
+import type {
+	AgentConfig,
+	AgentHooks,
+	HookErrorMode,
+	TeamEvent,
+	Tool,
+} from "@clinebot/agents";
+import type { providers as LlmsProviders } from "@clinebot/llms";
+import type {
+	AgentMode,
+	BasicLogger,
+	SessionExecutionConfig,
+	SessionPromptConfig,
+	SessionWorkspaceConfig,
+} from "@clinebot/shared";
+
+export type CoreAgentMode = AgentMode;
+
+export interface CoreModelConfig {
+	providerId: string;
+	modelId: string;
+	apiKey?: string;
+	baseUrl?: string;
+	headers?: Record<string, string>;
+	providerConfig?: LlmsProviders.ProviderConfig;
+	knownModels?: Record<string, LlmsProviders.ModelInfo>;
+	/**
+	 * Request model-side thinking/reasoning when supported.
+	 */
+	thinking?: boolean;
+}
+
+export interface CoreRuntimeFeatures {
+	enableTools: boolean;
+	enableSpawnAgent: boolean;
+	enableAgentTeams: boolean;
+}
+
+export interface CoreSessionConfig
+	extends CoreModelConfig,
+		CoreRuntimeFeatures,
+		Omit<SessionWorkspaceConfig, "workspaceRoot">,
+		Omit<SessionPromptConfig, "systemPrompt">,
+		Omit<
+			SessionExecutionConfig,
+			| "enableTools"
+			| "teamName"
+			| "missionLogIntervalSteps"
+			| "missionLogIntervalMs"
+		> {
+	sessionId?: string;
+	workspaceRoot?: string;
+	systemPrompt: string;
+	teamName?: string;
+	missionLogIntervalSteps?: number;
+	missionLogIntervalMs?: number;
+	hooks?: AgentHooks;
+	hookErrorMode?: HookErrorMode;
+	logger?: BasicLogger;
+	extraTools?: Tool[];
+	pluginPaths?: string[];
+	extensions?: AgentConfig["extensions"];
+	onTeamEvent?: (event: TeamEvent) => void;
+}

package/src/types/events.ts

@@ -0,0 +1,46 @@
+export interface SessionChunkEvent {
+	sessionId: string;
+	stream: "stdout" | "stderr" | "agent";
+	chunk: string;
+	ts: number;
+}
+
+export interface SessionEndedEvent {
+	sessionId: string;
+	reason: string;
+	ts: number;
+}
+
+export interface SessionToolEvent {
+	sessionId: string;
+	hookEventName: "tool_call" | "tool_result" | "agent_end" | "session_shutdown";
+	agentId?: string;
+	conversationId?: string;
+	parentAgentId?: string;
+	iteration?: number;
+	toolName?: string;
+	inputTokens?: number;
+	outputTokens?: number;
+	ts?: string;
+}
+
+export interface SessionTeamProgressEvent {
+	sessionId: string;
+	teamName: string;
+	lifecycle: import("@clinebot/shared").TeamProgressLifecycleEvent;
+	summary: import("@clinebot/shared").TeamProgressSummary;
+}
+
+export type CoreSessionEvent =
+	| { type: "chunk"; payload: SessionChunkEvent }
+	| {
+			type: "agent_event";
+			payload: {
+				sessionId: string;
+				event: import("@clinebot/agents").AgentEvent;
+			};
+	  }
+	| { type: "team_progress"; payload: SessionTeamProgressEvent }
+	| { type: "ended"; payload: SessionEndedEvent }
+	| { type: "hook"; payload: SessionToolEvent }
+	| { type: "status"; payload: { sessionId: string; status: string } };

package/src/types/index.ts

@@ -0,0 +1,24 @@
+export type { SessionSource, SessionStatus } from "./common";
+export type {
+	CoreAgentMode,
+	CoreModelConfig,
+	CoreRuntimeFeatures,
+	CoreSessionConfig,
+} from "./config";
+export type {
+	CoreSessionEvent,
+	SessionChunkEvent,
+	SessionEndedEvent,
+	SessionTeamProgressEvent,
+	SessionToolEvent,
+} from "./events";
+export type {
+	ProviderConfig,
+	ProviderSettings,
+	ProviderTokenSource,
+	StoredProviderSettings,
+	StoredProviderSettingsEntry,
+} from "./provider-settings";
+export type { SessionRecord, SessionRef } from "./sessions";
+export type { ArtifactStore, SessionStore, TeamStore } from "./storage";
+export type { WorkspaceInfo } from "./workspace";

package/src/types/provider-settings.ts

@@ -0,0 +1,43 @@
+import { providers } from "@clinebot/llms";
+import { z } from "zod";
+
+export type ProviderConfig = providers.ProviderConfig;
+export type ProviderSettings = providers.ProviderSettings;
+export const ProviderSettingsSchema: z.ZodType<ProviderSettings> =
+	providers.ProviderSettingsSchema;
+export const toProviderConfig = providers.toProviderConfig;
+
+export type ProviderTokenSource = "manual" | "oauth" | "migration";
+
+export interface StoredProviderSettingsEntry {
+	settings: ProviderSettings;
+	updatedAt: string;
+	tokenSource: ProviderTokenSource;
+}
+
+export interface StoredProviderSettings {
+	version: 1;
+	lastUsedProvider?: string;
+	providers: Record<string, StoredProviderSettingsEntry>;
+}
+
+export const StoredProviderSettingsEntrySchema: z.ZodType<StoredProviderSettingsEntry> =
+	z.object({
+		settings: providers.ProviderSettingsSchema,
+		updatedAt: z.string().datetime(),
+		tokenSource: z.enum(["manual", "oauth", "migration"]).default("manual"),
+	});
+
+export const StoredProviderSettingsSchema: z.ZodType<StoredProviderSettings> =
+	z.object({
+		version: z.literal(1),
+		lastUsedProvider: z.string().min(1).optional(),
+		providers: z.record(z.string(), StoredProviderSettingsEntrySchema),
+	});
+
+export function emptyStoredProviderSettings(): StoredProviderSettings {
+	return {
+		version: 1,
+		providers: {},
+	};
+}

package/src/types/sessions.ts

@@ -0,0 +1,16 @@
+import type {
+	SessionLineage,
+	SessionRuntimeRecordShape,
+} from "@clinebot/shared";
+import type { SessionSource, SessionStatus } from "./common";
+
+export interface SessionRef extends SessionLineage {
+	sessionId: string;
+}
+
+export interface SessionRecord
+	extends SessionRef,
+		Omit<SessionRuntimeRecordShape, "source" | "status"> {
+	source: SessionSource;
+	status: SessionStatus;
+}

package/src/types/storage.ts

@@ -0,0 +1,64 @@
+import type {
+	TeamEvent,
+	TeamRuntimeState,
+	TeamTeammateSpec,
+} from "@clinebot/agents";
+import type { SessionStatus } from "./common";
+import type { SessionRecord } from "./sessions";
+
+export interface SessionStore {
+	init(): Promise<void> | void;
+	create(record: SessionRecord): Promise<void> | void;
+	updateStatus(
+		sessionId: string,
+		status: SessionStatus,
+		exitCode?: number | null,
+	): Promise<void> | void;
+	update(
+		record: Partial<SessionRecord> & { sessionId: string },
+	): Promise<void> | void;
+	get(
+		sessionId: string,
+	): Promise<SessionRecord | undefined> | SessionRecord | undefined;
+	list(limit?: number): Promise<SessionRecord[]> | SessionRecord[];
+	delete(sessionId: string, cascade?: boolean): Promise<boolean> | boolean;
+}
+
+export interface TeamStore {
+	listTeamNames(): Promise<string[]> | string[];
+	readState(
+		teamName: string,
+	): Promise<TeamRuntimeState | undefined> | TeamRuntimeState | undefined;
+	readHistory(teamName: string, limit?: number): Promise<unknown[]> | unknown[];
+	loadRuntime(teamName: string):
+		| Promise<{
+				state?: TeamRuntimeState;
+				teammates: TeamTeammateSpec[];
+				interruptedRunIds: string[];
+		  }>
+		| {
+				state?: TeamRuntimeState;
+				teammates: TeamTeammateSpec[];
+				interruptedRunIds: string[];
+		  };
+	handleTeamEvent(teamName: string, event: TeamEvent): Promise<void> | void;
+	persistRuntime(
+		teamName: string,
+		state: TeamRuntimeState,
+		teammates: TeamTeammateSpec[],
+	): Promise<void> | void;
+	markInProgressRunsInterrupted(
+		teamName: string,
+		reason: string,
+	): Promise<string[]> | string[];
+}
+
+export interface ArtifactStore {
+	appendTranscript(sessionId: string, text: string): Promise<void> | void;
+	appendHook(sessionId: string, payload: unknown): Promise<void> | void;
+	writeMessages(sessionId: string, messages: unknown[]): Promise<void> | void;
+	readTranscript(
+		sessionId: string,
+		maxChars?: number,
+	): Promise<string> | string;
+}

package/src/types/workspace.ts

@@ -0,0 +1,7 @@
+export interface WorkspaceInfo {
+	rootPath: string;
+	hint?: string;
+	associatedRemoteUrls?: string[];
+	latestGitCommitHash?: string;
+	latestGitBranchName?: string;
+}

package/src/types.ts

@@ -0,0 +1,127 @@
+import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { CoreSessionEvent } from "./types/events";
+
+export type {
+	AgentConfigWatcher,
+	AgentConfigWatcherEvent,
+	AgentYamlConfig,
+	BuildAgentConfigOverridesOptions,
+	CreateAgentConfigWatcherOptions,
+	CreateInstructionWatcherOptions,
+	CreateRulesConfigDefinitionOptions,
+	CreateSkillsConfigDefinitionOptions,
+	CreateUserInstructionConfigWatcherOptions,
+	CreateWorkflowsConfigDefinitionOptions,
+	LoadAgentPluginFromPathOptions,
+	ParseMarkdownFrontmatterResult,
+	ParseYamlFrontmatterResult,
+	ResolveAgentPluginPathsOptions,
+	RuleConfig,
+	SkillConfig,
+	UnifiedConfigDefinition,
+	UnifiedConfigFileCandidate,
+	UnifiedConfigFileContext,
+	UnifiedConfigRecord,
+	UnifiedConfigWatcherEvent,
+	UnifiedConfigWatcherOptions,
+	UserInstructionConfig,
+	UserInstructionConfigType,
+	UserInstructionConfigWatcher,
+	UserInstructionConfigWatcherEvent,
+	WorkflowConfig,
+} from "./agents";
+export {
+	createAgentConfigDefinition,
+	createAgentConfigWatcher,
+	createRulesConfigDefinition,
+	createSkillsConfigDefinition,
+	createUserInstructionConfigWatcher,
+	createWorkflowsConfigDefinition,
+	discoverPluginModulePaths,
+	loadAgentPluginFromPath,
+	loadAgentPluginsFromPaths,
+	parseAgentConfigFromYaml,
+	parsePartialAgentConfigFromYaml,
+	parseRuleConfigFromMarkdown,
+	parseSkillConfigFromMarkdown,
+	parseWorkflowConfigFromMarkdown,
+	RULES_CONFIG_DIRECTORY_NAME,
+	resolveAgentPluginPaths,
+	resolveAgentTools,
+	resolveAndLoadAgentPlugins,
+	resolveDocumentsRulesDirectoryPath,
+	resolveDocumentsWorkflowsDirectoryPath,
+	resolvePluginConfigSearchPaths,
+	resolveRulesConfigSearchPaths,
+	resolveSkillsConfigSearchPaths,
+	resolveWorkflowsConfigSearchPaths,
+	SKILLS_CONFIG_DIRECTORY_NAME,
+	toPartialAgentConfig,
+	UnifiedConfigFileWatcher,
+	WORKFLOWS_CONFIG_DIRECTORY_NAME,
+} from "./agents";
+export type {
+	ChatMessage,
+	ChatSessionConfig,
+	ChatSessionStatus,
+	ChatSummary,
+	ChatViewState,
+} from "./chat/chat-schema";
+export type {
+	SandboxCallOptions,
+	SubprocessSandboxOptions,
+} from "./runtime/sandbox/subprocess-sandbox";
+export { SubprocessSandbox } from "./runtime/sandbox/subprocess-sandbox";
+export type {
+	BuiltRuntime as RuntimeEnvironment,
+	RuntimeBuilder,
+	RuntimeBuilderInput,
+	SessionRuntime,
+} from "./runtime/session-runtime";
+export type {
+	CreateSessionHostOptions,
+	SessionHost,
+} from "./session/session-host";
+export type {
+	SendSessionInput,
+	SessionManager,
+	StartSessionInput,
+	StartSessionResult,
+} from "./session/session-manager";
+export type { SessionManifest } from "./session/session-manifest";
+export type {
+	CreateRootSessionWithArtifactsInput,
+	RootSessionArtifacts,
+} from "./session/session-service";
+export type {
+	WorkspaceManager,
+	WorkspaceManagerEvent,
+} from "./session/workspace-manager";
+export type { WorkspaceManifest } from "./session/workspace-manifest";
+export type { SessionSource, SessionStatus } from "./types/common";
+export type {
+	CoreAgentMode,
+	CoreModelConfig,
+	CoreRuntimeFeatures,
+	CoreSessionConfig,
+} from "./types/config";
+export type {
+	CoreSessionEvent,
+	SessionChunkEvent,
+	SessionEndedEvent,
+	SessionTeamProgressEvent,
+	SessionToolEvent,
+} from "./types/events";
+export type { SessionRecord, SessionRef } from "./types/sessions";
+export type { ArtifactStore, SessionStore, TeamStore } from "./types/storage";
+export type { WorkspaceInfo } from "./types/workspace";
+
+// Backward-compat alias used by CLI persistence.
+export interface StoredMessages {
+	version: 1;
+	updatedAt: string;
+	messages: LlmsProviders.MessageWithMetadata[];
+}
+
+// Backward-compat alias with previous event naming.
+export type SessionEvent = CoreSessionEvent;