@tarquinen/opencode-dcp 3.2.4-beta0 → 3.2.5-beta0

package/lib/compress/timing.ts

@@ -1,77 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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
-}