@clinebot/core 0.0.18 → 0.0.21

package/src/session/utils/helpers.ts

@@ -1,139 +0,0 @@
-import type { AgentConfig, AgentEvent, AgentResult } from "@clinebot/agents";
-import type { LlmsProviders } from "@clinebot/llms";
-import type { SessionSource } from "../../types/common";
-import type { SessionRecord } from "../../types/sessions";
-import type { SessionRow } from "../session-service";
-import type { StoredMessageWithMetadata } from "./types";
-
-const WORKSPACE_CONFIGURATION_MARKER = "# Workspace Configuration";
-
-export function extractWorkspaceMetadataFromSystemPrompt(
-	systemPrompt: string,
-): string | undefined {
-	const markerIndex = systemPrompt.lastIndexOf(WORKSPACE_CONFIGURATION_MARKER);
-	if (markerIndex < 0) {
-		return undefined;
-	}
-	const metadata = systemPrompt.slice(markerIndex).trim();
-	return metadata.length > 0 ? metadata : undefined;
-}
-
-export function hasRuntimeHooks(hooks: AgentConfig["hooks"]): boolean {
-	if (!hooks) {
-		return false;
-	}
-	return Object.values(hooks).some((value) => typeof value === "function");
-}
-
-export function mergeAgentExtensions(
-	explicitExtensions: AgentConfig["extensions"] | undefined,
-	loadedExtensions: AgentConfig["extensions"] | undefined,
-): AgentConfig["extensions"] {
-	const merged = [...(explicitExtensions ?? []), ...(loadedExtensions ?? [])];
-	if (merged.length === 0) {
-		return undefined;
-	}
-	const deduped: NonNullable<AgentConfig["extensions"]> = [];
-	const seenNames = new Set<string>();
-	for (const extension of merged) {
-		if (seenNames.has(extension.name)) {
-			continue;
-		}
-		seenNames.add(extension.name);
-		deduped.push(extension);
-	}
-	return deduped;
-}
-
-export function serializeAgentEvent(event: AgentEvent): string {
-	return JSON.stringify(event, (_key, value) => {
-		if (value instanceof Error) {
-			return {
-				name: value.name,
-				message: value.message,
-				stack: value.stack,
-			};
-		}
-		return value;
-	});
-}
-
-export function withLatestAssistantTurnMetadata(
-	messages: LlmsProviders.Message[],
-	result: AgentResult,
-	previousMessages: LlmsProviders.MessageWithMetadata[] = [],
-): StoredMessageWithMetadata[] {
-	const next = messages.map((message, index) => {
-		const previous = previousMessages[index];
-		const sameMessage =
-			previous?.role === message.role &&
-			JSON.stringify(previous.content) === JSON.stringify(message.content);
-		return sameMessage
-			? ({
-					...previous,
-					...message,
-				} as StoredMessageWithMetadata)
-			: ({ ...message } as StoredMessageWithMetadata);
-	});
-	const assistantIndex = [...next]
-		.reverse()
-		.findIndex((message) => message.role === "assistant");
-	if (assistantIndex === -1) {
-		return next;
-	}
-
-	const targetIndex = next.length - 1 - assistantIndex;
-	const target = next[targetIndex];
-	const usage = result.usage;
-	next[targetIndex] = {
-		...target,
-		providerId: target.providerId ?? result.model.provider,
-		modelId: target.modelId ?? result.model.id,
-		modelInfo: target.modelInfo ?? {
-			id: result.model.id,
-			provider: result.model.provider,
-		},
-		metrics: {
-			...(target.metrics ?? {}),
-			inputTokens: usage.inputTokens,
-			outputTokens: usage.outputTokens,
-			cacheReadTokens: usage.cacheReadTokens,
-			cacheWriteTokens: usage.cacheWriteTokens,
-			cost: usage.totalCost,
-		},
-		ts: target.ts ?? result.endedAt.getTime(),
-	};
-	return next;
-}
-
-export function toSessionRecord(row: SessionRow): SessionRecord {
-	return {
-		sessionId: row.sessionId,
-		source: row.source as SessionSource,
-		pid: row.pid,
-		startedAt: row.startedAt,
-		endedAt: row.endedAt ?? null,
-		exitCode: row.exitCode ?? null,
-		status: row.status,
-		interactive: row.interactive,
-		provider: row.provider,
-		model: row.model,
-		cwd: row.cwd,
-		workspaceRoot: row.workspaceRoot,
-		teamName: row.teamName ?? undefined,
-		enableTools: row.enableTools,
-		enableSpawn: row.enableSpawn,
-		enableTeams: row.enableTeams,
-		parentSessionId: row.parentSessionId ?? undefined,
-		parentAgentId: row.parentAgentId ?? undefined,
-		agentId: row.agentId ?? undefined,
-		conversationId: row.conversationId ?? undefined,
-		isSubagent: row.isSubagent,
-		prompt: row.prompt ?? undefined,
-		metadata: row.metadata ?? undefined,
-		transcriptPath: row.transcriptPath,
-		hookPath: row.hookPath,
-		messagesPath: row.messagesPath ?? undefined,
-		updatedAt: row.updatedAt,
-	};
-}

package/src/session/utils/types.ts

@@ -1,57 +0,0 @@
-import type { Agent } from "@clinebot/agents";
-import type { LlmsProviders } from "@clinebot/llms";
-import type { BuiltRuntime } from "../../runtime/session-runtime";
-import type { SessionSource } from "../../types/common";
-import type { CoreSessionConfig } from "../../types/config";
-import type { SessionAccumulatedUsage } from "../session-manager";
-import type { RootSessionArtifacts } from "../session-service";
-
-export type ActiveSession = {
-	sessionId: string;
-	config: CoreSessionConfig;
-	artifacts?: RootSessionArtifacts;
-	source: SessionSource;
-	startedAt: string;
-	pendingPrompt?: string;
-	runtime: BuiltRuntime;
-	agent: Agent;
-	started: boolean;
-	aborting: boolean;
-	interactive: boolean;
-	persistedMessages?: LlmsProviders.MessageWithMetadata[];
-	activeTeamRunIds: Set<string>;
-	pendingTeamRunUpdates: TeamRunUpdate[];
-	teamRunWaiters: Array<() => void>;
-	pendingPrompts: PendingPrompt[];
-	drainingPendingPrompts: boolean;
-	pluginSandboxShutdown?: () => Promise<void>;
-	turnUsageBaseline?: SessionAccumulatedUsage;
-};
-
-export type PendingPrompt = {
-	id: string;
-	prompt: string;
-	delivery: "queue" | "steer";
-	userImages?: string[];
-	userFiles?: string[];
-};
-
-export type TeamRunUpdate = {
-	runId: string;
-	agentId: string;
-	taskId?: string;
-	status: "completed" | "failed" | "cancelled" | "interrupted";
-	error?: string;
-	iterations?: number;
-};
-
-export type StoredMessageWithMetadata = LlmsProviders.MessageWithMetadata & {
-	providerId?: string;
-	modelId?: string;
-};
-
-export type PreparedTurnInput = {
-	prompt: string;
-	userImages?: string[];
-	userFiles?: string[];
-};

package/src/session/utils/usage.ts

@@ -1,32 +0,0 @@
-import type { SessionAccumulatedUsage } from "../session-manager";
-
-export function createInitialAccumulatedUsage(): SessionAccumulatedUsage {
-	return {
-		inputTokens: 0,
-		outputTokens: 0,
-		cacheReadTokens: 0,
-		cacheWriteTokens: 0,
-		totalCost: 0,
-	};
-}
-
-export function accumulateUsageTotals(
-	baseline: SessionAccumulatedUsage,
-	usage: {
-		inputTokens?: number;
-		outputTokens?: number;
-		cacheReadTokens?: number;
-		cacheWriteTokens?: number;
-		totalCost?: number;
-	},
-): SessionAccumulatedUsage {
-	return {
-		inputTokens: baseline.inputTokens + Math.max(0, usage.inputTokens ?? 0),
-		outputTokens: baseline.outputTokens + Math.max(0, usage.outputTokens ?? 0),
-		cacheReadTokens:
-			baseline.cacheReadTokens + Math.max(0, usage.cacheReadTokens ?? 0),
-		cacheWriteTokens:
-			baseline.cacheWriteTokens + Math.max(0, usage.cacheWriteTokens ?? 0),
-		totalCost: baseline.totalCost + Math.max(0, usage.totalCost ?? 0),
-	};
-}

package/src/session/workspace-manager.ts

@@ -1,98 +0,0 @@
-import type { WorkspaceInfo } from "../types/workspace";
-import {
-	generateWorkspaceInfo,
-	normalizeWorkspacePath,
-	upsertWorkspaceInfo,
-	type WorkspaceManifest,
-	WorkspaceManifestSchema,
-} from "./workspace-manifest";
-
-export interface WorkspaceManagerEvent {
-	type: "workspace_added" | "workspace_switched";
-	workspace: WorkspaceInfo;
-}
-
-export interface WorkspaceManager {
-	addWorkspacePath(workspacePath: string): Promise<WorkspaceInfo>;
-	switchWorkspace(workspacePath: string): Promise<WorkspaceInfo>;
-	subscribe(listener: (event: WorkspaceManagerEvent) => void): () => void;
-	getCurrentWorkspace(): WorkspaceInfo | undefined;
-	getWorkspace(workspacePath: string): WorkspaceInfo | undefined;
-	listWorkspaces(): WorkspaceInfo[];
-	getManifest(): WorkspaceManifest;
-}
-
-export class InMemoryWorkspaceManager implements WorkspaceManager {
-	private manifest: WorkspaceManifest;
-	private readonly listeners = new Set<
-		(event: WorkspaceManagerEvent) => void
-	>();
-
-	constructor(manifest?: WorkspaceManifest) {
-		this.manifest = WorkspaceManifestSchema.parse(
-			manifest ?? { workspaces: {} },
-		);
-	}
-
-	async addWorkspacePath(workspacePath: string): Promise<WorkspaceInfo> {
-		const info = await generateWorkspaceInfo(workspacePath);
-		this.manifest = upsertWorkspaceInfo(this.manifest, info);
-		this.emit({ type: "workspace_added", workspace: info });
-		return info;
-	}
-
-	async switchWorkspace(workspacePath: string): Promise<WorkspaceInfo> {
-		const normalizedPath = normalizeWorkspacePath(workspacePath);
-		const existing = this.manifest.workspaces[normalizedPath];
-		if (existing) {
-			this.manifest = WorkspaceManifestSchema.parse({
-				...this.manifest,
-				currentWorkspacePath: normalizedPath,
-			});
-			this.emit({ type: "workspace_switched", workspace: existing });
-			return existing;
-		}
-
-		const added = await this.addWorkspacePath(normalizedPath);
-		this.manifest = WorkspaceManifestSchema.parse({
-			...this.manifest,
-			currentWorkspacePath: added.rootPath,
-		});
-		this.emit({ type: "workspace_switched", workspace: added });
-		return added;
-	}
-
-	subscribe(listener: (event: WorkspaceManagerEvent) => void): () => void {
-		this.listeners.add(listener);
-		return () => {
-			this.listeners.delete(listener);
-		};
-	}
-
-	getCurrentWorkspace(): WorkspaceInfo | undefined {
-		const currentPath = this.manifest.currentWorkspacePath;
-		if (!currentPath) {
-			return undefined;
-		}
-		return this.manifest.workspaces[currentPath];
-	}
-
-	getWorkspace(workspacePath: string): WorkspaceInfo | undefined {
-		const normalizedPath = normalizeWorkspacePath(workspacePath);
-		return this.manifest.workspaces[normalizedPath];
-	}
-
-	listWorkspaces(): WorkspaceInfo[] {
-		return Object.values(this.manifest.workspaces);
-	}
-
-	getManifest(): WorkspaceManifest {
-		return this.manifest;
-	}
-
-	private emit(event: WorkspaceManagerEvent): void {
-		for (const listener of this.listeners) {
-			listener(event);
-		}
-	}
-}

package/src/session/workspace-manifest.ts

@@ -1,100 +0,0 @@
-import { basename, resolve } from "node:path";
-import simpleGit from "simple-git";
-import { z } from "zod";
-import type { WorkspaceInfo } from "../types/workspace";
-
-export const WorkspaceInfoSchema = z.object({
-	rootPath: z.string().min(1),
-	hint: z.string().min(1).optional(),
-	associatedRemoteUrls: z.array(z.string().min(1)).optional(),
-	latestGitCommitHash: z.string().min(1).optional(),
-	latestGitBranchName: z.string().min(1).optional(),
-});
-
-export const WorkspaceManifestSchema = z.object({
-	currentWorkspacePath: z.string().min(1).optional(),
-	workspaces: z.record(z.string().min(1), WorkspaceInfoSchema),
-});
-
-export type WorkspaceManifest = z.infer<typeof WorkspaceManifestSchema>;
-
-export function emptyWorkspaceManifest(): WorkspaceManifest {
-	return { workspaces: {} };
-}
-
-export function normalizeWorkspacePath(workspacePath: string): string {
-	return resolve(workspacePath);
-}
-
-export async function generateWorkspaceInfo(
-	workspacePath: string,
-): Promise<WorkspaceInfo> {
-	const rootPath = normalizeWorkspacePath(workspacePath);
-	const info: WorkspaceInfo = {
-		rootPath,
-		hint: basename(rootPath),
-	};
-
-	try {
-		const git = simpleGit({ baseDir: rootPath });
-		const isRepo = await git.checkIsRepo();
-		if (!isRepo) {
-			return info;
-		}
-
-		const remotes = await git.getRemotes(true);
-		if (remotes.length > 0) {
-			const associatedRemoteUrls = remotes.map((remote) => {
-				const remoteUrl = remote.refs.fetch || remote.refs.push;
-				return `${remote.name}: ${remoteUrl}`;
-			});
-			info.associatedRemoteUrls = associatedRemoteUrls;
-		}
-
-		const latestGitCommitHash = (await git.revparse(["HEAD"])).trim();
-		if (latestGitCommitHash.length > 0) {
-			info.latestGitCommitHash = latestGitCommitHash;
-		}
-
-		const latestGitBranchName = (await git.branch()).current.trim();
-		if (latestGitBranchName.length > 0) {
-			info.latestGitBranchName = latestGitBranchName;
-		}
-	} catch {
-		// Non-git workspaces keep only path + hint.
-	}
-
-	return info;
-}
-
-export function upsertWorkspaceInfo(
-	manifest: WorkspaceManifest,
-	info: WorkspaceInfo,
-): WorkspaceManifest {
-	const nextManifest: WorkspaceManifest = {
-		...manifest,
-		workspaces: {
-			...manifest.workspaces,
-			[info.rootPath]: info,
-		},
-	};
-	if (!nextManifest.currentWorkspacePath) {
-		nextManifest.currentWorkspacePath = info.rootPath;
-	}
-	return WorkspaceManifestSchema.parse(nextManifest);
-}
-
-export async function buildWorkspaceMetadata(cwd: string): Promise<string> {
-	const workspaceInfo = await generateWorkspaceInfo(cwd);
-	const workspaceConfig = {
-		workspaces: {
-			[workspaceInfo.rootPath]: {
-				hint: workspaceInfo.hint,
-				associatedRemoteUrls: workspaceInfo.associatedRemoteUrls,
-				latestGitCommitHash: workspaceInfo.latestGitCommitHash,
-				latestGitBranchName: workspaceInfo.latestGitBranchName,
-			},
-		},
-	};
-	return `# Workspace Configuration\n${JSON.stringify(workspaceConfig, null, 2)}`;
-}

package/src/storage/artifact-store.ts

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

package/src/storage/file-team-store.ts

@@ -1,257 +0,0 @@
-import {
-	appendFileSync,
-	existsSync,
-	mkdirSync,
-	readdirSync,
-	readFileSync,
-	renameSync,
-	writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-import type {
-	TeamEvent,
-	TeamRuntimeState,
-	TeamTeammateSpec,
-} from "@clinebot/agents";
-import { resolveTeamDataDir } from "@clinebot/shared/storage";
-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);
-		const interruptedRunIds = this.markInProgressRunsInterrupted(
-			teamName,
-			"runtime_recovered",
-		);
-		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;
-	}
-}

package/src/storage/index.ts

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