@tarquinen/opencode-dcp 3.1.12 → 3.1.14

package/lib/ui/utils.ts

@@ -0,0 +1,304 @@
+import { SessionState, ToolParameterEntry, WithParts } from "../state"
+import { countTokens } from "../token-utils"
+import { isIgnoredUserMessage } from "../messages/query"
+
+function extractParameterKey(tool: string, parameters: any): string {
+    if (!parameters) return ""
+
+    if (tool === "read" && parameters.filePath) {
+        const offset = parameters.offset
+        const limit = parameters.limit
+        if (offset !== undefined && limit !== undefined) {
+            return `${parameters.filePath} (lines ${offset}-${offset + limit})`
+        }
+        if (offset !== undefined) {
+            return `${parameters.filePath} (lines ${offset}+)`
+        }
+        if (limit !== undefined) {
+            return `${parameters.filePath} (lines 0-${limit})`
+        }
+        return parameters.filePath
+    }
+
+    if ((tool === "write" || tool === "edit" || tool === "multiedit") && parameters.filePath) {
+        return parameters.filePath
+    }
+
+    if (tool === "apply_patch" && typeof parameters.patchText === "string") {
+        const pathRegex = /\*\*\* (?:Add|Delete|Update) File: ([^\n\r]+)/g
+        const paths: string[] = []
+        let match
+        while ((match = pathRegex.exec(parameters.patchText)) !== null) {
+            paths.push(match[1].trim())
+        }
+        if (paths.length > 0) {
+            const uniquePaths = [...new Set(paths)]
+            const count = uniquePaths.length
+            const plural = count > 1 ? "s" : ""
+            if (count === 1) return uniquePaths[0]
+            if (count === 2) return uniquePaths.join(", ")
+            return `${count} file${plural}: ${uniquePaths[0]}, ${uniquePaths[1]}...`
+        }
+        return "patch"
+    }
+
+    if (tool === "list") {
+        return parameters.path || "(current directory)"
+    }
+
+    if (tool === "glob") {
+        if (parameters.pattern) {
+            const pathInfo = parameters.path ? ` in ${parameters.path}` : ""
+            return `"${parameters.pattern}"${pathInfo}`
+        }
+        return "(unknown pattern)"
+    }
+
+    if (tool === "grep") {
+        if (parameters.pattern) {
+            const pathInfo = parameters.path ? ` in ${parameters.path}` : ""
+            return `"${parameters.pattern}"${pathInfo}`
+        }
+        return "(unknown pattern)"
+    }
+
+    if (tool === "bash") {
+        if (parameters.description) return parameters.description
+        if (parameters.command) {
+            return parameters.command.length > 50
+                ? parameters.command.substring(0, 50) + "..."
+                : parameters.command
+        }
+    }
+
+    if (tool === "webfetch" && parameters.url) {
+        return parameters.url
+    }
+    if (tool === "websearch" && parameters.query) {
+        return `"${parameters.query}"`
+    }
+    if (tool === "codesearch" && parameters.query) {
+        return `"${parameters.query}"`
+    }
+
+    if (tool === "todowrite") {
+        return `${parameters.todos?.length || 0} todos`
+    }
+    if (tool === "todoread") {
+        return "read todo list"
+    }
+
+    if (tool === "task" && parameters.description) {
+        return parameters.description
+    }
+    if (tool === "skill" && parameters.name) {
+        return parameters.name
+    }
+
+    if (tool === "lsp") {
+        const op = parameters.operation || "lsp"
+        const path = parameters.filePath || ""
+        const line = parameters.line
+        const char = parameters.character
+        if (path && line !== undefined && char !== undefined) {
+            return `${op} ${path}:${line}:${char}`
+        }
+        if (path) {
+            return `${op} ${path}`
+        }
+        return op
+    }
+
+    if (tool === "question") {
+        const questions = parameters.questions
+        if (Array.isArray(questions) && questions.length > 0) {
+            const headers = questions
+                .map((q: any) => q.header || "")
+                .filter(Boolean)
+                .slice(0, 3)
+
+            const count = questions.length
+            const plural = count > 1 ? "s" : ""
+
+            if (headers.length > 0) {
+                const suffix = count > 3 ? ` (+${count - 3} more)` : ""
+                return `${count} question${plural}: ${headers.join(", ")}${suffix}`
+            }
+            return `${count} question${plural}`
+        }
+        return "question"
+    }
+
+    const paramStr = JSON.stringify(parameters)
+    if (paramStr === "{}" || paramStr === "[]" || paramStr === "null") {
+        return ""
+    }
+
+    return paramStr.substring(0, 50)
+}
+
+export function formatStatsHeader(totalTokensSaved: number, pruneTokenCounter: number): string {
+    const totalTokensSavedStr = `~${formatTokenCount(totalTokensSaved + pruneTokenCounter)}`
+    return [`▣ DCP | ${totalTokensSavedStr} saved total`].join("\n")
+}
+
+export function formatTokenCount(tokens: number, compact?: boolean): string {
+    const suffix = compact ? "" : " tokens"
+    if (tokens >= 1000) {
+        return `${(tokens / 1000).toFixed(1)}K`.replace(".0K", "K") + suffix
+    }
+    return tokens.toString() + suffix
+}
+
+export function truncate(str: string, maxLen: number = 60): string {
+    if (str.length <= maxLen) return str
+    return str.slice(0, maxLen - 3) + "..."
+}
+
+export function formatProgressBar(
+    messageIds: string[],
+    prunedMessages: Map<string, number>,
+    recentMessageIds: string[],
+    width: number = 50,
+): string {
+    const ACTIVE = "█"
+    const PRUNED = "░"
+    const RECENT = "⣿"
+    const recentSet = new Set(recentMessageIds)
+
+    const total = messageIds.length
+    if (total === 0) return `│${PRUNED.repeat(width)}│`
+
+    const bar = new Array(width).fill(ACTIVE)
+
+    for (let m = 0; m < total; m++) {
+        const msgId = messageIds[m]
+        const start = Math.floor((m / total) * width)
+        const end = Math.floor(((m + 1) / total) * width)
+
+        if (recentSet.has(msgId)) {
+            for (let i = start; i < end; i++) {
+                bar[i] = RECENT
+            }
+        } else if (prunedMessages.has(msgId)) {
+            for (let i = start; i < end; i++) {
+                bar[i] = PRUNED
+            }
+        }
+    }
+
+    return `│${bar.join("")}│`
+}
+
+export function cacheSystemPromptTokens(state: SessionState, messages: WithParts[]): void {
+    let firstInputTokens = 0
+    for (const msg of messages) {
+        if (msg.info.role !== "assistant") {
+            continue
+        }
+        const info = msg.info as any
+        const input = info?.tokens?.input || 0
+        const cacheRead = info?.tokens?.cache?.read || 0
+        const cacheWrite = info?.tokens?.cache?.write || 0
+        if (input > 0 || cacheRead > 0 || cacheWrite > 0) {
+            firstInputTokens = input + cacheRead + cacheWrite
+            break
+        }
+    }
+
+    if (firstInputTokens <= 0) {
+        state.systemPromptTokens = undefined
+        return
+    }
+
+    let firstUserText = ""
+    for (const msg of messages) {
+        if (msg.info.role !== "user" || isIgnoredUserMessage(msg)) {
+            continue
+        }
+        const parts = Array.isArray(msg.parts) ? msg.parts : []
+        for (const part of parts) {
+            if (part.type === "text" && !(part as any).ignored) {
+                firstUserText += part.text
+            }
+        }
+        break
+    }
+
+    const estimatedSystemTokens = Math.max(0, firstInputTokens - countTokens(firstUserText))
+    state.systemPromptTokens = estimatedSystemTokens > 0 ? estimatedSystemTokens : undefined
+}
+
+export function shortenPath(input: string, workingDirectory?: string): string {
+    const inPathMatch = input.match(/^(.+) in (.+)$/)
+    if (inPathMatch) {
+        const prefix = inPathMatch[1]
+        const pathPart = inPathMatch[2]
+        const shortenedPath = shortenSinglePath(pathPart, workingDirectory)
+        return `${prefix} in ${shortenedPath}`
+    }
+
+    return shortenSinglePath(input, workingDirectory)
+}
+
+function shortenSinglePath(path: string, workingDirectory?: string): string {
+    if (workingDirectory) {
+        if (path.startsWith(workingDirectory + "/")) {
+            return path.slice(workingDirectory.length + 1)
+        }
+        if (path === workingDirectory) {
+            return "."
+        }
+    }
+
+    return path
+}
+
+export function formatPrunedItemsList(
+    pruneToolIds: string[],
+    toolMetadata: Map<string, ToolParameterEntry>,
+    workingDirectory?: string,
+): string[] {
+    const lines: string[] = []
+
+    for (const id of pruneToolIds) {
+        const metadata = toolMetadata.get(id)
+
+        if (metadata) {
+            const paramKey = extractParameterKey(metadata.tool, metadata.parameters)
+            if (paramKey) {
+                // Use 60 char limit to match notification style
+                const displayKey = truncate(shortenPath(paramKey, workingDirectory), 60)
+                lines.push(`→ ${metadata.tool}: ${displayKey}`)
+            } else {
+                lines.push(`→ ${metadata.tool}`)
+            }
+        }
+    }
+
+    const knownCount = pruneToolIds.filter((id) => toolMetadata.has(id)).length
+    const unknownCount = pruneToolIds.length - knownCount
+
+    if (unknownCount > 0) {
+        lines.push(`→ (${unknownCount} tool${unknownCount > 1 ? "s" : ""} with unknown metadata)`)
+    }
+
+    return lines
+}
+
+export function formatPruningResultForTool(
+    prunedIds: string[],
+    toolMetadata: Map<string, ToolParameterEntry>,
+    workingDirectory?: string,
+): string {
+    const lines: string[] = []
+    lines.push(`Context pruning complete. Pruned ${prunedIds.length} tool outputs.`)
+    lines.push("")
+
+    if (prunedIds.length > 0) {
+        lines.push(`Semantically pruned (${prunedIds.length}):`)
+        lines.push(...formatPrunedItemsList(prunedIds, toolMetadata, workingDirectory))
+    }
+
+    return lines.join("\n").trim()
+}

package/lib/update.ts

@@ -0,0 +1,185 @@
+import { readFile, rm } from "node:fs/promises"
+import { basename, dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+import type { PluginInput } from "@opencode-ai/plugin"
+
+type PackageJson = {
+    name?: string
+    version?: string
+    dependencies?: Record<string, string>
+}
+
+type UpdateResult =
+    | { updated: true; name: string; current: string; latest: string }
+    | { updated: false; error: "remove_failed"; name: string; current: string; latest: string }
+    | { updated: false }
+
+const PACKAGE_NAME = "@tarquinen/opencode-dcp"
+
+export function startAutoUpdate(ctx: PluginInput, enabled: boolean): void {
+    if (!enabled) return
+
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), 10_000)
+    void checkAutoUpdate(controller.signal)
+        .then((result) => {
+            if (!result.updated) return
+            setTimeout(() => {
+                ctx.client.tui.showToast({
+                    body: {
+                        title: "DCP update ready",
+                        message: `Updated ${result.name} from ${result.current} to ${result.latest}. Restart OpenCode to finish.`,
+                        variant: "info",
+                        duration: 7000,
+                    },
+                })
+            }, 5000)
+        })
+        .catch(() => {})
+        .finally(() => clearTimeout(timeout))
+}
+
+export async function checkAutoUpdate(signal: AbortSignal): Promise<UpdateResult> {
+    const packageDir = await findPackageDir(PACKAGE_NAME)
+    if (!packageDir) return { updated: false }
+
+    const pkg = await readPackageJson(join(packageDir, "package.json"))
+    if (!pkg?.name || !pkg.version) return { updated: false }
+
+    const latest = await fetchLatestVersion(pkg.name, signal)
+    if (!latest || !isVersionNewer(latest, pkg.version)) return { updated: false }
+
+    const removeDir = await updateRemoveDir(packageDir, pkg.name)
+    if (!removeDir) return { updated: false }
+
+    try {
+        await rm(removeDir, { recursive: true, force: true })
+    } catch {
+        return {
+            updated: false,
+            error: "remove_failed",
+            name: pkg.name,
+            current: pkg.version,
+            latest,
+        }
+    }
+
+    return { updated: true, name: pkg.name, current: pkg.version, latest }
+}
+
+async function findPackageDir(name: string) {
+    let dir = dirname(fileURLToPath(import.meta.url))
+    for (;;) {
+        const pkg = await readPackageJson(join(dir, "package.json"))
+        if (pkg?.name === name) return dir
+
+        const parent = dirname(dir)
+        if (parent === dir) return undefined
+        dir = parent
+    }
+}
+
+export async function updateRemoveDir(packageDir: string, name: string) {
+    const packageParent = dirname(packageDir)
+    const nodeModulesDir = basename(packageParent).startsWith("@")
+        ? dirname(packageParent)
+        : packageParent
+    if (basename(nodeModulesDir) !== "node_modules") return undefined
+
+    const wrapperDir = dirname(nodeModulesDir)
+    const wrapperPkg = await readPackageJson(join(wrapperDir, "package.json"))
+    const spec = wrapperSpec(wrapperDir, name) ?? wrapperPkg?.dependencies?.[name]
+    if (!spec || !isAutoUpdatableSpec(spec)) return undefined
+
+    return wrapperDir
+}
+
+function wrapperSpec(wrapperDir: string, name: string) {
+    if (name.startsWith("@")) {
+        const [scope, pkg] = name.split("/")
+        if (!scope || !pkg || basename(dirname(wrapperDir)) !== scope) return undefined
+        const prefix = `${pkg}@`
+        const base = basename(wrapperDir)
+        return base.startsWith(prefix) ? base.slice(prefix.length) : undefined
+    }
+
+    const prefix = `${name}@`
+    const base = basename(wrapperDir)
+    return base.startsWith(prefix) ? base.slice(prefix.length) : undefined
+}
+
+export function isAutoUpdatableSpec(spec: string) {
+    const value = spec.trim()
+    if (!value) return false
+    if (value === "latest" || value === "*") return true
+    if (/^[~^]/.test(value)) return true
+    if (/^(?:>=|>|<=|<)/.test(value)) return true
+    if (/\s+(?:\|\||-|[<>=])\s+/.test(value)) return true
+    return false
+}
+
+async function readPackageJson(path: string): Promise<PackageJson | undefined> {
+    try {
+        const data = JSON.parse(await readFile(path, "utf-8"))
+        return data && typeof data === "object" ? (data as PackageJson) : undefined
+    } catch {
+        return undefined
+    }
+}
+
+async function fetchLatestVersion(name: string, signal: AbortSignal) {
+    try {
+        const response = await fetch(
+            `https://registry.npmjs.org/${encodeURIComponent(name)}/latest`,
+            {
+                signal,
+            },
+        )
+        if (!response.ok) return undefined
+        const data: unknown = await response.json()
+        if (!data || typeof data !== "object") return undefined
+        const version = (data as { version?: unknown }).version
+        return typeof version === "string" ? version : undefined
+    } catch {
+        return undefined
+    }
+}
+
+export function isVersionNewer(latest: string, current: string) {
+    const next = parseVersion(latest)
+    const prev = parseVersion(current)
+    if (!next || !prev) return false
+
+    for (let i = 0; i < 3; i++) {
+        if (next.parts[i] !== prev.parts[i]) return next.parts[i] > prev.parts[i]
+    }
+
+    if (!next.pre.length && prev.pre.length) return true
+    if (next.pre.length && !prev.pre.length) return false
+
+    for (let i = 0; i < Math.max(next.pre.length, prev.pre.length); i++) {
+        const a = next.pre[i]
+        const b = prev.pre[i]
+        if (a === undefined) return false
+        if (b === undefined) return true
+        if (a === b) continue
+
+        const aNumber = /^\d+$/.test(a) ? Number(a) : undefined
+        const bNumber = /^\d+$/.test(b) ? Number(b) : undefined
+        if (aNumber !== undefined && bNumber !== undefined) return aNumber > bNumber
+        if (aNumber !== undefined) return false
+        if (bNumber !== undefined) return true
+        return a > b
+    }
+
+    return false
+}
+
+function parseVersion(version: string) {
+    const match = version.match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+.+)?$/)
+    if (!match) return undefined
+    return {
+        parts: [Number(match[1]), Number(match[2]), Number(match[3])],
+        pre: match[4]?.split(".") ?? [],
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://json.schemastore.org/package.json",
     "name": "@tarquinen/opencode-dcp",
-    "version": "3.1.12",
+    "version": "3.1.14",
     "type": "module",
     "description": "OpenCode plugin that optimizes token usage by pruning obsolete tool outputs from conversation context",
     "main": "./dist/index.js",
@@ -14,6 +14,10 @@
         "./server": {
             "types": "./dist/index.d.ts",
             "import": "./dist/index.js"
+        },
+        "./tui": {
+            "types": "./dist/tui.d.ts",
+            "import": "./tui.tsx"
         }
     },
     "scripts": {
@@ -40,16 +44,19 @@
     ],
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/Tarquinen/opencode-dynamic-context-pruning.git"
+        "url": "git+https://github.com/Opencode-DCP/opencode-dynamic-context-pruning.git"
     },
     "bugs": {
-        "url": "https://github.com/Tarquinen/opencode-dynamic-context-pruning/issues"
+        "url": "https://github.com/Opencode-DCP/opencode-dynamic-context-pruning/issues"
     },
-    "homepage": "https://github.com/Tarquinen/opencode-dynamic-context-pruning#readme",
+    "homepage": "https://github.com/Opencode-DCP/opencode-dynamic-context-pruning#readme",
     "author": "tarquinen",
     "license": "AGPL-3.0-or-later",
     "peerDependencies": {
-        "@opencode-ai/plugin": ">=1.4.3"
+        "@opencode-ai/plugin": ">=1.4.3",
+        "@opentui/core": "^0.4.2",
+        "@opentui/solid": "^0.4.2",
+        "solid-js": "^1.9.12"
     },
     "dependencies": {
         "@anthropic-ai/tokenizer": "^0.0.4",
@@ -58,14 +65,23 @@
     },
     "devDependencies": {
         "@opencode-ai/plugin": "^1.4.3",
+        "@opentui/core": "^0.4.2",
+        "@opentui/solid": "^0.4.2",
         "@types/node": "^25.5.0",
         "prettier": "^3.8.1",
+        "solid-js": "^1.9.12",
         "tsup": "^8.5.1",
         "tsx": "^4.21.0",
         "typescript": "^6.0.2"
     },
+    "overrides": {
+        "@babel/core": "7.29.7",
+        "esbuild": "0.28.1"
+    },
     "files": [
         "dist/",
+        "lib/",
+        "tui.tsx",
         "README.md",
         "LICENSE"
     ]

package/tui.tsx

@@ -0,0 +1,26 @@
+/** @jsxImportSource @opentui/solid */
+
+import type { TuiPluginModule } from "@opencode-ai/plugin/tui"
+import { registerCommands } from "./lib/tui/commands"
+import { loadConfig } from "./lib/tui/data"
+import { openPanelModal } from "./lib/tui/modals"
+
+const tui: TuiPluginModule["tui"] = async (api) => {
+    const config = loadConfig(api)
+    if (!config.enabled || !config.commands.enabled) return
+
+    registerCommands(api, [
+        {
+            title: "DCP",
+            name: "dcp.panel",
+            description: "Open DCP panel",
+            slashName: "dcp",
+            run: () => openPanelModal(api, config),
+        },
+    ])
+}
+
+export default {
+    id: "opencode-dcp",
+    tui,
+} satisfies TuiPluginModule