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

package/lib/commands/recompress.ts

@@ -0,0 +1,224 @@
+import type { Logger } from "../logger"
+import type { PruneMessagesState, SessionState, WithParts } from "../state"
+import { syncCompressionBlocks } from "../messages"
+import { parseBlockRef } from "../message-ids"
+import { getCurrentParams } from "../token-utils"
+import { saveSessionState } from "../state/persistence"
+import { sendIgnoredMessage } from "../ui/notification"
+import { formatTokenCount } from "../ui/utils"
+import {
+    getRecompressibleCompressionTargets,
+    resolveCompressionTarget,
+    type CompressionTarget,
+} from "./compression-targets"
+
+export interface RecompressCommandContext {
+    client: any
+    state: SessionState
+    logger: Logger
+    sessionId: string
+    messages: WithParts[]
+    args: string[]
+}
+
+function parseBlockIdArg(arg: string): number | null {
+    const normalized = arg.trim().toLowerCase()
+    const blockRef = parseBlockRef(normalized)
+    if (blockRef !== null) {
+        return blockRef
+    }
+
+    if (!/^[1-9]\d*$/.test(normalized)) {
+        return null
+    }
+
+    const parsed = Number.parseInt(normalized, 10)
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : null
+}
+
+function snapshotActiveMessages(messagesState: PruneMessagesState): Set<string> {
+    const activeMessages = new Set<string>()
+    for (const [messageId, entry] of messagesState.byMessageId) {
+        if (entry.activeBlockIds.length > 0) {
+            activeMessages.add(messageId)
+        }
+    }
+    return activeMessages
+}
+
+function formatRecompressMessage(
+    target: CompressionTarget,
+    recompressedMessageCount: number,
+    recompressedTokens: number,
+    deactivatedBlockIds: number[],
+): string {
+    const lines: string[] = []
+
+    lines.push(`Re-applied compression ${target.displayId}.`)
+    if (target.runId !== target.displayId || target.grouped) {
+        lines.push(`Tool call label: Compression #${target.runId}.`)
+    }
+    if (deactivatedBlockIds.length > 0) {
+        const refs = deactivatedBlockIds.map((id) => String(id)).join(", ")
+        lines.push(`Also re-compressed nested compression(s): ${refs}.`)
+    }
+
+    if (recompressedMessageCount > 0) {
+        lines.push(
+            `Re-compressed ${recompressedMessageCount} message(s) (~${formatTokenCount(recompressedTokens)}).`,
+        )
+    } else {
+        lines.push("No messages were re-compressed.")
+    }
+
+    return lines.join("\n")
+}
+
+function formatAvailableBlocksMessage(availableTargets: CompressionTarget[]): string {
+    const lines: string[] = []
+
+    lines.push("Usage: /dcp recompress <n>")
+    lines.push("")
+
+    if (availableTargets.length === 0) {
+        lines.push("No user-decompressed blocks are available to re-compress.")
+        return lines.join("\n")
+    }
+
+    lines.push("Available user-decompressed compressions:")
+    const entries = availableTargets.map((target) => {
+        const topic = target.topic.replace(/\s+/g, " ").trim() || "(no topic)"
+        const label = `${target.displayId} (${formatTokenCount(target.compressedTokens)})`
+        const details = target.grouped
+            ? `Compression #${target.runId} - ${target.blocks.length} messages`
+            : `Compression #${target.runId}`
+        return { label, topic: `${details} - ${topic}` }
+    })
+
+    const labelWidth = Math.max(...entries.map((entry) => entry.label.length)) + 4
+    for (const entry of entries) {
+        lines.push(`  ${entry.label.padEnd(labelWidth)}${entry.topic}`)
+    }
+
+    return lines.join("\n")
+}
+
+export async function handleRecompressCommand(ctx: RecompressCommandContext): Promise<void> {
+    const { client, state, logger, sessionId, messages, args } = ctx
+
+    const params = getCurrentParams(state, messages, logger)
+    const targetArg = args[0]
+
+    if (args.length > 1) {
+        await sendIgnoredMessage(
+            client,
+            sessionId,
+            "Invalid arguments. Usage: /dcp recompress <n>",
+            params,
+            logger,
+        )
+        return
+    }
+
+    syncCompressionBlocks(state, logger, messages)
+    const messagesState = state.prune.messages
+    const availableMessageIds = new Set(messages.map((msg) => msg.info.id))
+
+    if (!targetArg) {
+        const availableTargets = getRecompressibleCompressionTargets(
+            messagesState,
+            availableMessageIds,
+        )
+        const message = formatAvailableBlocksMessage(availableTargets)
+        await sendIgnoredMessage(client, sessionId, message, params, logger)
+        return
+    }
+
+    const targetBlockId = parseBlockIdArg(targetArg)
+    if (targetBlockId === null) {
+        await sendIgnoredMessage(
+            client,
+            sessionId,
+            `Please enter a compression number. Example: /dcp recompress 2`,
+            params,
+            logger,
+        )
+        return
+    }
+
+    const target = resolveCompressionTarget(messagesState, targetBlockId)
+    if (!target) {
+        await sendIgnoredMessage(
+            client,
+            sessionId,
+            `Compression ${targetBlockId} does not exist.`,
+            params,
+            logger,
+        )
+        return
+    }
+
+    if (target.blocks.some((block) => !availableMessageIds.has(block.compressMessageId))) {
+        await sendIgnoredMessage(
+            client,
+            sessionId,
+            `Compression ${target.displayId} can no longer be re-applied because its origin message is no longer in this session.`,
+            params,
+            logger,
+        )
+        return
+    }
+
+    if (!target.blocks.some((block) => block.deactivatedByUser)) {
+        const message = target.blocks.some((block) => block.active)
+            ? `Compression ${target.displayId} is already active.`
+            : `Compression ${target.displayId} is not user-decompressed.`
+        await sendIgnoredMessage(client, sessionId, message, params, logger)
+        return
+    }
+
+    const activeMessagesBefore = snapshotActiveMessages(messagesState)
+    const activeBlockIdsBefore = new Set(messagesState.activeBlockIds)
+
+    for (const block of target.blocks) {
+        block.deactivatedByUser = false
+        block.deactivatedAt = undefined
+        block.deactivatedByBlockId = undefined
+    }
+
+    syncCompressionBlocks(state, logger, messages)
+
+    let recompressedMessageCount = 0
+    let recompressedTokens = 0
+    for (const [messageId, entry] of messagesState.byMessageId) {
+        const isActiveNow = entry.activeBlockIds.length > 0
+        if (isActiveNow && !activeMessagesBefore.has(messageId)) {
+            recompressedMessageCount++
+            recompressedTokens += entry.tokenCount
+        }
+    }
+
+    state.stats.totalPruneTokens += recompressedTokens
+
+    const deactivatedBlockIds = Array.from(activeBlockIdsBefore)
+        .filter((blockId) => !messagesState.activeBlockIds.has(blockId))
+        .sort((a, b) => a - b)
+
+    await saveSessionState(state, logger)
+
+    const message = formatRecompressMessage(
+        target,
+        recompressedMessageCount,
+        recompressedTokens,
+        deactivatedBlockIds,
+    )
+    await sendIgnoredMessage(client, sessionId, message, params, logger)
+
+    logger.info("Recompress command completed", {
+        targetBlockId: target.displayId,
+        targetRunId: target.runId,
+        recompressedMessageCount,
+        recompressedTokens,
+        deactivatedBlockIds,
+    })
+}

package/lib/commands/stats.ts

@@ -0,0 +1,148 @@
+/**
+ * DCP Stats command handler.
+ * Shows pruning statistics for the current session and all-time totals.
+ */
+
+import type { Logger } from "../logger"
+import type { SessionState, WithParts } from "../state"
+import { sendIgnoredMessage } from "../ui/notification"
+import { formatTokenCount } from "../ui/utils"
+import { loadAllSessionStats, type AggregatedStats } from "../state/persistence"
+import { getCurrentParams } from "../token-utils"
+import { getActiveCompressionTargets } from "./compression-targets"
+
+export interface StatsCommandContext {
+    client: any
+    state: SessionState
+    logger: Logger
+    sessionId: string
+    messages: WithParts[]
+}
+
+function formatStatsMessage(
+    sessionTokens: number,
+    sessionSummaryTokens: number,
+    sessionTools: number,
+    sessionMessages: number,
+    sessionDurationMs: number,
+    allTime: AggregatedStats,
+): string {
+    const lines: string[] = []
+
+    lines.push("╭───────────────────────────────────────────────────────────╮")
+    lines.push("│                    DCP Statistics                         │")
+    lines.push("╰───────────────────────────────────────────────────────────╯")
+    lines.push("")
+    lines.push("Compression:")
+    lines.push("─".repeat(60))
+    lines.push(
+        `  Tokens in|out:    ~${formatTokenCount(sessionTokens)} | ~${formatTokenCount(sessionSummaryTokens)}`,
+    )
+    lines.push(`  Ratio:            ${formatCompressionRatio(sessionTokens, sessionSummaryTokens)}`)
+    lines.push(`  Time:             ${formatCompressionTime(sessionDurationMs)}`)
+    lines.push(`  Messages:         ${sessionMessages}`)
+    lines.push(`  Tools:            ${sessionTools}`)
+    lines.push("")
+    lines.push("All-time:")
+    lines.push("─".repeat(60))
+    lines.push(`  Tokens saved:    ~${formatTokenCount(allTime.totalTokens)}`)
+    lines.push(`  Tools pruned:     ${allTime.totalTools}`)
+    lines.push(`  Messages pruned:  ${allTime.totalMessages}`)
+    lines.push(`  Sessions:         ${allTime.sessionCount}`)
+
+    return lines.join("\n")
+}
+
+function formatCompressionRatio(inputTokens: number, outputTokens: number): string {
+    if (inputTokens <= 0) {
+        return "0:1"
+    }
+
+    if (outputTokens <= 0) {
+        return "∞:1"
+    }
+
+    const ratio = Math.max(1, Math.round(inputTokens / outputTokens))
+    return `${ratio}:1`
+}
+
+function formatCompressionTime(ms: number): string {
+    const safeMs = Math.max(0, Math.round(ms))
+    if (safeMs < 1000) {
+        return `${safeMs} ms`
+    }
+
+    const totalSeconds = safeMs / 1000
+    if (totalSeconds < 60) {
+        return `${totalSeconds.toFixed(1)} s`
+    }
+
+    const wholeSeconds = Math.floor(totalSeconds)
+    const hours = Math.floor(wholeSeconds / 3600)
+    const minutes = Math.floor((wholeSeconds % 3600) / 60)
+    const seconds = wholeSeconds % 60
+
+    if (hours > 0) {
+        return `${hours}h ${minutes}m ${seconds}s`
+    }
+
+    return `${minutes}m ${seconds}s`
+}
+
+export async function handleStatsCommand(ctx: StatsCommandContext): Promise<void> {
+    const { client, state, logger, sessionId, messages } = ctx
+
+    // Session stats from in-memory state
+    const sessionTokens = state.stats.totalPruneTokens
+    const sessionSummaryTokens = Array.from(state.prune.messages.blocksById.values()).reduce(
+        (total, block) => (block.active ? total + block.summaryTokens : total),
+        0,
+    )
+    const sessionDurationMs = getActiveCompressionTargets(state.prune.messages).reduce(
+        (total, target) => total + target.durationMs,
+        0,
+    )
+
+    const prunedToolIds = new Set<string>(state.prune.tools.keys())
+    for (const block of state.prune.messages.blocksById.values()) {
+        if (block.active) {
+            for (const toolId of block.effectiveToolIds) {
+                prunedToolIds.add(toolId)
+            }
+        }
+    }
+    const sessionTools = prunedToolIds.size
+
+    let sessionMessages = 0
+    for (const entry of state.prune.messages.byMessageId.values()) {
+        if (entry.activeBlockIds.length > 0) {
+            sessionMessages++
+        }
+    }
+
+    // All-time stats from storage files
+    const allTime = await loadAllSessionStats(logger)
+
+    const message = formatStatsMessage(
+        sessionTokens,
+        sessionSummaryTokens,
+        sessionTools,
+        sessionMessages,
+        sessionDurationMs,
+        allTime,
+    )
+
+    const params = getCurrentParams(state, messages, logger)
+    await sendIgnoredMessage(client, sessionId, message, params, logger)
+
+    logger.info("Stats command executed", {
+        sessionTokens,
+        sessionSummaryTokens,
+        sessionTools,
+        sessionMessages,
+        sessionDurationMs,
+        allTimeTokens: allTime.totalTokens,
+        allTimeTools: allTime.totalTools,
+        allTimeMessages: allTime.totalMessages,
+    })
+}

package/lib/commands/sweep.ts

@@ -0,0 +1,268 @@
+/**
+ * DCP Sweep command handler.
+ * Prunes tool outputs since the last user message, or the last N tools.
+ *
+ * Usage:
+ *   /dcp sweep        - Prune all tools since the previous user message
+ *   /dcp sweep 10     - Prune the last 10 tools
+ */
+
+import type { Logger } from "../logger"
+import type { SessionState, WithParts, ToolParameterEntry } from "../state"
+import type { PluginConfig } from "../config"
+import { sendIgnoredMessage } from "../ui/notification"
+import { formatPrunedItemsList } from "../ui/utils"
+import { getCurrentParams, getTotalToolTokens } from "../token-utils"
+import { isIgnoredUserMessage } from "../messages/query"
+import { buildToolIdList } from "../messages/utils"
+import { saveSessionState } from "../state/persistence"
+import { isMessageCompacted } from "../state/utils"
+import {
+    getFilePathsFromParameters,
+    isFilePathProtected,
+    isToolNameProtected,
+} from "../protected-patterns"
+import { syncToolCache } from "../state/tool-cache"
+
+export interface SweepCommandContext {
+    client: any
+    state: SessionState
+    config: PluginConfig
+    logger: Logger
+    sessionId: string
+    messages: WithParts[]
+    args: string[]
+    workingDirectory: string
+}
+
+function findLastUserMessageIndex(messages: WithParts[]): number {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i]
+        if (msg.info.role === "user" && !isIgnoredUserMessage(msg)) {
+            return i
+        }
+    }
+
+    return -1
+}
+
+function collectToolIdsAfterIndex(
+    state: SessionState,
+    messages: WithParts[],
+    afterIndex: number,
+): string[] {
+    const toolIds: string[] = []
+
+    for (let i = afterIndex + 1; i < messages.length; i++) {
+        const msg = messages[i]
+        if (isMessageCompacted(state, msg)) {
+            continue
+        }
+        const parts = Array.isArray(msg.parts) ? msg.parts : []
+        if (parts.length > 0) {
+            for (const part of parts) {
+                if (part.type === "tool" && part.callID && part.tool) {
+                    toolIds.push(part.callID)
+                }
+            }
+        }
+    }
+
+    return toolIds
+}
+
+function formatNoUserMessage(): string {
+    const lines: string[] = []
+
+    lines.push("╭───────────────────────────────────────────────────────────╮")
+    lines.push("│                      DCP Sweep                            │")
+    lines.push("╰───────────────────────────────────────────────────────────╯")
+    lines.push("")
+    lines.push("Nothing swept: no user message found.")
+
+    return lines.join("\n")
+}
+
+function formatSweepMessage(
+    toolCount: number,
+    tokensSaved: number,
+    mode: "since-user" | "last-n",
+    toolIds: string[],
+    toolMetadata: Map<string, ToolParameterEntry>,
+    workingDirectory?: string,
+    skippedProtected?: number,
+): string {
+    const lines: string[] = []
+
+    lines.push("╭───────────────────────────────────────────────────────────╮")
+    lines.push("│                      DCP Sweep                            │")
+    lines.push("╰───────────────────────────────────────────────────────────╯")
+    lines.push("")
+
+    if (toolCount === 0) {
+        if (mode === "since-user") {
+            lines.push("No tools found since the previous user message.")
+        } else {
+            lines.push(`No tools found to sweep.`)
+        }
+        if (skippedProtected && skippedProtected > 0) {
+            lines.push(`(${skippedProtected} protected tool(s) skipped)`)
+        }
+    } else {
+        if (mode === "since-user") {
+            lines.push(`Swept ${toolCount} tool(s) since the previous user message.`)
+        } else {
+            lines.push(`Swept the last ${toolCount} tool(s).`)
+        }
+        lines.push(`Tokens saved: ~${tokensSaved.toLocaleString()}`)
+        if (skippedProtected && skippedProtected > 0) {
+            lines.push(`(${skippedProtected} protected tool(s) skipped)`)
+        }
+        lines.push("")
+        const itemLines = formatPrunedItemsList(toolIds, toolMetadata, workingDirectory)
+        lines.push(...itemLines)
+    }
+
+    return lines.join("\n")
+}
+
+export async function handleSweepCommand(ctx: SweepCommandContext): Promise<void> {
+    const { client, state, config, logger, sessionId, messages, args, workingDirectory } = ctx
+
+    const params = getCurrentParams(state, messages, logger)
+    const protectedTools = config.commands.protectedTools
+
+    syncToolCache(state, config, logger, messages)
+    buildToolIdList(state, messages)
+
+    // Parse optional numeric argument
+    const numArg = args[0] ? parseInt(args[0], 10) : null
+    const isLastNMode = numArg !== null && !isNaN(numArg) && numArg > 0
+
+    let toolIdsToSweep: string[]
+    let mode: "since-user" | "last-n"
+
+    if (isLastNMode) {
+        // Mode: Sweep last N tools
+        mode = "last-n"
+        const startIndex = Math.max(0, state.toolIdList.length - numArg!)
+        toolIdsToSweep = state.toolIdList.slice(startIndex)
+        logger.info(`Sweep command: last ${numArg} mode, found ${toolIdsToSweep.length} tools`)
+    } else {
+        // Mode: Sweep since last user message
+        mode = "since-user"
+        const lastUserMsgIndex = findLastUserMessageIndex(messages)
+
+        if (lastUserMsgIndex === -1) {
+            // No user message found - show message and return
+            const message = formatNoUserMessage()
+            await sendIgnoredMessage(client, sessionId, message, params, logger)
+            logger.info("Sweep command: no user message found")
+            return
+        } else {
+            toolIdsToSweep = collectToolIdsAfterIndex(state, messages, lastUserMsgIndex)
+            logger.info(
+                `Sweep command: found last user at index ${lastUserMsgIndex}, sweeping ${toolIdsToSweep.length} tools`,
+            )
+        }
+    }
+
+    // Filter out already-pruned tools, protected tools, and protected file paths
+    const newToolIds = toolIdsToSweep.filter((id) => {
+        if (state.prune.tools.has(id)) {
+            return false
+        }
+        const entry = state.toolParameters.get(id)
+        if (!entry) {
+            return true
+        }
+        if (isToolNameProtected(entry.tool, protectedTools)) {
+            logger.debug(`Sweep: skipping protected tool ${entry.tool} (${id})`)
+            return false
+        }
+        const filePaths = getFilePathsFromParameters(entry.tool, entry.parameters)
+        if (isFilePathProtected(filePaths, config.protectedFilePatterns)) {
+            logger.debug(`Sweep: skipping protected file path(s) ${filePaths.join(", ")} (${id})`)
+            return false
+        }
+        return true
+    })
+
+    // Count how many were skipped due to protection
+    const skippedProtected = toolIdsToSweep.filter((id) => {
+        const entry = state.toolParameters.get(id)
+        if (!entry) {
+            return false
+        }
+        if (isToolNameProtected(entry.tool, protectedTools)) {
+            return true
+        }
+        const filePaths = getFilePathsFromParameters(entry.tool, entry.parameters)
+        if (isFilePathProtected(filePaths, config.protectedFilePatterns)) {
+            return true
+        }
+        return false
+    }).length
+
+    if (newToolIds.length === 0) {
+        const message = formatSweepMessage(
+            0,
+            0,
+            mode,
+            [],
+            new Map(),
+            workingDirectory,
+            skippedProtected,
+        )
+        await sendIgnoredMessage(client, sessionId, message, params, logger)
+        logger.info("Sweep command: no new tools to sweep", { skippedProtected })
+        return
+    }
+
+    const tokensSaved = getTotalToolTokens(state, newToolIds)
+
+    // Add to prune list
+    for (const id of newToolIds) {
+        const entry = state.toolParameters.get(id)
+        state.prune.tools.set(id, entry?.tokenCount ?? 0)
+    }
+    state.stats.pruneTokenCounter += tokensSaved
+    state.stats.totalPruneTokens += state.stats.pruneTokenCounter
+    state.stats.pruneTokenCounter = 0
+
+    // Collect metadata for logging
+    const toolMetadata: Map<string, ToolParameterEntry> = new Map()
+    for (const id of newToolIds) {
+        const entry = state.toolParameters.get(id)
+        if (entry) {
+            toolMetadata.set(id, entry)
+        }
+    }
+
+    // Persist state
+    saveSessionState(state, logger).catch((err) =>
+        logger.error("Failed to persist state after sweep", { error: err.message }),
+    )
+
+    const message = formatSweepMessage(
+        newToolIds.length,
+        tokensSaved,
+        mode,
+        newToolIds,
+        toolMetadata,
+        workingDirectory,
+        skippedProtected,
+    )
+    await sendIgnoredMessage(client, sessionId, message, params, logger)
+
+    logger.info("Sweep command completed", {
+        toolsSwept: newToolIds.length,
+        tokensSaved,
+        skippedProtected,
+        mode,
+        tools: Array.from(toolMetadata.entries()).map(([id, entry]) => ({
+            id,
+            tool: entry.tool,
+        })),
+    })
+}

package/lib/compress/index.ts

@@ -0,0 +1,3 @@
+export { ToolContext } from "./types"
+export { createCompressMessageTool } from "./message"
+export { createCompressRangeTool } from "./range"