@tarquinen/opencode-dcp 3.1.11 → 3.1.13

package/lib/compress/state.ts

@@ -0,0 +1,268 @@
+import type { CompressionBlock, PruneMessagesState, SessionState } from "../state"
+import { formatBlockRef, formatMessageIdTag } from "../message-ids"
+import type { AppliedCompressionResult, CompressionStateInput, SelectionResolution } from "./types"
+
+export const COMPRESSED_BLOCK_HEADER = "[Compressed conversation section]"
+
+export function allocateBlockId(state: SessionState): number {
+    const next = state.prune.messages.nextBlockId
+    if (!Number.isInteger(next) || next < 1) {
+        state.prune.messages.nextBlockId = 2
+        return 1
+    }
+
+    state.prune.messages.nextBlockId = next + 1
+    return next
+}
+
+export function allocateRunId(state: SessionState): number {
+    const next = state.prune.messages.nextRunId
+    if (!Number.isInteger(next) || next < 1) {
+        state.prune.messages.nextRunId = 2
+        return 1
+    }
+
+    state.prune.messages.nextRunId = next + 1
+    return next
+}
+
+export function attachCompressionDuration(
+    messagesState: PruneMessagesState,
+    messageId: string,
+    callId: string,
+    durationMs: number,
+): number {
+    if (typeof durationMs !== "number" || !Number.isFinite(durationMs)) {
+        return 0
+    }
+
+    let updates = 0
+    for (const block of messagesState.blocksById.values()) {
+        if (block.compressMessageId !== messageId || block.compressCallId !== callId) {
+            continue
+        }
+
+        block.durationMs = durationMs
+        updates++
+    }
+
+    return updates
+}
+
+export function wrapCompressedSummary(blockId: number, summary: string): string {
+    const header = COMPRESSED_BLOCK_HEADER
+    const footer = formatMessageIdTag(formatBlockRef(blockId))
+    const body = summary.trim()
+    if (body.length === 0) {
+        return `${header}\n${footer}`
+    }
+    return `${header}\n${body}\n\n${footer}`
+}
+
+export function applyCompressionState(
+    state: SessionState,
+    input: CompressionStateInput,
+    selection: SelectionResolution,
+    anchorMessageId: string,
+    blockId: number,
+    summary: string,
+    consumedBlockIds: number[],
+): AppliedCompressionResult {
+    const messagesState = state.prune.messages
+    const consumed = [...new Set(consumedBlockIds.filter((id) => Number.isInteger(id) && id > 0))]
+    const included = [...consumed]
+
+    const effectiveMessageIds = new Set<string>(selection.messageIds)
+    const effectiveToolIds = new Set<string>(selection.toolIds)
+
+    for (const consumedBlockId of consumed) {
+        const consumedBlock = messagesState.blocksById.get(consumedBlockId)
+        if (!consumedBlock) {
+            continue
+        }
+        for (const messageId of consumedBlock.effectiveMessageIds) {
+            effectiveMessageIds.add(messageId)
+        }
+        for (const toolId of consumedBlock.effectiveToolIds) {
+            effectiveToolIds.add(toolId)
+        }
+    }
+
+    const initiallyActiveMessages = new Set<string>()
+    for (const messageId of effectiveMessageIds) {
+        const entry = messagesState.byMessageId.get(messageId)
+        if (entry && entry.activeBlockIds.length > 0) {
+            initiallyActiveMessages.add(messageId)
+        }
+    }
+
+    const initiallyActiveToolIds = new Set<string>()
+    for (const activeBlockId of messagesState.activeBlockIds) {
+        const activeBlock = messagesState.blocksById.get(activeBlockId)
+        if (!activeBlock || !activeBlock.active) {
+            continue
+        }
+
+        for (const toolId of activeBlock.effectiveToolIds) {
+            initiallyActiveToolIds.add(toolId)
+        }
+    }
+
+    const createdAt = Date.now()
+    const block: CompressionBlock = {
+        blockId,
+        runId: input.runId,
+        active: true,
+        deactivatedByUser: false,
+        compressedTokens: 0,
+        summaryTokens: input.summaryTokens,
+        durationMs: 0,
+        mode: input.mode,
+        topic: input.topic,
+        batchTopic: input.batchTopic,
+        startId: input.startId,
+        endId: input.endId,
+        anchorMessageId,
+        compressMessageId: input.compressMessageId,
+        compressCallId: input.compressCallId,
+        includedBlockIds: included,
+        consumedBlockIds: consumed,
+        parentBlockIds: [],
+        directMessageIds: [],
+        directToolIds: [],
+        effectiveMessageIds: [...effectiveMessageIds],
+        effectiveToolIds: [...effectiveToolIds],
+        createdAt,
+        summary,
+    }
+
+    messagesState.blocksById.set(blockId, block)
+    messagesState.activeBlockIds.add(blockId)
+    messagesState.activeByAnchorMessageId.set(anchorMessageId, blockId)
+
+    const deactivatedAt = Date.now()
+    for (const consumedBlockId of consumed) {
+        const consumedBlock = messagesState.blocksById.get(consumedBlockId)
+        if (!consumedBlock || !consumedBlock.active) {
+            continue
+        }
+
+        consumedBlock.active = false
+        consumedBlock.deactivatedAt = deactivatedAt
+        consumedBlock.deactivatedByBlockId = blockId
+        if (!consumedBlock.parentBlockIds.includes(blockId)) {
+            consumedBlock.parentBlockIds.push(blockId)
+        }
+
+        messagesState.activeBlockIds.delete(consumedBlockId)
+        const mappedBlockId = messagesState.activeByAnchorMessageId.get(
+            consumedBlock.anchorMessageId,
+        )
+        if (mappedBlockId === consumedBlockId) {
+            messagesState.activeByAnchorMessageId.delete(consumedBlock.anchorMessageId)
+        }
+    }
+
+    const removeActiveBlockId = (
+        entry: { activeBlockIds: number[] },
+        blockIdToRemove: number,
+    ): void => {
+        if (entry.activeBlockIds.length === 0) {
+            return
+        }
+        entry.activeBlockIds = entry.activeBlockIds.filter((id) => id !== blockIdToRemove)
+    }
+
+    for (const consumedBlockId of consumed) {
+        const consumedBlock = messagesState.blocksById.get(consumedBlockId)
+        if (!consumedBlock) {
+            continue
+        }
+        for (const messageId of consumedBlock.effectiveMessageIds) {
+            const entry = messagesState.byMessageId.get(messageId)
+            if (!entry) {
+                continue
+            }
+            removeActiveBlockId(entry, consumedBlockId)
+        }
+    }
+
+    for (const messageId of selection.messageIds) {
+        const tokenCount = selection.messageTokenById.get(messageId) || 0
+        const existing = messagesState.byMessageId.get(messageId)
+
+        if (!existing) {
+            messagesState.byMessageId.set(messageId, {
+                tokenCount,
+                allBlockIds: [blockId],
+                activeBlockIds: [blockId],
+            })
+            continue
+        }
+
+        existing.tokenCount = Math.max(existing.tokenCount, tokenCount)
+        if (!existing.allBlockIds.includes(blockId)) {
+            existing.allBlockIds.push(blockId)
+        }
+        if (!existing.activeBlockIds.includes(blockId)) {
+            existing.activeBlockIds.push(blockId)
+        }
+    }
+
+    for (const messageId of block.effectiveMessageIds) {
+        if (selection.messageTokenById.has(messageId)) {
+            continue
+        }
+
+        const existing = messagesState.byMessageId.get(messageId)
+        if (!existing) {
+            continue
+        }
+        if (!existing.allBlockIds.includes(blockId)) {
+            existing.allBlockIds.push(blockId)
+        }
+        if (!existing.activeBlockIds.includes(blockId)) {
+            existing.activeBlockIds.push(blockId)
+        }
+    }
+
+    let compressedTokens = 0
+    const newlyCompressedMessageIds: string[] = []
+    for (const messageId of effectiveMessageIds) {
+        const entry = messagesState.byMessageId.get(messageId)
+        if (!entry) {
+            continue
+        }
+
+        const isNowActive = entry.activeBlockIds.length > 0
+        const wasActive = initiallyActiveMessages.has(messageId)
+
+        if (isNowActive && !wasActive) {
+            compressedTokens += entry.tokenCount
+            newlyCompressedMessageIds.push(messageId)
+        }
+    }
+
+    const newlyCompressedToolIds: string[] = []
+    for (const toolId of effectiveToolIds) {
+        if (!initiallyActiveToolIds.has(toolId)) {
+            newlyCompressedToolIds.push(toolId)
+        }
+    }
+
+    block.directMessageIds = [...newlyCompressedMessageIds]
+    block.directToolIds = [...newlyCompressedToolIds]
+
+    block.compressedTokens = compressedTokens
+
+    state.stats.pruneTokenCounter += compressedTokens
+    state.stats.totalPruneTokens += state.stats.pruneTokenCounter
+    state.stats.pruneTokenCounter = 0
+
+    return {
+        compressedTokens,
+        messageIds: selection.messageIds,
+        newlyCompressedMessageIds,
+        newlyCompressedToolIds,
+    }
+}

package/lib/compress/timing.ts

@@ -0,0 +1,77 @@
+import type { SessionState } from "../state/types"
+import { attachCompressionDuration } from "./state"
+
+export interface PendingCompressionDuration {
+    messageId: string
+    callId: string
+    durationMs: number
+}
+
+export interface CompressionTimingState {
+    startsByCallId: Map<string, number>
+    pendingByCallId: Map<string, PendingCompressionDuration>
+}
+
+export function buildCompressionTimingKey(messageId: string, callId: string): string {
+    return `${messageId}:${callId}`
+}
+
+export function consumeCompressionStart(
+    state: SessionState,
+    messageId: string,
+    callId: string,
+): number | undefined {
+    const key = buildCompressionTimingKey(messageId, callId)
+    const start = state.compressionTiming.startsByCallId.get(key)
+    state.compressionTiming.startsByCallId.delete(key)
+    return start
+}
+
+export function resolveCompressionDuration(
+    startedAt: number | undefined,
+    eventTime: number | undefined,
+    partTime: { start?: unknown; end?: unknown } | undefined,
+): number | undefined {
+    const runningAt =
+        typeof partTime?.start === "number" && Number.isFinite(partTime.start)
+            ? partTime.start
+            : eventTime
+    const pendingToRunningMs =
+        typeof startedAt === "number" && typeof runningAt === "number"
+            ? Math.max(0, runningAt - startedAt)
+            : undefined
+
+    const toolStart = partTime?.start
+    const toolEnd = partTime?.end
+    const runtimeMs =
+        typeof toolStart === "number" &&
+        Number.isFinite(toolStart) &&
+        typeof toolEnd === "number" &&
+        Number.isFinite(toolEnd)
+            ? Math.max(0, toolEnd - toolStart)
+            : undefined
+
+    return typeof pendingToRunningMs === "number" ? pendingToRunningMs : runtimeMs
+}
+
+export function applyPendingCompressionDurations(state: SessionState): number {
+    if (state.compressionTiming.pendingByCallId.size === 0) {
+        return 0
+    }
+
+    let updates = 0
+    for (const [key, entry] of state.compressionTiming.pendingByCallId) {
+        const applied = attachCompressionDuration(
+            state.prune.messages,
+            entry.messageId,
+            entry.callId,
+            entry.durationMs,
+        )
+        if (applied > 0) {
+            updates += applied
+            state.compressionTiming.pendingByCallId.delete(key)
+        }
+    }
+
+    return updates
+}

package/lib/compress/types.ts

@@ -0,0 +1,108 @@
+import type { PluginConfig } from "../config"
+import type { Logger } from "../logger"
+import type { PromptStore } from "../prompts/store"
+import type { CompressionBlock, CompressionMode, SessionState, WithParts } from "../state"
+
+export interface ToolContext {
+    client: any
+    state: SessionState
+    logger: Logger
+    config: PluginConfig
+    prompts: PromptStore
+}
+
+export interface CompressRangeEntry {
+    startId: string
+    endId: string
+    summary: string
+}
+
+export interface CompressRangeToolArgs {
+    topic: string
+    content: CompressRangeEntry[]
+}
+
+export interface CompressMessageEntry {
+    messageId: string
+    topic: string
+    summary: string
+}
+
+export interface CompressMessageToolArgs {
+    topic: string
+    content: CompressMessageEntry[]
+}
+
+export interface BoundaryReference {
+    kind: "message" | "compressed-block"
+    rawIndex: number
+    messageId?: string
+    blockId?: number
+    anchorMessageId?: string
+}
+
+export interface SearchContext {
+    rawMessages: WithParts[]
+    rawMessagesById: Map<string, WithParts>
+    rawIndexById: Map<string, number>
+    summaryByBlockId: Map<number, CompressionBlock>
+}
+
+export interface SelectionResolution {
+    startReference: BoundaryReference
+    endReference: BoundaryReference
+    messageIds: string[]
+    messageTokenById: Map<string, number>
+    toolIds: string[]
+    requiredBlockIds: number[]
+}
+
+export interface ResolvedMessageCompression {
+    entry: CompressMessageEntry
+    selection: SelectionResolution
+    anchorMessageId: string
+}
+
+export interface ResolvedRangeCompression {
+    index: number
+    entry: CompressRangeEntry
+    selection: SelectionResolution
+    anchorMessageId: string
+}
+
+export interface ResolvedMessageCompressionsResult {
+    plans: ResolvedMessageCompression[]
+    skippedIssues: string[]
+    skippedCount: number
+}
+
+export interface ParsedBlockPlaceholder {
+    raw: string
+    blockId: number
+    startIndex: number
+    endIndex: number
+}
+
+export interface InjectedSummaryResult {
+    expandedSummary: string
+    consumedBlockIds: number[]
+}
+
+export interface AppliedCompressionResult {
+    compressedTokens: number
+    messageIds: string[]
+    newlyCompressedMessageIds: string[]
+    newlyCompressedToolIds: string[]
+}
+
+export interface CompressionStateInput {
+    topic: string
+    batchTopic: string
+    startId: string
+    endId: string
+    mode: CompressionMode
+    runId: number
+    compressMessageId: string
+    compressCallId?: string
+    summaryTokens: number
+}

package/lib/compress-permission.ts

@@ -0,0 +1,25 @@
+import type { PluginConfig } from "./config"
+import { type HostPermissionSnapshot, resolveEffectiveCompressPermission } from "./host-permissions"
+import type { SessionState, WithParts } from "./state"
+import { getLastUserMessage } from "./messages/query"
+
+export const compressPermission = (
+    state: SessionState,
+    config: PluginConfig,
+): "ask" | "allow" | "deny" => {
+    return state.compressPermission ?? config.compress.permission
+}
+
+export const syncCompressPermissionState = (
+    state: SessionState,
+    config: PluginConfig,
+    hostPermissions: HostPermissionSnapshot,
+    messages: WithParts[],
+): void => {
+    const activeAgent = getLastUserMessage(messages)?.info.agent
+    state.compressPermission = resolveEffectiveCompressPermission(
+        config.compress.permission,
+        hostPermissions,
+        activeAgent,
+    )
+}