chore: remove 1,152 lines of verified dead code (#874)

* chore(deps): remove unused dependencies

Removed @openauthjs/openauth, hono, open, and xdg-basedir - none are imported in src/

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

* chore(cleanup): remove unused agent prompts and tool files

Deleted:
- src/agents/build-prompt.ts (exports never imported)
- src/agents/plan-prompt.ts (exports never imported)
- src/tools/ast-grep/napi.ts (never imported)
- src/tools/interactive-bash/types.ts (never imported)

Verified by: LSP FindReferences + explore agents

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

* chore(hooks): remove unused comment-checker filters

Deleted entire filters/ directory:
- filters/bdd.ts
- filters/directive.ts
- filters/docstring.ts
- filters/shebang.ts
- filters/index.ts

Not used by main hook (cli.ts uses external binary instead)

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

* chore(hooks): remove unused comment-checker output and constants

Deleted:
- output/formatter.ts
- output/xml-builder.ts
- output/index.ts
- constants.ts

All 0 external imports - migrated to external binary

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

* chore(hooks): remove unused pruning subsystem

Deleted pruning subsystem (dependency order):
- pruning-purge-errors.ts
- pruning-storage.ts
- pruning-supersede.ts
- pruning-executor.ts

Not imported by main recovery hook

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

* chore(hooks): remove unused createBackgroundCompactionHook export

Removed export from index.ts - never imported in src/index.ts

Verified by: LSP FindReferences (only 2 refs: definition + barrel export)

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

---------

Co-authored-by: justsisyphus <sisyphus-dev-ai@users.noreply.github.com>
Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>
This commit is contained in:
justsisyphus
2026-01-17 21:12:55 +09:00
committed by GitHub
parent 3afc8e777f
commit db41a6fb01
19 changed files with 0 additions and 1156 deletions
@@ -1,125 +0,0 @@
import type { DynamicContextPruningConfig } from "../../config"
import type { PruningState, PruningResult } from "./pruning-types"
import { executeDeduplication } from "./pruning-deduplication"
import { executeSupersedeWrites } from "./pruning-supersede"
import { executePurgeErrors } from "./pruning-purge-errors"
import { applyPruning } from "./pruning-storage"
import { log } from "../../shared/logger"
const DEFAULT_PROTECTED_TOOLS = new Set([
"task",
"todowrite",
"todoread",
"lsp_rename",
"session_read",
"session_write",
"session_search",
])
function createPruningState(): PruningState {
return {
toolIdsToPrune: new Set<string>(),
currentTurn: 0,
fileOperations: new Map(),
toolSignatures: new Map(),
erroredTools: new Map(),
}
}
export async function executeDynamicContextPruning(
sessionID: string,
config: DynamicContextPruningConfig,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
client: any
): Promise<PruningResult> {
const state = createPruningState()
const protectedTools = new Set([
...DEFAULT_PROTECTED_TOOLS,
...(config.protected_tools || []),
])
log("[pruning-executor] starting DCP", {
sessionID,
notification: config.notification,
turnProtection: config.turn_protection,
})
let dedupCount = 0
let supersedeCount = 0
let purgeCount = 0
if (config.strategies?.deduplication?.enabled !== false) {
dedupCount = executeDeduplication(
sessionID,
state,
{ enabled: true },
protectedTools
)
}
if (config.strategies?.supersede_writes?.enabled !== false) {
supersedeCount = executeSupersedeWrites(
sessionID,
state,
{
enabled: true,
aggressive: config.strategies?.supersede_writes?.aggressive || false,
},
protectedTools
)
}
if (config.strategies?.purge_errors?.enabled !== false) {
purgeCount = executePurgeErrors(
sessionID,
state,
{
enabled: true,
turns: config.strategies?.purge_errors?.turns || 5,
},
protectedTools
)
}
const totalPruned = state.toolIdsToPrune.size
const tokensSaved = await applyPruning(sessionID, state)
log("[pruning-executor] DCP complete", {
totalPruned,
tokensSaved,
deduplication: dedupCount,
supersede: supersedeCount,
purge: purgeCount,
})
const result: PruningResult = {
itemsPruned: totalPruned,
totalTokensSaved: tokensSaved,
strategies: {
deduplication: dedupCount,
supersedeWrites: supersedeCount,
purgeErrors: purgeCount,
},
}
if (config.notification !== "off" && totalPruned > 0) {
const message =
config.notification === "detailed"
? `Pruned ${totalPruned} tool outputs (~${Math.round(tokensSaved / 1000)}k tokens). Dedup: ${dedupCount}, Supersede: ${supersedeCount}, Purge: ${purgeCount}`
: `Pruned ${totalPruned} tool outputs (~${Math.round(tokensSaved / 1000)}k tokens)`
await client.tui
.showToast({
body: {
title: "Dynamic Context Pruning",
message,
variant: "success",
duration: 3000,
},
})
.catch(() => {})
}
return result
}
@@ -1,152 +0,0 @@
import { existsSync, readdirSync, readFileSync } from "node:fs"
import { join } from "node:path"
import type { PruningState, ErroredToolCall } from "./pruning-types"
import { estimateTokens } from "./pruning-types"
import { log } from "../../shared/logger"
import { MESSAGE_STORAGE } from "../../features/hook-message-injector"
export interface PurgeErrorsConfig {
enabled: boolean
turns: number
protectedTools?: string[]
}
interface ToolPart {
type: string
callID?: string
tool?: string
state?: {
input?: unknown
output?: string
status?: string
}
}
interface MessagePart {
type: string
parts?: ToolPart[]
}
function getMessageDir(sessionID: string): string | null {
if (!existsSync(MESSAGE_STORAGE)) return null
const directPath = join(MESSAGE_STORAGE, sessionID)
if (existsSync(directPath)) return directPath
for (const dir of readdirSync(MESSAGE_STORAGE)) {
const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
if (existsSync(sessionPath)) return sessionPath
}
return null
}
function readMessages(sessionID: string): MessagePart[] {
const messageDir = getMessageDir(sessionID)
if (!messageDir) return []
const messages: MessagePart[] = []
try {
const files = readdirSync(messageDir).filter(f => f.endsWith(".json"))
for (const file of files) {
const content = readFileSync(join(messageDir, file), "utf-8")
const data = JSON.parse(content)
if (data.parts) {
messages.push(data)
}
}
} catch {
return []
}
return messages
}
export function executePurgeErrors(
sessionID: string,
state: PruningState,
config: PurgeErrorsConfig,
protectedTools: Set<string>
): number {
if (!config.enabled) return 0
const messages = readMessages(sessionID)
let currentTurn = 0
for (const msg of messages) {
if (!msg.parts) continue
for (const part of msg.parts) {
if (part.type === "step-start") {
currentTurn++
}
}
}
state.currentTurn = currentTurn
let turnCounter = 0
let prunedCount = 0
let tokensSaved = 0
for (const msg of messages) {
if (!msg.parts) continue
for (const part of msg.parts) {
if (part.type === "step-start") {
turnCounter++
continue
}
if (part.type !== "tool" || !part.callID || !part.tool) continue
if (protectedTools.has(part.tool)) continue
if (config.protectedTools?.includes(part.tool)) continue
if (state.toolIdsToPrune.has(part.callID)) continue
if (part.state?.status !== "error") continue
const turnAge = currentTurn - turnCounter
if (turnAge >= config.turns) {
state.toolIdsToPrune.add(part.callID)
prunedCount++
const input = part.state.input
if (input) {
tokensSaved += estimateTokens(JSON.stringify(input))
}
const errorInfo: ErroredToolCall = {
callID: part.callID,
toolName: part.tool,
turn: turnCounter,
errorAge: turnAge,
}
state.erroredTools.set(part.callID, errorInfo)
log("[pruning-purge-errors] pruned old error", {
tool: part.tool,
callID: part.callID,
turn: turnCounter,
errorAge: turnAge,
threshold: config.turns,
})
}
}
}
log("[pruning-purge-errors] complete", {
prunedCount,
tokensSaved,
currentTurn,
threshold: config.turns,
})
return prunedCount
}
@@ -1,101 +0,0 @@
import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs"
import { join } from "node:path"
import type { PruningState } from "./pruning-types"
import { estimateTokens } from "./pruning-types"
import { log } from "../../shared/logger"
import { MESSAGE_STORAGE } from "../../features/hook-message-injector"
function getMessageDir(sessionID: string): string | null {
if (!existsSync(MESSAGE_STORAGE)) return null
const directPath = join(MESSAGE_STORAGE, sessionID)
if (existsSync(directPath)) return directPath
for (const dir of readdirSync(MESSAGE_STORAGE)) {
const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
if (existsSync(sessionPath)) return sessionPath
}
return null
}
interface ToolPart {
type: string
callID?: string
tool?: string
state?: {
input?: unknown
output?: string
status?: string
}
}
interface MessageData {
parts?: ToolPart[]
[key: string]: unknown
}
export async function applyPruning(
sessionID: string,
state: PruningState
): Promise<number> {
const messageDir = getMessageDir(sessionID)
if (!messageDir) {
log("[pruning-storage] message dir not found", { sessionID })
return 0
}
let totalTokensSaved = 0
let filesModified = 0
try {
const files = readdirSync(messageDir).filter(f => f.endsWith(".json"))
for (const file of files) {
const filePath = join(messageDir, file)
const content = readFileSync(filePath, "utf-8")
const data: MessageData = JSON.parse(content)
if (!data.parts) continue
let modified = false
for (const part of data.parts) {
if (part.type !== "tool" || !part.callID) continue
if (!state.toolIdsToPrune.has(part.callID)) continue
if (part.state?.input) {
const inputStr = JSON.stringify(part.state.input)
totalTokensSaved += estimateTokens(inputStr)
part.state.input = { __pruned: true, reason: "DCP" }
modified = true
}
if (part.state?.output) {
totalTokensSaved += estimateTokens(part.state.output)
part.state.output = "[Content pruned by Dynamic Context Pruning]"
modified = true
}
}
if (modified) {
writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8")
filesModified++
}
}
} catch (error) {
log("[pruning-storage] error applying pruning", {
sessionID,
error: String(error),
})
}
log("[pruning-storage] applied pruning", {
sessionID,
filesModified,
totalTokensSaved,
})
return totalTokensSaved
}
@@ -1,212 +0,0 @@
import { existsSync, readdirSync, readFileSync } from "node:fs"
import { join } from "node:path"
import type { PruningState, FileOperation } from "./pruning-types"
import { estimateTokens } from "./pruning-types"
import { log } from "../../shared/logger"
import { MESSAGE_STORAGE } from "../../features/hook-message-injector"
export interface SupersedeWritesConfig {
enabled: boolean
aggressive: boolean
}
interface ToolPart {
type: string
callID?: string
tool?: string
state?: {
input?: unknown
output?: string
}
}
interface MessagePart {
type: string
parts?: ToolPart[]
}
function getMessageDir(sessionID: string): string | null {
if (!existsSync(MESSAGE_STORAGE)) return null
const directPath = join(MESSAGE_STORAGE, sessionID)
if (existsSync(directPath)) return directPath
for (const dir of readdirSync(MESSAGE_STORAGE)) {
const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
if (existsSync(sessionPath)) return sessionPath
}
return null
}
function readMessages(sessionID: string): MessagePart[] {
const messageDir = getMessageDir(sessionID)
if (!messageDir) return []
const messages: MessagePart[] = []
try {
const files = readdirSync(messageDir).filter(f => f.endsWith(".json"))
for (const file of files) {
const content = readFileSync(join(messageDir, file), "utf-8")
const data = JSON.parse(content)
if (data.parts) {
messages.push(data)
}
}
} catch {
return []
}
return messages
}
function extractFilePath(toolName: string, input: unknown): string | null {
if (!input || typeof input !== "object") return null
const inputObj = input as Record<string, unknown>
if (toolName === "write" || toolName === "edit" || toolName === "read") {
if (typeof inputObj.filePath === "string") {
return inputObj.filePath
}
}
return null
}
export function executeSupersedeWrites(
sessionID: string,
state: PruningState,
config: SupersedeWritesConfig,
protectedTools: Set<string>
): number {
if (!config.enabled) return 0
const messages = readMessages(sessionID)
const writesByFile = new Map<string, FileOperation[]>()
const readsByFile = new Map<string, number[]>()
let currentTurn = 0
for (const msg of messages) {
if (!msg.parts) continue
for (const part of msg.parts) {
if (part.type === "step-start") {
currentTurn++
continue
}
if (part.type !== "tool" || !part.callID || !part.tool) continue
if (protectedTools.has(part.tool)) continue
if (state.toolIdsToPrune.has(part.callID)) continue
const filePath = extractFilePath(part.tool, part.state?.input)
if (!filePath) continue
if (part.tool === "write" || part.tool === "edit") {
if (!writesByFile.has(filePath)) {
writesByFile.set(filePath, [])
}
writesByFile.get(filePath)!.push({
callID: part.callID,
tool: part.tool,
filePath,
turn: currentTurn,
})
if (!state.fileOperations.has(filePath)) {
state.fileOperations.set(filePath, [])
}
state.fileOperations.get(filePath)!.push({
callID: part.callID,
tool: part.tool,
filePath,
turn: currentTurn,
})
} else if (part.tool === "read") {
if (!readsByFile.has(filePath)) {
readsByFile.set(filePath, [])
}
readsByFile.get(filePath)!.push(currentTurn)
}
}
}
let prunedCount = 0
let tokensSaved = 0
for (const [filePath, writes] of writesByFile) {
const reads = readsByFile.get(filePath) || []
if (config.aggressive) {
for (const write of writes) {
const superseded = reads.some(readTurn => readTurn > write.turn)
if (superseded) {
state.toolIdsToPrune.add(write.callID)
prunedCount++
const input = findToolInput(messages, write.callID)
if (input) {
tokensSaved += estimateTokens(JSON.stringify(input))
}
log("[pruning-supersede] pruned superseded write", {
tool: write.tool,
callID: write.callID,
turn: write.turn,
filePath,
})
}
}
} else {
if (writes.length > 1) {
for (const write of writes.slice(0, -1)) {
const superseded = reads.some(readTurn => readTurn > write.turn)
if (superseded) {
state.toolIdsToPrune.add(write.callID)
prunedCount++
const input = findToolInput(messages, write.callID)
if (input) {
tokensSaved += estimateTokens(JSON.stringify(input))
}
log("[pruning-supersede] pruned superseded write (conservative)", {
tool: write.tool,
callID: write.callID,
turn: write.turn,
filePath,
})
}
}
}
}
}
log("[pruning-supersede] complete", {
prunedCount,
tokensSaved,
filesTracked: writesByFile.size,
mode: config.aggressive ? "aggressive" : "conservative",
})
return prunedCount
}
function findToolInput(messages: MessagePart[], callID: string): unknown | null {
for (const msg of messages) {
if (!msg.parts) continue
for (const part of msg.parts) {
if (part.type === "tool" && part.callID === callID && part.state?.input) {
return part.state.input
}
}
}
return null
}