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

package/lib/state/utils.ts

@@ -1,334 +0,0 @@
-import type {
-    CompressionBlock,
-    PruneMessagesState,
-    PrunedMessageEntry,
-    SessionState,
-    WithParts,
-} from "./types"
-import { isIgnoredUserMessage, messageHasCompress } from "../messages/query"
-import { countTokens } from "../token-utils"
-
-export const isMessageCompacted = (state: SessionState, msg: WithParts): boolean => {
-    if (msg.info.time.created < state.lastCompaction) {
-        return true
-    }
-    const pruneEntry = state.prune.messages.byMessageId.get(msg.info.id)
-    if (pruneEntry && pruneEntry.activeBlockIds.length > 0) {
-        return true
-    }
-    return false
-}
-
-interface PersistedPruneMessagesState {
-    byMessageId: Record<string, PrunedMessageEntry>
-    blocksById: Record<string, CompressionBlock>
-    activeBlockIds: number[]
-    activeByAnchorMessageId: Record<string, number>
-    nextBlockId: number
-    nextRunId: number
-}
-
-export function serializePruneMessagesState(
-    messagesState: PruneMessagesState,
-): PersistedPruneMessagesState {
-    return {
-        byMessageId: Object.fromEntries(messagesState.byMessageId),
-        blocksById: Object.fromEntries(
-            Array.from(messagesState.blocksById.entries()).map(([blockId, block]) => [
-                String(blockId),
-                block,
-            ]),
-        ),
-        activeBlockIds: Array.from(messagesState.activeBlockIds),
-        activeByAnchorMessageId: Object.fromEntries(messagesState.activeByAnchorMessageId),
-        nextBlockId: messagesState.nextBlockId,
-        nextRunId: messagesState.nextRunId,
-    }
-}
-
-export async function isSubAgentSession(client: any, sessionID: string): Promise<boolean> {
-    try {
-        const result = await client.session.get({ path: { id: sessionID } })
-        return !!result.data?.parentID
-    } catch (error: any) {
-        return false
-    }
-}
-
-export function findLastCompactionTimestamp(messages: WithParts[]): number {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const msg = messages[i]
-        if (msg.info.role === "assistant" && msg.info.summary === true) {
-            return msg.info.time.created
-        }
-    }
-    return 0
-}
-
-export function countTurns(state: SessionState, messages: WithParts[]): number {
-    let turnCount = 0
-    for (const msg of messages) {
-        if (isMessageCompacted(state, msg)) {
-            continue
-        }
-        const parts = Array.isArray(msg.parts) ? msg.parts : []
-        for (const part of parts) {
-            if (part.type === "step-start") {
-                turnCount++
-            }
-        }
-    }
-    return turnCount
-}
-
-export function loadPruneMap(obj?: Record<string, number>): Map<string, number> {
-    if (!obj || typeof obj !== "object") {
-        return new Map()
-    }
-
-    const entries = Object.entries(obj).filter(
-        (entry): entry is [string, number] =>
-            typeof entry[0] === "string" && typeof entry[1] === "number",
-    )
-    return new Map(entries)
-}
-
-export function createPruneMessagesState(): PruneMessagesState {
-    return {
-        byMessageId: new Map<string, PrunedMessageEntry>(),
-        blocksById: new Map<number, CompressionBlock>(),
-        activeBlockIds: new Set<number>(),
-        activeByAnchorMessageId: new Map<string, number>(),
-        nextBlockId: 1,
-        nextRunId: 1,
-    }
-}
-
-export function loadPruneMessagesState(
-    persisted?: PersistedPruneMessagesState,
-): PruneMessagesState {
-    const state = createPruneMessagesState()
-    if (!persisted || typeof persisted !== "object") {
-        return state
-    }
-
-    if (typeof persisted.nextBlockId === "number" && Number.isInteger(persisted.nextBlockId)) {
-        state.nextBlockId = Math.max(1, persisted.nextBlockId)
-    }
-    if (typeof persisted.nextRunId === "number" && Number.isInteger(persisted.nextRunId)) {
-        state.nextRunId = Math.max(1, persisted.nextRunId)
-    }
-
-    if (persisted.byMessageId && typeof persisted.byMessageId === "object") {
-        for (const [messageId, entry] of Object.entries(persisted.byMessageId)) {
-            if (!entry || typeof entry !== "object") {
-                continue
-            }
-
-            const tokenCount = typeof entry.tokenCount === "number" ? entry.tokenCount : 0
-            const allBlockIds = Array.isArray(entry.allBlockIds)
-                ? [
-                      ...new Set(
-                          entry.allBlockIds.filter(
-                              (id): id is number => Number.isInteger(id) && id > 0,
-                          ),
-                      ),
-                  ]
-                : []
-            const activeBlockIds = Array.isArray(entry.activeBlockIds)
-                ? [
-                      ...new Set(
-                          entry.activeBlockIds.filter(
-                              (id): id is number => Number.isInteger(id) && id > 0,
-                          ),
-                      ),
-                  ]
-                : []
-
-            state.byMessageId.set(messageId, {
-                tokenCount,
-                allBlockIds,
-                activeBlockIds,
-            })
-        }
-    }
-
-    if (persisted.blocksById && typeof persisted.blocksById === "object") {
-        for (const [blockIdStr, block] of Object.entries(persisted.blocksById)) {
-            const blockId = Number.parseInt(blockIdStr, 10)
-            if (!Number.isInteger(blockId) || blockId < 1 || !block || typeof block !== "object") {
-                continue
-            }
-
-            const toNumberArray = (value: unknown): number[] =>
-                Array.isArray(value)
-                    ? [
-                          ...new Set(
-                              value.filter(
-                                  (item): item is number => Number.isInteger(item) && item > 0,
-                              ),
-                          ),
-                      ]
-                    : []
-            const toStringArray = (value: unknown): string[] =>
-                Array.isArray(value)
-                    ? [...new Set(value.filter((item): item is string => typeof item === "string"))]
-                    : []
-
-            state.blocksById.set(blockId, {
-                blockId,
-                runId:
-                    typeof block.runId === "number" &&
-                    Number.isInteger(block.runId) &&
-                    block.runId > 0
-                        ? block.runId
-                        : blockId,
-                active: block.active === true,
-                deactivatedByUser: block.deactivatedByUser === true,
-                compressedTokens:
-                    typeof block.compressedTokens === "number" &&
-                    Number.isFinite(block.compressedTokens)
-                        ? Math.max(0, block.compressedTokens)
-                        : 0,
-                summaryTokens:
-                    typeof block.summaryTokens === "number" && Number.isFinite(block.summaryTokens)
-                        ? Math.max(0, block.summaryTokens)
-                        : typeof block.summary === "string"
-                          ? countTokens(block.summary)
-                          : 0,
-                durationMs:
-                    typeof block.durationMs === "number" && Number.isFinite(block.durationMs)
-                        ? Math.max(0, block.durationMs)
-                        : 0,
-                mode: block.mode === "range" || block.mode === "message" ? block.mode : undefined,
-                topic: typeof block.topic === "string" ? block.topic : "",
-                batchTopic:
-                    typeof block.batchTopic === "string"
-                        ? block.batchTopic
-                        : typeof block.topic === "string"
-                          ? block.topic
-                          : "",
-                startId: typeof block.startId === "string" ? block.startId : "",
-                endId: typeof block.endId === "string" ? block.endId : "",
-                anchorMessageId:
-                    typeof block.anchorMessageId === "string" ? block.anchorMessageId : "",
-                compressMessageId:
-                    typeof block.compressMessageId === "string" ? block.compressMessageId : "",
-                compressCallId:
-                    typeof block.compressCallId === "string" ? block.compressCallId : undefined,
-                includedBlockIds: toNumberArray(block.includedBlockIds),
-                consumedBlockIds: toNumberArray(block.consumedBlockIds),
-                parentBlockIds: toNumberArray(block.parentBlockIds),
-                directMessageIds: toStringArray(block.directMessageIds),
-                directToolIds: toStringArray(block.directToolIds),
-                effectiveMessageIds: toStringArray(block.effectiveMessageIds),
-                effectiveToolIds: toStringArray(block.effectiveToolIds),
-                createdAt: typeof block.createdAt === "number" ? block.createdAt : 0,
-                deactivatedAt:
-                    typeof block.deactivatedAt === "number" ? block.deactivatedAt : undefined,
-                deactivatedByBlockId:
-                    typeof block.deactivatedByBlockId === "number" &&
-                    Number.isInteger(block.deactivatedByBlockId)
-                        ? block.deactivatedByBlockId
-                        : undefined,
-                summary: typeof block.summary === "string" ? block.summary : "",
-            })
-        }
-    }
-
-    if (Array.isArray(persisted.activeBlockIds)) {
-        for (const blockId of persisted.activeBlockIds) {
-            if (!Number.isInteger(blockId) || blockId < 1) {
-                continue
-            }
-            state.activeBlockIds.add(blockId)
-        }
-    }
-
-    if (
-        persisted.activeByAnchorMessageId &&
-        typeof persisted.activeByAnchorMessageId === "object"
-    ) {
-        for (const [anchorMessageId, blockId] of Object.entries(
-            persisted.activeByAnchorMessageId,
-        )) {
-            if (typeof blockId !== "number" || !Number.isInteger(blockId) || blockId < 1) {
-                continue
-            }
-            state.activeByAnchorMessageId.set(anchorMessageId, blockId)
-        }
-    }
-
-    for (const [blockId, block] of state.blocksById) {
-        if (block.active) {
-            state.activeBlockIds.add(blockId)
-            if (block.anchorMessageId) {
-                state.activeByAnchorMessageId.set(block.anchorMessageId, blockId)
-            }
-        }
-        if (blockId >= state.nextBlockId) {
-            state.nextBlockId = blockId + 1
-        }
-        if (block.runId >= state.nextRunId) {
-            state.nextRunId = block.runId + 1
-        }
-    }
-
-    return state
-}
-
-export function collectTurnNudgeAnchors(messages: WithParts[]): Set<string> {
-    const anchors = new Set<string>()
-    let pendingUserMessageId: string | null = null
-
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const message = messages[i]
-
-        if (messageHasCompress(message)) {
-            break
-        }
-
-        if (message.info.role === "user") {
-            if (!isIgnoredUserMessage(message)) {
-                pendingUserMessageId = message.info.id
-            }
-            continue
-        }
-
-        if (message.info.role === "assistant" && pendingUserMessageId) {
-            anchors.add(message.info.id)
-            anchors.add(pendingUserMessageId)
-            pendingUserMessageId = null
-        }
-    }
-
-    return anchors
-}
-
-export function getActiveSummaryTokenUsage(state: SessionState): number {
-    let total = 0
-    for (const blockId of state.prune.messages.activeBlockIds) {
-        const block = state.prune.messages.blocksById.get(blockId)
-        if (!block || !block.active) {
-            continue
-        }
-        total += block.summaryTokens
-    }
-    return total
-}
-
-export function resetOnCompaction(state: SessionState): void {
-    state.toolParameters.clear()
-    state.prune.tools = new Map<string, number>()
-    state.prune.messages = createPruneMessagesState()
-    state.messageIds = {
-        byRawId: new Map<string, string>(),
-        byRef: new Map<string, string>(),
-        nextRef: 1,
-    }
-    state.nudges = {
-        contextLimitAnchors: new Set<string>(),
-        turnNudgeAnchors: new Set<string>(),
-        iterationNudgeAnchors: new Set<string>(),
-    }
-}

package/lib/token-utils.ts

@@ -1,162 +0,0 @@
-import { SessionState, WithParts } from "./state"
-import { AssistantMessage, UserMessage } from "@opencode-ai/sdk/v2"
-import { Logger } from "./logger"
-import { countTokens as anthropicCountTokens } from "@anthropic-ai/tokenizer"
-import { getLastUserMessage } from "./messages/query"
-
-export function getCurrentTokenUsage(state: SessionState, messages: WithParts[]): number {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const msg = messages[i]
-        if (msg.info.role !== "assistant") {
-            continue
-        }
-
-        const assistantInfo = msg.info as AssistantMessage
-        if ((assistantInfo.tokens?.output || 0) <= 0) {
-            continue
-        }
-
-        if (
-            state.lastCompaction > 0 &&
-            (msg.info.time.created < state.lastCompaction ||
-                (msg.info.summary === true && msg.info.time.created === state.lastCompaction))
-        ) {
-            return 0
-        }
-
-        const input = assistantInfo.tokens?.input || 0
-        const output = assistantInfo.tokens?.output || 0
-        const reasoning = assistantInfo.tokens?.reasoning || 0
-        const cacheRead = assistantInfo.tokens?.cache?.read || 0
-        const cacheWrite = assistantInfo.tokens?.cache?.write || 0
-        return input + output + reasoning + cacheRead + cacheWrite
-    }
-
-    return 0
-}
-
-export function getCurrentParams(
-    state: SessionState,
-    messages: WithParts[],
-    logger: Logger,
-): {
-    providerId: string | undefined
-    modelId: string | undefined
-    agent: string | undefined
-    variant: string | undefined
-} {
-    const userMsg = getLastUserMessage(messages)
-    if (!userMsg) {
-        logger.debug("No user message found when determining current params")
-        return {
-            providerId: undefined,
-            modelId: undefined,
-            agent: undefined,
-            variant: state.variant,
-        }
-    }
-    const userInfo = userMsg.info as UserMessage
-    const agent: string = userInfo.agent
-    const providerId: string | undefined = userInfo.model.providerID
-    const modelId: string | undefined = userInfo.model.modelID
-    const variant: string | undefined = state.variant ?? userInfo.variant
-
-    return { providerId, modelId, agent, variant }
-}
-
-export function countTokens(text: string): number {
-    if (!text) return 0
-    try {
-        return anthropicCountTokens(text)
-    } catch {
-        return Math.round(text.length / 4)
-    }
-}
-
-export function estimateTokensBatch(texts: string[]): number {
-    if (texts.length === 0) return 0
-    return countTokens(texts.join(" "))
-}
-
-export const COMPACTED_TOOL_OUTPUT_PLACEHOLDER = "[Old tool result content cleared]"
-
-function stringifyToolContent(value: unknown): string {
-    return typeof value === "string" ? value : JSON.stringify(value)
-}
-
-export function extractCompletedToolOutput(part: any): string | undefined {
-    if (
-        part?.type !== "tool" ||
-        part.state?.status !== "completed" ||
-        part.state?.output === undefined
-    ) {
-        return undefined
-    }
-
-    if (part.state?.time?.compacted) {
-        return COMPACTED_TOOL_OUTPUT_PLACEHOLDER
-    }
-
-    return stringifyToolContent(part.state.output)
-}
-
-export function extractToolContent(part: any): string[] {
-    const contents: string[] = []
-
-    if (part?.type !== "tool") {
-        return contents
-    }
-
-    if (part.state?.input !== undefined) {
-        contents.push(stringifyToolContent(part.state.input))
-    }
-
-    const completedOutput = extractCompletedToolOutput(part)
-    if (completedOutput !== undefined) {
-        contents.push(completedOutput)
-    } else if (part.state?.status === "error" && part.state?.error) {
-        contents.push(stringifyToolContent(part.state.error))
-    }
-
-    return contents
-}
-
-export function countToolTokens(part: any): number {
-    const contents = extractToolContent(part)
-    return estimateTokensBatch(contents)
-}
-
-export function getTotalToolTokens(state: SessionState, toolIds: string[]): number {
-    let total = 0
-    for (const id of toolIds) {
-        const entry = state.toolParameters.get(id)
-        total += entry?.tokenCount ?? 0
-    }
-    return total
-}
-
-export function countMessageTextTokens(msg: WithParts): number {
-    const texts: string[] = []
-    const parts = Array.isArray(msg.parts) ? msg.parts : []
-    for (const part of parts) {
-        if (part.type === "text") {
-            texts.push(part.text)
-        }
-    }
-    if (texts.length === 0) return 0
-    return estimateTokensBatch(texts)
-}
-
-export function countAllMessageTokens(msg: WithParts): number {
-    const parts = Array.isArray(msg.parts) ? msg.parts : []
-    const texts: string[] = []
-    for (const part of parts) {
-        if (part.type === "text") {
-            texts.push(part.text)
-        } else {
-            texts.push(...extractToolContent(part))
-        }
-    }
-    if (texts.length === 0) return 0
-    return estimateTokensBatch(texts)
-}

package/tui/data/context.ts

@@ -1,177 +0,0 @@
-import { Logger } from "../../lib/logger"
-import {
-    createSessionState,
-    loadSessionState,
-    type SessionState,
-    type WithParts,
-} from "../../lib/state"
-import {
-    findLastCompactionTimestamp,
-    getActiveSummaryTokenUsage,
-    loadPruneMap,
-    loadPruneMessagesState,
-} from "../../lib/state/utils"
-import { loadAllSessionStats } from "../../lib/state/persistence"
-import { analyzeTokens, emptyBreakdown } from "../../lib/analysis/tokens"
-import type { DcpContextSnapshot, DcpTuiClient } from "../shared/types"
-
-const snapshotCache = new Map<string, DcpContextSnapshot>()
-const inflightSnapshots = new Map<string, Promise<DcpContextSnapshot>>()
-const CACHE_TTL_MS = 5000
-
-export const createPlaceholderContextSnapshot = (
-    sessionID?: string,
-    notes: string[] = [],
-): DcpContextSnapshot => ({
-    sessionID,
-    breakdown: emptyBreakdown(),
-    activeSummaryTokens: 0,
-    persisted: {
-        available: false,
-        activeBlockCount: 0,
-        activeBlocks: [],
-    },
-    messageStatuses: [],
-    allTimeStats: { totalTokensSaved: 0, sessionCount: 0 },
-    notes,
-    loadedAt: Date.now(),
-})
-
-function cleanBlockSummary(raw: string): string {
-    return raw
-        .replace(/^\s*\[Compressed conversation section\]\s*/i, "")
-        .replace(/(?:\r?\n)*<dcp-message-id>b\d+<\/dcp-message-id>\s*$/i, "")
-        .trim()
-}
-
-const buildState = async (
-    sessionID: string,
-    messages: WithParts[],
-    logger: Logger,
-): Promise<{ state: SessionState; persisted: Awaited<ReturnType<typeof loadSessionState>> }> => {
-    const state = createSessionState()
-    const persisted = await loadSessionState(sessionID, logger)
-
-    state.sessionId = sessionID
-    state.lastCompaction = findLastCompactionTimestamp(messages)
-    state.stats.pruneTokenCounter = 0
-    state.stats.totalPruneTokens = persisted?.stats?.totalPruneTokens || 0
-    state.prune.tools = loadPruneMap(persisted?.prune?.tools)
-    state.prune.messages = loadPruneMessagesState(persisted?.prune?.messages)
-
-    return {
-        state,
-        persisted,
-    }
-}
-
-const loadContextSnapshot = async (
-    client: DcpTuiClient,
-    logger: Logger,
-    sessionID?: string,
-): Promise<DcpContextSnapshot> => {
-    if (!sessionID) {
-        return createPlaceholderContextSnapshot(undefined, ["No active session."])
-    }
-
-    const messagesResult = await client.session.messages({ sessionID })
-    const rawMessages =
-        messagesResult && typeof messagesResult === "object" && "data" in messagesResult
-            ? messagesResult.data
-            : messagesResult
-    const messages = Array.isArray(rawMessages) ? (rawMessages as WithParts[]) : ([] as WithParts[])
-
-    const { state, persisted } = await buildState(sessionID, messages, logger)
-    const [{ breakdown, messageStatuses }, aggregated] = await Promise.all([
-        Promise.resolve(analyzeTokens(state, messages)),
-        loadAllSessionStats(logger),
-    ])
-
-    const allBlocks = Array.from(state.prune.messages.activeBlockIds)
-        .map((blockID) => state.prune.messages.blocksById.get(blockID))
-        .filter((block): block is NonNullable<typeof block> => !!block && !!block.topic)
-        .map((block) => ({ topic: block.topic, summary: cleanBlockSummary(block.summary) }))
-
-    const notes: string[] = []
-    if (persisted) {
-        notes.push("Using live session messages plus persisted DCP state.")
-    } else {
-        notes.push("No saved DCP state found for this session yet.")
-    }
-    if (messages.length === 0) {
-        notes.push("This session does not have any messages yet.")
-    }
-
-    return {
-        sessionID,
-        breakdown,
-        activeSummaryTokens: getActiveSummaryTokenUsage(state),
-        persisted: {
-            available: !!persisted,
-            activeBlockCount: state.prune.messages.activeBlockIds.size,
-            activeBlocks: allBlocks,
-            lastUpdated: persisted?.lastUpdated,
-        },
-        messageStatuses,
-        allTimeStats: {
-            totalTokensSaved: aggregated.totalTokens,
-            sessionCount: aggregated.sessionCount,
-        },
-        notes,
-        loadedAt: Date.now(),
-    }
-}
-
-export const peekContextSnapshot = (sessionID?: string): DcpContextSnapshot | undefined => {
-    if (!sessionID) return undefined
-    return snapshotCache.get(sessionID)
-}
-
-export const invalidateContextSnapshot = (sessionID?: string) => {
-    if (!sessionID) {
-        snapshotCache.clear()
-        inflightSnapshots.clear()
-        return
-    }
-    snapshotCache.delete(sessionID)
-    inflightSnapshots.delete(sessionID)
-}
-
-export const loadContextSnapshotCached = async (
-    client: DcpTuiClient,
-    logger: Logger,
-    sessionID?: string,
-): Promise<DcpContextSnapshot> => {
-    if (!sessionID) {
-        return createPlaceholderContextSnapshot(undefined, ["No active session."])
-    }
-
-    const cached = snapshotCache.get(sessionID)
-    if (cached && Date.now() - cached.loadedAt < CACHE_TTL_MS) {
-        return cached
-    }
-
-    const inflight = inflightSnapshots.get(sessionID)
-    if (inflight) {
-        return inflight
-    }
-
-    const request = loadContextSnapshot(client, logger, sessionID)
-        .then((snapshot) => {
-            snapshotCache.set(sessionID, snapshot)
-            return snapshot
-        })
-        .catch((error) => {
-            logger.error("Failed to load TUI context snapshot", {
-                sessionID,
-                error: error instanceof Error ? error.message : String(error),
-            })
-            throw error
-        })
-        .finally(() => {
-            inflightSnapshots.delete(sessionID)
-        })
-
-    inflightSnapshots.set(sessionID, request)
-    return request
-}

package/tui/index.tsx

@@ -1,34 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import type { TuiPlugin } from "@opencode-ai/plugin/tui"
-import { getConfigForDirectory } from "../lib/config"
-import { Logger } from "../lib/logger"
-import { createSidebarContentSlot } from "./slots/sidebar-content"
-import { createSummaryRoute } from "./routes/summary"
-import { NAMES } from "./shared/names"
-
-const tui: TuiPlugin = async (api) => {
-    const config = getConfigForDirectory(api.state.path.directory, (title, message) => {
-        api.ui.toast({
-            title,
-            message,
-            variant: "warning",
-            duration: 7000,
-        })
-    })
-    if (!config.enabled) return
-
-    const logger = new Logger(config.tui.debug, "tui")
-
-    api.route.register([createSummaryRoute(api)])
-
-    if (config.tui.sidebar) {
-        api.slots.register(createSidebarContentSlot(api, NAMES, logger))
-    }
-}
-
-const id = "opencode-dynamic-context-pruning"
-
-export default {
-    id,
-    tui,
-}