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

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-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,
+    )
+}

package/lib/config.ts

@@ -1,7 +1,7 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync } from "fs"
 import { join, dirname } from "path"
 import { homedir } from "os"
-import { parse } from "jsonc-parser"
+import * as jsoncParser from "jsonc-parser"
 import type { PluginInput } from "@opencode-ai/plugin"
 
 type Permission = "ask" | "allow" | "deny"
@@ -824,7 +824,7 @@ function loadConfigFile(configPath: string): ConfigLoadResult {
     }
 
     try {
-        const parsed = parse(fileContent, undefined, { allowTrailingComma: true })
+        const parsed = jsoncParser.parse(fileContent, undefined, { allowTrailingComma: true })
         if (parsed === undefined || parsed === null) {
             return { data: null, parseError: "Config file is empty or invalid" }
         }

package/lib/hooks.ts

@@ -0,0 +1,378 @@
+import type { SessionState, WithParts } from "./state"
+import type { Logger } from "./logger"
+import type { PluginConfig } from "./config"
+import { assignMessageRefs } from "./message-ids"
+import {
+    buildPriorityMap,
+    buildToolIdList,
+    injectCompressNudges,
+    injectExtendedSubAgentResults,
+    injectMessageIds,
+    prune,
+    stripHallucinations,
+    stripHallucinationsFromString,
+    stripStaleMetadata,
+    syncCompressionBlocks,
+} from "./messages"
+import { renderSystemPrompt, type PromptStore } from "./prompts"
+import { buildProtectedToolsExtension } from "./prompts/extensions/system"
+import {
+    applyPendingCompressionDurations,
+    buildCompressionTimingKey,
+    consumeCompressionStart,
+    resolveCompressionDuration,
+} from "./compress/timing"
+import {
+    applyPendingManualTrigger,
+    handleContextCommand,
+    handleDecompressCommand,
+    handleHelpCommand,
+    handleManualToggleCommand,
+    handleManualTriggerCommand,
+    handleRecompressCommand,
+    handleStatsCommand,
+    handleSweepCommand,
+} from "./commands"
+import { type HostPermissionSnapshot } from "./host-permissions"
+import { compressPermission, syncCompressPermissionState } from "./compress-permission"
+import { checkSession, ensureSessionInitialized, saveSessionState, syncToolCache } from "./state"
+import { cacheSystemPromptTokens } from "./ui/utils"
+
+const INTERNAL_AGENT_SIGNATURES = [
+    "You are a title generator",
+    "You are a helpful AI assistant tasked with summarizing conversations",
+    "Summarize what was done in this conversation",
+]
+
+export function createSystemPromptHandler(
+    state: SessionState,
+    logger: Logger,
+    config: PluginConfig,
+    prompts: PromptStore,
+) {
+    return async (
+        input: { sessionID?: string; model: { limit: { context: number } } },
+        output: { system: string[] },
+    ) => {
+        if (input.model?.limit?.context) {
+            state.modelContextLimit = input.model.limit.context
+            logger.debug("Cached model context limit", { limit: state.modelContextLimit })
+        }
+
+        if (state.isSubAgent && !config.experimental.allowSubAgents) {
+            return
+        }
+
+        const systemText = output.system.join("\n")
+        if (INTERNAL_AGENT_SIGNATURES.some((sig) => systemText.includes(sig))) {
+            logger.info("Skipping DCP system prompt injection for internal agent")
+            return
+        }
+
+        const effectivePermission =
+            input.sessionID && state.sessionId === input.sessionID
+                ? compressPermission(state, config)
+                : config.compress.permission
+
+        if (effectivePermission === "deny") {
+            return
+        }
+
+        prompts.reload()
+        const runtimePrompts = prompts.getRuntimePrompts()
+        const newPrompt = renderSystemPrompt(
+            runtimePrompts,
+            buildProtectedToolsExtension(config.compress.protectedTools),
+            !!state.manualMode,
+            state.isSubAgent && config.experimental.allowSubAgents,
+        )
+        if (output.system.length > 0) {
+            output.system[output.system.length - 1] += "\n\n" + newPrompt
+        } else {
+            output.system.push(newPrompt)
+        }
+    }
+}
+
+export function createChatMessageTransformHandler(
+    client: any,
+    state: SessionState,
+    logger: Logger,
+    config: PluginConfig,
+    prompts: PromptStore,
+    hostPermissions: HostPermissionSnapshot,
+) {
+    return async (input: {}, output: { messages: WithParts[] }) => {
+        await checkSession(client, state, logger, output.messages, config.manualMode.enabled)
+
+        syncCompressPermissionState(state, config, hostPermissions, output.messages)
+
+        if (state.isSubAgent && !config.experimental.allowSubAgents) {
+            return
+        }
+
+        stripHallucinations(output.messages)
+        cacheSystemPromptTokens(state, output.messages)
+        assignMessageRefs(state, output.messages)
+        syncCompressionBlocks(state, logger, output.messages)
+        syncToolCache(state, config, logger, output.messages)
+        buildToolIdList(state, output.messages)
+        prune(state, logger, config, output.messages)
+        await injectExtendedSubAgentResults(
+            client,
+            state,
+            logger,
+            output.messages,
+            config.experimental.allowSubAgents,
+        )
+        const compressionPriorities = buildPriorityMap(config, state, output.messages)
+        prompts.reload()
+        injectCompressNudges(
+            state,
+            config,
+            logger,
+            output.messages,
+            prompts.getRuntimePrompts(),
+            compressionPriorities,
+        )
+        injectMessageIds(state, config, output.messages, compressionPriorities)
+        applyPendingManualTrigger(state, output.messages, logger)
+        stripStaleMetadata(output.messages)
+
+        if (state.sessionId) {
+            await logger.saveContext(state.sessionId, output.messages)
+        }
+    }
+}
+
+export function createCommandExecuteHandler(
+    client: any,
+    state: SessionState,
+    logger: Logger,
+    config: PluginConfig,
+    workingDirectory: string,
+    hostPermissions: HostPermissionSnapshot,
+) {
+    return async (
+        input: { command: string; sessionID: string; arguments: string },
+        output: { parts: any[] },
+    ) => {
+        if (!config.commands.enabled) {
+            return
+        }
+
+        if (input.command === "dcp") {
+            const messagesResponse = await client.session.messages({
+                path: { id: input.sessionID },
+            })
+            const messages = (messagesResponse.data || messagesResponse) as WithParts[]
+
+            await ensureSessionInitialized(
+                client,
+                state,
+                input.sessionID,
+                logger,
+                messages,
+                config.manualMode.enabled,
+            )
+
+            syncCompressPermissionState(state, config, hostPermissions, messages)
+
+            const effectivePermission = compressPermission(state, config)
+            if (effectivePermission === "deny") {
+                return
+            }
+
+            const args = (input.arguments || "").trim().split(/\s+/).filter(Boolean)
+            const subcommand = args[0]?.toLowerCase() || ""
+            const subArgs = args.slice(1)
+
+            const commandCtx = {
+                client,
+                state,
+                config,
+                logger,
+                sessionId: input.sessionID,
+                messages,
+            }
+
+            if (subcommand === "context") {
+                await handleContextCommand(commandCtx)
+                throw new Error("__DCP_CONTEXT_HANDLED__")
+            }
+
+            if (subcommand === "stats") {
+                await handleStatsCommand(commandCtx)
+                throw new Error("__DCP_STATS_HANDLED__")
+            }
+
+            if (subcommand === "sweep") {
+                await handleSweepCommand({
+                    ...commandCtx,
+                    args: subArgs,
+                    workingDirectory,
+                })
+                throw new Error("__DCP_SWEEP_HANDLED__")
+            }
+
+            if (subcommand === "manual") {
+                await handleManualToggleCommand(commandCtx, subArgs[0]?.toLowerCase())
+                throw new Error("__DCP_MANUAL_HANDLED__")
+            }
+
+            if (subcommand === "compress") {
+                const userFocus = subArgs.join(" ").trim()
+                const prompt = await handleManualTriggerCommand(commandCtx, "compress", userFocus)
+                if (!prompt) {
+                    throw new Error("__DCP_MANUAL_TRIGGER_BLOCKED__")
+                }
+
+                state.manualMode = "compress-pending"
+                state.pendingManualTrigger = {
+                    sessionId: input.sessionID,
+                    prompt,
+                }
+                const rawArgs = (input.arguments || "").trim()
+                output.parts.length = 0
+                output.parts.push({
+                    type: "text",
+                    text: rawArgs ? `/dcp ${rawArgs}` : `/dcp ${subcommand}`,
+                })
+                return
+            }
+
+            if (subcommand === "decompress") {
+                await handleDecompressCommand({
+                    ...commandCtx,
+                    args: subArgs,
+                })
+                throw new Error("__DCP_DECOMPRESS_HANDLED__")
+            }
+
+            if (subcommand === "recompress") {
+                await handleRecompressCommand({
+                    ...commandCtx,
+                    args: subArgs,
+                })
+                throw new Error("__DCP_RECOMPRESS_HANDLED__")
+            }
+
+            await handleHelpCommand(commandCtx)
+            throw new Error("__DCP_HELP_HANDLED__")
+        }
+    }
+}
+
+export function createTextCompleteHandler() {
+    return async (
+        _input: { sessionID: string; messageID: string; partID: string },
+        output: { text: string },
+    ) => {
+        output.text = stripHallucinationsFromString(output.text)
+    }
+}
+
+export function createEventHandler(state: SessionState, logger: Logger) {
+    return async (input: { event: any }) => {
+        const eventTime =
+            typeof input.event?.time === "number" && Number.isFinite(input.event.time)
+                ? input.event.time
+                : typeof input.event?.properties?.time === "number" &&
+                    Number.isFinite(input.event.properties.time)
+                  ? input.event.properties.time
+                  : undefined
+
+        if (input.event.type !== "message.part.updated") {
+            return
+        }
+
+        const part = input.event.properties?.part
+        if (part?.type !== "tool" || part.tool !== "compress") {
+            return
+        }
+
+        if (part.state.status === "pending") {
+            if (typeof part.callID !== "string" || typeof part.messageID !== "string") {
+                return
+            }
+
+            const startedAt = eventTime ?? Date.now()
+            const key = buildCompressionTimingKey(part.messageID, part.callID)
+            if (state.compressionTiming.startsByCallId.has(key)) {
+                return
+            }
+            state.compressionTiming.startsByCallId.set(key, startedAt)
+            logger.debug("Recorded compression start", {
+                messageID: part.messageID,
+                callID: part.callID,
+                startedAt,
+            })
+            return
+        }
+
+        if (part.state.status === "completed") {
+            if (typeof part.callID !== "string" || typeof part.messageID !== "string") {
+                return
+            }
+
+            const key = buildCompressionTimingKey(part.messageID, part.callID)
+            const start = consumeCompressionStart(state, part.messageID, part.callID)
+            const durationMs = resolveCompressionDuration(start, eventTime, part.state.time)
+            if (typeof durationMs !== "number") {
+                return
+            }
+
+            state.compressionTiming.pendingByCallId.set(key, {
+                messageId: part.messageID,
+                callId: part.callID,
+                durationMs,
+            })
+
+            const updates = applyPendingCompressionDurations(state)
+            if (updates === 0) {
+                return
+            }
+
+            await saveSessionState(state, logger)
+
+            logger.info("Attached compression time to blocks", {
+                messageID: part.messageID,
+                callID: part.callID,
+                blocks: updates,
+                durationMs,
+            })
+            return
+        }
+
+        if (part.state.status === "running") {
+            return
+        }
+
+        if (typeof part.callID === "string" && typeof part.messageID === "string") {
+            state.compressionTiming.startsByCallId.delete(
+                buildCompressionTimingKey(part.messageID, part.callID),
+            )
+        }
+    }
+}
+
+export function createChatMessageHandler(
+    state: SessionState,
+    logger: Logger,
+    _config: PluginConfig,
+    _hostPermissions: HostPermissionSnapshot,
+) {
+    return async (
+        input: {
+            sessionID: string
+            agent?: string
+            model?: { providerID: string; modelID: string }
+            messageID?: string
+            variant?: string
+        },
+        _output: any,
+    ) => {
+        state.variant = input.variant
+        logger.debug("Cached variant from chat.message hook", { variant: input.variant })
+    }
+}