cleanup(ui): remove unused compression graph helpers

Author: Tarquinen

lib/ui/utils.ts

@@ -1,6 +1,5 @@
 import { SessionState, ToolParameterEntry, WithParts } from "../state"
-import { countTokens, extractToolContent } from "../strategies/utils"
-import { clog, C } from "../compress-logger"
+import { countTokens } from "../strategies/utils"
 import { isIgnoredUserMessage } from "../messages/utils"
 
 function extractParameterKey(tool: string, parameters: any): string {
@@ -178,94 +177,6 @@ export function formatSessionMap(
     return `│${bar.join("")}│`
 }
 
-export interface CompressionGraphData {
-    systemTokens: number
-    recentCompressedTokens: number
-    olderCompressedTokens: number
-    remainingTokens: number
-    totalSessionTokens: number
-    segments: CompressionGraphSegment[]
-}
-
-type CompressionGraphSegmentType = "system" | "recentCompressed" | "olderCompressed" | "inContext"
-
-export interface CompressionGraphSegment {
-    type: CompressionGraphSegmentType
-    tokens: number
-}
-
-function appendGraphSegment(
-    segments: CompressionGraphSegment[],
-    type: CompressionGraphSegmentType,
-    tokens: number,
-): void {
-    if (tokens <= 0) {
-        return
-    }
-
-    const last = segments[segments.length - 1]
-    if (last && last.type === type) {
-        last.tokens += tokens
-        return
-    }
-
-    segments.push({ type, tokens })
-}
-
-function incrementMapValue(map: Map<string, number>, key: string, value: number): void {
-    if (value <= 0) {
-        return
-    }
-    map.set(key, (map.get(key) || 0) + value)
-}
-
-function countMessageTokensExcludingPrunedTools(state: SessionState, msg: WithParts): number {
-    const parts = Array.isArray(msg.parts) ? msg.parts : []
-    const texts: string[] = []
-
-    for (const part of parts) {
-        if ((part as any).ignored) {
-            continue
-        }
-
-        if (part.type === "text") {
-            texts.push(part.text)
-            continue
-        }
-
-        if (part.type !== "tool") {
-            continue
-        }
-
-        if (!part.callID || state.prune.tools.has(part.callID)) {
-            continue
-        }
-
-        texts.push(...extractToolContent(part))
-    }
-
-    if (texts.length === 0) {
-        return 0
-    }
-    return countTokens(texts.join(" "))
-}
-
-function buildToolParentMap(messages: WithParts[]): Map<string, string> {
-    const map = new Map<string, string>()
-
-    for (const msg of messages) {
-        const parts = Array.isArray(msg.parts) ? msg.parts : []
-        for (const part of parts) {
-            if (part.type !== "tool" || !part.callID) {
-                continue
-            }
-            map.set(part.callID, msg.info.id)
-        }
-    }
-
-    return map
-}
-
 export function cacheSystemPromptTokens(state: SessionState, messages: WithParts[]): void {
     let firstInputTokens = 0
     for (const msg of messages) {
@@ -304,208 +215,6 @@ export function cacheSystemPromptTokens(state: SessionState, messages: WithParts
     state.systemPromptTokens = estimatedSystemTokens > 0 ? estimatedSystemTokens : undefined
 }
 
-export function buildCompressionGraphData(
-    state: SessionState,
-    messages: WithParts[],
-    newMessageIds: Set<string>,
-    newToolIds: Set<string>,
-): CompressionGraphData {
-    const toolParentMap = buildToolParentMap(messages)
-    const prunedMessageIds = new Set(state.prune.messages.keys())
-    const messageIds = new Set(messages.map((m) => m.info.id))
-
-    let compressedMessageTokens = 0
-    for (const tokens of state.prune.messages.values()) {
-        compressedMessageTokens += tokens
-    }
-
-    const recentStandaloneByMessage = new Map<string, number>()
-    const olderStandaloneByMessage = new Map<string, number>()
-
-    let unparentedRecentStandaloneTokens = 0
-    let unparentedOlderStandaloneTokens = 0
-    let compressedStandaloneToolTokens = 0
-    let recentStandaloneToolTokens = 0
-    for (const [toolId, toolTokens] of state.prune.tools.entries()) {
-        const parentMessageId = toolParentMap.get(toolId)
-        if (parentMessageId && prunedMessageIds.has(parentMessageId)) {
-            continue
-        }
-
-        compressedStandaloneToolTokens += toolTokens
-
-        const isRecent = newToolIds.has(toolId)
-        if (isRecent) {
-            recentStandaloneToolTokens += toolTokens
-        }
-
-        if (parentMessageId) {
-            incrementMapValue(
-                isRecent ? recentStandaloneByMessage : olderStandaloneByMessage,
-                parentMessageId,
-                toolTokens,
-            )
-        } else if (isRecent) {
-            unparentedRecentStandaloneTokens += toolTokens
-        } else {
-            unparentedOlderStandaloneTokens += toolTokens
-        }
-    }
-
-    const compressedTotalTokens = compressedMessageTokens + compressedStandaloneToolTokens
-
-    let recentMessageTokens = 0
-    for (const messageId of newMessageIds) {
-        recentMessageTokens += state.prune.messages.get(messageId) || 0
-    }
-
-    const recentCompressedTokens = recentMessageTokens + recentStandaloneToolTokens
-    const olderCompressedTokens = Math.max(0, compressedTotalTokens - recentCompressedTokens)
-
-    const summaryTokensByAnchor = new Map<string, number>()
-    let summaryTokensTotal = 0
-    for (const summary of state.compressSummaries) {
-        if (!messageIds.has(summary.anchorMessageId)) {
-            continue
-        }
-
-        const tokens = countTokens(summary.summary)
-        summaryTokensTotal += tokens
-        incrementMapValue(summaryTokensByAnchor, summary.anchorMessageId, tokens)
-    }
-
-    let remainingTokens = 0
-
-    for (const msg of messages) {
-        if (prunedMessageIds.has(msg.info.id)) {
-            continue
-        }
-        if (msg.info.role === "user" && isIgnoredUserMessage(msg)) {
-            continue
-        }
-        remainingTokens += countMessageTokensExcludingPrunedTools(state, msg)
-    }
-
-    remainingTokens += summaryTokensTotal
-
-    const systemTokens = state.systemPromptTokens ?? 0
-    const totalSessionTokens =
-        systemTokens + recentCompressedTokens + olderCompressedTokens + remainingTokens
-
-    const segments: CompressionGraphSegment[] = []
-    appendGraphSegment(segments, "system", systemTokens)
-
-    for (const msg of messages) {
-        const messageId = msg.info.id
-        const summaryTokens = summaryTokensByAnchor.get(messageId) || 0
-        appendGraphSegment(segments, "inContext", summaryTokens)
-
-        if (prunedMessageIds.has(messageId)) {
-            const messageTokens = state.prune.messages.get(messageId) || 0
-            appendGraphSegment(
-                segments,
-                newMessageIds.has(messageId) ? "recentCompressed" : "olderCompressed",
-                messageTokens,
-            )
-        } else if (!(msg.info.role === "user" && isIgnoredUserMessage(msg))) {
-            const messageTokens = countMessageTokensExcludingPrunedTools(state, msg)
-            appendGraphSegment(segments, "inContext", messageTokens)
-        }
-
-        appendGraphSegment(
-            segments,
-            "recentCompressed",
-            recentStandaloneByMessage.get(messageId) || 0,
-        )
-        appendGraphSegment(
-            segments,
-            "olderCompressed",
-            olderStandaloneByMessage.get(messageId) || 0,
-        )
-    }
-
-    appendGraphSegment(segments, "recentCompressed", unparentedRecentStandaloneTokens)
-    appendGraphSegment(segments, "olderCompressed", unparentedOlderStandaloneTokens)
-
-    clog.info(C.COMPRESS, "Compression graph token accounting", {
-        systemTokens,
-        recentCompressedTokens,
-        olderCompressedTokens,
-        remainingTokens,
-        totalSessionTokens,
-        segments: segments.length,
-    })
-
-    return {
-        systemTokens,
-        recentCompressedTokens,
-        olderCompressedTokens,
-        remainingTokens,
-        totalSessionTokens,
-        segments,
-    }
-}
-
-function allocateSegmentWidths(values: number[], total: number, width: number): number[] {
-    if (total <= 0 || width <= 0) {
-        return new Array(values.length).fill(0)
-    }
-
-    const raw = values.map((v) => (v / total) * width)
-    const base = raw.map((v) => Math.floor(v))
-    let used = base.reduce((acc, v) => acc + v, 0)
-
-    const order = raw
-        .map((v, idx) => ({ idx, frac: v - Math.floor(v) }))
-        .sort((a, b) => b.frac - a.frac)
-
-    for (let i = 0; used < width && i < order.length; i++) {
-        base[order[i].idx] += 1
-        used++
-    }
-
-    return base
-}
-
-export function formatCompressionGraph(data: CompressionGraphData, width: number = 50): string {
-    const segments: CompressionGraphSegment[] =
-        data.segments.length > 0
-            ? data.segments
-            : [
-                  { type: "system", tokens: data.systemTokens },
-                  { type: "recentCompressed", tokens: data.recentCompressedTokens },
-                  { type: "olderCompressed", tokens: data.olderCompressedTokens },
-                  { type: "inContext", tokens: data.remainingTokens },
-              ]
-
-    const chars: Record<CompressionGraphSegmentType, string> = {
-        system: "▌",
-        recentCompressed: "⣿",
-        olderCompressed: "░",
-        inContext: "█",
-    }
-    const segmentWidths = allocateSegmentWidths(
-        segments.map((segment) => segment.tokens),
-        data.totalSessionTokens,
-        width,
-    )
-
-    let bar = ""
-    for (let i = 0; i < segments.length; i++) {
-        bar += chars[segments[i].type].repeat(Math.max(0, segmentWidths[i]))
-    }
-
-    if (bar.length < width) {
-        bar += " ".repeat(width - bar.length)
-    }
-
-    return `│${bar}│`
-}
-
-export function formatCompressionGraphLegend(): string {
-    return "→ Legend: ▌ system | ⣿ recent compress | ░ older compressed | █ in context"
-}
-
 export function shortenPath(input: string, workingDirectory?: string): string {
     const inPathMatch = input.match(/^(.+) in (.+)$/)
     if (inPathMatch) {