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

package/lib/compress/pipeline.ts

@@ -1,106 +0,0 @@
-import type { WithParts } from "../state"
-import { ensureSessionInitialized } from "../state"
-import { saveSessionState } from "../state/persistence"
-import { assignMessageRefs } from "../message-ids"
-import { isIgnoredUserMessage } from "../messages/query"
-import { deduplicate, purgeErrors } from "../strategies"
-import { getCurrentParams } from "../token-utils"
-import { sendCompressNotification } from "../ui/notification"
-import type { ToolContext } from "./types"
-import { buildSearchContext, fetchSessionMessages } from "./search"
-import type { SearchContext } from "./types"
-import { applyPendingCompressionDurations } from "./timing"
-
-interface RunContext {
-    ask(input: {
-        permission: string
-        patterns: string[]
-        always: string[]
-        metadata: Record<string, unknown>
-    }): Promise<void>
-    metadata(input: { title: string }): void
-    sessionID: string
-}
-
-export interface NotificationEntry {
-    blockId: number
-    runId: number
-    summary: string
-    summaryTokens: number
-}
-
-export interface PreparedSession {
-    rawMessages: WithParts[]
-    searchContext: SearchContext
-}
-
-export async function prepareSession(
-    ctx: ToolContext,
-    toolCtx: RunContext,
-    title: string,
-): Promise<PreparedSession> {
-    if (ctx.state.manualMode && ctx.state.manualMode !== "compress-pending") {
-        throw new Error(
-            "Manual mode: compress blocked. Do not retry until `<compress triggered manually>` appears in user context.",
-        )
-    }
-
-    await toolCtx.ask({
-        permission: "compress",
-        patterns: ["*"],
-        always: ["*"],
-        metadata: {},
-    })
-
-    toolCtx.metadata({ title })
-
-    const rawMessages = await fetchSessionMessages(ctx.client, toolCtx.sessionID)
-
-    await ensureSessionInitialized(
-        ctx.client,
-        ctx.state,
-        toolCtx.sessionID,
-        ctx.logger,
-        rawMessages,
-        ctx.config.manualMode.enabled,
-    )
-
-    assignMessageRefs(ctx.state, rawMessages)
-
-    deduplicate(ctx.state, ctx.logger, ctx.config, rawMessages)
-    purgeErrors(ctx.state, ctx.logger, ctx.config, rawMessages)
-
-    return {
-        rawMessages,
-        searchContext: buildSearchContext(ctx.state, rawMessages),
-    }
-}
-
-export async function finalizeSession(
-    ctx: ToolContext,
-    toolCtx: RunContext,
-    rawMessages: WithParts[],
-    entries: NotificationEntry[],
-    batchTopic: string | undefined,
-): Promise<void> {
-    ctx.state.manualMode = ctx.state.manualMode ? "active" : false
-    applyPendingCompressionDurations(ctx.state)
-    await saveSessionState(ctx.state, ctx.logger)
-
-    const params = getCurrentParams(ctx.state, rawMessages, ctx.logger)
-    const sessionMessageIds = rawMessages
-        .filter((msg) => !isIgnoredUserMessage(msg))
-        .map((msg) => msg.info.id)
-
-    await sendCompressNotification(
-        ctx.client,
-        ctx.logger,
-        ctx.config,
-        ctx.state,
-        toolCtx.sessionID,
-        entries,
-        batchTopic,
-        sessionMessageIds,
-        params,
-    )
-}

package/lib/compress/protected-content.ts

@@ -1,154 +0,0 @@
-import type { SessionState } from "../state"
-import { isIgnoredUserMessage } from "../messages/query"
-import {
-    getFilePathsFromParameters,
-    isFilePathProtected,
-    isToolNameProtected,
-} from "../protected-patterns"
-import {
-    buildSubagentResultText,
-    getSubAgentId,
-    mergeSubagentResult,
-} from "../subagents/subagent-results"
-import { fetchSessionMessages } from "./search"
-import type { SearchContext, SelectionResolution } from "./types"
-
-export function appendProtectedUserMessages(
-    summary: string,
-    selection: SelectionResolution,
-    searchContext: SearchContext,
-    state: SessionState,
-    enabled: boolean,
-): string {
-    if (!enabled) return summary
-
-    const userTexts: string[] = []
-
-    for (const messageId of selection.messageIds) {
-        const existingCompressionEntry = state.prune.messages.byMessageId.get(messageId)
-        if (existingCompressionEntry && existingCompressionEntry.activeBlockIds.length > 0) {
-            continue
-        }
-
-        const message = searchContext.rawMessagesById.get(messageId)
-        if (!message) continue
-        if (message.info.role !== "user") continue
-        if (isIgnoredUserMessage(message)) continue
-
-        const parts = Array.isArray(message.parts) ? message.parts : []
-        for (const part of parts) {
-            if (part.type === "text" && typeof part.text === "string" && part.text.trim()) {
-                userTexts.push(part.text)
-                break
-            }
-        }
-    }
-
-    if (userTexts.length === 0) {
-        return summary
-    }
-
-    const heading = "\n\nThe following user messages were sent in this conversation verbatim:"
-    const body = userTexts.map((text) => `\n${text}`).join("")
-    return summary + heading + body
-}
-
-export async function appendProtectedTools(
-    client: any,
-    state: SessionState,
-    allowSubAgents: boolean,
-    summary: string,
-    selection: SelectionResolution,
-    searchContext: SearchContext,
-    protectedTools: string[],
-    protectedFilePatterns: string[] = [],
-): Promise<string> {
-    const protectedOutputs: string[] = []
-
-    for (const messageId of selection.messageIds) {
-        const existingCompressionEntry = state.prune.messages.byMessageId.get(messageId)
-        if (existingCompressionEntry && existingCompressionEntry.activeBlockIds.length > 0) {
-            continue
-        }
-
-        const message = searchContext.rawMessagesById.get(messageId)
-        if (!message) continue
-
-        const parts = Array.isArray(message.parts) ? message.parts : []
-        for (const part of parts) {
-            if (part.type === "tool" && part.callID) {
-                let isToolProtected = isToolNameProtected(part.tool, protectedTools)
-
-                if (!isToolProtected && protectedFilePatterns.length > 0) {
-                    const filePaths = getFilePathsFromParameters(part.tool, part.state?.input)
-                    if (isFilePathProtected(filePaths, protectedFilePatterns)) {
-                        isToolProtected = true
-                    }
-                }
-
-                if (isToolProtected) {
-                    const title = `Tool: ${part.tool}`
-                    let output = ""
-
-                    if (part.state?.status === "completed" && part.state?.output) {
-                        output =
-                            typeof part.state.output === "string"
-                                ? part.state.output
-                                : JSON.stringify(part.state.output)
-                    }
-
-                    if (
-                        allowSubAgents &&
-                        part.tool === "task" &&
-                        part.state?.status === "completed" &&
-                        typeof part.state?.output === "string"
-                    ) {
-                        const cachedSubAgentResult = state.subAgentResultCache.get(part.callID)
-
-                        if (cachedSubAgentResult !== undefined) {
-                            if (cachedSubAgentResult) {
-                                output = mergeSubagentResult(
-                                    part.state.output,
-                                    cachedSubAgentResult,
-                                )
-                            }
-                        } else {
-                            const subAgentSessionId = getSubAgentId(part)
-                            if (subAgentSessionId) {
-                                let subAgentResultText = ""
-                                try {
-                                    const subAgentMessages = await fetchSessionMessages(
-                                        client,
-                                        subAgentSessionId,
-                                    )
-                                    subAgentResultText = buildSubagentResultText(subAgentMessages)
-                                } catch {
-                                    subAgentResultText = ""
-                                }
-
-                                if (subAgentResultText) {
-                                    state.subAgentResultCache.set(part.callID, subAgentResultText)
-                                    output = mergeSubagentResult(
-                                        part.state.output,
-                                        subAgentResultText,
-                                    )
-                                }
-                            }
-                        }
-                    }
-
-                    if (output) {
-                        protectedOutputs.push(`\n### ${title}\n${output}`)
-                    }
-                }
-            }
-        }
-    }
-
-    if (protectedOutputs.length === 0) {
-        return summary
-    }
-
-    const heading = "\n\nThe following protected tools were used in this conversation as well:"
-    return summary + heading + protectedOutputs.join("")
-}

package/lib/compress/range-utils.ts

@@ -1,308 +0,0 @@
-import type { CompressionBlock, SessionState } from "../state"
-import { resolveAnchorMessageId, resolveBoundaryIds, resolveSelection } from "./search"
-import type {
-    BoundaryReference,
-    CompressRangeToolArgs,
-    InjectedSummaryResult,
-    ParsedBlockPlaceholder,
-    ResolvedRangeCompression,
-    SearchContext,
-} from "./types"
-
-const BLOCK_PLACEHOLDER_REGEX = /\(b(\d+)\)|\{block_(\d+)\}/gi
-
-export function validateArgs(args: CompressRangeToolArgs): void {
-    if (typeof args.topic !== "string" || args.topic.trim().length === 0) {
-        throw new Error("topic is required and must be a non-empty string")
-    }
-
-    if (!Array.isArray(args.content) || args.content.length === 0) {
-        throw new Error("content is required and must be a non-empty array")
-    }
-
-    for (let index = 0; index < args.content.length; index++) {
-        const entry = args.content[index]
-        const prefix = `content[${index}]`
-
-        if (typeof entry?.startId !== "string" || entry.startId.trim().length === 0) {
-            throw new Error(`${prefix}.startId is required and must be a non-empty string`)
-        }
-
-        if (typeof entry?.endId !== "string" || entry.endId.trim().length === 0) {
-            throw new Error(`${prefix}.endId is required and must be a non-empty string`)
-        }
-
-        if (typeof entry?.summary !== "string" || entry.summary.trim().length === 0) {
-            throw new Error(`${prefix}.summary is required and must be a non-empty string`)
-        }
-    }
-}
-
-export function resolveRanges(
-    args: CompressRangeToolArgs,
-    searchContext: SearchContext,
-    state: SessionState,
-): ResolvedRangeCompression[] {
-    return args.content.map((entry, index) => {
-        const normalizedEntry = {
-            startId: entry.startId.trim(),
-            endId: entry.endId.trim(),
-            summary: entry.summary,
-        }
-
-        const { startReference, endReference } = resolveBoundaryIds(
-            searchContext,
-            state,
-            normalizedEntry.startId,
-            normalizedEntry.endId,
-        )
-        const selection = resolveSelection(searchContext, startReference, endReference)
-
-        return {
-            index,
-            entry: normalizedEntry,
-            selection,
-            anchorMessageId: resolveAnchorMessageId(startReference),
-        }
-    })
-}
-
-export function validateNonOverlapping(plans: ResolvedRangeCompression[]): void {
-    const sortedPlans = [...plans].sort(
-        (left, right) =>
-            left.selection.startReference.rawIndex - right.selection.startReference.rawIndex ||
-            left.selection.endReference.rawIndex - right.selection.endReference.rawIndex ||
-            left.index - right.index,
-    )
-
-    const issues: string[] = []
-
-    for (let index = 1; index < sortedPlans.length; index++) {
-        const previous = sortedPlans[index - 1]
-        const current = sortedPlans[index]
-        if (!previous || !current) {
-            continue
-        }
-
-        if (current.selection.startReference.rawIndex > previous.selection.endReference.rawIndex) {
-            continue
-        }
-
-        issues.push(
-            `content[${previous.index}] (${previous.entry.startId}..${previous.entry.endId}) overlaps content[${current.index}] (${current.entry.startId}..${current.entry.endId}). Overlapping ranges cannot be compressed in the same batch.`,
-        )
-    }
-
-    if (issues.length > 0) {
-        throw new Error(
-            issues.length === 1 ? issues[0] : issues.map((issue) => `- ${issue}`).join("\n"),
-        )
-    }
-}
-
-export function parseBlockPlaceholders(summary: string): ParsedBlockPlaceholder[] {
-    const placeholders: ParsedBlockPlaceholder[] = []
-    const regex = new RegExp(BLOCK_PLACEHOLDER_REGEX)
-
-    let match: RegExpExecArray | null
-    while ((match = regex.exec(summary)) !== null) {
-        const full = match[0]
-        const blockIdPart = match[1] || match[2]
-        const parsed = Number.parseInt(blockIdPart, 10)
-        if (!Number.isInteger(parsed)) {
-            continue
-        }
-
-        placeholders.push({
-            raw: full,
-            blockId: parsed,
-            startIndex: match.index,
-            endIndex: match.index + full.length,
-        })
-    }
-
-    return placeholders
-}
-
-export function validateSummaryPlaceholders(
-    placeholders: ParsedBlockPlaceholder[],
-    requiredBlockIds: number[],
-    startReference: BoundaryReference,
-    endReference: BoundaryReference,
-    summaryByBlockId: Map<number, CompressionBlock>,
-): number[] {
-    const boundaryOptionalIds = new Set<number>()
-    if (startReference.kind === "compressed-block") {
-        if (startReference.blockId === undefined) {
-            throw new Error("Failed to map boundary matches back to raw messages")
-        }
-        boundaryOptionalIds.add(startReference.blockId)
-    }
-    if (endReference.kind === "compressed-block") {
-        if (endReference.blockId === undefined) {
-            throw new Error("Failed to map boundary matches back to raw messages")
-        }
-        boundaryOptionalIds.add(endReference.blockId)
-    }
-
-    const strictRequiredIds = requiredBlockIds.filter((id) => !boundaryOptionalIds.has(id))
-    const requiredSet = new Set(requiredBlockIds)
-    const keptPlaceholderIds = new Set<number>()
-    const validPlaceholders: ParsedBlockPlaceholder[] = []
-
-    for (const placeholder of placeholders) {
-        const isKnown = summaryByBlockId.has(placeholder.blockId)
-        const isRequired = requiredSet.has(placeholder.blockId)
-        const isDuplicate = keptPlaceholderIds.has(placeholder.blockId)
-
-        if (isKnown && isRequired && !isDuplicate) {
-            validPlaceholders.push(placeholder)
-            keptPlaceholderIds.add(placeholder.blockId)
-        }
-    }
-
-    placeholders.length = 0
-    placeholders.push(...validPlaceholders)
-
-    return strictRequiredIds.filter((id) => !keptPlaceholderIds.has(id))
-}
-
-export function injectBlockPlaceholders(
-    summary: string,
-    placeholders: ParsedBlockPlaceholder[],
-    summaryByBlockId: Map<number, CompressionBlock>,
-    startReference: BoundaryReference,
-    endReference: BoundaryReference,
-): InjectedSummaryResult {
-    let cursor = 0
-    let expanded = summary
-    const consumed: number[] = []
-    const consumedSeen = new Set<number>()
-
-    if (placeholders.length > 0) {
-        expanded = ""
-        for (const placeholder of placeholders) {
-            const target = summaryByBlockId.get(placeholder.blockId)
-            if (!target) {
-                throw new Error(`Compressed block not found: (b${placeholder.blockId})`)
-            }
-
-            expanded += summary.slice(cursor, placeholder.startIndex)
-            expanded += restoreSummary(target.summary)
-            cursor = placeholder.endIndex
-
-            if (!consumedSeen.has(placeholder.blockId)) {
-                consumedSeen.add(placeholder.blockId)
-                consumed.push(placeholder.blockId)
-            }
-        }
-
-        expanded += summary.slice(cursor)
-    }
-
-    expanded = injectBoundarySummary(
-        expanded,
-        startReference,
-        "start",
-        summaryByBlockId,
-        consumed,
-        consumedSeen,
-    )
-    expanded = injectBoundarySummary(
-        expanded,
-        endReference,
-        "end",
-        summaryByBlockId,
-        consumed,
-        consumedSeen,
-    )
-
-    return {
-        expandedSummary: expanded,
-        consumedBlockIds: consumed,
-    }
-}
-
-export function appendMissingBlockSummaries(
-    summary: string,
-    missingBlockIds: number[],
-    summaryByBlockId: Map<number, CompressionBlock>,
-    consumedBlockIds: number[],
-): InjectedSummaryResult {
-    const consumedSeen = new Set<number>(consumedBlockIds)
-    const consumed = [...consumedBlockIds]
-
-    const missingSummaries: string[] = []
-    for (const blockId of missingBlockIds) {
-        if (consumedSeen.has(blockId)) {
-            continue
-        }
-
-        const target = summaryByBlockId.get(blockId)
-        if (!target) {
-            throw new Error(`Compressed block not found: (b${blockId})`)
-        }
-
-        missingSummaries.push(`\n### (b${blockId})\n${restoreSummary(target.summary)}`)
-        consumedSeen.add(blockId)
-        consumed.push(blockId)
-    }
-
-    if (missingSummaries.length === 0) {
-        return {
-            expandedSummary: summary,
-            consumedBlockIds: consumed,
-        }
-    }
-
-    const heading =
-        "\n\nThe following previously compressed summaries were also part of this conversation section:"
-
-    return {
-        expandedSummary: summary + heading + missingSummaries.join(""),
-        consumedBlockIds: consumed,
-    }
-}
-
-function restoreSummary(summary: string): string {
-    const headerMatch = summary.match(/^\s*\[Compressed conversation(?: section)?(?: b\d+)?\]/i)
-    if (!headerMatch) {
-        return summary
-    }
-
-    const afterHeader = summary.slice(headerMatch[0].length)
-    const withoutLeadingBreaks = afterHeader.replace(/^(?:\r?\n)+/, "")
-    return withoutLeadingBreaks
-        .replace(/(?:\r?\n)*<dcp-message-id>b\d+<\/dcp-message-id>\s*$/i, "")
-        .replace(/(?:\r?\n)+$/, "")
-}
-
-function injectBoundarySummary(
-    summary: string,
-    reference: BoundaryReference,
-    position: "start" | "end",
-    summaryByBlockId: Map<number, CompressionBlock>,
-    consumed: number[],
-    consumedSeen: Set<number>,
-): string {
-    if (reference.kind !== "compressed-block" || reference.blockId === undefined) {
-        return summary
-    }
-    if (consumedSeen.has(reference.blockId)) {
-        return summary
-    }
-
-    const target = summaryByBlockId.get(reference.blockId)
-    if (!target) {
-        throw new Error(`Compressed block not found: (b${reference.blockId})`)
-    }
-
-    const injectedBody = restoreSummary(target.summary)
-    const left = position === "start" ? injectedBody.trim() : summary.trim()
-    const right = position === "start" ? summary.trim() : injectedBody.trim()
-    const next = !left ? right : !right ? left : `${left}\n\n${right}`
-
-    consumedSeen.add(reference.blockId)
-    consumed.push(reference.blockId)
-    return next
-}