@tarquinen/opencode-dcp 3.1.11 → 3.1.13

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"

package/lib/compress/message-utils.ts

@@ -0,0 +1,250 @@
+import type { PluginConfig } from "../config"
+import type { SessionState } from "../state"
+import { parseBoundaryId } from "../message-ids"
+import { isIgnoredUserMessage, isProtectedUserMessage } from "../messages/query"
+import { resolveAnchorMessageId, resolveBoundaryIds, resolveSelection } from "./search"
+import { COMPRESSED_BLOCK_HEADER } from "./state"
+import type {
+    CompressMessageEntry,
+    CompressMessageToolArgs,
+    ResolvedMessageCompression,
+    ResolvedMessageCompressionsResult,
+    SearchContext,
+} from "./types"
+
+interface SkippedIssue {
+    kind: string
+    messageId: string
+}
+
+class SoftIssue extends Error {
+    constructor(
+        public readonly kind: string,
+        public readonly messageId: string,
+        message: string,
+    ) {
+        super(message)
+    }
+}
+
+export function validateArgs(args: CompressMessageToolArgs): 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?.messageId !== "string" || entry.messageId.trim().length === 0) {
+            throw new Error(`${prefix}.messageId is required and must be a non-empty string`)
+        }
+
+        if (typeof entry?.topic !== "string" || entry.topic.trim().length === 0) {
+            throw new Error(`${prefix}.topic 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 formatResult(
+    processedCount: number,
+    skippedIssues: string[],
+    skippedCount: number,
+): string {
+    const messageNoun = processedCount === 1 ? "message" : "messages"
+    const processedText =
+        processedCount > 0
+            ? `Compressed ${processedCount} ${messageNoun} into ${COMPRESSED_BLOCK_HEADER}.`
+            : "Compressed 0 messages."
+
+    if (skippedCount === 0) {
+        return processedText
+    }
+
+    const issueNoun = skippedCount === 1 ? "issue" : "issues"
+    const issueLines = skippedIssues.map((issue) => `- ${issue}`).join("\n")
+    return `${processedText}\nSkipped ${skippedCount} ${issueNoun}:\n${issueLines}`
+}
+
+export function formatIssues(skippedIssues: string[], skippedCount: number): string {
+    const issueNoun = skippedCount === 1 ? "issue" : "issues"
+    const issueLines = skippedIssues.map((issue) => `- ${issue}`).join("\n")
+    return `Unable to compress any messages. Found ${skippedCount} ${issueNoun}:\n${issueLines}`
+}
+
+const ISSUE_TEMPLATES: Record<string, [singular: string, plural: string]> = {
+    blocked: [
+        "refers to a protected message and cannot be compressed.",
+        "refer to protected messages and cannot be compressed.",
+    ],
+    "invalid-format": [
+        "is invalid. Use an injected raw message ID of the form mNNNN.",
+        "are invalid. Use injected raw message IDs of the form mNNNN.",
+    ],
+    "block-id": [
+        "is invalid here. Block IDs like bN are not allowed; use an mNNNN message ID instead.",
+        "are invalid here. Block IDs like bN are not allowed; use mNNNN message IDs instead.",
+    ],
+    "not-in-context": [
+        "is not available in the current conversation context. Choose an injected mNNNN ID visible in context.",
+        "are not available in the current conversation context. Choose injected mNNNN IDs visible in context.",
+    ],
+    protected: [
+        "refers to a protected message and cannot be compressed.",
+        "refer to protected messages and cannot be compressed.",
+    ],
+    "already-compressed": [
+        "is already part of an active compression.",
+        "are already part of active compressions.",
+    ],
+    duplicate: [
+        "was selected more than once in this batch.",
+        "were each selected more than once in this batch.",
+    ],
+}
+
+function formatSkippedGroup(kind: string, messageIds: string[]): string {
+    const templates = ISSUE_TEMPLATES[kind]
+    const ids = messageIds.join(", ")
+    const single = messageIds.length === 1
+    const prefix = single ? "messageId" : "messageIds"
+
+    if (!templates) {
+        return `${prefix} ${ids}: unknown issue.`
+    }
+
+    return `${prefix} ${ids} ${single ? templates[0] : templates[1]}`
+}
+
+function groupSkippedIssues(issues: SkippedIssue[]): string[] {
+    const groups = new Map<string, string[]>()
+    const order: string[] = []
+
+    for (const issue of issues) {
+        let ids = groups.get(issue.kind)
+        if (!ids) {
+            ids = []
+            groups.set(issue.kind, ids)
+            order.push(issue.kind)
+        }
+        ids.push(issue.messageId)
+    }
+
+    return order.map((kind) => {
+        const ids = groups.get(kind)!
+        return formatSkippedGroup(kind, ids)
+    })
+}
+
+export function resolveMessages(
+    args: CompressMessageToolArgs,
+    searchContext: SearchContext,
+    state: SessionState,
+    config: PluginConfig,
+): ResolvedMessageCompressionsResult {
+    const issues: SkippedIssue[] = []
+    const plans: ResolvedMessageCompression[] = []
+    const seenMessageIds = new Set<string>()
+
+    for (const entry of args.content) {
+        const normalizedMessageId = entry.messageId.trim()
+        if (seenMessageIds.has(normalizedMessageId)) {
+            issues.push({ kind: "duplicate", messageId: normalizedMessageId })
+            continue
+        }
+
+        try {
+            const plan = resolveMessage(
+                {
+                    ...entry,
+                    messageId: normalizedMessageId,
+                },
+                searchContext,
+                state,
+                config,
+            )
+            seenMessageIds.add(plan.entry.messageId)
+            plans.push(plan)
+        } catch (error: any) {
+            if (error instanceof SoftIssue) {
+                issues.push({ kind: error.kind, messageId: error.messageId })
+                continue
+            }
+
+            throw error
+        }
+    }
+
+    return {
+        plans,
+        skippedIssues: groupSkippedIssues(issues),
+        skippedCount: issues.length,
+    }
+}
+
+function resolveMessage(
+    entry: CompressMessageEntry,
+    searchContext: SearchContext,
+    state: SessionState,
+    config: PluginConfig,
+): ResolvedMessageCompression {
+    if (entry.messageId.toUpperCase() === "BLOCKED") {
+        throw new SoftIssue("blocked", "BLOCKED", "protected message")
+    }
+
+    const parsed = parseBoundaryId(entry.messageId)
+
+    if (!parsed) {
+        throw new SoftIssue("invalid-format", entry.messageId, "invalid format")
+    }
+
+    if (parsed.kind === "compressed-block") {
+        throw new SoftIssue("block-id", entry.messageId, "block ID used")
+    }
+
+    const messageId = state.messageIds.byRef.get(parsed.ref)
+    const rawMessage = messageId ? searchContext.rawMessagesById.get(messageId) : undefined
+    if (
+        !messageId ||
+        !rawMessage ||
+        !searchContext.rawIndexById.has(messageId) ||
+        isIgnoredUserMessage(rawMessage)
+    ) {
+        throw new SoftIssue("not-in-context", parsed.ref, "not in context")
+    }
+
+    const { startReference, endReference } = resolveBoundaryIds(
+        searchContext,
+        state,
+        parsed.ref,
+        parsed.ref,
+    )
+    const selection = resolveSelection(searchContext, startReference, endReference)
+
+    if (isProtectedUserMessage(config, rawMessage)) {
+        throw new SoftIssue("protected", parsed.ref, "protected message")
+    }
+
+    const pruneEntry = state.prune.messages.byMessageId.get(messageId)
+    if (pruneEntry && pruneEntry.activeBlockIds.length > 0) {
+        throw new SoftIssue("already-compressed", parsed.ref, "already compressed")
+    }
+
+    return {
+        entry: {
+            messageId: parsed.ref,
+            topic: entry.topic,
+            summary: entry.summary,
+        },
+        selection,
+        anchorMessageId: resolveAnchorMessageId(startReference),
+    }
+}

package/lib/compress/message.ts

@@ -0,0 +1,145 @@
+import { tool } from "@opencode-ai/plugin"
+import type { ToolContext } from "./types"
+import { countTokens } from "../token-utils"
+import { MESSAGE_FORMAT_EXTENSION } from "../prompts/extensions/tool"
+import { formatIssues, formatResult, resolveMessages, validateArgs } from "./message-utils"
+import { finalizeSession, prepareSession, type NotificationEntry } from "./pipeline"
+import { appendProtectedPromptInfo, appendProtectedTools } from "./protected-content"
+import {
+    allocateBlockId,
+    allocateRunId,
+    applyCompressionState,
+    wrapCompressedSummary,
+} from "./state"
+import type { CompressMessageToolArgs } from "./types"
+
+function buildSchema() {
+    return {
+        topic: tool.schema
+            .string()
+            .describe(
+                "Short label (3-5 words) for the overall batch - e.g., 'Closed Research Notes'",
+            ),
+        content: tool.schema
+            .array(
+                tool.schema.object({
+                    messageId: tool.schema
+                        .string()
+                        .describe("Raw message ID to compress (e.g. m0001)"),
+                    topic: tool.schema
+                        .string()
+                        .describe("Short label (3-5 words) for this one message summary"),
+                    summary: tool.schema
+                        .string()
+                        .describe("Complete technical summary replacing that one message"),
+                }),
+            )
+            .describe("Batch of individual message summaries to create in one tool call"),
+    }
+}
+
+export function createCompressMessageTool(ctx: ToolContext): ReturnType<typeof tool> {
+    ctx.prompts.reload()
+    const runtimePrompts = ctx.prompts.getRuntimePrompts()
+
+    return tool({
+        description: runtimePrompts.compressMessage + MESSAGE_FORMAT_EXTENSION,
+        args: buildSchema(),
+        async execute(args, toolCtx) {
+            const input = args as CompressMessageToolArgs
+            validateArgs(input)
+            const callId =
+                typeof (toolCtx as unknown as { callID?: unknown }).callID === "string"
+                    ? (toolCtx as unknown as { callID: string }).callID
+                    : undefined
+
+            const { rawMessages, searchContext } = await prepareSession(
+                ctx,
+                toolCtx,
+                `Compress Message: ${input.topic}`,
+            )
+            const { plans, skippedIssues, skippedCount } = resolveMessages(
+                input,
+                searchContext,
+                ctx.state,
+                ctx.config,
+            )
+
+            if (plans.length === 0 && skippedCount > 0) {
+                throw new Error(formatIssues(skippedIssues, skippedCount))
+            }
+
+            const notifications: NotificationEntry[] = []
+
+            const preparedPlans: Array<{
+                plan: (typeof plans)[number]
+                summaryWithTools: string
+            }> = []
+
+            for (const plan of plans) {
+                const summaryWithPromptInfo = appendProtectedPromptInfo(
+                    plan.entry.summary,
+                    plan.selection,
+                    searchContext,
+                    ctx.state,
+                    ctx.config.compress.protectTags,
+                )
+
+                const summaryWithTools = await appendProtectedTools(
+                    ctx.client,
+                    ctx.state,
+                    ctx.config.experimental.allowSubAgents,
+                    summaryWithPromptInfo,
+                    plan.selection,
+                    searchContext,
+                    ctx.config.compress.protectedTools,
+                    ctx.config.protectedFilePatterns,
+                )
+
+                preparedPlans.push({
+                    plan,
+                    summaryWithTools,
+                })
+            }
+
+            const runId = allocateRunId(ctx.state)
+
+            for (const { plan, summaryWithTools } of preparedPlans) {
+                const blockId = allocateBlockId(ctx.state)
+                const storedSummary = wrapCompressedSummary(blockId, summaryWithTools)
+                const summaryTokens = countTokens(storedSummary)
+
+                applyCompressionState(
+                    ctx.state,
+                    {
+                        topic: plan.entry.topic,
+                        batchTopic: input.topic,
+                        startId: plan.entry.messageId,
+                        endId: plan.entry.messageId,
+                        mode: "message",
+                        runId,
+                        compressMessageId: toolCtx.messageID,
+                        compressCallId: callId,
+                        summaryTokens,
+                    },
+                    plan.selection,
+                    plan.anchorMessageId,
+                    blockId,
+                    storedSummary,
+                    [],
+                )
+
+                notifications.push({
+                    blockId,
+                    runId,
+                    summary: summaryWithTools,
+                    summaryTokens,
+                })
+            }
+
+            await finalizeSession(ctx, toolCtx, rawMessages, notifications, input.topic)
+
+            return formatResult(plans.length, skippedIssues, skippedCount)
+        },
+    })
+}