@royalcat/opencode-dcp-rc 0.0.0-stage → 4.0.1

package/lib/commands/help.ts

@@ -0,0 +1,76 @@
+/**
+ * DCP Help command handler.
+ * Shows available DCP commands and their descriptions.
+ */
+
+import type { Logger } from "../logger"
+import type { PluginConfig } from "../config"
+import type { SessionState, WithParts } from "../state"
+import { compressPermission } from "../compress-permission"
+import { sendIgnoredMessage } from "../ui/notification"
+import { getCurrentParams } from "../token-utils"
+
+export interface HelpCommandContext {
+    client: any
+    state: SessionState
+    config: PluginConfig
+    logger: Logger
+    sessionId: string
+    messages: WithParts[]
+}
+
+const TUI_COMMANDS: [string, string][] = [
+    ["DCP Context", "Show token usage breakdown for current session"],
+    ["DCP Stats", "Show DCP pruning statistics"],
+    ["DCP Help", "Show this help in a modal"],
+]
+
+const TOOL_COMMANDS: Record<string, [string, string]> = {
+    compress: ["/dcp-compress [focus]", "Trigger manual compress tool execution"],
+    decompress: ["/dcp decompress <n>", "Restore selected compression"],
+    recompress: ["/dcp recompress <n>", "Re-apply a user-decompressed compression"],
+}
+
+function getVisibleCommands(state: SessionState, config: PluginConfig): [string, string][] {
+    const commands = [...TUI_COMMANDS]
+
+    if (compressPermission(state, config) !== "deny") {
+        commands.push(TOOL_COMMANDS.compress)
+    }
+
+    return commands
+}
+
+export function formatHelpMessage(state: SessionState, config: PluginConfig): string {
+    const commands = getVisibleCommands(state, config)
+    const colWidth = Math.max(...commands.map(([cmd]) => cmd.length)) + 4
+    const lines: string[] = []
+
+    lines.push("╭─────────────────────────────────────────────────────────────────────────╮")
+    lines.push("│                              DCP Commands                               │")
+    lines.push("╰─────────────────────────────────────────────────────────────────────────╯")
+    lines.push("")
+    lines.push(`  ${"Manual mode:".padEnd(colWidth)}${state.manualMode ? "ON" : "OFF"}`)
+    lines.push("")
+    lines.push("  Open the command palette for DCP modal commands.")
+    lines.push("  Use /dcp-compress [focus] when you want DCP to ask the model to run compression.")
+    lines.push("")
+    for (const [cmd, desc] of commands) {
+        lines.push(`  ${cmd.padEnd(colWidth)}${desc}`)
+    }
+    lines.push("")
+
+    return lines.join("\n")
+}
+
+export async function handleHelpCommand(ctx: HelpCommandContext): Promise<void> {
+    const { client, state, logger, sessionId, messages } = ctx
+
+    const { config } = ctx
+    const message = formatHelpMessage(state, config)
+
+    const params = getCurrentParams(state, messages, logger)
+    await sendIgnoredMessage(client, sessionId, message, params, logger)
+
+    logger.info("Help command executed")
+}

package/lib/commands/index.ts

@@ -0,0 +1,11 @@
+export { handleContextCommand } from "./context"
+export { handleDecompressCommand } from "./decompress"
+export { handleHelpCommand } from "./help"
+export {
+    applyPendingManualTrigger,
+    handleManualToggleCommand,
+    handleManualTriggerCommand,
+} from "./manual"
+export { handleRecompressCommand } from "./recompress"
+export { handleStatsCommand } from "./stats"
+export { handleSweepCommand } from "./sweep"

package/lib/commands/manual.ts

@@ -0,0 +1,126 @@
+/**
+ * DCP Manual mode command handler.
+ * Handles toggling manual mode and triggering individual tool executions.
+ *
+ * Usage:
+ *   /dcp manual [on|off]  - Toggle manual mode or set explicit state
+ *   /dcp-compress [focus]  - Trigger manual compress execution
+ */
+
+import type { Logger } from "../logger"
+import type { SessionState, WithParts } from "../state"
+import type { PluginConfig } from "../config"
+import { sendIgnoredMessage } from "../ui/notification"
+import { saveManualModeSetting } from "../state/persistence"
+import { getCurrentParams } from "../token-utils"
+import { buildCompressedBlockGuidance } from "../prompts/extensions/nudge"
+import { isIgnoredUserMessage } from "../messages/query"
+
+const MANUAL_MODE_ON = "Manual mode is now ON. Use /dcp-compress to trigger context tools manually."
+
+const MANUAL_MODE_OFF = "Manual mode is now OFF."
+
+const COMPRESS_TRIGGER_PROMPT = [
+    "<compress triggered manually>",
+    "Manual mode trigger received. You must now use the compress tool.",
+    "Find the most significant completed conversation content that can be compressed into a high-fidelity technical summary.",
+    "Follow the active compress mode, preserve all critical implementation details, and choose safe targets.",
+    "Return after compress with a brief explanation of what content was compressed.",
+].join("\n\n")
+
+function getTriggerPrompt(
+    tool: "compress",
+    state: SessionState,
+    config: PluginConfig,
+    userFocus?: string,
+): string {
+    const base = COMPRESS_TRIGGER_PROMPT
+    const compressedBlockGuidance = buildCompressedBlockGuidance(state)
+
+    const sections = [base, compressedBlockGuidance]
+    if (userFocus && userFocus.trim().length > 0) {
+        sections.push(`Additional user focus:\n${userFocus.trim()}`)
+    }
+
+    return sections.join("\n\n")
+}
+
+export interface ManualCommandContext {
+    client: any
+    state: SessionState
+    config: PluginConfig
+    logger: Logger
+    sessionId: string
+    messages: WithParts[]
+}
+
+export async function handleManualToggleCommand(
+    ctx: ManualCommandContext,
+    modeArg?: string,
+): Promise<void> {
+    const { client, state, logger, sessionId, messages } = ctx
+
+    if (modeArg === "on") {
+        state.manualMode = "active"
+    } else if (modeArg === "off") {
+        state.manualMode = false
+    } else {
+        state.manualMode = state.manualMode ? false : "active"
+    }
+
+    const params = getCurrentParams(state, messages, logger)
+    await sendIgnoredMessage(
+        client,
+        sessionId,
+        state.manualMode ? MANUAL_MODE_ON : MANUAL_MODE_OFF,
+        params,
+        logger,
+    )
+    await saveManualModeSetting(sessionId, !!state.manualMode, logger)
+
+    logger.info("Manual mode toggled", { manualMode: state.manualMode })
+}
+
+export async function handleManualTriggerCommand(
+    ctx: ManualCommandContext,
+    tool: "compress",
+    userFocus?: string,
+): Promise<string | null> {
+    return getTriggerPrompt(tool, ctx.state, ctx.config, userFocus)
+}
+
+export function applyPendingManualTrigger(
+    state: SessionState,
+    messages: WithParts[],
+    logger: Logger,
+): void {
+    const pending = state.pendingManualTrigger
+    if (!pending) {
+        return
+    }
+
+    if (!state.sessionId || pending.sessionId !== state.sessionId) {
+        state.pendingManualTrigger = null
+        return
+    }
+
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i]
+        if (msg.info.role !== "user" || isIgnoredUserMessage(msg)) {
+            continue
+        }
+
+        for (const part of msg.parts) {
+            if (part.type !== "text" || part.ignored || part.synthetic) {
+                continue
+            }
+
+            part.text = pending.prompt
+            state.pendingManualTrigger = null
+            logger.debug("Applied manual prompt", { sessionId: pending.sessionId })
+            return
+        }
+    }
+
+    state.pendingManualTrigger = null
+}

package/lib/commands/recompress.ts

@@ -0,0 +1,222 @@
+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) ?? parseBlockRef(normalized, "compact")
+    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) {
+        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 = `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,180 @@
+/**
+ * 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 { normalizeCompressionUsageTotals, type CompressionUsageTotals } from "../compress/usage"
+import { getActiveCompressionTargets } from "./compression-targets"
+
+export interface StatsCommandContext {
+    client: any
+    state: SessionState
+    logger: Logger
+    sessionId: string
+    messages: WithParts[]
+}
+
+export function formatStatsMessage(
+    sessionTokens: number,
+    sessionSummaryTokens: number,
+    sessionTools: number,
+    sessionMessages: number,
+    sessionDurationMs: number,
+    sessionUsage: CompressionUsageTotals,
+    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(
+        `  Summary requests: ${sessionUsage.calls} (${sessionUsage.providerCalls} provider, ${sessionUsage.estimatedCalls} estimated)`,
+    )
+    lines.push(
+        `  Request in|out:   ~${formatTokenCount(sessionUsage.inputTokens)} | ~${formatTokenCount(sessionUsage.outputTokens)}`,
+    )
+    lines.push(
+        `  Request cache:    ~${formatTokenCount(sessionUsage.cacheReadTokens)} read | ~${formatTokenCount(sessionUsage.cacheWriteTokens)} write`,
+    )
+    lines.push(`  Request reason:   ~${formatTokenCount(sessionUsage.reasoningTokens)}`)
+    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}`)
+    lines.push(
+        `  Summary requests: ${allTime.compressionUsage.calls} (~${formatTokenCount(allTime.compressionUsage.inputTokens)} in | ~${formatTokenCount(allTime.compressionUsage.outputTokens)} out)`,
+    )
+
+    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
+
+    const report = await buildStatsReport(state, logger)
+    const message = formatStatsMessage(
+        report.sessionTokens,
+        report.sessionSummaryTokens,
+        report.sessionTools,
+        report.sessionMessages,
+        report.sessionDurationMs,
+        report.sessionCompressionUsage,
+        report.allTime,
+    )
+
+    const params = getCurrentParams(state, messages, logger)
+    await sendIgnoredMessage(client, sessionId, message, params, logger)
+
+    logger.info("Stats command executed", {
+        sessionTokens: report.sessionTokens,
+        sessionSummaryTokens: report.sessionSummaryTokens,
+        sessionTools: report.sessionTools,
+        sessionMessages: report.sessionMessages,
+        sessionDurationMs: report.sessionDurationMs,
+        sessionCompressionUsage: report.sessionCompressionUsage,
+        allTimeTokens: report.allTime.totalTokens,
+        allTimeTools: report.allTime.totalTools,
+        allTimeMessages: report.allTime.totalMessages,
+        allTimeCompressionUsage: report.allTime.compressionUsage,
+    })
+}
+
+export async function buildStatsReport(state: SessionState, logger: Logger) {
+    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
+
+    const sessionCompressionUsage = normalizeCompressionUsageTotals(state.stats.compressionUsage)
+
+    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)
+
+    return {
+        sessionTokens,
+        sessionSummaryTokens,
+        sessionTools,
+        sessionMessages,
+        sessionDurationMs,
+        sessionCompressionUsage,
+        allTime,
+    }
+}