@clinebot/core 0.0.28 → 0.0.29

package/src/extensions/context/agentic-compaction.ts

@@ -0,0 +1,119 @@
+import type * as LlmsProviders from "@clinebot/llms";
+import { createHandler } from "@clinebot/llms";
+import type { BasicLogger } from "@clinebot/shared";
+import type {
+	CoreCompactionContext,
+	CoreCompactionResult,
+	CoreCompactionSummarizerConfig,
+} from "../../types/config";
+import {
+	buildSummaryMessage,
+	buildSummaryRequest,
+	type EstimateMessageTokens,
+	ensureFilesSection,
+	extractFileOps,
+	findCutIndex,
+	findLatestSummaryIndex,
+	getCompactionSummaryMetadata,
+	resolveSummarizerConfig,
+	serializeConversation,
+} from "./compaction-shared";
+
+async function generateSummary(options: {
+	providerConfig: LlmsProviders.ProviderConfig;
+	request: string;
+	logger?: BasicLogger;
+}): Promise<string> {
+	const handler = createHandler(options.providerConfig);
+	let text = "";
+	for await (const chunk of handler.createMessage(
+		"Summarize the provided coding session into a concise continuation note with detailed next steps.",
+		[{ role: "user", content: options.request }],
+	)) {
+		if (chunk.type === "text") {
+			text += chunk.text;
+			continue;
+		}
+		if (chunk.type === "done" && !chunk.success && chunk.error) {
+			throw new Error(chunk.error);
+		}
+	}
+	options.logger?.debug("Generated compaction summary", {
+		outputChars: text.length,
+		modelId: options.providerConfig.modelId,
+		providerId: options.providerConfig.providerId,
+	});
+	return text.trim();
+}
+
+export async function runAgenticCompaction(options: {
+	context: CoreCompactionContext;
+	providerConfig: LlmsProviders.ProviderConfig;
+	summarizer?: CoreCompactionSummarizerConfig;
+	preserveRecentTokens: number;
+	estimateMessageTokens: EstimateMessageTokens;
+	logger?: BasicLogger;
+}): Promise<CoreCompactionResult | undefined> {
+	const messages = options.context.messages;
+	if (messages.length < 2) {
+		return undefined;
+	}
+
+	const cutIndex = findCutIndex(
+		messages,
+		options.preserveRecentTokens,
+		options.estimateMessageTokens,
+	);
+	if (cutIndex <= 0 || cutIndex >= messages.length) {
+		return undefined;
+	}
+
+	const messagesToSummarize = messages.slice(0, cutIndex);
+	const latestSummaryIndex = findLatestSummaryIndex(messagesToSummarize);
+	const previousSummary =
+		latestSummaryIndex >= 0
+			? getCompactionSummaryMetadata(messagesToSummarize[latestSummaryIndex])
+					?.summary
+			: undefined;
+	const newMessagesToFold =
+		latestSummaryIndex >= 0
+			? messagesToSummarize.slice(latestSummaryIndex + 1)
+			: messagesToSummarize;
+	if (newMessagesToFold.length === 0) {
+		return undefined;
+	}
+
+	const fileOps = extractFileOps(messagesToSummarize);
+	const conversationText = serializeConversation(newMessagesToFold);
+	const rawSummary = await generateSummary({
+		providerConfig: resolveSummarizerConfig({
+			activeProviderConfig: options.providerConfig,
+			summarizer: options.summarizer,
+		}),
+		request: buildSummaryRequest({
+			previousSummary,
+			conversationText,
+			fileOps,
+		}),
+		logger: options.logger,
+	});
+	if (!rawSummary.trim()) {
+		return undefined;
+	}
+
+	const summary = ensureFilesSection(rawSummary, fileOps);
+	const tokensBefore = messages.reduce(
+		(total, message) => total + options.estimateMessageTokens(message),
+		0,
+	);
+	return {
+		messages: [
+			buildSummaryMessage({
+				summary,
+				fileOps,
+				tokensBefore,
+			}),
+			...messages.slice(cutIndex),
+		],
+	};
+}

package/src/extensions/context/basic-compaction.ts

@@ -0,0 +1,275 @@
+import type { BasicLogger, MessageWithMetadata } from "@clinebot/shared";
+import type {
+	CoreCompactionContext,
+	CoreCompactionResult,
+} from "../../types/config";
+import {
+	type EstimateMessageTokens,
+	findFirstUserMessageIndex,
+	findLastAssistantIndex,
+	findLastTurnStartIndex,
+	isCompactionSummaryMessage,
+	MIN_TRUNCATED_MESSAGE_TOKENS,
+	truncateText,
+} from "./compaction-shared";
+
+interface BasicCompactionCandidate {
+	index: number;
+	message: MessageWithMetadata;
+	estimatedTokens: number;
+	isFirstUser: boolean;
+	isLastUser: boolean;
+	isLastAssistant: boolean;
+}
+
+function sanitizeMessageForBasic(
+	message: MessageWithMetadata,
+): MessageWithMetadata | undefined {
+	if (isCompactionSummaryMessage(message)) {
+		return undefined;
+	}
+	if (typeof message.content === "string") {
+		const text = message.content.trim();
+		return text ? { ...message, content: text } : undefined;
+	}
+
+	const textParts: string[] = [];
+	for (const block of message.content) {
+		if (block.type === "text") {
+			const text = block.text.trim();
+			if (text) {
+				textParts.push(text);
+			}
+		}
+	}
+	const text = textParts.join("\n\n").trim();
+	return text ? { ...message, content: text } : undefined;
+}
+
+function getTotalTokens(
+	messages: MessageWithMetadata[],
+	estimateMessageTokens: EstimateMessageTokens,
+): number {
+	return messages.reduce(
+		(total, message) => total + estimateMessageTokens(message),
+		0,
+	);
+}
+
+function truncateMessageToTokens(
+	message: MessageWithMetadata,
+	maxTokens: number,
+): MessageWithMetadata {
+	const content = typeof message.content === "string" ? message.content : "";
+	const safeMaxTokens = Math.max(1, maxTokens);
+	const targetChars = Math.max(16, safeMaxTokens * 4);
+	const truncated = truncateText(content, targetChars).trim();
+	return {
+		...message,
+		content: truncated || "...",
+	};
+}
+
+function buildBasicCandidates(
+	messages: MessageWithMetadata[],
+	estimateMessageTokens: EstimateMessageTokens,
+): BasicCompactionCandidate[] {
+	const firstUserIndex = findFirstUserMessageIndex(messages);
+	const lastUserIndex = findLastTurnStartIndex(messages);
+	const lastAssistantIndex = findLastAssistantIndex(messages);
+	const candidates: BasicCompactionCandidate[] = [];
+	for (let index = 0; index < messages.length; index += 1) {
+		const sanitized = sanitizeMessageForBasic(messages[index]);
+		if (!sanitized) {
+			continue;
+		}
+		candidates.push({
+			index,
+			message: sanitized,
+			estimatedTokens: estimateMessageTokens(sanitized),
+			isFirstUser: index === firstUserIndex,
+			isLastUser: index === lastUserIndex,
+			isLastAssistant: index === lastAssistantIndex,
+		});
+	}
+	return candidates;
+}
+
+function updateCandidate(
+	candidates: BasicCompactionCandidate[],
+	index: number,
+	message: MessageWithMetadata,
+	estimateMessageTokens: EstimateMessageTokens,
+): void {
+	const candidate = candidates[index];
+	candidate.message = message;
+	candidate.estimatedTokens = estimateMessageTokens(message);
+}
+
+function removeCandidatesByPredicate(
+	candidates: BasicCompactionCandidate[],
+	predicate: (candidate: BasicCompactionCandidate) => boolean,
+	targetTokens: number,
+	estimateMessageTokens: EstimateMessageTokens,
+): void {
+	let totalTokens = getTotalTokens(
+		candidates.map((candidate) => candidate.message),
+		estimateMessageTokens,
+	);
+	for (
+		let index = 0;
+		index < candidates.length && totalTokens > targetTokens;
+	) {
+		if (!predicate(candidates[index])) {
+			index += 1;
+			continue;
+		}
+		totalTokens -= candidates[index].estimatedTokens;
+		candidates.splice(index, 1);
+	}
+}
+
+function trimCandidatesToBudget(
+	candidates: BasicCompactionCandidate[],
+	targetTokens: number,
+	estimateMessageTokens: EstimateMessageTokens,
+): void {
+	let totalTokens = getTotalTokens(
+		candidates.map((candidate) => candidate.message),
+		estimateMessageTokens,
+	);
+	if (totalTokens <= targetTokens) {
+		return;
+	}
+
+	for (
+		let index = candidates.length - 1;
+		index >= 0 && totalTokens > targetTokens;
+		index -= 1
+	) {
+		const candidate = candidates[index];
+		if (candidate.isFirstUser) {
+			continue;
+		}
+		const desiredTokens = Math.max(
+			MIN_TRUNCATED_MESSAGE_TOKENS,
+			candidate.estimatedTokens - (totalTokens - targetTokens),
+		);
+		if (desiredTokens >= candidate.estimatedTokens) {
+			continue;
+		}
+		updateCandidate(
+			candidates,
+			index,
+			truncateMessageToTokens(candidate.message, desiredTokens),
+			estimateMessageTokens,
+		);
+		totalTokens = getTotalTokens(
+			candidates.map((item) => item.message),
+			estimateMessageTokens,
+		);
+	}
+
+	if (totalTokens <= targetTokens) {
+		return;
+	}
+
+	const firstUserIndex = candidates.findIndex(
+		(candidate) => candidate.isFirstUser,
+	);
+	if (firstUserIndex >= 0) {
+		const desiredTokens = Math.max(
+			1,
+			candidates[firstUserIndex].estimatedTokens - (totalTokens - targetTokens),
+		);
+		updateCandidate(
+			candidates,
+			firstUserIndex,
+			truncateMessageToTokens(
+				candidates[firstUserIndex].message,
+				desiredTokens,
+			),
+			estimateMessageTokens,
+		);
+	}
+}
+
+function haveMessagesChanged(
+	original: MessageWithMetadata[],
+	next: MessageWithMetadata[],
+): boolean {
+	return JSON.stringify(original) !== JSON.stringify(next);
+}
+
+export function runBasicCompaction(options: {
+	context: CoreCompactionContext;
+	estimateMessageTokens: EstimateMessageTokens;
+	logger?: BasicLogger;
+}): CoreCompactionResult | undefined {
+	const targetTokens = Math.max(
+		1,
+		Math.min(
+			options.context.triggerTokens,
+			options.context.contextWindowTokens,
+		),
+	);
+	const candidates = buildBasicCandidates(
+		options.context.messages,
+		options.estimateMessageTokens,
+	);
+	if (candidates.length === 0) {
+		return undefined;
+	}
+
+	removeCandidatesByPredicate(
+		candidates,
+		(candidate) =>
+			candidate.message.role === "assistant" && !candidate.isLastAssistant,
+		targetTokens,
+		options.estimateMessageTokens,
+	);
+	removeCandidatesByPredicate(
+		candidates,
+		(candidate) =>
+			candidate.message.role === "user" &&
+			!candidate.isFirstUser &&
+			!candidate.isLastUser,
+		targetTokens,
+		options.estimateMessageTokens,
+	);
+	removeCandidatesByPredicate(
+		candidates,
+		(candidate) =>
+			candidate.message.role === "assistant" && candidate.isLastAssistant,
+		targetTokens,
+		options.estimateMessageTokens,
+	);
+	removeCandidatesByPredicate(
+		candidates,
+		(candidate) =>
+			candidate.message.role === "user" &&
+			candidate.isLastUser &&
+			!candidate.isFirstUser,
+		targetTokens,
+		options.estimateMessageTokens,
+	);
+
+	trimCandidatesToBudget(
+		candidates,
+		targetTokens,
+		options.estimateMessageTokens,
+	);
+
+	const nextMessages = candidates.map((candidate) => candidate.message);
+	if (!haveMessagesChanged(options.context.messages, nextMessages)) {
+		return undefined;
+	}
+
+	options.logger?.debug("Performed basic compaction", {
+		beforeCount: options.context.messages.length,
+		afterCount: nextMessages.length,
+		targetTokens,
+	});
+
+	return { messages: nextMessages };
+}