CodeBurn - Local Dashboard

+ {c.label} +
+ {r[c.key]} +

/.git/worktrees/. Only the latter should canonicalize to + // the main repo. A parent directory with a stray .git directory must not + // absorb sibling projects. + // Guard against foreign paths (e.g. a Windows path recorded on a machine + // that now runs macOS): only walk paths that look like absolute paths on the + // current platform. A relative or foreign-format path cannot be walked on + // the current filesystem without risking false positives. + const isAbsoluteOnCurrentPlatform = process.platform === 'win32' + ? /^[a-zA-Z]:[/\\]/.test(trimmed) + : trimmed.startsWith('/') + if (!isAbsoluteOnCurrentPlatform) return { path: cwd, isWorktree: false } + + let dir = trimmed + while (true) { + const gitEntry = join(dir, '.git') + const entryStat = await lstat(gitEntry).catch(() => null) + if (entryStat?.isDirectory()) { + return { path: dir === trimmed ? dir : cwd, isWorktree: false } + } + if (entryStat?.isFile()) { + const gitFile = await readFile(gitEntry, 'utf-8').catch(() => null) + if (gitFile === null) return { path: dir === trimmed ? dir : cwd, isWorktree: false } + const match = gitFile.match(/^gitdir:\s*(.+?)\s*$/m) + if (!match?.[1]) return { path: dir === trimmed ? dir : cwd, isWorktree: false } + const gitDir = resolve(dir, match[1]) + const normalizedGitDir = gitDir.replace(/\\/g, '/') + const worktreeMarker = '/.git/worktrees/' + const markerIndex = normalizedGitDir.lastIndexOf(worktreeMarker) + if (markerIndex === -1) return { path: dir === trimmed ? dir : cwd, isWorktree: false } + return { path: normalizedGitDir.slice(0, markerIndex), isWorktree: true } + } + const parent = dirname(dir) + if (parent === dir) return { path: cwd, isWorktree: false } + dir = parent + } +} + +const LARGE_JSONL_LINE_BYTES = 32 * 1024 + +export function parseJsonlLine(line: string | Buffer): JournalEntry | null { + if (Buffer.isBuffer(line)) { + if (line.length > LARGE_JSONL_LINE_BYTES) return parseLargeJsonlBuffer(line) + try { + return JSON.parse(line.toString('utf-8')) as JournalEntry + } catch { + return null + } + } + if (line.length > LARGE_JSONL_LINE_BYTES) return parseLargeJsonlLine(line) + try { + return JSON.parse(line) as JournalEntry + } catch { + return null + } +} + +const RAW_HEAD_BYTES = 2048 + +type JsonValueBounds = { + start: number + end: number + kind: 'string' | 'object' | 'array' | 'scalar' +} + +function findJsonStringEnd(source: string, start: number, limit = source.length): number { + for (let i = start + 1; i < limit; i++) { + const ch = source.charCodeAt(i) + if (ch === 0x5c) { + i++ + continue + } + if (ch === 0x22) return i + } + return -1 +} + +function findJsonContainerEnd(source: string, start: number, open: number, close: number, limit = source.length): number { + let depth = 0 + let inString = false + for (let i = start; i < limit; i++) { + const ch = source.charCodeAt(i) + if (inString) { + if (ch === 0x5c) { + i++ + } else if (ch === 0x22) { + inString = false + } + continue + } + if (ch === 0x22) { + inString = true + } else if (ch === open) { + depth++ + } else if (ch === close) { + depth-- + if (depth === 0) return i + } + } + return -1 +} + +function findJsonValueBounds(source: string, start: number, limit = source.length): JsonValueBounds | null { + let i = start + while (i < limit && /\s/.test(source[i]!)) i++ + if (i >= limit) return null + const ch = source.charCodeAt(i) + if (ch === 0x22) { + const end = findJsonStringEnd(source, i, limit) + return end === -1 ? null : { start: i, end: end + 1, kind: 'string' } + } + if (ch === 0x7b) { + const end = findJsonContainerEnd(source, i, 0x7b, 0x7d, limit) + return end === -1 ? null : { start: i, end: end + 1, kind: 'object' } + } + if (ch === 0x5b) { + const end = findJsonContainerEnd(source, i, 0x5b, 0x5d, limit) + return end === -1 ? null : { start: i, end: end + 1, kind: 'array' } + } + let end = i + while (end < limit) { + const c = source.charCodeAt(end) + if (c === 0x2c || c === 0x7d || c === 0x5d || /\s/.test(source[end]!)) break + end++ + } + return { start: i, end, kind: 'scalar' } +} + +function findObjectFieldValue(source: string, objectStart: number, objectEnd: number, field: string): JsonValueBounds | null { + if (source.charCodeAt(objectStart) !== 0x7b) return null + let i = objectStart + 1 + while (i < objectEnd - 1) { + while (i < objectEnd && /\s/.test(source[i]!)) i++ + if (source.charCodeAt(i) === 0x2c) { + i++ + continue + } + if (source.charCodeAt(i) !== 0x22) { + i++ + continue + } + const keyEnd = findJsonStringEnd(source, i, objectEnd) + if (keyEnd === -1) return null + const key = source.slice(i + 1, keyEnd) + i = keyEnd + 1 + while (i < objectEnd && /\s/.test(source[i]!)) i++ + if (source.charCodeAt(i) !== 0x3a) continue + const value = findJsonValueBounds(source, i + 1, objectEnd) + if (!value) return null + if (key === field) return value + i = value.end + } + return null +} + +function readJsonString(source: string, bounds: JsonValueBounds | null, cap = Number.POSITIVE_INFINITY): string | undefined { + if (!bounds || bounds.kind !== 'string') return undefined + let out = '' + for (let i = bounds.start + 1; i < bounds.end - 1 && out.length < cap; i++) { + const ch = source[i]! + if (ch !== '\\') { + out += ch + continue + } + const next = source[++i] + if (!next) break + if (next === 'n') out += '\n' + else if (next === 'r') out += '\r' + else if (next === 't') out += '\t' + else if (next === 'b') out += '\b' + else if (next === 'f') out += '\f' + else if (next === 'u' && i + 4 < bounds.end) { + const hex = source.slice(i + 1, i + 5) + const code = Number.parseInt(hex, 16) + if (Number.isFinite(code)) out += String.fromCharCode(code) + i += 4 + } else { + out += next + } + } + return out +} + +function readJsonNumberField(source: string, objectBounds: JsonValueBounds | null, field: string): number | undefined { + if (!objectBounds || objectBounds.kind !== 'object') return undefined + const bounds = findObjectFieldValue(source, objectBounds.start, objectBounds.end, field) + if (!bounds) return undefined + const value = Number(source.slice(bounds.start, bounds.end)) + return Number.isFinite(value) ? value : undefined +} + +function parseLargeUsage(source: string, usageBounds: JsonValueBounds | null) { + const usage: AssistantMessageContent['usage'] = { + input_tokens: readJsonNumberField(source, usageBounds, 'input_tokens') ?? 0, + output_tokens: readJsonNumberField(source, usageBounds, 'output_tokens') ?? 0, + cache_creation_input_tokens: readJsonNumberField(source, usageBounds, 'cache_creation_input_tokens'), + cache_read_input_tokens: readJsonNumberField(source, usageBounds, 'cache_read_input_tokens'), + } + + if (usageBounds?.kind === 'object') { + const cacheCreation = findObjectFieldValue(source, usageBounds.start, usageBounds.end, 'cache_creation') + const ephemeral5m = readJsonNumberField(source, cacheCreation, 'ephemeral_5m_input_tokens') + const ephemeral1h = readJsonNumberField(source, cacheCreation, 'ephemeral_1h_input_tokens') + if (ephemeral5m !== undefined || ephemeral1h !== undefined) { + ;(usage as AssistantMessageContent['usage']).cache_creation = { + ...(ephemeral5m !== undefined ? { ephemeral_5m_input_tokens: ephemeral5m } : {}), + ...(ephemeral1h !== undefined ? { ephemeral_1h_input_tokens: ephemeral1h } : {}), + } + } + + const serverToolUse = findObjectFieldValue(source, usageBounds.start, usageBounds.end, 'server_tool_use') + const webSearch = readJsonNumberField(source, serverToolUse, 'web_search_requests') + const webFetch = readJsonNumberField(source, serverToolUse, 'web_fetch_requests') + if (webSearch !== undefined || webFetch !== undefined) { + ;(usage as AssistantMessageContent['usage']).server_tool_use = { + ...(webSearch !== undefined ? { web_search_requests: webSearch } : {}), + ...(webFetch !== undefined ? { web_fetch_requests: webFetch } : {}), + } + } + + const speed = readJsonString(source, findObjectFieldValue(source, usageBounds.start, usageBounds.end, 'speed')) + if (speed === 'standard' || speed === 'fast') usage.speed = speed + } + + return usage +} + +function extractLargeToolBlocks(source: string, contentBounds: JsonValueBounds | null): ToolUseBlock[] { + if (!contentBounds || contentBounds.kind !== 'array') return [] + const tools: ToolUseBlock[] = [] + let i = contentBounds.start + 1 + while (i < contentBounds.end - 1 && tools.length < MAX_TOOL_BLOCKS) { + while (i < contentBounds.end && /\s/.test(source[i]!)) i++ + if (source.charCodeAt(i) === 0x2c) { + i++ + continue + } + if (source.charCodeAt(i) !== 0x7b) { + i++ + continue + } + const objectEnd = findJsonContainerEnd(source, i, 0x7b, 0x7d, contentBounds.end) + if (objectEnd === -1) break + const objectBounds = { start: i, end: objectEnd + 1, kind: 'object' as const } + const blockType = readJsonString(source, findObjectFieldValue(source, objectBounds.start, objectBounds.end, 'type')) + if (blockType === 'tool_use') { + const name = readJsonString(source, findObjectFieldValue(source, objectBounds.start, objectBounds.end, 'name')) ?? '' + const id = readJsonString(source, findObjectFieldValue(source, objectBounds.start, objectBounds.end, 'id')) ?? '' + const inputBounds = findObjectFieldValue(source, objectBounds.start, objectBounds.end, 'input') + const input: Record = {} + if (inputBounds?.kind === 'object') { + if (name === 'Skill') { + const skill = readJsonString(source, findObjectFieldValue(source, inputBounds.start, inputBounds.end, 'skill'), 200) + const skillName = readJsonString(source, findObjectFieldValue(source, inputBounds.start, inputBounds.end, 'name'), 200) + if (skill !== undefined) input['skill'] = skill + if (skillName !== undefined) input['name'] = skillName + } else if (name === 'Read' || name === 'FileReadTool' || EDIT_TOOLS.has(name)) { + const filePath = readJsonString(source, findObjectFieldValue(source, inputBounds.start, inputBounds.end, 'file_path'), BASH_COMMAND_CAP) + if (filePath !== undefined) input['file_path'] = filePath + } else if (name === 'Agent' || name === 'Task') { + const subagentType = readJsonString(source, findObjectFieldValue(source, inputBounds.start, inputBounds.end, 'subagent_type'), 200) + if (subagentType !== undefined) input['subagent_type'] = subagentType + } else if (BASH_TOOLS.has(name)) { + const command = readJsonString(source, findObjectFieldValue(source, inputBounds.start, inputBounds.end, 'command'), BASH_COMMAND_CAP) + if (command !== undefined) input['command'] = command + } + } + tools.push({ type: 'tool_use', id, name, input }) + } + i = objectEnd + 1 + } + return tools +} + +function extractLargeUserText(source: string, contentBounds: JsonValueBounds | null): string | undefined { + if (!contentBounds) return undefined + if (contentBounds.kind === 'string') return readJsonString(source, contentBounds, USER_TEXT_CAP) + if (contentBounds.kind !== 'array') return undefined + + let text = '' + let i = contentBounds.start + 1 + while (i < contentBounds.end - 1 && text.length < USER_TEXT_CAP) { + while (i < contentBounds.end && /\s/.test(source[i]!)) i++ + if (source.charCodeAt(i) === 0x2c) { + i++ + continue + } + if (source.charCodeAt(i) !== 0x7b) { + i++ + continue + } + const objectEnd = findJsonContainerEnd(source, i, 0x7b, 0x7d, contentBounds.end) + if (objectEnd === -1) break + const objectBounds = { start: i, end: objectEnd + 1, kind: 'object' as const } + const type = readJsonString(source, findObjectFieldValue(source, objectBounds.start, objectBounds.end, 'type')) + if (type === 'text' || type === 'input_text') { + const part = readJsonString( + source, + findObjectFieldValue(source, objectBounds.start, objectBounds.end, 'text'), + USER_TEXT_CAP - text.length, + ) + if (part) text += (text ? ' ' : '') + part + } + i = objectEnd + 1 + } + return text || undefined +} + +function extractLargeAddedNames(source: string, attachmentBounds: JsonValueBounds | null): string[] { + if (!attachmentBounds || attachmentBounds.kind !== 'object') return [] + const attachmentType = readJsonString(source, findObjectFieldValue(source, attachmentBounds.start, attachmentBounds.end, 'type')) + if (attachmentType !== 'deferred_tools_delta') return [] + const addedNames = findObjectFieldValue(source, attachmentBounds.start, attachmentBounds.end, 'addedNames') + if (!addedNames || addedNames.kind !== 'array') return [] + const names: string[] = [] + let i = addedNames.start + 1 + while (i < addedNames.end - 1 && names.length < MAX_ADDED_NAMES) { + while (i < addedNames.end && /\s/.test(source[i]!)) i++ + if (source.charCodeAt(i) === 0x2c) { + i++ + continue + } + if (source.charCodeAt(i) !== 0x22) { + i++ + continue + } + const end = findJsonStringEnd(source, i, addedNames.end) + if (end === -1) break + const name = readJsonString(source, { start: i, end: end + 1, kind: 'string' }, 500) + if (name) names.push(name) + i = end + 1 + } + return names +} + +function parseLargeJsonlLine(line: string): JournalEntry | null { + const rootEnd = findJsonContainerEnd(line, 0, 0x7b, 0x7d) + if (rootEnd === -1) return null + const rootStart = 0 + const rootLimit = rootEnd + 1 + const type = readJsonString(line, findObjectFieldValue(line, rootStart, rootLimit, 'type')) + if (!type) return null + + const entry: JournalEntry = { type } + const timestamp = readJsonString(line, findObjectFieldValue(line, rootStart, rootLimit, 'timestamp')) + const sessionId = readJsonString(line, findObjectFieldValue(line, rootStart, rootLimit, 'sessionId')) + const cwd = readJsonString(line, findObjectFieldValue(line, rootStart, rootLimit, 'cwd')) + if (timestamp !== undefined) entry.timestamp = timestamp + if (sessionId !== undefined) entry.sessionId = sessionId + if (cwd !== undefined) entry.cwd = cwd + const addedNames = extractLargeAddedNames(line, findObjectFieldValue(line, rootStart, rootLimit, 'attachment')) + if (addedNames.length > 0) { + ;(entry as Record)['attachment'] = { type: 'deferred_tools_delta', addedNames } + } + + if (type === 'user') { + const message = findObjectFieldValue(line, rootStart, rootLimit, 'message') + if (message?.kind === 'object') { + const content = findObjectFieldValue(line, message.start, message.end, 'content') + const text = extractLargeUserText(line, content) + if (text !== undefined) entry.message = { role: 'user', content: text } + } + return entry + } + + if (type !== 'assistant') return entry + const message = findObjectFieldValue(line, rootStart, rootLimit, 'message') + if (message?.kind !== 'object') return entry + const model = readJsonString(line, findObjectFieldValue(line, message.start, message.end, 'model')) + const usageBounds = findObjectFieldValue(line, message.start, message.end, 'usage') + if (!model || usageBounds?.kind !== 'object') return entry + const id = readJsonString(line, findObjectFieldValue(line, message.start, message.end, 'id')) + const contentBounds = findObjectFieldValue(line, message.start, message.end, 'content') + + entry.message = { + type: 'message', + role: 'assistant', + model, + ...(id !== undefined ? { id } : {}), + content: extractLargeToolBlocks(line, contentBounds), + usage: parseLargeUsage(line, usageBounds), + } + + return entry +} + +type BufferJsonValueBounds = { + start: number + end: number + kind: 'string' | 'object' | 'array' | 'scalar' +} + +function isJsonWhitespaceByte(ch: number | undefined): boolean { + return ch === 0x20 || ch === 0x0a || ch === 0x0d || ch === 0x09 +} + +function findJsonStringEndBuffer(source: Buffer, start: number, limit = source.length): number { + for (let i = start + 1; i < limit; i++) { + const ch = source[i] + if (ch === 0x5c) { + i++ + continue + } + if (ch === 0x22) return i + } + return -1 +} + +function findJsonContainerEndBuffer(source: Buffer, start: number, open: number, close: number, limit = source.length): number { + let depth = 0 + let inString = false + for (let i = start; i < limit; i++) { + const ch = source[i] + if (inString) { + if (ch === 0x5c) { + i++ + } else if (ch === 0x22) { + inString = false + } + continue + } + if (ch === 0x22) { + inString = true + } else if (ch === open) { + depth++ + } else if (ch === close) { + depth-- + if (depth === 0) return i + } + } + return -1 +} + +function findJsonValueBoundsBuffer(source: Buffer, start: number, limit = source.length): BufferJsonValueBounds | null { + let i = start + while (i < limit && isJsonWhitespaceByte(source[i])) i++ + if (i >= limit) return null + const ch = source[i] + if (ch === 0x22) { + const end = findJsonStringEndBuffer(source, i, limit) + return end === -1 ? null : { start: i, end: end + 1, kind: 'string' } + } + if (ch === 0x7b) { + const end = findJsonContainerEndBuffer(source, i, 0x7b, 0x7d, limit) + return end === -1 ? null : { start: i, end: end + 1, kind: 'object' } + } + if (ch === 0x5b) { + const end = findJsonContainerEndBuffer(source, i, 0x5b, 0x5d, limit) + return end === -1 ? null : { start: i, end: end + 1, kind: 'array' } + } + let end = i + while (end < limit) { + const c = source[end] + if (c === 0x2c || c === 0x7d || c === 0x5d || isJsonWhitespaceByte(c)) break + end++ + } + return { start: i, end, kind: 'scalar' } +} + +function bufferKeyEquals(source: Buffer, keyStart: number, keyEnd: number, field: string): boolean { + if (keyEnd - keyStart !== field.length) return false + return source.subarray(keyStart, keyEnd).equals(Buffer.from(field)) +} + +function findObjectFieldValueBuffer(source: Buffer, objectStart: number, objectEnd: number, field: string): BufferJsonValueBounds | null { + if (source[objectStart] !== 0x7b) return null + let i = objectStart + 1 + while (i < objectEnd - 1) { + while (i < objectEnd && isJsonWhitespaceByte(source[i])) i++ + if (source[i] === 0x2c) { + i++ + continue + } + if (source[i] !== 0x22) { + i++ + continue + } + const keyEnd = findJsonStringEndBuffer(source, i, objectEnd) + if (keyEnd === -1) return null + const keyStart = i + 1 + i = keyEnd + 1 + while (i < objectEnd && isJsonWhitespaceByte(source[i])) i++ + if (source[i] !== 0x3a) continue + const value = findJsonValueBoundsBuffer(source, i + 1, objectEnd) + if (!value) return null + if (bufferKeyEquals(source, keyStart, keyEnd, field)) return value + i = value.end + } + return null +} + +function appendBufferJsonSegment(source: Buffer, start: number, end: number, current: string, cap: number): string { + if (start >= end || current.length >= cap) return current + const remaining = cap - current.length + const cappedEnd = Number.isFinite(cap) ? Math.min(end, start + remaining * 4) : end + return current + source.subarray(start, cappedEnd).toString('utf-8').slice(0, remaining) +} + +function readJsonStringBuffer(source: Buffer, bounds: BufferJsonValueBounds | null, cap = Number.POSITIVE_INFINITY): string | undefined { + if (!bounds || bounds.kind !== 'string') return undefined + let out = '' + let segmentStart = bounds.start + 1 + for (let i = bounds.start + 1; i < bounds.end - 1 && out.length < cap; i++) { + const ch = source[i] + if (ch !== 0x5c) continue + + out = appendBufferJsonSegment(source, segmentStart, i, out, cap) + if (out.length >= cap) break + const next = source[++i] + if (next === undefined) break + if (next === 0x6e) out += '\n' + else if (next === 0x72) out += '\r' + else if (next === 0x74) out += '\t' + else if (next === 0x62) out += '\b' + else if (next === 0x66) out += '\f' + else if (next === 0x75 && i + 4 < bounds.end) { + const hex = source.subarray(i + 1, i + 5).toString('ascii') + const code = Number.parseInt(hex, 16) + if (Number.isFinite(code)) out += String.fromCharCode(code) + i += 4 + } else { + out += String.fromCharCode(next) + } + segmentStart = i + 1 + } + return appendBufferJsonSegment(source, segmentStart, bounds.end - 1, out, cap) +} + +function readJsonNumberFieldBuffer(source: Buffer, objectBounds: BufferJsonValueBounds | null, field: string): number | undefined { + if (!objectBounds || objectBounds.kind !== 'object') return undefined + const bounds = findObjectFieldValueBuffer(source, objectBounds.start, objectBounds.end, field) + if (!bounds) return undefined + const value = Number(source.subarray(bounds.start, bounds.end).toString('ascii')) + return Number.isFinite(value) ? value : undefined +} + +function parseLargeUsageBuffer(source: Buffer, usageBounds: BufferJsonValueBounds | null) { + const usage: AssistantMessageContent['usage'] = { + input_tokens: readJsonNumberFieldBuffer(source, usageBounds, 'input_tokens') ?? 0, + output_tokens: readJsonNumberFieldBuffer(source, usageBounds, 'output_tokens') ?? 0, + cache_creation_input_tokens: readJsonNumberFieldBuffer(source, usageBounds, 'cache_creation_input_tokens'), + cache_read_input_tokens: readJsonNumberFieldBuffer(source, usageBounds, 'cache_read_input_tokens'), + } + + if (usageBounds?.kind === 'object') { + const cacheCreation = findObjectFieldValueBuffer(source, usageBounds.start, usageBounds.end, 'cache_creation') + const ephemeral5m = readJsonNumberFieldBuffer(source, cacheCreation, 'ephemeral_5m_input_tokens') + const ephemeral1h = readJsonNumberFieldBuffer(source, cacheCreation, 'ephemeral_1h_input_tokens') + if (ephemeral5m !== undefined || ephemeral1h !== undefined) { + ;(usage as AssistantMessageContent['usage']).cache_creation = { + ...(ephemeral5m !== undefined ? { ephemeral_5m_input_tokens: ephemeral5m } : {}), + ...(ephemeral1h !== undefined ? { ephemeral_1h_input_tokens: ephemeral1h } : {}), + } + } + + const serverToolUse = findObjectFieldValueBuffer(source, usageBounds.start, usageBounds.end, 'server_tool_use') + const webSearch = readJsonNumberFieldBuffer(source, serverToolUse, 'web_search_requests') + const webFetch = readJsonNumberFieldBuffer(source, serverToolUse, 'web_fetch_requests') + if (webSearch !== undefined || webFetch !== undefined) { + ;(usage as AssistantMessageContent['usage']).server_tool_use = { + ...(webSearch !== undefined ? { web_search_requests: webSearch } : {}), + ...(webFetch !== undefined ? { web_fetch_requests: webFetch } : {}), + } + } + + const speed = readJsonStringBuffer(source, findObjectFieldValueBuffer(source, usageBounds.start, usageBounds.end, 'speed')) + if (speed === 'standard' || speed === 'fast') usage.speed = speed + } + + return usage +} + +function extractLargeToolBlocksBuffer(source: Buffer, contentBounds: BufferJsonValueBounds | null): ToolUseBlock[] { + if (!contentBounds || contentBounds.kind !== 'array') return [] + const tools: ToolUseBlock[] = [] + let i = contentBounds.start + 1 + while (i < contentBounds.end - 1 && tools.length < MAX_TOOL_BLOCKS) { + while (i < contentBounds.end && isJsonWhitespaceByte(source[i])) i++ + if (source[i] === 0x2c) { + i++ + continue + } + if (source[i] !== 0x7b) { + i++ + continue + } + const objectEnd = findJsonContainerEndBuffer(source, i, 0x7b, 0x7d, contentBounds.end) + if (objectEnd === -1) break + const objectBounds = { start: i, end: objectEnd + 1, kind: 'object' as const } + const blockType = readJsonStringBuffer(source, findObjectFieldValueBuffer(source, objectBounds.start, objectBounds.end, 'type')) + if (blockType === 'tool_use') { + const name = readJsonStringBuffer(source, findObjectFieldValueBuffer(source, objectBounds.start, objectBounds.end, 'name')) ?? '' + const id = readJsonStringBuffer(source, findObjectFieldValueBuffer(source, objectBounds.start, objectBounds.end, 'id')) ?? '' + const inputBounds = findObjectFieldValueBuffer(source, objectBounds.start, objectBounds.end, 'input') + const input: Record = {} + if (inputBounds?.kind === 'object') { + if (name === 'Skill') { + const skill = readJsonStringBuffer(source, findObjectFieldValueBuffer(source, inputBounds.start, inputBounds.end, 'skill'), 200) + const skillName = readJsonStringBuffer(source, findObjectFieldValueBuffer(source, inputBounds.start, inputBounds.end, 'name'), 200) + if (skill !== undefined) input['skill'] = skill + if (skillName !== undefined) input['name'] = skillName + } else if (name === 'Read' || name === 'FileReadTool' || EDIT_TOOLS.has(name)) { + const filePath = readJsonStringBuffer(source, findObjectFieldValueBuffer(source, inputBounds.start, inputBounds.end, 'file_path'), BASH_COMMAND_CAP) + if (filePath !== undefined) input['file_path'] = filePath + } else if (name === 'Agent' || name === 'Task') { + const subagentType = readJsonStringBuffer(source, findObjectFieldValueBuffer(source, inputBounds.start, inputBounds.end, 'subagent_type'), 200) + if (subagentType !== undefined) input['subagent_type'] = subagentType + } else if (BASH_TOOLS.has(name)) { + const command = readJsonStringBuffer(source, findObjectFieldValueBuffer(source, inputBounds.start, inputBounds.end, 'command'), BASH_COMMAND_CAP) + if (command !== undefined) input['command'] = command + } + } + tools.push({ type: 'tool_use', id, name, input }) + } + i = objectEnd + 1 + } + return tools +} + +function extractLargeUserTextBuffer(source: Buffer, contentBounds: BufferJsonValueBounds | null): string | undefined { + if (!contentBounds) return undefined + if (contentBounds.kind === 'string') return readJsonStringBuffer(source, contentBounds, USER_TEXT_CAP) + if (contentBounds.kind !== 'array') return undefined + + let text = '' + let i = contentBounds.start + 1 + while (i < contentBounds.end - 1 && text.length < USER_TEXT_CAP) { + while (i < contentBounds.end && isJsonWhitespaceByte(source[i])) i++ + if (source[i] === 0x2c) { + i++ + continue + } + if (source[i] !== 0x7b) { + i++ + continue + } + const objectEnd = findJsonContainerEndBuffer(source, i, 0x7b, 0x7d, contentBounds.end) + if (objectEnd === -1) break + const objectBounds = { start: i, end: objectEnd + 1, kind: 'object' as const } + const type = readJsonStringBuffer(source, findObjectFieldValueBuffer(source, objectBounds.start, objectBounds.end, 'type')) + if (type === 'text' || type === 'input_text') { + const part = readJsonStringBuffer( + source, + findObjectFieldValueBuffer(source, objectBounds.start, objectBounds.end, 'text'), + USER_TEXT_CAP - text.length, + ) + if (part) text += (text ? ' ' : '') + part + } + i = objectEnd + 1 + } + return text || undefined +} + +function extractLargeAddedNamesBuffer(source: Buffer, attachmentBounds: BufferJsonValueBounds | null): string[] { + if (!attachmentBounds || attachmentBounds.kind !== 'object') return [] + const attachmentType = readJsonStringBuffer( + source, + findObjectFieldValueBuffer(source, attachmentBounds.start, attachmentBounds.end, 'type'), + ) + if (attachmentType !== 'deferred_tools_delta') return [] + const addedNames = findObjectFieldValueBuffer(source, attachmentBounds.start, attachmentBounds.end, 'addedNames') + if (!addedNames || addedNames.kind !== 'array') return [] + const names: string[] = [] + let i = addedNames.start + 1 + while (i < addedNames.end - 1 && names.length < MAX_ADDED_NAMES) { + while (i < addedNames.end && isJsonWhitespaceByte(source[i])) i++ + if (source[i] === 0x2c) { + i++ + continue + } + if (source[i] !== 0x22) { + i++ + continue + } + const end = findJsonStringEndBuffer(source, i, addedNames.end) + if (end === -1) break + const name = readJsonStringBuffer(source, { start: i, end: end + 1, kind: 'string' }, 500) + if (name) names.push(name) + i = end + 1 + } + return names +} + +function parseLargeJsonlBuffer(line: Buffer): JournalEntry | null { + let rootStart = 0 + while (rootStart < line.length && isJsonWhitespaceByte(line[rootStart])) rootStart++ + if (line[rootStart] !== 0x7b) return null + const rootEnd = findJsonContainerEndBuffer(line, rootStart, 0x7b, 0x7d) + if (rootEnd === -1) return null + const rootLimit = rootEnd + 1 + const type = readJsonStringBuffer(line, findObjectFieldValueBuffer(line, rootStart, rootLimit, 'type')) + if (!type) return null + + const entry: JournalEntry = { type } + const timestamp = readJsonStringBuffer(line, findObjectFieldValueBuffer(line, rootStart, rootLimit, 'timestamp')) + const sessionId = readJsonStringBuffer(line, findObjectFieldValueBuffer(line, rootStart, rootLimit, 'sessionId')) + const cwd = readJsonStringBuffer(line, findObjectFieldValueBuffer(line, rootStart, rootLimit, 'cwd')) + if (timestamp !== undefined) entry.timestamp = timestamp + if (sessionId !== undefined) entry.sessionId = sessionId + if (cwd !== undefined) entry.cwd = cwd + const addedNames = extractLargeAddedNamesBuffer(line, findObjectFieldValueBuffer(line, rootStart, rootLimit, 'attachment')) + if (addedNames.length > 0) { + ;(entry as Record)['attachment'] = { type: 'deferred_tools_delta', addedNames } + } + + if (type === 'user') { + const message = findObjectFieldValueBuffer(line, rootStart, rootLimit, 'message') + if (message?.kind === 'object') { + const content = findObjectFieldValueBuffer(line, message.start, message.end, 'content') + const text = extractLargeUserTextBuffer(line, content) + if (text !== undefined) entry.message = { role: 'user', content: text } + } + return entry + } + + if (type !== 'assistant') return entry + const message = findObjectFieldValueBuffer(line, rootStart, rootLimit, 'message') + if (message?.kind !== 'object') return entry + const model = readJsonStringBuffer(line, findObjectFieldValueBuffer(line, message.start, message.end, 'model')) + const usageBounds = findObjectFieldValueBuffer(line, message.start, message.end, 'usage') + if (!model || usageBounds?.kind !== 'object') return entry + const id = readJsonStringBuffer(line, findObjectFieldValueBuffer(line, message.start, message.end, 'id')) + const contentBounds = findObjectFieldValueBuffer(line, message.start, message.end, 'content') + + entry.message = { + type: 'message', + role: 'assistant', + model, + ...(id !== undefined ? { id } : {}), + content: extractLargeToolBlocksBuffer(line, contentBounds), + usage: parseLargeUsageBuffer(line, usageBounds), + } + + return entry +} + +function getTopLevelRawJsonStringField(head: string, field: string): string | null { + let i = 0 + while (i < head.length && /\s/.test(head[i]!)) i++ + if (head.charCodeAt(i) !== 0x7b) return null + i++ + while (i < head.length) { + while (i < head.length && /\s/.test(head[i]!)) i++ + if (head.charCodeAt(i) === 0x2c) { + i++ + continue + } + if (head.charCodeAt(i) === 0x7d) return null + if (head.charCodeAt(i) !== 0x22) return null + const keyEnd = findJsonStringEnd(head, i) + if (keyEnd === -1) return null + const key = head.slice(i + 1, keyEnd) + i = keyEnd + 1 + while (i < head.length && /\s/.test(head[i]!)) i++ + if (head.charCodeAt(i) !== 0x3a) return null + const value = findJsonValueBounds(head, i + 1) + if (!value) return null + if (key === field) return readJsonString(head, value) ?? null + i = value.end + } + return null +} + +export function shouldSkipLine(line: string, threshold: string): boolean { + const head = line.length > RAW_HEAD_BYTES ? line.slice(0, RAW_HEAD_BYTES) : line + const type = getTopLevelRawJsonStringField(head, 'type') + if (type !== 'user' && type !== 'assistant') return false + const ts = getTopLevelRawJsonStringField(head, 'timestamp') + if (!ts || ts.length < 10) return false + return ts < threshold +} + +const USER_TEXT_CAP = 2000 +const BASH_COMMAND_CAP = 2000 +const MAX_TOOL_BLOCKS = 500 +const MAX_ADDED_NAMES = 1000 + +export function compactEntry(raw: JournalEntry): JournalEntry { + const entry: JournalEntry = { type: raw.type } + + if (raw.timestamp !== undefined) entry.timestamp = raw.timestamp + if (raw.sessionId !== undefined) entry.sessionId = raw.sessionId + if (raw.cwd !== undefined) entry.cwd = raw.cwd + + const att = (raw as Record)['attachment'] + if (att && typeof att === 'object') { + const a = att as Record + if (a['type'] === 'deferred_tools_delta' && Array.isArray(a['addedNames'])) { + const names: string[] = [] + for (let i = 0; i < Math.min(a['addedNames'].length, MAX_ADDED_NAMES); i++) { + const n = a['addedNames'][i] + if (typeof n === 'string') names.push(n) + } + ;(entry as Record)['attachment'] = { type: 'deferred_tools_delta', addedNames: names } + } + } + + if (!raw.message) return entry + + if (raw.message.role === 'user') { + const content = raw.message.content + if (typeof content === 'string') { + entry.message = { role: 'user', content: content.slice(0, USER_TEXT_CAP) } + } else if (Array.isArray(content)) { + let remaining = USER_TEXT_CAP + const blocks: { type: 'text'; text: string }[] = [] + for (const b of content) { + if (remaining <= 0) break + if (!b || typeof b !== 'object' || b.type !== 'text') continue + const text = (b as { text?: unknown }).text + if (typeof text !== 'string') continue + const sliced = text.slice(0, remaining) + blocks.push({ type: 'text', text: sliced }) + remaining -= sliced.length + } + entry.message = { role: 'user', content: blocks } + } + return entry + } + + const msg = raw.message as AssistantMessageContent + if (!msg.usage || !msg.model) return entry + + const rawContent = msg.content + const contentArr = Array.isArray(rawContent) ? rawContent : [] + const toolBlocks = contentArr.filter((b): b is ToolUseBlock => b != null && typeof b === 'object' && b.type === 'tool_use') + const compactContent: ContentBlock[] = toolBlocks.slice(0, MAX_TOOL_BLOCKS).map(tb => { + let input: Record = {} + if (tb.name === 'Skill') { + const ri = (tb.input ?? {}) as Record + if (typeof ri['skill'] === 'string') input['skill'] = (ri['skill'] as string).slice(0, 200) + if (typeof ri['name'] === 'string') input['name'] = (ri['name'] as string).slice(0, 200) + } else if (tb.name === 'Read' || tb.name === 'FileReadTool' || EDIT_TOOLS.has(tb.name)) { + const ri = (tb.input ?? {}) as Record + if (typeof ri['file_path'] === 'string') input['file_path'] = (ri['file_path'] as string).slice(0, BASH_COMMAND_CAP) + } else if (tb.name === 'Agent' || tb.name === 'Task') { + const ri = (tb.input ?? {}) as Record + if (typeof ri['subagent_type'] === 'string') input['subagent_type'] = (ri['subagent_type'] as string).slice(0, 200) + } else if (BASH_TOOLS.has(tb.name)) { + const ri = (tb.input ?? {}) as Record + if (typeof ri['command'] === 'string') { + input['command'] = (ri['command'] as string).slice(0, BASH_COMMAND_CAP) + } + } + return { type: 'tool_use' as const, id: tb.id ?? '', name: tb.name, input } + }) + + const u = msg.usage + const compactUsage: AssistantMessageContent['usage'] = { + input_tokens: u.input_tokens, + output_tokens: u.output_tokens, + } + if (u.cache_creation_input_tokens) compactUsage.cache_creation_input_tokens = u.cache_creation_input_tokens + if (u.cache_creation) { + compactUsage.cache_creation = { + ...(u.cache_creation.ephemeral_5m_input_tokens ? { ephemeral_5m_input_tokens: u.cache_creation.ephemeral_5m_input_tokens } : {}), + ...(u.cache_creation.ephemeral_1h_input_tokens ? { ephemeral_1h_input_tokens: u.cache_creation.ephemeral_1h_input_tokens } : {}), + } + } + if (u.cache_read_input_tokens) compactUsage.cache_read_input_tokens = u.cache_read_input_tokens + if (u.server_tool_use) { + compactUsage.server_tool_use = { + ...(u.server_tool_use.web_search_requests ? { web_search_requests: u.server_tool_use.web_search_requests } : {}), + ...(u.server_tool_use.web_fetch_requests ? { web_fetch_requests: u.server_tool_use.web_fetch_requests } : {}), + } + } + if (u.speed) compactUsage.speed = u.speed + + entry.message = { + type: 'message', + role: 'assistant', + model: msg.model, + usage: compactUsage, + content: compactContent, + ...(msg.id ? { id: msg.id } : {}), + } + + return entry +} + +function extractToolNames(content: ContentBlock[]): string[] { + return content + .filter((b): b is ToolUseBlock => b.type === 'tool_use') + .map(b => b.name) +} + +function extractMcpTools(tools: string[]): string[] { + return tools.filter(t => t.startsWith('mcp__')) +} + +function extractSkillNames(content: ContentBlock[]): string[] { + return content + .filter((b): b is ToolUseBlock => b.type === 'tool_use' && b.name === 'Skill') + .map(b => { + const input = (b.input ?? {}) as Record + const raw = input['skill'] ?? input['name'] + return typeof raw === 'string' ? raw.trim() : '' + }) + .filter(name => name.length > 0) +} + +function extractSubagentTypes(content: ContentBlock[]): string[] { + return content + .filter((b): b is ToolUseBlock => b.type === 'tool_use' && (b.name === 'Agent' || b.name === 'Task')) + .map(b => { + const input = (b.input ?? {}) as Record + const raw = input['subagent_type'] + return typeof raw === 'string' ? raw.trim() : '' + }) + .filter(name => name.length > 0) +} + +function extractCoreTools(tools: string[]): string[] { + return tools.filter(t => !t.startsWith('mcp__')) +} + +function extractBashCommandsFromContent(content: ContentBlock[]): string[] { + return content + .filter((b): b is ToolUseBlock => b.type === 'tool_use' && BASH_TOOLS.has((b as ToolUseBlock).name)) + .flatMap(b => { + const command = (b.input as Record)?.command + return typeof command === 'string' ? extractBashCommands(command) : [] + }) +} + +function getUserMessageText(entry: JournalEntry): string { + if (!entry.message || entry.message.role !== 'user') return '' + const content = entry.message.content + if (typeof content === 'string') return content + if (Array.isArray(content)) { + return content + .filter((b): b is { type: 'text'; text: string } => b.type === 'text') + .map(b => b.text) + .join(' ') + } + return '' +} + +function getMessageId(entry: JournalEntry): string | null { + if (entry.type !== 'assistant') return null + const msg = entry.message as AssistantMessageContent | undefined + return msg?.id ?? null +} + +export function safeNumber(value: unknown): number { + return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0 +} + +export function isPositiveNumber(value: unknown): value is number { + return typeof value === 'number' && Number.isFinite(value) && value > 0 +} + +function extractClaudeCacheCreation(usage: AssistantMessageContent['usage']): { totalTokens: number; oneHourTokens: number } { + const legacyTotal = safeNumber(usage.cache_creation_input_tokens) + const cacheCreation = usage.cache_creation + const fiveMinuteTokens = safeNumber(cacheCreation?.ephemeral_5m_input_tokens) + const oneHourTokens = safeNumber(cacheCreation?.ephemeral_1h_input_tokens) + const splitTotal = fiveMinuteTokens + oneHourTokens + + if (splitTotal === 0) return { totalTokens: legacyTotal, oneHourTokens: 0 } + + // Valid Claude usage reports the legacy total and split total as equal. + // Keep the larger value so malformed partial splits do not drop tokens. + const totalTokens = Math.max(legacyTotal, splitTotal) + return { + totalTokens, + oneHourTokens: Math.min(oneHourTokens, totalTokens), + } +} + +/// Apply local-model savings accounting to a call. If the raw model name is +/// mapped via `codeburn model-savings`, the call's actual cost is forced +/// to $0 and the hypothetical baseline cost is recorded as `savingsUSD`. +/// Returns the input unchanged when no mapping is configured for the +/// model — keeps the hot path branch-free for the common paid-only case. +function applyLocalModelSavings(call: ParsedApiCall): ParsedApiCall { + const u = call.usage + const savings = calculateLocalModelSavings( + call.model, + u.inputTokens, + u.outputTokens, + u.cacheCreationInputTokens, + u.cacheReadInputTokens, + u.webSearchRequests, + call.speed, + call.cacheCreationOneHourTokens ?? 0, + ) + if (!savings) return call + return { + ...call, + costUSD: 0, + savingsUSD: savings.savingsUSD, + savingsBaselineModel: savings.baselineModel, + isLocalSavings: true, + } +} + +export function parseApiCall(entry: JournalEntry): ParsedApiCall | null { + if (entry.type !== 'assistant') return null + const msg = entry.message as AssistantMessageContent | undefined + if (!msg?.usage || !msg?.model) return null + + const usage = msg.usage + const cacheCreation = extractClaudeCacheCreation(usage) + const tokens: TokenUsage = { + inputTokens: usage.input_tokens ?? 0, + outputTokens: usage.output_tokens ?? 0, + cacheCreationInputTokens: cacheCreation.totalTokens, + cacheReadInputTokens: usage.cache_read_input_tokens ?? 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: usage.server_tool_use?.web_search_requests ?? 0, + } + + // Defensive: a message whose `content` is a string (not an array of blocks) + // would crash the helpers below; normalize so one bad record can't abort the + // whole backfill (issue #441). + const contentBlocks = normalizeContentBlocks(msg.content) + const tools = extractToolNames(contentBlocks) + const skills = extractSkillNames(contentBlocks) + const subagentTypes = extractSubagentTypes(contentBlocks) + const costUSD = calculateCost( + msg.model, + tokens.inputTokens, + tokens.outputTokens, + tokens.cacheCreationInputTokens, + tokens.cacheReadInputTokens, + tokens.webSearchRequests, + usage.speed ?? 'standard', + cacheCreation.oneHourTokens, + ) + + const bashCmds = extractBashCommandsFromContent(contentBlocks) + + const toolSeq: ToolCall[][] = contentBlocks + .filter((b): b is ToolUseBlock => b.type === 'tool_use') + .map(b => { + const call: ToolCall = { tool: b.name } + const inp = (b.input ?? {}) as Record + if (typeof inp['file_path'] === 'string') call.file = inp['file_path'] as string + if (typeof inp['command'] === 'string') call.command = inp['command'] as string + return [call] + }) + + return applyLocalModelSavings({ + provider: 'claude', + model: msg.model, + usage: tokens, + costUSD, + tools, + mcpTools: extractMcpTools(tools), + skills, + subagentTypes, + hasAgentSpawn: tools.includes('Agent'), + hasPlanMode: tools.includes('EnterPlanMode'), + speed: usage.speed ?? 'standard', + timestamp: entry.timestamp ?? '', + bashCommands: bashCmds, + deduplicationKey: msg.id ?? `claude:${entry.timestamp}`, + cacheCreationOneHourTokens: cacheCreation.oneHourTokens || undefined, + toolSequence: toolSeq.length > 0 ? toolSeq : undefined, + }) +} + +export function dedupeStreamingMessageIds(entries: JournalEntry[]): JournalEntry[] { + const firstIdxById = new Map() + const lastIdxById = new Map() + for (let i = 0; i < entries.length; i++) { + const id = getMessageId(entries[i]!) + if (!id) continue + if (!firstIdxById.has(id)) firstIdxById.set(id, i) + lastIdxById.set(id, i) + } + if (lastIdxById.size === 0) return entries + const result: JournalEntry[] = [] + for (let i = 0; i < entries.length; i++) { + const id = getMessageId(entries[i]!) + if (id && lastIdxById.get(id) !== i) continue + if (id && firstIdxById.get(id) !== i) { + const firstTs = entries[firstIdxById.get(id)!]!.timestamp + result.push({ ...entries[i]!, timestamp: firstTs ?? entries[i]!.timestamp }) + continue + } + result.push(entries[i]!) + } + return result +} + +function groupIntoTurns(entries: JournalEntry[], seenMsgIds: Set): ParsedTurn[] { + const turns: ParsedTurn[] = [] + let currentUserMessage = '' + let currentCalls: ParsedApiCall[] = [] + let currentTimestamp = '' + let currentSessionId = '' + + for (const entry of entries) { + if (entry.type === 'user') { + const text = getUserMessageText(entry) + if (text.trim()) { + if (currentCalls.length > 0) { + turns.push({ + userMessage: currentUserMessage, + assistantCalls: currentCalls, + timestamp: currentTimestamp, + sessionId: currentSessionId, + }) + } + currentUserMessage = text + currentCalls = [] + currentTimestamp = entry.timestamp ?? '' + currentSessionId = entry.sessionId ?? '' + } + } else if (entry.type === 'assistant') { + const msgId = getMessageId(entry) + if (msgId && seenMsgIds.has(msgId)) continue + if (msgId) seenMsgIds.add(msgId) + const call = parseApiCall(entry) + if (call) currentCalls.push(call) + } + } + + if (currentCalls.length > 0) { + turns.push({ + userMessage: currentUserMessage, + assistantCalls: currentCalls, + timestamp: currentTimestamp, + sessionId: currentSessionId, + }) + } + + return turns +} + +/** + * Extract MCP tool inventory observed across a session's JSONL entries. + * + * Claude Code emits `attachment.type === "deferred_tools_delta"` entries whose + * `addedNames` array lists every tool currently available at that turn (built-in + * tools plus all `mcp____` names exposed by configured MCP + * servers). Tool inventory can change mid-session if the user reloads MCP + * config, so we union every occurrence rather than trusting only the first. + * + * Built-in tools are filtered out: only `mcp__*` identifiers survive. + */ +// Fully-qualified MCP tool name shape: `mcp____`. Both server +// and tool segments must be non-empty. Names like `mcp__server` (no tool +// segment) or `mcp__server__` (trailing empty tool) would silently pollute +// the inventory and break downstream `split('__')` consumers, so they're +// rejected here. +function isMcpToolName(name: string): boolean { + if (!name.startsWith('mcp__')) return false + const rest = name.slice(5) // strip `mcp__` + const sep = rest.indexOf('__') + if (sep <= 0) return false // missing or empty server + if (sep >= rest.length - 2) return false // missing or empty tool + return true +} + +export function extractMcpInventory(entries: JournalEntry[]): string[] { + const inventory = new Set() + for (const entry of entries) { + const att = entry['attachment'] + if (!att || typeof att !== 'object') continue + const a = att as { type?: unknown; addedNames?: unknown } + if (a.type !== 'deferred_tools_delta') continue + if (!Array.isArray(a.addedNames)) continue + for (const name of a.addedNames) { + if (typeof name !== 'string') continue + if (!isMcpToolName(name)) continue + inventory.add(name) + } + } + if (inventory.size === 0) return [] + return Array.from(inventory).sort() +} + +function extractCanonicalCwd(entries: JournalEntry[]): string | undefined { + for (const entry of entries) { + if (typeof entry.cwd !== 'string') continue + const cwd = entry.cwd.trim() + if (cwd) return cwd + } + return undefined +} + +function buildSessionSummary( + sessionId: string, + project: string, + turns: ClassifiedTurn[], + mcpInventory?: string[], + source?: SessionSourceMetadata, +): SessionSummary { + const modelBreakdown: SessionSummary['modelBreakdown'] = Object.create(null) + const toolBreakdown: SessionSummary['toolBreakdown'] = Object.create(null) + const mcpBreakdown: SessionSummary['mcpBreakdown'] = Object.create(null) + const bashBreakdown: SessionSummary['bashBreakdown'] = Object.create(null) + const categoryBreakdown: SessionSummary['categoryBreakdown'] = Object.create(null) + const skillBreakdown: SessionSummary['skillBreakdown'] = Object.create(null) + const subagentBreakdown: SessionSummary['subagentBreakdown'] = Object.create(null) + + let totalCost = 0 + let totalSavings = 0 + let totalInput = 0 + let totalOutput = 0 + let totalReasoning = 0 + let totalCacheRead = 0 + let totalCacheWrite = 0 + let apiCalls = 0 + let firstTs = '' + let lastTs = '' + + for (const turn of turns) { + const turnCost = turn.assistantCalls.reduce((s, c) => s + c.costUSD, 0) + const turnSavings = turn.assistantCalls.reduce((s, c) => s + (c.savingsUSD ?? 0), 0) + + if (!categoryBreakdown[turn.category]) { + categoryBreakdown[turn.category] = { turns: 0, costUSD: 0, savingsUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 } + } + categoryBreakdown[turn.category].turns++ + categoryBreakdown[turn.category].costUSD += turnCost + categoryBreakdown[turn.category].savingsUSD += turnSavings + if (turn.hasEdits) { + categoryBreakdown[turn.category].editTurns++ + categoryBreakdown[turn.category].retries += turn.retries + if (turn.retries === 0) categoryBreakdown[turn.category].oneShotTurns++ + } + + if (turn.subCategory) { + const skillKey = turn.subCategory + if (!skillBreakdown[skillKey]) { + skillBreakdown[skillKey] = { turns: 0, costUSD: 0, savingsUSD: 0, editTurns: 0, oneShotTurns: 0 } + } + skillBreakdown[skillKey].turns++ + skillBreakdown[skillKey].costUSD += turnCost + skillBreakdown[skillKey].savingsUSD += turnSavings + if (turn.hasEdits) { + skillBreakdown[skillKey].editTurns++ + if (turn.retries === 0) skillBreakdown[skillKey].oneShotTurns++ + } + } + + for (const call of turn.assistantCalls) { + const callSavings = call.savingsUSD ?? 0 + totalCost += call.costUSD + totalSavings += callSavings + totalInput += call.usage.inputTokens + totalOutput += call.usage.outputTokens + totalReasoning += call.usage.reasoningTokens + totalCacheRead += call.usage.cacheReadInputTokens + totalCacheWrite += call.usage.cacheCreationInputTokens + apiCalls++ + + const modelKey = call.provider === 'devin' ? call.model : getShortModelName(call.model) + if (!modelBreakdown[modelKey]) { + modelBreakdown[modelKey] = { + calls: 0, + costUSD: 0, + savingsUSD: 0, + tokens: { inputTokens: 0, outputTokens: 0, cacheCreationInputTokens: 0, cacheReadInputTokens: 0, cachedInputTokens: 0, reasoningTokens: 0, webSearchRequests: 0 }, + } + } + modelBreakdown[modelKey].calls++ + modelBreakdown[modelKey].costUSD += call.costUSD + modelBreakdown[modelKey].savingsUSD += callSavings + modelBreakdown[modelKey].tokens.inputTokens += call.usage.inputTokens + modelBreakdown[modelKey].tokens.outputTokens += call.usage.outputTokens + modelBreakdown[modelKey].tokens.cacheReadInputTokens += call.usage.cacheReadInputTokens + modelBreakdown[modelKey].tokens.cacheCreationInputTokens += call.usage.cacheCreationInputTokens + modelBreakdown[modelKey].tokens.reasoningTokens += call.usage.reasoningTokens + + for (const tool of extractCoreTools(call.tools)) { + toolBreakdown[tool] = toolBreakdown[tool] ?? { calls: 0 } + toolBreakdown[tool].calls++ + } + for (const mcp of call.mcpTools) { + const server = mcp.split('__')[1] ?? mcp + mcpBreakdown[server] = mcpBreakdown[server] ?? { calls: 0 } + mcpBreakdown[server].calls++ + } + for (const cmd of call.bashCommands) { + bashBreakdown[cmd] = bashBreakdown[cmd] ?? { calls: 0 } + bashBreakdown[cmd].calls++ + } + for (const sat of call.subagentTypes) { + subagentBreakdown[sat] = subagentBreakdown[sat] ?? { calls: 0, costUSD: 0, savingsUSD: 0 } + subagentBreakdown[sat].calls++ + subagentBreakdown[sat].costUSD += call.costUSD + subagentBreakdown[sat].savingsUSD += callSavings + } + + if (!firstTs || call.timestamp < firstTs) firstTs = call.timestamp + if (!lastTs || call.timestamp > lastTs) lastTs = call.timestamp + } + } + + return { + sessionId, + project, + firstTimestamp: firstTs || turns[0]?.timestamp || '', + lastTimestamp: lastTs || turns[turns.length - 1]?.timestamp || '', + totalCostUSD: totalCost, + totalSavingsUSD: totalSavings, + totalInputTokens: totalInput, + totalOutputTokens: totalOutput, + totalReasoningTokens: totalReasoning, + totalCacheReadTokens: totalCacheRead, + totalCacheWriteTokens: totalCacheWrite, + apiCalls, + turns, + modelBreakdown, + toolBreakdown, + mcpBreakdown, + bashBreakdown, + categoryBreakdown, + skillBreakdown, + subagentBreakdown, + ...(source ? { source } : {}), + ...(mcpInventory && mcpInventory.length > 0 ? { mcpInventory } : {}), + } +} + +async function parseSessionFile( + filePath: string, + project: string, + seenMsgIds: Set, + dateRange?: DateRange, +): Promise<{ session: SessionSummary; canonicalCwd?: string } | null> { + // Skip files whose mtime is older than the range start. A session file + // can only contain entries up to its last-modified time; if that predates + // the requested range, nothing in this file can match. + if (dateRange) { + try { + const s = await stat(filePath) + if (s.mtimeMs < dateRange.start.getTime()) return null + } catch { /* fall through to normal read; missing stat shouldn't break parsing */ } + } + const entries: JournalEntry[] = [] + let hasLines = false + + // When a dateRange is given, skip user/assistant lines whose timestamp + // is older than range.start - 24h without calling JSON.parse. Huge lines + // that cannot be skipped are yielded as Buffers and compact-parsed without + // converting the whole line into a V8 string. + const earlySkipThreshold = dateRange + ? new Date(dateRange.start.getTime() - 86_400_000).toISOString() + : null + const skipFn = earlySkipThreshold + ? (head: string) => shouldSkipLine(head, earlySkipThreshold) + : undefined + + for await (const line of readSessionLines(filePath, skipFn, { largeLineAsBuffer: true })) { + hasLines = true + const entry = parseJsonlLine(line) + if (entry) entries.push(compactEntry(entry)) + } + + if (!hasLines) return null + + if (entries.length === 0) return null + + const sessionId = basename(filePath, '.jsonl') + const dedupedEntries = dedupeStreamingMessageIds(entries) + let turns = groupIntoTurns(dedupedEntries, seenMsgIds) + if (dateRange) { + // Bucket a turn by the timestamp of its first assistant call (when the cost was + // actually incurred). Filtering entries directly produced orphan assistant calls + // when a user message sat in one day and the response landed in another -- those + // got pushed as turns with empty timestamps, which some code paths counted and + // others dropped, producing inconsistent Today totals. + turns = turns.filter(turn => { + if (turn.assistantCalls.length === 0) return false + const firstCallTs = turn.assistantCalls[0]!.timestamp + if (!firstCallTs) return false + const ts = new Date(firstCallTs) + return ts >= dateRange.start && ts <= dateRange.end + }) + if (turns.length === 0) return null + } + const classified = turns.map(classifyTurn) + + // Inventory is extracted from the full entry stream, not just the + // turns we kept after date filtering: tool availability is set up + // once at the start of a session (with possible mid-session reloads), + // and we want to reflect what was loaded even if the user only ran + // turns inside a narrow date window. + const mcpInventory = extractMcpInventory(entries) + const canonicalCwd = extractCanonicalCwd(entries) + + return { + session: buildSessionSummary(sessionId, project, classified, mcpInventory), + ...(canonicalCwd ? { canonicalCwd } : {}), + } +} + +// Recursively collect every `.jsonl` under `dir`. Subagent transcripts live in +// `subagents/`, and workflow/ultracode runs nest a further level deep +// (`subagents/workflows//agent-*.jsonl`); a flat scan misses those, so their +// usage went uncounted whenever the workflow feature was on. (#470) +async function collectJsonlInto(dir: string, out: Set): Promise { + const entries = await readdir(dir, { withFileTypes: true }).catch(() => []) + for (const e of entries) { + const p = join(dir, e.name) + if (e.isDirectory()) await collectJsonlInto(p, out) + else if (e.name.endsWith('.jsonl')) out.add(p) + } +} + +export async function collectJsonlFiles(dirPath: string): Promise { + const files = await readdir(dirPath).catch(() => []) + const jsonlFiles = new Set(files.filter(f => f.endsWith('.jsonl')).map(f => join(dirPath, f))) + + await collectJsonlInto(join(dirPath, 'subagents'), jsonlFiles) + for (const entry of files) { + if (entry.endsWith('.jsonl')) continue + await collectJsonlInto(join(dirPath, entry, 'subagents'), jsonlFiles) + } + + return [...jsonlFiles] +} + +// Claude Code subagent transcripts (`subagents/.../agent-*.jsonl`) have a sibling +// `.meta.json` carrying the `agentType` (e.g. `workflow-subagent`, `Explore`). +// Returns undefined for ordinary session files, which carry no agent type. +export async function readAgentType(filePath: string): Promise { + if (!/[\\/]subagents[\\/]/.test(filePath)) return undefined + const metaPath = filePath.replace(/\.jsonl$/, '.meta.json') + try { + const t = (JSON.parse(await readFile(metaPath, 'utf8')) as { agentType?: unknown }).agentType + if (typeof t === 'string' && t.trim()) return t.trim().slice(0, 100) + } catch { /* missing or unreadable meta */ } + // Workflow agents always live under `subagents/workflows/`, so fall back to that + // even when the meta sidecar is absent. + return /[\\/]subagents[\\/]workflows[\\/]/.test(filePath) ? 'workflow-subagent' : undefined +} + +async function scanProjectDirs( + dirs: Array<{ path: string; name: string; source?: SessionSourceMetadata }>, + seenMsgIds: Set, + diskCache: SessionCache, + dateRange?: DateRange, +): Promise { + const section = getOrCreateProviderSection(diskCache, 'claude') + const allDiscoveredFiles = new Set() + + type FileInfo = { dirName: string; fp: NonNullable>>; source?: SessionSourceMetadata } + const unchangedFiles: Array<{ filePath: string; dirName: string; source?: SessionSourceMetadata; cached: CachedFile }> = [] + const changedFiles: Array<{ filePath: string; info: FileInfo }> = [] + + const discoverProgress = createScanProgress('scanning claude project dirs', dirs.length) + let dirsDone = 0 + for (const { path: dirPath, name: dirName, source } of dirs) { + const jsonlFiles = await collectJsonlFiles(dirPath) + for (const filePath of jsonlFiles) { + allDiscoveredFiles.add(filePath) + const fp = await fingerprintFile(filePath) + if (!fp) continue + + const action = reconcileFile(fp, section.files[filePath]) + if (action.action === 'unchanged') { + unchangedFiles.push({ filePath, dirName, source, cached: section.files[filePath]! }) + } else { + changedFiles.push({ filePath, info: { dirName, fp, source } }) + } + } + dirsDone++ + await discoverProgress.tick(dirsDone) + } + discoverProgress.finish() + + // Pre-seed dedup set from cached (unchanged) files + for (const { cached } of unchangedFiles) { + for (const turn of cached.turns) { + for (const call of turn.calls) { + seenMsgIds.add(call.deduplicationKey) + } + } + } + + const parseProgress = createScanProgress('parsing changed claude sessions', changedFiles.length) + let filesDone = 0 + for (const { filePath, info } of changedFiles) { + delete section.files[filePath] + + try { + const tracker = { lastCompleteLineOffset: 0 } + const entries = await parseClaudeEntries(filePath, tracker) + if (!entries) { filesDone++; await parseProgress.tick(filesDone); continue } + + const turns = groupIntoTurns(dedupeStreamingMessageIds(entries), seenMsgIds) + const cwd = extractCanonicalCwd(entries) + const canonical = (cwd && !isCoworkSession(cwd, filePath)) ? await resolveCanonicalProjectPath(cwd) : undefined + section.files[filePath] = { + fingerprint: info.fp, + lastCompleteLineOffset: tracker.lastCompleteLineOffset, + canonicalCwd: canonical?.path, + canonicalProjectName: canonical?.isWorktree ? projectNameFromPath(canonical.path, info.dirName) : undefined, + mcpInventory: extractMcpInventory(entries), + turns: turns.map(parsedTurnToCachedTurn), + agentType: await readAgentType(filePath), + } + ;(diskCache as { _dirty?: boolean })._dirty = true + } catch (err) { + // A single malformed Claude session file must not abort the whole run — that + // would empty the daily-cache backfill and wipe the trend/history (issue #441, + // same isolation the provider path already has). Record a failure marker keyed + // by the current fingerprint so it isn't re-read and re-thrown every run; it + // re-parses only if the file changes. + section.files[filePath] = { fingerprint: info.fp, mcpInventory: [], turns: [], failed: true } + ;(diskCache as { _dirty?: boolean })._dirty = true + warnProviderParseFailure('claude', filePath, err) + } + filesDone++ + await parseProgress.tick(filesDone) + } + parseProgress.finish() + + if (dirs.length > 0) { + for (const cachedPath of Object.keys(section.files)) { + if (!allDiscoveredFiles.has(cachedPath)) { + delete section.files[cachedPath] + ;(diskCache as { _dirty?: boolean })._dirty = true + } + } + } + + const projectMap = new Map }>() + + const allFiles = [ + ...unchangedFiles.map(f => ({ filePath: f.filePath, dirName: f.dirName, source: f.source })), + ...changedFiles.map(f => ({ filePath: f.filePath, dirName: f.info.dirName, source: f.info.source })), + ] + + for (const { filePath, dirName, source } of allFiles) { + const cachedFile = section.files[filePath] + if (!cachedFile || cachedFile.turns.length === 0) continue + + let classifiedTurns = cachedFile.turns.map(cachedTurnToClassified) + + if (dateRange) { + classifiedTurns = classifiedTurns.filter(turn => { + if (turn.assistantCalls.length === 0) return false + const firstCallTs = turn.assistantCalls[0]!.timestamp + if (!firstCallTs) return false + const ts = new Date(firstCallTs) + return ts >= dateRange.start && ts <= dateRange.end + }) + } + + if (classifiedTurns.length === 0) continue + + const sessionId = basename(filePath, '.jsonl') + const projectPath = cachedFile.canonicalCwd ?? claudeSlugFallbackPath(dirName) + const projectName = cachedFile.canonicalProjectName ?? dirName + const mcpInv = cachedFile.mcpInventory.length > 0 ? cachedFile.mcpInventory : undefined + const session = buildSessionSummary(sessionId, projectName, classifiedTurns, mcpInv, source) + session.agentType = cachedFile.agentType + + if (session.apiCalls > 0) { + const projectKey = cachedFile.canonicalCwd + ? normalizeProjectPathKey(cachedFile.canonicalCwd) + : `slug:${dirName}` + const existing = projectMap.get(projectKey) + if (existing) { + existing.sessions.push(session) + existing.dirNames.add(dirName) + } else { + projectMap.set(projectKey, { project: projectName, projectPath, sessions: [session], dirNames: new Set([dirName]) }) + } + } + } + + // Fold slug-keyed entries into cwd-keyed entries + const cwdKeyByDirName = new Map() + for (const [key, entry] of projectMap) { + if (key.startsWith('slug:')) continue + for (const dirName of entry.dirNames) { + if (!cwdKeyByDirName.has(dirName)) cwdKeyByDirName.set(dirName, key) + } + } + for (const [key, entry] of [...projectMap]) { + if (!key.startsWith('slug:')) continue + const cwdKey = cwdKeyByDirName.get(entry.project) + if (!cwdKey) continue + const target = projectMap.get(cwdKey)! + target.sessions.push(...entry.sessions) + projectMap.delete(key) + } + + const projects: ProjectSummary[] = [] + for (const { project, projectPath, sessions } of projectMap.values()) { + projects.push(summarizeProject(project, projectPath, sessions)) + } + + return projects +} + +/// Build a ProjectSummary from its sessions, rolling up cost/savings/calls and +/// deriving the proxy attribution. This is the single place proxy matching +/// happens: a project whose canonical path is under a configured `proxyPaths` +/// prefix keeps its full API-rate `totalCostUSD` but records that amount as +/// `totalProxiedCostUSD` (subscription-covered). All ProjectSummary callers go +/// through here so the rule stays consistent across the fresh, cached, and +/// date/day-filtered paths. +function summarizeProject(project: string, projectPath: string, sessions: SessionSummary[]): ProjectSummary { + const totalCostUSD = sessions.reduce((s, sess) => s + sess.totalCostUSD, 0) + return { + project, + projectPath, + sessions, + totalCostUSD, + totalSavingsUSD: sessions.reduce((s, sess) => s + sess.totalSavingsUSD, 0), + totalApiCalls: sessions.reduce((s, sess) => s + sess.apiCalls, 0), + totalProxiedCostUSD: isProxiedPath(projectPath) ? totalCostUSD : 0, + } +} + +function providerCallToTurn(call: ParsedProviderCall): ParsedTurn { + const tools = call.tools + const usage: TokenUsage = { + inputTokens: call.inputTokens, + outputTokens: call.outputTokens, + cacheCreationInputTokens: call.cacheCreationInputTokens, + cacheReadInputTokens: call.cacheReadInputTokens, + cachedInputTokens: call.cachedInputTokens, + reasoningTokens: call.reasoningTokens, + webSearchRequests: call.webSearchRequests, + } + + const apiCall: ParsedApiCall = applyLocalModelSavings({ + provider: call.provider, + model: call.model, + usage, + costUSD: call.costUSD, + tools, + mcpTools: extractMcpTools(tools), + skills: call.skills ?? [], + subagentTypes: call.subagentTypes ?? [], + hasAgentSpawn: tools.includes('Agent'), + hasPlanMode: tools.includes('EnterPlanMode'), + speed: call.speed, + timestamp: call.timestamp, + bashCommands: call.bashCommands, + deduplicationKey: call.deduplicationKey, + }) + + return { + userMessage: call.userMessage, + assistantCalls: [apiCall], + timestamp: call.timestamp, + sessionId: call.sessionId, + } +} + +// ── Cache Conversion ─────────────────────────────────────────────────── + +function providerCallToCachedCall(call: ParsedProviderCall): CachedCall { + return { + provider: call.provider, + model: call.model, + usage: { + inputTokens: call.inputTokens, + outputTokens: call.outputTokens, + cacheCreationInputTokens: call.cacheCreationInputTokens, + cacheReadInputTokens: call.cacheReadInputTokens, + cachedInputTokens: call.cachedInputTokens, + reasoningTokens: call.reasoningTokens, + webSearchRequests: call.webSearchRequests, + cacheCreationOneHourTokens: 0, + }, + costUSD: (call.provider === 'mistral-vibe' || call.provider === 'antigravity' || call.provider === 'devin' || call.provider === 'vercel-gateway' || call.provider === 'hermes') ? call.costUSD : undefined, + speed: call.speed, + timestamp: call.timestamp, + tools: call.tools, + bashCommands: call.bashCommands, + skills: call.skills ?? [], + subagentTypes: call.subagentTypes ?? [], + deduplicationKey: call.deduplicationKey, + project: call.project, + projectPath: call.projectPath, + toolSequence: call.toolSequence, + } +} + +async function canonicalizeProviderCallProject(call: ParsedProviderCall): Promise { + if (!call.projectPath) return call + + const canonical = await resolveCanonicalProjectPath(call.projectPath) + if (!canonical.isWorktree) return call + + return { + ...call, + project: projectNameFromPath(canonical.path, call.project ?? canonical.path), + projectPath: canonical.path, + } +} + +function apiCallToCachedCall(call: ParsedApiCall): CachedCall { + return { + provider: call.provider, + model: call.model, + usage: { ...call.usage, cacheCreationOneHourTokens: call.cacheCreationOneHourTokens ?? 0 }, + speed: call.speed, + timestamp: call.timestamp, + tools: call.tools, + bashCommands: call.bashCommands, + skills: call.skills, + subagentTypes: call.subagentTypes, + deduplicationKey: call.deduplicationKey, + toolSequence: call.toolSequence, + } +} + +function parsedTurnToCachedTurn(turn: ParsedTurn): CachedTurn { + return { + timestamp: turn.timestamp, + sessionId: turn.sessionId, + userMessage: turn.userMessage.slice(0, 2000), + calls: turn.assistantCalls.map(apiCallToCachedCall), + } +} + +function providerCallToCachedTurn(call: ParsedProviderCall): CachedTurn { + return { + timestamp: call.timestamp, + sessionId: call.sessionId, + userMessage: call.userMessage.slice(0, 2000), + calls: [providerCallToCachedCall(call)], + } +} + +function providerCallsToCachedTurns(calls: ParsedProviderCall[]): CachedTurn[] { + const turns: CachedTurn[] = [] + const grouped = new Map() + + for (const call of calls) { + if (!call.turnId) { + turns.push(providerCallToCachedTurn(call)) + continue + } + + const key = `${call.sessionId}\0${call.turnId}` + let turn = grouped.get(key) + if (!turn) { + turn = { + timestamp: call.timestamp, + sessionId: call.sessionId, + userMessage: call.userMessage.slice(0, 2000), + calls: [], + } + grouped.set(key, turn) + turns.push(turn) + } + turn.calls.push(providerCallToCachedCall(call)) + } + + return turns +} + +function cachedCallToApiCall(call: CachedCall): ParsedApiCall { + const u = call.usage + const outputForCost = call.provider === 'claude' + ? u.outputTokens + : u.outputTokens + u.reasoningTokens + const costUSD = calculateCost( + call.model, u.inputTokens, outputForCost, + u.cacheCreationInputTokens, u.cacheReadInputTokens, + u.webSearchRequests, call.speed, u.cacheCreationOneHourTokens, + ) + return applyLocalModelSavings({ + provider: call.provider, + model: call.model, + usage: { + inputTokens: u.inputTokens, + outputTokens: u.outputTokens, + cacheCreationInputTokens: u.cacheCreationInputTokens, + cacheReadInputTokens: u.cacheReadInputTokens, + cachedInputTokens: u.cachedInputTokens, + reasoningTokens: u.reasoningTokens, + webSearchRequests: u.webSearchRequests, + }, + costUSD: call.costUSD ?? costUSD, + tools: call.tools, + mcpTools: extractMcpTools(call.tools), + skills: call.skills, + subagentTypes: call.subagentTypes ?? [], + hasAgentSpawn: call.tools.includes('Agent'), + hasPlanMode: call.tools.includes('EnterPlanMode'), + speed: call.speed, + timestamp: call.timestamp, + bashCommands: call.bashCommands, + deduplicationKey: call.deduplicationKey, + cacheCreationOneHourTokens: u.cacheCreationOneHourTokens || undefined, + toolSequence: call.toolSequence, + }) +} + +function cachedTurnToClassified(turn: CachedTurn): ClassifiedTurn { + const parsed: ParsedTurn = { + userMessage: turn.userMessage, + assistantCalls: turn.calls.map(cachedCallToApiCall), + timestamp: turn.timestamp, + sessionId: turn.sessionId, + } + return classifyTurn(parsed) +} + +// ── Cache-Aware Parsing Helpers ──────────────────────────────────────── + +async function parseClaudeEntries( + filePath: string, + tracker: { lastCompleteLineOffset: number }, +): Promise { + const entries: JournalEntry[] = [] + let hasLines = false + for await (const line of readSessionLines(filePath, undefined, { + largeLineAsBuffer: true, + byteOffsetTracker: tracker, + })) { + hasLines = true + const entry = parseJsonlLine(line) + if (entry) entries.push(compactEntry(entry)) + } + if (!hasLines || entries.length === 0) return null + return entries +} + +function getOrCreateProviderSection(cache: SessionCache, provider: string): ProviderSection { + const envFp = computeEnvFingerprint(provider) + const existing = cache.providers[provider] + if (existing && existing.envFingerprint === envFp) return existing + const section = { envFingerprint: envFp, files: {} } + cache.providers[provider] = section + return section +} + +function cachedFileNeedsProviderReparse(providerName: string, sourcePath: string, cached: CachedFile): boolean { + // Antigravity data comes from the live server, not from the conversation file. + // A 0-turn cache entry may just mean the server was unavailable last run. + if (providerName === 'antigravity') return shouldReparseAntigravitySource(sourcePath, cached.turns.length) + + // Devin transcript usage is enriched from sessions.db. The cache fingerprint + // only tracks the transcript JSON, so reparse to pick up DB-side project, + // title, model, and timestamp changes. + if (providerName === 'devin') return true + + if (providerName !== 'gemini') return false + + return cached.turns.some(turn => + turn.calls.some(call => call.deduplicationKey === `gemini:${turn.sessionId}`), + ) +} + +const warnedProviderReadFailures = new Set() + +function warnProviderReadFailureOnce(providerName: string, err: unknown): void { + const key = `${providerName}:sqlite-busy` + if (warnedProviderReadFailures.has(key)) return + warnedProviderReadFailures.add(key) + if (isSqliteBusyError(err)) { + process.stderr.write( + `codeburn: skipped ${providerName} data because its SQLite database is temporarily locked; will retry on the next refresh.\n` + ) + } +} + +// Warn per offending file (so a systemic break surfaces more than one path), +// but cap per provider per run to avoid a flood. Cached failure markers mean a +// given broken file is only re-encountered when it changes, so this stays quiet +// across refreshes. +const parseFailureCounts = new Map() +const PARSE_FAILURE_WARN_CAP = 5 + +function warnProviderParseFailure(providerName: string, sourcePath: string, err: unknown): void { + const n = (parseFailureCounts.get(providerName) ?? 0) + 1 + parseFailureCounts.set(providerName, n) + if (n > PARSE_FAILURE_WARN_CAP) return + const msg = err instanceof Error ? err.message : String(err) + const tail = n === PARSE_FAILURE_WARN_CAP + ? ` (further ${providerName} parse failures this run are suppressed)` + : '' + process.stderr.write( + `codeburn: skipped ${providerName} session that failed to parse: ${sourcePath} (${msg})${tail}\n` + ) +} + +// A cold-cache scan over a large ~/.claude/projects tree (hundreds of project +// dirs, e.g. a git-worktree-per-task workflow) can run long enough that it +// looks hung, and is CPU-heavy enough on a single thread to visibly compete +// with anything else running interactively on the same machine. Two cheap +// mitigations, neither of which reduces total CPU work: (1) a `\r`-updated +// progress line so a long cold run reads as "working" instead of "stuck", +// gated on isTTY so it never corrupts piped/captured output (export.ts, the +// --no-color path, or a subprocess capturing stderr); (2) yielding to the +// event loop every YIELD_EVERY items so the OS scheduler gets regular break +// points instead of one long uninterrupted synchronous block. This does NOT +// fix CPU contention with a separate process (that's the OS scheduler's job +// regardless), it only keeps this process itself responsive and honest about +// progress during the scan. +const YIELD_EVERY = 25 + +function yieldToEventLoop(): Promise { + return new Promise(resolve => setImmediate(resolve)) +} + +// Suppress the scan-progress line while an interactive Ink UI is live. The +// dashboard and compare render to stdout on the same terminal, and their scans +// run (dashboard) or re-run every 30s (dashboard auto-refresh, including the +// getPlanUsages → parseAllSessions path) AFTER render() has painted a frame, so +// a `\r` progress line on stderr prints over it and garbles the screen. isTTY +// alone can't tell them apart from a plain CLI command. The interactive +// entrypoints call setInteractiveScanUI() right before render(); a pre-render +// scan (e.g. compare's cold start) still shows progress and finish() clears the +// line before Ink paints. +let interactiveScanUI = false +export function setInteractiveScanUI(active = true): void { + interactiveScanUI = active +} + +export function createScanProgress(label: string, total: number) { + const show = !interactiveScanUI && total > 20 && process.stderr.isTTY === true + let lastWrite = 0 + return { + async tick(done: number): Promise { + if (done % YIELD_EVERY === 0) await yieldToEventLoop() + if (!show) return + const now = Date.now() + if (done !== total && now - lastWrite < 100) return + lastWrite = now + process.stderr.write(`\rcodeburn: ${label} ${done}/${total}…`) + }, + finish(): void { + if (!show) return + process.stderr.write('\r\x1b[K') + }, + } +} + +async function parseProviderSources( + providerName: string, + sources: SessionSource[], + seenKeys: Set, + diskCache: SessionCache, + dateRange?: DateRange, +): Promise { + const provider = await getProvider(providerName) + if (!provider) return [] + + const section = getOrCreateProviderSection(diskCache, providerName) + const allDiscoveredFiles = new Set() + + type SourceInfo = { source: SessionSource; fp: NonNullable>> } + const unchangedSources: Array<{ source: SessionSource; cached: CachedFile }> = [] + const changedSources: SourceInfo[] = [] + + for (const source of sources) { + allDiscoveredFiles.add(source.path) + + // Network providers (e.g. Vercel AI Gateway) have no on-disk file — their data + // comes from a live API fetch in createSessionParser. There's nothing to + // fingerprint or incrementally cache, so re-fetch every run with a synthetic + // fingerprint (mtime=now so the date-range filter below never excludes it). + if (provider.network) { + changedSources.push({ source, fp: { dev: 0, ino: 0, mtimeMs: Date.now(), sizeBytes: 0 } }) + continue + } + + const fp = await fingerprintFile(source.path) + if (!fp) continue + + const cached = section.files[source.path] + const action = reconcileFile(fp, cached) + // A cached parse failure at this same fingerprint stays skipped — don't + // re-read a file that already threw and hasn't changed. It re-parses only + // when the file changes (then `reconcileFile` reports non-'unchanged'). + if (action.action === 'unchanged' && cached && (cached.failed || !cachedFileNeedsProviderReparse(providerName, source.path, cached))) { + unchangedSources.push({ source, cached }) + } else { + changedSources.push({ source, fp }) + } + } + + // Parser dedup: cross-provider keys + cached file keys. + // Separate from seenKeys so parsing doesn't suppress query-time output. + const parserDedup = new Set(seenKeys) + for (const { cached } of unchangedSources) { + for (const turn of cached.turns) { + for (const call of turn.calls) { + parserDedup.add(call.deduplicationKey) + } + } + } + + // Parse changed files, update cache + let didParse = false + // Track which paths have already been cleared this pass so that subsequent + // sources sharing the same path (e.g. multiple OTel conversations from one + // agent-traces.db) can accumulate via the merge logic below rather than + // being wiped on every iteration. + const clearedPaths = new Set() + try { + for (const { source, fp } of changedSources) { + if (dateRange) { + if (fp.mtimeMs < dateRange.start.getTime()) continue + } + + // Clear stale entry before parse — but only once per path so that + // multiple sources mapping to the same file path can merge their turns. + // Durable providers (e.g. copilot OTel) never clear existing entries so + // that pruned-away data is preserved for monotonic monthly totals. + if (!provider.durableSources && !clearedPaths.has(source.path)) { + delete section.files[source.path] + clearedPaths.add(source.path) + } + + const parser = provider.createSessionParser(source, parserDedup, dateRange) + + try { + const providerCalls: ParsedProviderCall[] = [] + for await (const call of parser.parse()) { + providerCalls.push(call) + } + const canonicalCalls = await Promise.all(providerCalls.map(canonicalizeProviderCallProject)) + const turns = providerCallsToCachedTurns(canonicalCalls) + + // Store/merge parsed turns into the cache. + // Durable providers use a union-by-deduplicationKey merge: existing turns + // are NEVER deleted (preserves data for spans pruned from the DB), and + // only turns whose dedup keys are not already cached are appended. + // Non-durable providers keep the original overwrite-or-append behaviour. + if (provider.durableSources) { + const existingEntry = section.files[source.path] + if (existingEntry) { + const existingKeys = new Set( + existingEntry.turns.flatMap(t => t.calls.map(c => c.deduplicationKey)) + ) + const newTurns = turns.filter(t => + t.calls.every(c => !existingKeys.has(c.deduplicationKey)) + ) + existingEntry.turns = [...existingEntry.turns, ...newTurns] + existingEntry.fingerprint = fp + } else { + section.files[source.path] = { fingerprint: fp, mcpInventory: [], turns } + } + } else { + // Non-durable: overwrite (clearedPaths already deleted stale entry above) + // or append when multiple sources map to the same path. NOTE: the append + // path assumes discoverSessions yields a unique path per source, which all + // current providers do; it only fires for same-path multi-source providers. + const existingCacheEntry = section.files[source.path] + if (existingCacheEntry) { + existingCacheEntry.turns = [...existingCacheEntry.turns, ...turns] + } else { + section.files[source.path] = { fingerprint: fp, mcpInventory: [], turns } + } + } + didParse = true + ;(diskCache as { _dirty?: boolean })._dirty = true + } catch (err) { + if (isSqliteBusyError(err)) { + warnProviderReadFailureOnce(providerName, err) + continue + } + // A single malformed session file must not abort the entire run — that + // would silently empty the daily-cache backfill and wipe the trend / + // history (issue #441). Record a negative-result marker keyed by the + // current fingerprint so we don't re-read + re-throw this unchanged file + // on every refresh; it re-parses only if it changes. Empty turns => no + // usage contributed. + section.files[source.path] = { fingerprint: fp, mcpInventory: [], turns: [], failed: true } + ;(diskCache as { _dirty?: boolean })._dirty = true + warnProviderParseFailure(providerName, source.path, err) + continue + } + } + } finally { + if (didParse && providerName === 'codex') await flushCodexCache() + if (didParse && providerName === 'antigravity') { + const liveIds = new Set(sources.map(s => antigravityCascadeIdFromPath(s.path))) + await flushAntigravityCache(liveIds) + } + } + + // Stamp the durable flag into the cache section so the orphan-bootstrap in + // parseAllSessions can fast-check without a getProvider() round-trip. + if (provider.durableSources && !section.durable) { + section.durable = true + ;(diskCache as { _dirty?: boolean })._dirty = true + } + + if (sources.length > 0 && !provider.durableSources) { + for (const cachedPath of Object.keys(section.files)) { + if (!allDiscoveredFiles.has(cachedPath)) { + delete section.files[cachedPath] + ;(diskCache as { _dirty?: boolean })._dirty = true + } + } + } + + // 90-day age-out for durable providers: remove entries whose newest call is + // older than 90 days so the cache doesn't grow unboundedly over time. + if (provider.durableSources) { + const cutoffMs = Date.now() - 90 * 24 * 60 * 60 * 1000 + for (const [cachedPath, cachedFile] of Object.entries(section.files)) { + const newestTs = cachedFile.turns + .flatMap(t => t.calls) + .map(c => new Date(c.timestamp).getTime()) + .filter(ts => !isNaN(ts)) + .reduce((max, ts) => Math.max(max, ts), 0) + if (newestTs > 0 && newestTs < cutoffMs) { + delete section.files[cachedPath] + ;(diskCache as { _dirty?: boolean })._dirty = true + } + } + } + + // Query-time: derive SessionSummary from all cached turns. + // Uses seenKeys (shared across providers) for cross-provider dedup. + const sessionMap = new Map() + + for (const source of sources) { + const cachedFile = section.files[source.path] + if (!cachedFile) continue + + for (const turn of cachedFile.turns) { + const hasDup = turn.calls.some(c => seenKeys.has(c.deduplicationKey)) + if (hasDup) continue + + for (const c of turn.calls) seenKeys.add(c.deduplicationKey) + + if (dateRange) { + const callTs = turn.calls[0]?.timestamp + if (!callTs) continue + const ts = new Date(callTs) + if (ts < dateRange.start || ts > dateRange.end) continue + } + + const classified = cachedTurnToClassified(turn) + const project = turn.calls[0]?.project ?? source.project + const key = `${providerName}:${turn.sessionId}:${project}` + + const existing = sessionMap.get(key) + if (existing) { + existing.turns.push(classified) + if (!existing.projectPath && turn.calls[0]?.projectPath) { + existing.projectPath = turn.calls[0]!.projectPath + } + } else { + sessionMap.set(key, { project, projectPath: turn.calls[0]?.projectPath, turns: [classified] }) + } + } + } + + // Second pass: durable orphans — cache entries for paths that are no longer + // discovered (e.g. OTel conversations pruned from the DB). Their turns are + // counted here so the monthly total never drops. + if (provider.durableSources) { + for (const [cachedPath, cachedFile] of Object.entries(section.files)) { + if (allDiscoveredFiles.has(cachedPath)) continue // already counted above + + for (const turn of cachedFile.turns) { + const hasDup = turn.calls.some(c => seenKeys.has(c.deduplicationKey)) + if (hasDup) continue + + for (const c of turn.calls) seenKeys.add(c.deduplicationKey) + + if (dateRange) { + const callTs = turn.calls[0]?.timestamp + if (!callTs) continue + const ts = new Date(callTs) + if (ts < dateRange.start || ts > dateRange.end) continue + } + + const classified = cachedTurnToClassified(turn) + const project = turn.calls[0]?.project ?? providerName + const key = `${providerName}:${turn.sessionId}:${project}` + + const existingEntry = sessionMap.get(key) + if (existingEntry) { + existingEntry.turns.push(classified) + if (!existingEntry.projectPath && turn.calls[0]?.projectPath) { + existingEntry.projectPath = turn.calls[0]!.projectPath + } + } else { + sessionMap.set(key, { project, projectPath: turn.calls[0]?.projectPath, turns: [classified] }) + } + } + } + } + + const projectMap = new Map() + for (const [key, { project, projectPath, turns }] of sessionMap) { + const sessionId = key.split(':')[1] ?? key + const session = buildSessionSummary(sessionId, project, turns) + if (session.apiCalls > 0) { + const existing = projectMap.get(project) + if (existing) { + existing.sessions.push(session) + if (!existing.projectPath && projectPath) existing.projectPath = projectPath + } else { + projectMap.set(project, { projectPath, sessions: [session] }) + } + } + } + + const projects: ProjectSummary[] = [] + for (const [dirName, { projectPath, sessions }] of projectMap) { + projects.push(summarizeProject(dirName, projectPath ?? unsanitizePath(dirName), sessions)) + } + + return projects +} + +const CACHE_TTL_MS = 180_000 +const MAX_CACHE_ENTRIES = 10 +const sessionCache = new Map() + +function cacheKey(dateRange?: DateRange, providerFilter?: string): string { + const s = dateRange ? `${dateRange.start.getTime()}:${dateRange.end.getTime()}` : 'none' + // Include the Claude config-dir env so a config change in a long-lived + // process (menubar / GNOME extension / test workers) does not return + // stale data keyed under a previous configuration. + const claudeEnv = (process.env['CLAUDE_CONFIG_DIRS'] ?? '') + '|' + (process.env['CLAUDE_CONFIG_DIR'] ?? '') + // Proxy attribution (totalProxiedCostUSD) is computed live from proxyPaths and + // then cached, so the key must change when that config changes. + return `${s}:${providerFilter ?? 'all'}:${claudeEnv}:${getProxyPathsConfigHash()}` +} + +export function clearSessionCache(): void { + sessionCache.clear() +} + +function cachePut(key: string, data: ProjectSummary[]) { + const now = Date.now() + for (const [k, v] of sessionCache) { + if (now - v.ts > CACHE_TTL_MS) sessionCache.delete(k) + } + if (sessionCache.size >= MAX_CACHE_ENTRIES) { + const oldest = [...sessionCache.entries()].sort((a, b) => a[1].ts - b[1].ts)[0] + if (oldest) sessionCache.delete(oldest[0]) + } + sessionCache.set(key, { data, ts: now }) +} + +export function filterProjectsByName( + projects: ProjectSummary[], + include?: string[], + exclude?: string[], +): ProjectSummary[] { + let result = projects + if (include && include.length > 0) { + const patterns = include.map(s => s.toLowerCase()) + result = result.filter(p => { + const name = p.project.toLowerCase() + const path = p.projectPath.toLowerCase() + return patterns.some(pat => name.includes(pat) || path.includes(pat)) + }) + } + if (exclude && exclude.length > 0) { + const patterns = exclude.map(s => s.toLowerCase()) + result = result.filter(p => { + const name = p.project.toLowerCase() + const path = p.projectPath.toLowerCase() + return !patterns.some(pat => name.includes(pat) || path.includes(pat)) + }) + } + return result +} + +function turnIsInDateRange(turn: ClassifiedTurn, dateRange: DateRange): boolean { + if (turn.assistantCalls.length === 0) return false + const firstCallTs = turn.assistantCalls[0]!.timestamp + if (!firstCallTs) return false + const ts = new Date(firstCallTs) + return ts >= dateRange.start && ts <= dateRange.end +} + +function turnDayString(turn: ClassifiedTurn): string | null { + if (turn.assistantCalls.length === 0) return null + const ts = turn.assistantCalls[0]!.timestamp + if (!ts) return null + const d = new Date(ts) + const y = d.getFullYear() + const m = String(d.getMonth() + 1).padStart(2, '0') + const day = String(d.getDate()).padStart(2, '0') + return `${y}-${m}-${day}` +} + +export function filterProjectsByDays(projects: ProjectSummary[], days: Set): ProjectSummary[] { + const filtered: ProjectSummary[] = [] + for (const project of projects) { + const sessions: SessionSummary[] = [] + for (const session of project.sessions) { + const turns = session.turns.filter(turn => { + const ds = turnDayString(turn) + return ds !== null && days.has(ds) + }) + if (turns.length === 0) continue + sessions.push(buildSessionSummary(session.sessionId, session.project, turns, session.mcpInventory, session.source)) + } + if (sessions.length === 0) continue + filtered.push(summarizeProject(project.project, project.projectPath, sessions)) + } + return filtered.sort((a, b) => b.totalCostUSD - a.totalCostUSD) +} + +export function filterProjectsByClaudeConfigSource(projects: ProjectSummary[], sourceId: string): ProjectSummary[] { + const filtered: ProjectSummary[] = [] + for (const project of projects) { + // Match by source id across both claude-config and claude-desktop kinds so + // the Claude Desktop bucket is selectable too. + const sessions = project.sessions.filter(session => + session.source?.id === sourceId + ) + if (sessions.length === 0) continue + filtered.push(summarizeProject(project.project, project.projectPath, sessions)) + } + return filtered.sort((a, b) => b.totalCostUSD - a.totalCostUSD) +} + +export function filterProjectsByDateRange(projects: ProjectSummary[], dateRange: DateRange): ProjectSummary[] { + const filtered: ProjectSummary[] = [] + for (const project of projects) { + const sessions: SessionSummary[] = [] + for (const session of project.sessions) { + const turns = session.turns.filter(turn => turnIsInDateRange(turn, dateRange)) + if (turns.length === 0) continue + sessions.push(buildSessionSummary(session.sessionId, session.project, turns, session.mcpInventory, session.source)) + } + if (sessions.length === 0) continue + filtered.push(summarizeProject(project.project, project.projectPath, sessions)) + } + return filtered.sort((a, b) => b.totalCostUSD - a.totalCostUSD) +} + +export async function parseAllSessions(dateRange?: DateRange, providerFilter?: string): Promise { + const key = cacheKey(dateRange, providerFilter) + const cached = sessionCache.get(key) + if (cached && Date.now() - cached.ts < CACHE_TTL_MS) return cached.data + + const diskCache = await loadCache() + await cleanupOrphanedTempFiles() + + const seenMsgIds = new Set() + const seenKeys = new Set() + const allSources = await discoverAllSessions(providerFilter) + + const claudeSources = allSources.filter(s => s.provider === 'claude') + const nonClaudeSources = allSources.filter(s => s.provider !== 'claude') + + const claudeDirs = claudeSources.map(s => ({ + path: s.path, + name: s.project, + source: s.sourceId && s.sourceLabel && s.sourcePath && s.sourceKind + ? { id: s.sourceId, label: s.sourceLabel, path: s.sourcePath, kind: s.sourceKind } + : undefined, + })) + const claudeProjects = await scanProjectDirs(claudeDirs, seenMsgIds, diskCache, dateRange) + + const providerGroups = new Map() + for (const source of nonClaudeSources) { + const existing = providerGroups.get(source.provider) ?? [] + existing.push(source) + providerGroups.set(source.provider, existing) + } + + const otherProjects: ProjectSummary[] = [] + for (const [providerName, sources] of providerGroups) { + const projects = await parseProviderSources(providerName, sources, seenKeys, diskCache, dateRange) + otherProjects.push(...projects) + } + + // Durable providers with cached data but NO discovered sources (all files pruned + // by VS Code / the external tool) still need their orphan pass to run so the + // monthly total never drops. Call parseProviderSources with empty sources for + // any such provider found in the disk cache. + const processedProviders = new Set(providerGroups.keys()) + for (const providerName of Object.keys(diskCache.providers)) { + if (processedProviders.has(providerName)) continue + // Skip if filtered to a different provider + if (providerFilter && providerFilter !== 'all' && providerFilter !== providerName) continue + const section = diskCache.providers[providerName] + if (!section || Object.keys(section.files).length === 0) continue + // Use the persisted durable flag (set by parseProviderSources when it first + // processes a durableSources provider) OR the static DURABLE_PROVIDER_NAMES + // constant — both checks are O(1) and avoid a getProvider() dynamic-import + // round-trip for every unprocessed provider in the disk cache. + if (!section.durable && !DURABLE_PROVIDER_NAMES.has(providerName)) continue + const projects = await parseProviderSources(providerName, [], seenKeys, diskCache, dateRange) + otherProjects.push(...projects) + } + + if ((diskCache as { _dirty?: boolean })._dirty) { + try { await saveCache(diskCache) } catch {} + } + + // Merge across providers by normalised project path so the same repository + // is not double-counted when it was worked on with more than one tool + // (e.g. both Claude Code and Codex). Two sub-problems: + // + // 1. Codex's sanitizeProject strips the leading '/' from cwds, so + // "Users/carlo/foo" and "/Users/carlo/foo" must compare equal. We + // normalise by stripping leading slashes before keying. + // + // 2. Codex worktrees (e.g. ~/.codex/worktrees/e55f/Repo) are not resolved + // to their main-repo path by canonicalizeProviderCallProject because that + // function only operates on call.projectPath, which Codex doesn't set. + // Resolve at the ProjectSummary level here: prepend '/' if needed to get + // an absolute path, then run the same worktree-detection logic. + const resolvedOtherProjects = await Promise.all(otherProjects.map(async p => { + const absPath = p.projectPath.startsWith('/') || p.projectPath.startsWith('\\') + ? p.projectPath + : '/' + p.projectPath + const canonical = await resolveCanonicalProjectPath(absPath) + // Skip if path is unchanged: same location, not a worktree, not a subdir + if (!canonical.isWorktree && canonical.path === absPath.replace(/[/\\]+$/, '')) return p + return { ...p, project: projectNameFromPath(canonical.path, p.project), projectPath: canonical.path } + })) + + const crossProviderKey = (p: ProjectSummary): string => { + const path = p.projectPath.replace(/\\/g, '/').replace(/^\/+/, '').toLowerCase() + return path.includes('/') ? path : p.project.toLowerCase() + } + const mergedMap = new Map() + for (const p of [...claudeProjects, ...resolvedOtherProjects]) { + const key = crossProviderKey(p) + const existing = mergedMap.get(key) + if (existing) { + existing.sessions.push(...p.sessions) + existing.totalCostUSD += p.totalCostUSD + existing.totalApiCalls += p.totalApiCalls + } else { + mergedMap.set(key, { ...p }) + } + } + + // Re-derive proxy attribution on the merged total: the merge above sums + // totalCostUSD across providers that share a canonical path but never + // recomputed totalProxiedCostUSD, so a merged project (e.g. the same repo + // used with Claude Code + Codex) would otherwise carry the proxied amount of + // only the first-seen provider. The merge key is the canonical path, so both + // sides share the same proxied status — keying off the surviving projectPath + // and the final cost keeps the project-level all-or-nothing rule intact. + for (const p of mergedMap.values()) { + p.totalProxiedCostUSD = isProxiedPath(p.projectPath) ? p.totalCostUSD : 0 + } + + const result = Array.from(mergedMap.values()).sort((a, b) => b.totalCostUSD - a.totalCostUSD) + cachePut(key, result) + return result +} diff --git a/src/persistent-codeburn.ts b/src/persistent-codeburn.ts new file mode 100644 index 0000000..fc04323 --- /dev/null +++ b/src/persistent-codeburn.ts @@ -0,0 +1,66 @@ +import { constants } from 'fs' +import { access } from 'fs/promises' +import { delimiter, join } from 'path' + +export const PERSISTENT_CLI_REQUIRED_MESSAGE = + 'CodeBurn needs a persistent codeburn command. Install CodeBurn globally first: npm install -g codeburn' + +const DEFAULT_CLI_LOOKUP_PATHS = process.platform === 'win32' + ? [] + : ['/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/bin'] + +export function buildPersistentCodeburnLookupPath(existingPath = process.env.PATH ?? ''): string { + const parts = existingPath.split(delimiter).filter(Boolean) + for (const fallback of DEFAULT_CLI_LOOKUP_PATHS) { + if (!parts.includes(fallback)) parts.push(fallback) + } + return parts.join(delimiter) +} + +export function isTransientNpxPath(path: string): boolean { + return path.includes('/_npx/') || path.includes('/.npm/_npx/') || path.includes('\\_npx\\') +} + +function codeburnExecutableNames(): string[] { + if (process.platform !== 'win32') return ['codeburn'] + return ['codeburn.cmd', 'codeburn.exe', 'codeburn.bat', 'codeburn'] +} + +async function executableExists(path: string): Promise { + try { + await access(path, process.platform === 'win32' ? constants.F_OK : constants.F_OK | constants.X_OK) + return true + } catch { + return false + } +} + +export async function resolvePersistentCodeburnPathFromPath( + lookupPath: string, + message: string = PERSISTENT_CLI_REQUIRED_MESSAGE, +): Promise { + const seen = new Set() + for (const dir of lookupPath.split(delimiter).filter(Boolean)) { + for (const executable of codeburnExecutableNames()) { + const candidate = join(dir, executable) + if (seen.has(candidate)) continue + seen.add(candidate) + if (isTransientNpxPath(candidate)) continue + if (await executableExists(candidate)) return candidate + } + } + throw new Error(message) +} + +export function resolvePersistentCodeburnPathFromWhichOutput( + output: string, + message: string = PERSISTENT_CLI_REQUIRED_MESSAGE, +): string { + const paths = output + .split(/\r?\n/) + .map(path => path.trim()) + .filter(Boolean) + const persistentPath = paths.find(path => path.startsWith('/') && !isTransientNpxPath(path)) + if (persistentPath) return persistentPath + throw new Error(message) +} diff --git a/src/plan-usage.ts b/src/plan-usage.ts new file mode 100644 index 0000000..648d3c9 --- /dev/null +++ b/src/plan-usage.ts @@ -0,0 +1,214 @@ +import { readPlans, type Plan, type PlanMap } from './config.js' +import { parseAllSessions } from './parser.js' +import { PLAN_PROVIDERS } from './plans.js' +import type { DateRange, ProjectSummary } from './types.js' + +const MS_PER_DAY = 24 * 60 * 60 * 1000 +const PLAN_NEAR_THRESHOLD_PCT = 80 + +export type PlanStatus = 'under' | 'near' | 'over' + +export type PlanUsage = { + plan: Plan + periodStart: Date + periodEnd: Date + spentApiEquivalentUsd: number + budgetUsd: number + percentUsed: number + status: PlanStatus + projectedMonthUsd: number + daysUntilReset: number +} + +export function clampResetDay(resetDay: number | undefined): number { + if (!Number.isInteger(resetDay)) return 1 + return Math.min(28, Math.max(1, resetDay ?? 1)) +} + +export function computePeriodFromResetDay(resetDay: number | undefined, today: Date): { periodStart: Date; periodEnd: Date } { + const day = clampResetDay(resetDay) + const year = today.getFullYear() + const month = today.getMonth() + + if (today.getDate() >= day) { + return { + periodStart: new Date(year, month, day, 0, 0, 0, 0), + periodEnd: new Date(year, month + 1, day, 0, 0, 0, 0), + } + } + + return { + periodStart: new Date(year, month - 1, day, 0, 0, 0, 0), + periodEnd: new Date(year, month, day, 0, 0, 0, 0), + } +} + +function median(values: number[]): number { + if (values.length === 0) return 0 + const sorted = [...values].sort((a, b) => a - b) + const mid = Math.floor(sorted.length / 2) + if (sorted.length % 2 === 0) { + return (sorted[mid - 1] + sorted[mid]) / 2 + } + return sorted[mid]! +} + +function toLocalDateKey(d: Date): string { + const year = d.getFullYear() + const month = String(d.getMonth() + 1).padStart(2, '0') + const day = String(d.getDate()).padStart(2, '0') + return `${year}-${month}-${day}` +} + +function toDayIndex(d: Date): number { + return Math.floor(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()) / MS_PER_DAY) +} + +function diffCalendarDays(from: Date, to: Date): number { + return toDayIndex(to) - toDayIndex(from) +} + +export function projectMonthEnd( + projects: ProjectSummary[], + periodStart: Date, + periodEnd: Date, + today: Date, + spent: number, +): number { + const dayCosts = new Map() + + for (const project of projects) { + for (const session of project.sessions) { + for (const turn of session.turns) { + for (const call of turn.assistantCalls) { + const timestamp = call.timestamp || turn.timestamp + if (!timestamp) continue + const ts = new Date(timestamp) + if (Number.isNaN(ts.getTime())) continue + if (ts < periodStart || ts > today) continue + const dayKey = toLocalDateKey(ts) + dayCosts.set(dayKey, (dayCosts.get(dayKey) ?? 0) + call.costUSD) + } + } + } + } + + const elapsedDays = Math.max(1, diffCalendarDays(periodStart, today) + 1) + const elapsedDailyCosts: number[] = [] + for (let i = 0; i < elapsedDays; i++) { + const date = new Date(periodStart.getFullYear(), periodStart.getMonth(), periodStart.getDate() + i) + elapsedDailyCosts.push(dayCosts.get(toLocalDateKey(date)) ?? 0) + } + + const trailingWindow = elapsedDailyCosts.slice(-7) + const medianDailyCost = median(trailingWindow) + const daysRemaining = Math.max(0, diffCalendarDays(today, periodEnd) - 1) + + return spent + medianDailyCost * daysRemaining +} + +export function getPlanUsageFromProjects(plan: Plan, projects: ProjectSummary[], today = new Date()): PlanUsage { + const { periodStart, periodEnd } = computePeriodFromResetDay(plan.resetDay, today) + const spent = projects.reduce((sum, p) => sum + p.totalCostUSD, 0) + const budgetUsd = plan.monthlyUsd + const percentUsed = budgetUsd > 0 ? (spent / budgetUsd) * 100 : 0 + const status: PlanStatus = percentUsed > 100 ? 'over' : percentUsed >= PLAN_NEAR_THRESHOLD_PCT ? 'near' : 'under' + const projectedMonthUsd = projectMonthEnd(projects, periodStart, periodEnd, today, spent) + const daysUntilReset = Math.max(0, diffCalendarDays(today, periodEnd)) + + return { + plan, + periodStart, + periodEnd, + spentApiEquivalentUsd: spent, + budgetUsd, + percentUsed, + status, + projectedMonthUsd, + daysUntilReset, + } +} + +function getPlanScopedProjects(plan: Plan, projects: ProjectSummary[], today: Date): ProjectSummary[] { + const { periodStart } = computePeriodFromResetDay(plan.resetDay, today) + const provider = plan.provider + + // These scoped clones are consumed only by plan usage math; cost/call rollups + // are recomputed below, while unrelated breakdown fields remain unchanged. + return projects + .map(project => { + const sessions = project.sessions + .map(session => { + const turns = session.turns + .map(turn => { + const assistantCalls = turn.assistantCalls.filter(call => { + if (provider !== 'all' && call.provider !== provider) return false + const timestamp = call.timestamp || turn.timestamp + if (!timestamp) return false + const ts = new Date(timestamp) + return !Number.isNaN(ts.getTime()) && ts >= periodStart && ts <= today + }) + return assistantCalls.length > 0 ? { ...turn, assistantCalls } : null + }) + .filter((turn): turn is NonNullable => turn !== null) + + const totalCostUSD = turns.reduce( + (sum, turn) => sum + turn.assistantCalls.reduce((turnSum, call) => turnSum + call.costUSD, 0), + 0, + ) + const apiCalls = turns.reduce((sum, turn) => sum + turn.assistantCalls.length, 0) + return apiCalls > 0 ? { ...session, turns, totalCostUSD, apiCalls } : null + }) + .filter((session): session is NonNullable => session !== null) + + const totalCostUSD = sessions.reduce((sum, session) => sum + session.totalCostUSD, 0) + const totalApiCalls = sessions.reduce((sum, session) => sum + session.apiCalls, 0) + return totalApiCalls > 0 ? { ...project, sessions, totalCostUSD, totalApiCalls } : null + }) + .filter((project): project is NonNullable => project !== null) +} + +export async function getPlanUsage(plan: Plan, today = new Date()): Promise { + const { periodStart } = computePeriodFromResetDay(plan.resetDay, today) + const range: DateRange = { + start: periodStart, + end: today, + } + const projects = await parseAllSessions(range, plan.provider) + return getPlanUsageFromProjects(plan, projects, today) +} + +export async function getPlanUsageOrNull(today = new Date()): Promise { + return (await getPlanUsages(today))[0] ?? null +} + +export function activePlansFromMap(plans: PlanMap): Plan[] { + return PLAN_PROVIDERS + .map(provider => plans[provider]) + .filter(isActivePlan) +} + +export async function getPlanUsages(today = new Date()): Promise { + const plans = activePlansFromMap(await readPlans()) + if (plans.length === 0) return [] + + const starts = plans.map(plan => computePeriodFromResetDay(plan.resetDay, today).periodStart.getTime()) + const range: DateRange = { + start: new Date(Math.min(...starts)), + end: today, + } + + if (plans.length === 1) { + const plan = plans[0]! + const projects = await parseAllSessions(range, plan.provider) + return [getPlanUsageFromProjects(plan, projects, today)] + } + + const projects = await parseAllSessions(range, 'all') + + return plans.map(plan => getPlanUsageFromProjects(plan, getPlanScopedProjects(plan, projects, today), today)) +} + +export function isActivePlan(plan: Plan | undefined): plan is Plan { + return plan !== undefined && plan.id !== 'none' && Number.isFinite(plan.monthlyUsd) && plan.monthlyUsd > 0 +} diff --git a/src/plans.ts b/src/plans.ts new file mode 100644 index 0000000..e384e75 --- /dev/null +++ b/src/plans.ts @@ -0,0 +1,79 @@ +import type { Plan, PlanId, PlanProvider } from './config.js' + +export const PLAN_PROVIDERS: PlanProvider[] = ['all', 'claude', 'codex', 'cursor', 'grok'] +export const PLAN_IDS: PlanId[] = ['claude-pro', 'claude-max', 'claude-max-5x', 'cursor-pro', 'supergrok', 'supergrok-heavy', 'custom', 'none'] + +export const PRESET_PLANS: Record<'claude-pro' | 'claude-max' | 'claude-max-5x' | 'cursor-pro' | 'supergrok' | 'supergrok-heavy', Omit> = { + 'claude-pro': { + id: 'claude-pro', + monthlyUsd: 20, + provider: 'claude', + resetDay: 1, + }, + 'claude-max': { + id: 'claude-max', + monthlyUsd: 200, + provider: 'claude', + resetDay: 1, + }, + 'claude-max-5x': { + id: 'claude-max-5x', + monthlyUsd: 100, + provider: 'claude', + resetDay: 1, + }, + 'cursor-pro': { + id: 'cursor-pro', + monthlyUsd: 20, + provider: 'cursor', + resetDay: 1, + }, + 'supergrok': { + id: 'supergrok', + monthlyUsd: 30, + provider: 'grok', + resetDay: 1, + }, + 'supergrok-heavy': { + id: 'supergrok-heavy', + monthlyUsd: 300, + provider: 'grok', + resetDay: 1, + }, +} + +export function isPlanProvider(value: string): value is PlanProvider { + return PLAN_PROVIDERS.includes(value as PlanProvider) +} + +export function isPlanId(value: string): value is PlanId { + return PLAN_IDS.includes(value as PlanId) +} + +export function getPresetPlan(id: string): Omit | null { + if (id in PRESET_PLANS) { + return PRESET_PLANS[id as keyof typeof PRESET_PLANS] + } + return null +} + +export function planDisplayName(id: PlanId): string { + switch (id) { + case 'claude-pro': + return 'Claude Pro' + case 'claude-max': + return 'Claude Max 20x' + case 'claude-max-5x': + return 'Claude Max 5x' + case 'cursor-pro': + return 'Cursor Pro' + case 'supergrok': + return 'SuperGrok' + case 'supergrok-heavy': + return 'SuperGrok Heavy' + case 'custom': + return 'Custom' + case 'none': + return 'None' + } +} diff --git a/src/providers/antigravity.ts b/src/providers/antigravity.ts new file mode 100644 index 0000000..710b4bf --- /dev/null +++ b/src/providers/antigravity.ts @@ -0,0 +1,1351 @@ +import { readdir, readFile, mkdir, stat, open, rename, unlink } from 'fs/promises' +import { execFile } from 'child_process' +import { randomBytes } from 'crypto' +import { basename, join } from 'path' +import { homedir } from 'os' +import { fileURLToPath } from 'url' +import https from 'https' + +import { calculateCost } from '../models.js' +import { isSqliteAvailable, isSqliteBusyError, openDatabase } from '../sqlite.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' + +type AntigravityConversationRoot = { + dir: string + project: string + extensions: readonly string[] +} + +const CONVERSATION_ROOTS: readonly AntigravityConversationRoot[] = [ + { + dir: join(homedir(), '.gemini', 'antigravity', 'conversations'), + project: 'antigravity', + extensions: ['.pb', '.db'], + }, + { + dir: join(homedir(), '.gemini', 'antigravity-cli', 'conversations'), + project: 'antigravity-cli', + extensions: ['.pb', '.db'], + }, + { + dir: join(homedir(), '.gemini', 'antigravity-cli', 'implicit'), + project: 'antigravity-cli', + extensions: ['.pb'], + }, + { + dir: join(homedir(), '.gemini', 'antigravity-ide', 'conversations'), + project: 'antigravity-ide', + extensions: ['.pb', '.db'], + }, + { + dir: join(homedir(), '.gemini', 'antigravity-ide', 'implicit'), + project: 'antigravity-ide', + extensions: ['.pb'], + }, +] as const +const CACHE_VERSION = 2 + +const RPC_TIMEOUT_MS = 5000 +const MAX_RESPONSE_BYTES = 16 * 1024 * 1024 + +export type ServerInfo = { + port: number + csrfToken: string +} + +type ServerCandidate = ServerInfo & { + appDataDir?: 'antigravity' | 'antigravity-cli' | 'antigravity-ide' +} + +type ModelMap = Record + +type UsageEntry = { + model: string + inputTokens: string + outputTokens: string + thinkingOutputTokens?: string + responseOutputTokens?: string + apiProvider: string + responseId?: string +} + +export type GeneratorMetadata = { + stepIndices?: number[] + chatModel?: { + model: string + usage: UsageEntry + chatStartMetadata?: { + createdAt?: string + } + } +} + +type ModelMapResponse = { + models?: Record + response?: { + models?: Record + } +} + +type GeneratorMetadataResponse = { + generatorMetadata?: GeneratorMetadata[] + response?: { + generatorMetadata?: GeneratorMetadata[] + } +} + +type StatusLineCurrentUsage = { + input_tokens?: number + output_tokens?: number + cache_creation_input_tokens?: number + cache_read_input_tokens?: number +} + +type StatusLinePayload = { + conversation_id?: string + session_id?: string + model?: string | { + id?: string + display_name?: string + } + context_window?: { + current_usage?: StatusLineCurrentUsage | null + } +} + +type StatusLineEvent = { + at: string + conversationId: string + sessionId?: string + model: string + usage: { + inputTokens: number + outputTokens: number + cacheCreationInputTokens: number + cacheReadInputTokens: number + } +} + +type CachedCascade = { + mtimeMs: number + sizeBytes: number + calls: ParsedProviderCall[] +} + +type AntigravityCache = { + version: number + cascades: Record +} + +type ProtoField = { + number: number + wireType: number + value?: bigint + bytes?: Uint8Array +} + +type ProtoVarint = { + value: bigint + offset: number +} + +type AntigravityGenMetadataRow = { + idx: number + data: Uint8Array | string +} + +const cachedServers = new Map() +const cachedModelMaps = new Map() +let memCache: AntigravityCache | null = null +let cacheDirty = false +let httpsAgent: https.Agent | undefined +const protoTextDecoder = new TextDecoder('utf-8', { fatal: false }) + +const SERVER_PORT_FLAGS = ['https_server_port', 'extension_server_port', 'https-server-port', 'extension-server-port'] +const CSRF_TOKEN_FLAGS = ['csrf_token', 'extension_server_csrf_token', 'csrf-token', 'extension-server-csrf-token'] +const APP_DATA_DIR_FLAGS = ['app_data_dir', 'app-data-dir'] + +function getAgent(): https.Agent { + if (!httpsAgent) httpsAgent = new https.Agent({ rejectUnauthorized: false }) + return httpsAgent +} + +function getCacheDir(): string { + return process.env['CODEBURN_CACHE_DIR'] ?? join(homedir(), '.cache', 'codeburn') +} + +function getCachePath(): string { + return join(getCacheDir(), 'antigravity-results.json') +} + +export function getAntigravityStatusLineEventsPath(): string { + return join(getCacheDir(), 'antigravity-statusline.jsonl') +} + +function execFileText(command: string, args: string[], timeout = 3000): Promise { + return new Promise((resolve, reject) => { + execFile(command, args, { encoding: 'utf-8', timeout, maxBuffer: 1024 * 1024 }, (err, stdout) => { + if (err) reject(err) + else resolve(stdout) + }) + }) +} + +function getFlagValue(line: string, names: string[]): string | null { + for (const name of names) { + const match = line.match(new RegExp(`--${name}(?:=|\\s+)(?:"([^"]+)"|'([^']+)'|([^\\s]+))`, 'i')) + const value = match?.[1] ?? match?.[2] ?? match?.[3] + if (value && !value.startsWith('--')) return value + } + return null +} + +function isLikelyCsrfToken(value: string): boolean { + return value.length >= 16 && /^[A-Za-z0-9._~:/+=-]+$/.test(value) +} + +function normalizeAppDataDir(value: string | null): 'antigravity' | 'antigravity-cli' | 'antigravity-ide' | undefined { + if (!value) return undefined + const normalized = value.replace(/\\/g, '/').toLowerCase() + if (normalized.includes('antigravity-ide')) return 'antigravity-ide' + if (normalized.includes('antigravity-cli')) return 'antigravity-cli' + if (normalized.includes('antigravity')) return 'antigravity' + return undefined +} + +export function extractAntigravityAppDataDirFromLine(line: string): 'antigravity' | 'antigravity-cli' | 'antigravity-ide' | undefined { + return normalizeAppDataDir(getFlagValue(line, APP_DATA_DIR_FLAGS)) +} + +function parseAntigravityServerCandidateFromLine(line: string): ServerCandidate | null { + const lower = line.toLowerCase() + if (!lower.includes('language_server') || !lower.includes('antigravity')) return null + + const rawPort = getFlagValue(line, SERVER_PORT_FLAGS) + const csrfToken = getFlagValue(line, CSRF_TOKEN_FLAGS) + if (!rawPort || !csrfToken) return null + if (!isLikelyCsrfToken(csrfToken)) return null + + const port = Number(rawPort) + if (!Number.isInteger(port) || port < 0 || port > 65535) return null + + return { + port, + csrfToken, + appDataDir: extractAntigravityAppDataDirFromLine(line), + } +} + +export function parseAntigravityServerInfoFromLine(line: string): ServerInfo | { port: 0; csrfToken: string } | null { + const candidate = parseAntigravityServerCandidateFromLine(line) + return candidate ? { port: candidate.port, csrfToken: candidate.csrfToken } : null +} + +export function parseAntigravityServerInfo(lines: string[]): ServerInfo | null { + for (const line of lines) { + const server = parseAntigravityServerInfoFromLine(line) + if (server) return server + } + return null +} + +function parseAntigravityServerCandidates(lines: string[]): ServerCandidate[] { + return lines + .map(parseAntigravityServerCandidateFromLine) + .filter((server): server is ServerCandidate => server !== null) +} + +function getCanonicalModelId(key: string, displayName?: string): string { + if (displayName) { + const lower = displayName.toLowerCase() + if (lower.includes('3.5 flash')) { + if (lower.includes('high')) return 'gemini-3.5-flash-high' + if (lower.includes('medium')) return 'gemini-3.5-flash-medium' + if (lower.includes('low')) return 'gemini-3.5-flash-low' + return 'gemini-3.5-flash' + } + if (lower.includes('3.1 pro')) { + if (lower.includes('high')) return 'gemini-3.1-pro-high' + if (lower.includes('low')) return 'gemini-3.1-pro-low' + return 'gemini-3.1-pro' + } + if (lower.includes('3.1 flash')) { + if (lower.includes('image')) return 'gemini-3.1-flash-image' + if (lower.includes('lite')) return 'gemini-3.1-flash-lite' + return 'gemini-3.1-flash' + } + if (lower.includes('3 flash')) { + return 'gemini-3-flash' + } + if (lower.includes('3 pro')) { + return 'gemini-3-pro' + } + } + return key +} + +export function extractAntigravityModelMap(resp: unknown): ModelMap { + if (!resp || typeof resp !== 'object') return {} + const data = resp as ModelMapResponse + const models = data.response?.models ?? data.models + const map = new Map() + if (!models) return {} + for (const [key, info] of Object.entries(models)) { + if (info && typeof info === 'object' && typeof info.model === 'string') { + const canonicalKey = getCanonicalModelId(key, info.displayName) + map.set(info.model, canonicalKey) + } + } + return Object.fromEntries(map) +} + +export function extractAntigravityGeneratorMetadata(resp: unknown): GeneratorMetadata[] { + if (!resp || typeof resp !== 'object') return [] + const data = resp as GeneratorMetadataResponse + const metadata = data.response?.generatorMetadata ?? data.generatorMetadata + return Array.isArray(metadata) ? metadata : [] +} + +async function loadCache(): Promise { + if (memCache) return memCache + try { + const raw = await readFile(getCachePath(), 'utf-8') + const cache = JSON.parse(raw) as AntigravityCache + if (cache.version === CACHE_VERSION && cache.cascades && typeof cache.cascades === 'object') { + memCache = cache + return cache + } + } catch { /* no cache or invalid */ } + memCache = { version: CACHE_VERSION, cascades: {} } + return memCache +} + +async function flushCache(liveCascadeIds?: Set): Promise { + if (!memCache) return + // If the caller supplied liveCascadeIds, we must run the eviction step + // even when no cascade was added or updated this run; otherwise deleted + // .pb files would persist in the cache forever once it stops getting + // dirty writes. Mark the cache dirty when an eviction happens so the + // file write below proceeds. + if (liveCascadeIds) { + for (const id of Object.keys(memCache.cascades)) { + if (!liveCascadeIds.has(id)) { + delete memCache.cascades[id] + cacheDirty = true + } + } + } + if (!cacheDirty) return + try { + + const dir = getCacheDir() + await mkdir(dir, { recursive: true }) + const finalPath = getCachePath() + const tempPath = `${finalPath}.${randomBytes(8).toString('hex')}.tmp` + const handle = await open(tempPath, 'w', 0o600) + try { + await handle.writeFile(JSON.stringify(memCache), { encoding: 'utf-8' }) + await handle.sync() + } finally { + await handle.close() + } + try { + await rename(tempPath, finalPath) + } catch { + try { await unlink(tempPath) } catch { /* cleanup */ } + } + cacheDirty = false + } catch { /* best-effort */ } +} + +async function readProcessCommandLines(): Promise { + if (process.platform === 'win32') { + const script = [ + "$ErrorActionPreference = 'SilentlyContinue'", + '[Console]::OutputEncoding = [System.Text.Encoding]::UTF8', + "Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -and $_.CommandLine -like '*language_server*' -and $_.CommandLine -like '*antigravity*' } | ForEach-Object { $_.CommandLine }", + ].join('; ') + const output = await execFileText('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', script], 5000) + return output.split(/\r?\n/) + } + + const output = await execFileText('ps', ['-ww', '-eo', 'args']) + return output.split('\n') +} + +async function resolveEphemeralPort(csrfToken: string, appDataDir?: 'antigravity' | 'antigravity-cli' | 'antigravity-ide'): Promise { + if (process.platform === 'win32') { + try { + const script = [ + "$ErrorActionPreference = 'SilentlyContinue'", + '[Console]::OutputEncoding = [System.Text.Encoding]::UTF8', + "Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -and $_.CommandLine -like '*language_server*' -and $_.CommandLine -like '*antigravity*' } | ForEach-Object { @{ PID = $_.ProcessId; Cmd = $_.CommandLine } | ConvertTo-Json -Compress }" + ].join('; ') + const output = await execFileText('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', script], 5000) + + let targetPid = 0 + for (const line of output.split(/\r?\n/)) { + if (!line.trim()) continue + try { + const proc = JSON.parse(line) as { PID: number; Cmd: string } + const candidate = parseAntigravityServerCandidateFromLine(proc.Cmd) + if (candidate && candidate.csrfToken === csrfToken) { + if (!appDataDir || !candidate.appDataDir || candidate.appDataDir === appDataDir) { + targetPid = proc.PID + break + } + } + } catch { /* skip invalid parse */ } + } + + if (targetPid === 0) return null + + const portScript = `Get-NetTCPConnection -State Listen -OwningProcess ${targetPid} | Select-Object -ExpandProperty LocalPort` + const portOutput = await execFileText('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', portScript], 5000) + const ports = portOutput.split(/\r?\n/) + .map(p => Number(p.trim())) + .filter(p => Number.isInteger(p) && p > 0) + + for (const port of ports) { + try { + await new Promise((resolve, reject) => { + const req = https.request({ + hostname: '127.0.0.1', + port: port, + path: '/exa.language_server_pb.LanguageServerService/GetAvailableModels', + method: 'POST', + headers: { + 'Content-Type': 'application/json', + 'Connect-Protocol-Version': '1', + 'X-Codeium-Csrf-Token': csrfToken, + 'Content-Length': 2, + }, + agent: getAgent(), + timeout: 1000, + }, (res) => { + if (res.statusCode === 200) resolve(true) + else reject(new Error()) + }) + req.on('error', reject) + req.write('{}') + req.end() + }) + return { port, csrfToken } + } catch { /* try next port */ } + } + } catch { /* best-effort */ } + return null + } + + try { + const processOutput = await execFileText('ps', ['-ww', '-eo', 'pid=,args=']) + let pid = '' + for (const line of processOutput.split('\n')) { + const match = line.trim().match(/^(\d+)\s+(.+)$/) + if (!match) continue + const candidate = parseAntigravityServerCandidateFromLine(match[2]!) + if (!candidate) continue + if (candidate.csrfToken !== csrfToken) continue + if (appDataDir && candidate.appDataDir && candidate.appDataDir !== appDataDir) continue + pid = match[1]! + break + } + if (!pid) return null + const lsofOutput = await execFileText('lsof', ['-a', '-i', '-P', '-n', '-p', pid]) + for (const line of lsofOutput.split('\n')) { + if (!line.includes('LISTEN')) continue + const match = line.match(/:(\d+)\s+$LISTEN$/) + if (match) { + const port = Number(match[1]) + if (port > 0) return { port, csrfToken } + } + } + } catch { /* best-effort */ } + return null +} + +export function antigravityAppDataDirFromSourcePath(path: string): 'antigravity' | 'antigravity-cli' | 'antigravity-ide' { + const lower = path.replace(/\\/g, '/').toLowerCase() + if (lower.includes('/.gemini/antigravity-ide/')) return 'antigravity-ide' + if (lower.includes('/.gemini/antigravity-cli/')) return 'antigravity-cli' + return 'antigravity' +} + +async function detectServer(appDataDir: 'antigravity' | 'antigravity-cli' | 'antigravity-ide' = 'antigravity'): Promise { + if (cachedServers.has(appDataDir)) return cachedServers.get(appDataDir)! + try { + const candidates = parseAntigravityServerCandidates(await readProcessCommandLines()) + const info = candidates.find(candidate => candidate.appDataDir === appDataDir) + ?? (appDataDir === 'antigravity' ? candidates.find(candidate => candidate.appDataDir === undefined) : undefined) + ?? null + if (info && info.port > 0 && appDataDir !== 'antigravity-ide') { + cachedServers.set(appDataDir, { port: info.port, csrfToken: info.csrfToken }) + } else if (info) { + cachedServers.set(appDataDir, await resolveEphemeralPort(info.csrfToken, appDataDir)) + } else { + cachedServers.set(appDataDir, null) + } + return cachedServers.get(appDataDir)! + } catch { /* process discovery failed or timed out */ } + cachedServers.set(appDataDir, null) + return null +} + +async function rpc(server: ServerInfo, method: string, body: Record = {}): Promise { + return new Promise((resolve, reject) => { + const data = JSON.stringify(body) + const req = https.request({ + hostname: '127.0.0.1', + port: server.port, + path: `/exa.language_server_pb.LanguageServerService/${method}`, + method: 'POST', + headers: { + 'Content-Type': 'application/json', + 'Connect-Protocol-Version': '1', + 'X-Codeium-Csrf-Token': server.csrfToken, + 'Content-Length': Buffer.byteLength(data), + }, + agent: getAgent(), + timeout: RPC_TIMEOUT_MS, + }, (res) => { + const chunks: Buffer[] = [] + let totalBytes = 0 + res.on('data', (chunk: Buffer) => { + totalBytes += chunk.length + if (totalBytes > MAX_RESPONSE_BYTES) { + res.destroy() + reject(new Error(`RPC ${method}: response too large`)) + return + } + chunks.push(chunk) + }) + res.on('end', () => { + if (res.statusCode !== 200) { + reject(new Error(`RPC ${method}: HTTP ${res.statusCode}`)) + return + } + try { + resolve(JSON.parse(Buffer.concat(chunks).toString('utf-8'))) + } catch { + reject(new Error(`RPC ${method}: invalid JSON`)) + } + }) + res.on('error', reject) + }) + req.on('error', reject) + req.on('timeout', () => { req.destroy(); reject(new Error(`RPC ${method}: timeout`)) }) + req.write(data) + req.end() + }) +} + +async function getModelMap(server: ServerInfo): Promise { + const cacheKey = `${server.port}:${server.csrfToken}` + const cachedModelMap = cachedModelMaps.get(cacheKey) + if (cachedModelMap) return cachedModelMap + try { + const modelMap = extractAntigravityModelMap(await rpc(server, 'GetAvailableModels')) + cachedModelMaps.set(cacheKey, modelMap) + return modelMap + } catch { /* best-effort */ } + cachedModelMaps.set(cacheKey, {}) + return {} +} + +// Strip Antigravity-specific suffixes so the pricing DB can match +const PRICING_ALIASES: Record = { + 'gemini-pro': 'gemini-3.1-pro', +} + +function normalizePricingModel(model: string): string { + const stripped = model.replace(/-(high|medium|low|agent)$/, '') + return PRICING_ALIASES[stripped] ?? stripped +} + +function readProtoVarint(data: Uint8Array, startOffset: number): ProtoVarint | null { + let value = 0n + let shift = 0n + let offset = startOffset + + while (offset < data.length) { + const byte = BigInt(data[offset]!) + offset += 1 + value |= (byte & 0x7fn) << shift + if ((byte & 0x80n) === 0n) return { value, offset } + shift += 7n + if (shift > 70n) return null + } + + return null +} + +function parseProtoFields(data: Uint8Array): ProtoField[] { + const fields: ProtoField[] = [] + let offset = 0 + + while (offset < data.length) { + const key = readProtoVarint(data, offset) + if (!key) break + offset = key.offset + + const fieldNumber = Number(key.value >> 3n) + const wireType = Number(key.value & 0x7n) + if (!Number.isSafeInteger(fieldNumber) || fieldNumber <= 0) break + + if (wireType === 0) { + const value = readProtoVarint(data, offset) + if (!value) break + fields.push({ number: fieldNumber, wireType, value: value.value }) + offset = value.offset + continue + } + + if (wireType === 1) { + if (offset + 8 > data.length) break + fields.push({ number: fieldNumber, wireType, bytes: data.subarray(offset, offset + 8) }) + offset += 8 + continue + } + + if (wireType === 2) { + const length = readProtoVarint(data, offset) + if (!length) break + offset = length.offset + const byteLength = Number(length.value) + if (!Number.isSafeInteger(byteLength) || byteLength < 0 || offset + byteLength > data.length) break + fields.push({ number: fieldNumber, wireType, bytes: data.subarray(offset, offset + byteLength) }) + offset += byteLength + continue + } + + if (wireType === 5) { + if (offset + 4 > data.length) break + fields.push({ number: fieldNumber, wireType, bytes: data.subarray(offset, offset + 4) }) + offset += 4 + continue + } + + break + } + + return fields +} + +function firstProtoField(fields: readonly ProtoField[], fieldNumber: number): ProtoField | undefined { + return fields.find(field => field.number === fieldNumber) +} + +function protoFieldText(field: ProtoField | undefined): string | undefined { + if (!field?.bytes || field.bytes.length === 0) return undefined + const text = protoTextDecoder.decode(field.bytes) + if (!text || /[\u0000-\u0008\u000E-\u001F\u007F\uFFFD]/.test(text)) return undefined + return text +} + +function protoFieldPositiveInteger(field: ProtoField | undefined): number { + if (field?.value === undefined) return 0 + const value = Number(field.value) + return Number.isSafeInteger(value) && value > 0 ? value : 0 +} + +function protoFieldBytes(field: ProtoField | undefined): Uint8Array | undefined { + return field?.bytes +} + +function isAntigravityResponseId(value: string): boolean { + return /^[^\s]+$/.test(value) +} + +function antigravitySqliteResponseId(usageFields: readonly ProtoField[], fallback: string): string { + const responseId = protoFieldText(firstProtoField(usageFields, 11)) + return responseId && isAntigravityResponseId(responseId) ? responseId : fallback +} + +function genMetadataDataBytes(value: Uint8Array | string): Uint8Array { + return typeof value === 'string' + ? new TextEncoder().encode(value) + : value +} + +function antigravitySqliteMetadataAttributes(chatFields: readonly ProtoField[]): Map { + const attributes = new Map() + for (const field of chatFields) { + if (field.number !== 20) continue + const pairFields = parseProtoFields(protoFieldBytes(field) ?? new Uint8Array()) + const key = protoFieldText(firstProtoField(pairFields, 1)) + const value = protoFieldText(firstProtoField(pairFields, 2)) + if (key && value) attributes.set(key, value) + } + return attributes +} + +function antigravitySqliteModel(chatFields: readonly ProtoField[]): string { + const attributes = antigravitySqliteMetadataAttributes(chatFields) + const displayName = protoFieldText(firstProtoField(chatFields, 21)) + const rawModel = protoFieldText(firstProtoField(chatFields, 19)) + ?? attributes.get('model_enum') + ?? displayName + ?? 'unknown' + + return getCanonicalModelId(rawModel, displayName) +} + +function buildCallFromSqliteGenMetadataRow(cascadeId: string, row: AntigravityGenMetadataRow): ParsedProviderCall | null { + const rootFields = parseProtoFields(genMetadataDataBytes(row.data)) + const chatFields = parseProtoFields(protoFieldBytes(firstProtoField(rootFields, 1)) ?? new Uint8Array()) + const usageFields = parseProtoFields(protoFieldBytes(firstProtoField(chatFields, 4)) ?? new Uint8Array()) + if (usageFields.length === 0) return null + + const inputTokens = protoFieldPositiveInteger(firstProtoField(usageFields, 2)) + || protoFieldPositiveInteger(firstProtoField(usageFields, 1)) + const totalOutputTokens = protoFieldPositiveInteger(firstProtoField(usageFields, 3)) + let responseTokens = protoFieldPositiveInteger(firstProtoField(usageFields, 9)) + let thinkingTokens = protoFieldPositiveInteger(firstProtoField(usageFields, 10)) + + if (responseTokens === 0 && thinkingTokens === 0) { + responseTokens = totalOutputTokens + } else if (totalOutputTokens > 0 && responseTokens + thinkingTokens !== totalOutputTokens) { + const adjustedResponseTokens = totalOutputTokens - thinkingTokens + if (adjustedResponseTokens >= 0) responseTokens = adjustedResponseTokens + } + + if (inputTokens === 0 && totalOutputTokens === 0) return null + + const responseId = antigravitySqliteResponseId(usageFields, String(row.idx)) + const model = antigravitySqliteModel(chatFields) + const pricingModel = normalizePricingModel(model) + const costUSD = calculateCost(pricingModel, inputTokens, responseTokens + thinkingTokens, 0, 0, 0) + + return { + provider: 'antigravity', + model, + inputTokens, + outputTokens: responseTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: thinkingTokens, + webSearchRequests: 0, + costUSD, + tools: [], + bashCommands: [], + timestamp: '', + speed: 'standard', + deduplicationKey: `antigravity:${cascadeId}:${responseId}`, + userMessage: '', + sessionId: cascadeId, + } +} + +function buildCallsFromSqliteGenMetadata(cascadeId: string, rows: AntigravityGenMetadataRow[]): ParsedProviderCall[] { + const calls: ParsedProviderCall[] = [] + const seenResponseIds = new Set() + + for (const row of rows) { + const call = buildCallFromSqliteGenMetadataRow(cascadeId, row) + if (!call) continue + if (seenResponseIds.has(call.deduplicationKey)) continue + seenResponseIds.add(call.deduplicationKey) + calls.push(call) + } + + return calls +} + +async function parseSqliteGenMetadataCalls(filePath: string, cascadeId: string): Promise { + if (!filePath.toLowerCase().endsWith('.db')) return [] + if (!isSqliteAvailable()) return [] + + let db: ReturnType | null = null + try { + db = openDatabase(filePath) + const rows = db.query('SELECT idx, data FROM gen_metadata ORDER BY idx') + return buildCallsFromSqliteGenMetadata(cascadeId, rows) + } catch (err) { + // Let a transient lock propagate so the run retries this file on the next + // refresh instead of treating it as empty (see parser.ts busy handling). + if (isSqliteBusyError(err)) throw err + return [] + } finally { + db?.close() + } +} + +function parseFiniteToken(value: unknown): number { + return typeof value === 'number' && Number.isFinite(value) && value > 0 + ? Math.floor(value) + : 0 +} + +function usageSignature(event: StatusLineEvent): string { + const u = event.usage + return [ + event.model, + u.inputTokens, + u.outputTokens, + u.cacheCreationInputTokens, + u.cacheReadInputTokens, + ].join(':') +} + +function usageHasTokens(usage: StatusLineEvent['usage']): boolean { + return ( + usage.inputTokens > 0 || + usage.outputTokens > 0 || + usage.cacheCreationInputTokens > 0 || + usage.cacheReadInputTokens > 0 + ) +} + +function usageIsMonotonic(current: StatusLineEvent['usage'], previous: StatusLineEvent['usage']): boolean { + return ( + current.inputTokens >= previous.inputTokens && + current.outputTokens >= previous.outputTokens && + current.cacheCreationInputTokens >= previous.cacheCreationInputTokens && + current.cacheReadInputTokens >= previous.cacheReadInputTokens + ) +} + +function usageDelta(current: StatusLineEvent['usage'], previous: StatusLineEvent['usage']): StatusLineEvent['usage'] { + return { + inputTokens: current.inputTokens - previous.inputTokens, + outputTokens: current.outputTokens - previous.outputTokens, + cacheCreationInputTokens: current.cacheCreationInputTokens - previous.cacheCreationInputTokens, + cacheReadInputTokens: current.cacheReadInputTokens - previous.cacheReadInputTokens, + } +} + +export function antigravityCascadeIdFromPath(path: string): string { + return basename(path).replace(/\.(pb|db)$/i, '') +} + +function buildCallsFromGeneratorMetadata( + cascadeId: string, + metadata: GeneratorMetadata[], + modelMap: ModelMap, +): ParsedProviderCall[] { + const results: ParsedProviderCall[] = [] + + for (let i = 0; i < metadata.length; i++) { + const entry = metadata[i]! + const usage = entry.chatModel?.usage + if (!usage) continue + + const inputTokens = parseInt(usage.inputTokens ?? '0', 10) + const outputTokens = parseInt(usage.outputTokens ?? '0', 10) + const thinkingTokens = parseInt(usage.thinkingOutputTokens ?? '0', 10) + const responseTokens = parseInt(usage.responseOutputTokens ?? '0', 10) + + if (inputTokens === 0 && outputTokens === 0) continue + + const responseId = usage.responseId || String(i) + const dedupKey = `antigravity:${cascadeId}:${responseId}` + + const model = modelMap[usage.model] ?? usage.model + const pricingModel = normalizePricingModel(model) + const timestamp = entry.chatModel?.chatStartMetadata?.createdAt ?? '' + const costUSD = calculateCost(pricingModel, inputTokens, responseTokens + thinkingTokens, 0, 0, 0) + + results.push({ + provider: 'antigravity', + model, + inputTokens, + outputTokens: responseTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: thinkingTokens, + webSearchRequests: 0, + costUSD, + tools: [], + bashCommands: [], + timestamp, + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: '', + sessionId: cascadeId, + }) + } + + return results +} + +function isConversationFile(file: string, extensions: readonly string[]): boolean { + const lowerFile = file.toLowerCase() + return extensions.some(ext => lowerFile.endsWith(ext)) +} + +export function isAntigravityStatusLineEventsPath(path: string): boolean { + return path === getAntigravityStatusLineEventsPath() +} + +export async function discoverAntigravitySessionSources( + roots: readonly AntigravityConversationRoot[] = CONVERSATION_ROOTS, +): Promise { + const includeStatusLineEvents = roots === CONVERSATION_ROOTS + const sources: SessionSource[] = [] + for (const root of roots) { + let files: string[] + try { + files = await readdir(root.dir) + } catch { + continue + } + + for (const file of files.sort()) { + if (!isConversationFile(file, root.extensions)) continue + const path = join(root.dir, file) + const s = await stat(path).catch(() => null) + if (!s?.isFile()) continue + sources.push({ + path, + project: root.project, + provider: 'antigravity', + }) + } + } + + if (includeStatusLineEvents) { + const statusLinePath = getAntigravityStatusLineEventsPath() + const statusLineStat = await stat(statusLinePath).catch(() => null) + if (statusLineStat?.isFile()) { + sources.push({ + path: statusLinePath, + project: 'antigravity-cli', + provider: 'antigravity', + }) + } + } + + return sources +} + +function parseStatusLinePayload(input: unknown): StatusLineEvent | null { + if (!input || typeof input !== 'object') return null + const payload = input as StatusLinePayload + if (typeof payload.conversation_id !== 'string' || payload.conversation_id.length === 0) return null + const usage = payload.context_window?.current_usage + if (!usage) return null + + const event: StatusLineEvent = { + at: new Date().toISOString(), + conversationId: payload.conversation_id, + sessionId: typeof payload.session_id === 'string' ? payload.session_id : undefined, + model: typeof payload.model === 'string' + ? payload.model + : payload.model?.id ?? payload.model?.display_name ?? 'unknown', + usage: { + inputTokens: parseFiniteToken(usage.input_tokens), + outputTokens: parseFiniteToken(usage.output_tokens), + cacheCreationInputTokens: parseFiniteToken(usage.cache_creation_input_tokens), + cacheReadInputTokens: parseFiniteToken(usage.cache_read_input_tokens), + }, + } + + const u = event.usage + if (u.inputTokens === 0 && u.outputTokens === 0 && u.cacheCreationInputTokens === 0 && u.cacheReadInputTokens === 0) { + return null + } + if (event.model === 'unknown') return null + return event +} + +export async function recordAntigravityStatusLinePayload(input: unknown): Promise { + const event = parseStatusLinePayload(input) + if (!event) return false + + const path = getAntigravityStatusLineEventsPath() + await mkdir(getCacheDir(), { recursive: true, mode: 0o700 }) + const fd = await open(path, 'a', 0o600) + try { + await fd.appendFile(`${JSON.stringify(event)}\n`, { encoding: 'utf-8' }) + } finally { + await fd.close() + } + return true +} + +function parseStatusLineEvent(input: unknown): StatusLineEvent | null { + if (!input || typeof input !== 'object') return null + const event = input as StatusLineEvent + if (typeof event.at !== 'string' || Number.isNaN(new Date(event.at).getTime())) return null + if (typeof event.conversationId !== 'string' || event.conversationId.length === 0) return null + if (typeof event.model !== 'string' || event.model.length === 0) return null + if (!event.usage || typeof event.usage !== 'object') return null + + const usage = { + inputTokens: parseFiniteToken(event.usage.inputTokens), + outputTokens: parseFiniteToken(event.usage.outputTokens), + cacheCreationInputTokens: parseFiniteToken(event.usage.cacheCreationInputTokens), + cacheReadInputTokens: parseFiniteToken(event.usage.cacheReadInputTokens), + } + + if ( + usage.inputTokens === 0 && + usage.outputTokens === 0 && + usage.cacheCreationInputTokens === 0 && + usage.cacheReadInputTokens === 0 + ) return null + + return { + at: event.at, + conversationId: event.conversationId, + sessionId: typeof event.sessionId === 'string' ? event.sessionId : undefined, + model: event.model, + usage, + } +} + +function hasRpcCacheForConversation(seenKeys: Set, conversationId: string): boolean { + const prefix = `antigravity:${conversationId}:` + for (const key of seenKeys) { + if (key.startsWith(prefix)) return true + } + return false +} + +async function parseStatusLineCalls(source: SessionSource, seenKeys: Set): Promise { + const raw = await readFile(source.path, 'utf-8').catch(() => '') + const runsByConversation = new Map>() + + for (const line of raw.split(/\r?\n/)) { + if (!line.trim()) continue + let parsed: unknown + try { + parsed = JSON.parse(line) + } catch { + continue + } + + const event = parseStatusLineEvent(parsed) + if (!event) continue + if (hasRpcCacheForConversation(seenKeys, event.conversationId)) continue + + const signature = usageSignature(event) + const runs = runsByConversation.get(event.conversationId) ?? [] + const lastRun = runs.at(-1) + if (lastRun?.signature === signature) { + lastRun.count += 1 + lastRun.event = event + } else { + runs.push({ event, signature, count: 1 }) + runsByConversation.set(event.conversationId, runs) + } + } + + const results: ParsedProviderCall[] = [] + + for (const runs of runsByConversation.values()) { + let turnIndex = 0 + let previousSnapshotUsage: StatusLineEvent['usage'] | null = null + for (let i = 0; i < runs.length; i++) { + const run = runs[i]! + const isLastRun = i === runs.length - 1 + if (run.count === 1 && !isLastRun) continue + + const event = run.event + const signature = run.signature + const billableUsage = previousSnapshotUsage && usageIsMonotonic(event.usage, previousSnapshotUsage) + ? usageDelta(event.usage, previousSnapshotUsage) + : event.usage + previousSnapshotUsage = event.usage + if (!usageHasTokens(billableUsage)) continue + + const dedupKey = `antigravity-statusline:${event.conversationId}:${turnIndex}:${signature}` + turnIndex += 1 + if (seenKeys.has(dedupKey)) continue + + const u = billableUsage + const costUSD = calculateCost( + normalizePricingModel(event.model), + u.inputTokens, + u.outputTokens, + u.cacheCreationInputTokens, + u.cacheReadInputTokens, + 0, + ) + + results.push({ + provider: 'antigravity', + model: event.model, + inputTokens: u.inputTokens, + outputTokens: u.outputTokens, + cacheCreationInputTokens: u.cacheCreationInputTokens, + cacheReadInputTokens: u.cacheReadInputTokens, + cachedInputTokens: 0, + // StatusLine current_usage exposes aggregate output tokens, not a + // separate thinking/response split. Preserve the exact total instead + // of inventing a breakdown. + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + tools: [], + bashCommands: [], + timestamp: event.at, + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: '', + sessionId: event.conversationId, + project: source.project, + }) + } + } + + return results +} + +export function shouldReparseAntigravitySource(path: string, cachedTurnCount: number): boolean { + if (cachedTurnCount === 0) return true + return isAntigravityStatusLineEventsPath(path) +} + +async function findCascadeSource(cascadeId: string): Promise { + const sources = await discoverAntigravitySessionSources() + return sources.find(source => { + const lower = source.path.replace(/\\/g, '/').toLowerCase() + return (lower.includes('/.gemini/antigravity-cli/') || lower.includes('/.gemini/antigravity-ide/')) && + antigravityCascadeIdFromPath(source.path) === cascadeId + }) ?? null +} + +export async function snapshotAntigravityStatusLinePayload(input: unknown): Promise { + const event = parseStatusLinePayload(input) + if (!event) return false + + const cascadeId = event.conversationId + const source = await findCascadeSource(cascadeId) + if (!source) return false + + const s = await stat(source.path).catch(() => null) + if (!s) return false + + const cache = await loadCache() + const cached = cache.cascades[cascadeId] + if (cached && cached.mtimeMs === s.mtimeMs && cached.sizeBytes === s.size && cached.calls.length > 0) { + return true + } + + const server = await detectServer(antigravityAppDataDirFromSourcePath(source.path)) + if (!server) return false + + let metadata: GeneratorMetadata[] + try { + const modelMap = await getModelMap(server) + metadata = extractAntigravityGeneratorMetadata( + await rpc(server, 'GetCascadeTrajectoryGeneratorMetadata', { cascadeId }), + ) + cache.cascades[cascadeId] = { + mtimeMs: s.mtimeMs, + sizeBytes: s.size, + calls: buildCallsFromGeneratorMetadata(cascadeId, metadata, modelMap), + } + cacheDirty = true + await flushCache() + return cache.cascades[cascadeId]!.calls.length > 0 + } catch { + return false + } +} + +async function extractWorkspacePath(filePath: string): Promise { + let text = '' + if (filePath.endsWith('.db') && isSqliteAvailable()) { + try { + const db = openDatabase(filePath) + const rows = db.query<{ data: Uint8Array }>('SELECT data FROM trajectory_metadata_blob') + db.close() + const textDecoder = new TextDecoder('utf-8', { fatal: false }) + text = rows.map(r => textDecoder.decode(r.data)).join(' ') + } catch { /* ignore and fallback */ } + } + + if (!text) { + try { + text = await readFile(filePath, 'utf-8') + } catch { + return undefined + } + } + + const match = text.match(/file:\/\/\/[^\x00-\x1F\x7F"'\s]+/i) + if (!match) return undefined + + try { + return fileURLToPath(match[0]) + } catch { + return undefined + } +} + +function sanitizeProject(path: string): string { + return basename(path.replace(/\\/g, '/')) +} + +function applyAntigravityProject(call: ParsedProviderCall, source: SessionSource, projectPath: string | undefined): void { + if (source.project === 'antigravity-cli') { + call.project = source.project + delete call.projectPath + return + } + + if (projectPath) { + call.projectPath = projectPath + call.project = sanitizeProject(projectPath) + return + } + + call.project = source.project +} + +function createParser(source: SessionSource, seenKeys: Set): SessionParser { + return { + async *parse(): AsyncGenerator { + if (isAntigravityStatusLineEventsPath(source.path)) { + for (const call of await parseStatusLineCalls(source, seenKeys)) { + seenKeys.add(call.deduplicationKey) + yield call + } + return + } + + const cascadeId = antigravityCascadeIdFromPath(source.path) + const cache = await loadCache() + + const s = await stat(source.path).catch(() => null) + if (!s) return + + const projectPath = await extractWorkspacePath(source.path) + + const cached = cache.cascades[cascadeId] + if (cached && cached.mtimeMs === s.mtimeMs && cached.sizeBytes === s.size && cached.calls.length > 0) { + for (const call of cached.calls) { + applyAntigravityProject(call, source, projectPath) + if (seenKeys.has(call.deduplicationKey)) continue + seenKeys.add(call.deduplicationKey) + yield call + } + return + } + + const sqliteResults = await parseSqliteGenMetadataCalls(source.path, cascadeId) + if (sqliteResults.length > 0) { + for (const call of sqliteResults) { + applyAntigravityProject(call, source, projectPath) + } + + cache.cascades[cascadeId] = { + mtimeMs: s.mtimeMs, + sizeBytes: s.size, + calls: sqliteResults, + } + cacheDirty = true + + for (const call of sqliteResults) { + if (seenKeys.has(call.deduplicationKey)) continue + seenKeys.add(call.deduplicationKey) + yield call + } + return + } + + const server = await detectServer(antigravityAppDataDirFromSourcePath(source.path)) + if (!server) { + if (cached) { + for (const call of cached.calls) { + applyAntigravityProject(call, source, projectPath) + if (seenKeys.has(call.deduplicationKey)) continue + seenKeys.add(call.deduplicationKey) + yield call + } + } + return + } + + const modelMap = await getModelMap(server) + + let metadata: GeneratorMetadata[] + try { + metadata = extractAntigravityGeneratorMetadata( + await rpc(server, 'GetCascadeTrajectoryGeneratorMetadata', { cascadeId }), + ) + } catch { + if (cached) { + for (const call of cached.calls) { + applyAntigravityProject(call, source, projectPath) + if (seenKeys.has(call.deduplicationKey)) continue + seenKeys.add(call.deduplicationKey) + yield call + } + } + return + } + + const results = buildCallsFromGeneratorMetadata(cascadeId, metadata, modelMap) + for (const call of results) { + applyAntigravityProject(call, source, projectPath) + } + + cache.cascades[cascadeId] = { + mtimeMs: s.mtimeMs, + sizeBytes: s.size, + calls: results, + } + cacheDirty = true + + for (const call of results) { + if (seenKeys.has(call.deduplicationKey)) continue + seenKeys.add(call.deduplicationKey) + yield call + } + }, + } +} + +const modelDisplayNames: Record = { + 'gemini-pro-agent': 'Gemini Pro', + 'gemini-3-pro': 'Gemini 3 Pro', + 'gemini-3.1-pro-high': 'Gemini 3.1 Pro', + 'gemini-3.1-pro-low': 'Gemini 3.1 Pro (Low)', + 'gemini-3-flash': 'Gemini 3 Flash', + 'gemini-3-flash-agent': 'Gemini 3 Flash', + 'gemini-3.5-flash': 'Gemini 3.5 Flash', + 'gemini-3.5-flash-high': 'Gemini 3.5 Flash', + 'gemini-3.5-flash-medium': 'Gemini 3.5 Flash', + 'gemini-3.5-flash-low': 'Gemini 3.5 Flash', + 'Gemini 3.5 Flash (High)': 'Gemini 3.5 Flash', + 'Gemini 3.5 Flash (Medium)': 'Gemini 3.5 Flash', + 'Gemini 3.5 Flash (Low)': 'Gemini 3.5 Flash', + 'gemini-3.1-flash-image': 'Gemini 3.1 Flash', + 'gemini-3.1-flash-lite': 'Gemini 3.1 Flash Lite', + 'claude-opus-4-6-thinking': 'Opus 4.6', + 'claude-sonnet-4-6': 'Sonnet 4.6', +} + +export function createAntigravityProvider(): Provider { + return { + name: 'antigravity', + displayName: 'Antigravity', + + modelDisplayName(model: string): string { + return modelDisplayNames[model] ?? model + }, + + toolDisplayName(rawTool: string): string { + return rawTool + }, + + async discoverSessions(): Promise { + return discoverAntigravitySessionSources() + }, + + createSessionParser(source: SessionSource, seenKeys: Set): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export async function flushAntigravityCache(liveCascadeIds?: Set): Promise { + await flushCache(liveCascadeIds) +} + +export const antigravity = createAntigravityProvider() diff --git a/src/providers/claude.ts b/src/providers/claude.ts new file mode 100644 index 0000000..3613168 --- /dev/null +++ b/src/providers/claude.ts @@ -0,0 +1,327 @@ +import { readFile, readdir, stat } from 'fs/promises' +import { basename, delimiter as pathDelimiter, join, resolve } from 'path' +import { homedir } from 'os' +import { createHash } from 'crypto' + +import type { Provider, SessionSource, SessionParser } from './types.js' +import { getShortModelName } from '../models.js' +import { readConfig } from '../config.js' + +export type ClaudeConfigSource = { + id: string + label: string + path: string +} + +function expandHome(p: string): string { + if (p === '~') return homedir() + if (p.startsWith('~/') || p.startsWith('~\\')) return join(homedir(), p.slice(2)) + return p +} + +function dedupeResolved(paths: string[]): string[] { + const seen = new Set() + const out: string[] = [] + for (const p of paths) { + if (!seen.has(p)) { + seen.add(p) + out.push(p) + } + } + return out +} + +function claudeConfigSourceId(path: string): string { + return 'claude-config:' + createHash('sha256').update(path).digest('hex').slice(0, 16) +} + +function baseClaudeConfigLabel(path: string): string { + const normalized = resolve(path) + if (normalized === resolve(join(homedir(), '.claude'))) return 'Default Claude' + const name = basename(normalized).replace(/^\./, '').trim() + return name || normalized +} + +function makeUniqueLabels(sources: ClaudeConfigSource[]): ClaudeConfigSource[] { + const counts = new Map() + for (const source of sources) counts.set(source.label, (counts.get(source.label) ?? 0) + 1) + if (![...counts.values()].some(count => count > 1)) return sources + + const seen = new Map() + return sources.map(source => { + if ((counts.get(source.label) ?? 0) <= 1) return source + const index = (seen.get(source.label) ?? 0) + 1 + seen.set(source.label, index) + return { ...source, label: `${source.label} ${index}` } + }) +} + +/// Returns every Claude config dir to scan, in priority order with duplicates +/// removed (resolved-path equality). Precedence: `CLAUDE_CONFIG_DIRS` (a +/// `path.delimiter`-separated list, ":" on POSIX, ";" on Windows), then +/// `CLAUDE_CONFIG_DIR` (single dir), then the `claudeConfigDirs` array in +/// `~/.config/codeburn/config.json` (how the macOS menubar configures +/// multi-account aggregation, since a GUI app can't inherit the shell env), +/// then `~/.claude`. Sessions from every returned dir are merged into one +/// ProjectSummary per project name in `src/parser.ts:scanProjectDirs`, so two +/// dirs holding the same sanitized project slug naturally aggregate (#208). +export async function getClaudeConfigDirs(): Promise { + const multi = process.env['CLAUDE_CONFIG_DIRS'] + if (multi !== undefined && multi !== '') { + const dirs = multi + .split(pathDelimiter) + .map(s => s.trim()) + .filter(s => s.length > 0) + .map(s => resolve(expandHome(s))) + if (dirs.length > 0) return dedupeResolved(dirs) + } + const single = process.env['CLAUDE_CONFIG_DIR'] + if (single !== undefined && single !== '') return [resolve(expandHome(single))] + + // Config-file fallback (menubar-driven). Env vars always win so a power user + // can still override per-shell. A non-array or empty value falls through to + // the ~/.claude default, matching the "unset" behavior. + const config = await readConfig() + if (Array.isArray(config.claudeConfigDirs)) { + const dirs = config.claudeConfigDirs + .filter((s): s is string => typeof s === 'string' && s.trim().length > 0) + .map(s => resolve(expandHome(s.trim()))) + if (dirs.length > 0) return dedupeResolved(dirs) + } + + return [join(homedir(), '.claude')] +} + +export async function discoverClaudeConfigSources(): Promise { + const dirs = await getClaudeConfigDirs() + return makeUniqueLabels(dirs.map(path => ({ + id: claudeConfigSourceId(path), + label: baseClaudeConfigLabel(path), + path, + }))) +} + +export function getDesktopSessionsDir(): string { + const override = process.env['CODEBURN_DESKTOP_SESSIONS_DIR'] + if (override) return override + if (process.platform === 'darwin') return join(homedir(), 'Library', 'Application Support', 'Claude', 'local-agent-mode-sessions') + if (process.platform === 'win32') return join(homedir(), 'AppData', 'Roaming', 'Claude', 'local-agent-mode-sessions') + return join(homedir(), '.config', 'Claude', 'local-agent-mode-sessions') +} + +async function findDesktopProjectDirs(base: string): Promise { + const results: string[] = [] + async function walk(dir: string, depth: number): Promise { + if (depth > 8) return + const entries = await readdir(dir).catch(() => []) + for (const entry of entries) { + if (entry === 'node_modules' || entry === '.git') continue + const full = join(dir, entry) + const s = await stat(full).catch(() => null) + if (!s?.isDirectory()) continue + if (entry === 'projects') { + const projectDirs = await readdir(full).catch(() => []) + for (const pd of projectDirs) { + const pdFull = join(full, pd) + const pdStat = await stat(pdFull).catch(() => null) + if (pdStat?.isDirectory()) results.push(pdFull) + } + } else { + await walk(full, depth + 1) + } + } + } + await walk(base, 0) + return results +} + +// ── Cowork space resolution ──────────────────────────────────────────── +// Claude Desktop's local-agent-mode creates one directory per session under +// ///local_/ +// Inside each session directory Claude Code stores its own config at +// .claude/projects// +// which is what findDesktopProjectDirs picks up. The actual project name +// lives in the sibling /local_.json (spaceId field) +// and /spaces.json (id → name mapping). + +interface CoworkSpace { id: string; name: string } +interface CoworkSpacesFile { spaces: CoworkSpace[] } + +// Cache spaces.json per workspace directory to avoid redundant reads. +const spacesJsonCache = new Map() + +async function loadSpacesJson(workspaceDir: string): Promise { + if (spacesJsonCache.has(workspaceDir)) return spacesJsonCache.get(workspaceDir) ?? null + try { + const raw = await readFile(join(workspaceDir, 'spaces.json'), 'utf-8') + const parsed: unknown = JSON.parse(raw) + if ( + parsed !== null && + typeof parsed === 'object' && + 'spaces' in parsed && + Array.isArray((parsed as { spaces: unknown }).spaces) + ) { + const result = parsed as CoworkSpacesFile + spacesJsonCache.set(workspaceDir, result) + return result + } + } catch { + // unreadable or malformed — treat as no spaces + } + spacesJsonCache.set(workspaceDir, null) + return null +} + +async function resolveCoworkSpaceName(workspaceDir: string, sessionId: string): Promise { + const [spacesFile, sessionMetaRaw] = await Promise.all([ + loadSpacesJson(workspaceDir), + readFile(join(workspaceDir, `${sessionId}.json`), 'utf-8').catch(() => null), + ]) + if (!sessionMetaRaw) return null + let sessionMeta: unknown + try { sessionMeta = JSON.parse(sessionMetaRaw) } catch { return null } + if (sessionMeta === null || typeof sessionMeta !== 'object') return null + const meta = sessionMeta as Record + + const spaceId = meta['spaceId'] + if (typeof spaceId === 'string' && spacesFile) { + const spaceName = spacesFile.spaces.find(s => s.id === spaceId)?.name + if (spaceName) return spaceName + } + + // No spaceId (standalone session): fall back to selected folder then title. + const folders = meta['userSelectedFolders'] + if (Array.isArray(folders) && folders.length > 0 && typeof folders[0] === 'string') { + return basename(folders[0]) + } + const title = meta['title'] + if (typeof title === 'string' && title.trim().length > 0) return title.trim() + + return null +} + +export const claude: Provider = { + name: 'claude', + displayName: 'Claude', + + modelDisplayName(model: string): string { + return getShortModelName(model) + }, + + toolDisplayName(rawTool: string): string { + return rawTool + }, + + async discoverSessions(): Promise { + const sources: SessionSource[] = [] + const seenProjectDirs = new Set() + const configSources = await discoverClaudeConfigSources() + let anyDirReadable = false + + for (const configSource of configSources) { + const claudeDir = configSource.path + const projectsDir = join(claudeDir, 'projects') + let entries: string[] + try { + entries = await readdir(projectsDir) + anyDirReadable = true + } catch { + // Missing or unreadable dir is not fatal: a user can configure both + // a real and a stale path in CLAUDE_CONFIG_DIRS without breaking. + continue + } + for (const dirName of entries) { + const dirPath = join(projectsDir, dirName) + // Resolve before deduping so two CLAUDE_CONFIG_DIRS entries that + // reach the same projects/ directory (via symlinks or + // overlapping configs) emit only one SessionSource. + const resolved = resolve(dirPath) + if (seenProjectDirs.has(resolved)) continue + const dirStat = await stat(dirPath).catch(() => null) + if (!dirStat?.isDirectory()) continue + seenProjectDirs.add(resolved) + // `project: dirName` is identical across config dirs for the same + // sanitized slug, which is exactly what makes the parser merge + // their sessions into a single ProjectSummary. + sources.push({ + path: dirPath, + project: dirName, + provider: 'claude', + sourceId: configSource.id, + sourceLabel: configSource.label, + sourcePath: configSource.path, + sourceKind: 'claude-config', + }) + } + } + + // If the user explicitly set CLAUDE_CONFIG_DIRS and every entry was + // unreadable, emit a one-line stderr hint. Catches the most common + // misconfiguration: a Windows user typing `:` (POSIX delimiter) when + // the platform expects `;`, which produces a single bogus path that + // silently resolves to nothing on disk. + const explicitMulti = process.env['CLAUDE_CONFIG_DIRS'] + if (!anyDirReadable && explicitMulti !== undefined && explicitMulti !== '' && configSources.length > 0) { + process.stderr.write( + `codeburn: CLAUDE_CONFIG_DIRS was set but no listed directory could be read. ` + + `Tried: ${configSources.map(s => s.path).join(', ')}. ` + + `Use "${pathDelimiter}" as the separator on this platform.\n`, + ) + } + + const desktopBase = getDesktopSessionsDir() + const desktopDirs = await findDesktopProjectDirs(desktopBase) + const sep = desktopBase.includes('\\') ? '\\' : '/' + // Desktop / Cowork sessions belong to no CLAUDE_CONFIG_DIR. Tag them with a + // distinct source so a per-config view can account for them as their own + // "Claude Desktop" bucket instead of silently dropping them (which made + // sum-of-configs < All). + const desktopSourceId = 'claude-desktop:' + createHash('sha256').update(resolve(desktopBase)).digest('hex').slice(0, 16) + for (const dirPath of desktopDirs) { + const resolved = resolve(dirPath) + if (seenProjectDirs.has(resolved)) continue + seenProjectDirs.add(resolved) + + // For Claude Desktop local-agent-mode (Cowork) sessions, the project dir + // lives inside local_/.claude/projects/. We resolve the space + // name from the sibling .json and spaces.json so it groups correctly. + // Path structure: ///local_/.claude/projects/ + let projectName = basename(dirPath) + const resolvedBase = resolve(desktopBase) + if (resolved.startsWith(resolvedBase + sep) || resolved.startsWith(resolvedBase + '/')) { + const rel = resolved.slice(resolvedBase.length + 1) + const parts = rel.split(/[/\\]/) + // parts = [appId, workspaceId, local_sessionId, .claude, projects, slug] + if ( + parts.length >= 6 && + parts[2]?.startsWith('local_') && + parts[3] === '.claude' && + parts[4] === 'projects' + ) { + const workspaceDir = join(resolvedBase, parts[0]!, parts[1]!) + const sessionId = parts[2]! + const spaceName = await resolveCoworkSpaceName(workspaceDir, sessionId) + if (spaceName) projectName = spaceName + } + } + + sources.push({ + path: dirPath, + project: projectName, + provider: 'claude', + sourceId: desktopSourceId, + sourceLabel: 'Claude Desktop', + sourcePath: desktopBase, + sourceKind: 'claude-desktop', + }) + } + + return sources + }, + + createSessionParser(): SessionParser { + return { + async *parse() {}, + } + }, +} diff --git a/src/providers/cline.ts b/src/providers/cline.ts new file mode 100644 index 0000000..7317706 --- /dev/null +++ b/src/providers/cline.ts @@ -0,0 +1,73 @@ +import { stat } from 'fs/promises' +import { homedir } from 'os' +import { basename, join } from 'path' + +import { discoverClineTasks, createClineParser, getVSCodeGlobalStoragePath } from './vscode-cline-parser.js' +import type { Provider, SessionSource, SessionParser } from './types.js' + +const EXTENSION_ID = 'saoudrizwan.claude-dev' + +export function getClineDataPath(): string { + return join(homedir(), '.cline', 'data') +} + +function normalizeOverrideDirs(overrideDirs?: string | string[]): string[] | undefined { + if (overrideDirs === undefined) return undefined + // Cline has two default roots, so tests and future callers can override one or both. + return Array.isArray(overrideDirs) ? overrideDirs : [overrideDirs] +} + +async function dedupeTaskSources(sources: SessionSource[]): Promise { + const candidates = await Promise.all(sources.map(async source => ({ + source, + mtimeMs: (await stat(join(source.path, 'ui_messages.json')).catch(() => null))?.mtimeMs ?? 0, + }))) + + const seenTaskIds = new Set() + const deduped: SessionSource[] = [] + + for (const { source } of candidates.sort((a, b) => b.mtimeMs - a.mtimeMs)) { + const taskId = basename(source.path) + if (seenTaskIds.has(taskId)) continue + seenTaskIds.add(taskId) + deduped.push(source) + } + + return deduped +} + +export function createClineProvider(overrideDirs?: string | string[]): Provider { + const configuredDirs = normalizeOverrideDirs(overrideDirs) + + return { + name: 'cline', + displayName: 'Cline', + + modelDisplayName(model: string): string { + return model + }, + + toolDisplayName(rawTool: string): string { + return rawTool + }, + + async discoverSessions(): Promise { + const baseDirs = configuredDirs ?? [ + getVSCodeGlobalStoragePath(EXTENSION_ID), + getClineDataPath(), + ] + + const sources = await Promise.all( + baseDirs.map(dir => discoverClineTasks(EXTENSION_ID, 'cline', 'Cline', dir)), + ) + + return dedupeTaskSources(sources.flat()) + }, + + createSessionParser(source: SessionSource, seenKeys: Set): SessionParser { + return createClineParser(source, seenKeys, 'cline') + }, + } +} + +export const cline = createClineProvider() diff --git a/src/providers/codebuff.ts b/src/providers/codebuff.ts new file mode 100644 index 0000000..6ee746c --- /dev/null +++ b/src/providers/codebuff.ts @@ -0,0 +1,460 @@ +import { readdir, readFile, stat } from 'fs/promises' +import { basename, dirname, join } from 'path' +import { homedir } from 'os' + +import { calculateCost } from '../models.js' +import { extractBashCommands } from '../bash-utils.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' + +// Codebuff (formerly Manicode) uses a credit-based billing system. The local +// chat-messages.json doesn't record per-call token counts the way Claude Code +// or Codex do -- only `credits` on completed assistant messages. We convert +// credits to USD using Codebuff's retail pay-as-you-go rate so the cost shows +// up in the dashboard even when tokens are absent. The rate intentionally +// rounds up to the public PAYG tier ($0.01 / credit) so we never understate +// spend; users on a subscription plan get a conservative upper bound. +const USD_PER_CREDIT = 0.01 + +// Codebuff's chat history lives under `~/.config/manicode/` (the legacy +// product name is still on disk). Development and staging channels use +// `manicode-dev` and `manicode-staging` -- we walk all three when present. +const CHANNELS = ['manicode', 'manicode-dev', 'manicode-staging'] as const + +const modelDisplayNames: Record = { + codebuff: 'Codebuff', + 'codebuff-base': 'Codebuff Base', + 'codebuff-base2': 'Codebuff Base 2', + 'codebuff-lite': 'Codebuff Lite', + 'codebuff-max': 'Codebuff Max', +} + +// Codebuff's native tool names map to codeburn's canonical tool set so +// classifier heuristics (edit/read/bash/etc.) behave consistently with the +// other providers. +const toolNameMap: Record = { + read_files: 'Read', + read_file: 'Read', + code_search: 'Grep', + glob: 'Glob', + find_files: 'Glob', + str_replace: 'Edit', + edit_file: 'Edit', + write_file: 'Write', + run_terminal_command: 'Bash', + terminal: 'Bash', + spawn_agents: 'Agent', + spawn_agent: 'Agent', + write_todos: 'TodoWrite', + create_plan: 'TodoWrite', + browser_logs: 'WebFetch', + web_search: 'WebSearch', + fetch_url: 'WebFetch', +} + +// Tool names we ignore for classification -- they're not useful signals for +// distinguishing "coding" vs "exploration" vs "planning" work. +const IGNORED_TOOLS = new Set(['suggest_followups', 'end_turn']) + +type CodebuffUsage = { + inputTokens?: number + input_tokens?: number + promptTokens?: number + prompt_tokens?: number + outputTokens?: number + output_tokens?: number + completionTokens?: number + completion_tokens?: number + cacheCreationInputTokens?: number + cache_creation_input_tokens?: number + cacheReadInputTokens?: number + cache_read_input_tokens?: number + promptTokensDetails?: { cachedTokens?: number } + prompt_tokens_details?: { cached_tokens?: number } +} + +type CodebuffBlock = { + type?: string + content?: string + toolName?: string + input?: Record + output?: string + agentName?: string + agentType?: string + status?: string + blocks?: CodebuffBlock[] +} + +type CodebuffHistoryMessage = { + role?: string + providerOptions?: { + codebuff?: { model?: string; usage?: CodebuffUsage } + usage?: CodebuffUsage + } +} + +type CodebuffMetadata = { + model?: string + modelId?: string + timestamp?: string | number + usage?: CodebuffUsage + codebuff?: { model?: string; usage?: CodebuffUsage } + runState?: { + cwd?: string + sessionState?: { + cwd?: string + projectContext?: { cwd?: string } + fileContext?: { cwd?: string } + mainAgentState?: { + agentType?: string + messageHistory?: CodebuffHistoryMessage[] + } + } + } +} + +type CodebuffChatMessage = { + id?: string + variant?: string + role?: string + content?: string + timestamp?: string | number + credits?: number + blocks?: CodebuffBlock[] + metadata?: CodebuffMetadata +} + +function getCodebuffBaseDir(override?: string): string { + if (override && override.trim()) return override + const envPath = process.env['CODEBUFF_DATA_DIR'] + if (envPath && envPath.trim()) return envPath + return join(homedir(), '.config', 'manicode') +} + +function pickNumber(...vals: Array): number | undefined { + for (const v of vals) { + if (typeof v === 'number' && Number.isFinite(v)) return v + } + return undefined +} + +function normalizeUsage(u: CodebuffUsage | undefined): { + input: number + output: number + cacheRead: number + cacheWrite: number +} { + if (!u) return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } + return { + input: pickNumber(u.inputTokens, u.input_tokens, u.promptTokens, u.prompt_tokens) ?? 0, + output: pickNumber(u.outputTokens, u.output_tokens, u.completionTokens, u.completion_tokens) ?? 0, + cacheRead: + pickNumber( + u.cacheReadInputTokens, + u.cache_read_input_tokens, + u.promptTokensDetails?.cachedTokens, + u.prompt_tokens_details?.cached_tokens, + ) ?? 0, + cacheWrite: pickNumber(u.cacheCreationInputTokens, u.cache_creation_input_tokens) ?? 0, + } +} + +function coerceTimestamp(value: string | number | undefined): string { + if (value == null) return '' + if (typeof value === 'number') { + return Number.isFinite(value) ? new Date(value).toISOString() : '' + } + const parsed = Date.parse(value) + return Number.isFinite(parsed) ? new Date(parsed).toISOString() : value +} + +function parseChatIdToIso(chatId: string): string { + const iso = chatId.replace(/(\d{4}-\d{2}-\d{2}T\d{2})-(\d{2})-(\d{2})/, '$1:$2:$3') + const parsed = Date.parse(iso) + return Number.isFinite(parsed) ? new Date(parsed).toISOString() : '' +} + +function extractCwd(meta: CodebuffMetadata | undefined): string | null { + const rs = meta?.runState + if (!rs) return null + return ( + rs.sessionState?.projectContext?.cwd ?? + rs.sessionState?.fileContext?.cwd ?? + rs.sessionState?.cwd ?? + rs.cwd ?? + null + ) +} + +function extractAgentType(meta: CodebuffMetadata | undefined): string | null { + return meta?.runState?.sessionState?.mainAgentState?.agentType ?? null +} + +function collectBlockTools(blocks: CodebuffBlock[] | undefined, acc: { tools: string[]; bash: string[] }): void { + if (!Array.isArray(blocks)) return + for (const block of blocks) { + if (!block || typeof block !== 'object') continue + if (block.type === 'tool' && typeof block.toolName === 'string') { + const raw = block.toolName + if (!IGNORED_TOOLS.has(raw)) { + acc.tools.push(toolNameMap[raw] ?? raw) + } + if ((raw === 'run_terminal_command' || raw === 'terminal') && block.input) { + const cmd = block.input['command'] + if (typeof cmd === 'string') { + acc.bash.push(...extractBashCommands(cmd)) + } + } + } + if (block.type === 'agent' && Array.isArray(block.blocks)) { + collectBlockTools(block.blocks, acc) + } + } +} + +function resolveModel(meta: CodebuffMetadata | undefined, stashedModel: string | null): string { + const direct = meta?.model ?? meta?.modelId ?? meta?.codebuff?.model + if (direct) return direct + if (stashedModel) return stashedModel + const agentType = extractAgentType(meta) + if (agentType) return `codebuff-${agentType}` + return 'codebuff' +} + +function usageFromHistory(meta: CodebuffMetadata | undefined): { + model: string | null + input: number + output: number + cacheRead: number + cacheWrite: number +} { + const hist = meta?.runState?.sessionState?.mainAgentState?.messageHistory + if (!Array.isArray(hist)) return { model: null, input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } + for (let i = hist.length - 1; i >= 0; i--) { + const entry = hist[i] + if (!entry || entry.role !== 'assistant' || !entry.providerOptions) continue + const u = normalizeUsage(entry.providerOptions.usage ?? entry.providerOptions.codebuff?.usage) + if (u.input > 0 || u.output > 0 || u.cacheRead > 0 || u.cacheWrite > 0) { + return { model: entry.providerOptions.codebuff?.model ?? null, ...u } + } + } + return { model: null, input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } +} + +async function readJson(filePath: string): Promise { + try { + const raw = await readFile(filePath, 'utf-8') + return JSON.parse(raw) as T + } catch { + return null + } +} + +async function discoverChannel(root: string): Promise { + const sources: SessionSource[] = [] + const projectsDir = join(root, 'projects') + + let projectNames: string[] + try { + projectNames = await readdir(projectsDir) + } catch { + return sources + } + + for (const projectName of projectNames) { + const chatsDir = join(projectsDir, projectName, 'chats') + let chatIds: string[] + try { + chatIds = await readdir(chatsDir) + } catch { + continue + } + + for (const chatId of chatIds) { + const chatDir = join(chatsDir, chatId) + const dirStat = await stat(chatDir).catch(() => null) + if (!dirStat?.isDirectory()) continue + + const messagesPath = join(chatDir, 'chat-messages.json') + const messagesStat = await stat(messagesPath).catch(() => null) + if (!messagesStat?.isFile()) continue + + // Resolve the real cwd from run-state.json so sessions group by the + // originating project directory instead of the sanitized chat folder + // name (which is often the same for many users). + const runState = await readJson( + join(chatDir, 'run-state.json'), + ) + const cwd = extractCwd({ runState: runState ?? undefined }) + const project = cwd ? basename(cwd) : projectName + + sources.push({ path: chatDir, project, provider: 'codebuff' }) + } + } + + return sources +} + +async function discoverSessionsInBase(baseDir: string): Promise { + const results: SessionSource[] = [] + + // Honor an explicit override: walk only the provided directory even if it + // matches one of the channel names literally. + if (process.env['CODEBUFF_DATA_DIR'] || baseDir !== join(homedir(), '.config', 'manicode')) { + const rootStat = await stat(baseDir).catch(() => null) + if (!rootStat?.isDirectory()) return results + results.push(...await discoverChannel(baseDir)) + return results + } + + const configDir = join(homedir(), '.config') + for (const channel of CHANNELS) { + const root = join(configDir, channel) + const rootStat = await stat(root).catch(() => null) + if (!rootStat?.isDirectory()) continue + results.push(...await discoverChannel(root)) + } + return results +} + +// Downstream aggregation groups sessions by `(provider, sessionId, project)` +// (see src/parser.ts). Codebuff chat folders are ISO timestamps, which means +// the same `chatId` can legitimately appear under each channel root +// (`manicode`, `manicode-dev`, `manicode-staging`) and even resolve to the +// same project cwd. To keep those sessions distinct we include the channel +// identity in the sessionId. The channel is derived from the fixed path +// structure Codebuff writes on disk: `/projects//chats/`. +// Returns null when the path doesn't match that shape so the caller can fall +// back to a plain chatId. +// +// We use '/' as the channel/chatId separator rather than ':' because +// src/parser.ts builds its session key as `${provider}:${sessionId}:${project}` +// and reconstructs the sessionId with `key.split(':')[1]` -- any colon inside +// sessionId would get truncated to just the channel name downstream. +function extractChannelFromChatDir(chatDir: string): string | null { + const chatsDir = dirname(chatDir) + if (basename(chatsDir) !== 'chats') return null + const projectDir = dirname(chatsDir) + const projectsDir = dirname(projectDir) + if (basename(projectsDir) !== 'projects') return null + const channel = basename(dirname(projectsDir)) + return channel ? channel : null +} + +function createParser(source: SessionSource, seenKeys: Set): SessionParser { + return { + async *parse(): AsyncGenerator { + const chatDir = source.path + const chatId = basename(chatDir) + const channel = extractChannelFromChatDir(chatDir) + const sessionId = channel ? `${channel}/${chatId}` : chatId + const fallbackTs = parseChatIdToIso(chatId) + + const messages = await readJson( + join(chatDir, 'chat-messages.json'), + ) + if (!Array.isArray(messages)) return + + let pendingUserMessage = '' + + for (const [idx, msg] of messages.entries()) { + if (!msg || typeof msg !== 'object') continue + + const variant = msg.variant ?? msg.role + if (variant === 'user') { + if (typeof msg.content === 'string' && msg.content.length > 0) { + pendingUserMessage = msg.content + } + continue + } + + if (variant !== 'ai' && variant !== 'agent' && variant !== 'assistant') continue + + const credits = typeof msg.credits === 'number' && Number.isFinite(msg.credits) ? msg.credits : 0 + const directUsage = normalizeUsage(msg.metadata?.usage ?? msg.metadata?.codebuff?.usage) + const stashedUsage = usageFromHistory(msg.metadata) + + const hasDirect = + directUsage.input > 0 || + directUsage.output > 0 || + directUsage.cacheRead > 0 || + directUsage.cacheWrite > 0 + const usage = hasDirect ? directUsage : stashedUsage + const stashedModel = stashedUsage.model + + // Skip messages with neither credits nor tokens -- they're typically + // in-progress mode dividers or empty framing blocks. + if (credits === 0 && usage.input === 0 && usage.output === 0 && usage.cacheRead === 0 && usage.cacheWrite === 0) { + continue + } + + const model = resolveModel(msg.metadata, stashedModel) + const timestamp = coerceTimestamp(msg.timestamp ?? msg.metadata?.timestamp) || fallbackTs + + const dedupId = msg.id ?? String(idx) + const dedupKey = `codebuff:${chatDir}:${dedupId}` + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + const acc = { tools: [] as string[], bash: [] as string[] } + collectBlockTools(msg.blocks, acc) + + // Prefer calculated cost from tokens when available (multi-provider + // models routed through Codebuff still show up in LiteLLM); otherwise + // fall back to the credit-based approximation. + let costUSD = calculateCost(model, usage.input, usage.output, usage.cacheWrite, usage.cacheRead, 0) + if (costUSD === 0 && credits > 0) { + costUSD = credits * USD_PER_CREDIT + } + + yield { + provider: 'codebuff', + model, + inputTokens: usage.input, + outputTokens: usage.output, + cacheCreationInputTokens: usage.cacheWrite, + cacheReadInputTokens: usage.cacheRead, + cachedInputTokens: usage.cacheRead, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + tools: acc.tools, + bashCommands: acc.bash, + timestamp, + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: pendingUserMessage, + sessionId, + } + + pendingUserMessage = '' + } + }, + } +} + +export function createCodebuffProvider(baseDir?: string): Provider { + const dir = getCodebuffBaseDir(baseDir) + + return { + name: 'codebuff', + displayName: 'Codebuff', + + modelDisplayName(model: string): string { + return modelDisplayNames[model] ?? model + }, + + toolDisplayName(rawTool: string): string { + return toolNameMap[rawTool] ?? rawTool + }, + + async discoverSessions(): Promise { + return discoverSessionsInBase(dir) + }, + + createSessionParser(source: SessionSource, seenKeys: Set): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const codebuff = createCodebuffProvider() diff --git a/src/providers/codex.ts b/src/providers/codex.ts new file mode 100644 index 0000000..0917f66 --- /dev/null +++ b/src/providers/codex.ts @@ -0,0 +1,689 @@ +import { readdir, stat } from 'fs/promises' +import { createReadStream } from 'fs' +import { createInterface } from 'readline' +import { basename, join } from 'path' +import { homedir } from 'os' + +import { readSessionLines } from '../fs-utils.js' +import { calculateCost } from '../models.js' +import { readCachedCodexResults, writeCachedCodexResults, getCachedCodexProject, fingerprintFile } from '../codex-cache.js' +import { normalizeContentBlocks } from '../content-utils.js' +import type { ToolCall } from '../types.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' + +const modelDisplayNames: Record = { + 'codex-auto-review': 'Codex Auto Review', + 'gpt-5.5': 'GPT-5.5', + 'gpt-5.4-mini': 'GPT-5.4 Mini', + 'gpt-5.4': 'GPT-5.4', + 'gpt-5.3-codex-spark': 'GPT-5.3 Codex Spark', + 'gpt-5.3-codex': 'GPT-5.3 Codex', + 'gpt-5.2-low': 'GPT-5.2 Low', + 'gpt-5.2': 'GPT-5.2', + 'gpt-5': 'GPT-5', + 'gpt-4o-mini': 'GPT-4o Mini', + 'gpt-4o': 'GPT-4o', +} + +// Longest-first + version-boundary match so an unlisted future minor (gpt-5.6) +// falls through to its raw id instead of collapsing into the base "GPT-5" entry. +const modelDisplayEntries = Object.entries(modelDisplayNames).sort((a, b) => b[0].length - a[0].length) + +const toolNameMap: Record = { + exec_command: 'Bash', + read_file: 'Read', + write_file: 'Edit', + apply_diff: 'Edit', + apply_patch: 'Edit', + spawn_agent: 'Agent', + close_agent: 'Agent', + wait_agent: 'Agent', + read_dir: 'Glob', +} + +// CLI-based MCP wrappers (e.g. philschmid/mcp-cli) let Codex call an MCP tool +// through a shell command instead of registering the server natively. Codex +// then logs a plain exec_command with no `mcp_tool_call_end` event, so the MCP +// usage would only appear as a shell command and be absent from the MCP +// breakdown (issue #478). Recognize the `mcp-cli [options] call +// ` form and return the canonical mcp____ so the call is +// also attributed to MCP. Only the `call` subcommand (an actual tool execution) +// is matched; info / grep / bare listing are lookups. The exec_command still +// counts as Bash since it genuinely is a shell exec. Scoped to the mcp-cli +// binary; other wrappers would need their own pattern. +// +// The negative lookbehind keeps `mcp-cli` a standalone binary (a leading +// quote/space/slash from a `bash -lc "..."` wrapper or absolute path is fine, +// but `foo-mcp-cli` is not). `(?:\s+(?!call\b)[^\s;|&]+)*` skips any options and +// their values between the binary and the subcommand (e.g. +// `mcp-cli -c ./mcp.json call ...`) without crossing a shell separator, and +// stops at the `call` token. This is substring matching, so a command that +// merely mentions the phrase (a comment, an echo, a commit message) can +// false-positive, an accepted tradeoff for the common case. \s+ and the token +// class don't overlap, so there is no catastrophic backtracking. +const MCP_CLI_CALL = /(? typeof x === 'string').join(' ') : '' + if (!text) return null + const m = MCP_CLI_CALL.exec(text) + if (!m) return null + const server = m[1]!.replace(/['"]/g, '') + const tool = m[2]!.replace(/['"]/g, '') + if (!server || !tool) return null + return `mcp__${server}__${tool}` +} + +type CodexEntry = { + type: string + timestamp?: string + payload?: { + type?: string + role?: string + cwd?: string + model_provider?: string + originator?: string + session_id?: string + forked_from_id?: string + model?: string + name?: string + content?: Array<{ type?: string; text?: string }> + info?: { + model?: string + model_name?: string + last_token_usage?: CodexTokenUsage + total_token_usage?: CodexTokenUsage + } + } +} + +type CodexTokenUsage = { + input_tokens?: number + cached_input_tokens?: number + output_tokens?: number + reasoning_output_tokens?: number + total_tokens?: number +} + +const CHARS_PER_TOKEN = 4 +const RAW_HEAD_BYTES = 64 * 1024 +const LARGE_TEXT_CAP = 2000 + +function getCodexDir(override?: string): string { + return override ?? process.env['CODEX_HOME'] ?? join(homedir(), '.codex') +} + +function sanitizeProject(cwd: string): string { + return cwd.replace(/^\//, '').replace(/\//g, '-') +} + +// Cap how many bytes we'll read while looking for the first newline. Real +// Codex session_meta lines are ~22-27 KB; this leaves plenty of headroom while +// keeping memory bounded if a corrupt file has no newline at all. +const FIRST_LINE_READ_CAP = 1024 * 1024 + +async function readFirstLine(filePath: string): Promise { + // Codex CLI 0.128+ writes a session_meta line that can exceed 20 KB because + // it embeds the full base_instructions / system prompt. A fixed-size buffer + // would miss the trailing newline and reject the session as invalid. + // Stream the file via readline so we can read the first line up to + // FIRST_LINE_READ_CAP, which keeps memory bounded if the file has no newline. + const stream = createReadStream(filePath, { + encoding: 'utf-8', + start: 0, + end: FIRST_LINE_READ_CAP - 1, + }) + // Silence stream errors so a late read-ahead error after we've already + // returned the first line cannot escape as an unhandled 'error' event. + // readline's async iterator re-throws underlying stream errors (ENOENT, + // EACCES, etc.) on Node 16+, which the catch below handles for the cases + // that matter for validation. + stream.on('error', () => {}) + const rl = createInterface({ input: stream, crlfDelay: Infinity }) + let firstLine: string | undefined + try { + for await (const line of rl) { + firstLine = line + break + } + } catch { + return null + } finally { + rl.close() + stream.destroy() + } + if (!firstLine || !firstLine.trim()) return null + try { + return JSON.parse(firstLine) as CodexEntry + } catch { + return null + } +} + +async function isValidCodexSession(filePath: string): Promise<{ valid: boolean; meta?: CodexEntry }> { + const entry = await readFirstLine(filePath) + if (!entry) return { valid: false } + const valid = entry.type === 'session_meta' && + typeof entry.payload?.originator === 'string' && + entry.payload.originator.toLowerCase().startsWith('codex') + return { valid, meta: valid ? entry : undefined } +} + +function getRawJsonStringField(head: string, field: string): string | undefined { + const re = new RegExp(`"${field}"\\s*:\\s*"((?:\\\\.|[^"\\\\])*)"`) + const match = re.exec(head) + if (!match) return undefined + try { + return JSON.parse(`"${match[1]}"`) as string + } catch { + return match[1] + } +} + +function payloadHead(head: string): string { + const idx = head.indexOf('"payload"') + return idx === -1 ? head : head.slice(idx) +} + +function countJsonStringBytes(source: Buffer, valueStart: number): number { + let count = 0 + for (let i = valueStart; i < source.length; i++) { + const ch = source[i] + if (ch === 0x5c) { + i++ + count++ + continue + } + if (ch === 0x22) return count + count++ + } + return count +} + +function extractFirstJsonText(source: Buffer, cap = LARGE_TEXT_CAP): string { + const key = Buffer.from('"text"') + const idx = source.indexOf(key) + if (idx === -1) return '' + const colon = source.indexOf(0x3a, idx + key.length) + if (colon === -1) return '' + const qStart = source.indexOf(0x22, colon + 1) + if (qStart === -1) return '' + const chunks: number[] = [] + for (let i = qStart + 1; i < source.length && chunks.length < cap; i++) { + const ch = source[i] + if (ch === 0x5c) { + const next = source[++i] + if (next === 0x6e) chunks.push(0x0a) + else if (next === 0x72) chunks.push(0x0d) + else if (next === 0x74) chunks.push(0x09) + else if (next !== undefined) chunks.push(next) + continue + } + if (ch === 0x22) break + chunks.push(ch) + } + return Buffer.from(chunks).toString('utf-8') +} + +function countFirstJsonText(source: Buffer): number { + const key = Buffer.from('"text"') + const idx = source.indexOf(key) + if (idx === -1) return 0 + const colon = source.indexOf(0x3a, idx + key.length) + if (colon === -1) return 0 + const qStart = source.indexOf(0x22, colon + 1) + if (qStart === -1) return 0 + return countJsonStringBytes(source, qStart + 1) +} + +function parseCodexLine(line: string | Buffer): CodexEntry | null { + if (typeof line === 'string') { + const trimmed = line.trim() + if (!trimmed) return null + try { + return JSON.parse(trimmed) as CodexEntry + } catch { + return null + } + } + + if (line.length === 0) return null + const head = line.subarray(0, RAW_HEAD_BYTES).toString('utf-8') + const type = getRawJsonStringField(head, 'type') + if (!type) return null + const pHead = payloadHead(head) + const payloadType = getRawJsonStringField(pHead, 'type') + const role = getRawJsonStringField(pHead, 'role') + + const entry: CodexEntry = { + type, + timestamp: getRawJsonStringField(head, 'timestamp'), + payload: { + type: payloadType, + role, + cwd: getRawJsonStringField(pHead, 'cwd'), + model_provider: getRawJsonStringField(pHead, 'model_provider'), + originator: getRawJsonStringField(pHead, 'originator'), + session_id: getRawJsonStringField(pHead, 'session_id'), + forked_from_id: getRawJsonStringField(pHead, 'forked_from_id'), + model: getRawJsonStringField(pHead, 'model'), + name: getRawJsonStringField(pHead, 'name'), + }, + } + + if (type === 'response_item' && payloadType === 'message' && role === 'user') { + entry.payload!.content = [{ type: 'input_text', text: extractFirstJsonText(line) }] + } else if (type === 'response_item' && payloadType === 'message' && role === 'assistant') { + entry.payload!.content = [{ type: 'output_text', text: 'x'.repeat(Math.min(countFirstJsonText(line), LARGE_TEXT_CAP)) }] + } + + return entry +} + +async function discoverSessionsInDir(codexDir: string): Promise { + const sessionsDir = join(codexDir, 'sessions') + const sources: SessionSource[] = [] + + let years: string[] + try { + years = await readdir(sessionsDir) + } catch { + return sources + } + + for (const year of years) { + if (!/^\d{4}$/.test(year)) continue + const yearDir = join(sessionsDir, year) + const months = await readdir(yearDir).catch(() => [] as string[]) + + for (const month of months) { + if (!/^\d{2}$/.test(month)) continue + const monthDir = join(yearDir, month) + const days = await readdir(monthDir).catch(() => [] as string[]) + + for (const day of days) { + if (!/^\d{2}$/.test(day)) continue + const dayDir = join(monthDir, day) + const files = await readdir(dayDir).catch(() => [] as string[]) + + for (const file of files) { + if (!file.startsWith('rollout-') || !file.endsWith('.jsonl')) continue + const filePath = join(dayDir, file) + const s = await stat(filePath).catch(() => null) + if (!s?.isFile()) continue + + const cachedProject = await getCachedCodexProject(filePath) + if (cachedProject) { + sources.push({ path: filePath, project: cachedProject, provider: 'codex' }) + continue + } + + const { valid, meta } = await isValidCodexSession(filePath) + if (!valid || !meta) continue + + const cwd = meta.payload?.cwd ?? 'unknown' + sources.push({ path: filePath, project: sanitizeProject(cwd), provider: 'codex' }) + } + } + } + } + + return sources +} + +function resolveModel(info: CodexEntry['payload'], sessionModel?: string): string { + return info?.model + ?? info?.info?.model + ?? info?.info?.model_name + ?? sessionModel + ?? 'gpt-5' +} + +function createParser(source: SessionSource, seenKeys: Set): SessionParser { + return { + async *parse(): AsyncGenerator { + const cached = await readCachedCodexResults(source.path) + if (cached) { + for (const call of cached) { + if (seenKeys.has(call.deduplicationKey)) continue + seenKeys.add(call.deduplicationKey) + yield call + } + return + } + + const fp = await fingerprintFile(source.path) + if (!fp) return + + let sessionModel: string | undefined + let sessionId = '' + let forkedFromId = '' + let forkCutoff = '' + // Null sentinel rather than `0` so the FIRST event is never confused + // with a duplicate. A session that only emits last_token_usage (no + // total_token_usage) reports cumulativeTotal=0 on every event; with a + // 0-initialized prev, the first event would have matched and been + // dropped. Once we've observed any event, we record its cumulative + // total and dedup on equality regardless of whether it is zero. + let prevCumulativeTotal: number | null = null + let prevInput = 0 + let prevCached = 0 + let prevOutput = 0 + let prevReasoning = 0 + let pendingTools: string[] = [] + let pendingToolSequence: ToolCall[][] = [] + let pendingUserMessage = '' + let pendingOutputChars = 0 + let estCounter = 0 + let turnCounter = 0 + let currentTurnId = `${sessionId}:t0` + let sawAnyLine = false + const results: ParsedProviderCall[] = [] + + // Stream the session file line by line. Heavy Codex sessions can exceed + // 250 MB on disk; reading the entire file into a string would either hit + // the readSessionFile cap or push V8 toward its 512 MB string limit + // after split('\n'). readSessionLines streams raw buffers and hands + // huge lines to the compact parser without full string conversion. + for await (const rawLine of readSessionLines(source.path, undefined, { largeLineAsBuffer: true })) { + sawAnyLine = true + const entry = parseCodexLine(rawLine) + if (!entry) continue + + if (entry.type === 'session_meta') { + sessionId = entry.payload?.session_id ?? basename(source.path, '.jsonl') + forkedFromId = entry.payload?.forked_from_id ?? '' + if (forkedFromId && entry.timestamp) { + forkCutoff = new Date(new Date(entry.timestamp).getTime() + 5000).toISOString() + } + sessionModel = entry.payload?.model ?? sessionModel + continue + } + + if (entry.type === 'turn_context' && entry.payload?.model) { + sessionModel = entry.payload.model + continue + } + + if (entry.type === 'response_item' && entry.payload?.type === 'function_call') { + const rawName = entry.payload.name ?? '' + const mapped = toolNameMap[rawName] ?? rawName + pendingTools.push(mapped) + const call: ToolCall = { tool: mapped } + const rawArgs = (entry.payload as Record)['arguments'] + const args = typeof rawArgs === 'string' + ? (() => { try { return JSON.parse(rawArgs) as Record } catch { return null } })() + : typeof rawArgs === 'object' && rawArgs ? rawArgs as Record : null + if (args) { + const fp = args['file_path'] ?? args['path'] + if (typeof fp === 'string') call.file = fp + const cmd = args['command'] ?? args['cmd'] + if (typeof cmd === 'string') call.command = cmd + // Attribute a CLI-wrapped MCP call (e.g. `mcp-cli call server tool`) + // to the MCP breakdown too; the exec still counts as Bash above. + const mcpTool = mcpToolFromShellCommand(cmd) + if (mcpTool) { + pendingTools.push(mcpTool) + pendingToolSequence.push([{ tool: mcpTool }]) + } + } + pendingToolSequence.push([call]) + continue + } + + if (entry.type === 'event_msg' && entry.payload?.type === 'patch_apply_end') { + pendingTools.push('Edit') + const p = entry.payload as Record + const changes = p['changes'] + const filePaths = typeof changes === 'object' && changes ? Object.keys(changes as object) : [] + if (filePaths.length > 0) { + for (const fp of filePaths) { + pendingToolSequence.push([{ tool: 'Edit', file: fp }]) + } + } else { + pendingToolSequence.push([{ tool: 'Edit' }]) + } + continue + } + + // Recent Codex emits MCP calls as `event_msg`/`mcp_tool_call_end` + // instead of a `function_call` response_item, so the call was never + // attributed. Rebuild the canonical `mcp____` name the + // classifier recognizes. + if (entry.type === 'event_msg' && entry.payload?.type === 'mcp_tool_call_end') { + const inv = (entry.payload as Record)['invocation'] as Record | undefined + const server = typeof inv?.['server'] === 'string' ? inv['server'] as string : '' + const tool = typeof inv?.['tool'] === 'string' ? inv['tool'] as string : '' + if (server && tool) { + const name = `mcp__${server}__${tool}` + pendingTools.push(name) + pendingToolSequence.push([{ tool: name }]) + } + continue + } + + if (entry.type === 'response_item' && entry.payload?.type === 'message' && entry.payload?.role === 'user') { + const texts = normalizeContentBlocks(entry.payload.content) + .filter(c => c.type === 'input_text') + .map(c => c.text ?? '') + .filter(Boolean) + if (texts.length > 0) { + pendingUserMessage = texts.join(' ').slice(0, 500) + currentTurnId = `${sessionId}:t${++turnCounter}` + } + continue + } + + if (entry.type === 'response_item' && entry.payload?.type === 'message' && entry.payload?.role === 'assistant') { + const texts = normalizeContentBlocks(entry.payload.content) + .filter(c => c.type === 'output_text' || c.type === 'text') + .map(c => c.text ?? '') + pendingOutputChars += texts.join('').length + continue + } + + if (entry.type === 'event_msg' && entry.payload?.type === 'token_count') { + // Forked sessions replay the parent's entire event history with + // timestamps clustered at the fork creation time. Skip replayed + // events (within 5s of fork) to avoid double-counting. + if (forkCutoff && entry.timestamp && entry.timestamp < forkCutoff) continue + const info = entry.payload.info + if (!info) { + if (pendingOutputChars === 0 && pendingUserMessage.length === 0) continue + const estInput = Math.ceil(pendingUserMessage.length / CHARS_PER_TOKEN) + const estOutput = Math.ceil(pendingOutputChars / CHARS_PER_TOKEN) + if (estInput === 0 && estOutput === 0) continue + + const model = sessionModel ?? 'gpt-5' + const timestamp = entry.timestamp ?? '' + const dedupKey = `codex:${sessionId}:${timestamp}:est${estCounter++}` + + if (seenKeys.has(dedupKey)) { pendingTools = []; pendingToolSequence = []; pendingUserMessage = ''; pendingOutputChars = 0; continue } + seenKeys.add(dedupKey) + + const costUSD = calculateCost(model, estInput, estOutput, 0, 0, 0) + + results.push({ + provider: 'codex', + model, + inputTokens: estInput, + outputTokens: estOutput, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + costIsEstimated: true, + tools: pendingTools, + bashCommands: [], + timestamp, + speed: 'standard', + deduplicationKey: dedupKey, + turnId: currentTurnId, + toolSequence: pendingToolSequence.length > 0 ? pendingToolSequence : undefined, + userMessage: pendingUserMessage, + sessionId, + }) + + pendingTools = [] + pendingToolSequence = [] + pendingUserMessage = '' + pendingOutputChars = 0 + continue + } + + const cumulativeTotal = info.total_token_usage?.total_tokens ?? 0 + // Dedup guard. Two consecutive events with cumulativeTotal=0 but + // non-empty last_token_usage would have been double-counted with + // the previous `> 0` clause. The null sentinel ensures the FIRST + // event always passes (so a session that never reports cumulative + // doesn't lose its opening turn). + if (prevCumulativeTotal !== null && cumulativeTotal === prevCumulativeTotal) continue + prevCumulativeTotal = cumulativeTotal + + const last = info.last_token_usage + let inputTokens = 0 + let cachedInputTokens = 0 + let outputTokens = 0 + let reasoningTokens = 0 + + if (last) { + inputTokens = last.input_tokens ?? 0 + cachedInputTokens = last.cached_input_tokens ?? 0 + outputTokens = last.output_tokens ?? 0 + reasoningTokens = last.reasoning_output_tokens ?? 0 + } else if (cumulativeTotal > 0) { + const total = info.total_token_usage + if (!total) continue + inputTokens = (total.input_tokens ?? 0) - prevInput + cachedInputTokens = (total.cached_input_tokens ?? 0) - prevCached + outputTokens = (total.output_tokens ?? 0) - prevOutput + reasoningTokens = (total.reasoning_output_tokens ?? 0) - prevReasoning + } + + // Always advance the prev counters to track the cumulative state. + // Previously prev was only updated on the fallback branch, so a + // session with mixed last_token_usage / no-last events would + // compute the next fallback delta against a stale prev=0 baseline, + // double-counting the entire cumulative window. The prev value + // must mirror what cumulative reports regardless of whether this + // event used `last` or fell back to deltas. + const total = info.total_token_usage + if (total) { + prevInput = total.input_tokens ?? 0 + prevCached = total.cached_input_tokens ?? 0 + prevOutput = total.output_tokens ?? 0 + prevReasoning = total.reasoning_output_tokens ?? 0 + } + + const totalTokens = inputTokens + cachedInputTokens + outputTokens + reasoningTokens + if (totalTokens === 0) continue + + // OpenAI includes cached tokens inside input_tokens; Anthropic does not. + // Normalize to Anthropic semantics: inputTokens = non-cached only. + const uncachedInputTokens = Math.max(0, inputTokens - cachedInputTokens) + + const model = resolveModel(entry.payload, sessionModel) + const timestamp = entry.timestamp ?? '' + // Forked sessions copy the parent's entire token_count history + // (re-timestamped), so replays must collide with the parent's events + // and drop to avoid double-counting -- hence the parent namespace + // (forkedFromId) and the deliberate omission of the per-session id. + // But cumulativeTotal alone is too coarse a discriminator: a genuine + // post-divergence fork event whose running total coincidentally equals + // some parent total would also collide and be lost (undercount). So we + // also key on the cumulative token breakdown, which a fork replays + // verbatim from the parent -- a true replay collides exactly, while + // genuinely different work at the same total stays distinct. We use the + // CUMULATIVE figures (not the per-event deltas) on purpose: the deltas + // are computed against a running `prev` that the fork advances + // differently once the 5s cutoff skips some replays, so a delta-based + // key would spuriously diverge on a replay and double-count it. + const dedupKey = `codex:${forkedFromId || sessionId}:${cumulativeTotal}:${total?.input_tokens ?? 0}:${total?.cached_input_tokens ?? 0}:${total?.output_tokens ?? 0}:${total?.reasoning_output_tokens ?? 0}` + + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + const costUSD = calculateCost( + model, + uncachedInputTokens, + outputTokens + reasoningTokens, + 0, + cachedInputTokens, + 0, + ) + + results.push({ + provider: 'codex', + model, + inputTokens: uncachedInputTokens, + outputTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: cachedInputTokens, + cachedInputTokens, + reasoningTokens, + webSearchRequests: 0, + costUSD, + tools: pendingTools, + bashCommands: [], + timestamp, + speed: 'standard', + deduplicationKey: dedupKey, + turnId: currentTurnId, + toolSequence: pendingToolSequence.length > 0 ? pendingToolSequence : undefined, + userMessage: pendingUserMessage, + sessionId, + }) + + pendingTools = [] + pendingToolSequence = [] + pendingUserMessage = '' + pendingOutputChars = 0 + } + } + + // If the stream yielded nothing the file was unreadable, oversized, or + // empty. Skip cache write so a transient failure can't pin an empty + // result set against a fingerprint that would otherwise be re-parsed. + if (!sawAnyLine) return + + await writeCachedCodexResults(source.path, source.project, results, fp) + + for (const call of results) { + yield call + } + }, + } +} + +export function createCodexProvider(codexDir?: string): Provider { + const dir = getCodexDir(codexDir) + + return { + name: 'codex', + displayName: 'Codex', + + modelDisplayName(model: string): string { + for (const [key, name] of modelDisplayEntries) { + if (model === key || model.startsWith(key + '-')) return name + } + return model + }, + + toolDisplayName(rawTool: string): string { + return toolNameMap[rawTool] ?? rawTool + }, + + async discoverSessions(): Promise { + return discoverSessionsInDir(dir) + }, + + createSessionParser(source: SessionSource, seenKeys: Set): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const codex = createCodexProvider() diff --git a/src/providers/copilot.ts b/src/providers/copilot.ts new file mode 100644 index 0000000..e756197 --- /dev/null +++ b/src/providers/copilot.ts @@ -0,0 +1,2321 @@ +// ============================================================================= +// copilot.ts — Modified CodeBurn Copilot provider +// ============================================================================= +// +// WHAT CHANGED: +// The original provider only reads Copilot's JSONL session-state files from +// ~/.copilot/session-state/, which only log output tokens. Input tokens, +// cache-read tokens, and cache-creation tokens are never written there, so +// CodeBurn underreports Copilot costs by 60-80%. +// +// This modified version adds VS Code sources that can carry fuller token +// data: the OTel SQLite store (agent-traces.db), VS Code core chatSessions +// journals, and legacy extension transcripts. OTel and chatSessions contain +// input/output token breakdowns for Copilot Chat users; legacy JSONL remains +// a fallback when richer sources are absent. +// +// HOW TO ENABLE THE OTEL SQLITE STORE: +// TWO settings must both be enabled in VS Code settings.json: +// +// { +// "github.copilot.chat.otel.enabled": true, +// "github.copilot.chat.otel.dbSpanExporter.enabled": true +// } +// +// The first enables the OTel pipeline; the second (defaults to false) enables +// the SQLite span exporter that actually writes agent-traces.db. +// After changing these settings, restart VS Code — the extension watches for +// these changes and requires a reload to take effect. +// +// Or set the environment variable before launching VS Code: +// +// export COPILOT_OTEL_ENABLED=true +// +// The DB file is created in VS Code's global storage directory: +// ~/Library/Application Support/Code/User/globalStorage/github.copilot-chat/agent-traces.db +// +// ENVIRONMENT VARIABLES: +// CODEBURN_COPILOT_OTEL_DB — Override the agent-traces.db path +// CODEBURN_COPILOT_DISABLE_OTEL=1 — Skip OTel entirely, use only JSONL +// CODEBURN_COPILOT_WS_STORAGE_DIR — Override VS Code workspaceStorage +// CODEBURN_COPILOT_GLOBAL_STORAGE_DIR — Override VS Code globalStorage +// CODEBURN_COPILOT_JETBRAINS_DIR — Override the JetBrains github-copilot root +// +// ARCHITECTURE: +// discoverSessions() returns OTel sessions and legacy JSONL sessions. When +// OTel is present, VS Code core chatSessions are skipped because they mirror +// the same Copilot turns under different IDs. OTel sessions carry the full +// token breakdown; JSONL sessions only carry output tokens (the original +// behaviour, as a fallback). +// +// LIMITATIONS: +// - The OTel DB only contains Copilot Chat and Agent mode spans. Inline +// completions (ghost text) and Agent Host spans are NOT yet written to +// this DB (see https://github.com/microsoft/vscode/issues/315901). +// - The DB schema is inferred from the official OTel GenAI semantic +// conventions and the Copilot Budget extension's approach. If VS Code +// changes the schema, this parser will need updating. +// ============================================================================= + +import { readdir, stat } from 'fs/promises' +import { homedir, platform } from 'os' +import { join, basename, dirname, posix, win32 } from 'path' +import { existsSync } from 'fs' +import { createHash } from 'crypto' +import { readSessionFile } from '../fs-utils.js' +import { calculateCost } from '../models.js' +import { extractBashCommands } from '../bash-utils.js' +import { estimateTokens } from '../context-tree.js' +import type { + Provider, + SessionSource, + SessionParser, + ParsedProviderCall, +} from './types.js' + +// --------------------------------------------------------------------------- +// Model display names (unchanged from original) +// --------------------------------------------------------------------------- +const modelDisplayNames: Record = { + 'gpt-4.1-nano': 'GPT-4.1 Nano', + 'gpt-4.1-mini': 'GPT-4.1 Mini', + 'gpt-4.1': 'GPT-4.1', + 'gpt-4o-mini': 'GPT-4o Mini', + 'gpt-4o': 'GPT-4o', + 'gpt-5-mini': 'GPT-5 Mini', + 'gpt-5': 'GPT-5', + 'claude-sonnet-4-5': 'Sonnet 4.5', + 'claude-sonnet-4': 'Sonnet 4', + 'copilot-openai-auto': 'Copilot (OpenAI auto)', + 'copilot-anthropic-auto': 'Copilot (Anthropic auto)', +} + +// --------------------------------------------------------------------------- +// Tool name normalisation (unchanged from original, plus OTel tool names) +// --------------------------------------------------------------------------- +const toolNameMap: Record = { + // JSONL session-state tool names + bash: 'Bash', + read_file: 'Read', + write_file: 'Edit', + edit_file: 'Edit', + delete_file: 'Delete', + github_repo: 'GitHub', + web_search: 'WebSearch', + run_in_terminal: 'Shell', + // JetBrains Copilot agent tool names (snake_case) + insert_edit_into_file: 'Edit', + create_file: 'Edit', + get_errors: 'Diagnostics', + file_search: 'Search', + grep_search: 'Search', + semantic_search: 'Search', + list_dir: 'Search', + fetch_webpage: 'Web', + // OTel execute_tool span names from Copilot Chat: + readFile: 'Read', + writeFile: 'Edit', + editFile: 'Edit', + runCommand: 'Shell', + runInTerminal: 'Shell', + findFiles: 'Search', + grepSearch: 'Search', + codebaseSearch: 'Search', + getErrors: 'Diagnostics', + listCodeUsages: 'Search', + createFile: 'Edit', + deleteFile: 'Delete', + renameOrMoveFile: 'Edit', + fetchWebpage: 'Web', +} + +/** + * Normalise a raw tool name to its display form. + * - Known tools are mapped via toolNameMap. + * - MCP tools (containing both '-' and '_') are formatted as + * mcp__server_name__tool_name. + * - Everything else is returned unchanged. + */ +function normalizeTool(rawTool: string): string { + const mapped = toolNameMap[rawTool] + if (mapped) return mapped + // MCP tool names follow the pattern: server-name-tool_operand + // e.g. github-mcp-server-list_issues → mcp__github_mcp_server__list_issues + const dashIdx = rawTool.lastIndexOf('-') + if (dashIdx > 0 && rawTool.includes('_')) { + const server = rawTool.slice(0, dashIdx).replace(/-/g, '_') + const tool = rawTool.slice(dashIdx + 1) + return `mcp__${server}__${tool}` + } + return rawTool +} + +const modelDisplayEntries = Object.entries(modelDisplayNames).sort( + (a, b) => b[0].length - a[0].length +) + +// Tool names that represent shell/bash execution. When the AI calls one of +// these, we extract the `arguments.command` string into bashCommands[]. +const BASH_TOOL_NAMES = new Set(['bash', 'run_in_terminal', 'runInTerminal', 'runCommand']) + +// --------------------------------------------------------------------------- +// Types for JSONL session state events (unchanged from original) +// --------------------------------------------------------------------------- +type ToolRequest = { + toolName?: string // older format + name?: string // newer format (copilot-agent) + arguments?: Record +} + +type SessionStartData = { + selectedModel?: string +} + +type ModelChangeData = { + newModel: string + previousModel?: string +} + +type UserMessageData = { + content: string + interactionId?: string +} + +type AssistantMessageData = { + messageId: string + model?: string // present in newer copilot-agent format + outputTokens: number + interactionId?: string + toolRequests?: ToolRequest[] +} + +type SubagentSelectedData = { + agentName: string + agentDisplayName?: string + tools?: string[] +} + +type CopilotEvent = + | { type: 'session.start'; data: SessionStartData; timestamp?: string } + | { type: 'session.model_change'; data: ModelChangeData; timestamp?: string } + | { type: 'user.message'; data: UserMessageData; timestamp?: string } + | { type: 'assistant.message'; data: AssistantMessageData; timestamp?: string } + | { type: 'subagent.selected'; data: SubagentSelectedData; timestamp?: string } + +type ChatJournalPathSegment = string | number +type ChatSessionRequest = Record + +// --------------------------------------------------------------------------- +// Types for OTel span rows from agent-traces.db +// --------------------------------------------------------------------------- + +// The OTel SQLite store schema uses a spans table where attributes are stored +// either as a JSON blob or as individual columns. We handle both patterns. +// The Copilot Budget extension reads from this same DB and uses per-span +// token counts, confirming this schema is stable enough to depend on. + +// Parsed attribute bag from a span +interface SpanAttributes { + 'gen_ai.operation.name'?: string + 'gen_ai.response.model'?: string + 'gen_ai.request.model'?: string + 'gen_ai.usage.input_tokens'?: number + 'gen_ai.usage.output_tokens'?: number + 'gen_ai.usage.cache_read.input_tokens'?: number + 'gen_ai.usage.cache_creation.input_tokens'?: number + 'gen_ai.conversation.id'?: string + 'gen_ai.agent.name'?: string + 'gen_ai.tool.name'?: string + 'gen_ai.tool.call.arguments'?: string + 'copilot_chat.parent_chat_session_id'?: string + 'github.copilot.chat.turn.id'?: string + [key: string]: unknown +} + +// --------------------------------------------------------------------------- +// Paths +// --------------------------------------------------------------------------- + +function getCopilotSessionStateDir(override?: string): string { + return override ?? process.env['CODEBURN_COPILOT_SESSION_STATE_DIR'] ?? join(homedir(), '.copilot', 'session-state') +} + +/** + * Locate the agent-traces.db file. + * + * Priority: + * 1. CODEBURN_COPILOT_OTEL_DB env var + * 2. Platform-specific default VS Code global storage path + * 3. VSCodium variant paths + */ +function getAgentTracesDbPath(): string | null { + // Allow explicit override + const envOverride = process.env['CODEBURN_COPILOT_OTEL_DB'] + if (envOverride) { + return existsSync(envOverride) ? envOverride : null + } + + const home = homedir() + const candidates: string[] = [] + + const p = platform() + if (p === 'darwin') { + // macOS: VS Code, VS Code Insiders, VSCodium + candidates.push( + join(home, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'github.copilot-chat', 'agent-traces.db'), + join(home, 'Library', 'Application Support', 'Code - Insiders', 'User', 'globalStorage', 'github.copilot-chat', 'agent-traces.db'), + join(home, 'Library', 'Application Support', 'VSCodium', 'User', 'globalStorage', 'github.copilot-chat', 'agent-traces.db'), + ) + } else if (p === 'linux') { + // Linux: VS Code, VS Code Insiders, VSCodium + candidates.push( + join(home, '.config', 'Code', 'User', 'globalStorage', 'github.copilot-chat', 'agent-traces.db'), + join(home, '.config', 'Code - Insiders', 'User', 'globalStorage', 'github.copilot-chat', 'agent-traces.db'), + join(home, '.config', 'VSCodium', 'User', 'globalStorage', 'github.copilot-chat', 'agent-traces.db'), + ) + } else if (p === 'win32') { + // Windows + const appdata = process.env['APPDATA'] ?? join(home, 'AppData', 'Roaming') + candidates.push( + join(appdata, 'Code', 'User', 'globalStorage', 'github.copilot-chat', 'agent-traces.db'), + join(appdata, 'Code - Insiders', 'User', 'globalStorage', 'github.copilot-chat', 'agent-traces.db'), + join(appdata, 'VSCodium', 'User', 'globalStorage', 'github.copilot-chat', 'agent-traces.db'), + ) + } + + for (const candidate of candidates) { + if (existsSync(candidate)) return candidate + } + return null +} + +/** + * Locate the GitHub Copilot config root used by the JetBrains IDE plugin + * (IntelliJ IDEA, PyCharm, RubyMine, …). The JetBrains Copilot agent persists + * chat/agent sessions here — a location none of the VS Code or CLI sources + * touch, so this is the only way JetBrains-driven Copilot usage becomes + * visible to CodeBurn. + * + * The path mirrors the plugin's own `getXdgConfigPath` logic (observed in the + * bundled copilot-agent language server): + * - $XDG_CONFIG_HOME/github-copilot (when set to an absolute path) + * - macOS / Linux: ~/.config/github-copilot + * - Windows: %USERPROFILE%\AppData\Local\github-copilot + * + * Under this root, each IDE has its own subdir (e.g. `iu` for IntelliJ IDEA + * Ultimate, `intellij` for the community edition) containing + * chat-agent-sessions/, chat-sessions/, and chat-edit-sessions/. + */ +function getJetBrainsCopilotRoot(override?: string): string { + const envOverride = override ?? process.env['CODEBURN_COPILOT_JETBRAINS_DIR'] + if (envOverride) return envOverride + + const xdg = process.env['XDG_CONFIG_HOME'] + if (xdg && (posix.isAbsolute(xdg) || win32.isAbsolute(xdg))) { + return join(xdg, 'github-copilot') + } + + if (platform() === 'win32') { + const local = process.env['LOCALAPPDATA'] ?? join(homedir(), 'AppData', 'Local') + return join(local, 'github-copilot') + } + + return join(homedir(), '.config', 'github-copilot') +} + +// --------------------------------------------------------------------------- +// Helpers +// --------------------------------------------------------------------------- + +function parseCwd(yaml: string): string | null { + const match = yaml.match(/^cwd:\s*(.+)$/m) + if (!match?.[1]) return null + let raw = match[1].trim() + // Strip inline YAML comments (# preceded by optional whitespace) + raw = raw.replace(/\s*#.*$/, '') + // Strip surrounding single/double quotes + raw = raw.replace(/^['"]|['"]$/g, '').trim() + return raw || null +} + +/** + * Load span attributes from the span_attributes table (key-value pairs). + * This handles the modern VS Code Copilot Chat schema where attributes + * are stored as separate key-value rows rather than a JSON blob. + */ +function loadSpanAttributesFromTable( + db: ReturnType, + spanId: string +): SpanAttributes { + try { + const rows = db.query<{ key: string; value: string | null }>( + `SELECT key, value FROM span_attributes WHERE span_id = ?`, + [spanId] + ) + const attrs: SpanAttributes = {} + for (const row of rows) { + if (row.key && row.value) { + try { + // Try to parse numeric values + const numValue = Number(row.value) + attrs[row.key as keyof SpanAttributes] = Number.isNaN(numValue) + ? row.value + : numValue + } catch { + attrs[row.key as keyof SpanAttributes] = row.value + } + } + } + return attrs + } catch { + return {} + } +} + +/** + * Convert nanosecond or millisecond epoch to ISO timestamp. + * The OTel spec uses nanoseconds, but some implementations use milliseconds. + */ +function epochToISO(epoch: number): string { + // Guard malformed rows: new Date(NaN).toISOString() throws. Fall back to the + // epoch (1970) so a bad timestamp is excluded from period totals, not crashing. + if (!Number.isFinite(epoch) || epoch <= 0) return new Date(0).toISOString() + // If the value looks like nanoseconds (> 1e15), convert to ms + const ms = epoch > 1e15 ? Math.floor(epoch / 1e6) : epoch > 1e12 ? epoch : epoch * 1000 + return new Date(ms).toISOString() +} + +function timestampToISO(raw: unknown): string { + if (typeof raw === 'number' && Number.isFinite(raw) && raw > 0) { + return epochToISO(raw) + } + if (typeof raw !== 'string') return '' + const trimmed = raw.trim() + if (!trimmed) return '' + if (/^\d+(\.\d+)?$/.test(trimmed)) { + return epochToISO(Number(trimmed)) + } + const parsed = Date.parse(trimmed) + return Number.isNaN(parsed) ? '' : new Date(parsed).toISOString() +} + +function isRecord(value: unknown): value is Record { + return typeof value === 'object' && value !== null && !Array.isArray(value) +} + +function isReplayContainer(value: unknown): value is object { + return typeof value === 'object' && value !== null +} + +function createReplayObject(): Record { + return Object.create(null) as Record +} + +const FORBIDDEN_CHAT_JOURNAL_KEYS = new Set(['__proto__', 'prototype', 'constructor']) + +function parseChatJournalPath(rawPath: unknown, fallback?: ChatJournalPathSegment[]): ChatJournalPathSegment[] | null { + const value = rawPath === undefined ? fallback : rawPath + if (!Array.isArray(value)) return null + + const path: ChatJournalPathSegment[] = [] + for (const segment of value) { + if (typeof segment === 'number') { + if (!Number.isInteger(segment) || segment < 0) return null + path.push(segment) + continue + } + if (typeof segment === 'string') { + if (FORBIDDEN_CHAT_JOURNAL_KEYS.has(segment)) return null + path.push(segment) + continue + } + return null + } + return path +} + +function getReplayValue(container: object, segment: ChatJournalPathSegment): unknown { + return (container as Record)[String(segment)] +} + +function setReplayValue(container: object, segment: ChatJournalPathSegment, value: unknown): void { + ;(container as Record)[String(segment)] = value +} + +function createContainerForNext(segment: ChatJournalPathSegment): unknown[] | Record { + return typeof segment === 'number' ? [] : createReplayObject() +} + +function ensureReplayParent(root: object, path: ChatJournalPathSegment[]): object | null { + let current: object = root + for (let i = 0; i < path.length - 1; i++) { + const segment = path[i]! + const nextSegment = path[i + 1]! + let child = getReplayValue(current, segment) + if (!isReplayContainer(child)) { + const created = createContainerForNext(nextSegment) + setReplayValue(current, segment, created) + current = created + continue + } + current = child + } + return current +} + +function applyChatJournalSet(root: unknown, path: ChatJournalPathSegment[], value: unknown): unknown { + if (path.length === 0) return value + + const workingRoot = isReplayContainer(root) ? root : createReplayObject() + const parent = ensureReplayParent(workingRoot, path) + if (!parent) return workingRoot + setReplayValue(parent, path[path.length - 1]!, value) + return workingRoot +} + +function applyChatJournalAppend(root: unknown, path: ChatJournalPathSegment[], items: unknown[]): unknown { + const workingRoot = isReplayContainer(root) ? root : createReplayObject() + + if (path.length === 0) { + if (Array.isArray(workingRoot)) { + for (const item of items) workingRoot.push(item) + } + return workingRoot + } + + const parent = ensureReplayParent(workingRoot, path) + if (!parent) return workingRoot + + const last = path[path.length - 1]! + let target = getReplayValue(parent, last) + const targetArray: unknown[] = Array.isArray(target) ? target : [] + if (target !== targetArray) { + setReplayValue(parent, last, targetArray) + } + for (const item of items) targetArray.push(item) + return workingRoot +} + +function replayChatSessionJournal(content: string): unknown { + let root: unknown = createReplayObject() + const lines = content.split('\n').filter((l) => l.trim()) + + for (const line of lines) { + let entry: unknown + try { + entry = JSON.parse(line) as unknown + } catch { + continue + } + if (!isRecord(entry)) continue + + const kind = entry['kind'] + if (kind === 0) { + root = entry['v'] + continue + } + + if (kind === 1) { + const path = parseChatJournalPath(entry['k']) + if (!path) continue + root = applyChatJournalSet(root, path, entry['v']) + continue + } + + if (kind === 2) { + const hasPath = Object.prototype.hasOwnProperty.call(entry, 'k') + const path = parseChatJournalPath(hasPath ? entry['k'] : undefined, ['requests']) + const items = Array.isArray(entry['v']) ? entry['v'] : [] + if (!path) continue + root = applyChatJournalAppend(root, path, items) + } + } + + return root +} + +function numberOrZero(raw: unknown): number { + return typeof raw === 'number' && Number.isFinite(raw) && raw > 0 ? raw : 0 +} + +function readString(raw: unknown): string { + return typeof raw === 'string' ? raw : '' +} + +function modelFromChatSessionRequest(req: ChatSessionRequest, metadata: Record): string { + const resolved = readString(metadata['resolvedModel']) + if (resolved) return resolved + + const modelId = readString(req['modelId']).replace(/^copilot\//, '') + return modelId || 'unknown' +} + +function extractChatSessionTools(metadata: Record): string[] { + const rounds = metadata['toolCallRounds'] + if (!Array.isArray(rounds)) return [] + + const names = new Set() + const addName = (raw: unknown): void => { + if (typeof raw === 'string' && raw.trim()) names.add(normalizeTool(raw)) + } + const addFromRecord = (record: Record): void => { + addName(record['toolName']) + addName(record['name']) + addName(record['tool']) + } + + for (const round of rounds) { + if (!isRecord(round)) continue + addFromRecord(round) + + for (const key of ['tools', 'toolCalls', 'toolRequests']) { + const entries = round[key] + if (!Array.isArray(entries)) continue + for (const entry of entries) { + if (typeof entry === 'string') { + addName(entry) + } else if (isRecord(entry)) { + addFromRecord(entry) + } + } + } + } + + return [...names] +} + +/** + * Extract a shell command string from an OTel execute_tool span's + * `gen_ai.tool.call.arguments` attribute. The attribute is a JSON-encoded + * argument object (e.g. `{"command":"ls -la"}`); we pull out the `command` + * field. Returns null when the attribute is absent or doesn't carry a command, + * so callers can skip shell-command extraction cleanly. + */ +function parseToolCommand(raw: unknown): string | null { + if (typeof raw !== 'string' || !raw.trim()) return null + try { + const parsed = JSON.parse(raw) as Record + const command = parsed['command'] + return typeof command === 'string' ? command : null + } catch { + return null + } +} + +// Shell control-flow keywords. These lead a statement but are not commands, so +// they must never be reported as bash commands. +const OTEL_SHELL_KEYWORDS = new Set([ + 'if', 'then', 'else', 'elif', 'fi', + 'for', 'while', 'until', 'do', 'done', + 'case', 'esac', 'select', 'function', 'in', 'time', 'coproc', +]) + +/** + * Normalise an OTEL shell command before command-name extraction. + * + * Unlike the Copilot CLI / VS Code JSONL logs — which record a single command + * per tool call (e.g. `cd x && python3 y`) — the OTEL store records the FULL + * multi-line script the agent ran (heredocs, for/if blocks, newline-separated + * statements). The shared extractBashCommands helper only splits on `;`/`&&`/`|` + * and has no concept of shell keywords, so those scripts leak control-flow words + * (`for`, `do`, `if`, `then`, …) and collapse newline-separated statements. + * + * Normalising here — rather than in the shared helper — keeps every other + * provider's behaviour unchanged. We (1) turn newlines into `;` so each + * statement is its own segment, then (2) drop shell control-flow keywords. + */ +function extractOtelBashCommands(command: string): string[] { + const normalized = command.replace(/\r?\n/g, '; ') + return extractBashCommands(normalized).filter(c => !OTEL_SHELL_KEYWORDS.has(c)) +} + +// --------------------------------------------------------------------------- +// Helpers for JSONL / transcript parsing +// --------------------------------------------------------------------------- + +/** + * Safely coerce a raw toolRequests value to an array of ToolRequest. + * Non-array values (string, null, undefined) are treated as empty arrays + * so that a corrupt event.data doesn't abort the whole file parse loop. + */ +function coerceToolRequests(raw: unknown): ToolRequest[] { + return Array.isArray(raw) ? (raw as ToolRequest[]) : [] +} + +/** + * Infer the model bucket for a VS Code transcript file by counting the + * toolCallId prefixes across all assistant messages: + * call_* → OpenAI + * tooluse_* / toolu_* → Anthropic + * The dominant prefix determines the model for the whole session. + * Returns '' if no toolCallIds are present. + */ +function inferTranscriptModel(lines: string[]): string { + let openaiCount = 0 + let anthropicCount = 0 + + for (const line of lines) { + try { + const event = JSON.parse(line) as CopilotEvent + if (event.type !== 'assistant.message') continue + const data = event.data as AssistantMessageData & { toolRequests?: Array<{ toolCallId?: string }> } + const reqs = coerceToolRequests(data.toolRequests) + for (const req of reqs) { + const id = (req as { toolCallId?: unknown }).toolCallId + if (typeof id !== 'string') continue + if (id.startsWith('call_')) openaiCount++ + else if (/^tooluse_|^toolu_/.test(id)) anthropicCount++ + } + } catch { + continue + } + } + + if (openaiCount === 0 && anthropicCount === 0) return '' + return openaiCount >= anthropicCount ? 'copilot-openai-auto' : 'copilot-anthropic-auto' +} + +// --------------------------------------------------------------------------- +// JSONL parser (handles both regular session-state events and VS Code +// transcript format via session.start { producer: 'copilot-agent' }) +// --------------------------------------------------------------------------- + +function createJsonlParser( + source: SessionSource, + seenKeys: Set +): SessionParser { + return { + async *parse(): AsyncGenerator { + const content = await readSessionFile(source.path) + if (!content) return + const sessionId = basename(dirname(source.path)) + const lines = content.split('\n').filter((l) => l.trim()) + + // Detect VS Code transcript format: the first session.start event has + // { producer: 'copilot-agent' } and no outputTokens in messages. + let isTranscript = false + let currentModel = '' + let pendingUserMessage = '' + // Track the active subagent for this session (from subagent.selected events). + // Resets when a new subagent is selected. + let currentSubagentType: string | undefined + + // First pass: detect format and infer transcript model if needed. + for (const line of lines) { + try { + const ev = JSON.parse(line) as CopilotEvent + if (ev.type === 'session.start') { + const data = ev.data as SessionStartData & { producer?: string } + if (data.producer === 'copilot-agent') { + isTranscript = true + } + break + } + if (ev.type === 'session.model_change') break // regular format + } catch { + continue + } + } + + if (isTranscript) { + currentModel = inferTranscriptModel(lines) + if (!currentModel) return // no toolCallIds to infer model from + } + + for (const line of lines) { + let event: CopilotEvent + try { + event = JSON.parse(line) as CopilotEvent + } catch { + continue + } + + if (event.type === 'session.start') { + if (!isTranscript) { + currentModel = (event.data as SessionStartData).selectedModel ?? currentModel + } + continue + } + + if (event.type === 'session.model_change') { + currentModel = (event.data as ModelChangeData).newModel ?? currentModel + continue + } + + if (event.type === 'subagent.selected') { + currentSubagentType = (event.data as SubagentSelectedData).agentName + continue + } + + if (event.type === 'user.message') { + pendingUserMessage = (event.data as UserMessageData).content ?? '' + continue + } + + if (event.type === 'assistant.message') { + const msgData = event.data as AssistantMessageData + const { messageId, model: msgModel, outputTokens = 0 } = msgData + const rawRequests = (msgData as { toolRequests?: unknown }).toolRequests + const toolRequests = coerceToolRequests(rawRequests) + + // model may be carried per-message in newer copilot-agent format + if (msgModel) currentModel = msgModel + // Regular JSONL: skip zero-token messages; transcripts don't have tokens + if (!isTranscript && outputTokens === 0) continue + if (!currentModel) continue + + const dedupKey = `copilot:${sessionId}:${messageId}` + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + const tools = toolRequests + .map((t) => { + const raw = typeof t === 'object' && t !== null + ? ((t as { name?: unknown; toolName?: unknown }).name ?? (t as { name?: unknown; toolName?: unknown }).toolName) + : null + return typeof raw === 'string' ? normalizeTool(raw) : null + }) + .filter((t): t is string => t !== null) + + // Extract base command names from bash-type tool requests, routing the + // raw command through the shared extractBashCommands helper so chained + // commands are normalised the same way as every other provider + // (see bash-utils.ts, parser.ts, forge.ts, grok.ts, etc.). + const bashCommands = toolRequests.flatMap((t) => { + if (typeof t !== 'object' || t === null) return [] + const name = (t.name ?? t.toolName) ?? '' + if (!BASH_TOOL_NAMES.has(name)) return [] + const cmd = t.arguments?.['command'] + return typeof cmd === 'string' ? extractBashCommands(cmd) : [] + }) + + // Copilot JSONL only logs outputTokens; inputTokens are NOT available. + // Cost will be lower than actual API cost. This is the original + // behaviour — OTel data (below) replaces it when available. + const costUSD = calculateCost(currentModel, 0, outputTokens, 0, 0, 0) + + yield { + provider: 'copilot', + sessionId, + model: currentModel, + inputTokens: 0, + outputTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + tools, + bashCommands, + subagentTypes: currentSubagentType ? [currentSubagentType] : undefined, + timestamp: event.timestamp ?? '', + speed: 'standard' as const, + deduplicationKey: dedupKey, + userMessage: pendingUserMessage, + } + pendingUserMessage = '' + } + } + }, + } +} + +function createChatSessionParser( + source: SessionSource, + seenKeys: Set +): SessionParser { + return { + async *parse(): AsyncGenerator { + const content = await readSessionFile(source.path) + if (!content) return + + const root = replayChatSessionJournal(content) + if (!isRecord(root)) return + + const sessionId = readString(root['sessionId']) || basename(source.path, '.jsonl') + const sessionCreatedAt = timestampToISO(root['creationDate']) + const requests = Array.isArray(root['requests']) ? root['requests'] : [] + + for (let index = 0; index < requests.length; index++) { + const rawReq = requests[index] + if (!isRecord(rawReq)) continue + + const result = rawReq['result'] + const resultRecord = isRecord(result) ? result : null + const rawMetadata = resultRecord?.['metadata'] + const metadata = isRecord(rawMetadata) ? rawMetadata : createReplayObject() + + const inputTokens = numberOrZero(metadata['promptTokens']) + const metadataOutputTokens = numberOrZero(metadata['outputTokens']) + const outputTokens = metadataOutputTokens || numberOrZero(rawReq['completionTokens']) + + if (inputTokens === 0 && outputTokens === 0) continue + + const requestId = readString(rawReq['requestId']) || `request-${index}` + const dedupKey = `copilot-chatsession:${sessionId}:${requestId}` + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + const model = modelFromChatSessionRequest(rawReq, metadata) + const costUSD = calculateCost(model, inputTokens, outputTokens, 0, 0, 0) + const timestamp = timestampToISO(rawReq['timestamp']) || sessionCreatedAt + + yield { + provider: 'copilot', + sessionId, + project: source.project, + model, + inputTokens, + outputTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + tools: extractChatSessionTools(metadata), + bashCommands: [], + timestamp, + speed: 'standard' as const, + deduplicationKey: dedupKey, + userMessage: '', + } + } + }, + } +} + +// --------------------------------------------------------------------------- +// JetBrains parser (Nitrite .db from ~/.config/github-copilot) +// --------------------------------------------------------------------------- +// +// The JetBrains Copilot plugin stores each chat/agent session in a Nitrite +// (H2 MVStore) .db of Java-serialized documents. There is NO token accounting +// anywhere in the store, so we estimate output tokens from the assistant reply +// text (the same char-count approach CodeBurn already uses for Cursor and +// legacy Copilot JSONL). Cost is therefore marked costIsEstimated. +// +// The model (e.g. "claude-opus-4.5", "gpt-4.1") is not always tagged on each +// turn, so we recover it by scanning the raw buffer for a known model token. + +// Known JetBrains Copilot model tokens, longest-first so we match the most +// specific name (e.g. "gpt-4.1-mini" before "gpt-4.1"). +const JETBRAINS_MODEL_TOKENS = [ + 'claude-opus-4.5', + 'claude-opus-4.1', + 'claude-opus-4', + 'claude-sonnet-4.5', + 'claude-sonnet-4', + 'gpt-5.3-codex', + 'gpt-5.3', + 'gpt-5.2', + 'gpt-5.1', + 'gpt-5-mini', + 'gpt-5', + 'gpt-4.1-mini', + 'gpt-4.1-nano', + 'gpt-4.1', + 'gpt-4o-mini', + 'gpt-4o', + 'gemini-2.5-pro', + 'gemini-2.0-flash', + 'o3-mini', + 'o4-mini', + 'o3', +] + +/** + * Normalise a raw JetBrains model token to CodeBurn's canonical model id. + * Claude names use dots on disk (claude-opus-4.5) but dashes in the pricing + * tables (claude-opus-4-5); GPT/Gemini names are kept verbatim. + */ +function normalizeJetBrainsModelName(raw: string): string { + const t = raw.trim() + if (!t) return '' + if (t.startsWith('claude-')) return t.replace(/\./g, '-') + return t +} + +/** Match a known model token at an alnum boundary anywhere in a string. */ +function findJetBrainsModelToken(s: string): string { + for (const token of JETBRAINS_MODEL_TOKENS) { + const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + // "o3" etc. must not match inside words like "iso3166". + if (new RegExp(`(?() + let m: RegExpExecArray | null + while ((m = re.exec(raw))) { + // Decode %20 etc. and strip a trailing .rej/.orig suffix noise; keep the dir. + let p = m[1] + try { p = decodeURIComponent(p) } catch { /* leave as-is */ } + const dir = p.slice(0, p.lastIndexOf('/')) + if (dir.startsWith('/')) seen.add(dir) + } + if (seen.size === 0) return undefined + + for (const dir of seen) { + const repo = findGitRepoRoot(dir) + if (repo) return repo + } + return undefined +} + +/** Walk up from `dir` to the nearest ancestor containing `.git`; return its basename. */ +function findGitRepoRoot(dir: string): string | undefined { + let cur = dir + // Bound the walk to avoid pathological loops; repos are never this deep. + for (let i = 0; i < 40 && cur && cur !== '/'; i++) { + if (existsSync(join(cur, '.git'))) { + const name = basename(cur) + return name || undefined + } + const parent = dirname(cur) + if (parent === cur) break + cur = parent + } + return undefined +} + +/** + * Recover the plugin-recorded project label from a Nitrite .db. + * + * JetBrains Copilot 1.12+ serialises a `projectName` field on the session doc + * (e.g. `my-service`, `codeburn`). It is the plugin's OWN authoritative + * label — the JetBrains analogue of the OTel source's + * `github.copilot.git.repository` — so it is preferred over the file-path + * git-walk heuristic when present. + * + * The field is a Java-serialized string: the key bytes `projectName` are + * followed immediately by TC_STRING framing `0x74 + * `. We read exactly `length` bytes (so an embedded newline or + * quote can't truncate it) and accept the first occurrence whose value is a + * plausible short, printable repo name. Older plugins that don't write the + * field simply yield undefined (callers fall back to the git-walk). + * + * Note: the field lives on the session doc, which the plugin writes into the + * `chat-sessions` / `chat-edit-sessions` stores — often NOT the + * `chat-agent-sessions` store where the billable turns live. Discovery joins + * the two by store id; see resolveJetBrainsProjectNames. + */ +function extractJetBrainsProjectName(raw: string): string | undefined { + const re = /projectName\x74([\x00-\xff])([\x00-\xff])/g + let m: RegExpExecArray | null + while ((m = re.exec(raw))) { + const len = (m[1]!.charCodeAt(0) << 8) | m[2]!.charCodeAt(0) + // Repo names are short; a huge length means we matched a schema/key + // occurrence rather than a value-bearing one — skip it. + if (len < 1 || len > 128) continue + const start = m.index + m[0].length + // The .db is read as latin1, so re-interpret the length-delimited bytes as + // UTF-8 (repo names can contain non-ASCII). Reject only if the decoded value + // holds control chars — a sign we matched a non-value occurrence, not a name. + const val = Buffer.from(raw.slice(start, start + len), 'latin1').toString('utf8') + // eslint-disable-next-line no-control-regex + if (val.length > 0 && !/[\x00-\x1f]/.test(val)) return val + } + return undefined +} + +// --------------------------------------------------------------------------- +// Nitrite .db (H2 MVStore) extraction +// --------------------------------------------------------------------------- +// +// JetBrains Copilot sessions store their conversation in the Nitrite .db +// (copilot-*-nitrite.db). One .db holds many conversations. Assistant replies +// are stored as a distinct blob shape: +// +// {"__first__":{"type":"Subgraph","value":"..."}, ...} +// +// which is more deeply escaped than the user-message value-maps. The reply text +// is recovered by progressive unescaping and collecting "text":"..." fields. +// Failed turns ("Sorry, an error occurred …") carry an error status and no reply +// text — they are detected and billed as $0. + +// One assistant turn recovered from a .db. +type JBDbTurn = { + replyText: string + model: string + errored: boolean + // The owning conversation (chat tab): its internal GUID and title. One .db + // holds many conversations; turns are grouped back to their tab by this id. + conversationId: string + conversationTitle: string + // The file path this conversation referenced (home-relative common dir), or + // '' if the chat touched no files. Used as the project label. + conversationProject: string +} + +// A conversation (chat tab) recovered from a .db: internal GUID → title. +type JBConversation = { id: string; title: string } + +/** + * Recover the conversation (chat-tab) records from a raw .db buffer. Each is + * stored as `$ … name … value … source copilot`. Returns the + * GUID→title map so turns can be grouped back to the tab the user sees. + */ +function extractJetBrainsConversations(raw: string): JBConversation[] { + // A conversation's title EVOLVES as the user chats: it starts as "New Agent + // Session", may pass through an auto-generated name, and ends at the final + // title shown in the UI. The same `$<GUID> … name … value <title> … source` + // record is rewritten each time, so we collect every occurrence per GUID and + // keep the LAST meaningful (non-default) one. + const DEFAULT_TITLES = new Set(['New Agent Session', 'New Session', 'New Chat']) + const byId = new Map<string, string>() + const re = /\$([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})[\s\S]{0,8}name/g + let m: RegExpExecArray | null + while ((m = re.exec(raw))) { + const id = m[1] + const window = raw.slice(m.index, m.index + 400) + // The title is the Java-UTF string between the `value` marker and `source`. + const tm = window.match(/value.{1,6}?([\x20-\x7e]{3,80}?)t\x00\x06source/) + if (!tm) continue + const title = Buffer.from(tm[1].replace(/^[^A-Za-z0-9]*/, ''), 'latin1').toString('utf8').trim() + if (!title) continue + // Keep the latest non-default title; only fall back to a default if no + // meaningful title has been seen for this conversation yet. + const existing = byId.get(id) + if (existing && !DEFAULT_TITLES.has(existing) && DEFAULT_TITLES.has(title)) continue + byId.set(id, title) + } + return [...byId.entries()].map(([id, title]) => ({ id, title })) +} + +/** Brace-match a JSON object starting at `start`, tolerating escaped quotes. */ +function matchJsonObject(raw: string, start: number): { chunk: string; end: number } { + let depth = 0 + let inStr = false + let esc = false + let i = start + for (; i < raw.length; i++) { + const c = raw[i] + if (esc) { esc = false; continue } + if (c === '\\') { esc = true; continue } + if (c === '"') { inStr = !inStr; continue } + if (inStr) continue + if (c === '{') depth++ + else if (c === '}') { depth--; if (depth === 0) { i++; break } } + } + return { chunk: raw.slice(start, i), end: i } +} + +/** + * Recover the assistant reply text from a `__first__`/Subgraph response blob. + * + * JetBrains Copilot has two turn shapes, both handled here: + * + * - **Ask mode:** the reply is a `Markdown` record whose `data` is an escaped + * JSON document `{"text":"…","annotations":…}`. + * - **Agent mode** (e.g. PyCharm agent sessions): the reply is the `reply` + * field of an `AgentRound` record `{"roundId":N,"reply":"…","toolCalls":[…]}`. + * In agent mode the `Markdown` records hold the USER's prompts, not the + * reply, so we must NOT read them — the assistant output is the AgentRound + * reply. + * + * Both are read STRUCTURALLY rather than by fully unescaping the blob (which + * would strip the reply's own quotes and make regex extraction ambiguous): we + * locate each `data`/`reply` value, read it as a properly-delimited JSON-string + * literal (honouring escaping), unescape one level, and `JSON.parse` to reach + * the text. We unescape the blob one level at a time and extract at the first + * depth that yields text, never accumulating across depths (which would union a + * quote-truncated half-unescaped capture with the full one and garble the + * reply, inflating the token/cost estimate). + * + * Steps/error/progress-only blobs (no Markdown text and no AgentRound reply) + * yield '' and are billed as $0 upstream. + */ +function extractResponseText(blob: string): string { + let s = blob + for (let depth = 0; depth < 8; depth++) { + // Decide the mode by the PRESENCE of an AgentRound record, not by whether it + // yielded a reply. In agent mode the Markdown record holds the USER prompt, + // so an agent blob whose reply is empty (a failed turn, or a pure tool-call + // round) must NOT fall back to Markdown — that would bill the user's prompt + // as the assistant's output. Ask-mode blobs have no AgentRound record and + // use Markdown. (Verified across every observed store: the two reply shapes + // never coexist in one blob, so this mode split is unambiguous.) + const isAgentMode = /"type":"AgentRound"/.test(s) + if (isAgentMode || /"type":"Markdown"/.test(s)) { + const decoded = isAgentMode ? extractAgentRoundReplies(s) : extractMarkdownTexts(s) + // The .db is read as latin1 (byte-stable), so multibyte UTF-8 characters + // are split into separate code units. Re-interpret as UTF-8 so the char + // count (→ token estimate) reflects real content length, not byte count. + // decoded may be empty (failed/tool-only agent turn) → '' (billed $0). + return Buffer.from(decoded.join('\n').trim(), 'latin1').toString('utf8') + } + // Not yet at the depth where record markers appear bare — unescape one level + // in a single left-to-right pass so `\\` and `\"` resolve together (a + // two-pass replace would turn `\\"` into `\"` not `\\` + `"`). + const next = s.replace(/\\([\\"])/g, '$1') + if (next === s) break + s = next + } + return '' +} + +/** + * Collect the `text` of every `Markdown` record in `s`, treating each record's + * `data` value as a one-level-escaped JSON string parsed structurally (so the + * reply's own quotes never truncate it). Returns [] if `s` is not yet at the + * right unescape depth (no bare `"type":"Markdown"` with a parseable `data`). + * Scoping to Markdown skips `Error` (`message`) and `Steps` records — not + * billable output. Revisions repeat a reply, so identical texts are de-duped. + */ +function extractMarkdownTexts(s: string): string[] { + return extractRecordStrings(s, '"type":"Markdown"', '"data":"', 'text') +} + +/** + * Collect the non-empty `reply` of every `AgentRound` record (agent mode). A + * single blob can hold several rounds (a multi-turn agent session); each round's + * `reply` is the assistant's text for that step (empty on pure tool-call rounds). + * Deduped in order. + */ +function extractAgentRoundReplies(s: string): string[] { + return extractRecordStrings(s, '"type":"AgentRound"', '"data":"', 'reply') +} + +/** + * Shared structural reader: for every `<marker>` in `s`, find the following + * `<dataKey>` string literal (a one-level-escaped JSON document), parse it, and + * collect `doc[field]` when it is a non-empty string. Reading the value as a + * delimited literal — not a greedy regex — means the payload's own quotes never + * truncate it. Returns [] when `s` is not yet at the depth where the marker + * appears bare with a parseable payload. De-dupes in order (the store keeps + * byte-copies/revisions of each reply). + */ +function extractRecordStrings(s: string, marker: string, dataKey: string, field: string): string[] { + const texts: string[] = [] + const seen = new Set<string>() + const re = new RegExp(marker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g') + let m: RegExpExecArray | null + while ((m = re.exec(s))) { + const dk = s.indexOf(dataKey, m.index) + if (dk === -1 || dk - m.index > 200) continue + // The value runs from after `<dataKey>` to the first UNescaped quote (an odd + // run of preceding backslashes escapes it). + const start = dk + dataKey.length + let i = start + for (; i < s.length; i++) { + if (s[i] !== '"') continue + let bs = 0 + for (let j = i - 1; j >= start && s[j] === '\\'; j--) bs++ + if (bs % 2 === 0) break + } + const literal = s.slice(start, i) + try { + // Wrapping in quotes + parsing unescapes exactly one level → the inner + // JSON document as a string; parsing THAT reaches { <field>, … }. + const doc = JSON.parse(JSON.parse('"' + literal + '"') as string) as Record<string, unknown> + const text = typeof doc[field] === 'string' ? (doc[field] as string) : '' + if (text && !seen.has(text)) { + seen.add(text) + texts.push(text) + } + } catch { + // Not the right depth (or not a matching record) — skip. + } + } + return texts +} + +/** + * Extract assistant turns from a raw (latin1) Nitrite .db buffer. Each turn is + * one `{"__first__":{"type":"Subgraph"…}` blob; the per-turn model is recovered + * from inside the blob when present, else the whole-store default. Each turn is + * grouped back to its owning conversation (chat tab) by the nearest preceding + * conversation GUID. Duplicate byte-copies of the same reply (the store keeps + * several) are de-duplicated by content, per conversation. + */ +function extractJetBrainsDbTurns(raw: string): JBDbTurn[] { + const conversations = extractJetBrainsConversations(raw) + // Precompute the byte offset of each conversation GUID's full form so a turn + // can be attributed to the conversation whose id most recently precedes it. + const convById = new Map(conversations.map((c) => [c.id, c])) + + const turns: JBDbTurn[] = [] + const seenReplies = new Set<string>() // keyed by `${conversationId}::${reply}` + const re = /\{"__first__":\{"type":"Subgraph"/g + let m: RegExpExecArray | null + while ((m = re.exec(raw))) { + const { chunk, end } = matchJsonObject(raw, m.index) + re.lastIndex = end + + // Attribute this turn to the conversation whose GUID last appears before it. + let conversationId = '' + let conversationTitle = '' + let bestPos = -1 + for (const c of convById.values()) { + const p = raw.lastIndexOf(c.id, m.index) + if (p > bestPos) { + bestPos = p + conversationId = c.id + conversationTitle = c.title + } + } + + const replyText = extractResponseText(chunk) + // The files this turn referenced (home-relative common dir) → project label. + const conversationProject = inferJetBrainsProject(chunk) ?? '' + // A per-turn model token sometimes appears inside the blob. + const model = findJetBrainsModelToken(chunk) + // A failed turn carries an error status / phrase AND produces no reply text. + // Requiring empty text avoids misclassifying a genuine reply that merely + // *discusses* an error (e.g. explaining a stack trace) as a failed turn. + const hasErrorMarker = /error occurred|"isError":true|\\+"status\\+":\\+"(?:error|failed)\\+"/i.test(chunk) + if (hasErrorMarker && !replyText) { + turns.push({ replyText: '', model, errored: true, conversationId, conversationTitle, conversationProject }) + continue + } + if (!replyText) continue // Steps/progress-only blob — no billable output + const dedupeKey = `${conversationId}::${replyText}` + if (seenReplies.has(dedupeKey)) continue + seenReplies.add(dedupeKey) + turns.push({ replyText, model, errored: false, conversationId, conversationTitle, conversationProject }) + } + + // --------------------------------------------------------------------------- + // Fallback: old JetBrains Copilot plugin format (≤1.5.x, e.g. 1.5.59-243) + // --------------------------------------------------------------------------- + // In this format ALL session turns are stored inside ONE large outer Nitrite + // document — a binary-framed JSON object with UUID-keyed Value entries — rather + // than the per-turn {"__first__":{"type":"Subgraph",...}} blobs used by newer + // plugins (≥1.12.x). The AgentRound entries sit one escaping level deeper + // inside the outer document's string values, so `extractResponseText`'s + // depth-unescape loop handles extraction correctly once we feed it the right + // chunk. MVStore keeps two identical copies of the collection; `seenReplies` + // deduplicates them automatically. + // + // Detection heuristic: the __first__/Subgraph path produced no turns AND the + // raw file contains bare 'AgentRound' text (meaning old-format data is present). + if (turns.length === 0 && raw.includes('AgentRound')) { + // The outer Nitrite document is preceded by a single binary framing byte + // (0x81 in practice, but any non-printable/non-ASCII byte in MVStore). + // It starts with a UUID-keyed Value entry: {"<uuid>":{"type":"Value",...}}. + // Hex is matched case-insensitively — an uppercase UUID must not cause the + // whole session to fall through to $0 (the exact bug this path fixes). + const outerDocRe = /[\x00-\x1f\x7f-\xff]\{"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}":\{"type":"Value"/g + let dm: RegExpExecArray | null + while ((dm = outerDocRe.exec(raw))) { + // Skip the leading binary byte; matchJsonObject starts at the '{'. + const docStart = dm.index + 1 + const { chunk, end } = matchJsonObject(raw, docStart) + outerDocRe.lastIndex = end + + // Skip documents that contain no AgentRound data (e.g. empty sessions). + if (!chunk.includes('AgentRound')) continue + + // Attribute to the conversation whose GUID most recently precedes this doc. + let conversationId = '' + let conversationTitle = '' + let bestPos = -1 + for (const c of convById.values()) { + const p = raw.lastIndexOf(c.id, docStart) + if (p > bestPos) { + bestPos = p + conversationId = c.id + conversationTitle = c.title + } + } + + // extractResponseText handles the depth-1 unescape needed to surface the + // AgentRound records, then calls extractAgentRoundReplies for each turn. + // Because the outer document holds ALL turns in one blob we get back a + // single joined string; split it on the '\n' join to yield per-turn texts. + const allReplies = extractResponseText(chunk) + if (!allReplies) continue + + const conversationProject = inferJetBrainsProject(chunk) ?? '' + const storeModel = findJetBrainsModelToken(chunk) + + // extractResponseText joins multiple replies with '\n'. Since individual + // replies can themselves span multiple lines we cannot cleanly split here — + // instead we emit one ParsedProviderCall per outer document (one session). + const dedupeKey = `${conversationId}::${allReplies}` + if (seenReplies.has(dedupeKey)) continue + seenReplies.add(dedupeKey) + + turns.push({ + replyText: allReplies, + model: storeModel, + errored: false, + conversationId, + conversationTitle, + conversationProject, + }) + } + } + + // A project derived from ANY turn of a conversation applies to all its turns + // (the files are usually referenced in the first substantive turn only). + const projByConv = new Map<string, string>() + for (const t of turns) { + if (t.conversationProject && !projByConv.has(t.conversationId)) { + projByConv.set(t.conversationId, t.conversationProject) + } + } + for (const t of turns) { + if (!t.conversationProject) t.conversationProject = projByConv.get(t.conversationId) ?? '' + } + + return turns +} + +// --------------------------------------------------------------------------- +// JetBrains parser: one ParsedProviderCall per assistant turn in the .db +// --------------------------------------------------------------------------- + +function createJetBrainsParser( + source: JetBrainsSessionSource, + seenKeys: Set<string> +): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + const sessionId = source.sessionId + + // Nitrite .db (the store's authoritative session content). Read as latin1 + // so byte offsets are stable through the binary MVStore framing. + if (source.dbPath) { + let dbRaw: string | null = null + try { + dbRaw = await readSessionFile(source.dbPath, 'latin1') + } catch { + dbRaw = null + } + if (dbRaw) { + const storeModel = inferJetBrainsModel(dbRaw) + const turns = extractJetBrainsDbTurns(dbRaw) + // Dedup keys derive from the reply CONTENT, not the scan position: + // copilot is a durable provider (cached turns are never deleted and a + // re-parse appends any key it hasn't seen), while MVStore compaction + // can rewrite the file with blobs in a different byte order. With + // positional keys, a rewrite that puts a new blob ahead of an old one + // hands the new turn the old turn's key (skipped as seen) and re-emits + // the old turn under a fresh index — double-billing it. The per-hash + // counter keeps genuinely repeated replies and errored turns (which + // share replyText '') distinct within a conversation. + const perContentIndex = new Map<string, number>() + for (const turn of turns) { + // One .db holds many chat tabs; group each turn under its own + // conversation so the user sees one session per tab, not per file. + const convId = turn.conversationId || sessionId + const contentHash = createHash('sha256').update(turn.replyText).digest('hex').slice(0, 12) + const nth = (perContentIndex.get(`${convId}:${contentHash}`) ?? 0) + 1 + perContentIndex.set(`${convId}:${contentHash}`, nth) + const dedupKey = `copilot:jb:${convId}:${contentHash}:${nth}` + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + // Prefer the per-turn model, else the store default, else a generic + // Copilot bucket so a real reply is never mis-priced as free. + const model = turn.model || storeModel || 'copilot-anthropic-auto' + // Errored turns (failed generation) contribute no billable output. + const outputTokens = turn.errored ? 0 : estimateTokens(turn.replyText) + const costUSD = outputTokens > 0 ? calculateCost(model, 0, outputTokens, 0, 0, 0) : 0 + // Project resolution precedence: + // 1. projectName — the plugin's own recorded label (1.12+), + // joined across kind dirs by store id. Authoritative. + // 2. the git repo root of a file:// path the chat referenced + // (older plugins / when projectName is absent). + // 3. one honest bucket when neither signal exists. + // The conversation TITLE is a chat-thread name, NOT a project, and is + // kept out of `project` (it would otherwise pollute By-Project). + const project = + source.projectName || turn.conversationProject || 'copilot-jetbrains' + + yield { + provider: 'copilot', + sessionId: convId, + project, + model, + inputTokens: 0, + outputTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + costIsEstimated: true, + tools: [], + bashCommands: [], + timestamp: source.mtime, + speed: 'standard' as const, + deduplicationKey: dedupKey, + // Surface the chat-thread name here (it is the session's label, not + // a project) so it remains visible in session-level views. + userMessage: turn.conversationTitle, + } + } + } + } + + }, + } +} + +// --------------------------------------------------------------------------- +// OTel SQLite parser — reads agent-traces.db for FULL token data +// --------------------------------------------------------------------------- + +function createOtelParser( + source: SessionSource, + seenKeys: Set<string> +): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + // Lazy-load the SQLite module (same pattern as Cursor/OpenCode providers) + const { openDatabase } = await import('../sqlite.js') + + // One DB open handles ALL conversations — avoids N opens for N conversations. + const db = openDatabase(source.path) + + try { + // --------------------------------------------------------------- + // Get all distinct conversations in the DB with their project names. + // --------------------------------------------------------------- + const conversationRows = db.query<{ + conversation_id: string + project: string | null + min_start: number + }>( + `SELECT DISTINCT + sa_conv.value AS conversation_id, + COALESCE(sa_repo.value, 'copilot-chat') AS project, + MIN(s.start_time_ms) AS min_start + FROM spans s + LEFT JOIN span_attributes sa_conv + ON s.span_id = sa_conv.span_id AND sa_conv.key = 'gen_ai.conversation.id' + LEFT JOIN span_attributes sa_repo + ON s.span_id = sa_repo.span_id AND sa_repo.key = 'github.copilot.git.repository' + WHERE sa_conv.value IS NOT NULL + GROUP BY sa_conv.value + ORDER BY min_start DESC` + ) + + for (const convRow of conversationRows) { + const conversationId = convRow.conversation_id + if (!conversationId) continue + + let project = convRow.project ?? 'copilot-chat' + if (project.includes('/')) { + project = basename(project.replace(/\.git$/, '')) + } + + // ----------------------------------------------------------- + // Query all 'chat' spans for this conversation. + // ----------------------------------------------------------- + + const spanIdRows = db.query<{ span_id: string; trace_id: string }>( + `SELECT DISTINCT s.span_id, s.trace_id + FROM spans s + INNER JOIN span_attributes sa + ON s.span_id = sa.span_id AND sa.key = 'gen_ai.conversation.id' AND sa.value = ? + ORDER BY s.start_time_ms ASC`, + [conversationId] + ) + + // Collect trace IDs and span IDs belonging to this conversation + const traceIds = new Set<string>() + for (const row of spanIdRows) { + traceIds.add(row.trace_id) + } + + if (traceIds.size === 0) { + continue + } + + // Now query all spans within those traces to find chat and tool spans. + // Pull the metadata columns in the same query so we don't re-query the + // spans table once per chat span below (avoids an N+1). + const traceIdArr = [...traceIds] + const tracePlaceholders = traceIdArr.map(() => '?').join(',') + const traceSpans = db.query<{ + span_id: string + trace_id: string + operation_name: string | null + start_time_ms: number + response_model: string | null + }>( + `SELECT span_id, trace_id, operation_name, start_time_ms, response_model FROM spans WHERE trace_id IN (${tracePlaceholders})`, + traceIdArr + ) + + // Collect tool names, shell commands and subagent names from the + // execute_tool / invoke_agent spans for each trace. These mirror the + // metadata the JSONL path captures, so the OTel source stays + // equivalent (tools + bashCommands + subagentTypes are all first-class + // call metadata per types.ts). + // + // Subagent attribution: VS Code records a subagent run as an + // invoke_agent span carrying copilot_chat.parent_chat_session_id. The + // root turn agent (gen_ai.agent.name = 'GitHub Copilot Chat') has NO + // parent session and is intentionally excluded, otherwise it would + // surface as a bogus 'GitHub Copilot Chat' entry in the agents view. + // A subagent's invoke_agent span lives in the same trace as that + // subagent's own chat spans, so attributing the agent name per-trace + // labels exactly the subagent's calls. + const toolsByTrace = new Map<string, string[]>() + const bashByTrace = new Map<string, string[]>() + const subagentsByTrace = new Map<string, string[]>() + const chatSpanIds: string[] = [] + const spanMetaById = new Map<string, { trace_id: string; start_time_ms: number; response_model: string | null }>() + + for (const span of traceSpans) { + const opName = span.operation_name || '' + spanMetaById.set(span.span_id, span) + + if (opName === 'chat') { + chatSpanIds.push(span.span_id) + continue + } + + if (opName === 'execute_tool') { + // Load tool name from attributes and normalise to display form + const attrs = loadSpanAttributesFromTable(db, span.span_id) + const rawToolName = attrs['gen_ai.tool.name'] as string | undefined + if (rawToolName) { + const existing = toolsByTrace.get(span.trace_id) ?? [] + existing.push(normalizeTool(rawToolName)) + toolsByTrace.set(span.trace_id, existing) + + // For shell tools, extract command names via the OTEL-specific + // normaliser (handles the full multi-line scripts the OTEL store + // records; see extractOtelBashCommands). + if (BASH_TOOL_NAMES.has(rawToolName)) { + const command = parseToolCommand(attrs['gen_ai.tool.call.arguments']) + if (command) { + const bash = bashByTrace.get(span.trace_id) ?? [] + bash.push(...extractOtelBashCommands(command)) + bashByTrace.set(span.trace_id, bash) + } + } + } + continue + } + + // Genuine subagent invocation: an invoke_agent span with a parent + // chat session. The root turn agent ('GitHub Copilot Chat') has no + // parent session and is skipped to avoid a bogus agents-view entry. + if (opName === 'invoke_agent') { + const attrs = loadSpanAttributesFromTable(db, span.span_id) + const parentSession = attrs['copilot_chat.parent_chat_session_id'] + const agentName = attrs['gen_ai.agent.name'] as string | undefined + if (parentSession && agentName) { + const subs = subagentsByTrace.get(span.trace_id) ?? [] + subs.push(agentName) + subagentsByTrace.set(span.trace_id, subs) + } + } + } + + // Yield one ParsedProviderCall per chat span + for (const spanId of chatSpanIds) { + const attrs = loadSpanAttributesFromTable(db, spanId) + + const spanMetadata = spanMetaById.get(spanId) + if (!spanMetadata) continue + + const model = + (attrs['gen_ai.response.model'] as string | undefined) ?? + (attrs['gen_ai.request.model'] as string | undefined) ?? + spanMetadata.response_model ?? + 'unknown' + + const inputTokens = Number(attrs['gen_ai.usage.input_tokens'] ?? 0) + const outputTokens = Number(attrs['gen_ai.usage.output_tokens'] ?? 0) + const cacheReadTokens = Number(attrs['gen_ai.usage.cache_read.input_tokens'] ?? 0) + const cacheCreationTokens = Number(attrs['gen_ai.usage.cache_creation.input_tokens'] ?? 0) + + if (inputTokens === 0 && outputTokens === 0) { + continue + } + + // Dedup key uses span_id which is globally unique + const dedupKey = `copilot-otel:${spanId}` + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + // Also add a JSONL-style dedupKey pattern so that if the same + // interaction appears in both OTel and JSONL, we don't double-count. + // We use the turn ID from Copilot attributes if available. + const turnId = attrs['github.copilot.chat.turn.id'] as string | undefined + if (turnId) { + const jsonlDedupKey = `copilot:${conversationId}:${turnId}` + seenKeys.add(jsonlDedupKey) + } + + const tools = toolsByTrace.get(spanMetadata.trace_id) ?? [] + const bashCommands = bashByTrace.get(spanMetadata.trace_id) ?? [] + const subagentTypes = subagentsByTrace.get(spanMetadata.trace_id) + const timestamp = epochToISO(spanMetadata.start_time_ms) + + // calculateCost with FULL token data — this is the key improvement. + const costUSD = calculateCost( + model, + inputTokens, + outputTokens, + cacheCreationTokens, + cacheReadTokens, + 0 // reasoningTokens — not exposed in current OTel schema + ) + + yield { + provider: 'copilot', + sessionId: conversationId, + project, + model, + inputTokens, + outputTokens, + cacheCreationInputTokens: cacheCreationTokens, + cacheReadInputTokens: cacheReadTokens, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + tools, + bashCommands, + subagentTypes: subagentTypes && subagentTypes.length > 0 ? subagentTypes : undefined, + timestamp, + speed: 'standard' as const, + deduplicationKey: dedupKey, + userMessage: '', // Not available in OTel spans by default + } + } + } + } finally { + db.close() + } + }, + } +} + +// --------------------------------------------------------------------------- +// Extended SessionSource for OTel sessions +// --------------------------------------------------------------------------- + +interface OTelSessionSource extends SessionSource { + conversationId?: string + sourceType: 'otel' +} + +interface JsonlSessionSource extends SessionSource { + sourceType: 'jsonl' +} + +interface ChatSessionSource extends SessionSource { + sourceType: 'chatsession' +} + +interface JetBrainsSessionSource extends SessionSource { + sourceType: 'jetbrains' + // Fallback conversation id for turns whose own GUID can't be recovered (the + // on-disk store dir name). Normally each turn is grouped by its own tab GUID. + sessionId: string + // On-disk store directory name — the join key for the projectName lookup + // across sibling kind dirs (chat-sessions / chat-edit-sessions). + storeId: string + // Nitrite .db (copilot-*-nitrite.db) — the store's session content. + dbPath: string + // File mtime (ISO). The store has no reliable per-turn timestamp, so this + // places every turn on a day — without it, calls fall outside date ranges. + mtime: string + // Plugin-recorded project label (JetBrains Copilot 1.12+), resolved across + // all kind dirs by store id. The billable turns live in chat-agent-sessions, + // but the projectName field is usually written only into the sibling + // chat-sessions / chat-edit-sessions store, so discovery joins them by id. + // Undefined for older plugins that don't record it. + projectName?: string +} + +function isOtelSource(source: SessionSource): source is OTelSessionSource { + return (source as OTelSessionSource).sourceType === 'otel' +} + +function isChatSessionSource(source: SessionSource): source is ChatSessionSource { + return (source as ChatSessionSource).sourceType === 'chatsession' +} + +function isJetBrainsSource(source: SessionSource): source is JetBrainsSessionSource { + return (source as JetBrainsSessionSource).sourceType === 'jetbrains' +} + +// --------------------------------------------------------------------------- +// Session discovery: JSONL (original) +// --------------------------------------------------------------------------- + +async function discoverJsonlSessions( + sessionStateDir: string +): Promise<JsonlSessionSource[]> { + const sources: JsonlSessionSource[] = [] + + let sessionDirs: string[] + try { + sessionDirs = await readdir(sessionStateDir) + } catch { + return sources + } + + for (const sessionId of sessionDirs) { + const eventsPath = join(sessionStateDir, sessionId, 'events.jsonl') + const s = await stat(eventsPath).catch(() => null) + if (!s?.isFile()) continue + + let project = sessionId + try { + const yaml = await readSessionFile( + join(sessionStateDir, sessionId, 'workspace.yaml') + ) + const cwd = parseCwd(yaml ?? '') + if (cwd) project = basename(cwd) + } catch { + // workspace.yaml may not exist + } + + sources.push({ + path: eventsPath, + project, + provider: 'copilot', + sourceType: 'jsonl', + }) + } + + return sources +} + +// --------------------------------------------------------------------------- +// Session discovery: OTel SQLite +// --------------------------------------------------------------------------- + +async function discoverOtelSessions( + dbPath: string +): Promise<OTelSessionSource[]> { + // Verify the DB file exists. Return one source per DB file; the parser + // opens the DB once and iterates all conversations in a single DB open, + // which is far more efficient than one source (and one DB open) per conversation. + try { + await stat(dbPath) + } catch { + return [] + } + return [{ path: dbPath, project: 'copilot-chat', provider: 'copilot', sourceType: 'otel' }] +} + +// --------------------------------------------------------------------------- +// Session discovery: JetBrains (IntelliJ IDEA, PyCharm, …) +// --------------------------------------------------------------------------- + +// The three JetBrains Copilot session kinds (agent / ask / edit mode). Each +// store directory holds a Nitrite .db with that kind's session content. +const JETBRAINS_SESSION_KINDS = ['chat-agent-sessions', 'chat-sessions', 'chat-edit-sessions'] + +// Candidate Nitrite .db filenames per kind, plus a generic fallback. +const JETBRAINS_DB_NAMES: Record<string, string> = { + 'chat-agent-sessions': 'copilot-agent-sessions-nitrite.db', + 'chat-sessions': 'copilot-chat-nitrite.db', + 'chat-edit-sessions': 'copilot-edit-sessions-nitrite.db', +} + +/** Locate the Nitrite .db in a store dir (known name, else any *-nitrite.db). */ +async function findNitriteDbPath(storeDir: string, kind: string): Promise<string | null> { + const known = JETBRAINS_DB_NAMES[kind] + if (known) { + const p = join(storeDir, known) + if ((await stat(p).catch(() => null))?.isFile()) return p + } + let files: string[] + try { + files = await readdir(storeDir) + } catch { + return null + } + const db = files.find((f) => f.endsWith('-nitrite.db')) + return db ? join(storeDir, db) : null +} + +/** + * Discover JetBrains Copilot sessions under the github-copilot config root. + * + * Layout: <root>/<ide>/<kind>/<storeId>/copilot-*-nitrite.db + * <ide> — per-IDE dir (iu, intellij, PyCharm2025.2, …) + * <kind> — one of JETBRAINS_SESSION_KINDS + * + * Emits one source per store directory that has a Nitrite .db. The store + * records no token counts, so the parser estimates output tokens from the + * assistant reply text (see createJetBrainsParser). + */ +async function discoverJetBrainsSessions( + root: string +): Promise<JetBrainsSessionSource[]> { + const sources: JetBrainsSessionSource[] = [] + + let ideDirs: string[] + try { + ideDirs = await readdir(root) + } catch { + return sources + } + + for (const ide of ideDirs) { + for (const kind of JETBRAINS_SESSION_KINDS) { + const kindDir = join(root, ide, kind) + let storeDirs: string[] + try { + storeDirs = await readdir(kindDir) + } catch { + continue // this IDE doesn't have this session kind + } + + for (const storeId of storeDirs) { + const storeDir = join(kindDir, storeId) + const dbPath = await findNitriteDbPath(storeDir, kind) + if (!dbPath) continue + + const dbStat = await stat(dbPath).catch(() => null) + const mtime = (dbStat?.mtime ?? new Date(0)).toISOString() + + sources.push({ + path: dbPath, + project: 'copilot-jetbrains', + provider: 'copilot', + sourceType: 'jetbrains', + sessionId: storeId, + storeId, + dbPath, + mtime, + }) + } + } + } + + // Join projectName across kinds by store id. The plugin records the label on + // the session doc, which usually lands in the chat-sessions/chat-edit-sessions + // store — NOT the chat-agent-sessions store where the billable turns live. + // Without this join, every current agent session falls to the generic bucket + // even though its repo name is sitting one store dir over. + await resolveJetBrainsProjectNames(sources) + + return sources +} + +/** + * Populate each source's `projectName` from whichever store dir (of the same + * store id) actually recorded it. Reads each source's .db once; a store whose + * own .db lacks the field inherits it from a sibling-kind store with the same + * id. Best-effort — read/parse failures leave projectName undefined. + */ +async function resolveJetBrainsProjectNames( + sources: JetBrainsSessionSource[] +): Promise<void> { + const byStore = new Map<string, string>() + for (const src of sources) { + // Already found this store's name via a sibling-kind source — skip the read. + if (!src.dbPath || byStore.has(src.storeId)) continue + let raw: string | null = null + try { + raw = await readSessionFile(src.dbPath, 'latin1') + } catch { + raw = null + } + if (!raw) continue + const name = extractJetBrainsProjectName(raw) + if (name) byStore.set(src.storeId, name) + } + for (const src of sources) { + const name = byStore.get(src.storeId) + if (name) src.projectName = name + } +} + +// --------------------------------------------------------------------------- +// Provider factory +// --------------------------------------------------------------------------- + +/** + * Returns the VS Code workspaceStorage directories for all VS Code variants + * (Code, Code Insiders, VSCodium) on the given platform. Used to discover + * transcript sessions written by the Copilot Chat extension. + * + * Accepts explicit `home` and `os` arguments so callers (and tests) can pass + * custom values without relying on process-level globals. + */ +export function getVSCodeWorkspaceStorageDirs(home: string, os: string): string[] { + const j = os === 'win32' ? win32.join : posix.join + if (os === 'darwin') { + return [ + j(home, 'Library', 'Application Support', 'Code', 'User', 'workspaceStorage'), + j(home, 'Library', 'Application Support', 'Code - Insiders', 'User', 'workspaceStorage'), + j(home, 'Library', 'Application Support', 'VSCodium', 'User', 'workspaceStorage'), + ] + } + if (os === 'linux') { + return [ + j(home, '.config', 'Code', 'User', 'workspaceStorage'), + j(home, '.config', 'Code - Insiders', 'User', 'workspaceStorage'), + j(home, '.config', 'VSCodium', 'User', 'workspaceStorage'), + ] + } + // win32 + return [ + j(home, 'AppData', 'Roaming', 'Code', 'User', 'workspaceStorage'), + j(home, 'AppData', 'Roaming', 'Code - Insiders', 'User', 'workspaceStorage'), + j(home, 'AppData', 'Roaming', 'VSCodium', 'User', 'workspaceStorage'), + ] +} + +export function getVSCodeGlobalStorageDirs(home: string, os: string): string[] { + const j = os === 'win32' ? win32.join : posix.join + if (os === 'darwin') { + return [ + j(home, 'Library', 'Application Support', 'Code', 'User', 'globalStorage'), + j(home, 'Library', 'Application Support', 'Code - Insiders', 'User', 'globalStorage'), + j(home, 'Library', 'Application Support', 'VSCodium', 'User', 'globalStorage'), + ] + } + if (os === 'linux') { + return [ + j(home, '.config', 'Code', 'User', 'globalStorage'), + j(home, '.config', 'Code - Insiders', 'User', 'globalStorage'), + j(home, '.config', 'VSCodium', 'User', 'globalStorage'), + ] + } + return [ + j(home, 'AppData', 'Roaming', 'Code', 'User', 'globalStorage'), + j(home, 'AppData', 'Roaming', 'Code - Insiders', 'User', 'globalStorage'), + j(home, 'AppData', 'Roaming', 'VSCodium', 'User', 'globalStorage'), + ] +} + +async function resolveWorkspaceProject(wsDir: string, hashDir: string): Promise<string> { + let project = hashDir + try { + const wsJson = await readSessionFile(join(wsDir, hashDir, 'workspace.json')) + if (wsJson) { + const data = JSON.parse(wsJson) as { folder?: string } + if (typeof data.folder === 'string') { + // folder is a URI like 'file:///home/user/myapp' or 'file:///C:/Users/...' + const folder = data.folder.replace(/^file:\/\//, '').replace(/\/+$/, '') + const name = basename(folder) + if (name) project = name + } + } + } catch { + // workspace.json may be absent or malformed + } + return project +} + +async function hasChatSessionFiles(chatSessionsDir: string): Promise<boolean> { + let files: string[] + try { + files = await readdir(chatSessionsDir) + } catch { + return false + } + + for (const file of files) { + if (!file.endsWith('.jsonl')) continue + const s = await stat(join(chatSessionsDir, file)).catch(() => null) + if (s?.isFile()) return true + } + return false +} + +// --------------------------------------------------------------------------- +// Session discovery: VS Code core chatSessions +// --------------------------------------------------------------------------- + +async function discoverWorkspaceChatSessions( + workspaceStorageDirs: string[] +): Promise<ChatSessionSource[]> { + const sources: ChatSessionSource[] = [] + + for (const wsDir of workspaceStorageDirs) { + let hashDirs: string[] + try { + hashDirs = await readdir(wsDir) + } catch { + continue + } + + for (const hashDir of hashDirs) { + const chatSessionsDir = join(wsDir, hashDir, 'chatSessions') + let files: string[] + try { + files = await readdir(chatSessionsDir) + } catch { + continue + } + + const project = await resolveWorkspaceProject(wsDir, hashDir) + for (const file of files) { + if (!file.endsWith('.jsonl')) continue + const path = join(chatSessionsDir, file) + const s = await stat(path).catch(() => null) + if (!s?.isFile()) continue + sources.push({ + path, + project, + provider: 'copilot', + sourceType: 'chatsession', + }) + } + } + } + + return sources +} + +async function discoverEmptyWindowChatSessions( + globalStorageDirs: string[] +): Promise<ChatSessionSource[]> { + const sources: ChatSessionSource[] = [] + + for (const globalDir of globalStorageDirs) { + const chatSessionsDir = join(globalDir, 'emptyWindowChatSessions') + let files: string[] + try { + files = await readdir(chatSessionsDir) + } catch { + continue + } + + for (const file of files) { + if (!file.endsWith('.jsonl')) continue + const path = join(chatSessionsDir, file) + const s = await stat(path).catch(() => null) + if (!s?.isFile()) continue + sources.push({ + path, + project: 'copilot-chat', + provider: 'copilot', + sourceType: 'chatsession', + }) + } + } + + return sources +} + +// --------------------------------------------------------------------------- +// Session discovery: VS Code workspace transcripts +// --------------------------------------------------------------------------- + +/** + * Discover Copilot Chat transcript sessions stored in VS Code workspaceStorage. + * Structure: {wsDir}/{hash}/GitHub.copilot-chat/transcripts/{session}.jsonl + * Project is read from {wsDir}/{hash}/workspace.json (folder URI). + */ +async function discoverTranscriptSessions( + workspaceStorageDirs: string[] +): Promise<JsonlSessionSource[]> { + const sources: JsonlSessionSource[] = [] + + for (const wsDir of workspaceStorageDirs) { + let hashDirs: string[] + try { + hashDirs = await readdir(wsDir) + } catch { + continue + } + + for (const hashDir of hashDirs) { + const chatSessionsDir = join(wsDir, hashDir, 'chatSessions') + if (await hasChatSessionFiles(chatSessionsDir)) continue + + const transcriptsDir = join(wsDir, hashDir, 'GitHub.copilot-chat', 'transcripts') + const project = await resolveWorkspaceProject(wsDir, hashDir) + + let transcriptFiles: string[] + try { + transcriptFiles = await readdir(transcriptsDir) + } catch { + continue + } + + for (const file of transcriptFiles) { + if (!file.endsWith('.jsonl')) continue + const s = await stat(join(transcriptsDir, file)).catch(() => null) + if (!s?.isFile()) continue + sources.push({ + path: join(transcriptsDir, file), + project, + provider: 'copilot', + sourceType: 'jsonl', + }) + } + } + } + + return sources +} + +export function createCopilotProvider( + sessionStateDir?: string, + workspaceStorageDir?: string, + globalStorageDir?: string, + jetbrainsDir?: string +): Provider { + // jsonlDir is resolved lazily inside discoverSessions so that env-var + // overrides set after module load (e.g. in tests) are respected. + + /** + * Returns the workspaceStorage directories to scan for transcript sessions. + * When workspaceStorageDir is explicitly provided (e.g. in tests), that single + * directory is used. The CODEBURN_COPILOT_WS_STORAGE_DIR env var provides a + * single-dir override (useful for tests). Otherwise all platform-default VS + * Code variant paths are returned. + */ + function getWsDirs(): string[] { + if (workspaceStorageDir !== undefined) return [workspaceStorageDir] + const envDir = process.env['CODEBURN_COPILOT_WS_STORAGE_DIR'] + if (envDir) return [envDir] + return getVSCodeWorkspaceStorageDirs(homedir(), platform()) + } + + function getGlobalDirs(): string[] { + if (globalStorageDir !== undefined) return [globalStorageDir] + const envDir = process.env['CODEBURN_COPILOT_GLOBAL_STORAGE_DIR'] + if (envDir) return [envDir] + return getVSCodeGlobalStorageDirs(homedir(), platform()) + } + + return { + name: 'copilot', + displayName: 'Copilot', + durableSources: true, + + modelDisplayName(model: string): string { + for (const [key, display] of modelDisplayEntries) { + if (model.includes(key)) return display + } + return model + }, + + toolDisplayName(rawTool: string): string { + return normalizeTool(rawTool) + }, + + async discoverSessions(): Promise<SessionSource[]> { + const sources: SessionSource[] = [] + let discoveredOtel = false + + // 1. Discover OTel sessions (preferred — full token data) + const disableOtel = process.env['CODEBURN_COPILOT_DISABLE_OTEL'] === '1' + if (!disableOtel) { + const dbPath = getAgentTracesDbPath() + if (dbPath) { + try { + const otelSources = await discoverOtelSessions(dbPath) + discoveredOtel = otelSources.length > 0 + sources.push(...otelSources) + } catch { + // OTel discovery failed — fall through to JSONL + } + } + } + + // 2. Discover JSONL sessions (fallback — output tokens only) + try { + const jsonlDir = getCopilotSessionStateDir(sessionStateDir) + const jsonlSources = await discoverJsonlSessions(jsonlDir) + sources.push(...jsonlSources) + } catch { + // JSONL discovery failed + } + + // Prefer OTel over chatSessions: they can mirror the same turns under + // incompatible IDs, and OTel carries richer token/cache data. + if (!discoveredOtel) { + // 3. Discover VS Code core chatSessions journals + try { + const chatSessionSources = await discoverWorkspaceChatSessions(getWsDirs()) + sources.push(...chatSessionSources) + } catch { + // Workspace chatSessions discovery failed + } + + // 4. Discover VS Code empty-window chatSessions journals + try { + const emptyWindowSources = await discoverEmptyWindowChatSessions(getGlobalDirs()) + sources.push(...emptyWindowSources) + } catch { + // Empty-window chatSessions discovery failed + } + } + + // 5. Discover VS Code workspace transcript sessions + try { + const transcriptSources = await discoverTranscriptSessions(getWsDirs()) + sources.push(...transcriptSources) + } catch { + // Transcript discovery failed + } + + // 6. Discover JetBrains IDE sessions (IntelliJ, PyCharm, …). These live + // in a store none of the VS Code / CLI sources touch, so there is no + // overlap to dedupe against; the shared seenKeys set still guards it. + try { + const jetbrainsSources = await discoverJetBrainsSessions( + getJetBrainsCopilotRoot(jetbrainsDir) + ) + sources.push(...jetbrainsSources) + } catch { + // JetBrains discovery failed + } + + return sources + }, + + createSessionParser( + source: SessionSource, + seenKeys: Set<string> + ): SessionParser { + // Route to the correct parser based on source type. + // The dedup key set (seenKeys) is shared across both parsers, + // so if OTel already yielded a span, the JSONL parser will skip + // the matching assistant.message (and vice versa). + if (isOtelSource(source)) { + return createOtelParser(source, seenKeys) + } + if (isChatSessionSource(source)) { + return createChatSessionParser(source, seenKeys) + } + if (isJetBrainsSource(source)) { + return createJetBrainsParser(source, seenKeys) + } + return createJsonlParser(source, seenKeys) + }, + } +} + +// Default export for the provider registry +export const copilot = createCopilotProvider() diff --git a/src/providers/crush.ts b/src/providers/crush.ts new file mode 100644 index 0000000..5661d82 --- /dev/null +++ b/src/providers/crush.ts @@ -0,0 +1,258 @@ +import { readFile } from 'fs/promises' +import { join, resolve } from 'path' +import { homedir, platform } from 'os' + +import { calculateCost } from '../models.js' +import { isSqliteAvailable, getSqliteLoadError, openDatabase, type SqliteDatabase } from '../sqlite.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' + +/// Crush stores per-project SQLite databases discovered through a JSON registry. +/// We only read both. Schema source: charmbracelet/crush +/// internal/db/migrations/20250424200609_initial.sql, verified against v0.66.1. +/// The schema *comments* in that file claim millisecond timestamps, but every +/// INSERT/UPDATE in internal/db/sql/{sessions,messages}.sql uses +/// strftime('%s', 'now') which returns Unix seconds. We treat values as seconds. + +type ProjectEntry = { + path: string + data_dir: string +} + +type SessionRow = { + id: string + prompt_tokens: number | null + completion_tokens: number | null + cost: number | null + created_at: number | null + updated_at: number | null + message_count: number | null +} + +function getRegistryPath(): string { + const explicit = process.env['CRUSH_GLOBAL_DATA'] + if (explicit) return join(explicit, 'projects.json') + + if (platform() === 'win32') { + const localAppData = process.env['LOCALAPPDATA'] ?? join(homedir(), 'AppData', 'Local') + return join(localAppData, 'crush', 'projects.json') + } + + const xdg = process.env['XDG_DATA_HOME'] ?? join(homedir(), '.local', 'share') + return join(xdg, 'crush', 'projects.json') +} + +async function loadRegistry(path: string): Promise<ProjectEntry[]> { + let raw: string + try { + raw = await readFile(path, 'utf-8') + } catch { + return [] + } + let parsed: unknown + try { + parsed = JSON.parse(raw) + } catch { + return [] + } + // Crush writes projects.json as an object keyed by project id. Older builds + // (and tokscale's sample fixtures) emit an array. Accept both shapes. + let entries: unknown[] + if (Array.isArray(parsed)) { + entries = parsed + } else if (parsed && typeof parsed === 'object') { + entries = Object.values(parsed) + } else { + return [] + } + const out: ProjectEntry[] = [] + for (const e of entries) { + if (!e || typeof e !== 'object') continue + const obj = e as Record<string, unknown> + if (typeof obj['path'] !== 'string' || typeof obj['data_dir'] !== 'string') continue + out.push({ path: obj['path'], data_dir: obj['data_dir'] }) + } + return out +} + +function resolveDbPath(entry: ProjectEntry): string { + // data_dir defaults to ".crush" relative to the project path. Absolute paths + // are honored if a user has overridden the layout. + return join(resolve(entry.path, entry.data_dir), 'crush.db') +} + +function sanitizeProject(path: string): string { + return path.replace(/^\//, '').replace(/\//g, '-') +} + +function validateSchema(db: SqliteDatabase): boolean { + try { + db.query<{ cnt: number }>('SELECT COUNT(*) as cnt FROM sessions LIMIT 1') + db.query<{ cnt: number }>('SELECT COUNT(*) as cnt FROM messages LIMIT 1') + return true + } catch { + return false + } +} + +function epochSecondsToIso(epochSeconds: number | null): string { + if (epochSeconds === null || !Number.isFinite(epochSeconds)) { + return new Date(0).toISOString() + } + return new Date(epochSeconds * 1000).toISOString() +} + +function dominantModel(db: SqliteDatabase, sessionId: string): string { + try { + const rows = db.query<{ model: string | null }>( + `SELECT model FROM messages + WHERE session_id = ? AND model IS NOT NULL AND model <> '' + GROUP BY model + ORDER BY COUNT(*) DESC + LIMIT 1`, + [sessionId], + ) + if (rows.length === 0) return 'unknown' + return rows[0]!.model ?? 'unknown' + } catch { + return 'unknown' + } +} + +function createParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + if (!isSqliteAvailable()) { + process.stderr.write(getSqliteLoadError() + '\n') + return + } + + // Source paths are encoded as `<dbPath>:<sessionId>`. Split from the + // right because dbPath may contain a colon on Windows (drive letter). + const segments = source.path.split(':') + const sessionId = segments[segments.length - 1]! + const dbPath = segments.slice(0, -1).join(':') + + let db: SqliteDatabase + try { + db = openDatabase(dbPath) + } catch (err) { + process.stderr.write( + `codeburn: cannot open Crush database: ${err instanceof Error ? err.message : err}\n`, + ) + return + } + + try { + if (!validateSchema(db)) return + + const rows = db.query<SessionRow>( + `SELECT id, prompt_tokens, completion_tokens, cost, created_at, updated_at, message_count + FROM sessions + WHERE id = ? AND parent_session_id IS NULL`, + [sessionId], + ) + if (rows.length === 0) return + const session = rows[0]! + + const inputTokens = session.prompt_tokens ?? 0 + const outputTokens = session.completion_tokens ?? 0 + const cost = session.cost ?? 0 + if (inputTokens === 0 && outputTokens === 0 && cost === 0) return + + const dedupKey = `crush:${sessionId}` + if (seenKeys.has(dedupKey)) return + seenKeys.add(dedupKey) + + const model = dominantModel(db, sessionId) + // Crush already records cost in dollars; trust it. Fall back to + // pricing-table calculation only when the row is missing a cost. + const costUSD = cost > 0 + ? cost + : calculateCost(model, inputTokens, outputTokens, 0, 0, 0) + + yield { + provider: 'crush', + model, + inputTokens, + outputTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + tools: [], + bashCommands: [], + timestamp: epochSecondsToIso(session.updated_at ?? session.created_at), + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: '', + sessionId, + } + } finally { + db.close() + } + }, + } +} + +async function discoverFromDb(dbPath: string, project: string): Promise<SessionSource[]> { + let db: SqliteDatabase + try { + db = openDatabase(dbPath) + } catch { + return [] + } + try { + if (!validateSchema(db)) return [] + const rows = db.query<{ id: string }>( + `SELECT id FROM sessions + WHERE parent_session_id IS NULL + AND (cost > 0 OR prompt_tokens > 0 OR completion_tokens > 0) + ORDER BY created_at DESC`, + ) + return rows.map(row => ({ + path: `${dbPath}:${row.id}`, + project, + provider: 'crush', + })) + } catch { + return [] + } finally { + db.close() + } +} + +export function createCrushProvider(): Provider { + return { + name: 'crush', + displayName: 'Crush', + + modelDisplayName(model: string): string { + return model + }, + + toolDisplayName(rawTool: string): string { + return rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + if (!isSqliteAvailable()) return [] + const registry = await loadRegistry(getRegistryPath()) + const sources: SessionSource[] = [] + for (const entry of registry) { + const dbPath = resolveDbPath(entry) + const project = sanitizeProject(entry.path) + const found = await discoverFromDb(dbPath, project) + sources.push(...found) + } + return sources + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const crush = createCrushProvider() diff --git a/src/providers/cursor-agent.ts b/src/providers/cursor-agent.ts new file mode 100644 index 0000000..fbc0bfc --- /dev/null +++ b/src/providers/cursor-agent.ts @@ -0,0 +1,546 @@ +import { createHash } from 'crypto' +import { existsSync } from 'fs' +import { readdir, readFile, stat } from 'fs/promises' +import { join, basename } from 'path' +import { homedir } from 'os' + +import { calculateCost } from '../models.js' +import { openDatabase, type SqliteDatabase } from '../sqlite.js' +import { normalizeContentBlocks } from '../content-utils.js' +import type { + Provider, + SessionSource, + SessionParser, + ParsedProviderCall, +} from './types.js' + +type ConversationSummary = { + conversationId: string + model: string | null + title: string | null + updatedAt: string | null +} + +type AssistantTurn = { + body: string + reasoning: string + tools: string[] +} + +type ParsedTurn = { + userMessage: string + assistant: AssistantTurn +} + +const CURSOR_AGENT_COST_MODEL = 'claude-sonnet-4-5' +const CHARS_PER_TOKEN = 4 +const MAX_USER_TEXT_LENGTH = 500 +const DIGITS_ONLY = /^\d+$/ +const UUID_LIKE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i +const USER_MARKER = /^\s*user:\s*/i +const ASSISTANT_MARKER = /^\s*A:\s*/ +const THINKING_MARKER = /^\s*\[Thinking\]\s*/ +const TOOL_CALL_MARKER = /^\s*\[Tool call\]\s*(.+?)\s*$/i +const TOOL_RESULT_MARKER = /^\s*\[Tool result\]\b/i +const USER_QUERY_OPEN = '<user_query>' +const USER_QUERY_CLOSE = '</user_query>' +const warnedUnrecognizedTranscripts = new Set<string>() +const CONVERSATION_SUMMARY_QUERY = ` + SELECT conversationId, model, title, updatedAt + FROM conversation_summaries + WHERE conversationId = ? +` + +const modelDisplayNames: Record<string, string> = { + 'claude-4.5-opus-high-thinking': 'Opus 4.5 (Thinking)', + 'claude-4-opus': 'Opus 4', + 'claude-4-sonnet-thinking': 'Sonnet 4 (Thinking)', + 'claude-4.5-sonnet-thinking': 'Sonnet 4.5 (Thinking)', + 'claude-4.6-sonnet': 'Sonnet 4.6', + 'composer-1': 'Composer 1', + 'grok-code-fast-1': 'Grok Code Fast', + 'gemini-3-pro': 'Gemini 3 Pro', + 'gpt-5.1-codex-high': 'GPT-5.1 Codex', + 'gpt-5': 'GPT-5', + 'gpt-4.1': 'GPT-4.1', + default: 'Auto (Sonnet est.)', +} + +function getCursorAgentBaseDir(baseDirOverride?: string): string { + if (baseDirOverride) return baseDirOverride + // Windows paths unverified; tracked as Open Question 3 in issue #55. + return join(homedir(), '.cursor') +} + +function getProjectsDir(baseDir: string): string { + return join(baseDir, 'projects') +} + +function getAttributionDbPath(baseDir: string): string { + return join(baseDir, 'ai-tracking', 'ai-code-tracking.db') +} + +function estimateTokens(charCount: number): number { + if (charCount <= 0) return 0 + return Math.ceil(charCount / CHARS_PER_TOKEN) +} + +function parseToolName(raw: string): string { + const clean = raw.trim() + if (clean.length === 0) return 'unknown' + return clean.toLowerCase().replace(/\s+/g, '-') +} + +function normalizeTimestamp(raw: string | number | null | undefined): string | null { + if (raw === null || raw === undefined) return null + if (typeof raw === 'string') { + const trimmed = raw.trim() + if (trimmed.length === 0) return null + if (DIGITS_ONLY.test(trimmed)) { + const num = Number(trimmed) + if (!Number.isNaN(num)) { + const ms = num < 1e12 ? num * 1000 : num + return new Date(ms).toISOString() + } + } + const parsed = new Date(trimmed) + if (!Number.isNaN(parsed.getTime())) return parsed.toISOString() + return null + } + + const ms = raw < 1e12 ? raw * 1000 : raw + return new Date(ms).toISOString() +} + +function prettifyProjectId(raw: string): string { + if (!raw) return raw + + if (DIGITS_ONLY.test(raw)) { + const num = Number(raw) + if (!Number.isNaN(num) && raw.length >= 13) { + const iso = new Date(num).toISOString() + return `cursor-agent:${iso}` + } + } + + const withoutPrefix = raw.replace(/^-Users-/, '') + const parts = withoutPrefix.split('-').filter(Boolean) + if (parts.length > 0) return parts[parts.length - 1]! + + return raw +} + +function resolveModel(raw: string | null | undefined): string { + if (!raw || raw === 'default') return 'cursor-agent-auto' + return raw +} + +function costModel(model: string): string { + return model === 'cursor-agent-auto' ? CURSOR_AGENT_COST_MODEL : model +} + +function transcriptStem(transcriptPath: string): string { + const name = basename(transcriptPath) + if (name.endsWith('.jsonl')) return name.slice(0, -'.jsonl'.length) + if (name.endsWith('.txt')) return name.slice(0, -'.txt'.length) + return name +} + +function toConversationId(transcriptPath: string): string { + const filename = transcriptStem(transcriptPath) + if (filename.length === 36 && UUID_LIKE.test(filename)) return filename + return createHash('sha1').update(transcriptPath).digest('hex').slice(0, 16) +} + +async function appendTranscriptSources( + scanDir: string, + projectId: string, + sources: SessionSource[], +): Promise<void> { + const transcriptEntries = await readdir(scanDir, { withFileTypes: true }) + for (const transcript of transcriptEntries) { + // Legacy format: .txt files directly in the scan dir + if (transcript.isFile() && transcript.name.endsWith('.txt')) { + sources.push({ + path: join(scanDir, transcript.name), + project: projectId, + provider: 'cursor-agent', + }) + continue + } + + // Composer 2 format: UUID subdirectories with .jsonl files + if (transcript.isDirectory() && UUID_LIKE.test(transcript.name)) { + const subdir = join(scanDir, transcript.name) + const subEntries = await readdir(subdir, { withFileTypes: true }).catch(() => []) + const transcriptFilesByStem = new Map<string, { jsonl?: string; txt?: string }>() + + for (const sub of subEntries) { + if (sub.isFile() && (sub.name.endsWith('.jsonl') || sub.name.endsWith('.txt'))) { + const stem = transcriptStem(sub.name) + const existing = transcriptFilesByStem.get(stem) ?? {} + if (sub.name.endsWith('.jsonl')) { + transcriptFilesByStem.set(stem, { ...existing, jsonl: sub.name }) + } else { + transcriptFilesByStem.set(stem, { ...existing, txt: sub.name }) + } + continue + } + + // Subagent transcripts inside a subagents/ directory + if (sub.isDirectory() && sub.name === 'subagents') { + const subagentEntries = await readdir(join(subdir, sub.name), { withFileTypes: true }).catch(() => []) + for (const sa of subagentEntries) { + if (!sa.isFile()) continue + if (!sa.name.endsWith('.jsonl') && !sa.name.endsWith('.txt')) continue + sources.push({ + path: join(subdir, sub.name, sa.name), + project: projectId, + provider: 'cursor-agent', + }) + } + } + } + + for (const files of transcriptFilesByStem.values()) { + const selectedName = files.jsonl ?? files.txt + if (selectedName) { + sources.push({ + path: join(subdir, selectedName), + project: projectId, + provider: 'cursor-agent', + }) + } + } + } + } +} + +function extractUserQuery(userBlock: string): string { + const chunks: string[] = [] + let cursor = 0 + + while (cursor < userBlock.length) { + const openIndex = userBlock.indexOf(USER_QUERY_OPEN, cursor) + if (openIndex === -1) break + const start = openIndex + USER_QUERY_OPEN.length + const closeIndex = userBlock.indexOf(USER_QUERY_CLOSE, start) + if (closeIndex === -1) { + chunks.push(userBlock.slice(start).trim()) + break + } + chunks.push(userBlock.slice(start, closeIndex).trim()) + cursor = closeIndex + USER_QUERY_CLOSE.length + } + + const combined = chunks.filter(Boolean).join(' ').replace(/\s+/g, ' ').trim() + return combined.slice(0, MAX_USER_TEXT_LENGTH) +} + +function parseJsonlTranscript(raw: string): { turns: ParsedTurn[]; recognized: boolean } { + const lines = raw.split(/\r?\n/).filter(l => l.trim()) + if (lines.length === 0) return { turns: [], recognized: false } + + const turns: ParsedTurn[] = [] + let currentUserMessage = '' + + for (const line of lines) { + let entry: { role?: string; message?: { content?: Array<{ type?: string; text?: string; name?: string }> } } + try { + entry = JSON.parse(line) + } catch { + continue + } + + if (entry.role === 'user') { + const texts = normalizeContentBlocks(entry.message?.content) + .filter(c => c.type === 'text') + .map(c => c.text ?? '') + const combined = texts.join(' ') + currentUserMessage = extractUserQuery(combined) || combined.slice(0, MAX_USER_TEXT_LENGTH) + continue + } + + if (entry.role === 'assistant' && currentUserMessage) { + const content = normalizeContentBlocks(entry.message?.content) + const bodyParts: string[] = [] + const tools: string[] = [] + + for (const block of content) { + if (block.type === 'text' && block.text) { + bodyParts.push(block.text) + } else if (block.type === 'tool_use' && block.name) { + tools.push(`cursor:${block.name.toLowerCase()}`) + } + } + + turns.push({ + userMessage: currentUserMessage, + assistant: { + body: bodyParts.join('\n').trim(), + reasoning: '', + tools, + }, + }) + currentUserMessage = '' + } + } + + return { turns, recognized: turns.length > 0 } +} + +function parseTranscript(raw: string): { turns: ParsedTurn[]; recognized: boolean } { + const lines = raw.split(/\r?\n/) + let recognized = false + + const pendingUsers: string[] = [] + const turns: ParsedTurn[] = [] + + let active: 'none' | 'user' | 'assistant' = 'none' + let userLines: string[] = [] + let assistantLines: string[] = [] + + const flushUser = () => { + if (userLines.length === 0) return + const userQuery = extractUserQuery(userLines.join('\n')) + if (userQuery.length > 0) pendingUsers.push(userQuery) + userLines = [] + } + + const flushAssistant = () => { + if (assistantLines.length === 0) return + + let output = '' + let reasoning = '' + const toolsByTurn = new Map<string, true>() + + for (const line of assistantLines) { + if (TOOL_RESULT_MARKER.test(line)) continue + + const thinkingMatch = line.match(THINKING_MARKER) + if (thinkingMatch) { + const body = line.replace(THINKING_MARKER, '').trim() + if (body.length > 0) reasoning += `${body}\n` + continue + } + + const toolMatch = line.match(TOOL_CALL_MARKER) + if (toolMatch) { + const parsedTool = parseToolName(toolMatch[1] ?? '') + const toolKey = `cursor:${parsedTool}` + toolsByTurn.set(toolKey, true) + continue + } + + output += `${line}\n` + } + + if (pendingUsers.length > 0) { + const userMessage = pendingUsers.shift()! + const tools = Array.from(toolsByTurn.keys()) + turns.push({ + userMessage, + assistant: { + body: output.trim(), + reasoning: reasoning.trim(), + tools, + }, + }) + } + + assistantLines = [] + } + + for (const line of lines) { + if (USER_MARKER.test(line)) { + recognized = true + if (active === 'user') flushUser() + if (active === 'assistant') flushAssistant() + active = 'user' + userLines = [line.replace(USER_MARKER, '')] + continue + } + + if (ASSISTANT_MARKER.test(line)) { + recognized = true + if (active === 'user') flushUser() + if (active === 'assistant') flushAssistant() + active = 'assistant' + assistantLines = [line.replace(ASSISTANT_MARKER, '')] + continue + } + + if (active === 'user') { + userLines.push(line) + continue + } + + if (active === 'assistant') { + assistantLines.push(line) + } + } + + if (active === 'user') flushUser() + if (active === 'assistant') flushAssistant() + + return { turns, recognized } +} + +function createParser( + source: SessionSource, + seenKeys: Set<string>, + dbPath: string, + summariesByConversationId: Map<string, ConversationSummary>, +): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + const conversationId = toConversationId(source.path) + + let summary = summariesByConversationId.get(conversationId) + let db: SqliteDatabase | null = null + + try { + if (!summary) { + if (existsSync(dbPath)) { + try { + db = openDatabase(dbPath) + const rows = db.query<{ + conversationId: string + model: string | null + title: string | null + updatedAt: string | number | null + }>(CONVERSATION_SUMMARY_QUERY, [conversationId]) + + if (rows.length > 0) { + const row = rows[0]! + summary = { + conversationId: row.conversationId, + model: row.model, + title: row.title, + updatedAt: normalizeTimestamp(row.updatedAt), + } + summariesByConversationId.set(conversationId, summary) + } + } catch { + summary = undefined + } + } + } + + const transcript = await readFile(source.path, 'utf-8') + const isJsonl = source.path.endsWith('.jsonl') + const parsed = isJsonl ? parseJsonlTranscript(transcript) : parseTranscript(transcript) + + if (!parsed.recognized) { + if (!warnedUnrecognizedTranscripts.has(source.path)) { + warnedUnrecognizedTranscripts.add(source.path) + process.stderr.write(`codeburn: skipped ${basename(source.path)}: unrecognized cursor-agent transcript format\n`) + } + return + } + + let timestamp = summary?.updatedAt ?? null + if (!timestamp) { + const fileStat = await stat(source.path) + timestamp = fileStat.mtime.toISOString() + } + + const model = resolveModel(summary?.model ?? null) + + for (let turnIndex = 0; turnIndex < parsed.turns.length; turnIndex++) { + const turn = parsed.turns[turnIndex]! + const inputTokens = estimateTokens(turn.userMessage.length) + const outputTokens = estimateTokens(turn.assistant.body.length) + const reasoningTokens = estimateTokens(turn.assistant.reasoning.length) + const deduplicationKey = `cursor-agent:${conversationId}:${turnIndex}` + + if (seenKeys.has(deduplicationKey)) continue + seenKeys.add(deduplicationKey) + + const costUSD = calculateCost( + costModel(model), + inputTokens, + outputTokens + reasoningTokens, + 0, + 0, + 0, + ) + + yield { + provider: 'cursor-agent', + model, + inputTokens, + outputTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens, + webSearchRequests: 0, + costUSD, + tools: turn.assistant.tools, + bashCommands: [], + timestamp, + speed: 'standard', + deduplicationKey, + userMessage: turn.userMessage, + sessionId: conversationId, + } + } + } finally { + db?.close() + } + }, + } +} + +export function createCursorAgentProvider(baseDirOverride?: string): Provider { + const baseDir = getCursorAgentBaseDir(baseDirOverride) + const projectsDir = getProjectsDir(baseDir) + const dbPath = getAttributionDbPath(baseDir) + const summariesByConversationId = new Map<string, ConversationSummary>() + + return { + name: 'cursor-agent', + displayName: 'Cursor Agent', + + modelDisplayName(model: string): string { + if (model === 'cursor-agent-auto') return 'Cursor (auto)' + const label = modelDisplayNames[model] ?? model + return `${label} (est.)` + }, + + toolDisplayName(rawTool: string): string { + return rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + if (!existsSync(projectsDir)) return [] + + const projectEntries = await readdir(projectsDir, { withFileTypes: true }) + const sources: SessionSource[] = [] + + for (const entry of projectEntries) { + if (!entry.isDirectory()) continue + + const projectId = prettifyProjectId(entry.name) + const projectDir = join(projectsDir, entry.name) + if (entry.name === 'agent-transcripts') { + await appendTranscriptSources(projectDir, projectId, sources) + continue + } + + const transcriptDir = join(projectDir, 'agent-transcripts') + if (!existsSync(transcriptDir)) continue + await appendTranscriptSources(transcriptDir, projectId, sources) + } + + return sources + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys, dbPath, summariesByConversationId) + }, + } +} + +export const cursor_agent = createCursorAgentProvider() diff --git a/src/providers/cursor.ts b/src/providers/cursor.ts new file mode 100644 index 0000000..63ec7f2 --- /dev/null +++ b/src/providers/cursor.ts @@ -0,0 +1,1084 @@ +import { existsSync, readdirSync, readFileSync, statSync } from 'fs' +import { join } from 'path' +import { homedir } from 'os' + +import { calculateCost } from '../models.js' +import { extractBashCommands } from '../bash-utils.js' +import { readCachedResults, writeCachedResults } from '../cursor-cache.js' +import { isSqliteAvailable, isSqliteBusyError, getSqliteLoadError, openDatabase, blobToText, type SqliteDatabase } from '../sqlite.js' +import type { DateRange } from '../types.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' + +/** Matches cli-date.ts "all" period cap (6 months). */ +const CURSOR_MAX_LOOKBACK_MONTHS = 6 + +export function getCursorTimeFloor(dateRange?: DateRange): string { + const now = new Date() + const maxStart = new Date( + now.getFullYear(), + now.getMonth() - CURSOR_MAX_LOOKBACK_MONTHS, + now.getDate(), + ) + const start = dateRange?.start ?? maxStart + const effective = start < maxStart ? maxStart : start + return effective.toISOString() +} + +const CURSOR_COST_MODEL = 'claude-sonnet-4-5' + +const modelDisplayNames: Record<string, string> = { + 'claude-4.5-opus-high-thinking': 'Opus 4.5 (Thinking)', + 'claude-4-opus': 'Opus 4', + 'claude-4-sonnet-thinking': 'Sonnet 4 (Thinking)', + 'claude-4.5-sonnet-thinking': 'Sonnet 4.5 (Thinking)', + 'claude-4.6-sonnet': 'Sonnet 4.6', + 'composer-1': 'Composer 1', + 'grok-code-fast-1': 'Grok Code Fast', + 'gemini-3-pro': 'Gemini 3 Pro', + 'gpt-5.2-low': 'GPT-5.2 Low', + 'gpt-5.2': 'GPT-5.2', + 'gpt-5.1-codex-high': 'GPT-5.1 Codex', + 'gpt-5': 'GPT-5', + 'gpt-4.1': 'GPT-4.1', + 'cursor-auto': 'Cursor (auto)', +} + +type BubbleRow = { + bubble_key: string + input_tokens: number | null + output_tokens: number | null + model: string | null + created_at: string | null + request_id: string | null + user_text: Uint8Array | string | null + text_length: number | null + bubble_type: number | null + code_blocks: Uint8Array | string | null + /// Only populated on the paged scan path (BUBBLE_QUERY_PAGE) used for very + /// large databases; undefined on the un-paged BUBBLE_QUERY_SINCE path. + rid?: number +} + +type AgentKvRow = { + role: string | null + content: Uint8Array | string | null + request_id: string | null + model: string | null +} + +// SQLITE_BUSY must reach parser.ts, whose busy path skips the source without +// caching; swallowing it here would stamp a silently degraded parse into the +// results cache under an unchanged DB fingerprint (Cursor writes via WAL, so +// contention does not change the main file's stat). +function rethrowBusy(err: unknown): void { + if (isSqliteBusyError(err)) throw err +} + +const CHARS_PER_TOKEN = 4 + +function getCursorDbPath(): string { + if (process.platform === 'darwin') { + return join(homedir(), 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'state.vscdb') + } + if (process.platform === 'win32') { + return join(homedir(), 'AppData', 'Roaming', 'Cursor', 'User', 'globalStorage', 'state.vscdb') + } + return join(homedir(), '.config', 'Cursor', 'User', 'globalStorage', 'state.vscdb') +} + +function getCursorWorkspaceStorageDir(globalDbPath: string): string { + // Sibling of globalStorage. Cursor lays out User/{globalStorage,workspaceStorage}/. + // We derive the workspaceStorage path from the global DB path so a test or + // override can supply both consistently from one root. + // globalDbPath = .../User/globalStorage/state.vscdb + // workspaceStorage = .../User/workspaceStorage + const userDir = join(globalDbPath, '..', '..') + return join(userDir, 'workspaceStorage') +} + +/// Per-conversation workspace lookup table. Cursor stores each chat as +/// `bubbleId:<composerId>:<bubbleUuid>` rows in the GLOBAL state.vscdb but +/// does NOT carry a workspace path on the bubble itself. The mapping lives +/// in per-workspace dirs at `workspaceStorage/<hash>/`: +/// - `workspace.json` carries the folder URI (`file:///Users/me/proj`) +/// - `state.vscdb`'s `ItemTable['composer.composerData']` lists every +/// composerId opened in that workspace +/// We walk every workspace dir, pull both, and build composerId -> folder. +type WorkspaceMapping = { + composerToWorkspace: Map<string, string> // composerId -> folder URI + workspaceProjectName: Map<string, string> // folder URI -> sanitized project name +} + +const ORPHAN_TAG = '__orphan__' +// Catch-all project label for composers that did not register against any +// workspace. When the user has no workspaces at all this is the only label +// shown, matching the pre-PR `cursor` project so legacy installs are not +// renamed by the breakdown change. +const ORPHAN_PROJECT = 'cursor' + +function sanitizeWorkspaceUri(uri: string): string { + // Mirrors Claude's slug convention so two providers reporting the same + // project path produce identical project keys for cross-provider rollup. + // file:///Users/me/myproject → -Users-me-myproject + // vscode-remote://wsl+Ubuntu/home/me/proj → -wsl-Ubuntu-home-me-proj + let path: string + if (uri.startsWith('file://')) { + path = uri.slice('file://'.length) + } else { + // Other URI schemes (vscode-remote://, ssh+remote://, etc.): swap "://" + // for a leading "/" so the slugifier produces a predictable shape. + path = uri.replace(/^[^:]+:\/\//, '/').replace(/\+/g, '-') + } + try { + path = decodeURIComponent(path) + } catch { + // Malformed percent encoding — keep as-is rather than throw. + } + return path.replace(/\/+/g, '-') +} + +let workspaceMapCache: WorkspaceMapping | null = null +let workspaceMapCacheRoot: string | null = null + +/// Visible for tests so a fixture can rebuild the map after writing fresh +/// workspace directories. +export function clearCursorWorkspaceMapCache(): void { + workspaceMapCache = null + workspaceMapCacheRoot = null +} + +function loadWorkspaceMap(workspaceStorageDir: string): WorkspaceMapping { + if (workspaceMapCache && workspaceMapCacheRoot === workspaceStorageDir) { + return workspaceMapCache + } + const result: WorkspaceMapping = { + composerToWorkspace: new Map(), + workspaceProjectName: new Map(), + } + + let entries: string[] + try { + entries = readdirSync(workspaceStorageDir) + } catch { + workspaceMapCache = result + workspaceMapCacheRoot = workspaceStorageDir + return result + } + + for (const hashDir of entries) { + const wsJsonPath = join(workspaceStorageDir, hashDir, 'workspace.json') + const wsDbPath = join(workspaceStorageDir, hashDir, 'state.vscdb') + + let wsJsonRaw: string + try { + wsJsonRaw = readFileSync(wsJsonPath, 'utf-8') + } catch { + continue + } + + let folder: string | undefined + try { + const parsed = JSON.parse(wsJsonRaw) as { folder?: string } + folder = parsed.folder + } catch { + continue + } + if (!folder) continue + if (!existsSync(wsDbPath)) continue + + let db: SqliteDatabase + try { + db = openDatabase(wsDbPath) + } catch { + continue + } + try { + // Cursor renamed the per-workspace composer list from + // 'composer.composerData' to 'composer.composerHeaders' in newer builds + // (identical { allComposers: [{ composerId }] } shape). Read both keys + // and merge so the composer -> workspace mapping keeps working across + // Cursor versions. Without this, on builds that only write + // 'composer.composerHeaders' every composer falls through to the + // 'cursor' orphan bucket and per-project attribution is lost. + const rows = db.query<{ value: string }>( + "SELECT value FROM ItemTable WHERE key IN ('composer.composerData', 'composer.composerHeaders')", + ) + if (rows.length === 0) continue + const project = sanitizeWorkspaceUri(folder) + let added = 0 + for (const row of rows) { + let parsed: { allComposers?: Array<{ composerId?: string }> } + try { + parsed = JSON.parse(row.value) + } catch { + continue + } + for (const c of parsed.allComposers ?? []) { + if (typeof c.composerId === 'string') { + result.composerToWorkspace.set(c.composerId, folder) + added += 1 + } + } + } + if (added > 0) { + result.workspaceProjectName.set(folder, project) + } + } catch { + // best-effort + } finally { + db.close() + } + } + + workspaceMapCache = result + workspaceMapCacheRoot = workspaceStorageDir + return result +} + +/// Pulls the composer id out of a `bubbleId:<composerId>:<bubbleUuid>` key. +/// Returns null when the composer segment contains a CR/LF, which is the +/// signature Cursor uses for tool-call sub-composer rows in real data — +/// e.g. `bubbleId:task-call_xxxx\nfc_yyyy:<bubbleUuid>` is one key with a +/// literal newline between the `task-call_` and `fc_` halves. Those rows +/// are not standalone composers and would otherwise inflate the orphan +/// project's session count. +function parseComposerIdFromKey(key: string | undefined): string | null { + if (!key) return null + const firstColon = key.indexOf(':') + if (firstColon < 0) return null + const secondColon = key.indexOf(':', firstColon + 1) + if (secondColon < 0) return null + const candidate = key.slice(firstColon + 1, secondColon) + if (!candidate) return null + // Reject any multi-line / control-char composer id. Real composer ids + // (UUIDs) and synthetic fixture ids are both single-line. + if (/[\r\n\x00]/.test(candidate)) return null + return candidate +} + +// Encodes the active workspace into source.path so the parser knows which +// composers to filter for. `#cursor-ws=` is a private separator: `state.vscdb` +// does not contain `#` (we construct the path ourselves), and the literal +// token only appears in source paths emitted from this provider, so there +// is no realistic collision. +const WORKSPACE_SEP = '#cursor-ws=' + +function encodeSourcePath(dbPath: string, workspaceTag: string): string { + return `${dbPath}${WORKSPACE_SEP}${workspaceTag}` +} + +function decodeSourcePath(sourcePath: string): { dbPath: string; workspaceTag: string } { + const idx = sourcePath.indexOf(WORKSPACE_SEP) + // Backwards-compat: a bare DB path with no workspace tag means "give me + // every call from this DB". Older cached SessionSource entries and any + // hand-constructed source from a test land here. + if (idx < 0) return { dbPath: sourcePath, workspaceTag: '__all__' } + return { + dbPath: sourcePath.slice(0, idx), + workspaceTag: sourcePath.slice(idx + WORKSPACE_SEP.length), + } +} + +type CodeBlock = { languageId?: string } + +function extractLanguages(codeBlocksJson: string | null): string[] { + if (!codeBlocksJson) return [] + try { + const blocks = JSON.parse(codeBlocksJson) as CodeBlock[] + if (!Array.isArray(blocks)) return [] + const langs = new Set<string>() + for (const block of blocks) { + if (block.languageId && block.languageId !== 'plaintext') { + langs.add(block.languageId) + } + } + return [...langs] + } catch { + return [] + } +} + +function resolveModel(raw: string | null): string { + if (!raw || raw === 'default') return CURSOR_COST_MODEL + return raw +} + +function modelForDisplay(raw: string | null): string { + if (!raw || raw === 'default') return 'cursor-auto' + return raw +} + +const BUBBLE_QUERY_BASE = ` + SELECT + key as bubble_key, + json_extract(value, '$.tokenCount.inputTokens') as input_tokens, + json_extract(value, '$.tokenCount.outputTokens') as output_tokens, + json_extract(value, '$.modelInfo.modelName') as model, + json_extract(value, '$.createdAt') as created_at, + json_extract(value, '$.requestId') as request_id, + CAST(substr(json_extract(value, '$.text'), 1, 500) AS BLOB) as user_text, + length(json_extract(value, '$.text')) as text_length, + json_extract(value, '$.type') as bubble_type, + CAST(json_extract(value, '$.codeBlocks') AS BLOB) as code_blocks + FROM cursorDiskKV + WHERE key LIKE 'bubbleId:%' +` + +const AGENTKV_QUERY = ` + SELECT + json_extract(value, '$.role') as role, + CAST(json_extract(value, '$.content') AS BLOB) as content, + json_extract(value, '$.providerOptions.cursor.requestId') as request_id, + json_extract(value, '$.providerOptions.cursor.modelName') as model + FROM cursorDiskKV + WHERE key LIKE 'agentKv:blob:%' + AND hex(substr(value, 1, 1)) = '7B' + ORDER BY ROWID ASC +` + +const USER_MESSAGES_QUERY = ` + SELECT + key as bubble_key, + json_extract(value, '$.createdAt') as created_at, + CAST(substr(json_extract(value, '$.text'), 1, 500) AS BLOB) as text + FROM cursorDiskKV + WHERE key LIKE 'bubbleId:%' + AND json_extract(value, '$.type') = 1 + AND (json_extract(value, '$.createdAt') > ? OR json_extract(value, '$.createdAt') IS NULL) + ORDER BY ROWID ASC +` + +// Split into HEAD (predicates we always emit) and TAIL (ORDER BY) so the +// caller can splice in an optional `ROWID >= ?` cutoff without rewriting +// the whole template. The original combined string is preserved as +// BUBBLE_QUERY_SINCE for any caller that doesn't want the cap. +const BUBBLE_QUERY_SINCE_HEAD = BUBBLE_QUERY_BASE + ` + AND json_extract(value, '$.createdAt') IS NOT NULL + AND json_extract(value, '$.createdAt') > ?` +const BUBBLE_QUERY_SINCE_TAIL = ` + ORDER BY ROWID ASC +` +const BUBBLE_QUERY_SINCE = BUBBLE_QUERY_SINCE_HEAD + BUBBLE_QUERY_SINCE_TAIL + +// Paged variant for very large DBs: fetches one ROWID-descending page below a +// cursor. Returns ROWID and createdAt so the caller can stop once it has paged +// past the requested window floor. No date predicate here — the caller filters +// by createdAt in JS so it can see the window boundary. +const BUBBLE_QUERY_PAGE = ` + SELECT + key as bubble_key, + ROWID as rid, + json_extract(value, '$.tokenCount.inputTokens') as input_tokens, + json_extract(value, '$.tokenCount.outputTokens') as output_tokens, + json_extract(value, '$.modelInfo.modelName') as model, + json_extract(value, '$.createdAt') as created_at, + json_extract(value, '$.requestId') as request_id, + CAST(substr(json_extract(value, '$.text'), 1, 500) AS BLOB) as user_text, + length(json_extract(value, '$.text')) as text_length, + json_extract(value, '$.type') as bubble_type, + CAST(json_extract(value, '$.codeBlocks') AS BLOB) as code_blocks + FROM cursorDiskKV + WHERE key LIKE 'bubbleId:%' AND ROWID < ? + ORDER BY ROWID DESC + LIMIT ? +` + +function validateSchema(db: SqliteDatabase): boolean { + try { + const rows = db.query<{ cnt: number }>( + "SELECT COUNT(*) as cnt FROM cursorDiskKV WHERE key LIKE 'bubbleId:%' LIMIT 1" + ) + return rows.length > 0 + } catch (err) { + rethrowBusy(err) + return false + } +} + +type UserMsgRow = { bubble_key: string; created_at: string; text: Uint8Array | string } + +/// Per-conversation user-message buffer. We pop messages in arrival order via +/// the `pos` cursor — a previous implementation called Array.shift() which is +/// O(n) per call on large conversations and pinned multi-GB Cursor DBs at +/// minutes-of-parse for power users. The cursor walk is O(1). +type UserMessageQueue = { + messages: string[] + pos: number +} + +function buildUserMessageMap(db: SqliteDatabase, timeFloor: string): Map<string, UserMessageQueue> { + const map = new Map<string, UserMessageQueue>() + try { + const rows = db.query<UserMsgRow>(USER_MESSAGES_QUERY, [timeFloor]) + for (const row of rows) { + // Extract the composerId from the bubble key, matching parseBubbles(). + // The JSON `conversationId` field is empty in current Cursor builds. + const composerId = parseComposerIdFromKey(row.bubble_key) + if (!composerId || !row.text) continue + const text = blobToText(row.text) + const existing = map.get(composerId) + if (existing) { + existing.messages.push(text) + } else { + map.set(composerId, { messages: [text], pos: 0 }) + } + } + } catch (err) { + rethrowBusy(err) + } + return map +} + +function takeUserMessage(queues: Map<string, UserMessageQueue>, conversationId: string): string { + const queue = queues.get(conversationId) + if (!queue || queue.pos >= queue.messages.length) return '' + const msg = queue.messages[queue.pos] + queue.pos += 1 + return msg +} + +/// Scans bubbles for very large DBs by paging ROWID-descending (newest first), +/// keeping only rows within the requested window (createdAt > timeFloor), and +/// stopping once a full page lands below the floor. A `budget` caps the number +/// of in-range bubbles collected so a genuinely enormous in-range scan can't +/// stall; `truncated` is set only when that budget is actually hit, so the +/// caller warns only when older in-range sessions were really dropped. +function scanBubblesPaged( + db: SqliteDatabase, + timeFloor: string, + budget: number, +): { rows: BubbleRow[]; truncated: boolean } { + const BATCH = 25_000 + const collected: BubbleRow[] = [] + let beforeRowId = Number.MAX_SAFE_INTEGER + let truncated = false + + paging: while (true) { + let batch: BubbleRow[] + try { + batch = db.query<BubbleRow>(BUBBLE_QUERY_PAGE, [beforeRowId, BATCH]) + } catch (err) { + rethrowBusy(err) + break + } + if (batch.length === 0) break + + for (const row of batch) { + if (collected.length >= budget) { truncated = true; break paging } + if (row.created_at != null && row.created_at > timeFloor) collected.push(row) + } + + const oldest = batch[batch.length - 1]! + beforeRowId = oldest.rid ?? 0 + if (beforeRowId <= 0) break + if (batch.length < BATCH) break // exhausted the table + // Pages are ROWID-descending (~chronological), so once the oldest row in a + // full page predates the window, every older page does too. + if (oldest.created_at != null && oldest.created_at <= timeFloor) break + } + + // Restore ROWID-ascending order to match the un-paged query's row ordering. + collected.sort((a, b) => (a.rid ?? 0) - (b.rid ?? 0)) + return { rows: collected, truncated } +} + +// Cursor leaves the per-bubble tokenCount at {0,0} on current builds. The only +// real input figure on disk is the latest context-window snapshot, which Cursor +// records in composerData.promptTokenBreakdown.totalUsedTokens or +// contextTokensUsed (the in-app context meter). This is not cumulative per-turn, +// so local SQLite undercounts admin-console usage; parity requires the opt-in +// Cursor Admin API: POST api.cursor.com/teams/filtered-usage-events. +// The key-range predicate seeks the primary key instead of scanning the table. +const COMPOSER_META_QUERY = ` + SELECT + substr(key, length('composerData:') + 1) as composer_id, + json_extract(value, '$.promptTokenBreakdown.totalUsedTokens') as used, + json_extract(value, '$.contextTokensUsed') as ctx, + json_extract(value, '$.createdAt') as created_at + FROM cursorDiskKV + WHERE key >= 'composerData:' AND key < 'composerData;' +` + +type ComposerMeta = { tokens: number; createdAt: number | null } + +function loadComposerMeta(db: SqliteDatabase): Map<string, ComposerMeta> { + const map = new Map<string, ComposerMeta>() + try { + const rows = db.query<{ composer_id: string; used: number | null; ctx: number | null; created_at: number | null }>(COMPOSER_META_QUERY) + for (const r of rows) { + // `||` rather than `??`: a recorded-but-zero breakdown must fall through + // to the context meter instead of shadowing it. + const tokens = (r.used || r.ctx) ?? 0 + if (r.composer_id && tokens > 0) map.set(r.composer_id, { tokens, createdAt: r.created_at ?? null }) + } + } catch (err) { + rethrowBusy(err) + /* best-effort: callers fall back to the per-bubble text estimate */ + } + return map +} + +type AgentStream = { + tools: string[] + bash: string[] + userChars: number + contextChars: number + assistantChars: number + model: string | null +} + +function newAgentStream(): AgentStream { + return { tools: [], bash: [], userChars: 0, contextChars: 0, assistantChars: 0, model: null } +} + +// agentKv rows store content as a plain string or a block array; count only +// the text inside blocks so the JSON envelope and non-text parts are not +// billed as prompt characters. +function contentTextLength(raw: string): number { + const trimmed = raw.trimStart() + if (trimmed.startsWith('[') || trimmed.startsWith('{')) { + try { + const parsed = JSON.parse(trimmed) as unknown + const blocks = Array.isArray(parsed) ? parsed : [parsed] + let len = 0 + for (const block of blocks) { + if (block == null || typeof block !== 'object') continue + const b = block as { text?: unknown; content?: unknown } + if (typeof b.text === 'string') len += b.text.length + else if (typeof b.content === 'string') len += b.content.length + } + return len + } catch { + return raw.length + } + } + return raw.length +} + +// Cursor logs the agent's stream (prompt, injected context, tool calls, reply +// deltas) in agentKv blobs keyed by requestId. Bubbles carry the same +// requestId, so the map built from the scanned bubbles joins each request to +// its conversation. Requests with no matching bubble are kept separately: +// they are real sessions (background runs, older builds) that would otherwise +// vanish from totals. +function loadAgentStreams( + db: SqliteDatabase, + requestToComposer: Map<string, string>, +): { byComposer: Map<string, AgentStream>; unjoined: Map<string, AgentStream> } { + const byComposer = new Map<string, AgentStream>() + const unjoined = new Map<string, AgentStream>() + + let rows: AgentKvRow[] + try { + rows = db.query<AgentKvRow>(AGENTKV_QUERY) + } catch (err) { + rethrowBusy(err) + return { byComposer, unjoined } + } + + const bucketFor = (requestId: string): AgentStream => { + const composer = requestToComposer.get(requestId) + const map = composer ? byComposer : unjoined + const key = composer ?? requestId + const existing = map.get(key) + if (existing) return existing + const fresh = newAgentStream() + map.set(key, fresh) + return fresh + } + + // Only the turn-opening (user) agentKv row carries the requestId; rows that + // follow inherit it. Rows written BEFORE their request's id appears (the + // system prompt and opening user prompt at a conversation start) buffer + // until the next id, and a system row closes the previous request so + // interleaved sessions cannot inherit across a conversation boundary. + let currentRequestId: string | null = null + let pendingUserChars = 0 + let pendingContextChars = 0 + for (const row of rows) { + if (row.request_id) { + currentRequestId = row.request_id + if (pendingUserChars > 0 || pendingContextChars > 0) { + const bucket = bucketFor(currentRequestId) + bucket.userChars += pendingUserChars + bucket.contextChars += pendingContextChars + pendingUserChars = 0 + pendingContextChars = 0 + } + } + if (row.model && currentRequestId) { + const bucket = bucketFor(currentRequestId) + if (!bucket.model) bucket.model = row.model + } + if (!row.content) continue + + if (row.role === 'system') { + pendingContextChars += contentTextLength(blobToText(row.content)) + currentRequestId = null + continue + } + if (row.role === 'user') { + const len = contentTextLength(blobToText(row.content)) + if (currentRequestId) bucketFor(currentRequestId).userChars += len + else pendingUserChars += len + continue + } + if (row.role === 'tool') { + if (currentRequestId) bucketFor(currentRequestId).contextChars += contentTextLength(blobToText(row.content)) + continue + } + if (row.role !== 'assistant' || !currentRequestId) continue + + let content: unknown + try { + content = JSON.parse(blobToText(row.content)) + } catch { + continue + } + if (!Array.isArray(content)) continue + const bucket = bucketFor(currentRequestId) + for (const block of content as Array<{ type?: string; text?: unknown; toolName?: unknown; args?: { command?: unknown } }>) { + if (block == null || typeof block !== 'object') continue + if (typeof block.text === 'string') bucket.assistantChars += block.text.length + if (block.type !== 'tool-call' || typeof block.toolName !== 'string' || !block.toolName) continue + // Cursor's terminal tool is 'Shell'; emit the canonical 'Bash' so the + // cross-provider tool and command breakdowns merge. + bucket.tools.push(block.toolName === 'Shell' ? 'Bash' : block.toolName) + if (block.toolName === 'Shell' && typeof block.args?.command === 'string') { + bucket.bash.push(...extractBashCommands(block.args.command)) + } + } + } + return { byComposer, unjoined } +} + +// What drives a conversation's input figure, decided once per conversation so +// the sources can never stack on each other: +// bubbleTokens - some bubble carries a real tokenCount (older builds), so +// per-turn counts are authoritative and nothing is estimated. +// meter - the composerData context meter exists; one conversation +// record carries it. +// stream - no meter, but the agent stream holds the prompt/context; one +// conversation record carries the estimate. +// text - only visible bubble text exists; estimated per bubble. +type InputSource = 'bubbleTokens' | 'meter' | 'stream' | 'text' + +type ComposerScan = { + hasRealTokens: boolean + firstBubbleTs: string | null + assistantTextChars: number + model: string | null +} + +function parseBubbles( + db: SqliteDatabase, + seenKeys: Set<string>, + timeFloor: string, + agentKvTimestamp: string, +): { calls: ParsedProviderCall[] } { + const results: ParsedProviderCall[] = [] + let skipped = 0 + + const composerMeta = loadComposerMeta(db) + + // The bubble timestamp lives inside the JSON value (no index), so the date + // filter forces a full JSON decode per row. Multi-GB Cursor DBs (500k+ + // bubbles) were producing 30s+ parse stalls, so the scan is bounded. The old + // approach kept only the most-recent MAX_BUBBLES by ROWID, which dropped + // in-range older sessions and warned even when the requested window fit + // comfortably. Instead, for large DBs we page the requested window + // (ROWID-descending, stopping past the window floor) and only fall back to a + // hard budget — warning — when the in-range scan genuinely exceeds it. + // Override the budget in tests via CODEBURN_CURSOR_MAX_BUBBLES. + const MAX_BUBBLES = Number(process.env['CODEBURN_CURSOR_MAX_BUBBLES']) || 250_000 + + let total = 0 + try { + const countRows = db.query<{ cnt: number }>( + "SELECT COUNT(*) as cnt FROM cursorDiskKV WHERE key LIKE 'bubbleId:%'" + ) + total = countRows[0]?.cnt ?? 0 + } catch (err) { + rethrowBusy(err) + } + + let rows: BubbleRow[] + try { + if (total > MAX_BUBBLES) { + const scan = scanBubblesPaged(db, timeFloor, MAX_BUBBLES) + rows = scan.rows + if (scan.truncated) { + process.stderr.write( + `codeburn: Cursor database has ${total.toLocaleString()} bubbles and the ` + + `requested range exceeds the ${MAX_BUBBLES.toLocaleString()}-bubble scan budget; ` + + `the oldest sessions in range may be missing from this report.\n` + ) + } + } else { + rows = db.query<BubbleRow>(BUBBLE_QUERY_SINCE, [timeFloor]) + } + } catch (err) { + rethrowBusy(err) + return { calls: results } + } + + // Pre-pass: per-conversation facts the crediting decisions need, plus the + // requestId join for the agent stream — all from the rows already fetched, + // so no extra unbudgeted table scans. + const scans = new Map<string, ComposerScan>() + const requestToComposer = new Map<string, string>() + for (const row of rows) { + const cid = parseComposerIdFromKey(row.bubble_key) + if (!cid) continue + if (row.request_id) requestToComposer.set(row.request_id, cid) + let scan = scans.get(cid) + if (!scan) { + scan = { hasRealTokens: false, firstBubbleTs: null, assistantTextChars: 0, model: null } + scans.set(cid, scan) + } + if ((row.input_tokens ?? 0) > 0 || (row.output_tokens ?? 0) > 0) scan.hasRealTokens = true + if (!scan.firstBubbleTs && row.created_at) scan.firstBubbleTs = row.created_at + if (row.bubble_type !== 1) scan.assistantTextChars += row.text_length ?? 0 + if (!scan.model && row.model) scan.model = row.model + } + + const { byComposer: agentStreams, unjoined } = loadAgentStreams(db, requestToComposer) + const userMessages = buildUserMessageMap(db, timeFloor) + const lastUserMsg = new Map<string, string>() + + const inputSource = (cid: string): InputSource => { + if (scans.get(cid)?.hasRealTokens) return 'bubbleTokens' + if (composerMeta.has(cid)) return 'meter' + const stream = agentStreams.get(cid) + if ((stream?.userChars ?? 0) + (stream?.contextChars ?? 0) > 0) return 'stream' + return 'text' + } + + const emit = (call: Omit<ParsedProviderCall, 'provider' | 'speed' | 'cacheCreationInputTokens' | 'cacheReadInputTokens' | 'cachedInputTokens' | 'reasoningTokens' | 'webSearchRequests' | 'costIsEstimated'>): void => { + results.push({ + provider: 'cursor', + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + speed: 'standard', + // Output is a reply-text estimate and the input meter is the latest + // context snapshot, not a per-turn sum, so no cursor figure is exact. + costIsEstimated: true, + ...call, + }) + } + + const toolsAttached = new Set<string>() + for (const row of rows) { + try { + // The real composerId lives in the row key `bubbleId:<composerId>:<uuid>` + // (the JSON conversationId field is empty in current builds). + // parseComposerIdFromKey returns null for non-UUID composer segments + // (tool-call output rows and similar shapes), which are NOT sessions. + const conversationId = parseComposerIdFromKey(row.bubble_key) + if (!conversationId) { + skipped++ + continue + } + const createdAt = row.created_at + if (!createdAt) continue + + // Pair each user turn with its own prompt (even when the turn itself + // emits nothing) so the assistant reply that follows classifies against + // the right question. + if (row.bubble_type === 1) { + lastUserMsg.set(conversationId, takeUserMessage(userMessages, conversationId)) + } + + let inputTokens = row.input_tokens ?? 0 + let outputTokens = row.output_tokens ?? 0 + if (inputTokens === 0 && outputTokens === 0) { + const textLen = row.text_length ?? 0 + if (row.bubble_type === 1) { + // Conversation-level input (meter or stream) is emitted once after + // this loop; per-bubble text only counts when it is the + // conversation's best available signal. + if (inputSource(conversationId) === 'text' && textLen > 0) { + inputTokens = Math.ceil(textLen / CHARS_PER_TOKEN) + } + } else { + outputTokens = Math.ceil(textLen / CHARS_PER_TOKEN) + } + if (inputTokens === 0 && outputTokens === 0) continue + } + + // Use the SQLite row key (bubbleId:<unique>) as the dedup key. + // Cursor mutates token counts on the row in place when streaming + // completes — including tokens in the dedup key (the previous + // implementation) caused the same bubble to be counted twice once + // its tokens stabilized. + const dedupKey = `cursor:bubble:${row.bubble_key}` + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + // User bubbles (type=1) carry no modelInfo, so fall back to the + // conversation's model seen on its assistant bubbles or agent stream. + const effectiveModel = row.model ?? scans.get(conversationId)?.model ?? agentStreams.get(conversationId)?.model ?? null + const pricingModel = resolveModel(effectiveModel) + const costUSD = calculateCost(pricingModel, inputTokens, outputTokens, 0, 0, 0) + + const userQuestion = lastUserMsg.get(conversationId) ?? '' + const assistantText = blobToText(row.user_text) + const userText = (userQuestion + ' ' + assistantText).trim() + + const languages = extractLanguages(blobToText(row.code_blocks)) + const hasCode = languages.length > 0 + + // Meter/stream conversations carry their agent tools on the synthetic + // conversation record below; the rest attach them to their first + // emitted call so they are counted exactly once. + let agentTurn: AgentStream | undefined + const source = inputSource(conversationId) + if ((source === 'text' || source === 'bubbleTokens') && !toolsAttached.has(conversationId)) { + agentTurn = agentStreams.get(conversationId) + if (agentTurn) toolsAttached.add(conversationId) + } + + emit({ + model: modelForDisplay(effectiveModel), + inputTokens, + outputTokens, + costUSD, + tools: [ + ...(hasCode ? ['cursor:edit', ...languages.map(l => `lang:${l}`)] : []), + ...(agentTurn?.tools ?? []), + ], + bashCommands: agentTurn?.bash ?? [], + timestamp: createdAt, + deduplicationKey: dedupKey, + userMessage: userText, + sessionId: conversationId, + }) + } catch { + skipped++ + } + } + + // One conversation-level input record per metered/stream conversation, + // anchored to the conversation's own start (composerData.createdAt) so the + // credited day never depends on the parse window or cache state, and keyed + // by composerId so re-parses and daily-cache gap fills dedupe instead of + // multiplying. The meter is the LATEST context size, not a per-turn sum; + // growth after the anchor day is finalized stays uncounted, which keeps the + // documented undercount-vs-admin-console tradeoff but never double counts. + for (const [cid, scan] of scans) { + const source = inputSource(cid) + if (source !== 'meter' && source !== 'stream') continue + const stream = agentStreams.get(cid) + const meta = composerMeta.get(cid) + const inputTokens = source === 'meter' + ? meta?.tokens ?? 0 + : Math.ceil(((stream?.userChars ?? 0) + (stream?.contextChars ?? 0)) / CHARS_PER_TOKEN) + // Reply text normally lives on assistant bubbles; count the stream's + // reply deltas only when the bubbles carried none. + const outputTokens = scan.assistantTextChars > 0 ? 0 : Math.ceil((stream?.assistantChars ?? 0) / CHARS_PER_TOKEN) + if (inputTokens === 0 && outputTokens === 0) continue + + const dedupKey = `cursor:composer-input:${cid}` + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + const createdAtMs = meta?.createdAt + const timestamp = typeof createdAtMs === 'number' && createdAtMs > 0 ? new Date(createdAtMs).toISOString() : scan.firstBubbleTs + if (!timestamp) continue + + const effectiveModel = scan.model ?? stream?.model ?? null + emit({ + model: modelForDisplay(effectiveModel), + inputTokens, + outputTokens, + costUSD: calculateCost(resolveModel(effectiveModel), inputTokens, outputTokens, 0, 0, 0), + tools: stream?.tools ?? [], + bashCommands: stream?.bash ?? [], + timestamp, + deduplicationKey: dedupKey, + userMessage: '', + sessionId: cid, + }) + } + + // Sessions recorded only in the agent stream (no bubble carries their + // requestId). agentKv stores no timestamps, so these reuse the DB file's + // mtime as a bounded "last write" time, like the pre-composer parser did. + for (const [requestId, stream] of unjoined) { + const inputTokens = Math.ceil((stream.userChars + stream.contextChars) / CHARS_PER_TOKEN) + const outputTokens = Math.ceil(stream.assistantChars / CHARS_PER_TOKEN) + if (inputTokens === 0 && outputTokens === 0) continue + + const dedupKey = `cursor:agentKv:${requestId}` + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + emit({ + model: modelForDisplay(stream.model), + inputTokens, + outputTokens, + costUSD: calculateCost(resolveModel(stream.model), inputTokens, outputTokens, 0, 0, 0), + tools: stream.tools, + bashCommands: stream.bash, + timestamp: agentKvTimestamp, + deduplicationKey: dedupKey, + userMessage: '', + sessionId: requestId, + }) + } + + if (skipped > 0) { + process.stderr.write(`codeburn: skipped ${skipped} unreadable Cursor entries\n`) + } + + return { calls: results } +} + +function createParser( + source: SessionSource, + seenKeys: Set<string>, + dateRange?: DateRange, +): SessionParser { + const timeFloor = getCursorTimeFloor(dateRange) + + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + if (!isSqliteAvailable()) { + process.stderr.write(getSqliteLoadError() + '\n') + return + } + + const { dbPath, workspaceTag } = decodeSourcePath(source.path) + + // Decide which composers belong to this source. The workspace map is + // built once per process from `workspaceStorage/*` and reused across + // every workspace-scoped source, so we pay the directory walk cost + // only once per CLI run regardless of how many projects the user has. + // `composerFilter` holds the set of composers EITHER allowed (workspace + // source) or denied (orphan source); `filterMode` says which. + let composerFilter: Set<string> | null = null + let filterMode: 'include' | 'exclude' = 'include' + if (workspaceTag !== '__all__') { + const wsMap = loadWorkspaceMap(getCursorWorkspaceStorageDir(dbPath)) + if (workspaceTag === ORPHAN_TAG) { + // Orphan source: every composer that is mapped to SOME workspace + // is excluded here, so unmapped composers (and any non-UUID + // sub-composer ids that slip through) land in this bucket. + composerFilter = new Set(wsMap.composerToWorkspace.keys()) + filterMode = 'exclude' + } else { + composerFilter = new Set() + for (const [composerId, folder] of wsMap.composerToWorkspace) { + if (folder === workspaceTag) composerFilter.add(composerId) + } + filterMode = 'include' + } + } + + // Cache is keyed on the bare DB path so multiple workspace-scoped + // sources reuse one parsed bubble set per CLI run. Filtering happens + // post-cache so each source emits only its own composers. + let allCalls: ParsedProviderCall[] | null = null + const cached = await readCachedResults(dbPath, timeFloor) + if (cached) { + allCalls = cached + } else { + let db: SqliteDatabase + try { + db = openDatabase(dbPath) + } catch (err) { + rethrowBusy(err) + process.stderr.write(`codeburn: cannot open Cursor database: ${err instanceof Error ? err.message : err}\n`) + return + } + try { + if (!validateSchema(db)) { + process.stderr.write('codeburn: Cursor storage format not recognized. You may need to update CodeBurn.\n') + return + } + // Use a fresh local Set for intra-parse dedup so the global + // seenKeys is not mutated by calls that the workspace filter is + // about to drop. Cross-source dedup happens at yield time. + const localSeen = new Set<string>() + // agentKv rows carry no timestamps; sessions found only there get + // the DB's last-write time. + let agentKvTimestamp: string + try { + agentKvTimestamp = new Date(statSync(dbPath).mtimeMs).toISOString() + } catch { + agentKvTimestamp = new Date().toISOString() + } + const { calls: bubbleCalls } = parseBubbles(db, localSeen, timeFloor, agentKvTimestamp) + allCalls = bubbleCalls + await writeCachedResults(dbPath, allCalls, timeFloor) + } finally { + db.close() + } + } + + for (const call of allCalls) { + if (composerFilter !== null) { + const inSet = composerFilter.has(call.sessionId) + if (filterMode === 'include' && !inSet) continue + if (filterMode === 'exclude' && inSet) continue + } + if (seenKeys.has(call.deduplicationKey)) continue + seenKeys.add(call.deduplicationKey) + yield call + } + }, + } +} + +export function createCursorProvider(dbPathOverride?: string): Provider { + return { + name: 'cursor', + displayName: 'Cursor', + + modelDisplayName(model: string): string { + return modelDisplayNames[model] ?? model + }, + + toolDisplayName(rawTool: string): string { + return rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + if (!isSqliteAvailable()) return [] + + const dbPath = dbPathOverride ?? getCursorDbPath() + if (!existsSync(dbPath)) return [] + + const wsMap = loadWorkspaceMap(getCursorWorkspaceStorageDir(dbPath)) + const sources: SessionSource[] = [] + for (const [folder, project] of wsMap.workspaceProjectName) { + sources.push({ + path: encodeSourcePath(dbPath, folder), + project, + provider: 'cursor', + }) + } + // Always emit a catch-all source for composers with no workspace + // mapping. About a third of composers in real-world Cursor installs + // are unmapped (multi-root workspaces, "no folder open" sessions, + // deleted workspaces with surviving global rows). When the user has + // no workspaces at all this source captures everything and the + // dashboard looks identical to the pre-PR `cursor` project. + sources.push({ + path: encodeSourcePath(dbPath, ORPHAN_TAG), + project: ORPHAN_PROJECT, + provider: 'cursor', + }) + return sources + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>, dateRange?: DateRange): SessionParser { + return createParser(source, seenKeys, dateRange) + }, + } +} + +export const cursor = createCursorProvider() diff --git a/src/providers/devin.ts b/src/providers/devin.ts new file mode 100644 index 0000000..b41e7bb --- /dev/null +++ b/src/providers/devin.ts @@ -0,0 +1,594 @@ +import { readdir, stat } from "fs/promises"; +import { basename, join } from "path"; +import { homedir } from "os"; + +import { getShortModelName } from "../models.js"; +import { openDatabase } from "../sqlite.js"; +import { readConfig } from "../config.js"; +import type { + Provider, + SessionParser, + SessionSource, + ParsedProviderCall, +} from "./types.js"; +import { readSessionFile } from "../fs-utils.js"; +import { isPositiveNumber, safeNumber } from "../parser.js"; + +type AgentTrajectory<StepType extends Step = Step, AgentExtra = unknown> = { + schema_version: string; + session_id?: string; + agent: Agent<AgentExtra>; + steps: StepType[]; + final_metrics?: FinalMetrics; +}; + +type FinalMetrics = { + total_prompt_tokens?: number; + total_completion_tokens?: number; + total_cached_tokens?: number; + total_steps?: number; +}; + +type DevinAgentExtra = { + backend?: string; + permission_mode?: string; +}; + +type Agent<Extra = unknown> = { + name: string; + version: string; + model_name?: string; + tool_definitions?: unknown; + extra?: Extra; +}; + +type ToolCall = { + tool_call_id: string; + function_name: string; + arguments: unknown; +}; + +type DevinMetadata = { + created_at?: string; + committed_acu_cost?: number; + generation_model?: string; + is_user_input?: boolean; + num_tokens?: number; + request_id?: string; + finish_reason?: string; + metrics?: { + input_tokens?: number; + output_tokens?: number; + cache_creation_tokens?: number; + cache_read_tokens?: number; + tokens_per_sec?: number; + total_time_ms?: number; + ttft_ms?: number; + tpot_ms?: number; + }; +}; + +type ContentPart = ContentPartText | ContentPartImage; + +type ContentPartText = { + type: "text"; + text: string; +}; + +type ContentPartImage = { + type: "image"; + source: ImageSource; +}; + +function isTextContentPart( + contentPart: ContentPart, +): contentPart is ContentPartText { + return contentPart.type === "text"; +} + +type ImageSource = { + media_type: string; + path: string; +}; + +type Step<StepExtra = unknown, MetricsExtra = unknown> = { + step_id: number; + timestamp?: string; + source: string; + model_name?: string; + message: string | Array<ContentPart>; + tool_calls?: Array<ToolCall>; + extra?: StepExtra; + observation?: Observation; + metrics?: Metrics<MetricsExtra>; +}; + +type DevinTelemetry = { + source?: string; + operation?: string; +}; + +type DevinStepExtra = { + committed_acu_cost?: number; + generation_model?: string; + telemetry?: DevinTelemetry; +}; + +type Observation = { + results: Array<ObservationResult>; +}; + +type ObservationResult = { + source_call_id?: string; + content?: string | Array<ContentPart>; +}; + +type Metrics<Extra = unknown> = { + prompt_tokens?: number; + completion_tokens?: number; + cached_tokens?: number; + extra?: Extra; +}; + +type DevinMetricsExtra = { + cache_creation_input_tokens?: number; +}; + +type DevinStep = Step<DevinStepExtra, DevinMetricsExtra> & { + metadata?: DevinMetadata; +}; + +type DevinAgentTrajectory = AgentTrajectory<DevinStep, DevinAgentExtra>; + +type DevinSessionMetadata = { + id: string; + workingDirectory: string; + model: string; + title?: string; + createdAt: string; + lastActivityAt: string; + hidden: boolean; +}; + +type DevinUsage = { + committedAcuCost: number; + inputTokens: number; + outputTokens: number; + cacheCreationInputTokens: number; + cacheReadInputTokens: number; +}; + +const DEFAULT_DEVIN_CLI_DIR = join( + homedir(), + ".local", + "share", + "devin", + "cli", +); + +const DEFAULT_MODEL_NAME = "devin"; +const DEVIN_PROVIDER_NAME = "devin"; +const DEVIN_PROVIDER_DISPLAY_NAME = "Devin"; +const DEVIN_TRANSCRIPTS_SUBDIR = "transcripts"; +const DEVIN_SESSIONS_DB = "sessions.db"; +const DEVIN_EFFORT_TIERS = new Set(["xhigh", "high", "medium", "low"]); + +function parseTranscript(raw: string): DevinAgentTrajectory | null { + try { + return JSON.parse(raw) as DevinAgentTrajectory; + } catch { + return null; + } +} + +function parseNumericTimestamp(value: number): string { + const millis = value < 10_000_000_000 ? value * 1000 : value; + return new Date(millis).toISOString(); +} + +function getCommittedAcuCost(step: DevinStep): number { + const acuCost = [ + step.metadata?.committed_acu_cost, + step.extra?.committed_acu_cost, + ].filter((cost) => isPositiveNumber(cost)); + + return acuCost.shift() || 0; +} + +function hasAnyTokenField( + metrics: Metrics<DevinMetricsExtra> | null | undefined, +): boolean { + if (!metrics) return false; + return [ + metrics.prompt_tokens, + metrics.completion_tokens, + metrics.cached_tokens, + metrics.extra?.cache_creation_input_tokens, + ].some((value) => value != null); +} + +function getMetricsFromStep( + step: DevinStep, +): Metrics<DevinMetricsExtra> | null { + // Prefer step.metrics (standard ATIF v1.7) only when it actually carries + // token fields; a present-but-empty metrics object must not shadow the + // legacy metadata.metrics location. + if (hasAnyTokenField(step.metrics)) { + return step.metrics ?? null; + } + + if (step.metadata) { + return getDevinMetricsFromMetadata(step.metadata); + } + + return step.metrics ?? null; +} + +function getDevinMetricsFromMetadata( + metadata: DevinMetadata, +): Metrics<DevinMetricsExtra> { + return { + prompt_tokens: metadata.metrics?.input_tokens, + completion_tokens: metadata.metrics?.output_tokens, + cached_tokens: metadata.metrics?.cache_read_tokens, + extra: { + cache_creation_input_tokens: metadata.metrics?.cache_creation_tokens, + }, + }; +} + +function getUsage(step: DevinStep): DevinUsage | null { + const committedAcuCost = getCommittedAcuCost(step); + const metrics = getMetricsFromStep(step); + + const hasAnyUsage = [ + committedAcuCost, + metrics?.prompt_tokens, + metrics?.completion_tokens, + metrics?.extra?.cache_creation_input_tokens, + metrics?.cached_tokens, + ].some((x) => isPositiveNumber(x)); + + if (!hasAnyUsage) return null; + + return { + committedAcuCost, + inputTokens: safeNumber(metrics?.prompt_tokens), + outputTokens: safeNumber(metrics?.completion_tokens), + cacheCreationInputTokens: safeNumber( + metrics?.extra?.cache_creation_input_tokens, + ), + cacheReadInputTokens: safeNumber(metrics?.cached_tokens), + }; +} + +function getSessionId( + source: SessionSource, + transcript: DevinAgentTrajectory, +): string { + const fromTranscript = transcript.session_id?.trim(); + return fromTranscript || basename(source.path, ".json"); +} + +function projectNameFromPath(path: string): string { + const normalized = path.trim().replace(/[/\\]+$/, ""); + return normalized.split(/[/\\]/).filter(Boolean).pop() ?? path; +} + +function getProjectName( + source: SessionSource, + session: DevinSessionMetadata | null, +): string { + if (session?.workingDirectory) + return projectNameFromPath(session.workingDirectory); + if (session?.title) return session.title; + return source.project; +} + +function getProjectPath( + session: DevinSessionMetadata | null, +): string | undefined { + return session?.workingDirectory; +} + +function getTimestamp( + step: DevinStep, + session: DevinSessionMetadata | null, +): string | undefined { + return [ + step.metadata?.created_at, + session?.lastActivityAt, + session?.createdAt, + ] + .filter(Boolean) + .shift(); +} + +function firstPresentString(...values: Array<string | undefined>): string | undefined { + for (const value of values) { + const trimmed = value?.trim(); + if (trimmed) return trimmed; + } + return undefined; +} + +function getFriendlyGptName(model: string): string { + const shortName = getShortModelName(model); + const match = model.match(/^gpt-(\d+(?:\.\d+)*)(?:-(.+))?$/); + if (!match) return shortName; + + const suffixParts = match[2]?.split("-").filter(Boolean) ?? []; + // A purely numeric suffix token means this is a dated snapshot id such as + // gpt-4-1106-preview, not a clean version+word id. Fabricating a friendly + // name here would mislabel the date as text (e.g. "GPT-4 1106 Preview"), so + // defer to getShortModelName, which passes unknown snapshots through raw. + if (suffixParts.some((part) => /^\d+$/.test(part))) return shortName; + + const suffix = suffixParts + .map((part) => part.charAt(0).toUpperCase() + part.slice(1)) + .join(" "); + + const reconstructed = `GPT-${match[1]}${suffix ? ` ${suffix}` : ""}`; + if (shortName !== model && (!suffix || shortName !== `GPT-${match[1]}`)) { + return shortName; + } + + return reconstructed; +} + +function getDevinDisplayModelName( + generationModel: string | undefined, + modelName: string, +): string { + if (!generationModel || /^MODEL_/.test(generationModel)) { + return getShortModelName(modelName); + } + + if (generationModel.startsWith("gpt-")) { + // Devin minor versions are always a single digit (gpt-5-3-codex). Restrict + // the dash-to-dot rewrite to a single-digit minor at a token boundary so a + // dated snapshot like gpt-4-1106-preview is not misread as version 4.1106. + const normalized = generationModel.replace(/^gpt-(\d+)-(\d)(?=-|$)/, "gpt-$1.$2"); + const effortMatch = normalized.match(/-([^-]+)$/); + const effort = effortMatch && DEVIN_EFFORT_TIERS.has(effortMatch[1]!) + ? effortMatch[1] + : undefined; + const base = effort ? normalized.slice(0, -(effort.length + 1)) : normalized; + const friendlyBase = getFriendlyGptName(base); + return effort ? `${friendlyBase} (${effort})` : friendlyBase; + } + + return getShortModelName(generationModel); +} + +function getModelName( + transcript: DevinAgentTrajectory, + step: DevinStep, + session: DevinSessionMetadata | null, +): string { + const generationModel = firstPresentString( + step.metadata?.generation_model, + step.extra?.generation_model, + ); + const modelName = firstPresentString( + step.model_name, + transcript.agent?.model_name, + session?.model, + ) ?? DEFAULT_MODEL_NAME; + + return getDevinDisplayModelName(generationModel, modelName); +} + +function getToolNames(step: DevinStep): string[] { + return (step.tool_calls ?? []).map((call) => call.function_name); +} + +function normalizeContentPartMessage(contentPart: ContentPart) { + if (isTextContentPart(contentPart)) { + return contentPart.text; + } else { + return contentPart.source.path; + } +} + +function normalizeStepMessage(message: string | Array<ContentPart>): string { + if (Array.isArray(message)) { + return message.map((x) => normalizeContentPartMessage(x).trim()).join(" "); + } + return message.trim(); +} + +function getFirstUserMessageBeforeStep( + steps: DevinStep[], + index: number, +): string | null { + for (let i = index - 1; i >= 0; i--) { + const step = steps[i]; + if (!step?.metadata?.is_user_input) continue; + const message = step.message + ? normalizeStepMessage(step.message) + : undefined; + if (message) return message; + } + return null; +} + +function loadSessionMetadata( + dbPath: string, +): Map<string, DevinSessionMetadata> { + const sessions = new Map<string, DevinSessionMetadata>(); + let db: ReturnType<typeof openDatabase> | null = null; + try { + db = openDatabase(dbPath); + const rows = db.query<{ + id: string; + working_directory: string; + model: string; + title: string | null; + created_at: number; + last_activity_at: number; + hidden: number; + }>( + `SELECT id, working_directory, model, title, created_at, last_activity_at, hidden + FROM sessions`, + ); + for (const row of rows) { + if (!row.id) continue; + sessions.set(row.id, { + id: row.id, + workingDirectory: row.working_directory, + model: row.model, + title: row.title ?? undefined, + createdAt: parseNumericTimestamp(row.created_at), + lastActivityAt: parseNumericTimestamp(row.last_activity_at), + hidden: !!row.hidden, + }); + } + } catch { + return sessions; + } finally { + db?.close(); + } + return sessions; +} + +async function getCostFactor(): Promise<number | null> { + const configRate = (await readConfig()).devin?.acuUsdRate; + return isPositiveNumber(configRate) ? configRate : null; +} + +class DevinSessionParser implements SessionParser { + constructor( + private source: SessionSource, + private seenKeys: Set<string>, + private sessionMetadata: Map<string, DevinSessionMetadata>, + ) {} + + async *parse(): AsyncGenerator<ParsedProviderCall> { + const raw = await readSessionFile(this.source.path); + if (!raw) return; + + const transcript = parseTranscript(raw); + if (!transcript?.steps) return; + + const sessionId = getSessionId(this.source, transcript); + const session = this.sessionMetadata.get(sessionId) ?? null; + if (session?.hidden) return; + + const project = getProjectName(this.source, session); + const projectPath = getProjectPath(session); + const costFactor = await getCostFactor(); + if (costFactor === null) return; + + for (let index = 0; index < transcript.steps.length; index++) { + const step = transcript.steps[index]; + if (step.metadata?.is_user_input) continue; + + const usage = getUsage(step); + if (!usage) continue; + + const timestamp = getTimestamp(step, session) ?? ""; + + const deduplicationKey = `devin:${sessionId}:${step.step_id}`; + + if (this.seenKeys.has(deduplicationKey)) continue; + this.seenKeys.add(deduplicationKey); + + const model = getModelName(transcript, step, session); + const tools = getToolNames(step); + const userMessage = + getFirstUserMessageBeforeStep(transcript.steps, index) ?? ""; + + yield { + provider: DEVIN_PROVIDER_NAME, + model, + inputTokens: usage.inputTokens, + outputTokens: usage.outputTokens, + cacheCreationInputTokens: usage.cacheCreationInputTokens, + cacheReadInputTokens: usage.cacheReadInputTokens, + cachedInputTokens: usage.cacheReadInputTokens, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD: usage.committedAcuCost * costFactor, + tools, + bashCommands: [], + timestamp, + speed: "standard", + deduplicationKey, + userMessage, + sessionId, + project, + projectPath, + }; + } + } +} + +export function createDevinProvider(cliDir: string): Provider { + const sessionsDbPath = join(cliDir, DEVIN_SESSIONS_DB); + let sessionMetadata: Map<string, DevinSessionMetadata> | null = null; + + const getSessionMetadata = () => { + if (!sessionMetadata) sessionMetadata = loadSessionMetadata(sessionsDbPath); + return sessionMetadata; + }; + + return { + name: DEVIN_PROVIDER_NAME, + displayName: DEVIN_PROVIDER_DISPLAY_NAME, + + modelDisplayName(model: string): string { + return model; + }, + + toolDisplayName(rawTool: string): string { + return rawTool; + }, + + async discoverSessions(): Promise<SessionSource[]> { + if ((await getCostFactor()) === null) return []; + + const transcriptsDir = join(cliDir, DEVIN_TRANSCRIPTS_SUBDIR); + const entries = await readdir(transcriptsDir).catch(() => []); + const metadata = getSessionMetadata(); + const sources: SessionSource[] = []; + + for (const entry of entries) { + if (!entry.endsWith(".json")) continue; + + const filePath = join(transcriptsDir, entry); + const pathStats = await stat(filePath).catch(() => null); + + if (!pathStats?.isFile()) continue; + + const session = metadata.get(basename(filePath, ".json")) ?? null; + if (session?.hidden) continue; + + const tmpSource: SessionSource = { + path: filePath, + project: DEVIN_PROVIDER_NAME, + provider: DEVIN_PROVIDER_NAME, + }; + + const project = getProjectName(tmpSource, session); + + sources.push({ + path: filePath, + project, + provider: DEVIN_PROVIDER_NAME, + }); + } + + return sources; + }, + + createSessionParser( + source: SessionSource, + seenKeys: Set<string>, + ): SessionParser { + return new DevinSessionParser(source, seenKeys, getSessionMetadata()); + }, + }; +} + +export const devin = createDevinProvider(DEFAULT_DEVIN_CLI_DIR); diff --git a/src/providers/droid.ts b/src/providers/droid.ts new file mode 100644 index 0000000..4ec8cf6 --- /dev/null +++ b/src/providers/droid.ts @@ -0,0 +1,407 @@ +import { readdir, stat, readFile } from 'fs/promises' +import { join } from 'path' +import { homedir } from 'os' + +import { readSessionFile, readSessionLines } from '../fs-utils.js' +import { calculateCost, getShortModelName } from '../models.js' +import { extractBashCommands } from '../bash-utils.js' +import { normalizeContentBlocks } from '../content-utils.js' +import type { + Provider, + SessionSource, + SessionParser, + ParsedProviderCall, +} from './types.js' + +const toolNameMap: Record<string, string> = { + Read: 'Read', + Create: 'Create', + Edit: 'Edit', + MultiEdit: 'MultiEdit', + LS: 'LS', + Glob: 'Glob', + Grep: 'Grep', + Execute: 'Bash', + AskUser: 'AskUser', + TodoWrite: 'TodoWrite', + Skill: 'Skill', + Task: 'Agent', + WebSearch: 'WebSearch', + FetchUrl: 'FetchUrl', + GenerateDroid: 'GenerateDroid', + ExitSpecMode: 'ExitSpecMode', +} + +type DroidSettings = { + model?: string + tokenUsage?: { + inputTokens: number + outputTokens: number + cacheCreationTokens: number + cacheReadTokens: number + thinkingTokens: number + } +} + +type DroidContent = { + type: string + text?: string + name?: string + input?: Record<string, unknown> +} + +type DroidMessage = { + role: string + content?: DroidContent[] +} + +type DroidJsonlEntry = { + type: string + id?: string + timestamp?: string + message?: DroidMessage + title?: string + cwd?: string +} + +function getFactoryDir(): string { + return process.env['FACTORY_DIR'] ?? join(homedir(), '.factory') +} + + +// Strip Droid-specific wrapper to get the model's display name. +// e.g. "custom:GLM-5.1-[Proxy]-0" -> "GLM-5.1" +// Cost lookup is handled by codeburn's existing calculateCost/getCanonicalName +// which normalizes case and strips date suffixes automatically. +function stripModelPrefix(raw: string): string { + return raw + .replace(/^custom:/, '') + .replace(/\[.*?\]/g, '') + .replace(/-\d+$/, '') + .replace(/-+$/, '') + .replace(/^-/, '') +} + +function parseModelForDisplay(raw: string): string { + const stripped = stripModelPrefix(raw) + const lower = stripped.toLowerCase() + + if (lower.includes('opus')) return getShortModelName(stripped) + if (lower.includes('sonnet')) return getShortModelName(stripped) + if (lower.includes('haiku')) return getShortModelName(stripped) + if (lower.startsWith('gpt-')) return getShortModelName(stripped) + if (lower.startsWith('o3') || lower.startsWith('o4')) return getShortModelName(stripped) + if (lower.startsWith('gemini')) return getShortModelName(stripped) + + return stripped +} + +/** + * Extract meaningful shell command names from a Droid Execute call. + * Droid frequently passes multi-line scripts (python -c "...", heredocs, etc.) + * where splitting on ;/&&/| produces noise tokens like '}', 'await', 'import'. + * Instead, extract only the primary command from each logical line. + */ +function extractDroidBashCommands(command: string): string[] { + if (!command || !command.trim()) return [] + + const firstLine = command.split('\n')[0]!.trim() + return extractBashCommands(firstLine) +} + +function createParser( + source: SessionSource, + seenKeys: Set<string>, +): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + const content = await readSessionFile(source.path) + if (content === null) return + + // Read the companion settings file for token usage + const settingsPath = source.path.replace(/\.jsonl$/, '.settings.json') + let settings: DroidSettings = {} + try { + const raw = await readFile(settingsPath, 'utf-8') + settings = JSON.parse(raw) as DroidSettings + } catch { + // No settings file or parse error + } + + const lines = content.split('\n').filter(l => l.trim()) + let sessionId = '' + let sessionModelDisplay = settings.model ? stripModelPrefix(settings.model) : 'unknown' + let currentUserMessage = '' + + // Collect all assistant messages with their tools + const assistantCalls: Array<{ + id: string + timestamp: string + tools: string[] + bashCommands: string[] + }> = [] + + let pendingTools: string[] = [] + let pendingBashCommands: string[] = [] + + for (const line of lines) { + let entry: DroidJsonlEntry + try { + entry = JSON.parse(line) as DroidJsonlEntry + } catch { + continue + } + + if (entry.type === 'session_start') { + sessionId = entry.id ?? '' + continue + } + + if (entry.type !== 'message' || !entry.message) continue + + const msg = entry.message + + if (msg.role === 'user') { + // Extract user text from content + const texts = normalizeContentBlocks(msg.content) + .filter(c => c.type === 'text' && c.text) + .map(c => c.text!) + .filter(Boolean) + // Skip system-reminder-only messages + const nonSystemTexts = texts.filter(t => !t.startsWith('<system-reminder>')) + if (nonSystemTexts.length > 0) { + currentUserMessage = nonSystemTexts.join(' ').slice(0, 500) + } + continue + } + + if (msg.role === 'assistant') { + const toolUses = normalizeContentBlocks(msg.content).filter(c => c.type === 'tool_use') + + for (const tu of toolUses) { + const toolName = tu.name ?? '' + pendingTools.push(toolNameMap[toolName] ?? toolName) + + if (toolName === 'Execute' && tu.input && typeof tu.input['command'] === 'string') { + pendingBashCommands.push(...extractDroidBashCommands(tu.input['command'] as string)) + } + } + + // Check if this assistant message has any text content (non-thinking) + const hasText = normalizeContentBlocks(msg.content).some(c => c.type === 'text' && c.text) + + // Only emit a call entry if there are tools or substantial text + if (pendingTools.length > 0 || hasText) { + assistantCalls.push({ + id: entry.id ?? `msg-${assistantCalls.length}`, + timestamp: entry.timestamp ?? '', + tools: [...pendingTools], + bashCommands: [...pendingBashCommands], + }) + pendingTools = [] + pendingBashCommands = [] + } + continue + } + } + + if (assistantCalls.length === 0) return + + // KNOWN LIMITATION: Droid records token usage only at session level + // (settings.tokenUsage), not per-message. We split evenly across the + // emitted assistant calls and price all of them at settings.model + // (the latest model the session used). For sessions where the user + // switched models mid-stream, costs are approximate — we have no + // ground-truth breakdown to attribute tokens per model. + const totalTokens = settings.tokenUsage + if (!totalTokens) return + + const totalInput = totalTokens.inputTokens ?? 0 + const totalOutput = totalTokens.outputTokens ?? 0 + const totalCacheCreation = totalTokens.cacheCreationTokens ?? 0 + const totalCacheRead = totalTokens.cacheReadTokens ?? 0 + const totalThinking = totalTokens.thinkingTokens ?? 0 + const numCalls = assistantCalls.length + + // Distribute evenly across calls + const inputPerCall = Math.floor(totalInput / numCalls) + const outputPerCall = Math.floor(totalOutput / numCalls) + const cacheCreationPerCall = Math.floor(totalCacheCreation / numCalls) + const cacheReadPerCall = Math.floor(totalCacheRead / numCalls) + const thinkingPerCall = Math.floor(totalThinking / numCalls) + + for (let i = 0; i < assistantCalls.length; i++) { + const call = assistantCalls[i] + + // Assign remainder to the last call + const isLast = i === assistantCalls.length - 1 + const inputTokens = isLast + ? totalInput - inputPerCall * (numCalls - 1) + : inputPerCall + const outputTokens = isLast + ? totalOutput - outputPerCall * (numCalls - 1) + : outputPerCall + const cacheCreationTokens = isLast + ? totalCacheCreation - cacheCreationPerCall * (numCalls - 1) + : cacheCreationPerCall + const cacheReadTokens = isLast + ? totalCacheRead - cacheReadPerCall * (numCalls - 1) + : cacheReadPerCall + const thinkingTokens = isLast + ? totalThinking - thinkingPerCall * (numCalls - 1) + : thinkingPerCall + + const dedupKey = `droid:${sessionId}:${call.id}` + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + const costUSD = calculateCost( + sessionModelDisplay.toLowerCase(), + inputTokens, + outputTokens + thinkingTokens, + cacheCreationTokens, + cacheReadTokens, + 0, + ) + + // Use the call's timestamp, or session_start timestamp + const timestamp = call.timestamp || '' + + yield { + provider: 'droid', + model: sessionModelDisplay, + inputTokens, + outputTokens, + cacheCreationInputTokens: cacheCreationTokens, + cacheReadInputTokens: cacheReadTokens, + cachedInputTokens: cacheReadTokens, + reasoningTokens: thinkingTokens, + webSearchRequests: 0, + costUSD, + tools: call.tools, + bashCommands: call.bashCommands, + timestamp, + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: i === 0 ? currentUserMessage : '', + sessionId, + } + } + }, + } +} + +function isInternalSession(cwd: string, factoryDir: string): boolean { + // Skip sessions whose cwd is the .factory directory itself (internal housekeeping) + const normalized = cwd.replace(/\/+$/, '') + return normalized === factoryDir +} + +function deriveProjectName(cwd: string): string { + const normalized = cwd.replace(/\/+$/, '') + const home = homedir() + + // Strip home directory prefix + let relative = normalized.startsWith(home) + ? normalized.slice(home.length).replace(/^\/+/, '') + : normalized.replace(/^\/+/, '') + + if (!relative) relative = '~' + + // Walk from the right: use the "projects/<name>" segment if present, + // otherwise the last meaningful path component. + const parts = relative.split('/') + const projectsIdx = parts.lastIndexOf('projects') + if (projectsIdx !== -1 && projectsIdx + 1 < parts.length) { + return parts.slice(projectsIdx + 1).join('/') + } + + return parts.join('/') +} + +async function readFirstJsonlLine(filePath: string): Promise<string | null> { + for await (const line of readSessionLines(filePath)) { + return line + } + return null +} + +async function discoverSessionsInDir( + sessionsDir: string, + factoryDir: string, +): Promise<SessionSource[]> { + const sources: SessionSource[] = [] + + let entries: string[] + try { + entries = await readdir(sessionsDir) + } catch { + return sources + } + + for (const entry of entries) { + const subDir = join(sessionsDir, entry) + const s = await stat(subDir).catch(() => null) + if (!s?.isDirectory()) continue + + const files = await readdir(subDir).catch(() => [] as string[]) + for (const file of files) { + if (!file.endsWith('.jsonl')) continue + const filePath = join(subDir, file) + + const firstLine = await readFirstJsonlLine(filePath) + if (!firstLine?.trim()) continue + + let startEntry: DroidJsonlEntry + try { + startEntry = JSON.parse(firstLine) as DroidJsonlEntry + } catch { + continue + } + + if (startEntry.type !== 'session_start') continue + + const cwd = startEntry.cwd ?? entry + if (isInternalSession(cwd, factoryDir)) continue + + sources.push({ + path: filePath, + project: deriveProjectName(cwd), + provider: 'droid', + }) + } + } + + return sources +} + +export function createDroidProvider(factoryDir?: string): Provider { + const base = factoryDir ?? getFactoryDir() + const sessionsDir = join(base, 'sessions') + + return { + name: 'droid', + displayName: 'Droid', + + modelDisplayName(model: string): string { + return parseModelForDisplay(model) + }, + + toolDisplayName(rawTool: string): string { + return toolNameMap[rawTool] ?? rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + return discoverSessionsInDir(sessionsDir, base) + }, + + createSessionParser( + source: SessionSource, + seenKeys: Set<string>, + ): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const droid = createDroidProvider() diff --git a/src/providers/forge.ts b/src/providers/forge.ts new file mode 100644 index 0000000..27931e9 --- /dev/null +++ b/src/providers/forge.ts @@ -0,0 +1,284 @@ +import { existsSync } from 'fs' +import { homedir } from 'os' +import { join } from 'path' + +import { extractBashCommands } from '../bash-utils.js' +import { calculateCost } from '../models.js' +import { getSqliteLoadError, isSqliteAvailable, openDatabase, type SqliteDatabase } from '../sqlite.js' +import type { ParsedProviderCall, Provider, SessionParser, SessionSource } from './types.js' + +type ConversationRow = { + conversation_id: string + title: string | null + workspace_id: number | string + context: string | null + created_at: string | null + updated_at: string | null +} + +type DiscoveryRow = { + conversation_id: string + title: string | null + workspace_id: string +} + +type ContextMessage = { + message?: { + text?: { + role?: unknown + content?: unknown + model?: unknown + tool_calls?: unknown + } + } + usage?: unknown +} + +const DEFAULT_DB_PATH = join(homedir(), '.forge', '.forge.db') + +function validateSchema(db: SqliteDatabase): boolean { + try { + db.query('SELECT conversation_id, title, CAST(workspace_id AS TEXT) AS workspace_id, context, created_at, updated_at FROM conversations LIMIT 1') + return true + } catch { + return false + } +} + +function sqliteTimestampToIso(value: string | null | undefined): string { + if (!value) return new Date(0).toISOString() + + const match = value.match(/^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})(?:\.(\d+))?$/) + if (match) { + const ms = (match[3] ?? '').padEnd(3, '0').slice(0, 3) + const parsed = new Date(`${match[1]}T${match[2]}.${ms}Z`) + if (!Number.isNaN(parsed.getTime())) return parsed.toISOString() + } + + const parsed = new Date(value) + return Number.isNaN(parsed.getTime()) ? new Date(0).toISOString() : parsed.toISOString() +} + +function actual(value: unknown): number { + if (!value || typeof value !== 'object') return 0 + const raw = (value as Record<string, unknown>)['actual'] + return typeof raw === 'number' && Number.isFinite(raw) ? raw : 0 +} + +function usageActual(usage: unknown, key: string): number { + if (!usage || typeof usage !== 'object') return 0 + return actual((usage as Record<string, unknown>)[key]) +} + +function mapToolName(name: string): string { + switch (name) { + case 'shell': + case 'bash': + return 'Bash' + case 'read': + case 'Read': + return 'Read' + case 'write': + case 'Write': + return 'Write' + case 'patch': + case 'Edit': + case 'edit': + return 'Edit' + case 'fs_search': + case 'grep': + return 'Grep' + case 'task': + case 'dispatch_agent': + return 'Agent' + default: + return name + } +} + +function pushUnique(values: string[], value: string): void { + if (!values.includes(value)) values.push(value) +} + +function toolCalls(value: unknown): Record<string, unknown>[] { + return Array.isArray(value) ? value.filter(v => v && typeof v === 'object') as Record<string, unknown>[] : [] +} + +function extractToolsAndCommands(calls: Record<string, unknown>[]): { tools: string[]; bashCommands: string[]; firstCallId?: string } { + const tools: string[] = [] + const bashCommands: string[] = [] + let firstCallId: string | undefined + + for (const call of calls) { + const rawName = call['name'] + if (typeof rawName !== 'string') continue + if (!firstCallId && typeof call['call_id'] === 'string') firstCallId = call['call_id'] + + const tool = mapToolName(rawName) + pushUnique(tools, tool) + + if (tool === 'Bash') { + const args = call['arguments'] + if (args && typeof args === 'object') { + const command = (args as Record<string, unknown>)['command'] + if (typeof command === 'string') { + for (const cmd of extractBashCommands(command)) pushUnique(bashCommands, cmd) + } + } + } + } + + return { tools, bashCommands, firstCallId } +} + +function splitSourcePath(path: string): { dbPath: string; conversationId: string } | null { + const idx = path.lastIndexOf(':') + if (idx < 0) return null + return { dbPath: path.slice(0, idx), conversationId: path.slice(idx + 1) } +} + +function createParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + if (!isSqliteAvailable()) { + process.stderr.write(getSqliteLoadError() + '\n') + return + } + + const split = splitSourcePath(source.path) + if (!split) return + + let db: SqliteDatabase + try { + db = openDatabase(split.dbPath) + } catch { + return + } + + try { + if (!validateSchema(db)) return + const rows = db.query<ConversationRow>( + `SELECT conversation_id, title, CAST(workspace_id AS TEXT) AS workspace_id, context, created_at, updated_at + FROM conversations + WHERE conversation_id = ?`, + [split.conversationId], + ) + const row = rows[0] + if (!row?.context) return + + let parsed: unknown + try { + parsed = JSON.parse(row.context) + } catch { + return + } + const messages = Array.isArray((parsed as { messages?: unknown }).messages) + ? (parsed as { messages: ContextMessage[] }).messages + : [] + + let userMessage = '' + for (let i = 0; i < messages.length; i++) { + const text = messages[i]?.message?.text + const role = typeof text?.role === 'string' ? text.role.toLowerCase() : '' + const content = typeof text?.content === 'string' ? text.content : '' + + if (role === 'user') { + userMessage = content.length > 500 ? content.slice(0, 500) : content + continue + } + if (role !== 'assistant') continue + + const promptTokens = usageActual(messages[i]?.usage, 'prompt_tokens') + const outputTokens = usageActual(messages[i]?.usage, 'completion_tokens') + const cachedInputTokens = usageActual(messages[i]?.usage, 'cached_tokens') + const inputTokens = Math.max(0, promptTokens - cachedInputTokens) + if (inputTokens === 0 && outputTokens === 0) continue + + const model = typeof text?.model === 'string' ? text.model : 'unknown' + const calls = toolCalls(text?.tool_calls) + const { tools, bashCommands, firstCallId } = extractToolsAndCommands(calls) + const stableId = firstCallId ?? `${model}:${promptTokens}:${outputTokens}:${i}` + const deduplicationKey = `forge:${row.conversation_id}:${stableId}` + if (seenKeys.has(deduplicationKey)) continue + seenKeys.add(deduplicationKey) + yield { + provider: 'forge', + model, + inputTokens, + outputTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: cachedInputTokens, + cachedInputTokens, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD: calculateCost(model, inputTokens, outputTokens, 0, cachedInputTokens, 0), + tools, + bashCommands, + timestamp: sqliteTimestampToIso(row.updated_at ?? row.created_at), + speed: 'standard', + deduplicationKey, + userMessage, + sessionId: row.conversation_id, + } + } + } finally { + db.close() + } + }, + } +} + +async function discoverFromDb(dbPath: string): Promise<SessionSource[]> { + if (!existsSync(dbPath)) return [] + + let db: SqliteDatabase + try { + db = openDatabase(dbPath) + } catch { + return [] + } + + try { + if (!validateSchema(db)) return [] + const rows = db.query<DiscoveryRow>( + `SELECT conversation_id, title, CAST(workspace_id AS TEXT) AS workspace_id + FROM conversations + WHERE context IS NOT NULL`, + ) + return rows.map(row => ({ + path: `${dbPath}:${row.conversation_id}`, + project: row.title ?? String(row.workspace_id), + provider: 'forge', + })) + } catch { + return [] + } finally { + db.close() + } +} + +export function createForgeProvider(dbPath = DEFAULT_DB_PATH): Provider { + return { + name: 'forge', + displayName: 'Forge', + + modelDisplayName(model: string): string { + return model + }, + + toolDisplayName(rawTool: string): string { + return rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + if (!isSqliteAvailable()) return [] + return discoverFromDb(dbPath) + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const forge = createForgeProvider() diff --git a/src/providers/gemini.ts b/src/providers/gemini.ts new file mode 100644 index 0000000..e0333f0 --- /dev/null +++ b/src/providers/gemini.ts @@ -0,0 +1,285 @@ +import { readdir, stat } from 'fs/promises' +import { join } from 'path' +import { homedir } from 'os' + +import { readSessionFile } from '../fs-utils.js' +import { calculateCost } from '../models.js' +import { extractBashCommands } from '../bash-utils.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' + +const toolNameMap: Record<string, string> = { + read_file: 'Read', + write_file: 'Write', + edit_file: 'Edit', + create_file: 'Write', + delete_file: 'Delete', + list_dir: 'LS', + grep_search: 'Grep', + search_files: 'Grep', + find_files: 'Glob', + run_command: 'Bash', + web_search: 'WebSearch', + ReadFile: 'Read', + WriteFile: 'Write', + EditFile: 'Edit', + ListDir: 'LS', + SearchText: 'Grep', + Shell: 'Bash', +} + +type GeminiTokens = { + input?: number + output?: number + cached?: number + thoughts?: number + tool?: number + total?: number +} + +type GeminiToolCall = { + id: string + name: string + args: Record<string, unknown> + status?: string + displayName?: string +} + +type GeminiMessage = { + id: string + timestamp: string + type: 'user' | 'gemini' | 'info' + content: string | Array<{ text: string }> + tokens?: GeminiTokens + model?: string + toolCalls?: GeminiToolCall[] + thoughts?: unknown[] +} + +type GeminiSession = { + sessionId: string + projectHash?: string + startTime: string + lastUpdated?: string + messages: GeminiMessage[] + kind?: string +} + +function parseSession(data: GeminiSession, seenKeys: Set<string>): ParsedProviderCall[] { + const results: ParsedProviderCall[] = [] + + let lastUserMessage = '' + let turnOrdinal = 0 + let currentTurnId = `${data.sessionId}:prelude` + let geminiOrdinal = 0 + + for (const msg of data.messages) { + if (msg.type === 'user') { + if (Array.isArray(msg.content)) { + lastUserMessage = msg.content.map(c => c.text).join(' ').slice(0, 500) + } else if (typeof msg.content === 'string') { + lastUserMessage = msg.content.slice(0, 500) + } + currentTurnId = `${data.sessionId}:turn-${turnOrdinal++}` + continue + } + + if (msg.type !== 'gemini' || !msg.tokens || !msg.model) continue + + const t = msg.tokens + const totalInput = t.input ?? 0 + const totalOutput = t.output ?? 0 + const totalCached = t.cached ?? 0 + const totalThoughts = t.thoughts ?? 0 + if (totalInput === 0 && totalOutput === 0 && totalCached === 0 && totalThoughts === 0) continue + + const messageKey = msg.id || `idx-${geminiOrdinal}` + geminiOrdinal++ + const dedupKey = `gemini:${data.sessionId}:${messageKey}` + if (seenKeys.has(dedupKey)) continue + + const tools: string[] = [] + const bashCommands: string[] = [] + + if (msg.toolCalls) { + for (const tc of msg.toolCalls) { + const mapped = toolNameMap[tc.displayName ?? ''] ?? toolNameMap[tc.name] ?? tc.displayName ?? tc.name + tools.push(mapped) + if (mapped === 'Bash' && tc.args && typeof tc.args.command === 'string') { + bashCommands.push(...extractBashCommands(tc.args.command)) + } + } + } + + // Gemini's `input` count includes `cached` tokens as a subset, so fresh + // input must subtract cached to avoid double-charging at both rates. + const freshInput = Math.max(0, totalInput - totalCached) + + const tsDate = new Date(msg.timestamp || data.startTime) + if (isNaN(tsDate.getTime()) || tsDate.getTime() < 1_000_000_000_000) continue + + seenKeys.add(dedupKey) + + // Gemini bills thoughts at the output token rate; calculateCost does not + // accept a reasoning parameter, so fold thoughts into the output count for + // pricing while keeping outputTokens / reasoningTokens reported separately. + const costUSD = calculateCost(msg.model, freshInput, totalOutput + totalThoughts, 0, totalCached, 0) + + results.push({ + provider: 'gemini', + model: msg.model, + inputTokens: freshInput, + outputTokens: totalOutput, + cacheCreationInputTokens: 0, + cacheReadInputTokens: totalCached, + cachedInputTokens: totalCached, + reasoningTokens: totalThoughts, + webSearchRequests: 0, + costUSD, + tools: [...new Set(tools)], + bashCommands: [...new Set(bashCommands)], + timestamp: tsDate.toISOString(), + speed: 'standard', + deduplicationKey: dedupKey, + turnId: currentTurnId, + userMessage: lastUserMessage, + sessionId: data.sessionId, + }) + } + + return results +} + +function parseJsonl(raw: string): GeminiSession | null { + const lines = raw.split('\n').filter(l => l.trim()) + if (lines.length === 0) return null + + let sessionId = '' + let startTime = '' + let projectHash: string | undefined + let lastUpdated: string | undefined + let kind: string | undefined + const messages: GeminiMessage[] = [] + + for (const line of lines) { + let obj: Record<string, unknown> + try { + obj = JSON.parse(line) + } catch { + continue + } + if (obj['$set'] !== undefined) continue + if (obj['sessionId'] && obj['startTime'] && !sessionId) { + sessionId = obj['sessionId'] as string + startTime = obj['startTime'] as string + projectHash = obj['projectHash'] as string | undefined + lastUpdated = obj['lastUpdated'] as string | undefined + kind = obj['kind'] as string | undefined + } else if (obj['id'] && obj['type']) { + messages.push(obj as unknown as GeminiMessage) + } + } + + if (!sessionId) return null + return { sessionId, projectHash, startTime, lastUpdated, kind, messages } +} + +function createParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + const raw = await readSessionFile(source.path) + if (raw === null) return + + let data: GeminiSession | null = null + + // Try single JSON first (Gemini CLI <=0.38), then JSONL (>=0.39) + try { + const parsed = JSON.parse(raw) + if (parsed.messages && parsed.sessionId) { + data = parsed + } + } catch { /* not single JSON */ } + + if (!data) { + data = parseJsonl(raw) + } + + if (!data?.messages || !data.sessionId) return + + const calls = parseSession(data, seenKeys) + for (const call of calls) { + yield call + } + }, + } +} + +function getGeminiTmpDir(): string { + return join(homedir(), '.gemini', 'tmp') +} + +async function discoverSessions(): Promise<SessionSource[]> { + const sources: SessionSource[] = [] + const tmpDir = getGeminiTmpDir() + + let projectDirs: string[] + try { + const entries = await readdir(tmpDir, { withFileTypes: true }) + projectDirs = entries.filter(e => e.isDirectory()).map(e => e.name) + } catch { + return sources + } + + for (const project of projectDirs) { + const chatsDir = join(tmpDir, project, 'chats') + let files: string[] + try { + const entries = await readdir(chatsDir) + files = entries.filter(f => f.startsWith('session-') && (f.endsWith('.json') || f.endsWith('.jsonl'))) + } catch { + continue + } + + for (const file of files) { + const filePath = join(chatsDir, file) + const s = await stat(filePath).catch(() => null) + if (!s?.isFile()) continue + sources.push({ path: filePath, project, provider: 'gemini' }) + } + } + + return sources +} + +export function createGeminiProvider(): Provider { + return { + name: 'gemini', + displayName: 'Gemini', + + modelDisplayName(model: string): string { + if (model === 'gemini-auto') return 'Gemini (auto)' + const display: Record<string, string> = { + 'gemini-3-flash-preview': 'Gemini 3 Flash', + 'gemini-3.5-flash': 'Gemini 3.5 Flash', + 'gemini-3.1-pro-preview': 'Gemini 3.1 Pro', + 'gemini-2.5-pro': 'Gemini 2.5 Pro', + 'gemini-2.5-flash': 'Gemini 2.5 Flash', + 'gemini-2.0-flash': 'Gemini 2.0 Flash', + } + return display[model] ?? model + }, + + toolDisplayName(rawTool: string): string { + return toolNameMap[rawTool] ?? rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + return discoverSessions() + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const gemini = createGeminiProvider() diff --git a/src/providers/goose.ts b/src/providers/goose.ts new file mode 100644 index 0000000..7109709 --- /dev/null +++ b/src/providers/goose.ts @@ -0,0 +1,290 @@ +import { join } from 'path' +import { homedir, platform } from 'os' + +import { calculateCost, getShortModelName } from '../models.js' +import { extractBashCommands } from '../bash-utils.js' +import { isSqliteAvailable, getSqliteLoadError, openDatabase, blobToText, type SqliteDatabase } from '../sqlite.js' +import type { ToolCall } from '../types.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' + +type SessionRow = { + id: string + name: string + working_dir: string | null + created_at: string | null + updated_at: string | null + accumulated_input_tokens: number | null + accumulated_output_tokens: number | null + provider_name: string | null + model_config_json: Uint8Array | string | null +} + +type ModelConfig = { + model_name?: string + reasoning?: boolean +} + +type MessageRow = { + message_id: string + role: string + content_json: Uint8Array | string + created_timestamp: number +} + +type ContentItem = { + type: string + toolCall?: { value?: { name?: string; arguments?: Record<string, unknown> } } +} + +const toolNameMap: Record<string, string> = { + developer__shell: 'Bash', + developer__text_editor: 'Edit', + developer__read_file: 'Read', + developer__write_file: 'Write', + developer__list_directory: 'LS', + developer__search_files: 'Grep', + computercontroller__shell: 'Bash', +} + +function sanitize(dir: string): string { + return dir.replace(/^\//, '').replace(/\//g, '-') +} + +function getDbPath(): string { + const root = process.env['GOOSE_PATH_ROOT'] + if (root) return join(root, 'data', 'sessions', 'sessions.db') + + const p = platform() + if (p === 'darwin' || p === 'linux') { + const base = process.env['XDG_DATA_HOME'] ?? join(homedir(), '.local', 'share') + return join(base, 'goose', 'sessions', 'sessions.db') + } + return join(homedir(), 'AppData', 'Roaming', 'Block', 'goose', 'sessions', 'sessions.db') +} + +function validateSchema(db: SqliteDatabase): boolean { + try { + db.query<{ cnt: number }>("SELECT COUNT(*) as cnt FROM sessions LIMIT 1") + db.query<{ cnt: number }>("SELECT COUNT(*) as cnt FROM messages LIMIT 1") + return true + } catch { + return false + } +} + +function parseModelConfig(raw: string | null): ModelConfig { + if (!raw) return {} + try { + return JSON.parse(raw) as ModelConfig + } catch { + return {} + } +} + +function extractToolsFromMessages(db: SqliteDatabase, sessionId: string): { tools: string[]; bashCommands: string[]; toolSequence: ToolCall[][] } { + const tools: string[] = [] + const bashCommands: string[] = [] + const seen = new Set<string>() + const toolSequence: ToolCall[][] = [] + + try { + const rows = db.query<{ content_json: Uint8Array | string }>( + "SELECT CAST(content_json AS BLOB) AS content_json FROM messages WHERE session_id = ? AND role = 'assistant' AND content_json LIKE '%toolRequest%' ORDER BY created_timestamp ASC", + [sessionId], + ) + + for (const row of rows) { + let items: ContentItem[] + try { + items = JSON.parse(blobToText(row.content_json)) as ContentItem[] + } catch { + continue + } + const msgCalls: ToolCall[] = [] + for (const item of items) { + if (item.type !== 'toolRequest') continue + const rawName = item.toolCall?.value?.name ?? '' + if (!rawName) continue + const mapped = toolNameMap[rawName] ?? rawName.split('__').pop() ?? rawName + if (!seen.has(mapped)) { + seen.add(mapped) + tools.push(mapped) + } + const call: ToolCall = { tool: mapped } + const args = item.toolCall?.value?.arguments + if (args && typeof args === 'object') { + const fp = (args as Record<string, unknown>)['file_path'] + if (typeof fp === 'string') call.file = fp + const cmd = (args as Record<string, unknown>)['command'] + if (typeof cmd === 'string') call.command = cmd + } + msgCalls.push(call) + if (mapped === 'Bash') { + const cmd = item.toolCall?.value?.arguments?.command + if (typeof cmd === 'string') { + for (const c of extractBashCommands(cmd)) { + if (!bashCommands.includes(c)) bashCommands.push(c) + } + } + } + } + if (msgCalls.length > 0) toolSequence.push(msgCalls) + } + } catch { /* best-effort */ } + + return { tools, bashCommands, toolSequence } +} + +function getFirstUserMessage(db: SqliteDatabase, sessionId: string): string { + try { + const rows = db.query<{ content_json: Uint8Array | string }>( + "SELECT CAST(content_json AS BLOB) AS content_json FROM messages WHERE session_id = ? AND role = 'user' ORDER BY created_timestamp ASC LIMIT 1", + [sessionId], + ) + if (rows.length === 0) return '' + const items = JSON.parse(blobToText(rows[0]!.content_json)) as ContentItem[] + const text = items.find(i => i.type === 'text') as { text?: string } | undefined + return (text?.text ?? '').slice(0, 500) + } catch { + return '' + } +} + +function createParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + if (!isSqliteAvailable()) { + process.stderr.write(getSqliteLoadError() + '\n') + return + } + + const segments = source.path.split(':') + const sessionId = segments[segments.length - 1]! + const dbPath = segments.slice(0, -1).join(':') + + let db: SqliteDatabase + try { + db = openDatabase(dbPath) + } catch (err) { + process.stderr.write(`codeburn: cannot open Goose database: ${err instanceof Error ? err.message : err}\n`) + return + } + + try { + if (!validateSchema(db)) return + + const rows = db.query<SessionRow>( + 'SELECT id, name, working_dir, created_at, updated_at, accumulated_input_tokens, accumulated_output_tokens, provider_name, CAST(model_config_json AS BLOB) AS model_config_json FROM sessions WHERE id = ?', + [sessionId], + ) + if (rows.length === 0) return + + const session = rows[0]! + const inputTokens = session.accumulated_input_tokens ?? 0 + const outputTokens = session.accumulated_output_tokens ?? 0 + if (inputTokens === 0 && outputTokens === 0) return + + const dedupKey = `goose:${sessionId}` + if (seenKeys.has(dedupKey)) return + seenKeys.add(dedupKey) + + const config = parseModelConfig(blobToText(session.model_config_json)) + const model = config.model_name ?? 'unknown' + const costUSD = calculateCost(model, inputTokens, outputTokens, 0, 0, 0) + + const { tools, bashCommands, toolSequence } = extractToolsFromMessages(db, sessionId) + const userMessage = getFirstUserMessage(db, sessionId) + + const raw = session.updated_at || session.created_at || '' + let ts = new Date(raw) + if (isNaN(ts.getTime())) ts = new Date(raw + 'Z') + if (isNaN(ts.getTime())) ts = new Date() + + yield { + provider: 'goose', + model, + inputTokens, + outputTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + tools, + bashCommands, + toolSequence: toolSequence.length > 1 ? toolSequence : undefined, + timestamp: ts.toISOString(), + speed: 'standard', + deduplicationKey: dedupKey, + userMessage, + sessionId, + } + } finally { + db.close() + } + }, + } +} + +async function discoverFromDb(dbPath: string): Promise<SessionSource[]> { + let db: SqliteDatabase + try { + db = openDatabase(dbPath) + } catch { + return [] + } + + try { + const rows = db.query<SessionRow>( + 'SELECT id, name, working_dir, created_at, updated_at, accumulated_input_tokens, accumulated_output_tokens, provider_name, CAST(model_config_json AS BLOB) AS model_config_json FROM sessions ORDER BY updated_at DESC', + ) + + return rows + .filter(r => (r.accumulated_input_tokens ?? 0) > 0 || (r.accumulated_output_tokens ?? 0) > 0) + .map(row => ({ + path: `${dbPath}:${row.id}`, + project: row.working_dir ? sanitize(row.working_dir) : 'goose', + provider: 'goose', + })) + } catch { + return [] + } finally { + db.close() + } +} + +const modelDisplayNames: Record<string, string> = { + 'gpt-5.5': 'GPT-5.5', + 'gpt-5.4': 'GPT-5.4', + 'gpt-5.4-mini': 'GPT-5.4 Mini', + 'gpt-4o': 'GPT-4o', + 'gpt-4o-mini': 'GPT-4o Mini', +} + +export function createGooseProvider(): Provider { + return { + name: 'goose', + displayName: 'Goose', + + modelDisplayName(model: string): string { + return modelDisplayNames[model] ?? getShortModelName(model) + }, + + toolDisplayName(rawTool: string): string { + return toolNameMap[rawTool] ?? rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + if (!isSqliteAvailable()) return [] + const dbPath = getDbPath() + return discoverFromDb(dbPath) + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const goose = createGooseProvider() diff --git a/src/providers/grok.ts b/src/providers/grok.ts new file mode 100644 index 0000000..7e347f9 --- /dev/null +++ b/src/providers/grok.ts @@ -0,0 +1,279 @@ +import { readdir, stat } from 'fs/promises' +import { basename, dirname, join } from 'path' +import { homedir } from 'os' + +import { readSessionFile } from '../fs-utils.js' +import { calculateCost, getShortModelName } from '../models.js' +import { extractBashCommands } from '../bash-utils.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' + +// Grok Build (xAI's coding CLI) stores one session per directory at +// <grok-home>/sessions/<url-encoded-cwd>/<uuid>/, where grok-home is $GROK_HOME +// or ~/.grok. Each session dir holds summary.json, signals.json, and the ACP +// log updates.jsonl. +// +// Grok does NOT record billable input/output tokens. signals.json carries +// `contextTokensUsed` (current context fill) and updates.jsonl carries a running +// `_meta.totalTokens` per streamed chunk; there is no per-call input/output +// split. We reconstruct an ESTIMATE from the per-turn totalTokens curve. Agentic +// turns re-send the growing context every call, and that re-sent context is +// cached server-side, so we bill the unique context (summed per compaction segment) as fresh input, +// the re-sent remainder as cache reads, and the per-turn growth as output. Cost +// is flagged estimated; grok-build is priced via its grok-build-0.1 alias. + +const toolNameMap: Record<string, string> = { + bash: 'Bash', + run_terminal_command: 'Bash', + read_file: 'Read', + read: 'Read', + write_file: 'Write', + edit_file: 'Edit', + edit: 'Edit', + list_dir: 'Glob', + glob: 'Glob', + grep: 'Grep', + search: 'WebSearch', + web_search: 'WebSearch', + fetch: 'WebFetch', + task: 'Agent', + search_replace: 'Edit', + todo_write: 'TodoWrite', + spawn_subagent: 'Agent', +} + +function defaultSessionsDir(): string { + const home = process.env['GROK_HOME'] ?? join(homedir(), '.grok') + return join(home, 'sessions') +} + +type GrokSummary = { + info?: { id?: string; cwd?: string } + created_at?: string + updated_at?: string + last_active_at?: string + current_model_id?: string + session_summary?: string + generated_title?: string +} + +type GrokSignals = { + primaryModelId?: string + modelsUsed?: string[] + toolsUsed?: string[] +} + +async function readJson<T>(path: string): Promise<T | null> { + const content = await readSessionFile(path) + if (content === null) return null + try { + return JSON.parse(content) as T + } catch { + return null + } +} + +function safeDecode(name: string): string { + try { + return decodeURIComponent(name) + } catch { + return name + } +} + +// updates.jsonl is one ACP JSON-RPC notification per line; streamed chunks carry +// params._meta.{totalTokens, promptId}. totalTokens is the running context size, +// so grouping by promptId (one per turn) gives each turn's first/last value. +type GrokUpdate = { + params?: { + _meta?: { totalTokens?: number; promptId?: string } + update?: { sessionUpdate?: string; title?: string; rawInput?: { command?: unknown; subagent_type?: unknown } } + } +} + +// Single pass over updates.jsonl: per-turn totalTokens for the cost estimate, +// plus the real tool calls (each tool_call's title -> a tool, and +// run_terminal_command's rawInput.command -> shell commands). +function parseUpdates(updates: string): { + input: number + cacheRead: number + output: number + tools: string[] + bashCommands: string[] + subagentTypes: string[] +} { + const turns = new Map<string, { first: number; last: number }>() + const tools: string[] = [] + const bashCommands: string[] = [] + const subagentTypes: string[] = [] + // Compaction-aware fresh input: a large drop in totalTokens means the context + // was compacted and rebuilt, so we sum each segment's peak rather than the + // single global peak (which would lose everything before the last compaction). + let prevTotal = -1 + let segmentPeak = 0 + let inputFresh = 0 + + for (const line of updates.split('\n')) { + if (!line.trim()) continue + let params: GrokUpdate['params'] + try { + params = (JSON.parse(line) as GrokUpdate).params + } catch { + continue + } + if (!params) continue + + const total = params._meta?.totalTokens + if (typeof total === 'number') { + if (prevTotal >= 0 && total < prevTotal * 0.5) { + inputFresh += segmentPeak // close the segment a compaction just ended + segmentPeak = 0 + } + if (total > segmentPeak) segmentPeak = total + prevTotal = total + + const promptId = params._meta?.promptId + if (promptId) { + const turn = turns.get(promptId) + if (!turn) turns.set(promptId, { first: total, last: total }) + else turn.last = total + } + } + + const update = params.update + if (update?.sessionUpdate === 'tool_call' && typeof update.title === 'string') { + tools.push(toolNameMap[update.title] ?? update.title) + if (update.title === 'run_terminal_command' && typeof update.rawInput?.command === 'string') { + bashCommands.push(...extractBashCommands(update.rawInput.command)) + } + if (update.title === 'spawn_subagent' && typeof update.rawInput?.subagent_type === 'string') { + subagentTypes.push(update.rawInput.subagent_type) + } + } + } + + inputFresh += segmentPeak // close the final segment + let sumFirst = 0 + let output = 0 + for (const { first, last } of turns.values()) { + sumFirst += first + output += Math.max(0, last - first) + } + // Fresh input (summed segment peaks) is billed once; the rest of the per-turn + // re-sends are cache reads (Grok caches them, even though it reports nothing). + const cacheRead = Math.max(0, sumFirst - inputFresh) + return { input: inputFresh, cacheRead, output, tools, bashCommands, subagentTypes } +} + +function createParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + const dir = dirname(source.path) + const summary = await readJson<GrokSummary>(join(dir, 'summary.json')) + const updates = await readSessionFile(source.path) + if (!summary || updates === null) return + + const { input, cacheRead, output, tools, bashCommands, subagentTypes } = parseUpdates(updates) + if (input === 0 && output === 0) return + + const signals = await readJson<GrokSignals>(join(dir, 'signals.json')) + const model = + summary.current_model_id ?? signals?.primaryModelId ?? signals?.modelsUsed?.[0] ?? 'grok-build' + const timestamp = summary.updated_at ?? summary.last_active_at ?? summary.created_at ?? '' + const sessionId = summary.info?.id ?? basename(dir) + + const dedupKey = `${source.provider}:${dir}:${timestamp}:${sessionId}` + if (seenKeys.has(dedupKey)) return + seenKeys.add(dedupKey) + + yield { + provider: source.provider, + model, + inputTokens: input, + outputTokens: output, + cacheCreationInputTokens: 0, + cacheReadInputTokens: cacheRead, + cachedInputTokens: cacheRead, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD: calculateCost(model, input, output, 0, cacheRead, 0), + costIsEstimated: true, + tools, + bashCommands, + subagentTypes, + timestamp, + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: summary.session_summary ?? summary.generated_title ?? '', + sessionId, + project: source.project, + projectPath: summary.info?.cwd, + } + }, + } +} + +async function discoverSessions(sessionsDir: string): Promise<SessionSource[]> { + const sources: SessionSource[] = [] + + let cwdDirs: string[] + try { + cwdDirs = await readdir(sessionsDir) + } catch { + return sources + } + + for (const cwdName of cwdDirs) { + const cwdPath = join(sessionsDir, cwdName) + const cwdStat = await stat(cwdPath).catch(() => null) + if (!cwdStat?.isDirectory()) continue + + let sessionDirs: string[] + try { + sessionDirs = await readdir(cwdPath) + } catch { + continue + } + + for (const sessionName of sessionDirs) { + const sessionPath = join(cwdPath, sessionName) + const sessionStat = await stat(sessionPath).catch(() => null) + if (!sessionStat?.isDirectory()) continue + + const summary = await readJson<GrokSummary>(join(sessionPath, 'summary.json')) + if (!summary) continue + + const cwd = summary.info?.cwd ?? safeDecode(cwdName) + sources.push({ path: join(sessionPath, 'updates.jsonl'), project: basename(cwd), provider: 'grok' }) + } + } + + return sources +} + +export function createGrokProvider(sessionsDir?: string): Provider { + const dir = sessionsDir ?? defaultSessionsDir() + + return { + name: 'grok', + displayName: 'Grok Build', + + modelDisplayName(model: string): string { + if (model.startsWith('grok-build')) return 'Grok Build' + return getShortModelName(model) + }, + + toolDisplayName(rawTool: string): string { + return toolNameMap[rawTool] ?? rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + return discoverSessions(dir) + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const grok = createGrokProvider() diff --git a/src/providers/hermes.ts b/src/providers/hermes.ts new file mode 100644 index 0000000..309b29e --- /dev/null +++ b/src/providers/hermes.ts @@ -0,0 +1,481 @@ +import { readdir, stat } from 'fs/promises' +import { basename, dirname, join } from 'path' +import { homedir } from 'os' + +import { calculateCost, getShortModelName } from '../models.js' +import { isSqliteAvailable, getSqliteLoadError, openDatabase, isSqliteBusyError, type SqliteDatabase } from '../sqlite.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' +import type { ToolCall } from '../types.js' + +type HermesSessionRow = { + id: string + source: string | null + model: string | null + cwd: string | null + billing_provider: string | null + input_tokens: number | null + output_tokens: number | null + cache_read_tokens: number | null + cache_write_tokens: number | null + reasoning_tokens: number | null + estimated_cost_usd: number | null + actual_cost_usd: number | null + api_call_count: number | null + tool_call_count: number | null + started_at: number | null + ended_at: number | null + title: string | null +} + +type HermesMessageRow = { + id: number | null + role: string + content: string | null + tool_calls: string | null + tool_name: string | null + timestamp: number | null +} + +type HermesToolCall = { + function?: { + name?: string + arguments?: string + } +} + +type ProfileDb = { + dbPath: string + profile: string +} + +type TableInfoRow = { + name: string +} + +type TableColumn = keyof HermesSessionRow | keyof HermesMessageRow + +const toolNameMap: Record<string, string> = { + terminal: 'Bash', + execute_code: 'CodeExecution', + read_file: 'Read', + search_files: 'Grep', + write_file: 'Write', + patch: 'Edit', + browser_navigate: 'Browser', + browser_click: 'Browser', + browser_type: 'Browser', + browser_press: 'Browser', + browser_scroll: 'Browser', + browser_snapshot: 'Browser', + browser_vision: 'Vision', + browser_console: 'Browser', + browser_get_images: 'Browser', + web_search: 'WebSearch', + web_extract: 'WebFetch', + delegate_task: 'Agent', + vision_analyze: 'Vision', + process: 'Bash', + todo: 'TodoWrite', + skill_view: 'Skill', + skill_manage: 'Skill', + skills_list: 'Skill', + memory: 'Memory', + session_search: 'SessionSearch', +} + +function getHermesHome(override?: string): string { + return override ?? process.env['HERMES_HOME'] ?? join(homedir(), '.hermes') +} + +function sanitizeProject(raw: string): string { + const trimmed = raw.trim() + if (!trimmed) return 'hermes' + return trimmed.replace(/^[/\\]+/, '').replace(/[:/\\]/g, '-') +} + +function parseProfileName(dbPath: string, hermesHome: string): string { + const profilesDir = join(hermesHome, 'profiles') + const dir = dirname(dbPath) + if (dirname(dir) === profilesDir) return basename(dir) + return 'default' +} + +async function findStateDbs(hermesHome: string): Promise<ProfileDb[]> { + const dbs: ProfileDb[] = [] + const rootDb = join(hermesHome, 'state.db') + const rootStat = await stat(rootDb).catch(() => null) + if (rootStat?.isFile()) dbs.push({ dbPath: rootDb, profile: 'default' }) + + const profilesDir = join(hermesHome, 'profiles') + const profiles = await readdir(profilesDir, { withFileTypes: true }).catch(() => []) + for (const entry of profiles) { + if (!entry.isDirectory()) continue + const dbPath = join(profilesDir, entry.name, 'state.db') + const s = await stat(dbPath).catch(() => null) + if (s?.isFile()) dbs.push({ dbPath, profile: entry.name }) + } + return dbs +} + +function encodeSourcePath(dbPath: string, sessionId: string): string { + return `${dbPath}#hermes-session=${encodeURIComponent(sessionId)}` +} + +function decodeSourcePath(path: string): { dbPath: string; sessionId: string } | null { + const marker = '#hermes-session=' + const idx = path.lastIndexOf(marker) + if (idx === -1) return null + return { + dbPath: path.slice(0, idx), + sessionId: decodeURIComponent(path.slice(idx + marker.length)), + } +} + +function validateSchema(db: SqliteDatabase): boolean { + try { + db.query('SELECT session_id, role, content, tool_calls FROM messages LIMIT 1') + const columns = getSessionColumns(db) + return columns.has('id') && columns.has('input_tokens') && columns.has('output_tokens') + } catch (err) { + if (isSqliteBusyError(err)) throw err + return false + } +} + +function getSessionColumns(db: SqliteDatabase): Set<string> { + return new Set(db.query<TableInfoRow>('PRAGMA table_info(sessions)').map(row => row.name)) +} + +function numberColumn(columns: Set<string>, name: TableColumn): string { + return columns.has(name) ? `coalesce(${name}, 0) AS ${name}` : `0 AS ${name}` +} + +function nullableColumn(columns: Set<string>, name: TableColumn): string { + return columns.has(name) ? name : `NULL AS ${name}` +} + +function getMessageColumns(db: SqliteDatabase): Set<string> { + return new Set(db.query<TableInfoRow>('PRAGMA table_info(messages)').map(row => row.name)) +} + +function usageExpression(columns: Set<string>): string { + const usageColumns: Array<keyof HermesSessionRow> = [ + 'input_tokens', + 'output_tokens', + 'cache_read_tokens', + 'cache_write_tokens', + 'reasoning_tokens', + ] + const parts = usageColumns + .filter(name => columns.has(name)) + .map(name => `coalesce(${name}, 0)`) + return parts.length > 0 ? parts.join(' + ') : '0' +} + +function parseTimestamp(raw: number | null): string { + if (raw == null) return '' + const ms = raw < 1e12 ? raw * 1000 : raw + return new Date(ms).toISOString() +} + +function firstUserMessage(messages: HermesMessageRow[]): string { + const msg = messages.find(m => m.role === 'user' && typeof m.content === 'string' && m.content.trim().length > 0) + return Array.from(msg?.content ?? '').slice(0, 500).join('') +} + +function mapToolName(raw: string): string { + // Composio MCP tools are matched first — the generic mcp_ prefix on line + // below would also match composio names, so order matters here. + if (raw.startsWith('mcp_composio_')) return 'MCP' + if (raw.startsWith('mcp_') || raw.startsWith('mcp__')) return raw + if (raw.startsWith('browser_')) return 'Browser' + return toolNameMap[raw] ?? raw +} + +function parseToolCalls(raw: string | null): HermesToolCall[] { + if (!raw) return [] + try { + const parsed = JSON.parse(raw) as unknown + return Array.isArray(parsed) ? parsed as HermesToolCall[] : [] + } catch { + return [] + } +} + +function collectTools(messages: HermesMessageRow[]): { tools: string[]; toolSequence: ToolCall[][]; bashCommands: string[] } { + const tools: string[] = [] + const toolSequence: ToolCall[][] = [] + const bashCommands: string[] = [] + + for (const msg of messages) { + if (msg.role === 'assistant') { + const currentTurnTools: ToolCall[] = [] + for (const call of parseToolCalls(msg.tool_calls)) { + const rawName = call.function?.name ?? '' + if (!rawName) continue + const mapped = mapToolName(rawName) + tools.push(mapped) + const toolCall: ToolCall = { tool: mapped } + const rawArgs = call.function?.arguments + if (rawArgs) { + try { + const args = JSON.parse(rawArgs) as Record<string, unknown> + const file = args['path'] ?? args['file_path'] + if (typeof file === 'string') toolCall.file = file + const command = args['command'] + if (typeof command === 'string') { + toolCall.command = command + bashCommands.push(command) + } + } catch { + // Ignore malformed arguments from historical sessions. + } + } + currentTurnTools.push(toolCall) + } + if (currentTurnTools.length > 0) { + toolSequence.push(currentTurnTools) + } + } else if (msg.role === 'tool' && msg.tool_name) { + tools.push(mapToolName(msg.tool_name)) + } + } + + return { + tools: [...new Set(tools)], + toolSequence: toolSequence.length > 0 ? toolSequence : [], + bashCommands, + } +} + +function inferProject(messages: HermesMessageRow[], fallback: string): { project: string; projectPath?: string } { + const cwdPattern = /^Current working directory:\s*([a-zA-Z]:\\[^\r\n`"]+|\/[^\r\n`"\\]+)/m + for (const msg of messages) { + if (msg.role !== 'user' && msg.role !== 'system') continue + const text = msg.content ?? '' + const match = cwdPattern.exec(text) + if (match?.[1]) { + const projectPath = match[1].trim() + return { project: sanitizeProject(projectPath), projectPath } + } + } + return { project: fallback } +} + +async function discoverFromDb(dbPath: string, profile: string): Promise<SessionSource[]> { + let db: SqliteDatabase + try { + db = openDatabase(dbPath) + } catch { + return [] + } + + try { + if (!validateSchema(db)) return [] + const columns = getSessionColumns(db) + const usage = usageExpression(columns) + const orderBy = columns.has('started_at') ? 'started_at DESC' : 'id DESC' + const rows = db.query<HermesSessionRow>( + `SELECT id, + ${nullableColumn(columns, 'title')}, + ${numberColumn(columns, 'input_tokens')}, + ${numberColumn(columns, 'output_tokens')}, + ${numberColumn(columns, 'cache_read_tokens')}, + ${numberColumn(columns, 'cache_write_tokens')}, + ${numberColumn(columns, 'reasoning_tokens')} + FROM sessions + WHERE ${usage} > 0 + ORDER BY ${orderBy} + LIMIT 10000`, + ) + + return rows.map(row => ({ + path: encodeSourcePath(dbPath, row.id), + project: sanitizeProject(profile), + provider: 'hermes', + })) + } catch (err) { + if (isSqliteBusyError(err)) throw err + process.stderr.write(`codeburn: error querying Hermes database: ${err instanceof Error ? err.message : err}\n`) + return [] + } finally { + db.close() + } +} + +function createParser(source: SessionSource, seenKeys: Set<string>, hermesHome: string): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + if (!isSqliteAvailable()) { + process.stderr.write(getSqliteLoadError() + '\n') + return + } + + const decoded = decodeSourcePath(source.path) + if (!decoded) return + const profile = parseProfileName(decoded.dbPath, hermesHome) + + let db: SqliteDatabase + try { + db = openDatabase(decoded.dbPath) + } catch (err) { + process.stderr.write(`codeburn: cannot open Hermes database: ${err instanceof Error ? err.message : err}\n`) + return + } + + let result: ParsedProviderCall | undefined + try { + if (!validateSchema(db)) return + const columns = getSessionColumns(db) + const rows = db.query<HermesSessionRow>( + `SELECT id, + ${nullableColumn(columns, 'source')}, + ${nullableColumn(columns, 'model')}, + ${nullableColumn(columns, 'cwd')}, + ${nullableColumn(columns, 'billing_provider')}, + ${numberColumn(columns, 'input_tokens')}, + ${numberColumn(columns, 'output_tokens')}, + ${numberColumn(columns, 'cache_read_tokens')}, + ${numberColumn(columns, 'cache_write_tokens')}, + ${numberColumn(columns, 'reasoning_tokens')}, + ${nullableColumn(columns, 'estimated_cost_usd')}, + ${nullableColumn(columns, 'actual_cost_usd')}, + ${numberColumn(columns, 'api_call_count')}, + ${numberColumn(columns, 'tool_call_count')}, + ${nullableColumn(columns, 'started_at')}, + ${nullableColumn(columns, 'ended_at')}, + ${nullableColumn(columns, 'title')} + FROM sessions + WHERE id = ?`, + [decoded.sessionId], + ) + const row = rows[0] + if (!row) return + + const messageColumns = getMessageColumns(db) + const orderColumns = ['timestamp', 'id'].filter(name => messageColumns.has(name)) + const orderBy = orderColumns.length > 0 ? `ORDER BY ${orderColumns.join(' ASC, ')} ASC` : '' + const messages = db.query<HermesMessageRow>( + `SELECT ${numberColumn(messageColumns, 'id')}, + role, + content, + tool_calls, + ${nullableColumn(messageColumns, 'tool_name')}, + ${nullableColumn(messageColumns, 'timestamp')} + FROM messages + WHERE session_id = ? + ${orderBy}`, + [decoded.sessionId], + ) + + const inputTokens = row.input_tokens ?? 0 + const outputTokens = row.output_tokens ?? 0 + const cacheReadTokens = row.cache_read_tokens ?? 0 + const cacheWriteTokens = row.cache_write_tokens ?? 0 + const reasoningTokens = row.reasoning_tokens ?? 0 + if (inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens + reasoningTokens === 0) return + + const model = row.model ?? 'unknown' + const { tools, toolSequence, bashCommands } = collectTools(messages) + // Hermes records the session's working directory in sessions.cwd. + // Prefer it; fall back to scraping a "Current working directory:" line + // from the transcript (older builds), then to the profile name. + const cwd = row.cwd?.trim() + const projectInfo = cwd + ? { project: sanitizeProject(cwd), projectPath: cwd } + : inferProject(messages, sanitizeProject(profile)) + const timestamp = parseTimestamp(row.started_at) + const dedupKey = `hermes:${profile}:${row.id}` + if (seenKeys.has(dedupKey)) return + seenKeys.add(dedupKey) + + // Hermes bills reasoning tokens at the output rate (same as Gemini). + // The LiteLLM model table is used as a fallback when Hermes has not + // stored an actual or estimated cost for the session. + const calculatedCost = calculateCost( + model, + inputTokens, + outputTokens + reasoningTokens, + cacheWriteTokens, + cacheReadTokens, + 0, + ) + const recordedCost = + (row.actual_cost_usd ?? 0) > 0 ? row.actual_cost_usd! + : (row.estimated_cost_usd ?? 0) > 0 ? row.estimated_cost_usd! + : null + // When Hermes stored no cost (e.g. subscription-billed sessions), the + // figure is our LiteLLM-priced estimate from the session token totals. + const costUSD = recordedCost ?? calculatedCost + const costIsEstimated = recordedCost === null + + result = { + provider: 'hermes', + model, + inputTokens, + outputTokens, + cacheCreationInputTokens: cacheWriteTokens, + cacheReadInputTokens: cacheReadTokens, + cachedInputTokens: cacheReadTokens, + reasoningTokens, + webSearchRequests: 0, + costUSD, + costIsEstimated, + tools, + bashCommands, + timestamp, + speed: 'standard', + deduplicationKey: dedupKey, + turnId: `${row.id}:session`, + toolSequence: toolSequence.length > 0 ? toolSequence : undefined, + userMessage: firstUserMessage(messages), + sessionId: row.id, + project: projectInfo.project, + projectPath: projectInfo.projectPath, + } + } catch (err) { + // A transient lock on the live state.db must propagate so the caller + // retries, not get swallowed into an empty (negatively cached) result. + if (isSqliteBusyError(err)) throw err + process.stderr.write(`codeburn: error querying Hermes database: ${err instanceof Error ? err.message : err}\n`) + return + } finally { + db.close() + } + + if (result) yield result + }, + } +} + +export function createHermesProvider(hermesHomeOverride?: string): Provider { + const hermesHome = getHermesHome(hermesHomeOverride) + return { + name: 'hermes', + displayName: 'Hermes Agent', + + modelDisplayName(model: string): string { + return getShortModelName(model) + }, + + toolDisplayName(rawTool: string): string { + return mapToolName(rawTool) + }, + + async discoverSessions(): Promise<SessionSource[]> { + if (!isSqliteAvailable()) return [] + const dbs = await findStateDbs(hermesHome) + const sessions: SessionSource[] = [] + for (const { dbPath, profile } of dbs) { + sessions.push(...await discoverFromDb(dbPath, profile)) + } + return sessions + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys, hermesHome) + }, + } +} + +export const hermes = createHermesProvider() diff --git a/src/providers/ibm-bob.ts b/src/providers/ibm-bob.ts new file mode 100644 index 0000000..5aec0f6 --- /dev/null +++ b/src/providers/ibm-bob.ts @@ -0,0 +1,59 @@ +import { join } from 'path' +import { homedir } from 'os' + +import { getShortModelName } from '../models.js' +import { discoverClineTasksInBaseDirs, createClineParser } from './vscode-cline-parser.js' +import type { Provider, SessionSource, SessionParser } from './types.js' + +const PROVIDER_NAME = 'ibm-bob' +const DISPLAY_NAME = 'IBM Bob' +const EXTENSION_ID = 'ibm.bob-code' +const FALLBACK_MODEL = 'ibm-bob-auto' + +export function getIBMBobGlobalStorageDirs(): string[] { + const home = homedir() + if (process.platform === 'darwin') { + return [ + join(home, 'Library', 'Application Support', 'IBM Bob', 'User', 'globalStorage', EXTENSION_ID), + join(home, 'Library', 'Application Support', 'Bob-IDE', 'User', 'globalStorage', EXTENSION_ID), + ] + } + if (process.platform === 'win32') { + const appData = process.env['APPDATA'] ?? join(home, 'AppData', 'Roaming') + return [ + join(appData, 'IBM Bob', 'User', 'globalStorage', EXTENSION_ID), + join(appData, 'Bob-IDE', 'User', 'globalStorage', EXTENSION_ID), + ] + } + const configHome = process.env['XDG_CONFIG_HOME'] ?? join(home, '.config') + return [ + join(configHome, 'IBM Bob', 'User', 'globalStorage', EXTENSION_ID), + join(configHome, 'Bob-IDE', 'User', 'globalStorage', EXTENSION_ID), + ] +} + +export function createIBMBobProvider(overrideDir?: string): Provider { + return { + name: PROVIDER_NAME, + displayName: DISPLAY_NAME, + + modelDisplayName(model: string): string { + return getShortModelName(model) + }, + + toolDisplayName(rawTool: string): string { + return rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + const dirs = overrideDir ? [overrideDir] : getIBMBobGlobalStorageDirs() + return discoverClineTasksInBaseDirs(dirs, PROVIDER_NAME, DISPLAY_NAME) + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createClineParser(source, seenKeys, PROVIDER_NAME, FALLBACK_MODEL) + }, + } +} + +export const ibmBob = createIBMBobProvider() diff --git a/src/providers/index.ts b/src/providers/index.ts new file mode 100644 index 0000000..b61121a --- /dev/null +++ b/src/providers/index.ts @@ -0,0 +1,314 @@ +import { claude } from './claude.js' +import { cline } from './cline.js' +import { codebuff } from './codebuff.js' +import { codex } from './codex.js' +import { copilot } from './copilot.js' +import { droid } from './droid.js' +import { devin } from './devin.js' +import { gemini } from './gemini.js' +import { hermes } from './hermes.js' +import { ibmBob } from './ibm-bob.js' +import { kiloCode } from './kilo-code.js' +import { kiro } from './kiro.js' +import { kimi } from './kimi.js' +import { lingtaiTui } from './lingtai-tui.js' +import { mistralVibe } from './mistral-vibe.js' +import { mux } from './mux.js' +import { openclaw } from './openclaw.js' +import { openDesign } from './open-design.js' +import { pi, omp } from './pi.js' +import { qwen } from './qwen.js' +import { rooCode } from './roo-code.js' +import { zerostack } from './zerostack.js' +import { grok } from './grok.js' +import type { Provider, SessionSource } from './types.js' + +let antigravityProvider: Provider | null = null +let antigravityLoadAttempted = false +let warpProvider: Provider | null = null +let warpLoadAttempted = false + +async function loadAntigravity(): Promise<Provider | null> { + if (antigravityLoadAttempted) return antigravityProvider + antigravityLoadAttempted = true + try { + const { antigravity } = await import('./antigravity.js') + antigravityProvider = antigravity + return antigravity + } catch { + return null + } +} + +async function loadWarp(): Promise<Provider | null> { + if (warpLoadAttempted) return warpProvider + warpLoadAttempted = true + try { + const { warp } = await import('./warp.js') + warpProvider = warp + return warp + } catch { + return null + } +} + +let forgeProvider: Provider | null = null +let forgeLoadAttempted = false + +async function loadForge(): Promise<Provider | null> { + if (forgeLoadAttempted) return forgeProvider + forgeLoadAttempted = true + try { + const { forge } = await import('./forge.js') + forgeProvider = forge + return forge + } catch { + return null + } +} + +let gooseProvider: Provider | null = null +let gooseLoadAttempted = false + +async function loadGoose(): Promise<Provider | null> { + if (gooseLoadAttempted) return gooseProvider + gooseLoadAttempted = true + try { + const { goose } = await import('./goose.js') + gooseProvider = goose + return goose + } catch { + return null + } +} + +let cursorProvider: Provider | null = null +let cursorLoadAttempted = false + +async function loadCursor(): Promise<Provider | null> { + if (cursorLoadAttempted) return cursorProvider + cursorLoadAttempted = true + try { + const { cursor } = await import('./cursor.js') + cursorProvider = cursor + return cursor + } catch { + return null + } +} + +let opencodeProvider: Provider | null = null +let opencodeLoadAttempted = false + +let cursorAgentProvider: Provider | null = null +let cursorAgentLoadAttempted = false + +let crushProvider: Provider | null = null +let crushLoadAttempted = false + +let vercelGatewayProvider: Provider | null = null +let vercelGatewayLoadAttempted = false + +async function loadVercelGateway(): Promise<Provider | null> { + if (vercelGatewayLoadAttempted) return vercelGatewayProvider + vercelGatewayLoadAttempted = true + try { + const { vercelGateway } = await import('./vercel-gateway.js') + vercelGatewayProvider = vercelGateway + return vercelGateway + } catch { + return null + } +} + +async function loadOpenCode(): Promise<Provider | null> { + if (opencodeLoadAttempted) return opencodeProvider + opencodeLoadAttempted = true + try { + const { opencode } = await import('./opencode.js') + opencodeProvider = opencode + return opencode + } catch { + return null + } +} + +async function loadCursorAgent(): Promise<Provider | null> { + if (cursorAgentLoadAttempted) return cursorAgentProvider + cursorAgentLoadAttempted = true + try { + const { cursor_agent } = await import('./cursor-agent.js') + cursorAgentProvider = cursor_agent + return cursor_agent + } catch { + return null + } +} + +async function loadCrush(): Promise<Provider | null> { + if (crushLoadAttempted) return crushProvider + crushLoadAttempted = true + try { + const { crush } = await import('./crush.js') + crushProvider = crush + return crush + } catch { + return null + } +} + +let zcodeProvider: Provider | null = null +let zcodeLoadAttempted = false + +async function loadZcode(): Promise<Provider | null> { + if (zcodeLoadAttempted) return zcodeProvider + zcodeLoadAttempted = true + try { + const { zcode } = await import('./zcode.js') + zcodeProvider = zcode + return zcode + } catch { + return null + } +} + +let zedProvider: Provider | null = null +let zedLoadAttempted = false + +async function loadZed(): Promise<Provider | null> { + if (zedLoadAttempted) return zedProvider + zedLoadAttempted = true + try { + const { zed } = await import('./zed.js') + zedProvider = zed + return zed + } catch { + return null + } +} + +const coreProviders: Provider[] = [claude, cline, codebuff, codex, copilot, devin, droid, gemini, hermes, ibmBob, kiloCode, kiro, kimi, lingtaiTui, mistralVibe, mux, openclaw, openDesign, pi, omp, qwen, rooCode, zerostack, grok] + +// Lazily loaded providers, listed by name so --provider validation works even +// when an optional module fails to load. Must stay in sync with getAllProviders. +const lazyProviderNames = ['antigravity', 'forge', 'goose', 'cursor', 'opencode', 'cursor-agent', 'crush', 'warp', 'vercel-gateway', 'zcode', 'zed'] + +// Canonical set of every provider name (core + lazy), used to validate the +// --provider CLI flag. Computed lazily so importing this module never depends on +// every provider object being defined at load time (e.g. under test mocks). +let allProviderNamesCache: string[] | undefined +export function allProviderNames(): readonly string[] { + allProviderNamesCache ??= [ + ...coreProviders.map(p => p.name), + ...lazyProviderNames, + ].sort() + return allProviderNamesCache +} + +export async function getAllProviders(): Promise<Provider[]> { + const [ag, forge, gs, cursor, opencode, cursorAgent, crush, warp, vercelGw, zc, zd] = await Promise.all([ + loadAntigravity(), loadForge(), loadGoose(), loadCursor(), loadOpenCode(), loadCursorAgent(), loadCrush(), loadWarp(), loadVercelGateway(), loadZcode(), loadZed(), + ]) + const all = [...coreProviders] + if (ag) all.push(ag) + if (forge) all.push(forge) + if (gs) all.push(gs) + if (cursor) all.push(cursor) + if (opencode) all.push(opencode) + if (cursorAgent) all.push(cursorAgent) + if (crush) all.push(crush) + if (warp) all.push(warp) + if (vercelGw) all.push(vercelGw) + if (zc) all.push(zc) + if (zd) all.push(zd) + return all +} + +export const providers = coreProviders + +// Isolate one provider's discovery. A provider that throws (a crafted/corrupt +// file reaching a string op, an unexpected on-disk shape) must never take down +// the whole scan and blank every other provider's usage. Warn once per +// provider per run, then skip it. Mirrors the parse-failure isolation already +// used per-file in parser.ts. +const warnedDiscoveryFailures = new Set<string>() +export async function safeDiscoverSessions(provider: Provider): Promise<SessionSource[]> { + try { + return await provider.discoverSessions() + } catch (err) { + if (!warnedDiscoveryFailures.has(provider.name)) { + warnedDiscoveryFailures.add(provider.name) + const msg = err instanceof Error ? err.message : String(err) + process.stderr.write( + `codeburn: skipped ${provider.name} discovery after an error: ${msg}\n` + ) + } + return [] + } +} + +export async function discoverAllSessions( + providerFilter?: string, + // Injectable for tests so the isolation loop itself is exercised, not just + // the helper. Defaults to the real registry. + providerList?: Provider[], +): Promise<SessionSource[]> { + const allProviders = providerList ?? await getAllProviders() + const filtered = providerFilter && providerFilter !== 'all' + ? allProviders.filter(p => p.name === providerFilter) + : allProviders + const all: SessionSource[] = [] + for (const provider of filtered) { + const sessions = await safeDiscoverSessions(provider) + all.push(...sessions) + } + return all +} + +export async function getProvider(name: string): Promise<Provider | undefined> { + if (name === 'antigravity') { + const ag = await loadAntigravity() + return ag ?? undefined + } + if (name === 'forge') { + const forge = await loadForge() + return forge ?? undefined + } + if (name === 'goose') { + const gs = await loadGoose() + return gs ?? undefined + } + if (name === 'cursor') { + const cursor = await loadCursor() + return cursor ?? undefined + } + if (name === 'opencode') { + const oc = await loadOpenCode() + return oc ?? undefined + } + if (name === 'cursor-agent') { + const ca = await loadCursorAgent() + return ca ?? undefined + } + if (name === 'crush') { + const c = await loadCrush() + return c ?? undefined + } + if (name === 'warp') { + const w = await loadWarp() + return w ?? undefined + } + if (name === 'vercel-gateway') { + const vg = await loadVercelGateway() + return vg ?? undefined + } + if (name === 'zcode') { + const z = await loadZcode() + return z ?? undefined + } + if (name === 'zed') { + const z = await loadZed() + return z ?? undefined + } + return coreProviders.find(p => p.name === name) +} diff --git a/src/providers/kilo-code.ts b/src/providers/kilo-code.ts new file mode 100644 index 0000000..249fb5d --- /dev/null +++ b/src/providers/kilo-code.ts @@ -0,0 +1,53 @@ +import { join } from 'path' +import { homedir } from 'os' + +import { discoverClineTasks, createClineParser } from './vscode-cline-parser.js' +import { discoverSqliteSessions, createSqliteSessionParser, type SqliteProviderConfig } from './sqlite-session-parser.js' +import type { Provider, SessionSource, SessionParser } from './types.js' + +const EXTENSION_ID = 'kilocode.kilo-code' +const PROVIDER_NAME = 'kilo-code' + +function getSqliteConfig(): SqliteProviderConfig { + const base = process.env['XDG_DATA_HOME'] ?? join(homedir(), '.local', 'share') + return { + providerName: PROVIDER_NAME, + displayName: 'KiloCode', + dbDir: join(base, 'kilo'), + dbFilePrefix: 'kilo', + } +} + +export function createKiloCodeProvider(overrideDir?: string | string[]): Provider { + const sqliteConfig = getSqliteConfig() + + return { + name: PROVIDER_NAME, + displayName: 'KiloCode', + + modelDisplayName(model: string): string { + return model + }, + + toolDisplayName(rawTool: string): string { + return rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + const [oldSessions, dbSessions] = await Promise.all([ + discoverClineTasks(EXTENSION_ID, PROVIDER_NAME, 'KiloCode', overrideDir), + discoverSqliteSessions(sqliteConfig), + ]) + return [...oldSessions, ...dbSessions] + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + if (source.path.includes('.db:')) { + return createSqliteSessionParser(source, seenKeys, sqliteConfig) + } + return createClineParser(source, seenKeys, PROVIDER_NAME) + }, + } +} + +export const kiloCode = createKiloCodeProvider() diff --git a/src/providers/kimi.ts b/src/providers/kimi.ts new file mode 100644 index 0000000..75242cc --- /dev/null +++ b/src/providers/kimi.ts @@ -0,0 +1,394 @@ +import { createHash } from 'crypto' +import { readdir, readFile, stat } from 'fs/promises' +import { basename, dirname, join } from 'path' +import { homedir } from 'os' + +import { extractBashCommands } from '../bash-utils.js' +import { readSessionLines } from '../fs-utils.js' +import { calculateCost, getShortModelName } from '../models.js' +import type { ParsedProviderCall, Provider, SessionParser, SessionSource } from './types.js' + +type JsonObject = Record<string, unknown> + +const toolNameMap: Record<string, string> = { + Shell: 'Bash', + Bash: 'Bash', + bash: 'Bash', + ReadFile: 'Read', + ReadMediaFile: 'Read', + WriteFile: 'Write', + StrReplaceFile: 'Edit', + Grep: 'Grep', + Glob: 'Glob', + SearchWeb: 'WebSearch', + FetchURL: 'WebFetch', + Agent: 'Agent', + AgentTool: 'Agent', + TaskList: 'Agent', + TaskOutput: 'Agent', + TaskStop: 'Agent', + AskUserQuestion: 'AskUser', + SetTodoList: 'TodoWrite', + Think: 'Think', + EnterPlanMode: 'EnterPlanMode', + ExitPlanMode: 'ExitPlanMode', + SendDMail: 'DMail', +} + +function asObject(value: unknown): JsonObject | null { + return value && typeof value === 'object' && !Array.isArray(value) ? value as JsonObject : null +} + +function stringField(obj: JsonObject | null, key: string): string | undefined { + const value = obj?.[key] + return typeof value === 'string' ? value : undefined +} + +function numericField(obj: JsonObject, ...keys: string[]): number { + for (const key of keys) { + const raw = obj[key] + const n = typeof raw === 'number' ? raw : typeof raw === 'string' ? Number(raw) : NaN + if (Number.isFinite(n) && n > 0) return Math.trunc(n) + } + return 0 +} + +function getShareDir(overrideDir?: string): string { + return overrideDir ?? process.env['KIMI_SHARE_DIR'] ?? join(homedir(), '.kimi') +} + +function md5(text: string): string { + return createHash('md5').update(text, 'utf-8').digest('hex') +} + +function projectNameFromPath(pathValue: string): string { + const cleaned = pathValue.replace(/\/+$/, '') + return basename(cleaned) || cleaned || 'kimi' +} + +async function loadProjectNames(shareDir: string): Promise<Map<string, string>> { + const projects = new Map<string, string>() + const raw = await readFile(join(shareDir, 'kimi.json'), 'utf-8').catch(() => null) + if (!raw) return projects + + let data: unknown + try { + data = JSON.parse(raw) + } catch { + return projects + } + + const workDirs = asObject(data)?.['work_dirs'] + if (!Array.isArray(workDirs)) return projects + + for (const entry of workDirs) { + const obj = asObject(entry) + const pathValue = stringField(obj, 'path') + if (!pathValue) continue + const hash = md5(pathValue) + const project = projectNameFromPath(pathValue) + projects.set(hash, project) + + const kaos = stringField(obj, 'kaos') + if (kaos && kaos !== 'local') projects.set(`${kaos}_${hash}`, project) + } + + return projects +} + +function parseTomlString(raw: string): string | null { + const value = raw.trim() + if (!value) return null + if (value.startsWith('"')) { + const match = value.match(/^"((?:[^"\\]|\\.)*)"/) + if (!match) return null + try { + return JSON.parse(`"${match[1]}"`) as string + } catch { + return match[1] ?? null + } + } + if (value.startsWith("'")) { + const match = value.match(/^'([^']*)'/) + return match?.[1] ?? null + } + const match = value.match(/^([^#\s]+)/) + return match?.[1] ?? null +} + +function parseDefaultModelKey(configToml: string): string | null { + for (const line of configToml.split('\n')) { + const match = line.match(/^\s*default_model\s*=\s*(.+)$/) + if (!match) continue + return parseTomlString(match[1]!) + } + return null +} + +function parseModelSectionName(line: string): string | null { + const match = line.trim().match(/^\[models\.(?:"([^"]+)"|'([^']+)'|([^\]]+))\]$/) + if (!match) return null + return (match[1] ?? match[2] ?? match[3] ?? '').trim() || null +} + +function parseModelIdForKey(configToml: string, modelKey: string): string | null { + let inSection = false + for (const line of configToml.split('\n')) { + const section = parseModelSectionName(line) + if (section !== null) { + inSection = section === modelKey + continue + } + if (!inSection) continue + if (/^\s*\[/.test(line)) { + inSection = false + continue + } + const match = line.match(/^\s*model\s*=\s*(.+)$/) + if (!match) continue + return parseTomlString(match[1]!) + } + return null +} + +async function getConfiguredModel(shareDir: string): Promise<string> { + const envModel = process.env['KIMI_MODEL_NAME']?.trim() + if (envModel) return envModel + + const raw = await readFile(join(shareDir, 'config.toml'), 'utf-8').catch(() => null) + if (!raw) return 'kimi-auto' + + const defaultModel = parseDefaultModelKey(raw) + if (!defaultModel) return 'kimi-auto' + + return parseModelIdForKey(raw, defaultModel) ?? defaultModel +} + +function parseJsonObject(text: string | undefined): JsonObject | null { + if (!text) return null + try { + return asObject(JSON.parse(text)) + } catch { + return null + } +} + +function extractUserText(value: unknown): string { + if (typeof value === 'string') return value.slice(0, 500) + if (!Array.isArray(value)) return '' + + return value + .map(part => stringField(asObject(part), 'text') ?? '') + .filter(Boolean) + .join(' ') + .slice(0, 500) +} + +function timestampToIso(value: unknown): string { + if (typeof value === 'string') return value + if (typeof value !== 'number' || !Number.isFinite(value)) return '' + + const millis = value > 1_000_000_000_000 ? value : value * 1000 + const date = new Date(millis) + return Number.isFinite(date.getTime()) ? date.toISOString() : '' +} + +function extractEnvelope(record: JsonObject): { type: string; payload: JsonObject; timestamp: string } | null { + const message = asObject(record['message']) + const envelope = message ?? record + const type = stringField(envelope, 'type') + const payload = asObject(envelope['payload']) + if (!type || !payload) return null + return { type, payload, timestamp: timestampToIso(record['timestamp']) } +} + +function extractUsage(payload: JsonObject): { + inputTokens: number + outputTokens: number + cacheReadInputTokens: number + cacheCreationInputTokens: number +} | null { + const usage = asObject(payload['token_usage']) ?? asObject(payload['usage']) + if (!usage) return null + + const cacheReadInputTokens = numericField(usage, 'input_cache_read', 'cache_read_input_tokens', 'cached_input_tokens') + const cacheCreationInputTokens = numericField(usage, 'input_cache_creation', 'cache_creation_input_tokens') + let inputTokens = numericField(usage, 'input_other', 'input_tokens') + if (inputTokens === 0) { + const totalInput = numericField(usage, 'input') + inputTokens = Math.max(0, totalInput - cacheReadInputTokens - cacheCreationInputTokens) + } + const outputTokens = numericField(usage, 'output', 'output_tokens') + + if (inputTokens === 0 && outputTokens === 0 && cacheReadInputTokens === 0 && cacheCreationInputTokens === 0) { + return null + } + + return { inputTokens, outputTokens, cacheReadInputTokens, cacheCreationInputTokens } +} + +function extractTool(payload: JsonObject): { tool: string; bashCommands: string[] } | null { + const fn = asObject(payload['function']) + const rawName = stringField(fn, 'name') ?? stringField(payload, 'name') + if (!rawName) return null + + const tool = toolNameMap[rawName] ?? rawName + const argsText = stringField(fn, 'arguments') ?? stringField(payload, 'arguments') + const args = parseJsonObject(argsText) + const command = stringField(args, 'command') + const bashCommands = tool === 'Bash' && command ? extractBashCommands(command) : [] + + return { tool, bashCommands } +} + +function createParser(source: SessionSource, shareDir: string, seenKeys: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + const configuredModel = await getConfiguredModel(shareDir) + const tools = new Set<string>() + const bashCommands = new Set<string>() + let currentUserMessage = '' + const sessionId = basename(dirname(source.path)) + let index = 0 + + for await (const line of readSessionLines(source.path)) { + if (!line.trim()) continue + + let record: JsonObject | null = null + try { + record = asObject(JSON.parse(line)) + } catch { + continue + } + if (!record) continue + + const envelope = extractEnvelope(record) + if (!envelope || envelope.type === 'metadata') continue + + if (envelope.type === 'TurnBegin' || envelope.type === 'SteerInput') { + currentUserMessage = extractUserText(envelope.payload['user_input']) + continue + } + + if (envelope.type === 'TurnEnd') { + currentUserMessage = '' + tools.clear() + bashCommands.clear() + continue + } + + if (envelope.type === 'ToolCall' || envelope.type === 'ToolCallRequest') { + const extracted = extractTool(envelope.payload) + if (!extracted) continue + tools.add(extracted.tool) + for (const command of extracted.bashCommands) bashCommands.add(command) + continue + } + + if (envelope.type !== 'StatusUpdate') continue + + const usage = extractUsage(envelope.payload) + if (!usage) continue + + const rawMessageId = stringField(envelope.payload, 'message_id') + const dedupKey = `kimi:${sessionId}:${rawMessageId ?? index}` + index++ + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + const model = stringField(envelope.payload, 'model') ?? stringField(envelope.payload, 'model_name') ?? configuredModel + const costUSD = calculateCost( + model, + usage.inputTokens, + usage.outputTokens, + usage.cacheCreationInputTokens, + usage.cacheReadInputTokens, + 0, + ) + + yield { + provider: 'kimi', + model, + inputTokens: usage.inputTokens, + outputTokens: usage.outputTokens, + cacheCreationInputTokens: usage.cacheCreationInputTokens, + cacheReadInputTokens: usage.cacheReadInputTokens, + cachedInputTokens: usage.cacheReadInputTokens, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + tools: [...tools], + bashCommands: [...bashCommands], + timestamp: envelope.timestamp, + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: currentUserMessage, + sessionId, + } + + tools.clear() + bashCommands.clear() + } + }, + } +} + +async function addWireSource(sources: SessionSource[], filePath: string, project: string): Promise<void> { + const s = await stat(filePath).catch(() => null) + if (!s?.isFile()) return + sources.push({ path: filePath, project, provider: 'kimi' }) +} + +export function createKimiProvider(overrideDir?: string): Provider { + const shareDir = getShareDir(overrideDir) + + return { + name: 'kimi', + displayName: 'Kimi', + + modelDisplayName(model: string): string { + return getShortModelName(model) + }, + + toolDisplayName(rawTool: string): string { + return toolNameMap[rawTool] ?? rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + const sources: SessionSource[] = [] + const sessionsRoot = join(shareDir, 'sessions') + const projectNames = await loadProjectNames(shareDir) + const workDirs = await readdir(sessionsRoot, { withFileTypes: true }).catch(() => []) + + for (const workDir of workDirs) { + if (!workDir.isDirectory()) continue + + const project = projectNames.get(workDir.name) ?? workDir.name + const workDirPath = join(sessionsRoot, workDir.name) + const sessionDirs = await readdir(workDirPath, { withFileTypes: true }).catch(() => []) + + for (const sessionDir of sessionDirs) { + if (!sessionDir.isDirectory()) continue + + const sessionPath = join(workDirPath, sessionDir.name) + await addWireSource(sources, join(sessionPath, 'wire.jsonl'), project) + + const subagentsPath = join(sessionPath, 'subagents') + const subagents = await readdir(subagentsPath, { withFileTypes: true }).catch(() => []) + for (const subagent of subagents) { + if (!subagent.isDirectory()) continue + await addWireSource(sources, join(subagentsPath, subagent.name, 'wire.jsonl'), project) + } + } + } + + return sources + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, shareDir, seenKeys) + }, + } +} + +export const kimi = createKimiProvider() diff --git a/src/providers/kiro.ts b/src/providers/kiro.ts new file mode 100644 index 0000000..df63ca2 --- /dev/null +++ b/src/providers/kiro.ts @@ -0,0 +1,885 @@ +import type { Dirent } from 'fs' +import { existsSync } from 'fs' +import { readdir, readFile, stat } from 'fs/promises' +import { basename, dirname, extname, join } from 'path' +import { homedir } from 'os' + +import { readSessionFile } from '../fs-utils.js' +import { calculateCost } from '../models.js' +import type { ToolCall } from '../types.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' + +const CHARS_PER_TOKEN = 4 +const MIN_REASONABLE_TIMESTAMP_MS = 1_000_000_000_000 +const MODERN_CONVERSATION_KEYS = ['messages', 'conversation', 'chat', 'transcript', 'entries', 'events'] + +const modelDisplayNames: Record<string, string> = { + 'claude-sonnet-4-6': 'Sonnet 4.6', + 'claude-sonnet-4-5': 'Sonnet 4.5', + 'claude-sonnet-4': 'Sonnet 4', + 'claude-haiku-4-5': 'Haiku 4.5', + 'claude-3-7-sonnet': 'Sonnet 3.7', + 'claude-3-5-sonnet': 'Sonnet 3.5', + 'claude-3-5-haiku': 'Haiku 3.5', +} + +const modelDisplayEntries = Object.entries(modelDisplayNames).sort((a, b) => b[0].length - a[0].length) + +const toolNameMap: Record<string, string> = { + readFile: 'Read', + read_file: 'Read', + read: 'Read', + writeFile: 'Edit', + write_file: 'Edit', + write: 'Edit', + editFile: 'Edit', + edit_file: 'Edit', + createFile: 'Write', + create_file: 'Write', + deleteFile: 'Delete', + listDir: 'LS', + list_dir: 'LS', + openFolders: 'LS', + runCommand: 'Bash', + run_command: 'Bash', + shell: 'Bash', + executeBash: 'Bash', + searchFiles: 'Grep', + search_files: 'Grep', + grep: 'Grep', + grepSearch: 'Grep', + findFiles: 'Glob', + find_files: 'Glob', + glob: 'Glob', + fileSearch: 'Glob', + webSearch: 'WebSearch', + web_search: 'WebSearch', + web_fetch: 'WebFetch', + fsWrite: 'Edit', + strReplace: 'Edit', + listDirectory: 'LS', + code: 'Read', + subagent: 'Agent', +} + +type KiroChatMessage = { + role: 'human' | 'bot' | 'tool' + content: string +} + +type KiroChatFile = { + executionId: string + actionId: string + chat: KiroChatMessage[] + metadata: { + modelId: string + modelProvider: string + workflow: string + workflowId: string + startTime: number + endTime: number + } +} + +type KiroModernExecution = Record<string, unknown> + +function normalizeModelId(raw: string): string { + return raw.replace(/(\d+)\.(\d+)/g, '$1-$2') +} + +function extractToolNames(content: string): string[] { + const tools: string[] = [] + const regex = /<tool_use>\s*<name>([^<]+)<\/name>/g + let match + while ((match = regex.exec(content)) !== null) { + const name = match[1]!.trim() + tools.push(toolNameMap[name] ?? name) + } + return tools +} + +function asRecord(value: unknown): Record<string, unknown> | null { + return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : null +} + +function stringField(record: Record<string, unknown> | null, names: string[]): string { + if (!record) return '' + for (const name of names) { + const value = record[name] + if (typeof value === 'string' && value.trim()) return value.trim() + } + return '' +} + +function timeField(record: Record<string, unknown> | null, names: string[]): number | string | undefined { + if (!record) return undefined + for (const name of names) { + const value = record[name] + if (typeof value === 'number' || typeof value === 'string') return value + } + return undefined +} + +function parseKiroTimestamp(value: number | string | undefined): Date | null { + if (value === undefined) return null + + let parsed: number | string = value + if (typeof value === 'string') { + const trimmed = value.trim() + if (!trimmed) return null + parsed = /^-?\d+(\.\d+)?$/.test(trimmed) ? Number(trimmed) : trimmed + } + + if (typeof parsed === 'number') { + if (!Number.isFinite(parsed)) return null + const ms = parsed < MIN_REASONABLE_TIMESTAMP_MS ? parsed * 1000 : parsed + const date = new Date(ms) + return Number.isNaN(date.getTime()) || date.getTime() < MIN_REASONABLE_TIMESTAMP_MS ? null : date + } + + const date = new Date(parsed) + return Number.isNaN(date.getTime()) || date.getTime() < MIN_REASONABLE_TIMESTAMP_MS ? null : date +} + +function textField(record: Record<string, unknown> | null, names: string[]): string { + if (!record) return '' + for (const name of names) { + const text = extractText(record[name]) + if (text) return text + } + return '' +} + +function extractText(value: unknown): string { + if (typeof value === 'string') return value + if (Array.isArray(value)) return value.map(extractText).filter(Boolean).join('\n') + const record = asRecord(value) + if (!record) return '' + for (const key of ['content', 'text', 'message', 'value', 'parts', 'entries']) { + const text = extractText(record[key]) + if (text) return text + } + return '' +} + +function messageRole(value: unknown): string { + const record = asRecord(value) + if (!record) return '' + return stringField(record, ['role', 'type', 'author']).toLowerCase() +} + +function extractStructuredToolNames(value: unknown, text: string, options: { includeDirectName?: boolean } = {}): string[] { + const tools = extractToolNames(text) + const record = asRecord(value) + if (!record) return tools + + if (options.includeDirectName ?? true) { + const directName = stringField(record, ['toolName', 'name']) + if (directName) tools.push(toolNameMap[directName] ?? directName) + } + + for (const key of ['toolCalls', 'tool_calls', 'tools']) { + const entries = record[key] + if (!Array.isArray(entries)) continue + for (const entry of entries) { + const name = stringField(asRecord(entry), ['name', 'toolName', 'tool_name']) + if (name) tools.push(toolNameMap[name] ?? name) + } + } + + return tools +} + +function parseChatFile(data: KiroChatFile, sessionId: string, project: string, seenKeys: Set<string>): ParsedProviderCall[] { + const results: ParsedProviderCall[] = [] + const { chat, metadata } = data + + let modelId = normalizeModelId(metadata.modelId ?? '') + if (modelId === 'auto' || !modelId) modelId = 'kiro-auto' + + let pendingUserMessage = '' + const allTools: string[] = [] + const toolSequence: ToolCall[][] = [] + + for (const msg of chat) { + if (msg.role === 'human') { + if (msg.content.startsWith('<identity>')) continue + pendingUserMessage = msg.content.slice(0, 500) + } + if (msg.role === 'bot') { + const msgTools = extractToolNames(msg.content) + allTools.push(...msgTools) + if (msgTools.length > 0) toolSequence.push(msgTools.map(t => ({ tool: t }))) + } + } + + const botMessages = chat.filter(m => m.role === 'bot' && m.content.length > 0) + const totalOutputChars = botMessages.reduce((sum, m) => sum + m.content.length, 0) + if (totalOutputChars === 0) return results + + const dedupKey = `kiro:${sessionId}:${data.executionId}` + if (seenKeys.has(dedupKey)) return results + + const outputTokens = Math.ceil(totalOutputChars / CHARS_PER_TOKEN) + const inputTokens = Math.ceil(pendingUserMessage.length / CHARS_PER_TOKEN) + const costUSD = calculateCost(modelId, inputTokens, outputTokens, 0, 0, 0) + const tsDate = parseKiroTimestamp(metadata.startTime) + if (!tsDate) return results + const timestamp = tsDate.toISOString() + seenKeys.add(dedupKey) + + results.push({ + provider: 'kiro', + model: modelId, + inputTokens, + outputTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + tools: [...new Set(allTools)], + bashCommands: [], + toolSequence: toolSequence.length > 1 ? toolSequence : undefined, + timestamp, + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: pendingUserMessage, + sessionId, + }) + + return results +} + +function parseModernExecution(data: KiroModernExecution, sourcePath: string, seenKeys: Set<string>): ParsedProviderCall[] { + const results: ParsedProviderCall[] = [] + if (Array.isArray(data['executions'])) return results + + const metadata = asRecord(data['metadata']) + const modelObj = asRecord(data['model']) + let modelId = normalizeModelId( + stringField(data, ['modelId', 'modelID', 'modelName', 'model']) || + stringField(modelObj, ['id', 'name']) || + stringField(metadata, ['modelId', 'modelID', 'modelName']), + ) + if (modelId === 'auto' || !modelId) modelId = 'kiro-auto' + + const executionId = stringField(data, ['executionId', 'id']) || basename(sourcePath) + const sessionId = stringField(data, ['sessionId', 'chatSessionId', 'conversationId', 'workflowId']) || + stringField(metadata, ['workflowId', 'sessionId']) || + basename(dirname(sourcePath)) || + executionId + + let inputChars = 0 + let outputChars = 0 + let pendingUserMessage = '' + const allTools: string[] = [] + let hasOutputActivity = false + const directInput = textField(data, ['prompt', 'input', 'userMessage', 'user_message', 'request']) + const directOutput = textField(data, ['response', 'output', 'assistantMessage', 'assistant_message', 'result']) + const directTools = extractStructuredToolNames(data, directOutput, { includeDirectName: false }) + + if (directInput) { + inputChars += directInput.length + pendingUserMessage = directInput.slice(0, 500) + } + + if (directOutput) { + outputChars += directOutput.length + hasOutputActivity = true + } + + if (directTools.length > 0) { + hasOutputActivity = true + allTools.push(...directTools) + } + + // Check both data.context[key] and data[key] for conversation arrays. + // Kiro IDE stores messages at data.context.messages in current builds. + const context = asRecord(data['context']) + const conversationSources = context ? [context, data] : [data] + + for (const source of conversationSources) { + let found = false + for (const key of MODERN_CONVERSATION_KEYS) { + const messages = (source as Record<string, unknown>)[key] + if (!Array.isArray(messages)) continue + + for (const message of messages) { + const text = extractText(message) + const role = messageRole(message) + const tools = extractStructuredToolNames(message, text) + + if (role === 'human' || role === 'user') { + if (!text) continue + inputChars += text.length + pendingUserMessage = text.slice(0, 500) + } else if (role === 'bot' || role === 'assistant' || role === 'ai' || role === 'model') { + if (text) outputChars += text.length + if (text || tools.length > 0) hasOutputActivity = true + allTools.push(...tools) + } else if (role === 'tool' || role === 'system') { + if (text) inputChars += text.length + allTools.push(...tools) + } + } + found = true + break + } + if (found) break + } + + // Extract tools from usageSummary (reliable structured tool list in current Kiro builds). + // usageSummary is an array of per-turn entries with optional usedTools field. + const usageSummary = data['usageSummary'] + if (Array.isArray(usageSummary)) { + for (const entry of usageSummary) { + const rec = asRecord(entry) + if (!rec) continue + const usedTools = rec['usedTools'] + if (Array.isArray(usedTools)) { + for (const tool of usedTools) { + if (typeof tool === 'string' && tool) { + // Strip mcp_ prefix for cleaner display (e.g. mcp_aws_sentral_mcp_search_accounts -> aws_sentral_mcp_search_accounts) + const cleaned = tool.startsWith('mcp_') ? tool.slice(4) : tool + allTools.push(toolNameMap[cleaned] ?? cleaned) + hasOutputActivity = true + } + } + } + } + } + + if (!hasOutputActivity) return results + + const dedupKey = `kiro:${sessionId}:${executionId}` + if (seenKeys.has(dedupKey)) return results + + const rawStartTime = timeField(data, ['startTime', 'createdAt', 'timestamp']) ?? + timeField(metadata, ['startTime', 'createdAt', 'timestamp']) + const tsDate = parseKiroTimestamp(rawStartTime) + if (!tsDate) return results + + const inputTokens = Math.ceil(inputChars / CHARS_PER_TOKEN) + const outputTokens = Math.ceil(outputChars / CHARS_PER_TOKEN) + const costUSD = calculateCost(modelId, inputTokens, outputTokens, 0, 0, 0) + seenKeys.add(dedupKey) + + results.push({ + provider: 'kiro', + model: modelId, + inputTokens, + outputTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + tools: [...new Set(allTools)], + bashCommands: [], + timestamp: tsDate.toISOString(), + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: pendingUserMessage, + sessionId, + }) + + return results +} + +// --- Kiro CLI session types & parser --- + +type KiroCliEntry = { + version: string + kind: 'Prompt' | 'AssistantMessage' | 'ToolResults' | 'Clear' + data: Record<string, unknown> +} + +type KiroCliSessionMeta = { + session_id: string + cwd: string + created_at: string + updated_at: string + title?: string + session_state?: { + rts_model_state?: { model_info?: { model_id?: string } } + conversation_metadata?: { + user_turn_metadatas?: Array<{ + end_timestamp?: string + builtin_tool_uses?: number + metering_usage?: Array<{ value: number; unit: string }> + total_request_count?: number + }> + } + } +} + +function parseCliSession(meta: KiroCliSessionMeta, entries: KiroCliEntry[], seenKeys: Set<string>): ParsedProviderCall[] { + const results: ParsedProviderCall[] = [] + const sessionId = meta.session_id + const project = basename(meta.cwd || '') + + let modelId = meta.session_state?.rts_model_state?.model_info?.model_id ?? 'auto' + if (modelId === 'auto' || !modelId) modelId = 'kiro-auto' + else modelId = normalizeModelId(modelId) + + const turns = meta.session_state?.conversation_metadata?.user_turn_metadatas ?? [] + + // Walk through JSONL entries grouping by prompt turns + let turnIndex = 0 + let pendingUserMessage = '' + let outputChars = 0 + let inputChars = 0 + const allTools: string[] = [] + let turnStartTimestamp: string | undefined + + function flushTurn() { + if (outputChars === 0) return + const turnMeta = turns[turnIndex] + const dedupKey = `kiro-cli:${sessionId}:${turnIndex}` + if (seenKeys.has(dedupKey)) { turnIndex++; return } + + const timestamp = turnMeta?.end_timestamp ?? turnStartTimestamp ?? meta.created_at + const tsDate = parseKiroTimestamp(timestamp) + if (!tsDate) { turnIndex++; return } + + const costUSD = turnMeta?.metering_usage + ? turnMeta.metering_usage.reduce((sum, m) => sum + m.value, 0) + : 0 + + const inputTokens = Math.ceil(inputChars / CHARS_PER_TOKEN) + const outputTokens = Math.ceil(outputChars / CHARS_PER_TOKEN) + seenKeys.add(dedupKey) + + results.push({ + provider: 'kiro', + model: modelId, + inputTokens, + outputTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + costIsEstimated: !turnMeta?.metering_usage, + tools: [...new Set(allTools)], + bashCommands: [], + timestamp: tsDate.toISOString(), + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: pendingUserMessage, + sessionId, + project, + }) + turnIndex++ + } + + let isFirstPrompt = true + for (const entry of entries) { + if (entry.kind === 'Prompt') { + if (!isFirstPrompt) { + flushTurn() + pendingUserMessage = '' + outputChars = 0 + inputChars = 0 + allTools.length = 0 + } + isFirstPrompt = false + const content = entry.data['content'] + if (Array.isArray(content)) { + for (const item of content) { + const rec = asRecord(item) + if (rec && rec['kind'] === 'text' && typeof rec['data'] === 'string') { + pendingUserMessage = (rec['data'] as string).slice(0, 500) + inputChars += (rec['data'] as string).length + } + } + } + const meta2 = asRecord(entry.data['meta']) + if (meta2) { + const ts = meta2['timestamp'] + if (typeof ts === 'number') turnStartTimestamp = new Date(ts * 1000).toISOString() + } + } else if (entry.kind === 'AssistantMessage') { + const content = entry.data['content'] + if (Array.isArray(content)) { + for (const item of content) { + const rec = asRecord(item) + if (!rec) continue + if (rec['kind'] === 'text' && typeof rec['data'] === 'string') { + outputChars += (rec['data'] as string).length + } else if (rec['kind'] === 'toolUse') { + const toolData = asRecord(rec['data']) + if (toolData) { + const name = typeof toolData['name'] === 'string' ? toolData['name'] : '' + if (name) allTools.push(toolNameMap[name] ?? name) + } + } + } + } + } else if (entry.kind === 'ToolResults') { + // Tool results count as input context + const content = entry.data['content'] + if (Array.isArray(content)) { + for (const item of content) { + const text = extractText(item) + if (text) inputChars += text.length + } + } + } + } + // Flush last turn + flushTurn() + + return results +} + +function createParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + // CLI session: path points to a .jsonl file + if (source.path.endsWith('.jsonl')) { + const jsonlContent = await readSessionFile(source.path) + if (jsonlContent === null) return + + const entries: KiroCliEntry[] = [] + for (const line of jsonlContent.split('\n')) { + if (!line.trim()) continue + try { entries.push(JSON.parse(line) as KiroCliEntry) } catch { /* skip malformed lines */ } + } + if (entries.length === 0) return + + // Load companion .json for metadata + const metaPath = source.path.replace(/\.jsonl$/, '.json') + let meta: KiroCliSessionMeta + try { + const raw = await readFile(metaPath, 'utf-8') + meta = JSON.parse(raw) as KiroCliSessionMeta + } catch { + // Minimal fallback + meta = { session_id: basename(source.path, '.jsonl'), cwd: '', created_at: '', updated_at: '' } + } + + for (const call of parseCliSession(meta, entries, seenKeys)) { + yield call + } + return + } + + // IDE session: original path + const content = await readSessionFile(source.path) + if (content === null) return + + let data: unknown + try { + data = JSON.parse(content) + } catch { + return + } + + const record = asRecord(data) + if (!record) return + + // Workspace-session files (newer Kiro builds): have history[] with message.role/content + // and a top-level sessionId/selectedModel/workspaceDirectory. + const historyArr = record['history'] + if (Array.isArray(historyArr) && typeof record['sessionId'] === 'string') { + const sessionId = record['sessionId'] as string + const modelRaw = stringField(record, ['selectedModel']) + let modelId = normalizeModelId(modelRaw) + if (modelId === 'auto' || !modelId) modelId = 'kiro-auto' + + let inputChars = 0 + let outputChars = 0 + let pendingUserMessage = '' + const allTools: string[] = [] + let hasExecutionRefs = false + let hasRealAssistantContent = false + + for (const item of historyArr) { + const rec = asRecord(item) + if (!rec) continue + + // Track if this session references execution files (which are parsed separately) + const execBacked = typeof rec['executionId'] === 'string' + if (execBacked) hasExecutionRefs = true + + const msg = asRecord(rec['message']) + if (!msg) continue + const role = stringField(msg, ['role']) + const text = extractText(msg['content']) + if (role === 'user' && text) { + inputChars += text.length + pendingUserMessage = text.slice(0, 500) + } else if (role === 'assistant' && !execBacked && text && text !== 'On it.') { + // An item carrying an executionId is execution-backed: its content is + // counted from the execution file, so counting it here would double-count. + // 'On it.' is the observed placeholder text Kiro writes for such stubs + // when the executionId rides a separate history item. + outputChars += text.length + hasRealAssistantContent = true + } + } + + // Skip workspace-session entries that are pure execution stubs: + // they reference executionIds (parsed separately as execution files) + // and have no real assistant content beyond "On it." placeholders. + // This avoids double-counting input tokens from both paths. + if (hasExecutionRefs && !hasRealAssistantContent) return + + // Skip sessions with no meaningful content + if (inputChars === 0 && outputChars === 0) return + + // Use file mtime as timestamp (workspace-session files don't carry startTime). + // No stat means no usable timestamp: drop the call like the other parse paths. + let timestamp: string + try { + const s = await stat(source.path) + timestamp = new Date(s.mtimeMs).toISOString() + } catch { + return + } + + const dedupKey = `kiro:ws-session:${sessionId}` + if (seenKeys.has(dedupKey)) return + seenKeys.add(dedupKey) + + const inputTokens = Math.ceil(inputChars / CHARS_PER_TOKEN) + const outputTokens = Math.ceil(outputChars / CHARS_PER_TOKEN) + const costUSD = calculateCost(modelId, inputTokens, outputTokens, 0, 0, 0) + + yield { + provider: 'kiro', + model: modelId, + inputTokens, + outputTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + costIsEstimated: true, + tools: [...new Set(allTools)], + bashCommands: [], + timestamp, + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: pendingUserMessage, + sessionId, + } + return + } + + const metadata = asRecord(record['metadata']) + const calls = Array.isArray(record['chat']) && metadata + ? parseChatFile(record as unknown as KiroChatFile, stringField(metadata, ['workflowId']) || basename(source.path, '.chat'), source.project, seenKeys) + : parseModernExecution(record, source.path, seenKeys) + for (const call of calls) { + yield call + } + }, + } +} + +// --- Discovery --- + +function getKiroAgentDir(override?: string): string[] { + if (override) return [override] + if (process.platform === 'darwin') { + return [join(homedir(), 'Library', 'Application Support', 'Kiro', 'User', 'globalStorage', 'kiro.kiroagent')] + } + if (process.platform === 'win32') { + return [join(homedir(), 'AppData', 'Roaming', 'Kiro', 'User', 'globalStorage', 'kiro.kiroagent')] + } + // On Linux, scan both ~/.kiro-server/data/... (remote dev boxes) and + // ~/.config/Kiro/... (local installs). Both can have data simultaneously + // if the user switches between local and remote, or if .kiro-server exists + // but is stale while .config/Kiro has current sessions. + const paths: string[] = [] + const kiroServer = join(homedir(), '.kiro-server', 'data', 'User', 'globalStorage', 'kiro.kiroagent') + const kiroConfig = join(homedir(), '.config', 'Kiro', 'User', 'globalStorage', 'kiro.kiroagent') + if (existsSync(kiroServer)) paths.push(kiroServer) + if (existsSync(kiroConfig)) paths.push(kiroConfig) + // Fallback to config path if neither exists (will just find nothing) + return paths.length > 0 ? paths : [kiroConfig] +} + +function getKiroWorkspaceStorageDir(override?: string): string { + if (override) return override + if (process.platform === 'darwin') { + return join(homedir(), 'Library', 'Application Support', 'Kiro', 'User', 'workspaceStorage') + } + if (process.platform === 'win32') { + return join(homedir(), 'AppData', 'Roaming', 'Kiro', 'User', 'workspaceStorage') + } + return join(homedir(), '.config', 'Kiro', 'User', 'workspaceStorage') +} + +async function readWorkspaceProject(workspaceDir: string): Promise<string> { + try { + const raw = await readFile(join(workspaceDir, 'workspace.json'), 'utf-8') + const data = JSON.parse(raw) as { folder?: string } + if (data.folder) { + const url = data.folder.replace(/^file:\/\//, '') + return basename(decodeURIComponent(url)) + } + } catch {} + return basename(workspaceDir) +} + +async function resolveWorkspaceProject(agentDir: string, workspaceStorageDir: string, workspaceHash: string): Promise<string> { + const wsDir = join(workspaceStorageDir, workspaceHash) + const project = await readWorkspaceProject(wsDir) + if (project !== workspaceHash) return project + + try { + const sessionsPath = join(agentDir, 'workspace-sessions') + const dirs = await readdir(sessionsPath) + for (const dir of dirs) { + const decoded = Buffer.from(dir.replace(/_$/, ''), 'base64').toString('utf-8') + if (decoded) return basename(decoded) + } + } catch {} + + return workspaceHash +} + +async function discoverSessions(agentDir: string, workspaceStorageDir: string, cliSessionsDir: string): Promise<SessionSource[]> { + const sources: SessionSource[] = [] + + // --- Kiro CLI sessions (~/.kiro/sessions/cli/) --- + try { + const cliEntries = await readdir(cliSessionsDir, { withFileTypes: true }) + for (const entry of cliEntries) { + if (!entry.isFile() || !entry.name.endsWith('.jsonl')) continue + const jsonlPath = join(cliSessionsDir, entry.name) + // Derive project from companion .json + const metaPath = jsonlPath.replace(/\.jsonl$/, '.json') + let project = 'kiro-cli' + try { + const raw = await readFile(metaPath, 'utf-8') + const meta = JSON.parse(raw) as { cwd?: string } + if (meta.cwd) project = basename(meta.cwd) + } catch {} + sources.push({ path: jsonlPath, project, provider: 'kiro' }) + } + } catch {} + + // --- Kiro IDE sessions --- + let workspaceDirs: string[] + try { + const entries = await readdir(agentDir, { withFileTypes: true }) + workspaceDirs = entries.filter(e => e.isDirectory() && e.name.length === 32).map(e => e.name) + } catch { + return sources + } + + for (const wsHash of workspaceDirs) { + const wsPath = join(agentDir, wsHash) + const project = await resolveWorkspaceProject(agentDir, workspaceStorageDir, wsHash) + + let entries: Dirent[] + try { + entries = await readdir(wsPath, { withFileTypes: true }) + } catch { + continue + } + + for (const entry of entries) { + if (entry.name.startsWith('.')) continue + const entryPath = join(wsPath, entry.name) + if (entry.isFile() && (entry.name.endsWith('.chat') || extname(entry.name) === '')) { + sources.push({ path: entryPath, project, provider: 'kiro' }) + continue + } + + if (!entry.isDirectory()) continue + + const childEntries = await readdir(entryPath, { withFileTypes: true }).catch(() => []) + for (const child of childEntries) { + if (child.name.startsWith('.')) continue + if (!child.isFile()) continue + if (extname(child.name) !== '') continue + sources.push({ path: join(entryPath, child.name), project, provider: 'kiro' }) + } + } + } + + // --- Kiro IDE workspace-sessions (newer builds store session state here) --- + // These files contain history[].message with user prompts and assistant stubs + // plus executionId references. They capture sessions not written as per-execution files. + try { + const wsSessionsDir = join(agentDir, 'workspace-sessions') + const wsSessionDirs = await readdir(wsSessionsDir, { withFileTypes: true }) + for (const dir of wsSessionDirs) { + if (!dir.isDirectory()) continue + // Directory name is base64-encoded workspace path + let project = 'kiro-ide' + try { + const decoded = Buffer.from(dir.name.replace(/_/g, '='), 'base64').toString('utf-8') + if (decoded) project = basename(decoded) + } catch {} + // Skip bare homedir as project name + if (project === basename(homedir())) project = 'kiro-ide' + + const sessionFiles = await readdir(join(wsSessionsDir, dir.name), { withFileTypes: true }).catch(() => []) + for (const sf of sessionFiles) { + if (!sf.isFile() || !sf.name.endsWith('.json') || sf.name === 'sessions.json') continue + sources.push({ path: join(wsSessionsDir, dir.name, sf.name), project, provider: 'kiro' }) + } + } + } catch {} + + return sources +} + +export function createKiroProvider(agentDirOverride?: string, workspaceStorageDirOverride?: string, cliSessionsDirOverride?: string): Provider { + const agentDirs = getKiroAgentDir(agentDirOverride) + const wsDir = getKiroWorkspaceStorageDir(workspaceStorageDirOverride) + // When overrides are provided (tests), don't scan real CLI sessions unless explicitly given + const cliDir = cliSessionsDirOverride ?? (agentDirOverride ? join(agentDirOverride, '..', 'cli-sessions') : join(process.env['KIRO_HOME'] || join(homedir(), '.kiro'), 'sessions', 'cli')) + + return { + name: 'kiro', + displayName: 'Kiro', + + modelDisplayName(model: string): string { + if (model === 'kiro-auto') return 'Kiro (auto)' + for (const [key, name] of modelDisplayEntries) { + if (model === key || model.startsWith(key + '-')) return name + } + return model + }, + + toolDisplayName(rawTool: string): string { + if (rawTool.startsWith('mcp__')) return rawTool + return toolNameMap[rawTool] ?? rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + const allSources: SessionSource[] = [] + for (const agentDir of agentDirs) { + const sources = await discoverSessions(agentDir, wsDir, cliDir) + allSources.push(...sources) + } + // CLI sessions are only scanned once (first agentDir pass includes them); + // deduplicate by path in case multiple agentDirs share the same CLI dir. + const seen = new Set<string>() + return allSources.filter(s => { + if (seen.has(s.path)) return false + seen.add(s.path) + return true + }) + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const kiro = createKiroProvider() diff --git a/src/providers/lingtai-tui.ts b/src/providers/lingtai-tui.ts new file mode 100644 index 0000000..bec5d93 --- /dev/null +++ b/src/providers/lingtai-tui.ts @@ -0,0 +1,431 @@ +import { readdir, readFile, stat } from 'fs/promises' +import { basename, delimiter, dirname, join, resolve } from 'path' +import { homedir } from 'os' + +import { readSessionLines } from '../fs-utils.js' +import { calculateCost, getShortModelName } from '../models.js' +import type { ParsedProviderCall, Provider, SessionParser, SessionSource } from './types.js' + +type JsonObject = Record<string, unknown> + +type LingTaiAgentManifest = { + agent_id?: string + agent_name?: string + address?: string + nickname?: string | null + llm?: { + model?: string + base_url?: string + } +} + +type LingTaiLedgerEntry = { + source?: string + em_id?: string + run_id?: string + ts?: string | number + input?: number | string + output?: number | string + thinking?: number | string + cached?: number | string + model?: string + endpoint?: string +} + +type LingTaiProviderOptions = { + lingtaiHomeOverride?: string + defaultHomeOverride?: string + globalDirOverride?: string + cwdOverride?: string +} + +type LingTaiHome = { + path: string + projectPrefix?: string +} + +function normalizeOptions(options?: string | LingTaiProviderOptions): LingTaiProviderOptions { + return typeof options === 'string' + ? { lingtaiHomeOverride: options } + : options ?? {} +} + +function expandHome(raw: string): string { + if (raw === '~') return homedir() + if (raw.startsWith('~/') || raw.startsWith('~\\')) return join(homedir(), raw.slice(2)) + return raw +} + +function splitPathList(raw: string | undefined): string[] { + return (raw ?? '') + .split(delimiter) + .map(p => p.trim()) + .filter(Boolean) +} + +async function existingDir(path: string): Promise<string | null> { + const resolved = resolve(expandHome(path)) + const s = await stat(resolved).catch(() => null) + return s?.isDirectory() ? resolved : null +} + +function getDefaultLingTaiHome(options: LingTaiProviderOptions): string { + return options.defaultHomeOverride ?? join(homedir(), '.lingtai') +} + +function getLingTaiGlobalDir(options: LingTaiProviderOptions): string { + return options.globalDirOverride + ?? process.env['LINGTAI_TUI_GLOBAL_DIR'] + ?? join(homedir(), '.lingtai-tui') +} + +function projectPrefixFromHome(lingtaiHome: string, defaultLingTaiHome: string): string | undefined { + const defaultHome = resolve(expandHome(defaultLingTaiHome)) + const resolved = resolve(lingtaiHome) + if (resolved === defaultHome) return undefined + + const projectName = basename(dirname(resolved)) + return projectName && projectName !== '.' ? sanitizeProject(projectName) : undefined +} + +async function readRegisteredProjectPaths(globalDir: string): Promise<string[]> { + const projects: string[] = [] + + const registryRaw = await readFile(join(globalDir, 'registry.jsonl'), 'utf-8').catch(() => '') + for (const line of registryRaw.split(/\r?\n/)) { + if (!line.trim()) continue + try { + const obj = asObject(JSON.parse(line)) + const path = stringField(obj, 'path') + if (path) projects.push(path) + } catch { + // Ignore corrupt registry rows; LingTai treats this as append-only state. + } + } + + const briefDir = join(globalDir, 'brief', 'projects') + const entries = await readdir(briefDir, { withFileTypes: true }).catch(() => []) + for (const entry of entries) { + if (!entry.isDirectory()) continue + const meta = await readJson<JsonObject>(join(briefDir, entry.name, 'meta.json')) + const path = stringField(meta, 'project_path') + if (path) projects.push(path) + } + + return projects +} + +function cwdLingTaiHomes(cwd: string): string[] { + const homes: string[] = [] + let current = resolve(cwd) + for (;;) { + homes.push(join(current, '.lingtai')) + const parent = dirname(current) + if (parent === current) break + current = parent + } + return homes +} + +async function getLingTaiHomes(options: LingTaiProviderOptions): Promise<LingTaiHome[]> { + const explicit = splitPathList(options.lingtaiHomeOverride ?? process.env['LINGTAI_HOME'] ?? process.env['LINGTAI_TUI_HOME']) + const defaultHome = getDefaultLingTaiHome(options) + const candidates = explicit.length + ? explicit + : [ + defaultHome, + ...(await readRegisteredProjectPaths(getLingTaiGlobalDir(options))).map(project => join(project, '.lingtai')), + ...cwdLingTaiHomes(options.cwdOverride ?? process.cwd()), + ] + + const seen = new Set<string>() + const homes: LingTaiHome[] = [] + for (const candidate of candidates) { + const path = await existingDir(candidate) + if (!path || seen.has(path)) continue + seen.add(path) + homes.push({ path, projectPrefix: explicit.length ? undefined : projectPrefixFromHome(path, defaultHome) }) + } + + return homes +} + +function sanitizeProject(raw: string): string { + const trimmed = raw.trim() + if (!trimmed) return 'lingtai' + return trimmed.replace(/^[/\\]+/, '').replace(/[:/\\]/g, '-') +} + +function asObject(value: unknown): JsonObject | null { + return value && typeof value === 'object' && !Array.isArray(value) ? value as JsonObject : null +} + +function stringField(obj: JsonObject | null, key: string): string | undefined { + const value = obj?.[key] + return typeof value === 'string' && value.trim() ? value : undefined +} + +function numericField(obj: JsonObject, key: keyof LingTaiLedgerEntry): number { + const raw = obj[key] + const n = typeof raw === 'number' ? raw : typeof raw === 'string' ? Number(raw) : NaN + if (!Number.isFinite(n) || n <= 0) return 0 + return Math.trunc(n) +} + +async function readJson<T>(path: string): Promise<T | null> { + const raw = await readFile(path, 'utf-8').catch(() => null) + if (!raw) return null + try { + return JSON.parse(raw) as T + } catch { + return null + } +} + +async function readAgentManifest(agentDir: string): Promise<LingTaiAgentManifest | null> { + const obj = asObject(await readJson<unknown>(join(agentDir, '.agent.json'))) + if (!obj) return null + // .agent.json is untrusted: a planted file can be valid JSON with wrong-typed + // fields (e.g. `agent_name: {}`). Reading it as a raw cast let a non-string + // field reach sanitizeProject().trim() and throw — and because + // discoverAllSessions loops providers without a try/catch, that one file took + // down usage discovery for EVERY provider. Normalize to string-or-undefined + // here so no downstream string op ever sees a non-string. + const llm = asObject(obj['llm']) + return { + agent_id: stringField(obj, 'agent_id'), + agent_name: stringField(obj, 'agent_name'), + address: stringField(obj, 'address'), + nickname: stringField(obj, 'nickname') ?? null, + llm: llm + ? { model: stringField(llm, 'model'), base_url: stringField(llm, 'base_url') } + : undefined, + } +} + +function agentDirFromLedgerPath(ledgerPath: string): string { + return dirname(dirname(ledgerPath)) +} + +function projectFromManifest(manifest: LingTaiAgentManifest | null, fallback: string, prefix?: string): string { + const name = sanitizeProject( + manifest?.nickname + ?? manifest?.agent_name + ?? manifest?.address + ?? fallback, + ) + return prefix ? `${prefix}-${name}` : name +} + +function parseTimestamp(raw: unknown): string { + if (typeof raw === 'number' && Number.isFinite(raw)) { + const ms = raw < 1e12 ? raw * 1000 : raw + return new Date(ms).toISOString() + } + if (typeof raw !== 'string' || !raw.trim()) return '' + const d = new Date(raw) + return Number.isNaN(d.getTime()) ? '' : d.toISOString() +} + +function parseLedgerLine(line: string | Buffer): LingTaiLedgerEntry | null { + const text = Buffer.isBuffer(line) ? line.toString('utf-8') : line + if (!text.trim()) return null + try { + const parsed = JSON.parse(text) as unknown + const obj = asObject(parsed) + return obj ? obj as LingTaiLedgerEntry : null + } catch { + return null + } +} + +function activityForSource(sourceLabel: string): { userMessage: string; tools: string[]; subagentTypes: string[] } { + const normalized = sourceLabel.trim().toLowerCase() + + if (normalized === 'tc_wake' || normalized.startsWith('tc_') || normalized.includes('wake')) { + return { + userMessage: 'LingTai task coordinator wake', + tools: ['Agent'], + subagentTypes: ['lingtai-task-coordinator'], + } + } + + if (normalized === 'daemon') { + return { + userMessage: 'LingTai daemon task', + tools: ['Agent'], + subagentTypes: ['lingtai-daemon'], + } + } + + if (normalized === 'summarize_apriori' || normalized.includes('summar')) { + return { + userMessage: 'LingTai planning summary', + tools: ['EnterPlanMode'], + subagentTypes: [], + } + } + + return { + userMessage: normalized === 'main' + ? 'LingTai main conversation' + : `LingTai ${sourceLabel || 'main'} conversation`, + tools: [], + subagentTypes: [], + } +} + +async function discoverLedgersInHome(home: LingTaiHome): Promise<SessionSource[]> { + const entries = await readdir(home.path, { withFileTypes: true }).catch(() => []) + const sources: SessionSource[] = [] + + for (const entry of entries) { + if (!entry.isDirectory()) continue + + const agentDir = join(home.path, entry.name) + const ledgerPath = join(agentDir, 'logs', 'token_ledger.jsonl') + const s = await stat(ledgerPath).catch(() => null) + if (!s?.isFile()) continue + + const manifest = await readAgentManifest(agentDir) + sources.push({ + path: ledgerPath, + project: projectFromManifest(manifest, entry.name, home.projectPrefix), + provider: 'lingtai-tui', + }) + } + + return sources +} + +async function discoverLedgers(homes: LingTaiHome[]): Promise<SessionSource[]> { + const sources: SessionSource[] = [] + const seen = new Set<string>() + + for (const home of homes) { + for (const source of await discoverLedgersInHome(home)) { + if (seen.has(source.path)) continue + seen.add(source.path) + sources.push(source) + } + } + + return sources +} + +function createParser(source: SessionSource): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + const agentDir = agentDirFromLedgerPath(source.path) + const manifest = await readAgentManifest(agentDir) + const agentId = manifest?.agent_id ?? basename(agentDir) + const fallbackModel = manifest?.llm?.model ?? 'unknown' + const fallbackEndpoint = manifest?.llm?.base_url ?? '' + const project = source.project || projectFromManifest(manifest, basename(agentDir)) + const projectPath = agentDir + + let lineNo = 0 + for await (const line of readSessionLines(source.path)) { + lineNo += 1 + const entry = parseLedgerLine(line) + if (!entry) continue + + const obj = entry as JsonObject + const inputTotal = numericField(obj, 'input') + const outputTokens = numericField(obj, 'output') + const reasoningTokens = numericField(obj, 'thinking') + const cachedInputTokens = numericField(obj, 'cached') + const totalTokens = inputTotal + outputTokens + reasoningTokens + cachedInputTokens + if (totalTokens === 0) continue + + // LingTai records provider-normalized input totals plus a separate + // cached count. Match CodeBurn's normal shape by billing cached tokens + // in cacheReadInputTokens, not again as fresh input. + const inputTokens = Math.max(0, inputTotal - cachedInputTokens) + const model = stringField(obj, 'model') ?? fallbackModel + const endpoint = stringField(obj, 'endpoint') ?? fallbackEndpoint + const timestamp = parseTimestamp(entry.ts) + const sourceLabel = stringField(obj, 'source') ?? 'main' + const emId = stringField(obj, 'em_id') ?? '' + const runId = stringField(obj, 'run_id') ?? '' + const sessionId = runId || `${agentId}:${sourceLabel}` + const activity = activityForSource(sourceLabel) + const dedupKey = [ + 'lingtai-tui', + source.path, + lineNo, + timestamp, + model, + endpoint, + sourceLabel, + emId, + runId, + inputTotal, + outputTokens, + reasoningTokens, + cachedInputTokens, + ].join(':') + + const costUSD = calculateCost( + model, + inputTokens, + outputTokens + reasoningTokens, + 0, + cachedInputTokens, + 0, + ) + + yield { + provider: 'lingtai-tui', + model, + inputTokens, + outputTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: cachedInputTokens, + cachedInputTokens, + reasoningTokens, + webSearchRequests: 0, + costUSD, + tools: activity.tools, + bashCommands: [], + subagentTypes: activity.subagentTypes, + timestamp, + speed: 'standard', + deduplicationKey: dedupKey, + turnId: `${sessionId}:line:${lineNo}`, + userMessage: activity.userMessage, + sessionId, + project, + projectPath, + } + } + }, + } +} + +export function createLingTaiTuiProvider(options?: string | LingTaiProviderOptions): Provider { + const providerOptions = normalizeOptions(options) + + return { + name: 'lingtai-tui', + displayName: 'LingTai TUI', + + modelDisplayName(model: string): string { + return getShortModelName(model) + }, + + toolDisplayName(rawTool: string): string { + return rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + return discoverLedgers(await getLingTaiHomes(providerOptions)) + }, + + createSessionParser(source: SessionSource): SessionParser { + return createParser(source) + }, + } +} + +export const lingtaiTui = createLingTaiTuiProvider() diff --git a/src/providers/mistral-vibe.ts b/src/providers/mistral-vibe.ts new file mode 100644 index 0000000..158a53a --- /dev/null +++ b/src/providers/mistral-vibe.ts @@ -0,0 +1,436 @@ +import { readdir, stat } from 'fs/promises' +import { basename, join } from 'path' +import { homedir } from 'os' + +import { readSessionFile, readSessionLines } from '../fs-utils.js' +import { calculateCost } from '../models.js' +import { extractBashCommands } from '../bash-utils.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' +import { safeNumber } from '../parser.js' + +const METADATA_FILENAME = 'meta.json' +const MESSAGES_FILENAME = 'messages.jsonl' +const DEFAULT_MODEL = 'mistral-medium-3.5' + +const modelDisplayNames: Record<string, string> = { + 'mistral-medium-3.5': 'Mistral Medium 3.5', + 'mistral-vibe-cli-latest': 'Mistral Vibe CLI', + 'devstral-small': 'Devstral Small', + 'devstral-small-latest': 'Devstral Small', + devstral: 'Devstral', + local: 'Local', +} + +const toolNameMap: Record<string, string> = { + bash: 'Bash', + read_file: 'Read', + write_file: 'Write', + search_replace: 'Edit', + grep: 'Grep', + task: 'Agent', + todo: 'TodoWrite', + skill: 'Skill', + web_fetch: 'WebFetch', + web_search: 'WebSearch', + ask_user_question: 'AskUser', + exit_plan_mode: 'ExitPlanMode', +} + +type VibeStats = { + session_prompt_tokens?: number + session_completion_tokens?: number + session_cost?: number + input_price_per_million?: number + output_price_per_million?: number + tokens_per_second?: number +} + +type VibeModelConfig = { + name?: string + alias?: string + input_price?: number + output_price?: number +} + +type VibeMetadata = { + session_id?: string + start_time?: string + end_time?: string | null + environment?: { + working_directory?: string | null + } + stats?: VibeStats + config?: { + active_model?: string + models?: VibeModelConfig[] + } + title?: string | null +} + +type VibeToolCall = { + function?: { + name?: string + arguments?: string | Record<string, unknown> | null + } +} + +type VibeMessage = { + role?: string + content?: unknown + message_id?: string + timestamp?: string + tool_calls?: VibeToolCall[] | null +} + +function getMistralVibeSessionsDir(override?: string): string { + if (override) return override + const configuredHome = process.env['VIBE_HOME'] + const vibeHome = configuredHome ? expandHome(configuredHome) : join(homedir(), '.vibe') + return join(vibeHome, 'logs', 'session') +} + +function expandHome(path: string): string { + if (path === '~') return homedir() + if (path.startsWith('~/')) return join(homedir(), path.slice(2)) + return path +} + +async function isFile(path: string): Promise<boolean> { + const s = await stat(path).catch(() => null) + return Boolean(s?.isFile()) +} + +async function isDirectory(path: string): Promise<boolean> { + const s = await stat(path).catch(() => null) + return Boolean(s?.isDirectory()) +} + +async function hasSessionFiles(dir: string): Promise<boolean> { + const [hasMetadata, hasMessages] = await Promise.all([ + isFile(join(dir, METADATA_FILENAME)), + isFile(join(dir, MESSAGES_FILENAME)), + ]) + return hasMetadata && hasMessages +} + +async function readJsonFile<T>(path: string): Promise<T | null> { + const raw = await readSessionFile(path) + if (raw === null) return null + try { + const parsed = JSON.parse(raw) as unknown + return typeof parsed === 'object' && parsed !== null ? parsed as T : null + } catch { + return null + } +} + +async function discoverSessionDirs(root: string): Promise<string[]> { + const sessionDirs: string[] = [] + + let entries: string[] + try { + entries = (await readdir(root)).sort() + } catch { + return sessionDirs + } + + for (const entry of entries) { + const dir = join(root, entry) + if (!await isDirectory(dir)) continue + + if (await hasSessionFiles(dir)) { + sessionDirs.push(dir) + } + + const agentsDir = join(dir, 'agents') + if (!await isDirectory(agentsDir)) continue + + let agentEntries: string[] + try { + agentEntries = (await readdir(agentsDir)).sort() + } catch { + continue + } + + for (const agentEntry of agentEntries) { + const agentDir = join(agentsDir, agentEntry) + if (await isDirectory(agentDir) && await hasSessionFiles(agentDir)) { + sessionDirs.push(agentDir) + } + } + } + + return sessionDirs +} + +function activeModelConfig(metadata: VibeMetadata): VibeModelConfig | null { + const activeModel = metadata.config?.active_model + const models = metadata.config?.models + if (!activeModel || !Array.isArray(models)) return null + return models.find(m => m.alias === activeModel || m.name === activeModel) ?? null +} + +function resolveModel(metadata: VibeMetadata): string { + const activeModel = metadata.config?.active_model + if (activeModel) return activeModel + const configured = activeModelConfig(metadata) + return configured?.alias ?? configured?.name ?? DEFAULT_MODEL +} + +function calculateSessionCost(metadata: VibeMetadata, model: string, inputTokens: number, outputTokens: number): number { + const stats = metadata.stats ?? {} + const sessionCost = safeNumber(stats.session_cost) + if (sessionCost > 0) return sessionCost + + const configured = activeModelConfig(metadata) + const inputPrice = safeNumber(stats.input_price_per_million) || safeNumber(configured?.input_price) + const outputPrice = safeNumber(stats.output_price_per_million) || safeNumber(configured?.output_price) + + if (inputPrice > 0 || outputPrice > 0) { + return (inputTokens / 1_000_000) * inputPrice + (outputTokens / 1_000_000) * outputPrice + } + + return calculateCost(model, inputTokens, outputTokens, 0, 0, 0) +} + +function normalizeContent(content: unknown): string { + if (typeof content === 'string') return content + if (Array.isArray(content)) { + return content + .map(part => { + if (typeof part === 'string') return part + if (part && typeof part === 'object' && 'text' in part && typeof part.text === 'string') return part.text + return '' + }) + .filter(Boolean) + .join(' ') + } + return '' +} + +function parseToolArguments(raw: string | Record<string, unknown> | null | undefined): Record<string, unknown> { + if (!raw) return {} + if (typeof raw === 'object') return raw + try { + const parsed = JSON.parse(raw) as unknown + return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed as Record<string, unknown> : {} + } catch { + return {} + } +} + +function extractMessageTools(message: VibeMessage): { tools: string[]; bashCommands: string[] } { + const tools: string[] = [] + const bashCommands: string[] = [] + + if (message.role !== 'assistant') return { tools, bashCommands } + + for (const toolCall of message.tool_calls ?? []) { + const rawName = toolCall.function?.name + if (!rawName) continue + + const mappedName = toolNameMap[rawName] ?? rawName + tools.push(mappedName) + + if (mappedName !== 'Bash') continue + const args = parseToolArguments(toolCall.function?.arguments) + const command = args['command'] + if (typeof command === 'string') { + bashCommands.push(...extractBashCommands(command)) + } + } + + return { + tools: [...new Set(tools)], + bashCommands: [...new Set(bashCommands)], + } +} + +function extractTools(messages: VibeMessage[]): { tools: string[]; bashCommands: string[] } { + const tools: string[] = [] + const bashCommands: string[] = [] + + for (const message of messages) { + const extracted = extractMessageTools(message) + tools.push(...extracted.tools) + bashCommands.push(...extracted.bashCommands) + } + + return { + tools: [...new Set(tools)], + bashCommands: [...new Set(bashCommands)], + } +} + +async function readMessages(path: string): Promise<VibeMessage[]> { + const messages: VibeMessage[] = [] + for await (const line of readSessionLines(path)) { + if (!line.trim()) continue + try { + const parsed = JSON.parse(line) as unknown + if (parsed && typeof parsed === 'object') messages.push(parsed as VibeMessage) + } catch { + continue + } + } + return messages +} + +function firstUserMessage(messages: VibeMessage[], fallback?: string | null): string { + for (const message of messages) { + if (message.role !== 'user') continue + const text = normalizeContent(message.content).trim() + if (text) return text.slice(0, 500) + } + return (fallback ?? '').slice(0, 500) +} + +function allocateInteger(total: number, index: number, count: number): number { + if (count <= 1) return total + const base = Math.floor(total / count) + const remainder = total % count + return base + (index < remainder ? 1 : 0) +} + +function allocateCost(total: number, count: number): number { + return count <= 1 ? total : total / count +} + +function createParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + const metadataPath = join(source.path, METADATA_FILENAME) + const messagesPath = join(source.path, MESSAGES_FILENAME) + const metadata = await readJsonFile<VibeMetadata>(metadataPath) + if (!metadata) return + + const stats = metadata.stats ?? {} + const inputTokens = safeNumber(stats.session_prompt_tokens) + const outputTokens = safeNumber(stats.session_completion_tokens) + if (inputTokens === 0 && outputTokens === 0) return + + const sessionId = metadata.session_id || basename(source.path) + const messages = await readMessages(messagesPath) + const model = resolveModel(metadata) + const costUSD = calculateSessionCost(metadata, model, inputTokens, outputTokens) + const assistantMessages = messages.filter(m => m.role === 'assistant') + const fallbackTimestamp = metadata.end_time ?? metadata.start_time ?? '' + + if (assistantMessages.length === 0) { + const deduplicationKey = `mistral-vibe:${sessionId}` + if (seenKeys.has(deduplicationKey)) return + seenKeys.add(deduplicationKey) + const { tools, bashCommands } = extractTools(messages) + + yield { + provider: 'mistral-vibe', + model, + inputTokens, + outputTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + tools, + bashCommands, + timestamp: fallbackTimestamp, + speed: 'standard', + deduplicationKey, + userMessage: firstUserMessage(messages, metadata.title), + sessionId, + } + return + } + + let currentUserMessage = (metadata.title ?? '').slice(0, 500) + let turnOrdinal = 0 + let currentTurnId = `${sessionId}:prelude` + let assistantOrdinal = 0 + + for (const message of messages) { + if (message.role === 'user') { + const text = normalizeContent(message.content).trim() + if (text) currentUserMessage = text.slice(0, 500) + currentTurnId = `${sessionId}:turn-${turnOrdinal++}` + continue + } + + if (message.role !== 'assistant') continue + + const messageKey = message.message_id || `idx-${assistantOrdinal}` + const deduplicationKey = `mistral-vibe:${sessionId}:${messageKey}` + const allocationIndex = assistantOrdinal + assistantOrdinal++ + + if (seenKeys.has(deduplicationKey)) continue + seenKeys.add(deduplicationKey) + + const { tools, bashCommands } = extractMessageTools(message) + + yield { + provider: 'mistral-vibe', + model, + inputTokens: allocateInteger(inputTokens, allocationIndex, assistantMessages.length), + outputTokens: allocateInteger(outputTokens, allocationIndex, assistantMessages.length), + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD: allocateCost(costUSD, assistantMessages.length), + tools, + bashCommands, + timestamp: message.timestamp ?? fallbackTimestamp, + speed: 'standard', + deduplicationKey, + turnId: currentTurnId, + userMessage: currentUserMessage, + sessionId, + } + } + }, + } +} + +export function createMistralVibeProvider(sessionsDir?: string): Provider { + const dir = getMistralVibeSessionsDir(sessionsDir) + + return { + name: 'mistral-vibe', + displayName: 'Mistral Vibe', + + modelDisplayName(model: string): string { + return modelDisplayNames[model] ?? model + }, + + toolDisplayName(rawTool: string): string { + return toolNameMap[rawTool] ?? rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + const dirs = await discoverSessionDirs(dir) + const sources: SessionSource[] = [] + + for (const sessionDir of dirs) { + const metadata = await readJsonFile<VibeMetadata>(join(sessionDir, METADATA_FILENAME)) + if (!metadata) continue + const cwd = metadata.environment?.working_directory + sources.push({ + path: sessionDir, + project: cwd ? basename(cwd) : basename(sessionDir), + provider: 'mistral-vibe', + }) + } + + return sources + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const mistralVibe = createMistralVibeProvider() diff --git a/src/providers/mux.ts b/src/providers/mux.ts new file mode 100644 index 0000000..4ebd919 --- /dev/null +++ b/src/providers/mux.ts @@ -0,0 +1,282 @@ +import { readdir, readFile, stat } from 'fs/promises' +import { basename, dirname, join, resolve } from 'path' +import { homedir } from 'os' + +import { readSessionLines } from '../fs-utils.js' +import { calculateCost, getShortModelName } from '../models.js' +import { extractBashCommands } from '../bash-utils.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' +import { safeNumber } from '../parser.js' + +const toolNameMap: Record<string, string> = { + bash: 'Bash', + file_read: 'Read', + file_edit_replace_string: 'Edit', + file_edit_replace_lines: 'Edit', + file_edit_insert: 'Edit', + file_edit_operation: 'Edit', + web_fetch: 'WebFetch', + web_search: 'WebSearch', + task: 'Agent', + todo: 'TodoWrite', +} + +type MuxPart = { + type?: string + text?: string + toolName?: string + input?: unknown +} + +type MuxMessage = { + id?: string + role?: string + parts?: MuxPart[] + createdAt?: string + metadata?: { + model?: string + timestamp?: number + historySequence?: number + usage?: unknown + providerMetadata?: Record<string, unknown> + } +} + +function expandHome(p: string): string { + if (p === '~') return homedir() + if (p.startsWith('~/') || p.startsWith('~\\')) return join(homedir(), p.slice(2)) + return p +} + +function getMuxRoot(override?: string): string { + if (override) return resolve(expandHome(override)) + const codeburnOverride = process.env['CODEBURN_MUX_DIR'] + if (codeburnOverride) return resolve(expandHome(codeburnOverride)) + const muxRoot = process.env['MUX_ROOT'] + if (muxRoot) return resolve(expandHome(muxRoot)) + return join(homedir(), '.mux') +} + +// Splits on the first colon only, leaving any colon inside the id intact. +function stripProvider(model: string): string { + const i = model.indexOf(':') + return i >= 0 ? model.slice(i + 1) : model +} + +function asRecord(v: unknown): Record<string, unknown> | undefined { + return v !== null && typeof v === 'object' ? (v as Record<string, unknown>) : undefined +} + +// Guard against non-finite / out-of-range ms, which make toISOString() throw. +function toIsoTimestamp(ts: unknown, createdAt: unknown): string { + if (typeof ts === 'number' && Number.isFinite(ts)) { + const d = new Date(ts) + if (!Number.isNaN(d.getTime())) return d.toISOString() + } + return typeof createdAt === 'string' ? createdAt : '' +} + +// config.json shape: { projects: [[projectPath, { workspaces: [{ id }] }], ...] } +async function loadProjectMap(root: string): Promise<Map<string, string>> { + const map = new Map<string, string>() + let data: unknown + try { + data = JSON.parse(await readFile(join(root, 'config.json'), 'utf-8')) + } catch { + return map + } + const projects = asRecord(data)?.['projects'] + if (!Array.isArray(projects)) return map + for (const pair of projects) { + if (!Array.isArray(pair) || pair.length < 2) continue + const projectPath = pair[0] + if (typeof projectPath !== 'string') continue + const label = basename(projectPath) || projectPath + const workspaces = asRecord(pair[1])?.['workspaces'] + if (!Array.isArray(workspaces)) continue + for (const ws of workspaces) { + const id = asRecord(ws)?.['id'] + if (typeof id === 'string' && id) map.set(id, label) + } + } + return map +} + +async function pushChatSource(sources: SessionSource[], chatPath: string, project: string): Promise<void> { + const s = await stat(chatPath).catch(() => null) + if (s?.isFile()) sources.push({ path: chatPath, project, provider: 'mux' }) +} + +async function discoverSessions(root: string): Promise<SessionSource[]> { + const sessionsDir = join(root, 'sessions') + + let workspaceIds: string[] + try { + workspaceIds = await readdir(sessionsDir) + } catch { + return [] + } + + const projectMap = await loadProjectMap(root) + const sources: SessionSource[] = [] + for (const workspaceId of workspaceIds) { + const workspaceDir = join(sessionsDir, workspaceId) + const project = projectMap.get(workspaceId) ?? workspaceId + + // The workspace's own turns. + await pushChatSource(sources, join(workspaceDir, 'chat.jsonl'), project) + + // Sub-agent turns. Each spawned sub-agent is a separate LLM-client session + // recorded at subagent-transcripts/<childTaskId>/chat.jsonl — mux does NOT + // mirror these into a top-level sessions/<id> dir, so they are only + // reachable here. They carry real token usage (often the bulk of a + // session's spend) and are attributed to the parent workspace's project. + // Dedup stays correct: the parser keys off the child-task dir name, which + // is distinct from every workspace id, so each call is still counted once. + const subagentDir = join(workspaceDir, 'subagent-transcripts') + let childTaskIds: string[] + try { + childTaskIds = await readdir(subagentDir) + } catch { + continue + } + for (const childTaskId of childTaskIds) { + await pushChatSource(sources, join(subagentDir, childTaskId, 'chat.jsonl'), project) + } + } + return sources +} + +function createParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + const workspaceId = basename(dirname(source.path)) + let pendingUserMessage = '' + let lineIdx = 0 + + for await (const line of readSessionLines(source.path)) { + lineIdx++ + let msg: MuxMessage + try { + msg = JSON.parse(line) as MuxMessage + } catch { + continue + } + if (!msg || typeof msg !== 'object') continue + + if (msg.role === 'user') { + const texts = (Array.isArray(msg.parts) ? msg.parts : []) + .filter(p => p?.type === 'text' && typeof p.text === 'string') + .map(p => p.text as string) + .filter(Boolean) + if (texts.length > 0) pendingUserMessage = texts.join(' ').slice(0, 500) + continue + } + + if (msg.role !== 'assistant') continue + const meta = msg.metadata + const usage = asRecord(meta?.usage) + if (!meta || !usage) continue + + const pm = meta.providerMetadata ?? {} + const anthropic = asRecord(pm['anthropic']) + + // mux reports inputTokens inclusive of cache read+creation and + // outputTokens inclusive of reasoning; decompose to codeburn's + // cache/reasoning-exclusive convention. Cache creation is Anthropic-only. + // The AI SDK v6 normalizes reasoning into usage.reasoningTokens across + // every provider family, so that field is the single source of truth. + const cacheRead = safeNumber(usage['cachedInputTokens']) + const cacheCreate = safeNumber(anthropic?.['cacheCreationInputTokens']) + const reasoning = safeNumber(usage['reasoningTokens']) + const inputTokens = Math.max(0, safeNumber(usage['inputTokens']) - cacheRead - cacheCreate) + const outputTokens = Math.max(0, safeNumber(usage['outputTokens']) - reasoning) + + if (inputTokens === 0 && outputTokens === 0 && cacheRead === 0 && cacheCreate === 0 && reasoning === 0) { + continue + } + + // Strip the "provider:" prefix — codeburn's getCanonicalName only strips + // slash prefixes, so a colon-prefixed model would price at $0. + const rawModel = typeof meta.model === 'string' && meta.model ? meta.model : 'unknown' + const model = stripProvider(rawModel) + const id = typeof msg.id === 'string' && msg.id ? msg.id : `L${lineIdx}` + const dedupKey = `mux:${workspaceId}:${id}` + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + const toolParts = (Array.isArray(msg.parts) ? msg.parts : []).filter( + p => p?.type === 'dynamic-tool' && typeof p.toolName === 'string', + ) + const tools = toolParts.map(p => toolNameMap[p.toolName!] ?? p.toolName!) + const bashCommands = toolParts + .filter(p => p.toolName === 'bash') + .flatMap(p => { + const input = asRecord(p.input) + const script = input?.['script'] ?? input?.['command'] + return typeof script === 'string' ? extractBashCommands(script) : [] + }) + + const costUSD = calculateCost( + model, + inputTokens, + outputTokens + reasoning, + cacheCreate, + cacheRead, + 0, + ) + + const timestamp = toIsoTimestamp(meta.timestamp, msg.createdAt) + + yield { + provider: 'mux', + model, + inputTokens, + outputTokens, + cacheCreationInputTokens: cacheCreate, + cacheReadInputTokens: cacheRead, + cachedInputTokens: cacheRead, + reasoningTokens: reasoning, + webSearchRequests: 0, + costUSD, + tools, + bashCommands, + timestamp, + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: pendingUserMessage, + sessionId: workspaceId, + } + + pendingUserMessage = '' + } + }, + } +} + +export function createMuxProvider(muxRoot?: string): Provider { + const root = getMuxRoot(muxRoot) + + return { + name: 'mux', + displayName: 'Mux', + + modelDisplayName(model: string): string { + return getShortModelName(stripProvider(model)) + }, + + toolDisplayName(rawTool: string): string { + return toolNameMap[rawTool] ?? rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + return discoverSessions(root) + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const mux = createMuxProvider() diff --git a/src/providers/open-design.ts b/src/providers/open-design.ts new file mode 100644 index 0000000..5a2a079 --- /dev/null +++ b/src/providers/open-design.ts @@ -0,0 +1,259 @@ +import { readdir, stat } from 'fs/promises' +import { basename, dirname, join } from 'path' +import { homedir, platform } from 'os' + +import { readSessionLines } from '../fs-utils.js' +import { calculateCost } from '../models.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' + +const PROVIDER_NAME = 'open-design' +const ENV_DIR = 'CODEBURN_OPEN_DESIGN_DIR' + +const modelDisplayNames = new Map<string, string>([ + ['openai-codex:gpt-5.5', 'GPT-5.5'], + ['glm-5.2', 'GLM-5.2'], + ['GLM-5.2', 'GLM-5.2'], +]) + +type OpenDesignEntry = { + id?: unknown + event?: unknown + data?: unknown + timestamp?: unknown +} + +type TokenUsage = { + inputTokens: number + outputTokens: number + cacheReadTokens: number + reasoningTokens: number +} + +function isRecord(value: unknown): value is Record<string, unknown> { + return typeof value === 'object' && value !== null && !Array.isArray(value) +} + +function stringValue(value: unknown): string | undefined { + return typeof value === 'string' && value.length > 0 ? value : undefined +} + +function tokenValue(value: unknown): number { + return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0 +} + +function timestampValue(value: unknown): string { + const text = stringValue(value) + if (text) return text + if (typeof value !== 'number' || !Number.isFinite(value)) return '' + + const date = new Date(value) + return Number.isNaN(date.getTime()) ? '' : date.toISOString() +} + +function parseEvent(line: string | Buffer): OpenDesignEntry | null { + const text = (typeof line === 'string' ? line : line.toString('utf-8')).trim() + if (!text) return null + + try { + const parsed = JSON.parse(text) as unknown + return isRecord(parsed) ? parsed : null + } catch { + return null + } +} + +function parseUsage(data: unknown): TokenUsage | null { + if (!isRecord(data) || data['type'] !== 'usage') return null + const usage = data['usage'] + if (!isRecord(usage)) return null + + return { + inputTokens: tokenValue(usage['input_tokens']), + outputTokens: tokenValue(usage['output_tokens']), + cacheReadTokens: tokenValue(usage['cached_read_tokens']), + reasoningTokens: tokenValue(usage['thought_tokens']), + } +} + +function getOpenDesignDir(): string { + const override = process.env[ENV_DIR] + if (override) return override + + const home = homedir() + const os = platform() + if (os === 'darwin') { + return join(home, 'Library', 'Application Support', 'Open Design') + } + if (os === 'win32') { + return join(process.env['APPDATA'] ?? join(home, 'AppData', 'Roaming'), 'Open Design') + } + return join(home, '.config', 'Open Design') +} + +function namespaceFromDataDir(dataDir: string): string { + const ns = basename(dirname(dataDir)) + return ns && ns !== 'namespaces' ? ns : PROVIDER_NAME +} + +function namespaceFromRunsDir(runsDir: string): string { + return namespaceFromDataDir(dirname(runsDir)) +} + +async function discoverRunsDir(runsDir: string, project: string): Promise<SessionSource[]> { + const sources: SessionSource[] = [] + let runDirs: string[] + try { + runDirs = await readdir(runsDir) + } catch { + return sources + } + + for (const runDir of runDirs) { + const eventsPath = join(runsDir, runDir, 'events.jsonl') + const s = await stat(eventsPath).catch(() => null) + if (!s?.isFile()) continue + sources.push({ path: eventsPath, project, provider: PROVIDER_NAME }) + } + + return sources +} + +async function discoverNamespacesDir(namespacesDir: string): Promise<SessionSource[]> { + const sources: SessionSource[] = [] + let namespaces: string[] + try { + namespaces = await readdir(namespacesDir) + } catch { + return sources + } + + for (const ns of namespaces) { + const runsDir = join(namespacesDir, ns, 'data', 'runs') + sources.push(...await discoverRunsDir(runsDir, ns)) + } + + return sources +} + +function dedupeSources(sources: SessionSource[]): SessionSource[] { + const seen = new Set<string>() + const out: SessionSource[] = [] + for (const source of sources) { + if (seen.has(source.path)) continue + seen.add(source.path) + out.push(source) + } + return out +} + +async function discoverOpenDesignSessions(baseDir: string): Promise<SessionSource[]> { + const baseName = basename(baseDir) + if (baseName === 'runs') { + return discoverRunsDir(baseDir, namespaceFromRunsDir(baseDir)) + } + if (baseName === 'data') { + return discoverRunsDir(join(baseDir, 'runs'), namespaceFromDataDir(baseDir)) + } + + const sources: SessionSource[] = [] + sources.push(...await discoverRunsDir(join(baseDir, 'data', 'runs'), basename(baseDir) || PROVIDER_NAME)) + sources.push(...await discoverRunsDir(join(baseDir, 'runs'), basename(baseDir) || PROVIDER_NAME)) + sources.push(...await discoverNamespacesDir(baseName === 'namespaces' ? baseDir : join(baseDir, 'namespaces'))) + return dedupeSources(sources) +} + +function createParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + const sessionId = basename(dirname(source.path)) + let currentModel = '' + let fallbackEventCounter = 0 + + for await (const line of readSessionLines(source.path)) { + const entry = parseEvent(line) + if (!entry) continue + + const eventName = stringValue(entry.event) + const data = entry.data + + if (eventName === 'start' && isRecord(data)) { + const model = stringValue(data['model']) + if (model) currentModel = model + continue + } + + if (eventName !== 'agent' || !isRecord(data)) continue + + if (data['type'] === 'status') { + const model = stringValue(data['model']) + if (model) currentModel = model + continue + } + + const usage = parseUsage(data) + if (!usage || !currentModel) continue + + const eventId = stringValue(entry.id) ?? `line-${fallbackEventCounter++}` + const dedupKey = `${PROVIDER_NAME}:${sessionId}:${eventId}` + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + const uncachedInputTokens = Math.max(0, usage.inputTokens - usage.cacheReadTokens) + const costUSD = calculateCost( + currentModel, + uncachedInputTokens, + usage.outputTokens + usage.reasoningTokens, + 0, + usage.cacheReadTokens, + 0, + ) + + yield { + provider: PROVIDER_NAME, + sessionId, + project: source.project, + model: currentModel, + inputTokens: uncachedInputTokens, + outputTokens: usage.outputTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: usage.cacheReadTokens, + cachedInputTokens: usage.cacheReadTokens, + reasoningTokens: usage.reasoningTokens, + webSearchRequests: 0, + costUSD, + tools: [], + bashCommands: [], + timestamp: timestampValue(entry.timestamp), + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: '', + } + } + }, + } +} + +export function createOpenDesignProvider(overrideDir?: string): Provider { + return { + name: PROVIDER_NAME, + displayName: 'Open Design', + + modelDisplayName(model: string): string { + return modelDisplayNames.get(model) ?? model + }, + + toolDisplayName(rawTool: string): string { + return rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + return discoverOpenDesignSessions(overrideDir ?? getOpenDesignDir()) + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const openDesign = createOpenDesignProvider() diff --git a/src/providers/openclaw.ts b/src/providers/openclaw.ts new file mode 100644 index 0000000..bc6da53 --- /dev/null +++ b/src/providers/openclaw.ts @@ -0,0 +1,282 @@ +import { readdir, readFile } from 'fs/promises' +import { basename, join } from 'path' +import { homedir } from 'os' + +import { readSessionFile } from '../fs-utils.js' +import { calculateCost } from '../models.js' +import { extractBashCommands } from '../bash-utils.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' + +const toolNameMap: Record<string, string> = { + bash: 'Bash', + exec: 'Bash', + read: 'Read', + edit: 'Edit', + write: 'Write', + glob: 'Glob', + grep: 'Grep', + task: 'Agent', + dispatch_agent: 'Agent', + fetch: 'WebFetch', + search: 'WebSearch', + todo: 'TodoWrite', + patch: 'Patch', +} + +type OpenClawUsage = { + input: number + output: number + cacheRead: number + cacheWrite: number + totalTokens?: number + cost?: { + total?: number + } +} + +type OpenClawEntry = { + type: string + customType?: string + id?: string + timestamp?: string + provider?: string + modelId?: string + data?: { + provider?: string + modelId?: string + } + message?: { + role?: string + content?: Array<{ type?: string; text?: string; name?: string; arguments?: Record<string, unknown> }> + model?: string + provider?: string + usage?: OpenClawUsage + } +} + +type SessionIndex = Record<string, { + sessionId: string + sessionFile?: string +}> + +function getOpenClawDirs(): string[] { + const home = homedir() + return [ + join(home, '.openclaw', 'agents'), + join(home, '.clawdbot', 'agents'), + join(home, '.moltbot', 'agents'), + join(home, '.moldbot', 'agents'), + ] +} + +function extractTools(content: Array<{ type?: string; name?: string; arguments?: Record<string, unknown> }> | undefined): { tools: string[]; bashCommands: string[] } { + const tools: string[] = [] + const bashCommands: string[] = [] + if (!content) return { tools, bashCommands } + + for (const block of content) { + if ((block.type === 'tool_use' || block.type === 'toolCall') && block.name) { + const mapped = toolNameMap[block.name] ?? block.name + tools.push(mapped) + if (mapped === 'Bash' && block.arguments && typeof block.arguments.command === 'string') { + bashCommands.push(...extractBashCommands(block.arguments.command)) + } + } + } + return { tools, bashCommands } +} + +function createParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + const raw = await readSessionFile(source.path) + if (raw === null) return + + const lines = raw.split('\n').filter(l => l.trim()) + let sessionId = '' + let sessionTimestamp = '' + let currentModel = '' + + const calls: { + model: string + usage: OpenClawUsage + tools: string[] + bashCommands: string[] + timestamp: string + userMessage: string + dedupId: string + }[] = [] + + let pendingUserMessage = '' + + for (const line of lines) { + let entry: OpenClawEntry + try { + entry = JSON.parse(line) + } catch { + continue + } + + if (entry.type === 'session') { + sessionId = entry.id ?? basename(source.path, '.jsonl') + sessionTimestamp = entry.timestamp ?? '' + continue + } + + if (entry.type === 'model_change') { + currentModel = entry.modelId ?? currentModel + continue + } + + if (entry.type === 'custom' && entry.customType === 'model-snapshot') { + currentModel = entry.data?.modelId ?? currentModel + continue + } + + if (entry.type !== 'message' || !entry.message) continue + + const msg = entry.message + if (msg.role === 'user') { + if (!pendingUserMessage && Array.isArray(msg.content)) { + const textBlock = msg.content.find(c => c.type === 'text' && c.text) + pendingUserMessage = (textBlock?.text ?? '').slice(0, 500) + } + continue + } + + if (msg.role !== 'assistant') continue + + const model = msg.model ?? currentModel + if (msg.usage) { + const { tools, bashCommands } = extractTools(msg.content) + calls.push({ + model, + usage: msg.usage, + tools, + bashCommands, + timestamp: entry.timestamp ?? sessionTimestamp, + userMessage: pendingUserMessage, + dedupId: entry.id ?? '', + }) + pendingUserMessage = '' + } + } + + if (!sessionId) sessionId = basename(source.path, '.jsonl') + + for (let i = 0; i < calls.length; i++) { + const call = calls[i] + const dedupKey = `openclaw:${sessionId}:${call.dedupId || i}` + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + const u = call.usage + const costFromProvider = u.cost?.total ?? 0 + const costUSD = costFromProvider > 0 + ? costFromProvider + : calculateCost(call.model, u.input, u.output, u.cacheWrite, u.cacheRead, 0) + + const ts = new Date(call.timestamp) + if (isNaN(ts.getTime()) || ts.getTime() < 1_000_000_000_000) continue + + yield { + provider: 'openclaw', + model: call.model || 'openclaw-auto', + inputTokens: u.input, + outputTokens: u.output, + cacheCreationInputTokens: u.cacheWrite, + cacheReadInputTokens: u.cacheRead, + cachedInputTokens: u.cacheRead, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + tools: [...new Set(call.tools)], + bashCommands: [...new Set(call.bashCommands)], + timestamp: ts.toISOString(), + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: call.userMessage, + sessionId, + } + } + }, + } +} + +async function discoverInDir(agentsDir: string): Promise<SessionSource[]> { + const sources: SessionSource[] = [] + + let agentDirs: string[] + try { + const entries = await readdir(agentsDir, { withFileTypes: true }) + agentDirs = entries.filter(e => e.isDirectory()).map(e => e.name) + } catch { + return sources + } + + for (const agent of agentDirs) { + const sessionsDir = join(agentsDir, agent, 'sessions') + + let indexData: SessionIndex = {} + try { + const indexRaw = await readFile(join(sessionsDir, 'sessions.json'), 'utf-8') + indexData = JSON.parse(indexRaw) + } catch { /* no index, fall back to directory scan */ } + + const seenFiles = new Set<string>() + + for (const entry of Object.values(indexData)) { + if (entry.sessionFile) { + seenFiles.add(entry.sessionFile) + sources.push({ path: entry.sessionFile, project: agent, provider: 'openclaw' }) + } else if (entry.sessionId) { + const filePath = join(sessionsDir, `${entry.sessionId}.jsonl`) + seenFiles.add(filePath) + sources.push({ path: filePath, project: agent, provider: 'openclaw' }) + } + } + + try { + const files = await readdir(sessionsDir) + for (const f of files) { + if (!f.endsWith('.jsonl')) continue + const filePath = join(sessionsDir, f) + if (seenFiles.has(filePath)) continue + sources.push({ path: filePath, project: agent, provider: 'openclaw' }) + } + } catch { /* directory may not exist */ } + } + + return sources +} + +export function createOpenClawProvider(overrideDir?: string): Provider { + return { + name: 'openclaw', + displayName: 'OpenClaw', + + modelDisplayName(model: string): string { + return model + }, + + toolDisplayName(rawTool: string): string { + return toolNameMap[rawTool] ?? rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + if (overrideDir) return discoverInDir(overrideDir) + const all: SessionSource[] = [] + for (const dir of getOpenClawDirs()) { + const sessions = await discoverInDir(dir) + all.push(...sessions) + } + return all + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const openclaw = createOpenClawProvider() diff --git a/src/providers/opencode-file-parser.ts b/src/providers/opencode-file-parser.ts new file mode 100644 index 0000000..60bfb6a --- /dev/null +++ b/src/providers/opencode-file-parser.ts @@ -0,0 +1,154 @@ +import { readdir, readFile } from 'fs/promises' +import { join } from 'path' + +import { buildAssistantCall, sanitize, type MessageData, type PartData } from './session-message.js' +import type { SessionSource, SessionParser, ParsedProviderCall } from './types.js' + +// OpenCode 1.1+ stores sessions as file-based JSON instead of a SQLite DB: +// storage/session/<projectID>/<sessionID>.json session metadata +// storage/message/<sessionID>/<messageID>.json one file per message +// storage/part/<messageID>/<partID>.json one file per part +// The message/part shape matches the SQLite layout, so the per-message build +// logic is shared via buildAssistantCall. + +type SessionMeta = { + id?: string + directory?: string + title?: string + time?: { created?: number } +} + +type FileMessageData = MessageData & { + id?: string + time?: { created?: number } +} + +async function readJson<T>(path: string): Promise<T | null> { + try { + return JSON.parse(await readFile(path, 'utf8')) as T + } catch { + return null + } +} + +async function readParts(dataDir: string, messageId: string): Promise<PartData[]> { + const dir = join(dataDir, 'storage', 'part', messageId) + let files: string[] + try { + files = (await readdir(dir)).sort() + } catch { + return [] + } + const parts: PartData[] = [] + for (const f of files) { + if (!f.endsWith('.json')) continue + const part = await readJson<PartData>(join(dir, f)) + if (part) parts.push(part) + } + return parts +} + +export async function discoverOpenCodeFileSessions( + dataDir: string, + providerName: string, +): Promise<SessionSource[]> { + const sessionRoot = join(dataDir, 'storage', 'session') + let projectDirs: string[] + try { + projectDirs = await readdir(sessionRoot) + } catch { + return [] + } + + const sources: SessionSource[] = [] + for (const project of projectDirs) { + let files: string[] + try { + files = await readdir(join(sessionRoot, project)) + } catch { + continue + } + for (const f of files) { + if (!f.endsWith('.json')) continue + const path = join(sessionRoot, project, f) + const meta = await readJson<SessionMeta>(path) + if (!meta?.id) continue + sources.push({ + path, + project: sanitize(meta.directory || meta.title || ''), + provider: providerName, + }) + } + } + return sources +} + +export function createOpenCodeFileSessionParser( + source: SessionSource, + seenKeys: Set<string>, + dataDir: string, + providerName: string, +): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + const meta = await readJson<SessionMeta>(source.path) + if (!meta?.id) return + const sessionId = meta.id + + const messageDir = join(dataDir, 'storage', 'message', sessionId) + let messageFiles: string[] + try { + messageFiles = await readdir(messageDir) + } catch { + return + } + + const messages: Array<{ id: string; data: FileMessageData }> = [] + for (const f of messageFiles) { + if (!f.endsWith('.json')) continue + const data = await readJson<FileMessageData>(join(messageDir, f)) + if (!data) continue + messages.push({ id: data.id ?? f.replace(/\.json$/, ''), data }) + } + messages.sort((a, b) => { + const byTime = (a.data.time?.created ?? 0) - (b.data.time?.created ?? 0) + if (byTime !== 0) return byTime + return a.id < b.id ? -1 : a.id > b.id ? 1 : 0 + }) + + let currentUserMessage = '' + for (const { id, data } of messages) { + if (data.role === 'user') { + const parts = await readParts(dataDir, id) + const text = parts + .filter((p) => p.type === 'text') + .map((p) => p.text ?? '') + .filter(Boolean) + .join(' ') + if (text) currentUserMessage = text + continue + } + + if (data.role !== 'assistant' && data.role !== 'model') continue + + const dedupKey = `${providerName}:${sessionId}:${id}` + if (seenKeys.has(dedupKey)) continue + + const parts = await readParts(dataDir, id) + const call = buildAssistantCall({ + providerName, + dedupKey, + sessionId, + data, + parts, + timeCreatedMs: data.time?.created ?? meta.time?.created ?? 0, + userMessage: currentUserMessage, + }) + if (!call) continue + + seenKeys.add(dedupKey) + yield call + } + }, + } +} diff --git a/src/providers/opencode.ts b/src/providers/opencode.ts new file mode 100644 index 0000000..651f3cf --- /dev/null +++ b/src/providers/opencode.ts @@ -0,0 +1,79 @@ +import { join } from 'path' +import { homedir } from 'os' + +import { getShortModelName } from '../models.js' +import { discoverSqliteSessions, createSqliteSessionParser, type SqliteProviderConfig } from './sqlite-session-parser.js' +import { discoverOpenCodeFileSessions, createOpenCodeFileSessionParser } from './opencode-file-parser.js' +import type { Provider, SessionSource, SessionParser } from './types.js' + +const toolNameMap: Record<string, string> = { + bash: 'Bash', + read: 'Read', + edit: 'Edit', + write: 'Write', + glob: 'Glob', + grep: 'Grep', + task: 'Agent', + fetch: 'WebFetch', + search: 'WebSearch', + todo: 'TodoWrite', + skill: 'Skill', + patch: 'Patch', +} + +function getDataDir(dataDir?: string): string { + const base = + dataDir ?? + process.env['XDG_DATA_HOME'] ?? + join(homedir(), '.local', 'share') + return join(base, 'opencode') +} + +function getSqliteConfig(dataDir?: string): SqliteProviderConfig { + return { + providerName: 'opencode', + displayName: 'OpenCode', + dbDir: getDataDir(dataDir), + dbFilePrefix: 'opencode', + } +} + +export function createOpenCodeProvider(dataDir?: string): Provider { + const sqliteConfig = getSqliteConfig(dataDir) + const resolvedDataDir = getDataDir(dataDir) + + return { + name: 'opencode', + displayName: 'OpenCode', + + modelDisplayName(model: string): string { + const stripped = model.replace(/^[^/]+\//, '') + return getShortModelName(stripped) + }, + + toolDisplayName(rawTool: string): string { + return toolNameMap[rawTool] ?? rawTool + }, + + // OpenCode migrated from file-based JSON (storage/session/*.json) to a + // SQLite DB (opencode.db). After an in-place upgrade, legacy JSON files + // remain on disk while all new data flows into the SQLite DB. Merge both + // sources so migrated installs keep reporting legacy sessions AND pick up + // current SQLite data. Dedup is handled per-message in createSessionParser + // via seenKeys (keyed by `${provider}:${sessionId}:${messageId}`). + async discoverSessions(): Promise<SessionSource[]> { + const fileSessions = await discoverOpenCodeFileSessions(resolvedDataDir, 'opencode') + const sqliteSessions = await discoverSqliteSessions(sqliteConfig) + return [...fileSessions, ...sqliteSessions] + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + if (source.path.endsWith('.json')) { + return createOpenCodeFileSessionParser(source, seenKeys, resolvedDataDir, 'opencode') + } + return createSqliteSessionParser(source, seenKeys, sqliteConfig) + }, + } +} + +export const opencode = createOpenCodeProvider() diff --git a/src/providers/pi.ts b/src/providers/pi.ts new file mode 100644 index 0000000..85d5f25 --- /dev/null +++ b/src/providers/pi.ts @@ -0,0 +1,314 @@ +import { readdir, stat } from 'fs/promises' +import { basename, join } from 'path' +import { homedir } from 'os' + +import { readSessionFile } from '../fs-utils.js' +import { calculateCost } from '../models.js' +import { extractBashCommands } from '../bash-utils.js' +import { normalizeContentBlocks } from '../content-utils.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' + +const modelDisplayNames: Record<string, string> = { + 'gpt-5.4': 'GPT-5.4', + 'gpt-5.4-mini': 'GPT-5.4 Mini', + 'gpt-5.5': 'GPT-5.5', + 'gpt-5': 'GPT-5', + 'gpt-4o': 'GPT-4o', + 'gpt-4o-mini': 'GPT-4o Mini', +} + +const toolNameMap: Record<string, string> = { + bash: 'Bash', + read: 'Read', + edit: 'Edit', + write: 'Write', + glob: 'Glob', + grep: 'Grep', + task: 'Agent', + dispatch_agent: 'Agent', + fetch: 'WebFetch', + search: 'WebSearch', + todo: 'TodoWrite', + patch: 'Patch', +} + +// Pre-sorted by key length descending so longer/more-specific keys match first +const modelDisplayEntries = Object.entries(modelDisplayNames).sort((a, b) => b[0].length - a[0].length) + +// Pi/OMP have no dedicated skill tool the way Claude Code does. A native skill +// load is emitted as an ordinary `read` tool call whose path points at the +// skill's `SKILL.md` (Pi resolves skills from many roots: ~/.pi/agent/skills, +// project .pi/skills, .agents/skills, package skills/, --skill <path>), or, in +// newer OMP builds, at a `skill://<name>` URI. Left untouched these inflate the +// Read tool count and leave the Skills dimension empty (issue #588). Return the +// skill name when a read is really a skill load, else null so it stays a Read. +function skillLoadName(name: string | undefined, args: Record<string, unknown> | undefined): string | null { + if (name !== 'read') return null + const raw = args?.['path'] ?? args?.['file_path'] + if (typeof raw !== 'string') return null + const path = raw.trim() + if (path.length === 0) return null + + if (path.startsWith('skill://')) { + const rest = path.slice('skill://'.length).replace(/^\/+/, '') + const first = rest.split(/[/?#]/)[0]?.trim() ?? '' + return first.length > 0 ? first : null + } + + // Match on the SKILL.md basename, not a directory prefix, because skill roots + // live in many locations. Split on both separators so Windows paths work. + const segments = path.split(/[\\/]/).filter(Boolean) + if (segments[segments.length - 1] !== 'SKILL.md') return null + const parent = segments[segments.length - 2]?.trim() + return parent && parent.length > 0 ? parent : null +} + +type PiEntry = { + type: string + id?: string + timestamp?: string + cwd?: string + message?: { + role?: string + content?: Array<{ type?: string; text?: string; name?: string; arguments?: Record<string, unknown> }> | string + model?: string + responseId?: string + usage?: { + input: number + output: number + cacheRead: number + cacheWrite: number + } + } +} + +function getPiSessionsDir(override?: string): string { + return override ?? join(homedir(), '.pi', 'agent', 'sessions') +} + +function getOmpSessionsDir(override?: string): string { + return override ?? join(homedir(), '.omp', 'agent', 'sessions') +} + +async function readFirstEntry(filePath: string): Promise<PiEntry | null> { + const content = await readSessionFile(filePath) + if (content === null) return null + const line = content.split('\n')[0] + if (!line?.trim()) return null + try { + return JSON.parse(line) as PiEntry + } catch { + return null + } +} + +async function discoverSessionsInDir(sessionsDir: string, providerName: string): Promise<SessionSource[]> { + const sources: SessionSource[] = [] + + let projectDirs: string[] + try { + projectDirs = await readdir(sessionsDir) + } catch { + return sources + } + + for (const dirName of projectDirs) { + const dirPath = join(sessionsDir, dirName) + const dirStat = await stat(dirPath).catch(() => null) + if (!dirStat?.isDirectory()) continue + + let files: string[] + try { + files = await readdir(dirPath) + } catch { + continue + } + + for (const file of files) { + if (!file.endsWith('.jsonl')) continue + const filePath = join(dirPath, file) + const fileStat = await stat(filePath).catch(() => null) + if (!fileStat?.isFile()) continue + + const first = await readFirstEntry(filePath) + if (!first || first.type !== 'session') continue + + const cwd = first.cwd ?? dirName + sources.push({ path: filePath, project: basename(cwd), provider: providerName }) + } + } + + return sources +} + +function createParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + const content = await readSessionFile(source.path) + if (content === null) return + const lines = content.split('\n').filter(l => l.trim()) + let sessionId = basename(source.path, '.jsonl') + let pendingUserMessage = '' + + for (const [lineIdx, line] of lines.entries()) { + let entry: PiEntry + try { + entry = JSON.parse(line) as PiEntry + } catch { + continue + } + + if (entry.type === 'session') { + sessionId = entry.id ?? sessionId + continue + } + + if (entry.type !== 'message') continue + + const msg = entry.message + if (!msg) continue + + if (msg.role === 'user') { + const texts = normalizeContentBlocks(msg.content) + .filter(c => c.type === 'text') + .map(c => c.text ?? '') + .filter(Boolean) + if (texts.length > 0) pendingUserMessage = texts.join(' ') + continue + } + + if (msg.role !== 'assistant' || !msg.usage) continue + + // Coerce undefined/null token fields to 0. Pi/OMP session files + // sometimes omit individual usage fields; the destructure used to + // pass undefined into calculateCost which then returned NaN, and + // that NaN propagated into every aggregate cost total. + const input = msg.usage.input ?? 0 + const output = msg.usage.output ?? 0 + const cacheRead = msg.usage.cacheRead ?? 0 + const cacheWrite = msg.usage.cacheWrite ?? 0 + if (input === 0 && output === 0) continue + + const model = msg.model ?? 'gpt-5' + const responseId = msg.responseId ?? '' + const dedupKey = `${source.provider}:${source.path}:${responseId || entry.id || entry.timestamp || String(lineIdx)}` + + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + const toolCalls = normalizeContentBlocks(msg.content).filter(c => c.type === 'toolCall' && c.name) + + // A SKILL.md-loading read is surfaced as the `Skill` tool (not `Read`) + // and its name is recorded in `skills`. This mirrors how the Claude + // parser represents a skill invocation, so the shared classifier tags + // the turn `general` and the "Skills & Agents" breakdown picks it up, + // instead of over-counting a Read and leaving Skills empty (#588). + // Every other call stays a normal tool. + const tools: string[] = [] + const skills: string[] = [] + for (const c of toolCalls) { + const skill = skillLoadName(c.name, c.arguments) + if (skill !== null) { + skills.push(skill) + tools.push('Skill') + continue + } + tools.push(toolNameMap[c.name!] ?? c.name!) + } + + const bashCommands = toolCalls + .filter(c => c.name === 'bash') + .flatMap(c => { + const cmd = c.arguments?.['command'] + return typeof cmd === 'string' ? extractBashCommands(cmd) : [] + }) + + const costUSD = calculateCost(model, input, output, cacheWrite, cacheRead, 0) + const timestamp = entry.timestamp ?? '' + + yield { + provider: source.provider, + model, + inputTokens: input, + outputTokens: output, + cacheCreationInputTokens: cacheWrite, + cacheReadInputTokens: cacheRead, + cachedInputTokens: cacheRead, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + tools, + bashCommands, + skills, + timestamp, + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: pendingUserMessage, + sessionId, + } + + pendingUserMessage = '' + } + }, + } +} + +export function createPiProvider(sessionsDir?: string): Provider { + const dir = getPiSessionsDir(sessionsDir) + + return { + name: 'pi', + displayName: 'Pi', + + modelDisplayName(model: string): string { + for (const [key, name] of modelDisplayEntries) { + if (model.startsWith(key)) return name + } + return model + }, + + toolDisplayName(rawTool: string): string { + return toolNameMap[rawTool] ?? rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + return discoverSessionsInDir(dir, 'pi') + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const pi = createPiProvider() + +export function createOmpProvider(sessionsDir?: string): Provider { + const dir = getOmpSessionsDir(sessionsDir) + + return { + name: 'omp', + displayName: 'OMP', + + modelDisplayName(model: string): string { + for (const [key, name] of modelDisplayEntries) { + if (model.startsWith(key)) return name + } + return model + }, + + toolDisplayName(rawTool: string): string { + return toolNameMap[rawTool] ?? rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + return discoverSessionsInDir(dir, 'omp') + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const omp = createOmpProvider() diff --git a/src/providers/qwen.ts b/src/providers/qwen.ts new file mode 100644 index 0000000..427b5fd --- /dev/null +++ b/src/providers/qwen.ts @@ -0,0 +1,204 @@ +import { readdir, stat } from 'fs/promises' +import { basename, join } from 'path' +import { homedir } from 'os' + +import { readSessionFile } from '../fs-utils.js' +import { calculateCost } from '../models.js' +import { extractBashCommands } from '../bash-utils.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' + +const toolNameMap: Record<string, string> = { + read_file: 'Read', + write_to_file: 'Write', + edit_file: 'Edit', + execute_command: 'Bash', + search_files: 'Grep', + list_files: 'LS', + list_directory: 'LS', + browser_action: 'WebFetch', + web_search: 'WebSearch', + ask_followup_question: 'AskUser', + attempt_completion: 'Complete', +} + +type QwenPart = { + text?: string + thought?: boolean + functionCall?: { name?: string; args?: Record<string, unknown> } + functionResponse?: unknown +} + +type QwenEntry = { + uuid: string + sessionId: string + timestamp: string + type: string + subtype?: string + cwd?: string + model?: string + message?: { + role: string + parts: QwenPart[] + } + usageMetadata?: { + promptTokenCount: number + candidatesTokenCount: number + thoughtsTokenCount: number + totalTokenCount: number + cachedContentTokenCount: number + } +} + +function getQwenProjectsDir(): string { + return process.env['QWEN_DATA_DIR'] ?? join(homedir(), '.qwen', 'projects') +} + +function projectNameFromDirName(dirName: string): string { + const parts = dirName.replace(/^-/, '').split('-') + return parts[parts.length - 1] || dirName +} + +function extractTools(parts: QwenPart[]): { tools: string[]; bashCommands: string[] } { + const tools: string[] = [] + const bashCommands: string[] = [] + + for (const part of parts) { + if (part.functionCall?.name) { + const mapped = toolNameMap[part.functionCall.name] ?? part.functionCall.name + tools.push(mapped) + if (mapped === 'Bash' && part.functionCall.args && typeof part.functionCall.args['command'] === 'string') { + bashCommands.push(...extractBashCommands(part.functionCall.args['command'] as string)) + } + } + } + + return { tools, bashCommands } +} + +function createParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + const raw = await readSessionFile(source.path) + if (raw === null) return + + const lines = raw.split('\n').filter(l => l.trim()) + let pendingUserMessage = '' + + for (const line of lines) { + let entry: QwenEntry + try { + entry = JSON.parse(line) + } catch { + continue + } + + if (entry.type === 'user' && entry.message) { + const texts = (entry.message.parts ?? []) + .filter(p => p.text && !p.thought) + .map(p => p.text!) + if (texts.length > 0) { + pendingUserMessage = texts.join(' ').slice(0, 500) + } + continue + } + + if (entry.type !== 'assistant' || !entry.usageMetadata) continue + + const usage = entry.usageMetadata + if (usage.promptTokenCount === 0 && usage.candidatesTokenCount === 0) continue + + const dedupKey = `qwen:${entry.sessionId}:${entry.uuid}` + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + const model = entry.model || 'qwen-auto' + const { tools, bashCommands } = extractTools(entry.message?.parts ?? []) + + const inputTokens = usage.promptTokenCount + const outputTokens = usage.candidatesTokenCount + const reasoningTokens = usage.thoughtsTokenCount ?? 0 + const cachedTokens = usage.cachedContentTokenCount ?? 0 + + const costUSD = calculateCost(model, inputTokens, outputTokens + reasoningTokens, 0, cachedTokens, 0) + + yield { + provider: 'qwen', + model, + inputTokens, + outputTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: cachedTokens, + cachedInputTokens: cachedTokens, + reasoningTokens, + webSearchRequests: 0, + costUSD, + tools: [...new Set(tools)], + bashCommands: [...new Set(bashCommands)], + timestamp: entry.timestamp || '', + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: pendingUserMessage, + sessionId: entry.sessionId, + } + + pendingUserMessage = '' + } + }, + } +} + +export function createQwenProvider(overrideDir?: string): Provider { + const projectsDir = overrideDir ?? getQwenProjectsDir() + + return { + name: 'qwen', + displayName: 'Qwen', + + modelDisplayName(model: string): string { + return model + }, + + toolDisplayName(rawTool: string): string { + return toolNameMap[rawTool] ?? rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + const sources: SessionSource[] = [] + + let projectDirs: string[] + try { + projectDirs = await readdir(projectsDir) + } catch { + return sources + } + + for (const projDir of projectDirs) { + const chatsDir = join(projectsDir, projDir, 'chats') + const project = projectNameFromDirName(projDir) + + let chatFiles: string[] + try { + chatFiles = await readdir(chatsDir) + } catch { + continue + } + + for (const file of chatFiles) { + if (!file.endsWith('.jsonl')) continue + const filePath = join(chatsDir, file) + const s = await stat(filePath).catch(() => null) + if (!s?.isFile()) continue + sources.push({ path: filePath, project, provider: 'qwen' }) + } + } + + return sources + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const qwen = createQwenProvider() diff --git a/src/providers/roo-code.ts b/src/providers/roo-code.ts new file mode 100644 index 0000000..4059d96 --- /dev/null +++ b/src/providers/roo-code.ts @@ -0,0 +1,29 @@ +import { discoverClineTasks, createClineParser } from './vscode-cline-parser.js' +import type { Provider, SessionSource, SessionParser } from './types.js' + +const EXTENSION_ID = 'rooveterinaryinc.roo-cline' + +export function createRooCodeProvider(overrideDir?: string | string[]): Provider { + return { + name: 'roo-code', + displayName: 'Roo Code', + + modelDisplayName(model: string): string { + return model + }, + + toolDisplayName(rawTool: string): string { + return rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + return discoverClineTasks(EXTENSION_ID, 'roo-code', 'Roo Code', overrideDir) + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createClineParser(source, seenKeys, 'roo-code') + }, + } +} + +export const rooCode = createRooCodeProvider() diff --git a/src/providers/session-message.ts b/src/providers/session-message.ts new file mode 100644 index 0000000..f4e4eea --- /dev/null +++ b/src/providers/session-message.ts @@ -0,0 +1,167 @@ +import { calculateCost } from '../models.js' +import { extractBashCommands } from '../bash-utils.js' +import type { ParsedProviderCall } from './types.js' + +// The message/part shape shared by OpenCode-style stores (OpenCode SQLite, the +// OpenCode file-based JSON layout, and Kilo Code). Token-bearing assistant +// messages carry either the normalized `tokens` object or a raw `usage` block. +export type MessageData = { + role: string + modelID?: string + model?: string + cost?: number + tokens?: { + input?: number + output?: number + reasoning?: number + cache?: { read?: number; write?: number } + } + usage?: { + input_tokens?: number + output_tokens?: number + cache_creation_input_tokens?: number + cache_read_input_tokens?: number + } +} + +export type PartData = { + type: string + text?: string + tool?: string + state?: { input?: { command?: string; name?: string; subagent_type?: string } } +} + +const toolNameMap: Record<string, string> = { + bash: 'Bash', + read: 'Read', + edit: 'Edit', + write: 'Write', + glob: 'Glob', + grep: 'Grep', + task: 'Agent', + fetch: 'WebFetch', + search: 'WebSearch', + todo: 'TodoWrite', + skill: 'Skill', + patch: 'Patch', +} + +export function normalizeToolName(rawTool?: string): string { + if (!rawTool) return '' + if (rawTool.startsWith('mcp__')) return rawTool + const builtIn = toolNameMap[rawTool] + if (builtIn) return builtIn + const serverSeparator = rawTool.indexOf('_') + if (serverSeparator > 0 && serverSeparator < rawTool.length - 1) { + const server = rawTool.slice(0, serverSeparator) + const tool = rawTool.slice(serverSeparator + 1) + return `mcp__${server}__${tool}` + } + return rawTool +} + +export function sanitize(dir: string): string { + return dir.replace(/^\//, '').replace(/\//g, '-') +} + +export function parseTimestamp(raw: number): string { + const ms = raw < 1e12 ? raw * 1000 : raw + return new Date(ms).toISOString() +} + +// Build a ParsedProviderCall from one assistant message and its parts. Returns +// null when the message has no tokens, no cost, and no substantive parts (an +// empty or errored turn worth skipping). Shared by the SQLite and file-based +// OpenCode parsers so both attribute tokens, tools, and cost identically. +export function buildAssistantCall(opts: { + providerName: string + dedupKey: string + sessionId: string + data: MessageData + parts: PartData[] + timeCreatedMs: number + userMessage: string +}): ParsedProviderCall | null { + const { data, parts } = opts + + const tokens = { + input: data.tokens?.input ?? data.usage?.input_tokens ?? 0, + output: data.tokens?.output ?? data.usage?.output_tokens ?? 0, + reasoning: data.tokens?.reasoning ?? 0, + cacheRead: data.tokens?.cache?.read ?? data.usage?.cache_read_input_tokens ?? 0, + cacheWrite: data.tokens?.cache?.write ?? data.usage?.cache_creation_input_tokens ?? 0, + } + + const toolParts = parts.filter((p) => (p.type === 'tool' || p.type === 'tool-call' || p.type === 'tool_call') && normalizeToolName(p.tool)) + const hasTextOutput = parts.some((p) => p.type === 'text' && typeof p.text === 'string' && p.text.trim().length > 0) + const hasToolOrTextParts = hasTextOutput || toolParts.length > 0 + const hasAnySubstantiveParts = parts.some((p) => + p.type === 'text' || p.type === 'tool' || p.type === 'tool-call' || p.type === 'tool_call' || + p.type === 'tool-result' || p.type === 'tool_result' || p.type === 'reasoning' || p.type === 'file' + ) + const hasActivity = hasToolOrTextParts || hasAnySubstantiveParts + + const allZero = + tokens.input === 0 && + tokens.output === 0 && + tokens.reasoning === 0 && + tokens.cacheRead === 0 && + tokens.cacheWrite === 0 + if (allZero && (data.cost ?? 0) === 0 && !hasActivity) return null + + const tools = toolParts + .map((p) => normalizeToolName(p.tool)) + .filter(Boolean) + + const bashCommands = toolParts + .filter((p) => p.tool === 'bash' && typeof p.state?.input?.command === 'string') + .flatMap((p) => extractBashCommands(p.state!.input!.command!)) + + // The skill/subagent name lives in the tool-call input, not the tool name, so + // the Skills & Agents breakdown needs these extracted alongside the tool list. + const skills = toolParts + .filter((p) => p.tool === 'skill' && typeof p.state?.input?.name === 'string') + .map((p) => p.state!.input!.name!) + .filter(Boolean) + + const subagentTypes = toolParts + .filter((p) => p.tool === 'task' && typeof p.state?.input?.subagent_type === 'string') + .map((p) => p.state!.input!.subagent_type!) + .filter(Boolean) + + const model = data.modelID ?? data.model ?? 'unknown' + let costUSD = calculateCost( + model, + tokens.input, + tokens.output + tokens.reasoning, + tokens.cacheWrite, + tokens.cacheRead, + 0, + ) + + if (costUSD === 0 && typeof data.cost === 'number' && data.cost > 0) { + costUSD = data.cost + } + + return { + provider: opts.providerName, + model, + inputTokens: tokens.input, + outputTokens: tokens.output, + cacheCreationInputTokens: tokens.cacheWrite, + cacheReadInputTokens: tokens.cacheRead, + cachedInputTokens: tokens.cacheRead, + reasoningTokens: tokens.reasoning, + webSearchRequests: 0, + costUSD, + tools, + bashCommands, + skills, + subagentTypes, + timestamp: parseTimestamp(opts.timeCreatedMs), + speed: 'standard', + deduplicationKey: opts.dedupKey, + userMessage: opts.userMessage, + sessionId: opts.sessionId, + } +} diff --git a/src/providers/sqlite-session-parser.ts b/src/providers/sqlite-session-parser.ts new file mode 100644 index 0000000..7d81e9d --- /dev/null +++ b/src/providers/sqlite-session-parser.ts @@ -0,0 +1,327 @@ +import { readdir } from 'fs/promises' +import { join } from 'path' + +import { calculateCost } from '../models.js' +import { isSqliteAvailable, getSqliteLoadError, openDatabase, blobToText, isSqliteBusyError, type SqliteDatabase } from '../sqlite.js' +import { buildAssistantCall, parseTimestamp, sanitize, type MessageData, type PartData } from './session-message.js' +import type { + SessionSource, + SessionParser, + ParsedProviderCall, +} from './types.js' + +type MessageRow = { + session_id: string + id: string + time_created: number + data: Uint8Array | string +} + +type PartRow = { + message_id: string + data: Uint8Array | string +} + +type SessionRow = { + id: string + directory: Uint8Array | string + title: Uint8Array | string + time_created: number +} + +type SessionTokenRow = { + cost?: number + tokens_input?: number + tokens_output?: number + tokens_reasoning?: number + tokens_cache_read?: number + tokens_cache_write?: number + model_id?: string +} + +function tryQuerySessionTokens(db: SqliteDatabase, sessionId: string): { + cost: number; input: number; output: number; reasoning: number + cacheRead: number; cacheWrite: number; model: string | undefined +} | null { + try { + const rows = db.query<SessionTokenRow>( + `SELECT cost, tokens_input, tokens_output, tokens_reasoning, tokens_cache_read, tokens_cache_write, model_id FROM session WHERE id = ?`, + [sessionId], + ) + if (rows.length === 0) return null + const r = rows[0]! + return { + cost: r.cost ?? 0, + input: r.tokens_input ?? 0, + output: r.tokens_output ?? 0, + reasoning: r.tokens_reasoning ?? 0, + cacheRead: r.tokens_cache_read ?? 0, + cacheWrite: r.tokens_cache_write ?? 0, + model: r.model_id ?? undefined, + } + } catch { + return null + } +} + +type SchemaCheckResult = { ok: true } | { ok: false; missing: string[] } + +function validateSchemaDetailed(db: SqliteDatabase): SchemaCheckResult { + const required = ['session', 'message', 'part'] + const missing: string[] = [] + for (const table of required) { + try { + db.query<{ cnt: number }>(`SELECT COUNT(*) as cnt FROM ${table} LIMIT 1`) + } catch (err) { + if (isSqliteBusyError(err)) throw err + missing.push(table) + } + } + return missing.length === 0 ? { ok: true } : { ok: false, missing } +} + +const warnedSchemas = new Map<string, Set<string>>() + +function warnUnrecognizedSchemaOnce(providerLabel: string, missing: string[]): void { + const providerSet = warnedSchemas.get(providerLabel) ?? new Set() + const key = missing.slice().sort().join(',') + if (providerSet.has(key)) return + providerSet.add(key) + warnedSchemas.set(providerLabel, providerSet) + process.stderr.write( + `codeburn: ${providerLabel} database is missing expected tables (${missing.join(', ')}). ` + + `Run ${providerLabel} once to apply migrations, or report at https://github.com/getagentseal/codeburn/issues if this persists.\n` + ) +} + +export type SqliteProviderConfig = { + providerName: string + displayName: string + dbDir: string + dbFilePrefix: string +} + +export function createSqliteSessionParser( + source: SessionSource, + seenKeys: Set<string>, + config: SqliteProviderConfig, +): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + if (!isSqliteAvailable()) { + process.stderr.write(getSqliteLoadError() + '\n') + return + } + + const segments = source.path.split(':') + const sessionId = segments[segments.length - 1]! + const dbPath = segments.slice(0, -1).join(':') + + let db: SqliteDatabase + try { + db = openDatabase(dbPath) + } catch (err) { + process.stderr.write(`codeburn: cannot open ${config.displayName} database: ${err instanceof Error ? err.message : err}\n`) + return + } + + try { + const schema = validateSchemaDetailed(db) + if (!schema.ok) { + warnUnrecognizedSchemaOnce(config.displayName, schema.missing) + return + } + + const messages = db.query<MessageRow>( + `WITH RECURSIVE session_tree(id) AS ( + SELECT id FROM session WHERE id = ? + UNION + SELECT child.id + FROM session child + JOIN session_tree parent ON child.parent_id = parent.id + WHERE child.time_archived IS NULL + ) + SELECT session_id, id, time_created, CAST(data AS BLOB) AS data + FROM message + WHERE session_id IN (SELECT id FROM session_tree) + ORDER BY time_created ASC, id ASC`, + [sessionId], + ) + + const parts = db.query<PartRow>( + `WITH RECURSIVE session_tree(id) AS ( + SELECT id FROM session WHERE id = ? + UNION + SELECT child.id + FROM session child + JOIN session_tree parent ON child.parent_id = parent.id + WHERE child.time_archived IS NULL + ) + SELECT message_id, CAST(data AS BLOB) AS data + FROM part + WHERE session_id IN (SELECT id FROM session_tree) + ORDER BY message_id, id`, + [sessionId], + ) + + const partsByMsg = new Map<string, PartData[]>() + for (const part of parts) { + try { + const parsed = JSON.parse(blobToText(part.data)) as PartData + const list = partsByMsg.get(part.message_id) ?? [] + list.push(parsed) + partsByMsg.set(part.message_id, list) + } catch { + // skip corrupt part data + } + } + + const currentUserMessageBySession = new Map<string, string>() + let yieldCount = 0 + let parseFailCount = 0 + let roleSkipCount = 0 + + for (const msg of messages) { + let data: MessageData + try { + data = JSON.parse(blobToText(msg.data)) as MessageData + } catch { + parseFailCount++ + continue + } + + if (data.role === 'user') { + const textParts = (partsByMsg.get(msg.id) ?? []) + .filter((p) => p.type === 'text') + .map((p) => p.text ?? '') + .filter(Boolean) + if (textParts.length > 0) { + currentUserMessageBySession.set(msg.session_id, textParts.join(' ')) + } + continue + } + + if (data.role !== 'assistant' && data.role !== 'model') { + if (data.role !== 'user') roleSkipCount++ + continue + } + + const dedupKey = `${config.providerName}:${msg.session_id}:${msg.id}` + if (seenKeys.has(dedupKey)) continue + + const call = buildAssistantCall({ + providerName: config.providerName, + dedupKey, + sessionId, + data, + parts: partsByMsg.get(msg.id) ?? [], + timeCreatedMs: msg.time_created, + userMessage: currentUserMessageBySession.get(msg.session_id) ?? '', + }) + if (!call) continue + + seenKeys.add(dedupKey) + yieldCount++ + yield call + } + + if (yieldCount === 0 && messages.length > 0) { + const sessionTokens = tryQuerySessionTokens(db, sessionId) + if (sessionTokens && (sessionTokens.cost > 0 || sessionTokens.input > 0 || sessionTokens.output > 0)) { + const dedupKey = `${config.providerName}:${sessionId}:session-level` + if (!seenKeys.has(dedupKey)) { + seenKeys.add(dedupKey) + const model = sessionTokens.model ?? 'unknown' + let costUSD = calculateCost(model, sessionTokens.input, sessionTokens.output, sessionTokens.cacheWrite, sessionTokens.cacheRead, 0) + if (costUSD === 0 && sessionTokens.cost > 0) costUSD = sessionTokens.cost + yield { + provider: config.providerName, + model, + inputTokens: sessionTokens.input, + outputTokens: sessionTokens.output, + cacheCreationInputTokens: sessionTokens.cacheWrite, + cacheReadInputTokens: sessionTokens.cacheRead, + cachedInputTokens: sessionTokens.cacheRead, + reasoningTokens: sessionTokens.reasoning, + webSearchRequests: 0, + costUSD, + tools: [], + bashCommands: [], + timestamp: parseTimestamp(messages[0]!.time_created), + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: '', + sessionId, + } + yieldCount++ + } + } + + if (yieldCount === 0 && process.env['CODEBURN_VERBOSE'] === '1') { + process.stderr.write( + `codeburn: ${config.displayName} session ${sessionId} has ${messages.length} messages ` + + `(${parseFailCount} unparseable, ${roleSkipCount} non-user/assistant roles) ` + + `but yielded 0 calls. Parts: ${parts.length}.\n` + ) + } + } + } finally { + db.close() + } + }, + } +} + +export async function discoverSqliteSessions( + config: SqliteProviderConfig, +): Promise<SessionSource[]> { + if (!isSqliteAvailable()) return [] + + let dbPaths: string[] + try { + const entries = await readdir(config.dbDir) + dbPaths = entries + .filter((f) => f.startsWith(config.dbFilePrefix) && f.endsWith('.db')) + .map((f) => join(config.dbDir, f)) + } catch { + return [] + } + + if (dbPaths.length === 0) return [] + + const sessions: SessionSource[] = [] + for (const dbPath of dbPaths) { + let db: SqliteDatabase + try { + db = openDatabase(dbPath) + } catch { + continue + } + + try { + const schema = validateSchemaDetailed(db) + if (!schema.ok) continue + + const rows = db.query<SessionRow>( + 'SELECT id, CAST(directory AS BLOB) AS directory, CAST(title AS BLOB) AS title, time_created FROM session WHERE time_archived IS NULL AND parent_id IS NULL ORDER BY time_created DESC', + ) + + for (const row of rows) { + const dir = blobToText(row.directory) + const title = blobToText(row.title) + sessions.push({ + path: `${dbPath}:${row.id}`, + project: dir ? sanitize(dir) : sanitize(title), + provider: config.providerName, + }) + } + } catch { + // skip this DB + } finally { + db.close() + } + } + + return sessions +} + diff --git a/src/providers/types.ts b/src/providers/types.ts new file mode 100644 index 0000000..113f279 --- /dev/null +++ b/src/providers/types.ts @@ -0,0 +1,63 @@ +import type { DateRange, ToolCall } from '../types.js' + +export type SessionSource = { + path: string + project: string + provider: string + sourceId?: string + sourceLabel?: string + sourcePath?: string + sourceKind?: 'claude-config' | 'claude-desktop' +} + +export type SessionParser = { + parse(): AsyncGenerator<ParsedProviderCall> +} + +export type ParsedProviderCall = { + provider: string + model: string + inputTokens: number + outputTokens: number + cacheCreationInputTokens: number + cacheReadInputTokens: number + cachedInputTokens: number + reasoningTokens: number + webSearchRequests: number + costUSD: number + costIsEstimated?: boolean + tools: string[] + bashCommands: string[] + // Subagent types spawned in this call (e.g. 'general-purpose'). Feeds the + // Skills & Agents breakdown; optional since most providers don't expose it. + subagentTypes?: string[] + // Skill names invoked in this call (e.g. 'commit'). Feeds the Skills & Agents + // breakdown; optional since most providers don't expose it. + skills?: string[] + timestamp: string + speed: 'standard' | 'fast' + deduplicationKey: string + turnId?: string + toolSequence?: ToolCall[][] + userMessage: string + sessionId: string + project?: string + projectPath?: string +} + +export type Provider = { + name: string + displayName: string + // Data comes from a live API fetch (no on-disk file). Such sources can't be + // fingerprinted or incrementally cached, so the parser re-fetches every run. + network?: boolean + // Source data is managed by an external process that may prune old records + // (e.g. VS Code's OTel agent-traces.db). Cached entries for discovered paths + // are never evicted, and orphaned entries (paths no longer discovered) are + // kept and included in query-time aggregation so the monthly total never drops. + durableSources?: boolean + modelDisplayName(model: string): string + toolDisplayName(rawTool: string): string + discoverSessions(): Promise<SessionSource[]> + createSessionParser(source: SessionSource, seenKeys: Set<string>, dateRange?: DateRange): SessionParser +} diff --git a/src/providers/vercel-gateway.ts b/src/providers/vercel-gateway.ts new file mode 100644 index 0000000..9968d6d --- /dev/null +++ b/src/providers/vercel-gateway.ts @@ -0,0 +1,151 @@ +import type { DateRange } from '../types.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' +import { fetchWithTimeout } from '../fetch-utils.js' + +const REPORT_URL = 'https://ai-gateway.vercel.sh/v1/report' + +type ReportRow = { + day?: string + model?: string + total_cost?: number + input_tokens?: number + output_tokens?: number + cached_input_tokens?: number + cache_creation_input_tokens?: number + reasoning_tokens?: number + request_count?: number +} + +export function getVercelGatewayApiKey(): string | null { + const key = process.env['AI_GATEWAY_API_KEY'] ?? process.env['VERCEL_OIDC_TOKEN'] + return key?.trim() ? key.trim() : null +} + +function formatUtcDate(d: Date): string { + const y = d.getUTCFullYear() + const m = String(d.getUTCMonth() + 1).padStart(2, '0') + const day = String(d.getUTCDate()).padStart(2, '0') + return `${y}-${m}-${day}` +} + +export async function fetchVercelGatewayReport( + dateRange: DateRange, +): Promise<ReportRow[]> { + const key = getVercelGatewayApiKey() + if (!key) return [] + + const params = new URLSearchParams({ + start_date: formatUtcDate(dateRange.start), + end_date: formatUtcDate(dateRange.end), + date_part: 'day', + group_by: 'model', + }) + + try { + const res = await fetchWithTimeout(`${REPORT_URL}?${params}`, { + method: 'GET', + headers: { + Authorization: `Bearer ${key}`, + Accept: 'application/json', + }, + }) + + if (!res.ok) { + const detail = await res.text().catch(() => '') + process.stderr.write( + `codeburn: Vercel AI Gateway report failed (HTTP ${res.status}). ` + + 'Requires AI_GATEWAY_API_KEY or VERCEL_OIDC_TOKEN (Pro/Enterprise for /v1/report). ' + + `${detail.slice(0, 200)}\n`, + ) + return [] + } + + const body = (await res.json()) as { results?: ReportRow[] } + return body.results ?? [] + } catch (err) { + process.stderr.write( + `codeburn: Vercel AI Gateway report unreachable (${err instanceof Error ? err.message : String(err)}).\n`, + ) + return [] + } +} + +function createParser( + source: SessionSource, + seenKeys: Set<string>, + dateRange?: DateRange, +): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + if (!dateRange) return + + const rows = await fetchVercelGatewayReport(dateRange) + for (const row of rows) { + const day = row.day ?? '' + const model = row.model ?? 'unknown' + const costUSD = row.total_cost ?? 0 + const inputTokens = row.input_tokens ?? 0 + const outputTokens = row.output_tokens ?? 0 + if (costUSD === 0 && inputTokens === 0 && outputTokens === 0) continue + + const deduplicationKey = `vercel-gateway:${day}:${model}` + if (seenKeys.has(deduplicationKey)) continue + seenKeys.add(deduplicationKey) + + yield { + provider: 'vercel-gateway', + model, + inputTokens, + outputTokens, + cacheCreationInputTokens: row.cache_creation_input_tokens ?? 0, + cacheReadInputTokens: row.cached_input_tokens ?? 0, + cachedInputTokens: 0, + reasoningTokens: row.reasoning_tokens ?? 0, + webSearchRequests: 0, + costUSD, + tools: [], + bashCommands: [], + timestamp: day ? `${day}T12:00:00.000Z` : '', + speed: 'standard', + deduplicationKey, + userMessage: '', + sessionId: `${day}:${model}`, + project: source.project, + } + } + }, + } +} + +export const vercelGateway: Provider = { + name: 'vercel-gateway', + displayName: 'Vercel AI Gateway', + network: true, + + modelDisplayName(model: string): string { + const slash = model.indexOf('/') + return slash >= 0 ? model.slice(slash + 1) : model + }, + + toolDisplayName(rawTool: string): string { + return rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + if (!getVercelGatewayApiKey()) return [] + + return [{ + path: 'vercel-ai-gateway:report', + project: 'Vercel AI Gateway', + provider: 'vercel-gateway', + }] + }, + + createSessionParser( + source: SessionSource, + seenKeys: Set<string>, + dateRange?: DateRange, + ): SessionParser { + return createParser(source, seenKeys, dateRange) + }, +} diff --git a/src/providers/vscode-cline-parser.ts b/src/providers/vscode-cline-parser.ts new file mode 100644 index 0000000..2535a22 --- /dev/null +++ b/src/providers/vscode-cline-parser.ts @@ -0,0 +1,222 @@ +import { readdir, readFile, stat } from 'fs/promises' +import { basename, join, posix, win32 } from 'path' +import { homedir } from 'os' + +import { calculateCost } from '../models.js' +import type { SessionSource, SessionParser, ParsedProviderCall } from './types.js' + +type UiMessage = { + type?: string + say?: string + text?: string + ts?: number +} + +export function getVSCodeGlobalStoragePaths(extensionId: string, homeDir = homedir(), platform = process.platform): string[] { + const pathJoin = platform === 'win32' ? win32.join : posix.join + + if (platform === 'darwin') { + return [ + pathJoin(homeDir, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', extensionId), + pathJoin(homeDir, 'Library', 'Application Support', 'Code - Insiders', 'User', 'globalStorage', extensionId), + pathJoin(homeDir, 'Library', 'Application Support', 'VSCodium', 'User', 'globalStorage', extensionId), + ] + } + + if (platform === 'win32') { + return [ + pathJoin(homeDir, 'AppData', 'Roaming', 'Code', 'User', 'globalStorage', extensionId), + pathJoin(homeDir, 'AppData', 'Roaming', 'Code - Insiders', 'User', 'globalStorage', extensionId), + pathJoin(homeDir, 'AppData', 'Roaming', 'VSCodium', 'User', 'globalStorage', extensionId), + ] + } + + return [ + pathJoin(homeDir, '.config', 'Code', 'User', 'globalStorage', extensionId), + pathJoin(homeDir, '.config', 'Code - Insiders', 'User', 'globalStorage', extensionId), + pathJoin(homeDir, '.config', 'VSCodium', 'User', 'globalStorage', extensionId), + ] +} + +export function getVSCodeGlobalStoragePath(extensionId: string): string { + return getVSCodeGlobalStoragePaths(extensionId)[0]! +} + +export async function discoverClineTasks(extensionId: string, providerName: string, displayName: string, overrideDir?: string | string[]): Promise<SessionSource[]> { + const baseDirs = overrideDir + ? (Array.isArray(overrideDir) ? overrideDir : [overrideDir]) + : getVSCodeGlobalStoragePaths(extensionId) + return discoverClineTasksInBaseDirs(baseDirs, providerName, displayName) +} + +export async function discoverClineTasksInBaseDirs(baseDirs: string[], providerName: string, displayName: string): Promise<SessionSource[]> { + const sources: SessionSource[] = [] + const seen = new Set<string>() + for (const baseDir of baseDirs) { + for (const source of await discoverClineTasksInBaseDir(baseDir, providerName, displayName)) { + if (seen.has(source.path)) continue + seen.add(source.path) + sources.push(source) + } + } + return sources +} + +async function discoverClineTasksInBaseDir(baseDir: string, providerName: string, displayName: string): Promise<SessionSource[]> { + const tasksDir = join(baseDir, 'tasks') + const sources: SessionSource[] = [] + + let taskDirs: string[] + try { + taskDirs = await readdir(tasksDir) + } catch { + return sources + } + + for (const taskId of taskDirs) { + const taskDir = join(tasksDir, taskId) + const dirStat = await stat(taskDir).catch(() => null) + if (!dirStat?.isDirectory()) continue + + const uiPath = join(taskDir, 'ui_messages.json') + const uiStat = await stat(uiPath).catch(() => null) + if (!uiStat?.isFile()) continue + + sources.push({ path: taskDir, project: displayName, provider: providerName }) + } + + return sources +} + +const MODEL_TAG_RE = /<model>([^<]+)<\/model>/ +const WORKSPACE_DIR_RE = /Current Workspace Directory $([^)]+)$/ + +type HistoryMeta = { model: string; workspace: string | null } + +function extractHistoryMeta(taskDir: string, fallbackModel: string): Promise<HistoryMeta> { + return readFile(join(taskDir, 'api_conversation_history.json'), 'utf-8') + .then(raw => { + const msgs = JSON.parse(raw) as Array<{ role?: string; content?: Array<{ text?: string }> }> + if (!Array.isArray(msgs)) return { model: fallbackModel, workspace: null } + let model: string | null = null + let workspace: string | null = null + for (const msg of msgs) { + if (msg.role !== 'user' || !Array.isArray(msg.content)) continue + for (const block of msg.content) { + if (typeof block.text !== 'string') continue + if (!model) { + const mm = MODEL_TAG_RE.exec(block.text) + if (mm) model = mm[1].includes('/') ? mm[1].split('/').pop()! : mm[1] + } + if (!workspace) { + const wm = WORKSPACE_DIR_RE.exec(block.text) + if (wm) workspace = wm[1] + } + if (model && workspace) break + } + if (model && workspace) break + } + return { model: model ?? fallbackModel, workspace } + }) + .catch(() => ({ model: fallbackModel, workspace: null })) +} + +function workspaceToProject(workspace: string): string { + return basename(workspace) || workspace +} + +export function createClineParser(source: SessionSource, seenKeys: Set<string>, providerName: string, fallbackModel = 'cline-auto'): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + const taskDir = source.path + const taskId = basename(taskDir) + + let uiRaw: string + try { + uiRaw = await readFile(join(taskDir, 'ui_messages.json'), 'utf-8') + } catch { + return + } + + let uiMessages: UiMessage[] + try { + uiMessages = JSON.parse(uiRaw) + } catch { + return + } + + if (!Array.isArray(uiMessages)) return + + const meta = await extractHistoryMeta(taskDir, fallbackModel) + const model = meta.model + const project = meta.workspace ? workspaceToProject(meta.workspace) : undefined + const projectPath = meta.workspace ?? undefined + + let userMessage = '' + for (const msg of uiMessages) { + if (msg.type === 'say' && (msg.say === 'user_feedback' || msg.say === 'text')) { + userMessage = (msg.text ?? '').slice(0, 500) + break + } + } + + const apiReqEntries = uiMessages.filter(m => m.type === 'say' && m.say === 'api_req_started') + + for (const [index, entry] of apiReqEntries.entries()) { + const dedupKey = `${providerName}:${taskId}:${index}` + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + let tokensIn = 0 + let tokensOut = 0 + let cacheReads = 0 + let cacheWrites = 0 + let cost: number | undefined + + if (entry.text) { + try { + const parsed = JSON.parse(entry.text) as { + tokensIn?: number + tokensOut?: number + cacheReads?: number + cacheWrites?: number + cost?: number + } + tokensIn = parsed.tokensIn ?? 0 + tokensOut = parsed.tokensOut ?? 0 + cacheReads = parsed.cacheReads ?? 0 + cacheWrites = parsed.cacheWrites ?? 0 + cost = parsed.cost + } catch {} + } + + if (tokensIn === 0 && tokensOut === 0) continue + + const timestamp = entry.ts ? new Date(entry.ts).toISOString() : '' + const costUSD = cost ?? calculateCost(model, tokensIn, tokensOut, cacheWrites, cacheReads, 0) + + yield { + provider: providerName, + model, + inputTokens: tokensIn, + outputTokens: tokensOut, + cacheCreationInputTokens: cacheWrites, + cacheReadInputTokens: cacheReads, + cachedInputTokens: cacheReads, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD, + tools: [], + bashCommands: [], + timestamp, + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: index === 0 ? userMessage : '', + sessionId: taskId, + project, + projectPath, + } + } + }, + } +} diff --git a/src/providers/warp.ts b/src/providers/warp.ts new file mode 100644 index 0000000..9dec7ac --- /dev/null +++ b/src/providers/warp.ts @@ -0,0 +1,500 @@ +import { join } from 'path' +import { homedir } from 'os' + +import { extractBashCommands } from '../bash-utils.js' +import { calculateCost, getShortModelName } from '../models.js' +import { blobToText, getSqliteLoadError, isSqliteAvailable, openDatabase, type SqliteDatabase } from '../sqlite.js' +import type { ParsedProviderCall, Provider, SessionParser, SessionSource } from './types.js' +import { safeNumber } from '../parser.js' + +const WARP_GROUP_CONTAINER = '2BBY89MBSN.dev.warp' +const WARP_STABLE_BUNDLE_ID = 'dev.warp.Warp-Stable' +const WARP_PREVIEW_BUNDLE_ID = 'dev.warp.Warp-Preview' +const PRIMARY_AGENT_CATEGORY = 'primary_agent' +const CHARS_PER_TOKEN = 4 + +const modelAliases: Record<string, string> = { + 'Claude Sonnet 4.6': 'claude-sonnet-4-6', + 'Claude Sonnet 4.5': 'claude-sonnet-4-5', + 'Claude Haiku 4.5': 'claude-haiku-4-5', + 'Claude Opus 4.6': 'claude-opus-4-6', + 'GPT-5.3 Codex (low reasoning)': 'gpt-5.3-codex', + 'GPT-5.3 Codex (medium reasoning)': 'gpt-5.3-codex', + 'GPT-5.3 Codex (high reasoning)': 'gpt-5.3-codex', + 'GPT-5.3 Codex (extra high reasoning)': 'gpt-5.3-codex', + 'auto-efficient': 'warp-auto-efficient', + 'auto-powerful': 'warp-auto-powerful', +} + +type WarpConversationRow = { + conversation_id: string + conversation_data: string + last_modified_at: string | null +} + +type WarpQueryRow = { + exchange_id: string + conversation_id: string + start_ts: string + input: string + working_directory: string | null + output_status: string + model_id: string + planning_model_id: string + coding_model_id: string +} + +type WarpBlockRow = { + block_id: string + start_ts: string | null + stylized_command: Uint8Array | string | null +} + +type WarpTokenUsageEntry = { + model_id?: string + warp_tokens?: number + byok_tokens?: number + warp_token_usage_by_category?: Record<string, unknown> + byok_token_usage_by_category?: Record<string, unknown> +} + +type WarpConversationData = { + conversation_usage_metadata?: { + token_usage?: WarpTokenUsageEntry[] + } +} + +type ParsedExchange = WarpQueryRow & { + startMs: number +} + +type ExchangeToolInfo = { + tools: string[] + bashCommands: string[] +} + +function sanitizeProject(path: string): string { + return path.replace(/^\/+/, '').replace(/\//g, '-') +} + +function warpDbPath(bundleId: string): string { + return join( + homedir(), + 'Library', + 'Group Containers', + WARP_GROUP_CONTAINER, + 'Library', + 'Application Support', + bundleId, + 'warp.sqlite', + ) +} + +function getDbCandidates(dbPathOverride?: string): string[] { + if (dbPathOverride) return [dbPathOverride] + if (process.env['WARP_DB_PATH']) return [process.env['WARP_DB_PATH']] + return [warpDbPath(WARP_STABLE_BUNDLE_ID), warpDbPath(WARP_PREVIEW_BUNDLE_ID)] +} + +function normalizeModel(rawModel: string): string { + const model = rawModel.trim() + if (!model) return model + return modelAliases[model] ?? model +} + +function modelDisplayName(model: string): string { + if (model === 'warp-auto-efficient') return 'Warp Auto (efficient)' + if (model === 'warp-auto-powerful') return 'Warp Auto (powerful)' + return getShortModelName(model) +} + +function parseTimestamp(raw: string | null | undefined): number | null { + if (!raw) return null + const trimmed = raw.trim() + if (!trimmed) return null + const withT = trimmed.includes('T') ? trimmed : trimmed.replace(' ', 'T') + const lastPlus = withT.lastIndexOf('+') + const lastMinus = withT.lastIndexOf('-') + const hasOffset = lastPlus > 9 || lastMinus > 9 + const hasTimezone = withT.endsWith('Z') || hasOffset + const normalized = hasTimezone ? withT : `${withT}Z` + const ms = Date.parse(normalized) + return Number.isNaN(ms) ? null : ms +} + +function parseJsonString(raw: string): string { + try { + const parsed = JSON.parse(raw) as unknown + return typeof parsed === 'string' ? parsed : raw + } catch { + return raw + } +} + +function isFinalStatus(rawStatus: string): boolean { + const status = parseJsonString(rawStatus) + return status === 'Completed' || status === 'Cancelled' || status === 'Failed' +} + +function extractCategoryTokens(categories: Record<string, unknown> | undefined, key: string): number { + if (!categories) return 0 + return safeNumber(categories[key]) +} + +function extractTokenBudget(rawConversationData: string): { tokenBudget: number; dominantModel: string } { + let conversationData: WarpConversationData + try { + conversationData = JSON.parse(rawConversationData) as WarpConversationData + } catch { + return { tokenBudget: 0, dominantModel: '' } + } + + const entries = conversationData.conversation_usage_metadata?.token_usage ?? [] + let primaryTotal = 0 + let fallbackTotal = 0 + let dominantPrimaryTokens = 0 + let dominantFallbackTokens = 0 + let dominantModel = '' + + for (const entry of entries) { + const primaryTokens = + extractCategoryTokens(entry.warp_token_usage_by_category, PRIMARY_AGENT_CATEGORY) + + extractCategoryTokens(entry.byok_token_usage_by_category, PRIMARY_AGENT_CATEGORY) + const entryTotal = safeNumber(entry.warp_tokens) + safeNumber(entry.byok_tokens) + + primaryTotal += primaryTokens + fallbackTotal += entryTotal + + if (primaryTokens > dominantPrimaryTokens) { + dominantPrimaryTokens = primaryTokens + dominantModel = typeof entry.model_id === 'string' ? entry.model_id : dominantModel + } + + if (dominantPrimaryTokens === 0 && entryTotal > dominantFallbackTokens) { + dominantFallbackTokens = entryTotal + dominantModel = typeof entry.model_id === 'string' ? entry.model_id : dominantModel + } + } + + const tokenBudget = primaryTotal > 0 ? primaryTotal : fallbackTotal + return { tokenBudget: Math.max(0, Math.round(tokenBudget)), dominantModel: normalizeModel(dominantModel) } +} + +function extractUserMessage(rawInput: string): string { + try { + const parsed = JSON.parse(rawInput) as unknown + if (!Array.isArray(parsed)) return '' + for (const item of parsed) { + if (!item || typeof item !== 'object') continue + const query = (item as { Query?: { text?: unknown } }).Query + if (!query || typeof query !== 'object') continue + if (typeof query.text === 'string' && query.text.trim()) return query.text + } + return '' + } catch { + return '' + } +} + +function estimateWeight(rawInput: string): number { + const userMessage = extractUserMessage(rawInput) + const source = userMessage || rawInput + const tokens = Math.ceil(source.length / CHARS_PER_TOKEN) + return Math.max(1, tokens) +} + +function allocateTokens(weights: number[], tokenBudget: number): number[] { + if (weights.length === 0) return [] + const normalizedWeights = weights.map(w => Math.max(0, Math.round(w))) + const totalWeight = normalizedWeights.reduce((sum, weight) => sum + weight, 0) + const budget = Math.max(0, Math.round(tokenBudget)) + + if (budget === 0) return normalizedWeights.map(() => 0) + if (totalWeight === 0) { + const even = Math.floor(budget / normalizedWeights.length) + const allocated = normalizedWeights.map(() => even) + let remainder = budget - even * normalizedWeights.length + let index = 0 + while (remainder > 0) { + allocated[index] = (allocated[index] ?? 0) + 1 + remainder-- + index = (index + 1) % normalizedWeights.length + } + return allocated + } + + const rawAllocation = normalizedWeights.map(weight => (budget * weight) / totalWeight) + const allocated = rawAllocation.map(value => Math.floor(value)) + let remainder = budget - allocated.reduce((sum, value) => sum + value, 0) + + const byLargestFraction = rawAllocation + .map((value, index) => ({ index, fraction: value - Math.floor(value) })) + .sort((a, b) => b.fraction - a.fraction) + + let pointer = 0 + while (remainder > 0 && byLargestFraction.length > 0) { + const index = byLargestFraction[pointer]!.index + allocated[index] = (allocated[index] ?? 0) + 1 + remainder-- + pointer = (pointer + 1) % byLargestFraction.length + } + + return allocated +} + +function resolveModelForExchange(exchange: WarpQueryRow, dominantModel: string): string { + const candidate = + exchange.model_id.trim() || + exchange.coding_model_id.trim() || + exchange.planning_model_id.trim() || + dominantModel || + 'warp-auto-efficient' + const normalized = normalizeModel(candidate) + if ((normalized === 'warp-auto-efficient' || normalized === 'warp-auto-powerful') && dominantModel) { + return dominantModel + } + return normalized +} + +function assignCommandBlocksToExchanges( + blocks: WarpBlockRow[], + exchanges: ParsedExchange[], +): Map<string, ExchangeToolInfo> { + const toolsByExchange = new Map<string, ExchangeToolInfo>() + + function getOrCreate(exchangeId: string): ExchangeToolInfo { + const existing = toolsByExchange.get(exchangeId) + if (existing) return existing + const created: ExchangeToolInfo = { tools: [], bashCommands: [] } + toolsByExchange.set(exchangeId, created) + return created + } + + for (const block of blocks) { + const blockStartMs = parseTimestamp(block.start_ts) + if (blockStartMs === null) continue + + let targetExchange: ParsedExchange | null = null + for (const exchange of exchanges) { + if (exchange.startMs > blockStartMs) break + targetExchange = exchange + } + if (!targetExchange) continue + + const info = getOrCreate(targetExchange.exchange_id) + if (!info.tools.includes('Bash')) info.tools.push('Bash') + + const commandText = blobToText(block.stylized_command) + for (const command of extractBashCommands(commandText)) { + if (!info.bashCommands.includes(command)) info.bashCommands.push(command) + } + } + + return toolsByExchange +} + +function decodeSourcePath(path: string): { dbPath: string; conversationId: string } { + const splitIndex = path.lastIndexOf(':') + if (splitIndex <= 0) return { dbPath: path, conversationId: '' } + return { + dbPath: path.slice(0, splitIndex), + conversationId: path.slice(splitIndex + 1), + } +} + +function validateSchema(db: SqliteDatabase): boolean { + try { + db.query<{ cnt: number }>('SELECT COUNT(*) as cnt FROM agent_conversations LIMIT 1') + db.query<{ cnt: number }>('SELECT COUNT(*) as cnt FROM ai_queries LIMIT 1') + db.query<{ cnt: number }>('SELECT COUNT(*) as cnt FROM blocks LIMIT 1') + return true + } catch { + return false + } +} + +function createParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + if (!isSqliteAvailable()) { + process.stderr.write(getSqliteLoadError() + '\n') + return + } + + const { dbPath, conversationId } = decodeSourcePath(source.path) + if (!conversationId) return + + let db: SqliteDatabase + try { + db = openDatabase(dbPath) + } catch (err) { + process.stderr.write(`codeburn: cannot open Warp database: ${err instanceof Error ? err.message : err}\n`) + return + } + + try { + if (!validateSchema(db)) return + + const conversations = db.query<WarpConversationRow>( + `SELECT conversation_id, conversation_data, last_modified_at + FROM agent_conversations + WHERE conversation_id = ? + LIMIT 1`, + [conversationId], + ) + if (conversations.length === 0) return + + const exchanges = db.query<WarpQueryRow>( + `SELECT exchange_id, conversation_id, start_ts, input, working_directory, output_status, model_id, planning_model_id, coding_model_id + FROM ai_queries + WHERE conversation_id = ? + ORDER BY start_ts ASC`, + [conversationId], + ) + + const parsedExchanges: ParsedExchange[] = [] + for (const exchange of exchanges) { + if (!isFinalStatus(exchange.output_status)) continue + const startMs = parseTimestamp(exchange.start_ts) + if (startMs === null) continue + parsedExchanges.push({ ...exchange, startMs }) + } + if (parsedExchanges.length === 0) return + + const blocks = db.query<WarpBlockRow>( + `SELECT block_id, start_ts, CAST(stylized_command AS BLOB) AS stylized_command + FROM blocks + WHERE ai_metadata IS NOT NULL + AND ai_metadata <> '' + AND json_extract(ai_metadata, '$.conversation_id') = ? + ORDER BY start_ts ASC`, + [conversationId], + ) + + const { tokenBudget, dominantModel } = extractTokenBudget(conversations[0]!.conversation_data) + const weights = parsedExchanges.map(exchange => estimateWeight(exchange.input)) + const fallbackBudget = weights.reduce((sum, weight) => sum + weight, 0) + const allocatedTokens = allocateTokens(weights, tokenBudget > 0 ? tokenBudget : fallbackBudget) + const toolsByExchange = assignCommandBlocksToExchanges(blocks, parsedExchanges) + + for (let index = 0; index < parsedExchanges.length; index++) { + const exchange = parsedExchanges[index]! + const deduplicationKey = `warp:${conversationId}:${exchange.exchange_id}` + if (seenKeys.has(deduplicationKey)) continue + + const timestamp = new Date(exchange.startMs).toISOString() + const model = resolveModelForExchange(exchange, dominantModel) + const inputTokens = allocatedTokens[index] ?? 0 + const exchangeTools = toolsByExchange.get(exchange.exchange_id) ?? { tools: [], bashCommands: [] } + const userMessage = extractUserMessage(exchange.input).slice(0, 500) + const projectPath = exchange.working_directory?.trim() || undefined + const project = projectPath ? sanitizeProject(projectPath) : source.project + + seenKeys.add(deduplicationKey) + yield { + provider: 'warp', + model, + inputTokens, + // Warp exposes only conversation-level usage totals in these tables, + // so we cannot reliably split per-exchange input vs output tokens. + outputTokens: 0, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD: calculateCost(model, inputTokens, 0, 0, 0, 0), + costIsEstimated: true, + tools: exchangeTools.tools, + bashCommands: exchangeTools.bashCommands, + timestamp, + speed: 'standard', + deduplicationKey, + userMessage, + sessionId: conversationId, + project, + projectPath, + } + } + } finally { + db.close() + } + }, + } +} + +async function discoverFromDb(dbPath: string): Promise<SessionSource[]> { + let db: SqliteDatabase + try { + db = openDatabase(dbPath) + } catch { + return [] + } + + try { + if (!validateSchema(db)) return [] + const rows = db.query<{ conversation_id: string; working_directory: string | null }>( + `SELECT c.conversation_id AS conversation_id, + ( + SELECT q.working_directory + FROM ai_queries q + WHERE q.conversation_id = c.conversation_id + AND q.working_directory IS NOT NULL + AND q.working_directory <> '' + ORDER BY q.start_ts DESC + LIMIT 1 + ) AS working_directory + FROM agent_conversations c + WHERE EXISTS ( + SELECT 1 FROM ai_queries q + WHERE q.conversation_id = c.conversation_id + ) + ORDER BY c.last_modified_at DESC`, + ) + + return rows.map(row => { + const projectPath = row.working_directory?.trim() ?? '' + return { + path: `${dbPath}:${row.conversation_id}`, + project: projectPath ? sanitizeProject(projectPath) : 'warp', + provider: 'warp', + } + }) + } catch { + return [] + } finally { + db.close() + } +} + +export function createWarpProvider(dbPathOverride?: string): Provider { + return { + name: 'warp', + displayName: 'Warp', + + modelDisplayName(model: string): string { + return modelDisplayName(model) + }, + + toolDisplayName(rawTool: string): string { + return rawTool === 'run_command' ? 'Bash' : rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + if (!isSqliteAvailable()) return [] + + const sessions: SessionSource[] = [] + for (const candidate of getDbCandidates(dbPathOverride)) { + const found = await discoverFromDb(candidate) + sessions.push(...found) + } + return sessions + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const warp = createWarpProvider() diff --git a/src/providers/zcode.ts b/src/providers/zcode.ts new file mode 100644 index 0000000..d9eaf47 --- /dev/null +++ b/src/providers/zcode.ts @@ -0,0 +1,227 @@ +import { join } from 'path' +import { homedir } from 'os' + +import { calculateCost } from '../models.js' +import { isSqliteAvailable, getSqliteLoadError, openDatabase, type SqliteDatabase } from '../sqlite.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' + +/// ZCode (CLI v0.14.x) records usage in a single SQLite database at +/// ~/.zcode/cli/db/db.sqlite. We read it because the other on-disk sources are +/// unusable for billing: the JSONL activity log redacts token counts, and no +/// source stores a dollar cost (GLM-5.2 runs on z.ai's start-plan subscription). +/// Tokens are exact; cost is computed from the pricing table. Schema verified +/// against db v0.14.8 on 2026-06-20. + +type SessionRow = { + id: string + directory: string +} + +type UsageRow = { + id: string + turn_id: string | null + model_id: string + input_tokens: number + output_tokens: number + reasoning_tokens: number + cache_creation_input_tokens: number + cache_read_input_tokens: number + started_at: number + completed_at: number | null +} + +type ToolRow = { + turn_id: string | null + tool_name: string +} + +function getDbPath(override?: string): string { + return override ?? join(homedir(), '.zcode', 'cli', 'db', 'db.sqlite') +} + +function sanitizeProject(path: string): string { + return path.replace(/^\//, '').replace(/\//g, '-') +} + +function epochMsToIso(ms: number | null): string { + if (ms === null || !Number.isFinite(ms) || ms <= 0) return new Date(0).toISOString() + return new Date(ms).toISOString() +} + +function validateSchema(db: SqliteDatabase): boolean { + try { + db.query<{ cnt: number }>('SELECT COUNT(*) as cnt FROM model_usage LIMIT 1') + db.query<{ cnt: number }>('SELECT COUNT(*) as cnt FROM session LIMIT 1') + return true + } catch { + return false + } +} + +function discover(dbPath: string): SessionSource[] { + let db: SqliteDatabase + try { + db = openDatabase(dbPath) + } catch { + return [] + } + try { + if (!validateSchema(db)) return [] + const rows = db.query<SessionRow>( + `SELECT DISTINCT s.id as id, s.directory as directory + FROM session s + JOIN model_usage m ON m.session_id = s.id + WHERE m.input_tokens > 0 OR m.output_tokens > 0 OR m.reasoning_tokens > 0 + OR m.cache_read_input_tokens > 0 OR m.cache_creation_input_tokens > 0`, + ) + return rows.map(row => ({ + path: `${dbPath}:${row.id}`, + project: sanitizeProject(row.directory), + provider: 'zcode', + })) + } catch { + return [] + } finally { + db.close() + } +} + +function createParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + if (!isSqliteAvailable()) { + process.stderr.write(getSqliteLoadError() + '\n') + return + } + + // Source paths are `<dbPath>:<sessionId>`. Split from the right so a colon + // in the path (Windows drive letter) doesn't corrupt the session id. + const segments = source.path.split(':') + const sessionId = segments[segments.length - 1]! + const dbPath = segments.slice(0, -1).join(':') + + let db: SqliteDatabase + try { + db = openDatabase(dbPath) + } catch (err) { + process.stderr.write( + `codeburn: cannot open ZCode database: ${err instanceof Error ? err.message : err}\n`, + ) + return + } + + try { + if (!validateSchema(db)) return + + // model_usage rows don't link to individual tool calls, only to a turn, + // so collect each turn's tools and attach them to one request per turn + // (below) to avoid double-counting across a turn's multiple requests. + const toolRows = db.query<ToolRow>( + `SELECT turn_id, tool_name FROM tool_usage + WHERE session_id = ? AND turn_id IS NOT NULL + ORDER BY started_at ASC`, + [sessionId], + ) + const toolsByTurn = new Map<string, string[]>() + for (const tool of toolRows) { + if (!tool.turn_id) continue + const list = toolsByTurn.get(tool.turn_id) ?? [] + list.push(tool.tool_name) + toolsByTurn.set(tool.turn_id, list) + } + + const rows = db.query<UsageRow>( + `SELECT id, turn_id, model_id, input_tokens, output_tokens, reasoning_tokens, + cache_creation_input_tokens, cache_read_input_tokens, started_at, completed_at + FROM model_usage WHERE session_id = ? + ORDER BY started_at ASC`, + [sessionId], + ) + + const turnsWithToolsEmitted = new Set<string>() + + for (const row of rows) { + const cacheRead = row.cache_read_input_tokens ?? 0 + const cacheCreation = row.cache_creation_input_tokens ?? 0 + const output = row.output_tokens ?? 0 + const reasoning = row.reasoning_tokens ?? 0 + // ZCode folds cached tokens into input_tokens (OpenAI-style). Split + // them back out so fresh input bills at the input rate and cached at + // the cache-read rate, matching the pricing table's Anthropic-style + // semantics. + const freshInput = Math.max(0, (row.input_tokens ?? 0) - cacheRead - cacheCreation) + + if (freshInput === 0 && output === 0 && reasoning === 0 && cacheRead === 0 && cacheCreation === 0) { + continue + } + + const dedupKey = `zcode:${row.id}` + if (seenKeys.has(dedupKey)) continue + seenKeys.add(dedupKey) + + let tools: string[] = [] + if (row.turn_id && !turnsWithToolsEmitted.has(row.turn_id)) { + const turnTools = toolsByTurn.get(row.turn_id) + if (turnTools && turnTools.length > 0) { + tools = turnTools + turnsWithToolsEmitted.add(row.turn_id) + } + } + + const model = row.model_id + const costUSD = calculateCost(model, freshInput, output, cacheCreation, cacheRead, 0) + + yield { + provider: 'zcode', + model, + inputTokens: freshInput, + outputTokens: output, + cacheCreationInputTokens: cacheCreation, + cacheReadInputTokens: cacheRead, + cachedInputTokens: 0, + reasoningTokens: reasoning, + webSearchRequests: 0, + costUSD, + tools, + bashCommands: [], + timestamp: epochMsToIso(row.completed_at ?? row.started_at), + speed: 'standard', + deduplicationKey: dedupKey, + turnId: row.turn_id ?? undefined, + userMessage: '', + sessionId, + } + } + } finally { + db.close() + } + }, + } +} + +export function createZcodeProvider(dbPathOverride?: string): Provider { + const dbPath = getDbPath(dbPathOverride) + return { + name: 'zcode', + displayName: 'ZCode', + + modelDisplayName(model: string): string { + return model + }, + + toolDisplayName(rawTool: string): string { + return rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + if (!isSqliteAvailable()) return [] + return discover(dbPath) + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const zcode = createZcodeProvider() diff --git a/src/providers/zed.ts b/src/providers/zed.ts new file mode 100644 index 0000000..7164149 --- /dev/null +++ b/src/providers/zed.ts @@ -0,0 +1,229 @@ +import { existsSync } from 'fs' +import { join } from 'path' +import { homedir } from 'os' +import zlib from 'zlib' + +import { calculateCost } from '../models.js' +import { getSqliteLoadError, isSqliteAvailable, openDatabase, type SqliteDatabase } from '../sqlite.js' +import type { ParsedProviderCall, Provider, SessionParser, SessionSource } from './types.js' + +// Zed's built-in agent stores one row per thread in a single SQLite database; +// the `data` blob is zstd-compressed JSON carrying `request_token_usage` +// (per-request Anthropic-shaped token counts) and the thread's model. +// Format documented in issue #480. + +// zstd landed in node:zlib in 22.15 / 23.8; the package floor is 22.13, so the +// provider degrades with a notice instead of assuming the export exists. +const zstdDecompress = (zlib as { zstdDecompressSync?: (buf: Buffer) => Buffer }).zstdDecompressSync + +function getZedThreadsDbPath(): string { + if (process.platform === 'darwin') { + return join(homedir(), 'Library', 'Application Support', 'Zed', 'threads', 'threads.db') + } + if (process.platform === 'win32') { + return join(homedir(), 'AppData', 'Local', 'Zed', 'threads', 'threads.db') + } + return join(homedir(), '.local', 'share', 'zed', 'threads', 'threads.db') +} + +const THREADS_QUERY = ` + SELECT id, summary, updated_at, data_type, data + FROM threads + ORDER BY updated_at ASC +` + +type ThreadRow = { + id: string + summary: string | null + updated_at: string | null + data_type: string | null + data: Uint8Array | null +} + +type TokenUsage = { + input_tokens?: number + output_tokens?: number + cache_creation_input_tokens?: number + cache_read_input_tokens?: number +} + +type ThreadJson = { + model?: { provider?: string; model?: string } + request_token_usage?: Record<string, TokenUsage> + cumulative_token_usage?: TokenUsage +} + +function num(value: number | undefined): number { + return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : 0 +} + +function usageIsEmpty(usage: TokenUsage): boolean { + return ( + num(usage.input_tokens) === 0 && + num(usage.output_tokens) === 0 && + num(usage.cache_creation_input_tokens) === 0 && + num(usage.cache_read_input_tokens) === 0 + ) +} + +function buildCall(opts: { + threadId: string + requestKey: string + usage: TokenUsage + model: string + timestamp: string + userMessage: string +}): ParsedProviderCall { + const input = num(opts.usage.input_tokens) + const output = num(opts.usage.output_tokens) + const cacheWrite = num(opts.usage.cache_creation_input_tokens) + const cacheRead = num(opts.usage.cache_read_input_tokens) + return { + provider: 'zed', + model: opts.model, + inputTokens: input, + outputTokens: output, + cacheCreationInputTokens: cacheWrite, + cacheReadInputTokens: cacheRead, + cachedInputTokens: cacheRead, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD: calculateCost(opts.model, input, output, cacheWrite, cacheRead, 0), + tools: [], + bashCommands: [], + timestamp: opts.timestamp, + speed: 'standard', + deduplicationKey: `zed:${opts.threadId}:${opts.requestKey}`, + userMessage: opts.userMessage, + sessionId: opts.threadId, + } +} + +function parseThreads(db: SqliteDatabase, seenKeys: Set<string>): ParsedProviderCall[] { + const calls: ParsedProviderCall[] = [] + let skipped = 0 + + let rows: ThreadRow[] + try { + rows = db.query<ThreadRow>(THREADS_QUERY) + } catch { + return calls + } + + for (const row of rows) { + try { + // Zed's DataType enum is "zstd" (current save path) or "json" (legacy + // uncompressed rows); anything else is unknown. + if (!row.id || !row.data || (row.data_type !== 'zstd' && row.data_type !== 'json')) { + if (row.data != null) skipped++ + continue + } + const parsedAt = new Date(row.updated_at ?? '') + if (Number.isNaN(parsedAt.getTime())) continue + const timestamp = parsedAt.toISOString() + + const jsonText = row.data_type === 'zstd' + ? zstdDecompress!(Buffer.from(row.data)).toString('utf-8') + : Buffer.from(row.data).toString('utf-8') + const thread = JSON.parse(jsonText) as ThreadJson + const model = thread.model?.model || 'unknown' + const userMessage = row.summary ?? '' + + const requests = Object.entries(thread.request_token_usage ?? {}).filter(([, usage]) => usage != null && !usageIsEmpty(usage)) + // The per-request map is keyed by user message and does not cover every + // request (verified on a real thread: cumulative was ~3x the map sum), + // so a remainder entry tops the thread up to the exact cumulative + // counter. Threads with an empty map degrade to one cumulative call. + const entries: Array<[string, TokenUsage]> = [...requests] + const cumulative = thread.cumulative_token_usage + if (cumulative && !usageIsEmpty(cumulative)) { + let sumIn = 0, sumOut = 0, sumWrite = 0, sumRead = 0 + for (const [, usage] of requests) { + sumIn += num(usage.input_tokens) + sumOut += num(usage.output_tokens) + sumWrite += num(usage.cache_creation_input_tokens) + sumRead += num(usage.cache_read_input_tokens) + } + const remainder: TokenUsage = { + input_tokens: Math.max(0, num(cumulative.input_tokens) - sumIn), + output_tokens: Math.max(0, num(cumulative.output_tokens) - sumOut), + cache_creation_input_tokens: Math.max(0, num(cumulative.cache_creation_input_tokens) - sumWrite), + cache_read_input_tokens: Math.max(0, num(cumulative.cache_read_input_tokens) - sumRead), + } + if (!usageIsEmpty(remainder)) entries.push(['cumulative-remainder', remainder]) + } + + for (const [requestKey, usage] of entries) { + const call = buildCall({ threadId: row.id, requestKey, usage, model, timestamp, userMessage }) + if (seenKeys.has(call.deduplicationKey)) continue + seenKeys.add(call.deduplicationKey) + calls.push(call) + } + } catch { + skipped++ + } + } + + if (skipped > 0) { + process.stderr.write(`codeburn: skipped ${skipped} unreadable Zed threads\n`) + } + return calls +} + +function createParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + if (!isSqliteAvailable()) { + process.stderr.write(getSqliteLoadError() + '\n') + return + } + if (!zstdDecompress) { + process.stderr.write('codeburn: Zed threads need Node >= 22.15 (zstd support); skipping Zed usage.\n') + return + } + + let db: SqliteDatabase + try { + db = openDatabase(source.path) + } catch (err) { + process.stderr.write(`codeburn: cannot open Zed database: ${err instanceof Error ? err.message : err}\n`) + return + } + try { + for (const call of parseThreads(db, seenKeys)) { + yield call + } + } finally { + db.close() + } + }, + } +} + +export function createZedProvider(dbPathOverride?: string): Provider { + return { + name: 'zed', + displayName: 'Zed', + + modelDisplayName(model: string): string { + return model + }, + + toolDisplayName(rawTool: string): string { + return rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + if (!isSqliteAvailable()) return [] + const dbPath = dbPathOverride ?? getZedThreadsDbPath() + if (!existsSync(dbPath)) return [] + return [{ path: dbPath, project: 'zed', provider: 'zed' }] + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const zed = createZedProvider() diff --git a/src/providers/zerostack.ts b/src/providers/zerostack.ts new file mode 100644 index 0000000..959e1b1 --- /dev/null +++ b/src/providers/zerostack.ts @@ -0,0 +1,162 @@ +import { readdir } from 'fs/promises' +import { basename, join } from 'path' +import { homedir, platform } from 'os' + +import { readSessionFile } from '../fs-utils.js' +import { calculateCost, getShortModelName } from '../models.js' +import type { Provider, SessionSource, SessionParser, ParsedProviderCall } from './types.js' + +// zerostack (https://github.com/gi-dellav/zerostack) is a minimal Rust coding +// agent. Each session is a single JSON file under <dataDir>/zerostack/sessions/. +// Token counts are stored as CUMULATIVE session totals (total_input_tokens, +// total_output_tokens, total_cost) — there is no per-call breakdown — so we emit +// one ParsedProviderCall per session. + +const toolNameMap: Record<string, string> = { + bash: 'Bash', + read: 'Read', + write: 'Write', + edit: 'Edit', + grep: 'Grep', + glob: 'Glob', + fetch: 'WebFetch', + search: 'WebSearch', + task: 'Agent', +} + +type ZerostackMessage = { + role?: string + content?: string | Array<{ text?: string }> +} + +type ZerostackSession = { + id?: string + messages?: ZerostackMessage[] + created_at?: string + updated_at?: string + total_input_tokens?: number + total_output_tokens?: number + model?: string + provider?: string + working_dir?: string +} + +// zerostack uses the platform data dir (Rust `dirs::data_dir`): macOS maps to +// ~/Library/Application Support, everything else to $XDG_DATA_HOME or +// ~/.local/share, then a `zerostack` subdir. ZS_DATA_DIR overrides the whole +// data dir (sessions live directly under it). Matches src/session/storage.rs. +function defaultSessionsDir(): string { + const override = process.env['ZS_DATA_DIR'] + if (override) return join(override, 'sessions') + const base = + platform() === 'darwin' + ? join(homedir(), 'Library', 'Application Support') + : process.env['XDG_DATA_HOME'] ?? join(homedir(), '.local', 'share') + return join(base, 'zerostack', 'sessions') +} + +function firstUserMessage(messages: ZerostackMessage[]): string { + const msg = messages.find(m => m.role === 'user') + if (!msg) return '' + if (typeof msg.content === 'string') return msg.content + return (msg.content ?? []).map(c => c.text ?? '').filter(Boolean).join(' ') +} + +async function readSession(path: string): Promise<ZerostackSession | null> { + const content = await readSessionFile(path) + if (content === null) return null + try { + return JSON.parse(content) as ZerostackSession + } catch { + return null + } +} + +function createParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + const session = await readSession(source.path) + if (!session) return + + const input = session.total_input_tokens ?? 0 + const output = session.total_output_tokens ?? 0 + if (input === 0 && output === 0) return + + const timestamp = session.updated_at ?? session.created_at ?? '' + const sessionId = session.id ?? basename(source.path, '.json') + const dedupKey = `${source.provider}:${source.path}:${timestamp}:${sessionId}` + if (seenKeys.has(dedupKey)) return + seenKeys.add(dedupKey) + + const model = session.model ?? '' + + yield { + provider: source.provider, + model, + inputTokens: input, + outputTokens: output, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + costUSD: calculateCost(model, input, output, 0, 0, 0), + // zerostack persists only final assistant text, not tool-call records, + // so there is nothing to extract here. + tools: [], + bashCommands: [], + timestamp, + speed: 'standard', + deduplicationKey: dedupKey, + userMessage: firstUserMessage(session.messages ?? []), + sessionId, + project: source.project, + projectPath: session.working_dir, + } + }, + } +} + +export function createZerostackProvider(sessionsDir?: string): Provider { + const dir = sessionsDir ?? defaultSessionsDir() + + return { + name: 'zerostack', + displayName: 'Zerostack', + + modelDisplayName(model: string): string { + // OpenRouter routes arrive prefixed (e.g. "deepseek/deepseek-v4-pro"). + return getShortModelName(model.replace(/^[^/]+\//, '')) + }, + + toolDisplayName(rawTool: string): string { + return toolNameMap[rawTool] ?? rawTool + }, + + async discoverSessions(): Promise<SessionSource[]> { + let files: string[] + try { + files = await readdir(dir) + } catch { + return [] + } + + const sources: SessionSource[] = [] + for (const file of files) { + if (!file.endsWith('.json')) continue + const path = join(dir, file) + const session = await readSession(path) + if (!session) continue + const project = session.working_dir ? basename(session.working_dir) : basename(file, '.json') + sources.push({ path, project, provider: 'zerostack' }) + } + return sources + }, + + createSessionParser(source: SessionSource, seenKeys: Set<string>): SessionParser { + return createParser(source, seenKeys) + }, + } +} + +export const zerostack = createZerostackProvider() diff --git a/src/session-cache.ts b/src/session-cache.ts new file mode 100644 index 0000000..7d02e9c --- /dev/null +++ b/src/session-cache.ts @@ -0,0 +1,405 @@ +import { readFile, stat, open, rename, unlink, readdir, mkdir } from 'fs/promises' +import { existsSync } from 'fs' +import { createHash, randomBytes } from 'crypto' +import { join } from 'path' +import { homedir } from 'os' + +import type { ToolCall } from './types.js' + +// ── Types ────────────────────────────────────────────────────────────── + +export type CachedUsage = { + inputTokens: number + outputTokens: number + cacheCreationInputTokens: number + cacheReadInputTokens: number + cachedInputTokens: number + reasoningTokens: number + webSearchRequests: number + cacheCreationOneHourTokens: number +} + +export type CachedCall = { + provider: string + model: string + usage: CachedUsage + costUSD?: number + speed: 'standard' | 'fast' + timestamp: string + tools: string[] + bashCommands: string[] + skills: string[] + subagentTypes: string[] + deduplicationKey: string + project?: string + projectPath?: string + toolSequence?: ToolCall[][] +} + +export type CachedTurn = { + timestamp: string + sessionId: string + userMessage: string + calls: CachedCall[] +} + +export type FileFingerprint = { + dev: number + ino: number + mtimeMs: number + sizeBytes: number +} + +export type CachedFile = { + fingerprint: FileFingerprint + lastCompleteLineOffset?: number + canonicalCwd?: string + canonicalProjectName?: string + mcpInventory: string[] + turns: CachedTurn[] + // Claude Code only: for a subagent transcript (`subagents/.../agent-*.jsonl`), + // the `agentType` from its sibling `.meta.json` (e.g. `workflow-subagent`, + // `Explore`, `general-purpose`). Drives the Claude-scoped agent-type breakdown. + agentType?: string + // Negative-result marker: this file threw while parsing at the recorded + // fingerprint. Cached so we don't re-read + re-throw it on every refresh; it + // is re-parsed only when the file changes (fingerprint differs). Carries no + // turns, so it contributes no usage. (issue #441 follow-up) + failed?: boolean +} + +export type ProviderSection = { + envFingerprint: string + files: Record<string, CachedFile> + /** True when the provider's cache entries survive source-file eviction. */ + durable?: boolean +} + +export type SessionCache = { + version: number + providers: Record<string, ProviderSection> +} + +// ── Constants ────────────────────────────────────────────────────────── + +export const CACHE_VERSION = 4 + +const CACHE_FILE = 'session-cache.json' +const TEMP_FILE_MAX_AGE_MS = 5 * 60 * 1000 + +const PROVIDER_ENV_VARS: Record<string, string[]> = { + claude: ['CLAUDE_CONFIG_DIRS', 'CLAUDE_CONFIG_DIR'], + codex: ['CODEX_HOME'], + hermes: ['HERMES_HOME'], + 'lingtai-tui': ['LINGTAI_HOME', 'LINGTAI_TUI_HOME', 'LINGTAI_TUI_GLOBAL_DIR'], + droid: ['FACTORY_DIR'], + cursor: ['XDG_DATA_HOME'], + 'cursor-agent': ['XDG_DATA_HOME'], + opencode: ['XDG_DATA_HOME'], + goose: ['XDG_DATA_HOME'], + crush: ['XDG_DATA_HOME'], + warp: ['WARP_DB_PATH'], + antigravity: ['CODEBURN_CACHE_DIR'], + qwen: ['QWEN_DATA_DIR'], + 'ibm-bob': ['XDG_CONFIG_HOME'], +} + +// Names of providers whose cache entries are never evicted when source files +// disappear — they are preserved so month-to-date totals never drop. +export const DURABLE_PROVIDER_NAMES: ReadonlySet<string> = new Set(['copilot']) + +const PROVIDER_PARSE_VERSIONS: Record<string, string> = { + claude: 'cowork-space-grouping-v1', + cline: 'worktree-project-grouping-v1', + // Bump when the Codex parser changes attribution so unchanged, already-cached + // session files re-parse (session-cache.json serves them without invoking the + // provider parser otherwise). Covers native mcp_tool_call_end (#513) and + // CLI-wrapped `mcp-cli call` (#478) MCP attribution. + codex: 'mcp-attribution-v2', + cursor: 'composer-anchored-crediting-v1', + 'cursor-agent': 'workspaceless-transcript-v1', + copilot: 'otel-durable-v1', + hermes: 'reasoning-output-accounting-v1', + 'lingtai-tui': 'token-ledger-registry-activity-v3', + 'ibm-bob': 'worktree-project-grouping-v1', + kiro: 'ide-parsing-v1', + 'kilo-code': 'worktree-project-grouping-v1', + 'roo-code': 'worktree-project-grouping-v1', + warp: 'worktree-project-grouping-v1', + antigravity: 'worktree-project-grouping-v3', +} + +// ── Cache Dir ────────────────────────────────────────────────────────── + +function getCacheDir(): string { + return process.env['CODEBURN_CACHE_DIR'] ?? join(homedir(), '.cache', 'codeburn') +} + +function getCachePath(): string { + return join(getCacheDir(), CACHE_FILE) +} + +// ── Env Fingerprint ──────────────────────────────────────────────────── + +export function computeEnvFingerprint(provider: string): string { + const vars = PROVIDER_ENV_VARS[provider] ?? [] + const parts = vars.map(v => `${v}=${process.env[v] ?? ''}`) + const parseVersion = PROVIDER_PARSE_VERSIONS[provider] + if (parseVersion) parts.push(`parser=${parseVersion}`) + return createHash('sha256').update(parts.join('\0')).digest('hex').slice(0, 16) +} + +// ── Load / Save ──────────────────────────────────────────────────────── + +export function emptyCache(): SessionCache { + return { version: CACHE_VERSION, providers: {} } +} + +function isNum(v: unknown): v is number { + return typeof v === 'number' && Number.isFinite(v) +} + +function isStringArray(v: unknown): v is string[] { + return Array.isArray(v) && v.every(e => typeof e === 'string') +} + +function isOptionalString(v: unknown): boolean { + return v === undefined || typeof v === 'string' +} + +function isOptionalNum(v: unknown): boolean { + return v === undefined || isNum(v) +} + +function isToolCall(v: unknown): boolean { + if (!v || typeof v !== 'object') return false + const o = v as Record<string, unknown> + return typeof o['tool'] === 'string' + && isOptionalString(o['file']) + && isOptionalString(o['command']) +} + +function isToolCallArray(v: unknown): boolean { + return Array.isArray(v) && (v as unknown[]).every(isToolCall) +} + +function validateFingerprint(fp: unknown): fp is FileFingerprint { + if (!fp || typeof fp !== 'object') return false + const f = fp as Record<string, unknown> + return isNum(f['dev']) && isNum(f['ino']) && isNum(f['mtimeMs']) && isNum(f['sizeBytes']) +} + +function validateUsage(u: unknown): u is CachedUsage { + if (!u || typeof u !== 'object') return false + const o = u as Record<string, unknown> + return isNum(o['inputTokens']) && isNum(o['outputTokens']) + && isNum(o['cacheCreationInputTokens']) && isNum(o['cacheReadInputTokens']) + && isNum(o['cachedInputTokens']) && isNum(o['reasoningTokens']) + && isNum(o['webSearchRequests']) && isNum(o['cacheCreationOneHourTokens']) +} + +function validateCall(c: unknown): c is CachedCall { + if (!c || typeof c !== 'object') return false + const o = c as Record<string, unknown> + return typeof o['provider'] === 'string' + && typeof o['model'] === 'string' + && typeof o['deduplicationKey'] === 'string' + && typeof o['timestamp'] === 'string' + && (o['speed'] === 'standard' || o['speed'] === 'fast') + && isOptionalNum(o['costUSD']) + && isStringArray(o['tools']) + && isStringArray(o['bashCommands']) + && isStringArray(o['skills']) + && (o['subagentTypes'] === undefined || isStringArray(o['subagentTypes'])) + && isOptionalString(o['project']) + && isOptionalString(o['projectPath']) + && (o['toolSequence'] === undefined || (Array.isArray(o['toolSequence']) && (o['toolSequence'] as unknown[]).every(s => isToolCallArray(s)))) + && validateUsage(o['usage']) +} + +function validateTurn(t: unknown): t is CachedTurn { + if (!t || typeof t !== 'object') return false + const o = t as Record<string, unknown> + return typeof o['timestamp'] === 'string' + && typeof o['sessionId'] === 'string' + && typeof o['userMessage'] === 'string' + && Array.isArray(o['calls']) + && (o['calls'] as unknown[]).every(validateCall) +} + +function validateCachedFile(f: unknown): f is CachedFile { + if (!f || typeof f !== 'object') return false + const o = f as Record<string, unknown> + return validateFingerprint(o['fingerprint']) + && isOptionalNum(o['lastCompleteLineOffset']) + && isOptionalString(o['canonicalCwd']) + && isOptionalString(o['canonicalProjectName']) + && isStringArray(o['mcpInventory']) + && Array.isArray(o['turns']) + && (o['turns'] as unknown[]).every(validateTurn) +} + +function validateProviderSection(s: unknown): s is ProviderSection { + if (!s || typeof s !== 'object') return false + const o = s as Record<string, unknown> + if (typeof o['envFingerprint'] !== 'string') return false + if (!o['files'] || typeof o['files'] !== 'object' || Array.isArray(o['files'])) return false + return Object.values(o['files'] as Record<string, unknown>).every(validateCachedFile) +} + +function validateCache(raw: unknown): raw is SessionCache { + if (!raw || typeof raw !== 'object') return false + const o = raw as Record<string, unknown> + if (o['version'] !== CACHE_VERSION) return false + if (!o['providers'] || typeof o['providers'] !== 'object' || Array.isArray(o['providers'])) return false + return Object.values(o['providers'] as Record<string, unknown>).every(validateProviderSection) +} + +export async function loadCache(): Promise<SessionCache> { + try { + const raw = await readFile(getCachePath(), 'utf-8') + const parsed = JSON.parse(raw) + if (!validateCache(parsed)) return emptyCache() + return parsed + } catch { + return emptyCache() + } +} + +export async function saveCache(cache: SessionCache): Promise<void> { + const dir = getCacheDir() + if (!existsSync(dir)) await mkdir(dir, { recursive: true }) + + const finalPath = getCachePath() + const tempPath = `${finalPath}.${randomBytes(8).toString('hex')}.tmp` + delete (cache as { _dirty?: boolean })._dirty + const payload = JSON.stringify(cache) + + const handle = await open(tempPath, 'w', 0o600) + try { + await handle.writeFile(payload, { encoding: 'utf-8' }) + await handle.sync() + } finally { + await handle.close() + } + + try { + await rename(tempPath, finalPath) + } catch (err) { + try { await unlink(tempPath) } catch {} + throw err + } +} + +// ── File Fingerprinting ──────────────────────────────────────────────── + +export async function fingerprintFile(filePath: string): Promise<FileFingerprint | null> { + try { + const s = await stat(filePath) + return { dev: s.dev, ino: s.ino, mtimeMs: s.mtimeMs, sizeBytes: s.size } + } catch { + // Providers encode extra context into source paths using virtual suffixes: + // - Cursor: `<dbPath>#cursor-ws=<workspace>` (workspace-aware routing) + // - OpenCode: `<dbPath>:<sessionId>` (session scoping) + // These compound paths don't exist on disk; strip the suffix to stat the + // underlying file. Try `#` first (rare in real paths), then `:` (must use + // lastIndexOf to tolerate Windows drive letters like C:\...). + const hashIdx = filePath.indexOf('#') + if (hashIdx > 0) { + try { + const s = await stat(filePath.slice(0, hashIdx)) + return { dev: s.dev, ino: s.ino, mtimeMs: s.mtimeMs, sizeBytes: s.size } + } catch { + // fall through to colon check + } + } + const colonIdx = filePath.lastIndexOf(':') + if (colonIdx > 0) { + try { + const s = await stat(filePath.slice(0, colonIdx)) + return { dev: s.dev, ino: s.ino, mtimeMs: s.mtimeMs, sizeBytes: s.size } + } catch { + return null + } + } + return null + } +} + +// ── Reconciliation ───────────────────────────────────────────────────── + +export type ReconcileAction = + | { action: 'unchanged' } + | { action: 'appended'; readFromOffset: number } + | { action: 'modified' } + | { action: 'new' } + +export function reconcileFile( + current: FileFingerprint, + cached: CachedFile | undefined, +): ReconcileAction { + if (!cached) return { action: 'new' } + + const fp = cached.fingerprint + + if ( + fp.dev === current.dev && + fp.ino === current.ino && + fp.mtimeMs === current.mtimeMs && + fp.sizeBytes === current.sizeBytes + ) { + return { action: 'unchanged' } + } + + if ( + cached.lastCompleteLineOffset !== undefined && + fp.dev === current.dev && + fp.ino === current.ino && + current.sizeBytes > fp.sizeBytes + ) { + return { action: 'appended', readFromOffset: cached.lastCompleteLineOffset } + } + + return { action: 'modified' } +} + +// ── Dedup Merge ──────────────────────────────────────────────────────── +// When appending incremental data, streaming Claude messages can re-emit +// the same dedup key with updated usage. Merge by key: keep the earliest +// timestamp, take incoming usage/tools/bashCommands/skills (latest wins). + +export function mergeCallByDedupKey( + existing: CachedCall, + incoming: CachedCall, +): CachedCall { + return { + ...incoming, + timestamp: existing.timestamp < incoming.timestamp + ? existing.timestamp + : incoming.timestamp, + } +} + +// ── Temp Cleanup ─────────────────────────────────────────────────────── + +export async function cleanupOrphanedTempFiles(): Promise<void> { + const dir = getCacheDir() + if (!existsSync(dir)) return + + try { + const entries = await readdir(dir) + const now = Date.now() + + const prefix = 'session-cache.json.' + for (const entry of entries) { + if (!entry.startsWith(prefix) || !entry.endsWith('.tmp')) continue + try { + const fullPath = join(dir, entry) + const s = await stat(fullPath) + if (now - s.mtimeMs > TEMP_FILE_MAX_AGE_MS) { + await unlink(fullPath) + } + } catch {} + } + } catch {} +} diff --git a/src/sharing/client.ts b/src/sharing/client.ts new file mode 100644 index 0000000..fd96246 --- /dev/null +++ b/src/sharing/client.ts @@ -0,0 +1,111 @@ +import { request } from 'https' +import type { TLSSocket } from 'tls' + +import { certFingerprint } from './pairing.js' +import type { Identity } from './identity.js' +import type { UsageQuery } from './share-server.js' + +// req.setTimeout only arms once connected; it does not abort a stalled TCP +// connect, so an unreachable peer would otherwise ride the OS connect timeout +// (~75s on macOS). Cap the TCP-connect phase separately; it clears the instant +// the socket connects, so the TLS handshake and the read/approval timeouts +// (req.setTimeout) are unaffected even over a slow VPN link. +const CONNECT_TIMEOUT_MS = 3000 + +export type PeerEndpoint = { + identity: Identity // our own identity (we present our cert so the peer can bind a token to us) + host: string + port: number + // When set, the connection is aborted unless the peer's cert fingerprint matches. + expectedFingerprint?: string +} + +export type Response = { status: number; serverFingerprint: string; json: unknown } + +// One request to a peer. Self-signed certs are accepted at the TLS layer +// (rejectUnauthorized:false) but the peer is authenticated by pinning its cert +// fingerprint, the SSH/Syncthing trust-on-first-use model. +function call( + ep: PeerEndpoint, + method: string, + path: string, + headers: Record<string, string> = {}, + body?: string, + timeoutMs = 15000, +): Promise<Response> { + return new Promise((resolve, reject) => { + const req = request( + { + host: ep.host, + port: ep.port, + method, + path, + key: ep.identity.key, + cert: ep.identity.cert, + rejectUnauthorized: false, + checkServerIdentity: () => undefined, + // Fresh socket per request so the pinned-fingerprint check always reads + // this connection's certificate, never a pooled/keep-alive one. + agent: false, + headers: { ...headers, ...(body ? { 'content-type': 'application/json' } : {}) }, + }, + (res) => { + const cert = (res.socket as TLSSocket).getPeerCertificate?.() + const serverFingerprint = cert?.raw ? certFingerprint(cert.raw) : '' + if (ep.expectedFingerprint && serverFingerprint !== ep.expectedFingerprint) { + res.destroy() + reject(new Error('server fingerprint mismatch')) + return + } + let data = '' + res.on('data', (chunk) => { + data += chunk + }) + res.on('end', () => resolve({ status: res.statusCode ?? 0, serverFingerprint, json: safeJson(data) })) + }, + ) + req.on('error', reject) + req.setTimeout(timeoutMs, () => req.destroy(new Error('peer timed out'))) + const connectTimer = setTimeout(() => req.destroy(new Error('peer unreachable')), CONNECT_TIMEOUT_MS) + connectTimer.unref() + req.once('socket', (socket) => { + const clear = () => clearTimeout(connectTimer) + socket.once('connect', clear) + socket.once('secureConnect', clear) + }) + req.once('close', () => clearTimeout(connectTimer)) + if (body) req.write(body) + req.end() + }) +} + +export function hello(ep: PeerEndpoint): Promise<Response> { + return call(ep, 'GET', '/api/peer/hello') +} + +export function pair(ep: PeerEndpoint, pin: string, name: string): Promise<Response> { + return call(ep, 'POST', '/api/peer/pair', {}, JSON.stringify({ pin, name })) +} + +// Approve-style pairing: no PIN. The peer prompts its user to approve; this +// request stays open until they accept or decline. +export function pairRequest(ep: PeerEndpoint, name: string): Promise<Response> { + // Stays open while the peer's user decides; give it longer than the server's + // 60s approval prompt. + return call(ep, 'POST', '/api/peer/pair-request', {}, JSON.stringify({ name }), 65_000) +} + +export function fetchUsage(ep: PeerEndpoint, token: string, query: UsageQuery = {}): Promise<Response> { + const params = new URLSearchParams() + for (const [k, v] of Object.entries(query)) if (v) params.set(k, v) + const qs = params.toString() + return call(ep, 'GET', `/api/usage${qs ? `?${qs}` : ''}`, { authorization: `Bearer ${token}` }) +} + +function safeJson(s: string): unknown { + try { + return JSON.parse(s) + } catch { + return null + } +} diff --git a/src/sharing/discovery.ts b/src/sharing/discovery.ts new file mode 100644 index 0000000..9e34874 --- /dev/null +++ b/src/sharing/discovery.ts @@ -0,0 +1,54 @@ +import { Bonjour, type Service } from 'bonjour-service' + +const SERVICE_TYPE = 'codeburn' + +export type DiscoveredDevice = { name: string; host: string; port: number; fingerprint: string } + +export type Advertiser = { stop: () => Promise<void> } + +// Announce this device on the local network so others can find it without an IP. +export function advertise(opts: { name: string; port: number; fingerprint: string }): Advertiser { + const bonjour = new Bonjour() + bonjour.publish({ + name: opts.name, + type: SERVICE_TYPE, + port: opts.port, + txt: { fp: opts.fingerprint, dn: opts.name, v: '1' }, + }) + return { + stop: () => + new Promise<void>((resolve) => { + bonjour.unpublishAll(() => bonjour.destroy(() => resolve())) + }), + } +} + +function pickAddress(service: Service): string | null { + const addrs = service.addresses ?? [] + const ipv4 = addrs.find((a) => /^\d+\.\d+\.\d+\.\d+$/.test(a)) + if (ipv4) return ipv4 + if (service.host) return service.host + return addrs[0] ?? null +} + +// Browse the local network for sharing devices for `timeoutMs`. Resolves to the +// devices found, deduped by fingerprint. +export function browse(timeoutMs = 2500): Promise<DiscoveredDevice[]> { + return new Promise((resolve) => { + const bonjour = new Bonjour() + const found = new Map<string, DiscoveredDevice>() + const browser = bonjour.find({ type: SERVICE_TYPE }, (service) => { + const txt = (service.txt ?? {}) as Record<string, string> + const fingerprint = txt['fp'] + const address = pickAddress(service) + if (!fingerprint || !address) return + const name = txt['dn'] || service.name || address + found.set(fingerprint, { name, host: address, port: service.port, fingerprint }) + }) + const timer = setTimeout(() => { + browser.stop() + bonjour.destroy(() => resolve([...found.values()])) + }, timeoutMs) + timer.unref?.() + }) +} diff --git a/src/sharing/host.ts b/src/sharing/host.ts new file mode 100644 index 0000000..f5aaf3e --- /dev/null +++ b/src/sharing/host.ts @@ -0,0 +1,245 @@ +import { hello, pair, pairRequest, fetchUsage } from './client.js' +import { loadOrCreateIdentity } from './identity.js' +import { pairingCode } from './pairing.js' +import { sanitizeForSharing } from './sanitize.js' +import type { DiscoveredDevice } from './discovery.js' +import type { UsageQuery } from './share-server.js' +import { getSharingDir, loadRemotes, saveRemotes, type RemoteDevice } from './store.js' +import type { CombinedUsage, DeviceSummary, MenubarPayload } from '../menubar-json.js' +import { formatCost } from '../currency.js' +import { renderTable } from '../text-table.js' +import { Chalk } from 'chalk' + +export type { CombinedUsage, DeviceSummary } from '../menubar-json.js' + +// Minimal shape we read from a device's usage payload (the menubar payload). +// Cache read/write come from the period-scoped `current` (like input/output) +// when the peer sends them; older peers only carry cache in the daily history, +// so we fall back to summing that (scoped by `window` when provided). +type DevicePayload = { + current?: { cost?: number; calls?: number; sessions?: number; inputTokens?: number; outputTokens?: number; cacheReadTokens?: number; cacheWriteTokens?: number } + history?: { daily?: Array<{ date?: string; cacheReadTokens?: number; cacheWriteTokens?: number }> } +} + +type SummaryWindow = { + start: string + end: string +} + +export type DeviceUsage = { + id: string // stable unique id (cert fingerprint for remotes, 'local' for this device) + name: string + local: boolean + payload?: DevicePayload + error?: string +} + +const zeroUsage = { + cost: 0, + calls: 0, + sessions: 0, + inputTokens: 0, + outputTokens: 0, + cacheCreateTokens: 0, + cacheReadTokens: 0, + totalTokens: 0, +} + +function num(n: number | undefined): number { + return n ?? 0 +} + +function summarizeOneDevice(d: DeviceUsage, window?: SummaryWindow): DeviceSummary { + const error = d.error !== undefined ? d.error : d.payload === undefined ? 'no usage payload' : undefined + if (error !== undefined || d.payload === undefined) { + return { + id: d.id, + name: d.name, + local: d.local, + error, + ...zeroUsage, + } + } + + const cur = d.payload.current + const daily = (d.payload.history?.daily ?? []).filter((e) => { + if (window === undefined) return true + return e.date !== undefined && window.start <= e.date && e.date <= window.end + }) + const inputTokens = num(cur?.inputTokens) + const outputTokens = num(cur?.outputTokens) + // Prefer the period-scoped `current` counts (issue #583); fall back to the + // windowed daily history for older peers that don't send them. `??` keeps a + // genuine 0 and only falls back when the field is absent. + const cacheCreateTokens = cur?.cacheWriteTokens ?? daily.reduce((s, e) => s + num(e.cacheWriteTokens), 0) + const cacheReadTokens = cur?.cacheReadTokens ?? daily.reduce((s, e) => s + num(e.cacheReadTokens), 0) + return { + id: d.id, + name: d.name, + local: d.local, + cost: num(cur?.cost), + calls: num(cur?.calls), + sessions: num(cur?.sessions), + inputTokens, + outputTokens, + cacheCreateTokens, + cacheReadTokens, + totalTokens: inputTokens + outputTokens + cacheCreateTokens + cacheReadTokens, + } +} + +export function summarizeDeviceUsage(results: DeviceUsage[], window?: SummaryWindow): CombinedUsage { + const perDevice = results.map((d) => summarizeOneDevice(d, window)) + const combined = perDevice.reduce( + (a, d) => { + if (d.error !== undefined) return a + return { + cost: a.cost + d.cost, + calls: a.calls + d.calls, + sessions: a.sessions + d.sessions, + inputTokens: a.inputTokens + d.inputTokens, + outputTokens: a.outputTokens + d.outputTokens, + cacheCreateTokens: a.cacheCreateTokens + d.cacheCreateTokens, + cacheReadTokens: a.cacheReadTokens + d.cacheReadTokens, + totalTokens: a.totalTokens + d.totalTokens, + deviceCount: a.deviceCount, + reachableCount: a.reachableCount + 1, + } + }, + { ...zeroUsage, deviceCount: perDevice.length, reachableCount: 0 }, + ) + return { perDevice, combined } +} + +function parseHostPort(input: string, defaultPort: number): { host: string; port: number } { + const idx = input.lastIndexOf(':') + if (idx > 0 && /^\d+$/.test(input.slice(idx + 1))) { + return { host: input.slice(0, idx), port: Number(input.slice(idx + 1)) } + } + return { host: input, port: defaultPort } +} + +// Pair with a device the user is currently sharing (PIN shown on that device), +// pin its fingerprint, store the issued token, and persist it. +export async function addRemote( + input: string, + pin: string, + opts: { defaultPort: number; dir?: string }, +): Promise<RemoteDevice> { + const dir = opts.dir ?? getSharingDir() + const identity = await loadOrCreateIdentity(dir) + const { host, port } = parseHostPort(input, opts.defaultPort) + + const h = await hello({ identity, host, port }) + if (h.status !== 200) throw new Error(`could not reach a CodeBurn device at ${host}:${port}`) + const info = h.json as { fingerprint: string; name: string } + + const pr = await pair({ identity, host, port, expectedFingerprint: info.fingerprint }, pin, identity.name) + if (pr.status !== 200) { + const err = (pr.json as { error?: string })?.error ?? `HTTP ${pr.status}` + throw new Error(`pairing failed: ${err}`) + } + const token = (pr.json as { token: string }).token + + const device: RemoteDevice = { name: info.name, host, port, fingerprint: info.fingerprint, token, addedAt: Date.now() } + const remotes = (await loadRemotes(dir)).filter((r) => r.fingerprint !== device.fingerprint) + remotes.push(device) + await saveRemotes(remotes, dir) + return device +} + +// Pair with a discovered device using approve-style pairing (no PIN). The owner +// of that device approves on their screen after confirming the matching code. +export async function linkRemote( + d: DiscoveredDevice, + opts: { dir?: string; onCode?: (code: string) => void } = {}, +): Promise<RemoteDevice> { + const dir = opts.dir ?? getSharingDir() + const identity = await loadOrCreateIdentity(dir) + const code = pairingCode(identity.fingerprint, d.fingerprint) + opts.onCode?.(code) + const r = await pairRequest({ identity, host: d.host, port: d.port, expectedFingerprint: d.fingerprint }, identity.name) + if (r.status !== 200) { + throw new Error(r.status === 403 ? 'the other device declined' : `pairing failed (HTTP ${r.status})`) + } + const token = (r.json as { token: string }).token + const device: RemoteDevice = { name: d.name, host: d.host, port: d.port, fingerprint: d.fingerprint, token, addedAt: Date.now() } + const remotes = (await loadRemotes(dir)).filter((x) => x.fingerprint !== device.fingerprint) + remotes.push(device) + await saveRemotes(remotes, dir) + return device +} + +// Pull this machine's usage plus every paired remote's, each kept separate. +export async function pullDevices( + localGetUsage: (q: UsageQuery) => Promise<DevicePayload>, + query: UsageQuery, + localName: string, + opts: { dir?: string } = {}, +): Promise<DeviceUsage[]> { + const dir = opts.dir ?? getSharingDir() + const identity = await loadOrCreateIdentity(dir) + const remotes = await loadRemotes(dir) + + const local: DeviceUsage = { id: 'local', name: localName, local: true, payload: await localGetUsage(query) } + // Pull every remote concurrently and isolate failures, so one slow or + // powered-off device degrades to an error row instead of blocking the rest. + const remoteResults = await Promise.all( + remotes.map(async (r): Promise<DeviceUsage> => { + try { + const res = await fetchUsage({ identity, host: r.host, port: r.port, expectedFingerprint: r.fingerprint }, r.token, query) + // Re-sanitize on receipt: do not trust the sender to have stripped its + // own project names/sessions (it may run an older build). Belt and + // suspenders alongside the sender-side sanitize. + if (res.status === 200) return { id: r.fingerprint, name: r.name, local: false, payload: sanitizeForSharing(res.json as MenubarPayload) } + return { id: r.fingerprint, name: r.name, local: false, error: res.status === 401 ? 'not authorized (re-pair?)' : `HTTP ${res.status}` } + } catch (e) { + return { id: r.fingerprint, name: r.name, local: false, error: e instanceof Error ? e.message : String(e) } + } + }), + ) + return [local, ...remoteResults] +} + +// Joined "Totals by machine" report: one row per device plus a bold Combined +// row. Tokens are shown as full, comma-grouped numbers. +export function renderDevices(results: DeviceUsage[]): string { + const n = (x: number): string => Math.round(x).toLocaleString() + const money = (x: number): string => formatCost(x).replace(/(\d)(?=(\d{3})+(\.|$))/g, '$1,') + const summary = summarizeDeviceUsage(results) + const rows = summary.perDevice.map((d) => ({ + name: d.name + (d.local ? ' (this Mac)' : ''), + error: d.error, + cost: d.cost, + input: d.inputTokens, + output: d.outputTokens, + cacheCreate: d.cacheCreateTokens, + cacheRead: d.cacheReadTokens, + total: d.totalTokens, + })) + const combined = summary.combined + + const tableRows = [ + ...rows.map((r) => + r.error + ? [r.name, r.error, '-', '-', '-', '-', '-'] + : [r.name, money(r.cost), n(r.total), n(r.input), n(r.output), n(r.cacheCreate), n(r.cacheRead)], + ), + ['Combined', money(combined.cost), n(combined.totalTokens), n(combined.inputTokens), n(combined.outputTokens), n(combined.cacheCreateTokens), n(combined.cacheReadTokens)], + ] + const table = renderTable( + [ + { header: 'Host' }, + { header: 'Cost', right: true }, + { header: 'Total tokens', right: true }, + { header: 'Input', right: true }, + { header: 'Output', right: true }, + { header: 'Cache create', right: true }, + { header: 'Cache read', right: true }, + ], + tableRows, + { boldRows: new Set([tableRows.length - 1]) }, + ) + const heading = new Chalk({}).cyan('Totals by machine') + return heading + '\n' + table + '\n' +} diff --git a/src/sharing/identity.ts b/src/sharing/identity.ts new file mode 100644 index 0000000..0ae7399 --- /dev/null +++ b/src/sharing/identity.ts @@ -0,0 +1,58 @@ +import * as selfsigned from 'selfsigned' +import { X509Certificate } from 'crypto' +import { readFile, writeFile, mkdir } from 'fs/promises' +import { existsSync } from 'fs' +import { join } from 'path' +import { hostname } from 'os' + +import { certFingerprint } from './pairing.js' + +// A device's stable identity: a self-signed TLS keypair whose certificate +// fingerprint is the trust anchor (trust-on-first-use). No CA. +export type Identity = { + key: string // private key PEM + cert: string // certificate PEM + fingerprint: string // SHA-256 hex of the certificate DER + name: string // human label (defaults to the hostname) +} + +export async function generateIdentity(name: string = hostname()): Promise<Identity> { + const attrs = [{ name: 'commonName', value: 'codeburn-device' }] + // @types/selfsigned is missing `days`; the runtime accepts it. selfsigned >=5 + // resolves a Promise of { private, public, cert, fingerprint }. + const genOpts = { days: 3650, keySize: 2048, algorithm: 'sha256' } as unknown as Parameters< + typeof selfsigned.generate + >[1] + const pems = (await (selfsigned.generate(attrs, genOpts) as unknown as Promise<{ private: string; cert: string }>)) + const der = new X509Certificate(pems.cert).raw + return { key: pems.private, cert: pems.cert, fingerprint: certFingerprint(der), name } +} + +// Load the device identity from `dir`, creating and persisting it on first run. +export async function loadOrCreateIdentity(dir: string, name?: string): Promise<Identity> { + const keyPath = join(dir, 'device-key.pem') + const certPath = join(dir, 'device-cert.pem') + const namePath = join(dir, 'device-name') + + if (existsSync(keyPath) && existsSync(certPath)) { + const [key, cert] = await Promise.all([readFile(keyPath, 'utf8'), readFile(certPath, 'utf8')]) + let resolvedName = name ?? hostname() + try { + const stored = (await readFile(namePath, 'utf8')).trim() + if (stored) resolvedName = name ?? stored + } catch { + /* no stored name yet */ + } + const der = new X509Certificate(cert).raw + return { key, cert, fingerprint: certFingerprint(der), name: resolvedName } + } + + const id = await generateIdentity(name) + await mkdir(dir, { recursive: true }) + await Promise.all([ + writeFile(keyPath, id.key, { mode: 0o600 }), + writeFile(certPath, id.cert), + writeFile(namePath, id.name), + ]) + return id +} diff --git a/src/sharing/pairing.ts b/src/sharing/pairing.ts new file mode 100644 index 0000000..7aab37c --- /dev/null +++ b/src/sharing/pairing.ts @@ -0,0 +1,114 @@ +import { randomBytes, createHash, timingSafeEqual } from 'crypto' + +// Device identity is the SHA-256 of its self-signed TLS certificate +// (trust-on-first-use, like SSH/Syncthing). No certificate authority involved: +// once two devices have each other's fingerprint, that pin is the trust anchor. +export function certFingerprint(cert: Buffer | string): string { + const buf = typeof cert === 'string' ? Buffer.from(cert) : cert + return createHash('sha256').update(buf).digest('hex') +} + +// Short, human-typed pairing PIN: 6 uniform digits. Rejection-sampled so the +// distribution is even (no modulo bias across 0..999999). +export function generatePin(): string { + const limit = Math.floor(0xffffffff / 1_000_000) * 1_000_000 + let n = randomBytes(4).readUInt32BE(0) + while (n >= limit) n = randomBytes(4).readUInt32BE(0) + return (n % 1_000_000).toString().padStart(6, '0') +} + +export function constantTimeEqual(a: string, b: string): boolean { + const ab = Buffer.from(a) + const bb = Buffer.from(b) + if (ab.length !== bb.length) return false + return timingSafeEqual(ab, bb) +} + +export function mintToken(): string { + return randomBytes(32).toString('base64url') +} + +// Short confirmation code shown on BOTH devices during an approve-style pairing. +// Derived from the two cert fingerprints, so a man-in-the-middle (whose cert +// differs) yields a different code; the user confirms the codes match. This is +// the Bluetooth/SAS "do these numbers match?" check, not a secret. +export function pairingCode(fingerprintA: string, fingerprintB: string): string { + const [lo, hi] = [fingerprintA, fingerprintB].sort() + const digest = createHash('sha256').update(`${lo}|${hi}`).digest() + return (digest.readUInt16BE(0) % 1000).toString().padStart(3, '0') +} + +// An open pairing window on the device being added: a one-time PIN that expires. +// `now` is injectable so the lifecycle is deterministic in tests. +export class PairingWindow { + readonly pin: string + readonly openedAt: number + private used = false + private attempts = 0 + + constructor(ttlMs = 60_000, now: number = Date.now(), pin: string = generatePin(), maxAttempts = 5) { + this.ttlMs = ttlMs + this.pin = pin + this.openedAt = now + this.maxAttempts = maxAttempts + } + + private readonly ttlMs: number + private readonly maxAttempts: number + + isOpen(now: number = Date.now()): boolean { + return !this.used && now - this.openedAt <= this.ttlMs + } + + // Verify a submitted PIN. A correct match consumes the window (one-time use). + // Wrong guesses are counted and the window closes after maxAttempts, so a + // 6-digit PIN cannot be brute-forced by a LAN peer within the TTL. + verify(pin: string, now: number = Date.now()): boolean { + if (!this.isOpen(now)) return false + if (!constantTimeEqual(pin, this.pin)) { + this.attempts += 1 + if (this.attempts >= this.maxAttempts) this.used = true + return false + } + this.used = true + return true + } +} + +export type PairedPeer = { + fingerprint: string + name: string + token: string + pairedAt: number +} + +// The devices this device trusts. A pull is authorized only when BOTH the +// bearer token AND the TLS peer fingerprint match the same paired peer, so a +// token stolen and replayed from a different device is useless on its own. +export class PeerStore { + private byFingerprint = new Map<string, PairedPeer>() + + constructor(peers: PairedPeer[] = []) { + for (const p of peers) this.byFingerprint.set(p.fingerprint, p) + } + + list(): PairedPeer[] { + return [...this.byFingerprint.values()] + } + + pair(fingerprint: string, name: string, now: number = Date.now()): PairedPeer { + const peer: PairedPeer = { fingerprint, name, token: mintToken(), pairedAt: now } + this.byFingerprint.set(fingerprint, peer) + return peer + } + + authorize(token: string, fingerprint: string): boolean { + const peer = this.byFingerprint.get(fingerprint) + if (!peer) return false + return constantTimeEqual(token, peer.token) + } + + unpair(fingerprint: string): boolean { + return this.byFingerprint.delete(fingerprint) + } +} diff --git a/src/sharing/prompt.ts b/src/sharing/prompt.ts new file mode 100644 index 0000000..4f58a30 --- /dev/null +++ b/src/sharing/prompt.ts @@ -0,0 +1,30 @@ +import { createInterface } from 'readline' + +export function promptYesNo(question: string, timeoutMs?: number): Promise<boolean> { + const rl = createInterface({ input: process.stdin, output: process.stdout }) + return new Promise((resolve) => { + let settled = false + const finish = (value: boolean): void => { + if (settled) return + settled = true + rl.close() + resolve(value) + } + if (timeoutMs) { + const t = setTimeout(() => finish(false), timeoutMs) + t.unref?.() + } + rl.question(`${question} [Y/n] `, (answer) => finish(!/^\s*n/i.test(answer))) + }) +} + +export function promptChoice(question: string, max: number): Promise<number> { + const rl = createInterface({ input: process.stdin, output: process.stdout }) + return new Promise((resolve) => { + rl.question(`${question} `, (answer) => { + rl.close() + const n = Number.parseInt(answer.trim(), 10) + resolve(Number.isInteger(n) && n >= 1 && n <= max ? n : -1) + }) + }) +} diff --git a/src/sharing/sanitize.ts b/src/sharing/sanitize.ts new file mode 100644 index 0000000..a09f511 --- /dev/null +++ b/src/sharing/sanitize.ts @@ -0,0 +1,18 @@ +import type { MenubarPayload } from '../menubar-json.js' + +// Strip identifying detail before usage leaves the device. We never share +// project names, file paths, or per-session detail (the strongest signal of +// "what you are working on"). We DO share aggregate numbers plus model, tool, +// task, subagent, skill, and MCP-server usage, since the dashboard surfaces +// those per device. If a user names a subagent/skill after a client, that name +// would travel; revisit if that becomes a concern. +export function sanitizeForSharing(payload: MenubarPayload): MenubarPayload { + return { + ...payload, + current: { + ...payload.current, + topProjects: [], + topSessions: [], + }, + } +} diff --git a/src/sharing/share-controller.ts b/src/sharing/share-controller.ts new file mode 100644 index 0000000..b6c1917 --- /dev/null +++ b/src/sharing/share-controller.ts @@ -0,0 +1,151 @@ +import { randomUUID } from 'crypto' + +import { loadOrCreateIdentity, type Identity } from './identity.js' +import { PeerStore } from './pairing.js' +import { ShareServer, type PairRequest, type UsageQuery } from './share-server.js' +import { advertise } from './discovery.js' +import { getSharingDir, loadPeers, savePeers } from './store.js' + +export type PendingPairing = { id: string; name: string; code: string } +export type ShareStatus = { + sharing: boolean + name: string + port: number + always: boolean + peers: number + pending: PendingPairing[] +} + +const IDLE_TIMEOUT_MS = 10 * 60_000 + +// Runs the secure share server inside the dashboard process so the user can +// turn sharing on/off from the browser. Incoming approve-style pairings are +// queued and surfaced to the UI instead of prompting a terminal. +export class ShareController { + private server: ShareServer | null = null + private ad: ReturnType<typeof advertise> | null = null + private peers: PeerStore | null = null + private identity: Identity | null = null + private always = false + private idleTimer: ReturnType<typeof setInterval> | null = null + private lastActivity = 0 + private readonly dir = getSharingDir() + private readonly pending = new Map< + string, + { name: string; code: string; fingerprint: string; resolve: (ok: boolean) => void; timer: ReturnType<typeof setTimeout> } + >() + + constructor( + private readonly getUsage: (q: UsageQuery) => Promise<unknown>, + private readonly port = 7777, + ) {} + + private async getIdentity(): Promise<Identity> { + if (!this.identity) this.identity = await loadOrCreateIdentity(this.dir) + return this.identity + } + + isSharing(): boolean { + return !!this.server + } + + async start(always: boolean): Promise<void> { + if (this.server) { + this.always = always + this.refreshIdleWatch() + return + } + const identity = await this.getIdentity() + this.peers = new PeerStore(await loadPeers(this.dir)) + const server = new ShareServer({ + identity, + peers: this.peers, + getUsage: this.getUsage, + onPaired: () => { + if (this.peers) void savePeers(this.peers.list(), this.dir) + }, + approve: (req) => this.enqueueApproval(req), + }) + // listen() can reject (e.g. EADDRINUSE); only commit state after it binds, + // so a failed start never leaves us reporting always/sharing incorrectly. + await server.listen(this.port, '0.0.0.0') + this.always = always + this.server = server + this.ad = advertise({ name: identity.name, port: this.port, fingerprint: identity.fingerprint }) + this.lastActivity = Date.now() + server.server.on('request', () => { + this.lastActivity = Date.now() + }) + this.refreshIdleWatch() + } + + private refreshIdleWatch(): void { + if (this.idleTimer) { + clearInterval(this.idleTimer) + this.idleTimer = null + } + if (this.always) return + this.idleTimer = setInterval(() => { + if (Date.now() - this.lastActivity > IDLE_TIMEOUT_MS) void this.stop() + }, 30_000) + this.idleTimer.unref?.() + } + + async stop(): Promise<void> { + if (this.idleTimer) { + clearInterval(this.idleTimer) + this.idleTimer = null + } + for (const p of this.pending.values()) { + clearTimeout(p.timer) + p.resolve(false) + } + this.pending.clear() + await this.ad?.stop().catch(() => {}) + await this.server?.close().catch(() => {}) + this.ad = null + this.server = null + } + + private enqueueApproval(req: PairRequest): Promise<boolean> { + // One outstanding request per device, and a hard cap, so a LAN peer cannot + // flood the approval prompt or bury a legitimate request. + for (const p of this.pending.values()) if (p.fingerprint === req.fingerprint) return Promise.resolve(false) + if (this.pending.size >= 8) return Promise.resolve(false) + return new Promise((resolve) => { + const id = randomUUID() + const timer = setTimeout(() => { + this.pending.delete(id) + resolve(false) + }, 60_000) + timer.unref?.() + this.pending.set(id, { name: req.name, code: req.code, fingerprint: req.fingerprint, resolve, timer }) + }) + } + + listPending(): PendingPairing[] { + return [...this.pending.entries()].map(([id, p]) => ({ id, name: p.name, code: p.code })) + } + + resolvePending(id: string, approve: boolean): boolean { + const p = this.pending.get(id) + if (!p) return false + clearTimeout(p.timer) + this.pending.delete(id) + p.resolve(approve) + return true + } + + async status(): Promise<ShareStatus> { + const identity = await this.getIdentity() + const peers = this.peers ? this.peers.list().length : (await loadPeers(this.dir)).length + return { + sharing: this.isSharing(), + name: identity.name, + port: this.port, + always: this.always, + peers, + pending: this.listPending(), + } + } +} diff --git a/src/sharing/share-run.ts b/src/sharing/share-run.ts new file mode 100644 index 0000000..7073412 --- /dev/null +++ b/src/sharing/share-run.ts @@ -0,0 +1,92 @@ +import { networkInterfaces } from 'os' + +import { loadOrCreateIdentity } from './identity.js' +import { PeerStore } from './pairing.js' +import { ShareServer, type UsageQuery } from './share-server.js' +import { advertise } from './discovery.js' +import { promptYesNo } from './prompt.js' +import { sanitizeForSharing } from './sanitize.js' +import { getSharingDir, loadPeers, savePeers } from './store.js' +import { loadPricing } from '../models.js' +import { buildMenubarPayloadForRange } from '../usage-aggregator.js' +import { periodInfoFromQuery } from '../cli-date.js' + +function lanAddress(): string | null { + for (const list of Object.values(networkInterfaces())) { + for (const ni of list ?? []) { + if (ni.family === 'IPv4' && !ni.internal) return ni.address + } + } + return null +} + +const IDLE_TIMEOUT_MS = 10 * 60_000 + +// Run the secure share server. On-demand by default: it stops after 10 minutes +// of no requests. `--always` keeps it up until Ctrl+C (the opt-in persistent +// mode). `--pair` opens a one-time pairing window and prints the PIN + command. +export async function runShareServer(opts: { port: number; pair: boolean; always: boolean }): Promise<void> { + await loadPricing() + const dir = getSharingDir() + const identity = await loadOrCreateIdentity(dir) + const peers = new PeerStore(await loadPeers(dir)) + + const getUsage = async (q: UsageQuery): Promise<unknown> => { + const periodInfo = periodInfoFromQuery(q, 'month') + return sanitizeForSharing(await buildMenubarPayloadForRange(periodInfo, { provider: 'all', optimize: false })) + } + + const server = new ShareServer({ + identity, + peers, + getUsage, + onPaired: () => { + void savePeers(peers.list(), dir) + }, + approve: async (req) => { + process.stdout.write(`\n "${req.name}" wants your usage.\n`) + process.stdout.write(` Confirm this code matches on that device: ${req.code}\n`) + const ok = await promptYesNo(' Approve?', 60_000) + process.stdout.write(ok ? ` Approved "${req.name}".\n\n` : ` Declined "${req.name}".\n\n`) + return ok + }, + }) + + const port = await server.listen(opts.port, '0.0.0.0') + const ip = lanAddress() ?? '127.0.0.1' + const ad = advertise({ name: identity.name, port, fingerprint: identity.fingerprint }) + + const shutdown = async (): Promise<void> => { + await ad.stop().catch(() => {}) + await server.close().catch(() => {}) + process.exit(0) + } + process.on('SIGINT', () => void shutdown()) + + process.stdout.write(`\n Sharing "${identity.name}" - discoverable on your network.\n`) + process.stdout.write(` On your other Mac, run: codeburn devices add\n`) + if (opts.pair) { + const pin = server.openPairing(120_000) + process.stdout.write(`\n Manual fallback (if discovery is blocked):\n`) + process.stdout.write(` codeburn devices add ${ip}:${port} --pin ${pin}\n`) + } + process.stdout.write(`\n ${peers.list().length} paired device(s). Press Ctrl+C to stop.\n\n`) + + if (!opts.always) { + let last = Date.now() + server.server.on('request', () => { + last = Date.now() + }) + const timer = setInterval(() => { + if (Date.now() - last > IDLE_TIMEOUT_MS) { + process.stdout.write('\n Idle, stopping share. Run `codeburn share` again when you need it.\n') + process.exit(0) + } + }, 30_000) + timer.unref() + } + + await new Promise<never>(() => { + /* run until interrupted */ + }) +} diff --git a/src/sharing/share-server.ts b/src/sharing/share-server.ts new file mode 100644 index 0000000..f56cce3 --- /dev/null +++ b/src/sharing/share-server.ts @@ -0,0 +1,193 @@ +import { createServer, type Server } from 'https' +import type { IncomingMessage, ServerResponse } from 'http' +import type { TLSSocket } from 'tls' +import type { AddressInfo } from 'net' + +import { UsageQueryError } from '../cli-date.js' +import { certFingerprint, pairingCode, PeerStore, PairingWindow } from './pairing.js' +import type { Identity } from './identity.js' + +export type UsageQuery = { period?: string; from?: string; to?: string } + +// An approve-style pairing request, surfaced to the user on the sharing device. +export type PairRequest = { name: string; fingerprint: string; code: string } + +export type ShareServerOptions = { + identity: Identity + peers: PeerStore + getUsage: (query: UsageQuery) => Promise<unknown> + // Called after a successful pairing so the caller can persist the peer list. + onPaired?: () => void + // Enables the interactive approve flow (POST /api/peer/pair-request): return + // true to accept. The user confirms the matching `code` shown on both devices. + approve?: (req: PairRequest) => Promise<boolean> +} + +// A device's HTTPS sharing endpoint. Mutual TLS: the server presents its own +// self-signed cert (clients pin its fingerprint) and requests the client's cert +// so it can bind tokens to the caller's fingerprint. A pull is served only when +// the bearer token AND the client cert fingerprint match the same paired peer. +export class ShareServer { + readonly server: Server + private pairing: PairingWindow | null = null + + constructor(private readonly opts: ShareServerOptions) { + this.server = createServer( + { key: opts.identity.key, cert: opts.identity.cert, requestCert: true, rejectUnauthorized: false }, + (req, res) => { + void this.handle(req, res) + }, + ) + // Swallow server-level socket/TLS errors (e.g. a malformed handshake from a + // LAN peer) so they can never crash the host process. `listen()` attaches + // its own one-time handler for bind failures. + this.server.on('error', () => {}) + this.server.on('tlsClientError', () => {}) + } + + // Open a one-time pairing window and return the PIN to show the user. + openPairing(ttlMs = 60_000): string { + this.pairing = new PairingWindow(ttlMs) + return this.pairing.pin + } + + closePairing(): void { + this.pairing = null + } + + listen(port: number, host = '0.0.0.0'): Promise<number> { + return new Promise((resolve, reject) => { + this.server.once('error', reject) + this.server.listen(port, host, () => resolve((this.server.address() as AddressInfo).port)) + }) + } + + close(): Promise<void> { + return new Promise((resolve) => this.server.close(() => resolve())) + } + + private clientFingerprint(req: IncomingMessage): string | null { + const cert = (req.socket as TLSSocket).getPeerCertificate?.() + if (!cert || !cert.raw) return null + return certFingerprint(cert.raw) + } + + private async handle(req: IncomingMessage, res: ServerResponse): Promise<void> { + const url = new URL(req.url ?? '/', 'https://localhost') + const json = (code: number, body: unknown): void => { + res.writeHead(code, { 'content-type': 'application/json' }) + res.end(JSON.stringify(body)) + } + try { + await this.route(url, req, res, json) + } catch (err) { + // Never leave a request hanging (a hung peer makes the caller time out + // and drop this device); always answer, even on an internal error. + if (!res.headersSent) { + const message = err instanceof Error ? err.message : String(err) + json(err instanceof UsageQueryError ? 400 : 500, { error: message }) + } + } + } + + private async route( + url: URL, + req: IncomingMessage, + res: ServerResponse, + json: (code: number, body: unknown) => void, + ): Promise<void> { + + // Unauthenticated: just enough for a joiner to learn who this is and whether + // pairing is currently open. No usage data here. + if (url.pathname === '/api/peer/hello' && req.method === 'GET') { + json(200, { + fingerprint: this.opts.identity.fingerprint, + name: this.opts.identity.name, + pairingOpen: !!this.pairing?.isOpen(), + }) + return + } + + if (url.pathname === '/api/peer/pair' && req.method === 'POST') { + const clientFp = this.clientFingerprint(req) + if (!clientFp) { + json(400, { error: 'client certificate required' }) + return + } + const body = safeJson(await readBody(req)) as { pin?: unknown; name?: unknown } | null + const pin = typeof body?.pin === 'string' ? body.pin : '' + const name = typeof body?.name === 'string' ? body.name : 'device' + if (!this.pairing || !this.pairing.verify(pin)) { + json(401, { error: 'invalid or expired PIN' }) + return + } + this.pairing = null + const peer = this.opts.peers.pair(clientFp, name) + this.opts.onPaired?.() + json(200, { token: peer.token, name: this.opts.identity.name, fingerprint: this.opts.identity.fingerprint }) + return + } + + if (url.pathname === '/api/peer/pair-request' && req.method === 'POST') { + const clientFp = this.clientFingerprint(req) + if (!clientFp) { + json(400, { error: 'client certificate required' }) + return + } + if (!this.opts.approve) { + json(403, { error: 'this device is not accepting new pairings' }) + return + } + const body = safeJson(await readBody(req)) as { name?: unknown } | null + const name = typeof body?.name === 'string' ? body.name : 'device' + const code = pairingCode(this.opts.identity.fingerprint, clientFp) + const approved = await this.opts.approve({ name, fingerprint: clientFp, code }) + if (!approved) { + json(403, { error: 'pairing declined' }) + return + } + const peer = this.opts.peers.pair(clientFp, name) + this.opts.onPaired?.() + json(200, { token: peer.token, name: this.opts.identity.name, fingerprint: this.opts.identity.fingerprint, code }) + return + } + + if (url.pathname === '/api/usage' && req.method === 'GET') { + const clientFp = this.clientFingerprint(req) + const token = (req.headers['authorization'] ?? '').replace(/^Bearer\s+/i, '') + if (!clientFp || !token || !this.opts.peers.authorize(token, clientFp)) { + json(401, { error: 'unauthorized' }) + return + } + const payload = await this.opts.getUsage({ + period: url.searchParams.get('period') ?? undefined, + from: url.searchParams.get('from') ?? undefined, + to: url.searchParams.get('to') ?? undefined, + }) + json(200, payload) + return + } + + json(404, { error: 'not found' }) + } +} + +function readBody(req: IncomingMessage): Promise<string> { + return new Promise((resolve) => { + let data = '' + req.on('data', (chunk) => { + data += chunk + if (data.length > 1_000_000) req.destroy() // guard against oversized bodies + }) + req.on('end', () => resolve(data)) + req.on('error', () => resolve(data)) + }) +} + +function safeJson(s: string): unknown { + try { + return JSON.parse(s) + } catch { + return null + } +} diff --git a/src/sharing/store.ts b/src/sharing/store.ts new file mode 100644 index 0000000..2f52178 --- /dev/null +++ b/src/sharing/store.ts @@ -0,0 +1,64 @@ +import { readFile, writeFile, mkdir, chmod } from 'fs/promises' +import { join, dirname } from 'path' + +import { getConfigFilePath } from '../config.js' +import type { PairedPeer } from './pairing.js' + +// A device this host can pull FROM: its address, the pinned server-cert +// fingerprint, and the token issued to us during pairing. +export type RemoteDevice = { + name: string + host: string + port: number + fingerprint: string + token: string + addedAt: number +} + +// Sharing state lives next to the main config file. +export function getSharingDir(): string { + return join(dirname(getConfigFilePath()), 'sharing') +} + +async function readJson<T>(path: string, fallback: T): Promise<T> { + try { + return JSON.parse(await readFile(path, 'utf8')) as T + } catch { + return fallback + } +} + +// These files hold bearer tokens, so keep them owner-only (0600) like the TLS +// private key. mkdir/writeFile modes only apply on creation, so chmod enforces +// it on files that already exist from an earlier version. +async function writeJson(path: string, data: unknown): Promise<void> { + await mkdir(dirname(path), { recursive: true, mode: 0o700 }) + await writeFile(path, JSON.stringify(data, null, 2), { mode: 0o600 }) + await chmod(path, 0o600).catch(() => {}) +} + +// Peers allowed to pull from this device (the sharing side, used by ShareServer). +export function loadPeers(dir: string = getSharingDir()): Promise<PairedPeer[]> { + return readJson(join(dir, 'paired-peers.json'), [] as PairedPeer[]) +} +export function savePeers(peers: PairedPeer[], dir: string = getSharingDir()): Promise<void> { + return writeJson(join(dir, 'paired-peers.json'), peers) +} + +// Devices this host pulls from (the host side, used by `codeburn devices`). +export function loadRemotes(dir: string = getSharingDir()): Promise<RemoteDevice[]> { + return readJson(join(dir, 'remote-devices.json'), [] as RemoteDevice[]) +} +export function saveRemotes(remotes: RemoteDevice[], dir: string = getSharingDir()): Promise<void> { + return writeJson(join(dir, 'remote-devices.json'), remotes) +} + +// Whether the dashboard should keep sharing on (opt-in always-live). Persisted +// so `codeburn web` resumes the chosen state on launch. +export async function loadShareAlways(dir: string = getSharingDir()): Promise<boolean> { + const s = await readJson(join(dir, 'web-share.json'), { always: false } as { always?: boolean }) + return !!s.always +} +export function saveShareAlways(always: boolean, dir: string = getSharingDir()): Promise<void> { + return writeJson(join(dir, 'web-share.json'), { always }) +} diff --git a/src/sqlite.ts b/src/sqlite.ts new file mode 100644 index 0000000..3fb3c6a --- /dev/null +++ b/src/sqlite.ts @@ -0,0 +1,139 @@ +import { createRequire } from 'node:module' + +/// Thin SQLite read-only wrapper over Node's built-in `node:sqlite` module (stable in +/// Node 24, experimental in Node 22 / 23). Replaces the earlier `better-sqlite3` binding +/// so the dependency graph no longer pulls in the deprecated `prebuild-install` package +/// (issue #75). Works across Cursor and OpenCode session DBs, both of which we only read. + +const requireForSqlite = createRequire(import.meta.url) + +type Row = Record<string, unknown> + +export type SqliteDatabase = { + query<T extends Row = Row>(sql: string, params?: unknown[]): T[] + close(): void +} + +type DatabaseSyncCtor = new (path: string, options?: { readOnly?: boolean }) => { + prepare(sql: string): { all(...params: unknown[]): Row[] } + exec?(sql: string): void + close(): void +} + +let DatabaseSync: DatabaseSyncCtor | null = null +let loadAttempted = false +let loadError: string | null = null + +const textDecoder = new TextDecoder('utf-8', { fatal: false }) + +/// Safely decode a BLOB column (Uint8Array) to a UTF-8 string. Node's +/// node:sqlite crashes with a V8 CHECK abort when a TEXT column contains +/// invalid UTF-8 (common in Cursor chat blobs with truncated multi-byte +/// chars). By selecting those columns as `CAST(... AS BLOB)` in SQL, we +/// get a Uint8Array here and decode it in JS where bad bytes become the +/// U+FFFD replacement character instead of aborting the process. +export function blobToText(value: Uint8Array | string | null | undefined): string { + if (value == null) return '' + if (typeof value === 'string') return value + return textDecoder.decode(value) +} + +/// Lazily imports `node:sqlite`. On Node 22/23 it emits an ExperimentalWarning the first +/// time the module is loaded; we silence that specific warning once so dashboards aren't +/// preceded by a scary stderr line every run. Any other warnings (including future +/// non-SQLite ones) are left untouched. +function loadDriver(): boolean { + if (loadAttempted) return DatabaseSync !== null + loadAttempted = true + + const origEmit = process.emit.bind(process) + let restored = false + const restore = () => { + if (restored) return + restored = true + process.emit = origEmit + } + + // Node's `process.emit` signature is overloaded; we intercept the 'warning' channel + // only and proxy everything else through unchanged. The `any` cast avoids chasing the + // overload union which isn't worth its verbosity for a single-purpose shim. + // eslint-disable-next-line @typescript-eslint/no-explicit-any + process.emit = function patchedEmit(this: NodeJS.Process, event: string, ...args: any[]): boolean { + if (event === 'warning') { + const warning = args[0] as { name?: string; message?: string } | undefined + if ( + warning?.name === 'ExperimentalWarning' && + typeof warning.message === 'string' && + /SQLite/i.test(warning.message) + ) { + return false + } + } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + return (origEmit as any).call(this, event, ...args) + } as typeof process.emit + + try { + const mod = requireForSqlite('node:sqlite') as { DatabaseSync: DatabaseSyncCtor } + DatabaseSync = mod.DatabaseSync + return true + } catch (err) { + const message = err instanceof Error ? err.message : String(err) + loadError = + 'SQLite-based providers (Cursor, OpenCode) need Node 22+ with the node:sqlite module.\n' + + `Current Node: ${process.version}.\n` + + 'Upgrade Node (https://nodejs.org) and run codeburn again.\n' + + `(underlying error: ${message})` + return false + } finally { + process.nextTick(restore) + } +} + +export function isSqliteAvailable(): boolean { + return loadDriver() +} + +export function getSqliteLoadError(): string { + return loadError ?? 'SQLite driver not available' +} + +export function isSqliteBusyError(err: unknown): boolean { + const e = err as { code?: unknown; errcode?: unknown; errstr?: unknown; message?: unknown } | null + const code = typeof e?.code === 'string' ? e.code : '' + const errcode = typeof e?.errcode === 'number' ? e.errcode : null + const message = [ + typeof e?.message === 'string' ? e.message : '', + typeof e?.errstr === 'string' ? e.errstr : '', + ].join(' ') + + return ( + errcode === 5 || + errcode === 6 || + code === 'SQLITE_BUSY' || + code === 'SQLITE_LOCKED' || + /\bSQLITE_(BUSY|LOCKED)\b|database (?:is |table is )?locked/i.test(message) + ) +} + +export function openDatabase(path: string): SqliteDatabase { + if (!loadDriver() || DatabaseSync === null) { + throw new Error(getSqliteLoadError()) + } + + const db = new DatabaseSync(path, { readOnly: true }) + try { + db.exec?.('PRAGMA busy_timeout = 1000') + } catch { + // Best effort. Some Node sqlite builds may not expose exec on DatabaseSync. + } + + return { + query<T extends Row = Row>(sql: string, params: unknown[] = []): T[] { + return db.prepare(sql).all(...params) as T[] + }, + close() { + db.close() + }, + } +} diff --git a/src/text-table.ts b/src/text-table.ts new file mode 100644 index 0000000..2a82d7c --- /dev/null +++ b/src/text-table.ts @@ -0,0 +1,41 @@ +import { Chalk } from 'chalk' + +export type TableColumn = { header: string; right?: boolean } + +// Visible width, ignoring ANSI color codes, so padding stays aligned. +function vlen(s: string): number { + // eslint-disable-next-line no-control-regex + return s.replace(/\[[0-9;]*m/g, '').length +} + +// Box-drawing table with roomy 2-space cell padding, right-aligned numeric +// columns, and optional bold rows (e.g. a Combined/total row). Color is +// auto-detected; pass color:false to force plain text. +export function renderTable( + columns: TableColumn[], + rows: string[][], + opts: { color?: boolean; boldRows?: ReadonlySet<number> } = {}, +): string { + const c = new Chalk(opts.color === false ? { level: 0 } : {}) + const bold = opts.boldRows ?? new Set<number>() + const widths = columns.map((col, i) => Math.max(vlen(col.header), ...rows.map((r) => vlen(r[i] ?? '')))) + const pad = (s: string, w: number, right?: boolean): string => { + const fill = ' '.repeat(Math.max(0, w - vlen(s))) + return right ? fill + s : s + fill + } + const gap = ' ' + const sep = gap + '│' + gap + const bar = (l: string, mid: string, r: string): string => l + widths.map((w) => '─'.repeat(w + 4)).join(mid) + r + const line = (cells: string[], makeBold: boolean): string => + '│' + gap + columns.map((col, i) => { + const padded = pad(cells[i] ?? '', widths[i]!, col.right) + return makeBold ? c.bold(padded) : padded + }).join(sep) + gap + '│' + return [ + bar('┌', '┬', '┐'), + line(columns.map((col) => col.header), false), + bar('├', '┼', '┤'), + ...rows.map((r, i) => line(r, bold.has(i))), + bar('└', '┴', '┘'), + ].join('\n') +} diff --git a/src/types.ts b/src/types.ts new file mode 100644 index 0000000..c3cc822 --- /dev/null +++ b/src/types.ts @@ -0,0 +1,201 @@ +export type TokenUsage = { + inputTokens: number + outputTokens: number + cacheCreationInputTokens: number + cacheReadInputTokens: number + cachedInputTokens: number + reasoningTokens: number + webSearchRequests: number +} + +export type ToolUseBlock = { + type: 'tool_use' + id: string + name: string + input: Record<string, unknown> +} + +export type ContentBlock = + | { type: 'text'; text: string } + | { type: 'thinking'; thinking: string } + | ToolUseBlock + | { type: string; [key: string]: unknown } + +export type ApiUsage = { + input_tokens: number + output_tokens: number + cache_creation_input_tokens?: number + cache_creation?: { + ephemeral_5m_input_tokens?: number + ephemeral_1h_input_tokens?: number + } + cache_read_input_tokens?: number + server_tool_use?: { + web_search_requests?: number + web_fetch_requests?: number + } + speed?: 'standard' | 'fast' +} + +export type AssistantMessageContent = { + model: string + id?: string + type: 'message' + role: 'assistant' + content: ContentBlock[] + usage: ApiUsage + stop_reason?: string +} + +export type JournalEntry = { + type: string + uuid?: string + parentUuid?: string | null + timestamp?: string + sessionId?: string + cwd?: string + version?: string + gitBranch?: string + promptId?: string + message?: AssistantMessageContent | { role: 'user'; content: string | ContentBlock[] } + isSidechain?: boolean + [key: string]: unknown +} + +export type ParsedTurn = { + userMessage: string + assistantCalls: ParsedApiCall[] + timestamp: string + sessionId: string +} + +export type ParsedApiCall = { + provider: string + model: string + usage: TokenUsage + costUSD: number + tools: string[] + mcpTools: string[] + skills: string[] + subagentTypes: string[] + hasAgentSpawn: boolean + hasPlanMode: boolean + speed: 'standard' | 'fast' + timestamp: string + bashCommands: string[] + deduplicationKey: string + cacheCreationOneHourTokens?: number + toolSequence?: ToolCall[][] + /// When set, `costUSD` is the actual local call (forced to 0) and + /// `savingsUSD` is the counterfactual cost the same tokens would have + /// incurred against `savingsBaselineModel`. Set by the savings + /// normalization step in `src/parser.ts`. + savingsUSD?: number + savingsBaselineModel?: string + isLocalSavings?: boolean +} + +export type ToolCall = { + tool: string + file?: string + command?: string +} + +export type TaskCategory = + | 'coding' + | 'debugging' + | 'feature' + | 'refactoring' + | 'testing' + | 'exploration' + | 'planning' + | 'delegation' + | 'git' + | 'build/deploy' + | 'conversation' + | 'brainstorming' + | 'general' + +export type ClassifiedTurn = ParsedTurn & { + category: TaskCategory + subCategory?: string + retries: number + hasEdits: boolean +} + +export type SessionSourceMetadata = { + id: string + label: string + path: string + kind: 'claude-config' | 'claude-desktop' +} + +export type SessionSummary = { + sessionId: string + project: string + source?: SessionSourceMetadata + // Claude Code only: agent type of a subagent transcript session + // (`workflow-subagent`, `Explore`, `general-purpose`, …); undefined for + // ordinary sessions. Drives the Claude-scoped agent-type breakdown. + agentType?: string + firstTimestamp: string + lastTimestamp: string + totalCostUSD: number + totalSavingsUSD: number + totalInputTokens: number + totalOutputTokens: number + totalReasoningTokens: number + totalCacheReadTokens: number + totalCacheWriteTokens: number + apiCalls: number + turns: ClassifiedTurn[] + modelBreakdown: Record<string, { calls: number; costUSD: number; tokens: TokenUsage; savingsUSD: number }> + toolBreakdown: Record<string, { calls: number }> + mcpBreakdown: Record<string, { calls: number }> + bashBreakdown: Record<string, { calls: number }> + categoryBreakdown: Record<TaskCategory, { turns: number; costUSD: number; savingsUSD: number; retries: number; editTurns: number; oneShotTurns: number }> + skillBreakdown: Record<string, { turns: number; costUSD: number; savingsUSD: number; editTurns: number; oneShotTurns: number }> + subagentBreakdown: Record<string, { calls: number; costUSD: number; savingsUSD: number }> + // Observed MCP tools available in this session, captured from + // `attachment.deferred_tools_delta.addedNames` entries. Union across all + // turns. Each name is a fully-qualified `mcp__<server>__<tool>` identifier. + // Built-in tools (Bash, Edit, etc.) are filtered out. Provider-agnostic field; + // currently populated only by the Claude parser. + mcpInventory?: string[] +} + +export type ProjectSummary = { + project: string + projectPath: string + sessions: SessionSummary[] + totalCostUSD: number + totalSavingsUSD: number + totalApiCalls: number + // Portion of `totalCostUSD` served through a subscription-backed proxy + // (config `proxyPaths`). `totalCostUSD` is left at the full API rate (the + // billable / would-be figure); this is the subscription-covered amount, so + // net out-of-pocket for the project is `totalCostUSD - totalProxiedCostUSD`. + // 0 when the project is not under a configured proxy path. + totalProxiedCostUSD: number +} + +export type DateRange = { + start: Date + end: Date +} + +export const CATEGORY_LABELS: Record<TaskCategory, string> = { + coding: 'Coding', + debugging: 'Debugging', + feature: 'Feature Dev', + refactoring: 'Refactoring', + testing: 'Testing', + exploration: 'Exploration', + planning: 'Planning', + delegation: 'Delegation', + git: 'Git Ops', + 'build/deploy': 'Build/Deploy', + conversation: 'Conversation', + brainstorming: 'Brainstorming', + general: 'General', +} diff --git a/src/usage-aggregator.ts b/src/usage-aggregator.ts new file mode 100644 index 0000000..b70b401 --- /dev/null +++ b/src/usage-aggregator.ts @@ -0,0 +1,522 @@ +import { homedir } from 'node:os' +import { CATEGORY_LABELS, type ProjectSummary, type TaskCategory, type DateRange } from './types.js' +import { type PeriodData, type ProviderCost, type BreakdownArrays, type MenubarPayload, type ClaudeConfigSelector, buildMenubarPayload } from './menubar-json.js' +import { parseAllSessions, filterProjectsByName, filterProjectsByDays, filterProjectsByClaudeConfigSource } from './parser.js' +import { findUnpricedModels, getLocalModelSavingsConfigHash, getPriceOverridesConfigHash, getShortModelName } from './models.js' +import { getAllProviders, safeDiscoverSessions } from './providers/index.js' +import { claude, getClaudeConfigDirs, getDesktopSessionsDir } from './providers/claude.js' +import { stat } from 'node:fs/promises' +import { aggregateProjectsIntoDays, buildPeriodDataFromDays } from './day-aggregator.js' +import { aggregateModelEfficiency } from './model-efficiency.js' +import { aggregateModels } from './models-report.js' +import { scanAndDetect } from './optimize.js' +import { getDaysInRange, ensureCacheHydrated, loadDailyCache, emptyCache, BACKFILL_DAYS, toDateString, type DailyCache } from './daily-cache.js' + +export function buildPeriodData(label: string, projects: ProjectSummary[]): PeriodData { + const sessions = projects.flatMap(p => p.sessions) + const catTotals: Record<string, { turns: number; cost: number; savingsUSD: number; editTurns: number; oneShotTurns: number }> = {} + const modelTotals: Record<string, { calls: number; cost: number; savingsUSD: number; tokens: number }> = {} + let inputTokens = 0, outputTokens = 0, cacheReadTokens = 0, cacheWriteTokens = 0 + + for (const sess of sessions) { + inputTokens += sess.totalInputTokens + outputTokens += sess.totalOutputTokens + cacheReadTokens += sess.totalCacheReadTokens + cacheWriteTokens += sess.totalCacheWriteTokens + for (const [cat, d] of Object.entries(sess.categoryBreakdown)) { + if (!catTotals[cat]) catTotals[cat] = { turns: 0, cost: 0, savingsUSD: 0, editTurns: 0, oneShotTurns: 0 } + catTotals[cat].turns += d.turns + catTotals[cat].cost += d.costUSD + catTotals[cat].savingsUSD += d.savingsUSD + catTotals[cat].editTurns += d.editTurns + catTotals[cat].oneShotTurns += d.oneShotTurns + } + for (const [model, d] of Object.entries(sess.modelBreakdown)) { + if (!modelTotals[model]) modelTotals[model] = { calls: 0, cost: 0, savingsUSD: 0, tokens: 0 } + modelTotals[model].calls += d.calls + modelTotals[model].cost += d.costUSD + modelTotals[model].savingsUSD += d.savingsUSD + modelTotals[model].tokens += d.tokens.inputTokens + d.tokens.outputTokens + d.tokens.cacheReadInputTokens + d.tokens.cacheCreationInputTokens + } + } + + return { + label, + cost: projects.reduce((s, p) => s + p.totalCostUSD, 0), + savingsUSD: projects.reduce((s, p) => s + p.totalSavingsUSD, 0), + calls: projects.reduce((s, p) => s + p.totalApiCalls, 0), + sessions: projects.reduce((s, p) => s + p.sessions.length, 0), + inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, + categories: Object.entries(catTotals) + .sort(([, a], [, b]) => b.cost - a.cost) + .map(([cat, d]) => ({ name: CATEGORY_LABELS[cat as TaskCategory] ?? cat, ...d })), + models: Object.entries(modelTotals) + .sort(([, a], [, b]) => b.cost - a.cost) + .map(([name, d]) => ({ name, calls: d.calls, cost: d.cost, savingsUSD: d.savingsUSD })), + unpricedModels: findUnpricedModels(Object.entries(modelTotals) + .map(([model, d]) => ({ model, calls: d.calls, cost: d.cost, tokens: d.tokens }))), + } +} + +export function getDailyCacheConfigHash(): string { + const savingsHash = getLocalModelSavingsConfigHash() + const overridesHash = getPriceOverridesConfigHash() + if (!overridesHash) return savingsHash + return `localModelSavings=${savingsHash}\u0002priceOverrides=${overridesHash}` +} + +async function hydrateCache(): Promise<DailyCache> { + try { + return await ensureCacheHydrated( + (range) => parseAllSessions(range, 'all'), + aggregateProjectsIntoDays, + getDailyCacheConfigHash(), + ) + } catch (err) { + // Previously swallowed silently, which turned any backfill failure into an + // empty trend/history with no signal (issue #441). Per-file parse errors no + // longer reach here (they're isolated in parseProviderSources), so anything + // that does is exceptional and worth surfacing. + process.stderr.write( + `codeburn: daily history backfill failed; the trend chart may be incomplete. ` + + `${err instanceof Error ? err.message : String(err)}\n` + ) + return emptyCache() + } +} + +export type PeriodInfo = { range: DateRange; label: string } +export type AggregateOpts = { + provider?: string + project?: string[] + exclude?: string[] + daysSelection?: { range: DateRange; label: string; days: Set<string> } | null + optimize?: boolean + claudeConfigSourceId?: string | null +} + +type ConfigOption = { id: string; label: string; path: string } + +function buildSelector(byId: Map<string, ConfigOption>, selectedId?: string | null): ClaudeConfigSelector | undefined { + const options = [...byId.values()].sort((a, b) => a.label.localeCompare(b.label)) + if (options.length <= 1) return undefined + const validSelectedId = selectedId && options.some(option => option.id === selectedId) ? selectedId : null + return { selectedId: validSelectedId, options } +} + +// Complete option list including configs with NO data in the period (so the +// user can still switch to one to confirm it is $0). Only worth the extra +// Claude discovery walk when the user actually has multiple config dirs; a +// single-config user can never have a >1 selector, so skip it and let the +// project-derived path (which also surfaces a Claude Desktop bucket with data) +// stand. +async function claudeConfigSelector(projects: ProjectSummary[], selectedId?: string | null): Promise<ClaudeConfigSelector | undefined> { + const byId = new Map<string, ConfigOption>() + for (const session of projects.flatMap(project => project.sessions)) { + const source = session.source + if (source?.kind !== 'claude-config' && source?.kind !== 'claude-desktop') continue + if (!byId.has(source.id)) byId.set(source.id, { id: source.id, label: source.label, path: source.path }) + } + // The discovery walk lists sources that have no data in the period (so an + // idle config or Claude Desktop is still selectable). Only worth it when a + // second source is possible: more than one config dir, or a Claude Desktop + // sessions dir exists. A plain single-config user skips it entirely. + const desktopExists = await stat(getDesktopSessionsDir()).then(s => s.isDirectory()).catch(() => false) + if ((await getClaudeConfigDirs()).length > 1 || desktopExists) { + for (const source of await claude.discoverSessions()) { + if ((source.sourceKind !== 'claude-config' && source.sourceKind !== 'claude-desktop') || !source.sourceId || !source.sourceLabel || !source.sourcePath) continue + if (!byId.has(source.sourceId)) byId.set(source.sourceId, { id: source.sourceId, label: source.sourceLabel, path: source.sourcePath }) + } + } + return buildSelector(byId, selectedId) +} + +function dailyEntriesToHistory(days: ReturnType<typeof aggregateProjectsIntoDays>): MenubarPayload['history']['daily'] { + return days.map(d => { + const topModels = Object.entries(d.models) + .filter(([name]) => name !== '<synthetic>') + .sort(([, a], [, b]) => b.cost - a.cost) + .slice(0, 5) + .map(([name, m]) => ({ + name, + cost: m.cost, + savingsUSD: m.savingsUSD, + calls: m.calls, + inputTokens: m.inputTokens, + outputTokens: m.outputTokens, + })) + return { + date: d.date, + cost: d.cost, + savingsUSD: d.savingsUSD, + calls: d.calls, + inputTokens: d.inputTokens, + outputTokens: d.outputTokens, + cacheReadTokens: d.cacheReadTokens, + cacheWriteTokens: d.cacheWriteTokens, + topModels, + } + }) +} + +/** + * Resolved-range aggregation shared by `status --format menubar-json` and the MCP server. + * Pricing must already be loaded (callers run loadPricing first). When opts.optimize is + * false, the expensive scanAndDetect pass is skipped (retryTax/routingWaste still computed). + */ +export async function buildMenubarPayloadForRange(periodInfo: PeriodInfo, opts: AggregateOpts = {}): Promise<MenubarPayload> { + const pf = opts.provider ?? 'all' + const daysSelection = opts.daysSelection ?? null + const fp = (p: ProjectSummary[]) => filterProjectsByName(p, opts.project ?? [], opts.exclude ?? []) + + const now = new Date() + const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate()) + const todayRange: DateRange = { start: todayStart, end: now } + const todayStr = toDateString(todayStart) + const yesterdayStr = toDateString(new Date(now.getFullYear(), now.getMonth(), now.getDate() - 1)) + const rangeStartStr = toDateString(periodInfo.range.start) + const rangeEndStr = toDateString(periodInfo.range.end) + const historicalRangeEndStr = rangeEndStr < yesterdayStr ? rangeEndStr : yesterdayStr + const isAllProviders = pf === 'all' + + let todayAllProjects: ProjectSummary[] | null = null + let todayAllDays: ReturnType<typeof aggregateProjectsIntoDays> | null = null + + const getTodayAllProjects = async (): Promise<ProjectSummary[]> => { + if (!todayAllProjects) { + todayAllProjects = fp(await parseAllSessions(todayRange, 'all')) + } + return todayAllProjects + } + + const getTodayAllDays = async (): Promise<ReturnType<typeof aggregateProjectsIntoDays>> => { + if (!todayAllDays) { + todayAllDays = aggregateProjectsIntoDays(await getTodayAllProjects()) + } + return todayAllDays + } + + // Assigned in every branch below (scoped-valid, or the !effectivelyScoped + // fallthrough); the `!` tells the compiler what the flag guarantees. + let currentData!: PeriodData + let scanProjects!: ProjectSummary[] + let scanRange!: DateRange + let cache: DailyCache = emptyCache() + let todayProviderData: PeriodData | null = null + let claudeConfigs: ClaudeConfigSelector | undefined + const requestedClaudeConfigSourceId = opts.claudeConfigSourceId?.trim() || null + const isClaudeConfigScoped = requestedClaudeConfigSourceId !== null + + let effectivelyScoped = false + if (isClaudeConfigScoped) { + // A config source scopes Claude usage only, so scan just Claude (main.ts + // rejects a contradictory non-Claude --provider). This also avoids parsing + // every other provider's corpus on each scoped refresh. + const rawProjects = fp(await parseAllSessions(periodInfo.range, 'claude')) + const fullProjects = daysSelection ? filterProjectsByDays(rawProjects, daysSelection.days) : rawProjects + claudeConfigs = await claudeConfigSelector(fullProjects, requestedClaudeConfigSourceId) + const selectedSourceId = claudeConfigs?.selectedId ?? null + if (selectedSourceId) { + effectivelyScoped = true + scanProjects = filterProjectsByClaudeConfigSource(fullProjects, selectedSourceId) + scanRange = periodInfo.range + currentData = buildPeriodData(periodInfo.label, scanProjects) + } + // A stale/invalid id does NOT validate: fall through to the normal path so + // an --provider all query returns real all-provider totals instead of the + // Claude-only scan. claudeConfigs (selectedId null) is kept so the selector + // still renders. + } + if (!effectivelyScoped) { + if (isAllProviders) { + cache = await hydrateCache() + const todayProjects = await getTodayAllProjects() + const todayDays = await getTodayAllDays() + const historicalDays = rangeStartStr <= historicalRangeEndStr + ? getDaysInRange(cache, rangeStartStr, historicalRangeEndStr) + : [] + const todayInRange = todayDays.filter(d => d.date >= rangeStartStr && d.date <= rangeEndStr) + const unfilteredDays = [...historicalDays, ...todayInRange].sort((a, b) => a.date.localeCompare(b.date)) + const allDays = daysSelection ? unfilteredDays.filter(d => daysSelection.days.has(d.date)) : unfilteredDays + currentData = buildPeriodDataFromDays(allDays, periodInfo.label) + const isTodayOnly = rangeStartStr === todayStr && rangeEndStr === todayStr + if (isTodayOnly) { + scanProjects = todayProjects + scanRange = todayRange + } else { + const rawProjects = fp(await parseAllSessions(periodInfo.range, 'all')) + scanProjects = daysSelection ? filterProjectsByDays(rawProjects, daysSelection.days) : rawProjects + scanRange = periodInfo.range + } + } else { + cache = await loadDailyCache() + const rawProviderProjects = fp(await parseAllSessions(periodInfo.range, pf)) + const fullProjects = daysSelection ? filterProjectsByDays(rawProviderProjects, daysSelection.days) : rawProviderProjects + todayProviderData = buildPeriodData(periodInfo.label, fullProjects) + currentData = todayProviderData + scanProjects = fullProjects + scanRange = periodInfo.range + } + } + if (isAllProviders) { + currentData = buildPeriodData(periodInfo.label, scanProjects) + } + claudeConfigs = claudeConfigs ?? await claudeConfigSelector(scanProjects, null) + + // Codex credits for the period. Reuses the models aggregation (folds reasoning + // into output, keeps non-cached input + cached-read separate) so the figure + // matches the official credit rates. + const modelRows = await aggregateModels(scanProjects) + currentData.codexCredits = modelRows.reduce( + (sum, r) => sum + (r.provider === 'codex' && r.credits != null ? r.credits : 0), + 0, + ) + + // PROVIDERS + // For .all: enumerate every provider with cost across the period (from cache) + installed-but-zero. + // For specific: just this single provider with its scoped cost. + const allProviders = await getAllProviders() + const displayNameByName = new Map(allProviders.map(p => [p.name, p.displayName])) + const providers: ProviderCost[] = [] + if (isClaudeConfigScoped) { + const providerTotals: Record<string, number> = {} + for (const d of aggregateProjectsIntoDays(scanProjects)) { + for (const [name, p] of Object.entries(d.providers)) { + providerTotals[name] = (providerTotals[name] ?? 0) + p.cost + } + } + for (const [name, cost] of Object.entries(providerTotals)) { + providers.push({ name: displayNameByName.get(name) ?? name, cost }) + } + if (providers.length === 0 && claudeConfigs?.selectedId) { + providers.push({ name: displayNameByName.get('claude') ?? 'Claude', cost: 0 }) + } + } else if (isAllProviders) { + const unfilteredProviderDays = [ + ...(rangeStartStr <= historicalRangeEndStr ? getDaysInRange(cache, rangeStartStr, historicalRangeEndStr) : []), + ...(await getTodayAllDays()).filter(d => d.date >= rangeStartStr && d.date <= rangeEndStr), + ] + const allDaysForProviders = daysSelection ? unfilteredProviderDays.filter(d => daysSelection.days.has(d.date)) : unfilteredProviderDays + const providerTotals: Record<string, number> = {} + for (const d of allDaysForProviders) { + for (const [name, p] of Object.entries(d.providers)) { + providerTotals[name] = (providerTotals[name] ?? 0) + p.cost + } + } + for (const [name, cost] of Object.entries(providerTotals)) { + providers.push({ name: displayNameByName.get(name) ?? name, cost }) + } + for (const p of allProviders) { + if (providers.some(pc => pc.name === p.displayName)) continue + const sources = await safeDiscoverSessions(p) + if (sources.length > 0) providers.push({ name: p.displayName, cost: 0 }) + } + } else { + const display = displayNameByName.get(pf) ?? pf + providers.push({ name: display, cost: currentData.cost }) + } + + // DAILY HISTORY (last 365 days) + // Cache stores per-provider cost+calls per day in DailyEntry.providers, so we can derive + // a provider-filtered history without re-parsing. Tokens aren't broken down per provider + // in the cache, so the filtered view shows zero tokens (heatmap/trend still works on cost). + const historyStartStr = toDateString(new Date(now.getFullYear(), now.getMonth(), now.getDate() - BACKFILL_DAYS)) + const allCacheDays = getDaysInRange(cache, historyStartStr, yesterdayStr) + + let dailyHistory + if (isClaudeConfigScoped && claudeConfigs?.selectedId) { + const historyRange: DateRange = { + start: new Date(now.getFullYear(), now.getMonth(), now.getDate() - BACKFILL_DAYS), + end: now, + } + const historyProjects = filterProjectsByClaudeConfigSource( + fp(await parseAllSessions(historyRange, 'claude')), + claudeConfigs.selectedId, + ) + dailyHistory = dailyEntriesToHistory(aggregateProjectsIntoDays(historyProjects)) + } else if (isAllProviders) { + const todayDays = (await getTodayAllDays()).filter(d => d.date === todayStr) + const fullHistory = [...allCacheDays, ...todayDays] + dailyHistory = dailyEntriesToHistory(fullHistory) + } else { + const emptyModels = [] as { name: string; cost: number; savingsUSD: number; calls: number; inputTokens: number; outputTokens: number }[] + const historyFromCache = allCacheDays.map(d => { + const prov = d.providers[pf] ?? { calls: 0, cost: 0, savingsUSD: 0 } + return { + date: d.date, + cost: prov.cost, + savingsUSD: prov.savingsUSD, + calls: prov.calls, + inputTokens: 0, + outputTokens: 0, + cacheReadTokens: 0, + cacheWriteTokens: 0, + topModels: emptyModels, + } + }) + const todayFromParse = aggregateProjectsIntoDays(scanProjects) + .filter(d => d.date === todayStr) + .map(d => { + const prov = d.providers[pf] ?? { calls: 0, cost: 0, savingsUSD: 0 } + return { + date: d.date, + cost: prov.cost, + savingsUSD: prov.savingsUSD, + calls: prov.calls, + inputTokens: 0, + outputTokens: 0, + cacheReadTokens: 0, + cacheWriteTokens: 0, + topModels: emptyModels, + } + }) + dailyHistory = [...historyFromCache, ...todayFromParse] + } + + const home = homedir() + const friendlyProject = (p: ProjectSummary) => { + const resolved = p.projectPath || p.project + if (resolved === home || resolved === home + '/') return 'Home' + return resolved.split('/').filter(Boolean).pop() || p.project + } + + currentData.projects = scanProjects.map(p => ({ + name: friendlyProject(p), + cost: p.totalCostUSD, + savingsUSD: p.totalSavingsUSD, + sessions: p.sessions.length, + sessionDetails: [...p.sessions] + .sort((a, b) => b.totalCostUSD - a.totalCostUSD) + .slice(0, 10) + .map(s => ({ + cost: s.totalCostUSD, + savingsUSD: s.totalSavingsUSD, + calls: s.apiCalls, + inputTokens: s.totalInputTokens, + outputTokens: s.totalOutputTokens, + date: s.firstTimestamp?.split('T')[0] ?? '', + models: Object.entries(s.modelBreakdown) + .map(([name, m]) => ({ name, cost: m.costUSD, savingsUSD: m.savingsUSD })) + .sort((a, b) => b.cost - a.cost) + .slice(0, 3), + })), + })) + + const effMap = aggregateModelEfficiency(scanProjects) + currentData.modelEfficiency = [...effMap.entries()].map(([name, eff]) => ({ + name, + costPerEdit: eff.costPerEditUSD, + oneShotRate: eff.oneShotRate, + })) + + const retryTaxByModel = [...effMap.values()] + .filter(m => m.retries > 0 && m.editTurns > 0) + .map(m => ({ + name: m.model, + taxUSD: m.retries * (m.editCostUSD / m.editTurns), + retries: m.retries, + retriesPerEdit: m.retriesPerEdit, + })) + .sort((a, b) => b.taxUSD - a.taxUSD) + const retryTax = { + totalUSD: retryTaxByModel.reduce((s, m) => s + m.taxUSD, 0), + retries: retryTaxByModel.reduce((s, m) => s + m.retries, 0), + editTurns: [...effMap.values()].filter(m => m.retries > 0).reduce((s, m) => s + m.editTurns, 0), + byModel: retryTaxByModel.slice(0, 5), + } + + currentData.topSessions = scanProjects.flatMap(p => + p.sessions.map(s => ({ + project: friendlyProject(p), + cost: s.totalCostUSD, + savingsUSD: s.totalSavingsUSD, + calls: s.apiCalls, + date: s.firstTimestamp?.split('T')[0] ?? '', + })) + ).sort((a, b) => (b.cost + b.savingsUSD) - (a.cost + a.savingsUSD)).slice(0, 5) + + // Routing waste: find cheapest reliable model (≥90% 1-shot, ≥5 edits), + // then compute how much each pricier model overpaid. + const reliableModels = [...effMap.values()] + .filter(m => m.oneShotRate !== null && m.oneShotRate >= 90 && m.editTurns >= 5 + && (m.costPerEditUSD ?? 0) >= 0.01) + .sort((a, b) => (a.costPerEditUSD ?? Infinity) - (b.costPerEditUSD ?? Infinity)) + const baseline = reliableModels[0] + const routingWasteByModel = baseline + ? [...effMap.values()] + .filter(m => m.model !== baseline.model && m.editTurns > 0 && (m.costPerEditUSD ?? 0) > (baseline.costPerEditUSD ?? 0)) + .map(m => { + const counterfactual = m.editTurns * (baseline.costPerEditUSD ?? 0) + return { + name: m.model, + costPerEdit: m.costPerEditUSD ?? 0, + editTurns: m.editTurns, + actualUSD: m.editCostUSD, + counterfactualUSD: counterfactual, + savingsUSD: m.editCostUSD - counterfactual, + } + }) + .filter(m => m.savingsUSD > 0) + .sort((a, b) => b.savingsUSD - a.savingsUSD) + : [] + const routingWaste = { + totalSavingsUSD: routingWasteByModel.reduce((s, m) => s + m.savingsUSD, 0), + baselineModel: baseline?.model ?? '', + baselineCostPerEdit: baseline?.costPerEditUSD ?? 0, + byModel: routingWasteByModel.slice(0, 5), + } + + const breakdowns: BreakdownArrays = (() => { + const toolMap: Record<string, number> = {} + const skillMap: Record<string, { turns: number; cost: number }> = {} + const subagentMap: Record<string, { calls: number; cost: number }> = {} + const mcpMap: Record<string, number> = {} + // Local-model savings rollup: avoided spend (cost forced to $0, baseline + // recorded) grouped by model and provider. Mirrors the per-call savingsUSD + // that applyLocalModelSavings stamps in the parser. + const savingsByModel = new Map<string, { calls: number; actualUSD: number; savingsUSD: number; baselineModel: string; inputTokens: number; outputTokens: number }>() + const savingsByProvider = new Map<string, { calls: number; savingsUSD: number }>() + let totalSavings = 0 + let totalSavingsCalls = 0 + for (const p of scanProjects) for (const s of p.sessions) { + for (const [t, d] of Object.entries(s.toolBreakdown)) { if (!t.startsWith('lang:')) toolMap[t] = (toolMap[t] ?? 0) + d.calls } + for (const [sk, d] of Object.entries(s.skillBreakdown)) { const e = skillMap[sk] ?? { turns: 0, cost: 0 }; e.turns += d.turns; e.cost += d.costUSD; skillMap[sk] = e } + for (const [sa, d] of Object.entries(s.subagentBreakdown)) { const e = subagentMap[sa] ?? { calls: 0, cost: 0 }; e.calls += d.calls; e.cost += d.costUSD; subagentMap[sa] = e } + for (const [m, d] of Object.entries(s.mcpBreakdown)) { mcpMap[m] = (mcpMap[m] ?? 0) + d.calls } + for (const turn of s.turns) for (const call of turn.assistantCalls) { + if (!call.savingsUSD || call.savingsUSD <= 0) continue + totalSavings += call.savingsUSD + totalSavingsCalls += 1 + const modelKey = getShortModelName(call.model) + const acc = savingsByModel.get(modelKey) ?? { calls: 0, actualUSD: 0, savingsUSD: 0, baselineModel: call.savingsBaselineModel ?? '', inputTokens: 0, outputTokens: 0 } + acc.calls += 1 + acc.actualUSD += call.costUSD + acc.savingsUSD += call.savingsUSD + acc.baselineModel = acc.baselineModel || (call.savingsBaselineModel ?? '') + acc.inputTokens += call.usage.inputTokens + acc.outputTokens += call.usage.outputTokens + savingsByModel.set(modelKey, acc) + const provAcc = savingsByProvider.get(call.provider) ?? { calls: 0, savingsUSD: 0 } + provAcc.calls += 1 + provAcc.savingsUSD += call.savingsUSD + savingsByProvider.set(call.provider, provAcc) + } + } + const localModelSavings = { + totalUSD: totalSavings, + calls: totalSavingsCalls, + byModel: Array.from(savingsByModel.entries()).sort(([, a], [, b]) => b.savingsUSD - a.savingsUSD).slice(0, 5).map(([name, d]) => ({ name, ...d })), + byProvider: Array.from(savingsByProvider.entries()).sort(([, a], [, b]) => b.savingsUSD - a.savingsUSD).slice(0, 5).map(([name, d]) => ({ name, ...d })), + } + return { + tools: Object.entries(toolMap).sort(([, a], [, b]) => b - a).slice(0, 10).map(([name, calls]) => ({ name, calls })), + skills: Object.entries(skillMap).sort(([, a], [, b]) => b.cost - a.cost).slice(0, 10).map(([name, d]) => ({ name, ...d })), + subagents: Object.entries(subagentMap).sort(([, a], [, b]) => b.cost - a.cost).slice(0, 10).map(([name, d]) => ({ name, ...d })), + mcpServers: Object.entries(mcpMap).sort(([, a], [, b]) => b - a).slice(0, 10).map(([name, calls]) => ({ name, calls })), + localModelSavings, + } + })() + + const optimize = opts.optimize === false ? null : await scanAndDetect(scanProjects, scanRange) + return buildMenubarPayload(currentData, providers, optimize, dailyHistory, retryTax, routingWaste, breakdowns, claudeConfigs) +} diff --git a/src/web-dashboard.ts b/src/web-dashboard.ts new file mode 100644 index 0000000..83d4290 --- /dev/null +++ b/src/web-dashboard.ts @@ -0,0 +1,414 @@ +import { createServer, type Server } from 'http' +import { exec } from 'child_process' +import { readFile } from 'fs/promises' +import { existsSync } from 'fs' +import { join, normalize, extname, dirname, sep } from 'path' +import { fileURLToPath } from 'url' +import { AddressInfo } from 'net' + +import { hostname } from 'os' + +import { loadPricing } from './models.js' +import { buildMenubarPayloadForRange } from './usage-aggregator.js' +import type { MenubarPayload } from './menubar-json.js' +import { periodInfoFromQuery, UsageQueryError } from './cli-date.js' +import { pullDevices, linkRemote } from './sharing/host.js' +import { browse } from './sharing/discovery.js' +import { loadOrCreateIdentity } from './sharing/identity.js' +import { pairingCode } from './sharing/pairing.js' +import { getSharingDir, loadRemotes, loadShareAlways, saveShareAlways } from './sharing/store.js' +import { ShareController } from './sharing/share-controller.js' +import { sanitizeForSharing } from './sharing/sanitize.js' +import { buildContextTree, findClaudeSession, listRecentTitledSessions, snapshotRows, type ContextTreeResult, type SessionRef } from './context-tree.js' +import { buildCodexContextTree, findCodexSession, listRecentCodexSessions } from './context-tree-codex.js' + +function readBody(req: import('http').IncomingMessage): Promise<string> { + return new Promise((resolve, reject) => { + let body = '' + req.on('data', (c) => { + body += c + if (body.length > 1_000_000) reject(new Error('request body too large')) + }) + req.on('end', () => resolve(body)) + req.on('error', reject) + }) +} + +function writeJsonError(res: import('http').ServerResponse, status: number, error: string): void { + res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' }) + res.end(JSON.stringify({ error })) +} + +// Cap on the cached local payload, matched to the parser's own session cache +// (parser.ts) so the assembled payload is never staler than its source data. +const LOCAL_PAYLOAD_TTL_MS = 180_000 + +const HERE = dirname(fileURLToPath(import.meta.url)) + +// Locate the built React dashboard (dist/dash). Works both when running from a +// published package (dist/dash next to the bundled CLI) and from source. +function resolveDashDir(): string | null { + const candidates = [ + process.env['CODEBURN_DASH_DIR'], + join(HERE, 'dash'), + join(HERE, '..', 'dist', 'dash'), + join(HERE, '..', 'dash', 'dist'), + ].filter(Boolean) as string[] + for (const dir of candidates) { + if (existsSync(join(dir, 'index.html'))) return dir + } + return null +} + +const CONTENT_TYPES: Record<string, string> = { + '.html': 'text/html; charset=utf-8', + '.js': 'text/javascript; charset=utf-8', + '.css': 'text/css; charset=utf-8', + '.svg': 'image/svg+xml', + '.json': 'application/json; charset=utf-8', + '.woff2': 'font/woff2', + '.woff': 'font/woff', + '.png': 'image/png', + '.ico': 'image/x-icon', + '.map': 'application/json', +} + +const NOT_BUILT_PAGE = + '<!doctype html><meta charset="utf-8">' + + '<body style="font-family:system-ui;background:#0a0a0b;color:#e7e7ea;padding:48px;line-height:1.6">' + + '<h2>Dashboard not built yet</h2>' + + '<p>Build the web UI once, then reload:</p>' + + '<pre style="background:#141417;padding:12px 16px;border-radius:8px;color:#ff8c42">cd dash && npm install && npm run build</pre>' + + '<p>The CLI keeps serving the live data API in the meantime.</p></body>' + +function openBrowser(url: string): void { + const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start ""' : 'xdg-open' + try { + exec(`${cmd} ${url}`) + } catch { + /* user can open it manually */ + } +} + +export async function runWebDashboard(opts: { + period: string + provider: string + from?: string + to?: string + project: string[] + exclude: string[] + port: number + open: boolean +}): Promise<Server> { + await loadPricing() + const dashDir = resolveDashDir() + + // Sharing this device serves the SANITIZED aggregate (no project names/paths + // or per-session detail), unlike the local /api/usage which shows everything. + const shareGetUsage = async (q: { period?: string; from?: string; to?: string }) => { + const periodInfo = periodInfoFromQuery(q, opts.period) + return sanitizeForSharing(await buildMenubarPayloadForRange(periodInfo, { provider: 'all', optimize: false })) + } + const share = new ShareController(shareGetUsage) + if (await loadShareAlways()) await share.start(true).catch(() => {}) + + // The server is long-lived, so cache this machine's parsed payload (the CLI + // process cannot). Store the promise before any await so concurrent identical + // requests collapse into one parse instead of racing. + const localPayloadCache = new Map<string, { at: number; payload: Promise<MenubarPayload> }>() + const getLocalPayload = (period: string, provider: string, from?: string, to?: string): Promise<MenubarPayload> => { + const key = `${period}|${provider}|${from ?? ''}|${to ?? ''}` + const hit = localPayloadCache.get(key) + if (hit && Date.now() - hit.at < LOCAL_PAYLOAD_TTL_MS) return hit.payload + const periodInfo = periodInfoFromQuery({ period, from, to }, opts.period) + const payload = buildMenubarPayloadForRange(periodInfo, { provider, project: opts.project, exclude: opts.exclude, optimize: false }) + const now = Date.now() + localPayloadCache.set(key, { at: now, payload }) + for (const [k, v] of localPayloadCache) if (now - v.at >= LOCAL_PAYLOAD_TTL_MS) localPayloadCache.delete(k) + void payload.catch(() => localPayloadCache.delete(key)) + return payload + } + + // Context trees re-read a whole transcript (up to 100MB), so cache each by + // file version. Keyed on mtime: an active session invalidates itself. + const contextTreeCache = new Map<string, Promise<ContextTreeResult>>() + const getContextTree = (provider: 'claude' | 'codex', ref: SessionRef): Promise<ContextTreeResult> => { + const key = `${provider}:${ref.sessionId}:${ref.mtimeMs}` + const hit = contextTreeCache.get(key) + if (hit) { + // Re-insert so eviction is LRU rather than insertion order. + contextTreeCache.delete(key) + contextTreeCache.set(key, hit) + return hit + } + const tree = provider === 'claude' ? buildContextTree(ref) : buildCodexContextTree(ref) + contextTreeCache.set(key, tree) + void tree.catch(() => contextTreeCache.delete(key)) + while (contextTreeCache.size > 12) { + const oldest = contextTreeCache.keys().next().value + if (oldest === undefined) break + contextTreeCache.delete(oldest) + } + return tree + } + + // Embed this machine's prewarmed payload in index.html for an instant first + // paint with no data round-trip. Only the local device is inlined: no remote + // network wait, and paired devices stream in via the live fetch right after. + const serveIndexHtml = async (res: import('http').ServerResponse, filePath: string): Promise<void> => { + const html = await readFile(filePath, 'utf8') + const payload = await getLocalPayload(opts.period, opts.provider, opts.from, opts.to) + const devices = [{ id: 'local', name: hostname(), local: true, payload }] + // Escape every '<' so a device/model/project name can't close the <script>. + const json = JSON.stringify({ devices }).replace(/</g, String.fromCharCode(92) + 'u003c') + const injected = html.replace('<script type="module"', `<script>window.__CODEBURN_BOOTSTRAP__=${json}</script>\n <script type="module"`) + res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' }) + res.end(injected) + } + + const server = createServer(async (req, res) => { + try { + const url = new URL(req.url ?? '/', 'http://localhost') + + // Loopback-only server. Reject any request not addressed to localhost + // (defeats DNS rebinding, which would otherwise let a website you visit + // read your local usage) and any cross-origin request (CSRF). The local + // payload is unsanitized, so this guard is what keeps it on your machine. + const reqHost = (req.headers.host ?? '').replace(/:\d+$/, '') + const loopback = reqHost === '127.0.0.1' || reqHost === 'localhost' || reqHost === '::1' || reqHost === '[::1]' + const origin = req.headers.origin + const originOk = !origin || /^https?:\/\/(127\.0\.0\.1|localhost|\[::1\])(:\d+)?$/.test(origin) + if (!loopback || !originOk) { + res.writeHead(403, { 'content-type': 'text/plain' }) + res.end('Forbidden') + return + } + + if (url.pathname === '/api/usage') { + const period = url.searchParams.get('period') ?? opts.period + const provider = url.searchParams.get('provider') ?? opts.provider + const from = url.searchParams.get('from') ?? opts.from + const to = url.searchParams.get('to') ?? opts.to + let payload + try { + payload = await getLocalPayload(period, provider, from, to) + } catch (err) { + if (!(err instanceof UsageQueryError)) throw err + writeJsonError(res, 400, err.message) + return + } + res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' }) + res.end(JSON.stringify(payload)) + return + } + + // This machine plus every paired device, each kept separate. Remote + // payloads arrive already sanitized (aggregate numbers only). + if (url.pathname === '/api/devices') { + const period = url.searchParams.get('period') ?? opts.period + const provider = url.searchParams.get('provider') ?? opts.provider + const from = url.searchParams.get('from') ?? opts.from + const to = url.searchParams.get('to') ?? opts.to + let results + try { + results = await pullDevices(() => getLocalPayload(period, provider, from, to), { period, from, to }, hostname(), {}) + } catch (err) { + if (!(err instanceof UsageQueryError)) throw err + writeJsonError(res, 400, err.message) + return + } + res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' }) + res.end(JSON.stringify({ devices: results })) + return + } + + // This device's own identity (name + fingerprint) for the pairing UI. + if (url.pathname === '/api/identity') { + const id = await loadOrCreateIdentity(getSharingDir()) + res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' }) + res.end(JSON.stringify({ name: id.name, fingerprint: id.fingerprint })) + return + } + + // Discover devices currently sharing on the local network (mDNS). Each + // carries the confirm code to match, and whether it is already paired. + if (url.pathname === '/api/devices/scan') { + const dir = getSharingDir() + const id = await loadOrCreateIdentity(dir) + const pairedFps = new Set((await loadRemotes(dir)).map((r) => r.fingerprint)) + const found = await browse(2500) + const list = found + .filter((d) => d.fingerprint !== id.fingerprint) + .map((d) => ({ + name: d.name, + host: d.host, + port: d.port, + fingerprint: d.fingerprint, + code: pairingCode(id.fingerprint, d.fingerprint), + paired: pairedFps.has(d.fingerprint), + })) + res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' }) + res.end(JSON.stringify({ found: list })) + return + } + + // Pair with a chosen discovered device. Blocks until the other device + // approves (or declines / times out), then stores the link. + if (url.pathname === '/api/devices/pair' && req.method === 'POST') { + if (!(req.headers['content-type'] ?? '').includes('application/json')) { + res.writeHead(415, { 'content-type': 'application/json' }) + res.end(JSON.stringify({ ok: false, error: 'content-type must be application/json' })) + return + } + const body = JSON.parse((await readBody(req)) || '{}') as { name: string; host: string; port: number; fingerprint: string } + try { + const device = await linkRemote(body) + res.writeHead(200, { 'content-type': 'application/json; charset=utf-8' }) + res.end(JSON.stringify({ ok: true, name: device.name })) + } catch (err) { + res.writeHead(409, { 'content-type': 'application/json; charset=utf-8' }) + res.end(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) })) + } + return + } + + // Share-this-device controls. Status carries the pending pairing requests + // so the SPA can poll one endpoint and surface approvals in the browser. + if (url.pathname === '/api/share/status') { + res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' }) + res.end(JSON.stringify(await share.status())) + return + } + if (url.pathname === '/api/share/start' && req.method === 'POST') { + const body = JSON.parse((await readBody(req)) || '{}') as { always?: boolean } + let startError: string | undefined + try { + await share.start(!!body.always) + await saveShareAlways(!!body.always) + } catch (err) { + // e.g. EADDRINUSE when a CLI `codeburn share` already holds the port. + startError = err instanceof Error ? err.message : String(err) + } + res.writeHead(200, { 'content-type': 'application/json; charset=utf-8' }) + res.end(JSON.stringify({ ...(await share.status()), error: startError })) + return + } + if (url.pathname === '/api/share/stop' && req.method === 'POST') { + await share.stop() + await saveShareAlways(false) + res.writeHead(200, { 'content-type': 'application/json; charset=utf-8' }) + res.end(JSON.stringify(await share.status())) + return + } + // Session ids are resolved against the discovered session files only, + // never joined into a path from user input, and responses never carry + // local file paths. + if (url.pathname === '/api/context/sessions') { + const provider = url.searchParams.get('provider') ?? 'claude' + if (provider !== 'claude' && provider !== 'codex') { + writeJsonError(res, 400, 'provider must be claude or codex') + return + } + const refs = provider === 'claude' ? await listRecentTitledSessions(15) : await listRecentCodexSessions(15) + const sessions = refs.map((r) => ({ provider, sessionId: r.sessionId, project: r.project, title: r.title, mtimeMs: r.mtimeMs, sizeBytes: r.sizeBytes })) + res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' }) + res.end(JSON.stringify({ sessions })) + return + } + if (url.pathname === '/api/context/tree') { + const provider = url.searchParams.get('provider') ?? 'claude' + const id = url.searchParams.get('id') ?? '' + if ((provider !== 'claude' && provider !== 'codex') || !id) { + writeJsonError(res, 400, 'provider (claude|codex) and id are required') + return + } + const ref = provider === 'claude' ? await findClaudeSession(id) : await findCodexSession(id) + if (!ref || ref.sessionId !== id) { + writeJsonError(res, 404, `no ${provider} session ${id}`) + return + } + const tree = await getContextTree(provider, ref) + const payload = { + ...tree, + session: { sessionId: tree.session.sessionId, project: tree.session.project, mtimeMs: tree.session.mtimeMs, sizeBytes: tree.session.sizeBytes }, + effectiveRows: snapshotRows(tree.effective), + fullRows: snapshotRows(tree.full), + } + res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' }) + res.end(JSON.stringify(payload)) + return + } + + if (url.pathname === '/api/share/approve' && req.method === 'POST') { + const body = JSON.parse((await readBody(req)) || '{}') as { id?: string; approve?: boolean } + const ok = typeof body.id === 'string' && share.resolvePending(body.id, !!body.approve) + res.writeHead(200, { 'content-type': 'application/json; charset=utf-8' }) + res.end(JSON.stringify({ ok })) + return + } + + if (!dashDir) { + res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' }) + res.end(NOT_BUILT_PAGE) + return + } + + let pathname = decodeURIComponent(url.pathname) + if (pathname === '/' || pathname === '') pathname = '/index.html' + const filePath = normalize(join(dashDir, pathname)) + if (filePath !== dashDir && !filePath.startsWith(dashDir + sep)) { + res.writeHead(403) + res.end('Forbidden') + return + } + try { + if (extname(filePath) === '.html') { + await serveIndexHtml(res, filePath) + } else { + const buf = await readFile(filePath) + res.writeHead(200, { 'content-type': CONTENT_TYPES[extname(filePath)] ?? 'application/octet-stream' }) + res.end(buf) + } + } catch { + // Unknown path: serve index.html so the SPA can route it. + await serveIndexHtml(res, join(dashDir, 'index.html')) + } + } catch (err) { + res.writeHead(500, { 'content-type': 'application/json' }) + res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) })) + } + }) + + const port = await new Promise<number>((resolve, reject) => { + server.once('error', (err: NodeJS.ErrnoException) => { + if (err.code === 'EADDRINUSE') { + server.listen(0, '127.0.0.1', () => resolve((server.address() as AddressInfo).port)) + } else { + reject(err) + } + }) + server.listen(opts.port, '127.0.0.1', () => resolve((server.address() as AddressInfo).port)) + }) + // Durable handler so a post-bind socket error never crashes the process. + server.on('error', () => {}) + + void Promise.resolve().then(() => getLocalPayload(opts.period, opts.provider, opts.from, opts.to)).catch(() => {}) + + const url = `http://127.0.0.1:${port}` + if (!dashDir) { + process.stdout.write(`\n Dashboard UI is not built. Run: cd dash && npm install && npm run build\n`) + } + process.stdout.write(`\n CodeBurn dashboard at ${url}\n Press Ctrl+C to stop.\n\n`) + if (opts.open) openBrowser(url) + + // Withdraw the mDNS advertisement and close the share server cleanly on exit. + process.on('SIGINT', () => { + void share.stop().finally(() => process.exit(0)) + }) + + return server + + await new Promise<never>(() => { + /* run until interrupted */ + }) +} diff --git a/src/yield.ts b/src/yield.ts new file mode 100644 index 0000000..aefd928 --- /dev/null +++ b/src/yield.ts @@ -0,0 +1,289 @@ +import { execFileSync } from 'child_process' +import { parseAllSessions } from './parser.js' +import type { DateRange, SessionSummary } from './types.js' + +export type YieldCategory = 'productive' | 'reverted' | 'abandoned' + +export type SessionYield = { + sessionId: string + project: string + cost: number + category: YieldCategory + commitCount: number +} + +export type YieldSummary = { + productive: { cost: number; sessions: number } + reverted: { cost: number; sessions: number } + abandoned: { cost: number; sessions: number } + total: { cost: number; sessions: number } + details: SessionYield[] +} + +export type YieldJsonReport = { + period: { + label: string + start: string + end: string + } + summary: { + productive: YieldBucketJson + reverted: YieldBucketJson + abandoned: YieldBucketJson + total: { costUSD: number; sessions: number } + productiveToRevertedCostRatio: number | null + } + details: SessionYieldJson[] +} + +type YieldBucketJson = { + costUSD: number + sessions: number + costPercent: number + sessionPercent: number +} + +type SessionYieldJson = Omit<SessionYield, 'cost'> & { + costUSD: number +} + +const SAFE_REF_PATTERN = /^[A-Za-z0-9._/\-]+$/ + +function runGit(args: string[], cwd: string): string | null { + try { + return execFileSync('git', args, { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim() + } catch { + return null + } +} + +function isGitRepo(dir: string): boolean { + return runGit(['rev-parse', '--is-inside-work-tree'], dir) === 'true' +} + +function getMainBranch(cwd: string): string { + const result = runGit(['symbolic-ref', 'refs/remotes/origin/HEAD'], cwd) + if (result) { + const branch = result.replace('refs/remotes/origin/', '') + if (SAFE_REF_PATTERN.test(branch)) return branch + } + + const branches = runGit(['branch', '-a'], cwd) ?? '' + if (branches.includes('main')) return 'main' + if (branches.includes('master')) return 'master' + return 'main' +} + +type CommitInfo = { + sha: string + timestamp: Date + inMain: boolean + /** Set when a LATER commit's body says "This reverts commit <sha>" — i.e. the work in this commit was reverted out of main. */ + wasReverted: boolean +} + +/** + * Find SHAs that were the target of a `git revert` ANYWHERE in the repo's + * history (not just the time window). The standard `git revert` body + * format is "This reverts commit <SHA>." which we grep out. + * + * The previous implementation flagged a commit as `isRevert` based on the + * substring "revert" appearing in its OWN subject. Two bugs there: + * 1. Subjects like "Add revert button" matched. + * 2. The session that PERFORMED the revert was tagged "reverted", not the + * session whose work was being reverted — so the original session always + * looked productive even after its work was thrown away. + */ +function getRevertedShas(cwd: string): Set<string> { + const bodies = runGit( + ['log', '--all', '--grep=^This reverts commit', '--format=%B%x1e'], + cwd, + ) ?? '' + const set = new Set<string>() + const re = /This reverts commit ([0-9a-f]{7,40})/g + let m: RegExpExecArray | null + while ((m = re.exec(bodies)) !== null) { + set.add(m[1].toLowerCase()) + } + return set +} + +function getCommitsInRange(cwd: string, since: Date, until: Date, mainBranch: string): CommitInfo[] { + const sinceStr = since.toISOString() + const untilStr = until.toISOString() + + const log = runGit( + ['log', '--all', `--since=${sinceStr}`, `--until=${untilStr}`, '--format=%H|%aI|%s'], + cwd + ) + + if (!log) return [] + + const mainCommits = new Set( + (runGit(['log', mainBranch, '--format=%H'], cwd) ?? '').split('\n').filter(Boolean) + ) + const revertedShas = getRevertedShas(cwd) + + return log.split('\n').filter(Boolean).map(line => { + const [sha] = line.split('|') + const timestamp = line.split('|')[1] ?? '' + return { + sha, + timestamp: new Date(timestamp), + inMain: mainCommits.has(sha), + // wasReverted: matches when ANY later commit's body says + // "This reverts commit <sha>". Compare against the full SHA AND its + // 7-char short prefix to be safe; git revert sometimes records the + // short form. + wasReverted: revertedShas.has(sha.toLowerCase()) || + revertedShas.has(sha.toLowerCase().slice(0, 7)), + } + }) +} + +function categorizeSession( + session: SessionSummary, + commits: CommitInfo[] +): { category: YieldCategory; commitCount: number } { + if (!session.firstTimestamp) { + return { category: 'abandoned', commitCount: 0 } + } + + const sessionStart = new Date(session.firstTimestamp) + const lastTs = session.lastTimestamp ?? session.firstTimestamp + const sessionEnd = new Date(new Date(lastTs).getTime() + 60 * 60 * 1000) // +1 hour + + const relevantCommits = commits.filter(c => + c.timestamp >= sessionStart && c.timestamp <= sessionEnd + ) + + if (relevantCommits.length === 0) { + return { category: 'abandoned', commitCount: 0 } + } + + const inMainCount = relevantCommits.filter(c => c.inMain).length + // A session is "reverted" when at least half of its in-main commits were + // later reverted out (revert detected via "This reverts commit <sha>" + // anywhere later in history, not in the same time window). + const revertedCount = relevantCommits.filter(c => c.inMain && c.wasReverted).length + + if (revertedCount > 0 && revertedCount >= inMainCount / 2) { + return { category: 'reverted', commitCount: relevantCommits.length } + } + + if (inMainCount > 0) { + return { category: 'productive', commitCount: inMainCount } + } + + return { category: 'abandoned', commitCount: relevantCommits.length } +} + +export async function computeYield(range: DateRange, cwd: string): Promise<YieldSummary> { + const projects = await parseAllSessions(range, 'all') + + const summary: YieldSummary = { + productive: { cost: 0, sessions: 0 }, + reverted: { cost: 0, sessions: 0 }, + abandoned: { cost: 0, sessions: 0 }, + total: { cost: 0, sessions: 0 }, + details: [], + } + + // Get all commits in the date range for correlation + const commits = isGitRepo(cwd) + ? getCommitsInRange(cwd, range.start, range.end, getMainBranch(cwd)) + : [] + + for (const project of projects) { + // Try project-specific git repo first, fall back to cwd + const projectCwd = project.projectPath && isGitRepo(project.projectPath) + ? project.projectPath + : cwd + + const projectCommits = projectCwd !== cwd && isGitRepo(projectCwd) + ? getCommitsInRange(projectCwd, range.start, range.end, getMainBranch(projectCwd)) + : commits + + for (const session of project.sessions) { + const { category, commitCount } = categorizeSession(session, projectCommits) + + summary[category].cost += session.totalCostUSD + summary[category].sessions += 1 + summary.total.cost += session.totalCostUSD + summary.total.sessions += 1 + + summary.details.push({ + sessionId: session.sessionId, + project: project.project, + cost: session.totalCostUSD, + category, + commitCount, + }) + } + } + + return summary +} + +export function formatYieldSummary(summary: YieldSummary): string { + const { productive, reverted, abandoned, total } = summary + + const pct = (n: number) => total.cost > 0 ? Math.round((n / total.cost) * 100) : 0 + const fmt = (n: number) => `$${n.toFixed(2)}` + + const lines = [ + '', + `Productive: ${fmt(productive.cost).padStart(8)} (${pct(productive.cost)}%) - ${productive.sessions} sessions shipped to main`, + `Reverted: ${fmt(reverted.cost).padStart(8)} (${pct(reverted.cost)}%) - ${reverted.sessions} sessions were reverted`, + `Abandoned: ${fmt(abandoned.cost).padStart(8)} (${pct(abandoned.cost)}%) - ${abandoned.sessions} sessions never committed`, + '', + `Total: ${fmt(total.cost).padStart(8)} - ${total.sessions} sessions`, + '', + ] + + return lines.join('\n') +} + +export function buildYieldJsonReport( + summary: YieldSummary, + periodLabel: string, + range: DateRange, +): YieldJsonReport { + const bucket = (value: { cost: number; sessions: number }): YieldBucketJson => ({ + costUSD: value.cost, + sessions: value.sessions, + costPercent: summary.total.cost > 0 + ? Math.round((value.cost / summary.total.cost) * 1000) / 10 + : 0, + sessionPercent: summary.total.sessions > 0 + ? Math.round((value.sessions / summary.total.sessions) * 1000) / 10 + : 0, + }) + + return { + period: { + label: periodLabel, + start: range.start.toISOString(), + end: range.end.toISOString(), + }, + summary: { + productive: bucket(summary.productive), + reverted: bucket(summary.reverted), + abandoned: bucket(summary.abandoned), + total: { + costUSD: summary.total.cost, + sessions: summary.total.sessions, + }, + productiveToRevertedCostRatio: summary.reverted.cost > 0 + ? Math.round((summary.productive.cost / summary.reverted.cost) * 100) / 100 + : null, + }, + details: summary.details.map(detail => ({ + sessionId: detail.sessionId, + project: detail.project, + costUSD: detail.cost, + category: detail.category, + commitCount: detail.commitCount, + })), + } +} diff --git a/tests/act-journal.test.ts b/tests/act-journal.test.ts new file mode 100644 index 0000000..5732899 --- /dev/null +++ b/tests/act-journal.test.ts @@ -0,0 +1,215 @@ +import { afterAll, describe, expect, it } from 'vitest' +import { mkdtemp, mkdir, readFile, rm, utimes, writeFile } from 'node:fs/promises' +import { existsSync } from 'node:fs' +import { spawnSync } from 'node:child_process' +import { tmpdir } from 'node:os' +import { dirname, join } from 'node:path' +import { fileURLToPath } from 'node:url' +import { runAction } from '../src/act/apply.js' +import { journalPath, readRecords } from '../src/act/journal.js' +import { sha256 } from '../src/act/backup.js' +import type { ActionRecord } from '../src/act/types.js' + +const roots: string[] = [] + +async function makeRoot(): Promise<{ actionsDir: string; files: string }> { + const root = await mkdtemp(join(tmpdir(), 'codeburn-act-journal-')) + roots.push(root) + const files = join(root, 'files') + await mkdir(files, { recursive: true }) + return { actionsDir: join(root, 'actions'), files } +} + +afterAll(async () => { + for (const root of roots) await rm(root, { recursive: true, force: true }) +}) + +describe('runAction journaling', () => { + it('journals backups and afterHash for edit, create, and move ops', async () => { + const { actionsDir, files } = await makeRoot() + const editPath = join(files, 'edit.txt') + const createPath = join(files, 'new.txt') + const movePath = join(files, 'move.txt') + const moveDest = join(files, 'archive', 'move.txt') + await writeFile(editPath, 'old-edit') + await writeFile(movePath, 'move-body') + + const rec = await runAction({ + kind: 'claude-md-rule', + description: 'test action', + changes: [ + { op: 'edit', path: editPath, content: 'new-edit' }, + { op: 'create', path: createPath, content: 'created' }, + { op: 'move', path: movePath, movedTo: moveDest }, + ], + }, actionsDir) + + expect(rec.status).toBe('applied') + expect(rec.findingId).toBeNull() + expect(rec.changes).toHaveLength(3) + const [edit, create, move] = rec.changes + + expect(edit!.backup).not.toBeNull() + expect(await readFile(join(actionsDir, edit!.backup!), 'utf-8')).toBe('old-edit') + expect(edit!.afterHash).toBe(sha256(Buffer.from('new-edit'))) + expect(await readFile(editPath, 'utf-8')).toBe('new-edit') + + expect(create!.backup).toBeNull() + expect(create!.afterHash).toBe(sha256(Buffer.from('created'))) + expect(await readFile(createPath, 'utf-8')).toBe('created') + + expect(move!.backup).not.toBeNull() + expect(await readFile(join(actionsDir, move!.backup!), 'utf-8')).toBe('move-body') + expect(move!.movedTo).toBe(moveDest) + expect(move!.afterHash).toBe(sha256(Buffer.from('move-body'))) + expect(await readFile(moveDest, 'utf-8')).toBe('move-body') + expect(existsSync(movePath)).toBe(false) + + const records = await readRecords(actionsDir) + expect(records).toHaveLength(1) + expect(records[0]!.id).toBe(rec.id) + }) + + it('rolls back completed mutations and writes no record when a mutation fails', async () => { + const { actionsDir, files } = await makeRoot() + const editPath = join(files, 'edit.txt') + await writeFile(editPath, 'original') + const missingSrc = join(files, 'does-not-exist.txt') + + await expect(runAction({ + kind: 'shell-config', + description: 'failing action', + changes: [ + { op: 'edit', path: editPath, content: 'changed' }, + { op: 'move', path: missingSrc, movedTo: join(files, 'dest.txt') }, + ], + }, actionsDir)).rejects.toThrow() + + expect(await readFile(editPath, 'utf-8')).toBe('original') + expect(existsSync(journalPath(actionsDir))).toBe(false) + }) + + it('skips corrupt journal lines and still loads valid records', async () => { + const { actionsDir } = await makeRoot() + await mkdir(actionsDir, { recursive: true }) + const recA = sampleRecord('11111111-1111-1111-1111-111111111111', 'first') + const recB = sampleRecord('22222222-2222-2222-2222-222222222222', 'second') + await writeFile( + journalPath(actionsDir), + JSON.stringify(recA) + '\n' + '{ this is not json\n' + JSON.stringify(recB) + '\n', + ) + + const records = await readRecords(actionsDir) + expect(records.map(r => r.id)).toEqual([recA.id, recB.id]) + expect(records.map(r => r.description)).toEqual(['first', 'second']) + }) + + it('round-trips a record through JSON (act list --json shape)', async () => { + const { actionsDir, files } = await makeRoot() + const p = join(files, 'f.txt') + await writeFile(p, 'before') + const rec = await runAction({ + kind: 'model-default', + description: 'json shape', + changes: [{ op: 'edit', path: p, content: 'after' }], + }, actionsDir) + + const records = await readRecords(actionsDir) + const roundTripped = JSON.parse(JSON.stringify(records)) as ActionRecord[] + expect(roundTripped).toEqual(records) + + const only = roundTripped[0]! + expect(only).toMatchObject({ id: rec.id, kind: 'model-default', description: 'json shape', status: 'applied' }) + expect(typeof only.at).toBe('string') + expect(only.findingId).toBeNull() + expect(only.changes[0]).toMatchObject({ path: p, op: 'edit' }) + expect(only.changes[0]!.backup).not.toBeNull() + expect(typeof only.changes[0]!.afterHash).toBe('string') + }) +}) + +describe('action lock', () => { + it('refuses to run while a fresh foreign lock is held', async () => { + const { actionsDir, files } = await makeRoot() + await mkdir(actionsDir, { recursive: true }) + await writeFile(join(actionsDir, '.lock'), '') + const target = join(files, 'blocked.txt') + + await expect(runAction({ + kind: 'shell-config', + description: 'blocked by lock', + changes: [{ op: 'create', path: target, content: 'x' }], + }, actionsDir)).rejects.toThrow(/in progress/) + + expect(existsSync(target)).toBe(false) + }) + + it('takes over a lock whose mtime is older than 60s', async () => { + const { actionsDir, files } = await makeRoot() + await mkdir(actionsDir, { recursive: true }) + const lock = join(actionsDir, '.lock') + await writeFile(lock, JSON.stringify({ pid: 1, at: 0 })) + const past = new Date(Date.now() - 61_000) + await utimes(lock, past, past) + const target = join(files, 'takeover.txt') + + const rec = await runAction({ + kind: 'shell-config', + description: 'stale takeover', + changes: [{ op: 'create', path: target, content: 'x' }], + }, actionsDir) + + expect(rec.status).toBe('applied') + expect(await readFile(target, 'utf-8')).toBe('x') + expect(existsSync(lock)).toBe(false) + }) +}) + +describe('act list --json (CLI)', () => { + it('prints full records as JSON, newest first', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-act-cli-')) + roots.push(home) + const actionsDir = join(home, '.config', 'codeburn', 'actions') + const files = join(home, 'work') + await mkdir(files, { recursive: true }) + const p1 = join(files, 'a.txt') + const p2 = join(files, 'b.txt') + await writeFile(p1, 'a') + await writeFile(p2, 'b') + const recOlder = await runAction({ + kind: 'mcp-remove', description: 'older', changes: [{ op: 'edit', path: p1, content: 'a2' }], + }, actionsDir) + const recNewer = await runAction({ + kind: 'mcp-remove', description: 'newer', changes: [{ op: 'edit', path: p2, content: 'b2' }], + }, actionsDir) + + // Anchor the spawn to this checkout so running vitest from another cwd + // cannot execute a different checkout's cli.ts. + const repoRoot = join(dirname(fileURLToPath(import.meta.url)), '..') + const res = spawnSync(process.execPath, ['--import', 'tsx', 'src/cli.ts', 'act', 'list', '--json'], { + cwd: repoRoot, + env: { ...process.env, HOME: home, USERPROFILE: home, HOMEPATH: home, HOMEDRIVE: '' }, + encoding: 'utf-8', + }) + + expect(res.status).toBe(0) + const parsed = JSON.parse(res.stdout) as ActionRecord[] + expect(parsed.map(r => r.id)).toEqual([recNewer.id, recOlder.id]) + expect(parsed[0]).toMatchObject({ kind: 'mcp-remove', description: 'newer', status: 'applied', findingId: null }) + expect(parsed[0]!.changes[0]).toMatchObject({ path: p2, op: 'edit' }) + expect(typeof parsed[0]!.changes[0]!.afterHash).toBe('string') + expect(parsed[0]!.changes[0]!.backup).not.toBeNull() + }, 20_000) +}) + +function sampleRecord(id: string, description: string): ActionRecord { + return { + id, + at: new Date().toISOString(), + kind: 'mcp-remove', + findingId: null, + description, + changes: [], + status: 'applied', + } +} diff --git a/tests/act-report.test.ts b/tests/act-report.test.ts new file mode 100644 index 0000000..ae0664c --- /dev/null +++ b/tests/act-report.test.ts @@ -0,0 +1,435 @@ +import { afterAll, describe, expect, it } from 'vitest' +import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' + +import { journalPath } from '../src/act/journal.js' +import { + buildActReportJson, + buildOptimizeAppliedHeader, + computeActReport, + renderActReport, +} from '../src/act/report.js' +import type { ActionRecord } from '../src/act/types.js' +import type { ProjectSummary } from '../src/types.js' + +type Session = ProjectSummary['sessions'][number] + +const roots: string[] = [] +afterAll(async () => { for (const r of roots) await rm(r, { recursive: true, force: true }) }) + +const NOW = new Date('2026-07-01T00:00:00Z') +function daysAgo(n: number): string { + return new Date(NOW.getTime() - n * 86_400_000).toISOString() +} + +async function writeJournal(records: unknown[]): Promise<string> { + const root = await mkdtemp(join(tmpdir(), 'codeburn-act-report-')) + roots.push(root) + const actionsDir = join(root, 'actions') + await mkdir(actionsDir, { recursive: true }) + await writeFile(journalPath(actionsDir), records.map(r => JSON.stringify(r)).join('\n') + (records.length ? '\n' : '')) + return actionsDir +} + +function makeSession(id: string, firstTimestamp: string, over: Partial<Session> = {}): Session { + return { + sessionId: id, + project: 'app', + firstTimestamp, + lastTimestamp: firstTimestamp, + totalCostUSD: 1, + totalSavingsUSD: 0, + totalInputTokens: 1000, + totalOutputTokens: 0, + totalReasoningTokens: 0, + totalCacheReadTokens: 0, + totalCacheWriteTokens: 0, + apiCalls: 1, + turns: [], + modelBreakdown: {}, + toolBreakdown: {}, + mcpBreakdown: {}, + bashBreakdown: {}, + categoryBreakdown: {} as Session['categoryBreakdown'], + skillBreakdown: {}, + subagentBreakdown: {}, + ...over, + } +} + +function projectOf(sessions: Session[]): ProjectSummary { + return { + project: 'app', + projectPath: '/tmp/app', + sessions, + totalCostUSD: sessions.reduce((s, x) => s + x.totalCostUSD, 0), + totalSavingsUSD: 0, + totalApiCalls: sessions.length, + totalProxiedCostUSD: 0, + } +} + +function sessionsAt(count: number, ts: string, over: Partial<Session> = {}): Session[] { + return Array.from({ length: count }, (_, i) => makeSession(`s${i}`, ts, over)) +} + +function mcpRecord(over: Partial<ActionRecord> = {}): ActionRecord { + const at = daysAgo(10) + return { + id: 'a1', + at, + kind: 'mcp-remove', + findingId: 'unused-mcp', + description: 'Remove an MCP server from config', + changes: [], + status: 'applied', + baseline: { windowDays: 14, capturedAt: at, estimatedTokens: 56_000, sessions: 28, metrics: { 'brave-search': 2000 } }, + ...over, + } +} + +const load = (projects: ProjectSummary[]) => async () => projects + +describe('mcp realized delta', () => { + it('multiplies baseline tokens-per-session by post-window sessions (exact)', async () => { + const actionsDir = await writeJournal([mcpRecord()]) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf(sessionsAt(20, daysAgo(5)))]) }) + + expect(report.rows).toHaveLength(1) + const row = report.rows[0]! + expect(row.status).toBe('measured') + expect(row.realizedTokens).toBe(40_000) // 2000 tokens/session * 20 sessions + expect(row.estimatedAtApply).toBe(56_000) + expect(row.estimatedForWindow).toBe(40_000) // window-scaled: 2000 * 20 + expect(row.confidence).toBe('normal') + expect(report.totalRealizedTokens).toBe(40_000) + }) + + it('subtracts keeper sessions that still load the server for project-scope, not a revert', async () => { + const rec = mcpRecord({ kind: 'mcp-project-scope', findingId: 'mcp-project-scope', description: 'Project-scope an MCP server' }) + const actionsDir = await writeJournal([rec]) + const keepers = sessionsAt(5, daysAgo(4), { mcpInventory: ['mcp__brave-search__search'] }) + const cold = sessionsAt(15, daysAgo(5)) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf([...cold, ...keepers])]) }) + + const row = report.rows[0]! + expect(row.status).toBe('measured') + expect(row.realizedTokens).toBe(30_000) // 2000 x (20 - 5 still loading) + expect(row.estimatedForWindow).toBe(40_000) // 2000 x all 20 window sessions + }) + + it('reports "reverted" with zero savings when the server reappears in the window', async () => { + const actionsDir = await writeJournal([mcpRecord()]) + const back = sessionsAt(20, daysAgo(5), { mcpInventory: ['mcp__brave-search__search'] }) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf(back)]) }) + + const row = report.rows[0]! + expect(row.status).toBe('reverted') + expect(row.realizedTokens).toBe(0) + expect(row.note).toMatch(/reverted by user/) + expect(report.totalRealizedTokens).toBe(0) + }) +}) + +describe('confidence markers', () => { + it('marks low when fewer than 20 post-window sessions', async () => { + const actionsDir = await writeJournal([mcpRecord()]) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf(sessionsAt(10, daysAgo(5)))]) }) + + const row = report.rows[0]! + expect(row.status).toBe('measured') + expect(row.realizedTokens).toBe(20_000) // 2000 * 10 + expect(row.confidence).toBe('low') + }) + + it('marks low when volume shifts more than 2x versus baseline', async () => { + // 25 post-window sessions (>= 20, so not the count rule) over 10 days is + // 2.5/day against a 1/day baseline (14 sessions / 14 days) -> 2.5x shift. + const rec = mcpRecord({ baseline: { windowDays: 14, capturedAt: daysAgo(10), estimatedTokens: 56_000, sessions: 14, metrics: { 'brave-search': 2000 } } }) + const actionsDir = await writeJournal([rec]) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf(sessionsAt(25, daysAgo(5)))]) }) + + const row = report.rows[0]! + expect(row.status).toBe('measured') + expect(row.confidence).toBe('low') + }) + + it('stays normal when volume is comparable to baseline', async () => { + const actionsDir = await writeJournal([mcpRecord()]) // baseline 28/14 = 2/day + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf(sessionsAt(20, daysAgo(5)))]) }) // 20/10 = 2/day + expect(report.rows[0]!.confidence).toBe('normal') + }) +}) + +describe('eligibility', () => { + it('excludes undone actions and actions younger than 3 days', async () => { + const records = [ + mcpRecord({ id: 'old', at: daysAgo(10) }), + mcpRecord({ id: 'young', at: daysAgo(1) }), + mcpRecord({ id: 'undone', at: daysAgo(20), status: 'undone' }), + ] + const actionsDir = await writeJournal(records) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf(sessionsAt(20, daysAgo(5)))]) }) + + expect(report.rows).toHaveLength(1) + expect(report.rows[0]!.id).toBe('old') + expect(report.activeCount).toBe(2) // old + young are applied; undone is not + }) +}) + +describe('read-edit realized delta', () => { + it('credits the reduction in the read deficit using the detector estimate math', async () => { + // Baseline ratio 1:1 (deficit 3 reads/edit). After window: 120 reads / 40 + // edits = 3:1 (deficit 1). Credit (3 - 1) * 40 edits * 600 = 48000. + const at = daysAgo(10) + const rec: ActionRecord = { + id: 'r1', at, kind: 'claude-md-rule', findingId: 'read-edit-ratio', + description: 'Add the read-edit-ratio rule block', changes: [], status: 'applied', + baseline: { windowDays: 14, capturedAt: at, estimatedTokens: 12_000, sessions: 28, metrics: { reads: 10, edits: 10 } }, + } + const actionsDir = await writeJournal([rec]) + const session = makeSession('s0', daysAgo(5), { toolBreakdown: { Read: { calls: 120 }, Edit: { calls: 40 } } }) + const filler = sessionsAt(19, daysAgo(4)) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf([session, ...filler])]) }) + + const row = report.rows[0]! + expect(row.status).toBe('measured') + expect(row.realizedTokens).toBe(48_000) + expect(row.estimatedAtApply).toBe(12_000) + expect(row.estimatedForWindow).toBe(72_000) // deficitThen 3 x 40 edits x 600, same denominator as realized + expect(row.realizedTokens).toBeLessThanOrEqual(row.estimatedForWindow) + expect(row.note).toMatch(/1\.0:1 -> 3\.0:1/) + }) +}) + +describe('round-down discipline', () => { + it('floors non-integer mcp products, never rounds up', async () => { + const rec = mcpRecord({ baseline: { windowDays: 14, capturedAt: daysAgo(10), estimatedTokens: 5000, sessions: 3, metrics: { 'brave-search': 700.7 } } }) + const actionsDir = await writeJournal([rec]) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf(sessionsAt(3, daysAgo(5)))]) }) + + const row = report.rows[0]! + expect(row.status).toBe('measured') + expect(row.realizedTokens).toBe(2102) // floor(700.7 x 3 = 2102.1); ceil would be 2103 + expect(row.estimatedForWindow).toBe(2102) + }) + + it('floors non-integer read-edit products, never rounds up', async () => { + // deficitThen = 4 - 10/7 = 18/7; deficitNow = 4 - 20/10 = 2. + // realized = floor((18/7 - 2) x 10 x 600) = floor(3428.57...) = 3428. + // window estimate = floor(18/7 x 10 x 600) = floor(15428.57...) = 15428. + const at = daysAgo(10) + const rec: ActionRecord = { + id: 'rf1', at, kind: 'claude-md-rule', findingId: 'read-edit-ratio', + description: 'Add the read-edit-ratio rule block', changes: [], status: 'applied', + baseline: { windowDays: 14, capturedAt: at, estimatedTokens: 9000, sessions: 28, metrics: { reads: 10, edits: 7 } }, + } + const actionsDir = await writeJournal([rec]) + const session = makeSession('s0', daysAgo(5), { toolBreakdown: { Read: { calls: 20 }, Edit: { calls: 10 } } }) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf([session])]) }) + + const row = report.rows[0]! + expect(row.status).toBe('measured') + expect(row.realizedTokens).toBe(3428) // ceil would be 3429 + expect(row.estimatedForWindow).toBe(15_428) // ceil would be 15429 + }) +}) + +describe('archive realized delta', () => { + it('measures per-item definition tokens times sessions and detects un-archive', async () => { + const at = daysAgo(10) + const kept = join(tmpdir(), 'codeburn-act-report-absent-skill-xyz') // absent -> not reverted + const base = { windowDays: 14, capturedAt: at, estimatedTokens: 160, sessions: 28, metrics: { 'skill-a': 80, 'skill-b': 80 } } + const rec: ActionRecord = { + id: 'ar1', at, kind: 'archive-skill', findingId: 'unused-skills', + description: 'Archive 2 unused skills', status: 'applied', + changes: [{ path: kept, backup: null, op: 'move', movedTo: kept + '.archived', afterHash: '' }], + baseline: base, + } + const actionsDir = await writeJournal([rec]) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf(sessionsAt(20, daysAgo(5)))]) }) + expect(report.rows[0]!.status).toBe('measured') + expect(report.rows[0]!.realizedTokens).toBe(3200) // 160 tokens/session * 20 + // Tautology expected: estimate and realized share the formula when nothing + // reverted; the measured signal is the session count and the revert check. + expect(report.rows[0]!.estimatedForWindow).toBe(report.rows[0]!.realizedTokens) + + // Now the original path exists again -> reverted, zero savings. + const restoredPath = join(actionsDir, 'restored-skill') + await writeFile(restoredPath, 'x') + const rec2: ActionRecord = { ...rec, changes: [{ path: restoredPath, backup: null, op: 'move', movedTo: restoredPath + '.archived', afterHash: '' }] } + const dir2 = await writeJournal([rec2]) + const report2 = await computeActReport({ actionsDir: dir2, now: NOW, loadProjects: load([projectOf(sessionsAt(20, daysAgo(5)))]) }) + expect(report2.rows[0]!.status).toBe('reverted') + expect(report2.rows[0]!.realizedTokens).toBe(0) + }) +}) + +describe('unmeasured kinds', () => { + it('marks bash cap not measurable but keeps the estimate visible', async () => { + const at = daysAgo(10) + const rec: ActionRecord = { + id: 'b1', at, kind: 'shell-config', findingId: 'bash-output-cap', + description: 'Set the bash output cap', changes: [], status: 'applied', + baseline: { windowDays: 14, capturedAt: at, estimatedTokens: 3750, sessions: 28, metrics: { calls: 200 } }, + } + const actionsDir = await writeJournal([rec]) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf(sessionsAt(20, daysAgo(5)))]) }) + expect(report.rows[0]!.status).toBe('not-measurable') + expect(report.rows[0]!.estimatedAtApply).toBe(3750) + expect(report.rows[0]!.estimatedForWindow).toBe(3750) // no window scaling for unmeasured kinds + expect(report.measuredCount).toBe(0) + }) + + it('marks mcp and archive not measurable when the window has no sessions yet', async () => { + const at = daysAgo(10) + const arch: ActionRecord = { + id: 'z2', at, kind: 'archive-skill', findingId: 'unused-skills', + description: 'Archive 1 unused skill', changes: [], status: 'applied', + baseline: { windowDays: 14, capturedAt: at, estimatedTokens: 80, sessions: 28, metrics: { 'skill-a': 80 } }, + } + const actionsDir = await writeJournal([mcpRecord(), arch]) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([]) }) + + expect(report.rows).toHaveLength(2) + for (const row of report.rows) { + expect(row.status).toBe('not-measurable') + expect(row.note).toMatch(/no sessions in the window yet/) + expect(row.realizedTokens).toBe(0) + } + expect(report.measuredCount).toBe(0) + }) +}) + +describe('journal robustness', () => { + const missingAt = { id: 'm1', kind: 'mcp-remove', status: 'applied', description: 'missing at', changes: [] } + const numericAt = { id: 'm2', at: 12345, kind: 'mcp-remove', status: 'applied', description: 'numeric at', changes: [] } + + it('skips malformed records with a note instead of crashing, and drops the optimize header', async () => { + const actionsDir = await writeJournal([missingAt, numericAt]) + const report = await computeActReport({ + actionsDir, now: NOW, + loadProjects: async () => { throw new Error('should not scan when no eligible records remain') }, + }) + + expect(report.malformedRecords).toBe(2) + expect(report.rows).toHaveLength(0) + expect(report.activeCount).toBe(0) + expect(buildOptimizeAppliedHeader(report)).toBeNull() + expect(renderActReport(report)).toMatch(/2 malformed records skipped/) + }) + + it('still measures valid records alongside malformed ones', async () => { + const actionsDir = await writeJournal([missingAt, mcpRecord()]) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf(sessionsAt(20, daysAgo(5)))]) }) + + expect(report.malformedRecords).toBe(1) + expect(report.rows).toHaveLength(1) + expect(report.rows[0]!.realizedTokens).toBe(40_000) + expect(renderActReport(report)).toMatch(/1 malformed record skipped/) + }) +}) + +describe('optimize header', () => { + it('appears only when a normal-confidence measured token action exists', async () => { + const actionsDir = await writeJournal([mcpRecord()]) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf(sessionsAt(20, daysAgo(5)))]) }) + const header = buildOptimizeAppliedHeader(report) + expect(header).toMatch(/^Applied fixes: 1 active, realized ~40\.0K tokens.*over 10 days\. Details: codeburn act report$/) + }) + + it('renders no header when every measured row is low confidence (under-claim)', async () => { + const actionsDir = await writeJournal([mcpRecord()]) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf(sessionsAt(10, daysAgo(5)))]) }) + + expect(report.rows[0]!.status).toBe('measured') + expect(report.rows[0]!.confidence).toBe('low') + expect(report.rows[0]!.realizedTokens).toBe(20_000) // still visible in act report + expect(report.totalRealizedTokens).toBe(20_000) + expect(buildOptimizeAppliedHeader(report)).toBeNull() + }) + + it('sums only normal-confidence rows into the header total', async () => { + // r1: baseline 28/14d = 2/day vs post 20/10d = 2/day -> normal. + // r2: baseline 100/14d = 7.1/day vs 2/day -> >2x shift -> low. + const r1 = mcpRecord({ id: 'n1' }) + const r2 = mcpRecord({ + id: 'l1', + baseline: { windowDays: 14, capturedAt: daysAgo(10), estimatedTokens: 56_000, sessions: 100, metrics: { 'other-server': 2000 } }, + }) + const actionsDir = await writeJournal([r1, r2]) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf(sessionsAt(20, daysAgo(5)))]) }) + + expect(report.totalRealizedTokens).toBe(80_000) // both stay visible in act report + const header = buildOptimizeAppliedHeader(report) + expect(header).toMatch(/^Applied fixes: 2 active, realized ~40\.0K tokens/) + }) + + it('returns null and never scans when the journal has no eligible actions', async () => { + const emptyDir = await writeJournal([]) + const report = await computeActReport({ + actionsDir: emptyDir, now: NOW, + loadProjects: async () => { throw new Error('should not scan for an empty journal') }, + }) + expect(report.rows).toHaveLength(0) + expect(report.activeCount).toBe(0) + expect(buildOptimizeAppliedHeader(report)).toBeNull() + }) + + it('records the earliest apply date per finding for re-flagging', async () => { + const records = [ + mcpRecord({ id: 'x1', at: daysAgo(9), findingId: 'unused-mcp' }), + mcpRecord({ id: 'x2', at: daysAgo(4), findingId: 'unused-mcp' }), + ] + const actionsDir = await writeJournal(records) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf(sessionsAt(20, daysAgo(3)))]) }) + expect(report.appliedByFinding['unused-mcp']).toBe(daysAgo(9).slice(0, 10)) + }) +}) + +describe('json + render shape', () => { + it('mirrors the rows and totals in --json', async () => { + const actionsDir = await writeJournal([mcpRecord()]) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf(sessionsAt(20, daysAgo(5)))]) }) + const json = buildActReportJson(report) as { + actions: Array<Record<string, unknown>> + totals: Record<string, unknown> + footer: string + windowCapDays: number + } + + expect(Array.isArray(json.actions)).toBe(true) + expect(json.actions[0]).toMatchObject({ + kind: 'mcp-remove', + estimatedAtApply: 56_000, + estimatedForWindow: 40_000, + realizedTokens: 40_000, + status: 'measured', + confidence: 'normal', + }) + expect(json.totals).toMatchObject({ realizedTokens: 40_000, measuredActions: 1, activeActions: 1 }) + expect(json.windowCapDays).toBe(30) + expect((json as { malformedRecords?: number }).malformedRecords).toBe(0) + expect(typeof json.footer).toBe('string') + expect(json.footer).toMatch(/correlation/) + }) + + it('renders an empty state without a table when nothing is measurable', async () => { + const emptyDir = await writeJournal([]) + const report = await computeActReport({ actionsDir: emptyDir, now: NOW, loadProjects: async () => [] }) + const out = renderActReport(report) + expect(out).toMatch(/No applied actions to measure yet/) + expect(out).not.toMatch(/Total realized/) + }) + + it('renders a table with a total row when measurements exist', async () => { + const actionsDir = await writeJournal([mcpRecord()]) + const report = await computeActReport({ actionsDir, now: NOW, loadProjects: load([projectOf(sessionsAt(20, daysAgo(5)))]) }) + const out = renderActReport(report) + expect(out).toMatch(/Total realized/) + expect(out).toMatch(/40\.0K/) + expect(out).toMatch(/measures only its own metric/) + expect(out).toMatch(/scaled to the measured window/) + }) +}) diff --git a/tests/act-undo.test.ts b/tests/act-undo.test.ts new file mode 100644 index 0000000..3d37012 --- /dev/null +++ b/tests/act-undo.test.ts @@ -0,0 +1,307 @@ +import { afterAll, describe, expect, it } from 'vitest' +import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises' +import { existsSync } from 'node:fs' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { runAction } from '../src/act/apply.js' +import { appendRecord, readRecords } from '../src/act/journal.js' +import { DriftError, undoAction } from '../src/act/undo.js' +import type { ActionRecord } from '../src/act/types.js' + +const roots: string[] = [] + +async function makeRoot(): Promise<{ actionsDir: string; files: string }> { + const root = await mkdtemp(join(tmpdir(), 'codeburn-act-undo-')) + roots.push(root) + const files = join(root, 'files') + await mkdir(files, { recursive: true }) + return { actionsDir: join(root, 'actions'), files } +} + +afterAll(async () => { + for (const root of roots) await rm(root, { recursive: true, force: true }) +}) + +describe('undoAction', () => { + it('restores byte-identical content for edit, create, and move, then refuses a second undo', async () => { + const { actionsDir, files } = await makeRoot() + const editPath = join(files, 'edit.bin') + const createPath = join(files, 'created.bin') + const movePath = join(files, 'move.bin') + const moveDest = join(files, 'sub', 'move.bin') + const editOriginal = Buffer.from([0, 1, 2, 3, 255, 254]) + const moveOriginal = Buffer.from([10, 20, 30, 40]) + await writeFile(editPath, editOriginal) + await writeFile(movePath, moveOriginal) + + const rec = await runAction({ + kind: 'archive-skill', + description: 'undo test', + changes: [ + { op: 'edit', path: editPath, content: Buffer.from([9, 9, 9]) }, + { op: 'create', path: createPath, content: Buffer.from([7, 7]) }, + { op: 'move', path: movePath, movedTo: moveDest }, + ], + }, actionsDir) + + // 8-char prefix is accepted + await undoAction({ id: rec.id.slice(0, 8) }, { actionsDir }) + + expect(Buffer.compare(await readFile(editPath), editOriginal)).toBe(0) + expect(existsSync(createPath)).toBe(false) + expect(existsSync(moveDest)).toBe(false) + expect(Buffer.compare(await readFile(movePath), moveOriginal)).toBe(0) + + const records = await readRecords(actionsDir) + expect(records).toHaveLength(1) + expect(records[0]!.status).toBe('undone') + expect(records[0]!.undoneAt).toBeTruthy() + + await expect(undoAction({ id: rec.id }, { actionsDir })).rejects.toThrow(/already undone/) + }) + + it('undoes the most recent action with --last and leaves earlier actions applied', async () => { + const { actionsDir, files } = await makeRoot() + const first = join(files, 'first.txt') + const second = join(files, 'second.txt') + await writeFile(first, 'first-old') + await writeFile(second, 'second-old') + + const recFirst = await runAction({ + kind: 'claude-md-rule', description: 'first', changes: [{ op: 'edit', path: first, content: 'first-new' }], + }, actionsDir) + await runAction({ + kind: 'claude-md-rule', description: 'second', changes: [{ op: 'edit', path: second, content: 'second-new' }], + }, actionsDir) + + const undone = await undoAction({ last: true }, { actionsDir }) + expect(undone.description).toBe('second') + expect(await readFile(second, 'utf-8')).toBe('second-old') + expect(await readFile(first, 'utf-8')).toBe('first-new') + + const records = await readRecords(actionsDir) + expect(records.find(r => r.id === recFirst.id)!.status).toBe('applied') + }) + + it('refuses to undo a drifted file, but --force proceeds', async () => { + const { actionsDir, files } = await makeRoot() + const p = join(files, 'drift.txt') + await writeFile(p, 'original') + const rec = await runAction({ + kind: 'claude-md-rule', description: 'drift', changes: [{ op: 'edit', path: p, content: 'applied' }], + }, actionsDir) + + await writeFile(p, 'user-modified') + + await expect(undoAction({ id: rec.id }, { actionsDir })).rejects.toBeInstanceOf(DriftError) + expect((await readRecords(actionsDir))[0]!.status).toBe('applied') + expect(await readFile(p, 'utf-8')).toBe('user-modified') + + await undoAction({ id: rec.id }, { actionsDir, force: true }) + expect(await readFile(p, 'utf-8')).toBe('original') + expect((await readRecords(actionsDir))[0]!.status).toBe('undone') + }) + + it('reverts changes newest-first so overlapping changes restore the original state', async () => { + const { actionsDir, files } = await makeRoot() + const src = join(files, 'a.txt') + const dest = join(files, 'b.txt') + await writeFile(src, 'orig') + + const rec = await runAction({ + kind: 'shell-config', + description: 'move then edit', + changes: [ + { op: 'move', path: src, movedTo: dest }, + { op: 'edit', path: dest, content: 'edited' }, + ], + }, actionsDir) + + await undoAction({ id: rec.id }, { actionsDir }) + expect(await readFile(src, 'utf-8')).toBe('orig') + expect(existsSync(dest)).toBe(false) + }) + + it('refuses to undo a move when the original path is occupied, then --force overwrites', async () => { + const { actionsDir, files } = await makeRoot() + const src = join(files, 'a.txt') + const dest = join(files, 'b.txt') + await writeFile(src, 'moved-bytes') + const rec = await runAction({ + kind: 'archive-skill', description: 'occupied', changes: [{ op: 'move', path: src, movedTo: dest }], + }, actionsDir) + + await writeFile(src, 'squatter') + + const err = await undoAction({ id: rec.id }, { actionsDir }).catch(e => e) + expect(err).toBeInstanceOf(DriftError) + expect((err as DriftError).drifted.some(d => d.includes(src))).toBe(true) + + await undoAction({ id: rec.id }, { actionsDir, force: true }) + expect(await readFile(src, 'utf-8')).toBe('moved-bytes') + expect(existsSync(dest)).toBe(false) + }) + + it('snapshots an existing move destination and restores both files on undo', async () => { + const { actionsDir, files } = await makeRoot() + const src = join(files, 'a.txt') + const dest = join(files, 'b.txt') + await writeFile(src, 'src-bytes') + await writeFile(dest, 'dest-bytes') + + const rec = await runAction({ + kind: 'archive-agent', description: 'move onto dest', changes: [{ op: 'move', path: src, movedTo: dest }], + }, actionsDir) + expect(rec.changes[0]!.destBackup).not.toBeNull() + expect(await readFile(dest, 'utf-8')).toBe('src-bytes') + expect(await readFile(join(actionsDir, rec.changes[0]!.destBackup!), 'utf-8')).toBe('dest-bytes') + + await undoAction({ id: rec.id }, { actionsDir }) + expect(await readFile(src, 'utf-8')).toBe('src-bytes') + expect(await readFile(dest, 'utf-8')).toBe('dest-bytes') + }) + + it('force-undo of a move whose moved file is gone restores from backup and flips status', async () => { + const { actionsDir, files } = await makeRoot() + const src = join(files, 'a.txt') + const dest = join(files, 'b.txt') + await writeFile(src, 'precious') + const rec = await runAction({ + kind: 'archive-command', description: 'gone', changes: [{ op: 'move', path: src, movedTo: dest }], + }, actionsDir) + + await rm(dest) + + await expect(undoAction({ id: rec.id }, { actionsDir })).rejects.toBeInstanceOf(DriftError) + const undone = await undoAction({ id: rec.id }, { actionsDir, force: true }) + expect(undone.status).toBe('undone') + expect(await readFile(src, 'utf-8')).toBe('precious') + }) + + it('undoing a create that overwrote an existing file restores the prior bytes', async () => { + const { actionsDir, files } = await makeRoot() + const p = join(files, 'exists.txt') + await writeFile(p, 'prior') + + const rec = await runAction({ + kind: 'guard-install', description: 'create over existing', changes: [{ op: 'create', path: p, content: 'new' }], + }, actionsDir) + expect(rec.changes[0]!.backup).not.toBeNull() + + await undoAction({ id: rec.id }, { actionsDir }) + expect(await readFile(p, 'utf-8')).toBe('prior') + }) + + it('undoes a plan that touches the same path twice back to the original bytes', async () => { + const { actionsDir, files } = await makeRoot() + const p = join(files, 'twice.txt') + await writeFile(p, 'v0') + + const rec = await runAction({ + kind: 'claude-md-rule', + description: 'same path twice', + changes: [ + { op: 'edit', path: p, content: 'v1' }, + { op: 'edit', path: p, content: 'v2' }, + ], + }, actionsDir) + expect(rec.changes[0]!.afterHash).toBe(rec.changes[1]!.afterHash) + + await undoAction({ id: rec.id }, { actionsDir }) + expect(await readFile(p, 'utf-8')).toBe('v0') + }) + + it('rejects an ambiguous id prefix with the match count', async () => { + const { actionsDir } = await makeRoot() + await appendRecord(actionsDir, bareRecord('aaaaaaaa-1111-4111-8111-111111111111', 'one')) + await appendRecord(actionsDir, bareRecord('aaaaaaaa-2222-4222-8222-222222222222', 'two')) + + await expect(undoAction({ id: 'aaaaaaaa' }, { actionsDir })).rejects.toThrow(/matches 2 actions/) + }) + + it('archives a directory and undo restores the tree with nested content byte-identical', async () => { + const { actionsDir, files } = await makeRoot() + const dir = join(files, 'skill') + const dest = join(files, '.archived', 'skill') + const nestedBytes = Buffer.from([1, 2, 3, 250, 0]) + await mkdir(join(dir, 'nested'), { recursive: true }) + await writeFile(join(dir, 'SKILL.md'), 'skill body') + await writeFile(join(dir, 'nested', 'data.bin'), nestedBytes) + + const rec = await runAction({ + kind: 'archive-skill', + description: 'archive dir', + changes: [{ op: 'move', path: dir, movedTo: dest }], + }, actionsDir) + expect(rec.changes[0]!.afterHash).toBe('') + expect(rec.changes[0]!.backup).not.toBeNull() + expect(existsSync(dir)).toBe(false) + expect(await readFile(join(dest, 'SKILL.md'), 'utf-8')).toBe('skill body') + + await undoAction({ id: rec.id }, { actionsDir }) + expect(existsSync(dest)).toBe(false) + expect(await readFile(join(dir, 'SKILL.md'), 'utf-8')).toBe('skill body') + expect(Buffer.compare(await readFile(join(dir, 'nested', 'data.bin')), nestedBytes)).toBe(0) + }) + + it('moves a directory onto an existing destination directory and undo restores both trees', async () => { + const { actionsDir, files } = await makeRoot() + const src = join(files, 'agent') + const dest = join(files, 'agent-archived') + await mkdir(src, { recursive: true }) + await mkdir(dest, { recursive: true }) + await writeFile(join(src, 'agent.md'), 'src tree') + await writeFile(join(dest, 'old.md'), 'dest tree') + + const rec = await runAction({ + kind: 'archive-agent', + description: 'dir onto dir', + changes: [{ op: 'move', path: src, movedTo: dest }], + }, actionsDir) + expect(rec.changes[0]!.destBackup).not.toBeNull() + expect(await readFile(join(dest, 'agent.md'), 'utf-8')).toBe('src tree') + expect(existsSync(join(dest, 'old.md'))).toBe(false) + + await undoAction({ id: rec.id }, { actionsDir }) + expect(await readFile(join(src, 'agent.md'), 'utf-8')).toBe('src tree') + expect(await readFile(join(dest, 'old.md'), 'utf-8')).toBe('dest tree') + expect(existsSync(join(dest, 'agent.md'))).toBe(false) + }) + + it('refuses dir-move undo when the original path is occupied, then --force overwrites', async () => { + const { actionsDir, files } = await makeRoot() + const src = join(files, 'cmd') + const dest = join(files, 'cmd-archived') + await mkdir(src, { recursive: true }) + await writeFile(join(src, 'cmd.md'), 'body') + const rec = await runAction({ + kind: 'archive-command', + description: 'occupied dir', + changes: [{ op: 'move', path: src, movedTo: dest }], + }, actionsDir) + + await mkdir(src, { recursive: true }) + await writeFile(join(src, 'squatter.md'), 'squatter') + + const err = await undoAction({ id: rec.id }, { actionsDir }).catch(e => e) + expect(err).toBeInstanceOf(DriftError) + expect((err as DriftError).drifted.some(d => d.includes(src))).toBe(true) + + await undoAction({ id: rec.id }, { actionsDir, force: true }) + expect(await readFile(join(src, 'cmd.md'), 'utf-8')).toBe('body') + expect(existsSync(join(src, 'squatter.md'))).toBe(false) + expect(existsSync(dest)).toBe(false) + }) +}) + +function bareRecord(id: string, description: string): ActionRecord { + return { + id, + at: new Date().toISOString(), + kind: 'mcp-remove', + findingId: null, + description, + changes: [], + status: 'applied', + } +} diff --git a/tests/antigravity-statusline.test.ts b/tests/antigravity-statusline.test.ts new file mode 100644 index 0000000..8a41494 --- /dev/null +++ b/tests/antigravity-statusline.test.ts @@ -0,0 +1,149 @@ +import { chmod, mkdir, mkdtemp, readFile, rm, writeFile } from 'fs/promises' +import { tmpdir } from 'os' +import { delimiter, join } from 'path' +import { describe, expect, it } from 'vitest' + +import { + buildAntigravityHookLookupPath, + installAntigravityStatusLineHook, + resolvePersistentCodeburnPathFromPath, + uninstallAntigravityStatusLineHook, +} from '../src/antigravity-statusline.js' + +describe('Antigravity CLI statusLine hook installer', () => { + async function withTempSettings(run: (dir: string, settingsPath: string) => Promise<void>) { + const dir = await mkdtemp(join(tmpdir(), 'codeburn-agy-hook-')) + const settingsPath = join(dir, 'settings.json') + const binDir = join(dir, 'bin') + const codeburnPath = join(binDir, process.platform === 'win32' ? 'codeburn.cmd' : 'codeburn') + await mkdir(binDir, { recursive: true }) + await writeFile(codeburnPath, process.platform === 'win32' ? '@echo off\r\n' : '#!/bin/sh\n') + await chmod(codeburnPath, 0o755) + process.env['CODEBURN_ANTIGRAVITY_SETTINGS_PATH'] = settingsPath + process.env['CODEBURN_CACHE_DIR'] = join(dir, 'cache') + process.env.PATH = binDir + + try { + await run(dir, settingsPath) + } finally { + await rm(dir, { recursive: true, force: true }) + } + } + + it('builds a lookup PATH with user paths before fallbacks', () => { + const lookupPath = buildAntigravityHookLookupPath(['/Users/me/.nvm/versions/node/v22.13.0/bin', '/usr/bin'].join(delimiter)) + + expect(lookupPath.split(delimiter)).toContain('/Users/me/.nvm/versions/node/v22.13.0/bin') + if (process.platform !== 'win32') expect(lookupPath.split(delimiter)).toContain('/opt/homebrew/bin') + }) + + it('skips transient npx codeburn shims when resolving the hook command', async () => { + await withTempSettings(async (dir) => { + const npxBin = join(dir, '.npm', '_npx', 'abcd', 'node_modules', '.bin') + const persistentBin = join(dir, 'persistent-bin') + const npxCodeburn = join(npxBin, process.platform === 'win32' ? 'codeburn.cmd' : 'codeburn') + const persistentCodeburn = join(persistentBin, process.platform === 'win32' ? 'codeburn.cmd' : 'codeburn') + await mkdir(npxBin, { recursive: true }) + await mkdir(persistentBin, { recursive: true }) + await writeFile(npxCodeburn, process.platform === 'win32' ? '@echo off\r\n' : '#!/bin/sh\n') + await writeFile(persistentCodeburn, process.platform === 'win32' ? '@echo off\r\n' : '#!/bin/sh\n') + await chmod(npxCodeburn, 0o755) + await chmod(persistentCodeburn, 0o755) + + const resolved = await resolvePersistentCodeburnPathFromPath([npxBin, persistentBin].join(delimiter)) + + expect(resolved).toBe(persistentCodeburn) + }) + }) + + it('backs up and restores an existing custom statusLine when forced', async () => { + await withTempSettings(async (dir, settingsPath) => { + const customStatusLine = { + type: 'command', + command: 'custom-statusline', + padding: 1, + } + await writeFile(settingsPath, `${JSON.stringify({ statusLine: customStatusLine }, null, 2)}\n`) + + await expect(installAntigravityStatusLineHook(false)).rejects.toThrow('already has a custom statusLine') + expect(await installAntigravityStatusLineHook(true)).toBe('installed') + + const installed = JSON.parse(await readFile(settingsPath, 'utf-8')) + expect(installed.statusLine.command).toContain('agy-statusline-hook') + expect(installed.statusLine.command).not.toContain('custom-statusline') + + const backupPath = join(dir, 'cache', 'antigravity-statusline-previous.json') + const backup = JSON.parse(await readFile(backupPath, 'utf-8')) + expect(backup.statusLine).toEqual(customStatusLine) + + expect(await uninstallAntigravityStatusLineHook()).toBe('restored') + const restored = JSON.parse(await readFile(settingsPath, 'utf-8')) + expect(restored.statusLine).toEqual(customStatusLine) + }) + }) + + it('installs CodeBurn statusLine when no statusLine exists', async () => { + await withTempSettings(async (_dir, settingsPath) => { + expect(await installAntigravityStatusLineHook(false)).toBe('installed') + expect(await installAntigravityStatusLineHook(false)).toBe('already-installed') + + const settings = JSON.parse(await readFile(settingsPath, 'utf-8')) + expect(settings.statusLine).toMatchObject({ + type: 'command', + padding: 0, + }) + expect(settings.statusLine.command).toContain('agy-statusline-hook') + expect(settings.statusLine.command).toContain(join(_dir, 'bin')) + expect(settings.statusLine.command).not.toContain('dist/cli.js') + }) + }) + + it('repairs an existing stale CodeBurn statusLine command without force', async () => { + await withTempSettings(async (dir, settingsPath) => { + await writeFile(settingsPath, JSON.stringify({ + statusLine: { + type: 'command', + command: "'/usr/local/bin/node' '/Users/me/codeburn-agy-statusline/dist/cli.js' agy-statusline-hook", + padding: 0, + }, + })) + + expect(await installAntigravityStatusLineHook(false)).toBe('installed') + + const settings = JSON.parse(await readFile(settingsPath, 'utf-8')) + expect(settings.statusLine.command).toContain(join(dir, 'bin')) + expect(settings.statusLine.command).toContain('agy-statusline-hook') + expect(settings.statusLine.command).not.toContain('codeburn-agy-statusline/dist/cli.js') + }) + }) + + it('treats a custom statusLine that only mentions the hook token as custom, not CodeBurn-owned', async () => { + await withTempSettings(async (_dir, settingsPath) => { + const custom = 'mybar --note "runs agy-statusline-hook nightly"' + await writeFile(settingsPath, JSON.stringify({ + statusLine: { type: 'command', command: custom, padding: 0 }, + })) + + await expect(installAntigravityStatusLineHook(false)).rejects.toThrow(/custom statusLine/) + + const settings = JSON.parse(await readFile(settingsPath, 'utf-8')) + expect(settings.statusLine.command).toBe(custom) + }) + }) + + it('removes CodeBurn statusLine when there is no previous hook backup', async () => { + await withTempSettings(async (_dir, settingsPath) => { + await writeFile(settingsPath, JSON.stringify({ + statusLine: { + type: 'command', + command: 'codeburn agy-statusline-hook', + padding: 0, + }, + })) + + expect(await uninstallAntigravityStatusLineHook()).toBe('removed') + const settings = JSON.parse(await readFile(settingsPath, 'utf-8')) + expect(settings).not.toHaveProperty('statusLine') + }) + }) +}) diff --git a/tests/audit-report.test.ts b/tests/audit-report.test.ts new file mode 100644 index 0000000..1723712 --- /dev/null +++ b/tests/audit-report.test.ts @@ -0,0 +1,112 @@ +import { describe, it, expect } from 'vitest' + +import { aggregateAudit } from '../src/audit-report.js' +import type { + ProjectSummary, + SessionSummary, + ClassifiedTurn, + ParsedApiCall, + TokenUsage, + TaskCategory, +} from '../src/types.js' + +function emptyTokens(): TokenUsage { + return { + inputTokens: 0, + outputTokens: 0, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + } +} + +function makeCall(usage: Partial<TokenUsage>, costUSD: number, model = 'unknown-model-xyz', provider = 'claude'): ParsedApiCall { + return { + provider, + model, + usage: { ...emptyTokens(), ...usage }, + costUSD, + tools: [], + mcpTools: [], + skills: [], + hasAgentSpawn: false, + hasPlanMode: false, + speed: 'standard', + timestamp: '2026-05-09T00:00:00.000Z', + bashCommands: [], + deduplicationKey: `${provider}-${model}-${costUSD}-${usage.inputTokens ?? 0}-${usage.cachedInputTokens ?? 0}`, + } +} + +function makeProject(calls: ParsedApiCall[]): ProjectSummary { + const turn: ClassifiedTurn = { + userMessage: 't', + assistantCalls: calls, + timestamp: '2026-05-09T00:00:00.000Z', + sessionId: 's1', + category: 'feature' as TaskCategory, + retries: 0, + hasEdits: false, + } + const session: SessionSummary = { + sessionId: 's1', + project: 'p', + firstTimestamp: '2026-05-09T00:00:00.000Z', + lastTimestamp: '2026-05-09T00:00:00.000Z', + totalCostUSD: 0, + totalInputTokens: 0, + totalOutputTokens: 0, + totalCacheReadTokens: 0, + totalCacheWriteTokens: 0, + apiCalls: 0, + turns: [turn], + modelBreakdown: {}, + toolBreakdown: {}, + mcpBreakdown: {}, + bashBreakdown: {}, + categoryBreakdown: {} as SessionSummary['categoryBreakdown'], + skillBreakdown: {}, + } + return { project: 'p', projectPath: 'p', sessions: [session], totalCostUSD: 0, totalApiCalls: 0 } +} + +describe('aggregateAudit', () => { + it('keeps raw fields and exposes codeburn normalizations', async () => { + const anthropicCall = makeCall({ inputTokens: 100, outputTokens: 50, reasoningTokens: 10, cacheReadInputTokens: 200 }, 0.5) + const openaiCall = makeCall({ inputTokens: 100, outputTokens: 50, cachedInputTokens: 300 }, 0.5) + const rows = await aggregateAudit([makeProject([anthropicCall, openaiCall])]) + + expect(rows).toHaveLength(1) + const r = rows[0]! + // raw fields are summed untouched + expect(r.raw.inputTokens).toBe(200) + expect(r.raw.outputTokens).toBe(100) + expect(r.raw.reasoningTokens).toBe(10) + expect(r.raw.cacheReadInputTokens).toBe(200) + expect(r.raw.cachedInputTokens).toBe(300) + // reasoning folds into output for pricing + expect(r.displayed.outputTokens).toBe(110) + // cache read is the SUM of per-call max(anthropic, openai), not max of sums + expect(r.displayed.cacheReadTokens).toBe(500) + // attributed cost is preserved exactly + expect(r.attributedCostUSD).toBeCloseTo(1.0) + }) + + it('returns null rates and zero component cost for an unpriced model', async () => { + const rows = await aggregateAudit([makeProject([makeCall({ inputTokens: 1000 }, 0, 'definitely-not-a-real-model-zzz')])]) + expect(rows).toHaveLength(1) + expect(rows[0]!.rates).toBeNull() + expect(rows[0]!.cost.recomputedTotalUSD).toBe(0) + }) + + it('splits buckets by (provider, model)', async () => { + const rows = await aggregateAudit([makeProject([ + makeCall({ inputTokens: 10 }, 0.1, 'model-a', 'claude'), + makeCall({ inputTokens: 20 }, 0.2, 'model-b', 'claude'), + makeCall({ inputTokens: 30 }, 0.3, 'model-a', 'codex'), + ])]) + expect(rows).toHaveLength(3) + }) +}) diff --git a/tests/bash-commands.test.ts b/tests/bash-commands.test.ts new file mode 100644 index 0000000..3daf439 --- /dev/null +++ b/tests/bash-commands.test.ts @@ -0,0 +1,119 @@ +import { describe, it, expect } from 'vitest' +import { extractBashCommands } from '../src/bash-utils.js' +import { BASH_TOOLS } from '../src/classifier.js' + +describe('extractBashCommands', () => { + it('extracts single command', () => { + expect(extractBashCommands('git status')).toEqual(['git']) + }) + + it('extracts chained commands with &&', () => { + expect(extractBashCommands('git add . && git commit -m "x"')).toEqual(['git', 'git']) + }) + + it('extracts chained commands with ;', () => { + expect(extractBashCommands('ls; pwd')).toEqual(['ls', 'pwd']) + }) + + it('extracts piped commands', () => { + expect(extractBashCommands('cat file | grep pattern')).toEqual(['cat', 'grep']) + }) + + it('filters out cd', () => { + expect(extractBashCommands('cd /path && git status')).toEqual(['git']) + }) + + it('returns empty for cd only', () => { + expect(extractBashCommands('cd /path')).toEqual([]) + }) + + it('returns empty for empty string', () => { + expect(extractBashCommands('')).toEqual([]) + }) + + it('returns empty for whitespace only', () => { + expect(extractBashCommands(' ')).toEqual([]) + }) + + it('extracts basename from full path binary', () => { + expect(extractBashCommands('/usr/bin/git status')).toEqual(['git']) + }) + + it('handles mixed separators', () => { + expect(extractBashCommands('cd /x && npm install; npm run build | tee log')).toEqual(['npm', 'npm', 'tee']) + }) + + it('handles extra whitespace', () => { + expect(extractBashCommands(' git status ')).toEqual(['git']) + }) + + it('handles command with quotes containing separators', () => { + expect(extractBashCommands('echo "hello && world"')).toEqual(['echo']) + }) + + it('handles quoted separators followed by real separator', () => { + expect(extractBashCommands('echo "hello && world" && git status')).toEqual(['echo', 'git']) + }) + + it('handles single-quoted separators', () => { + expect(extractBashCommands("echo 'hello && world'")).toEqual(['echo']) + }) + + it('skips leading env var assignments', () => { + expect(extractBashCommands('NODE_ENV=prod npm test')).toEqual(['npm']) + expect(extractBashCommands('FOO=bar BAZ=qux ls -la')).toEqual(['ls']) + }) + + it('skips standalone true/false', () => { + expect(extractBashCommands('true && git status')).toEqual(['git']) + expect(extractBashCommands('false || echo done')).toEqual(['echo']) + expect(extractBashCommands('true')).toEqual([]) + }) + + it('handles env vars combined with chained commands', () => { + expect(extractBashCommands('NODE_ENV=test npm test && git push')).toEqual(['npm', 'git']) + }) + + it('skips command wrapper prefixes', () => { + expect(extractBashCommands('rtk git status')).toEqual(['git']) + expect(extractBashCommands('sudo npm install')).toEqual(['npm']) + expect(extractBashCommands('npx vitest --run')).toEqual(['vitest']) + }) + + it('skips prefix combined with env var assignment', () => { + expect(extractBashCommands('DEBUG=1 rtk git status')).toEqual(['git']) + }) + + it('skips nested wrapper prefixes', () => { + expect(extractBashCommands('sudo npx vitest --run')).toEqual(['vitest']) + }) + + it('skips prefix across chained commands', () => { + expect(extractBashCommands('rtk git add . && rtk git commit -m "msg"')).toEqual(['git', 'git']) + }) + + it('keeps a standalone prefix with no following command', () => { + expect(extractBashCommands('rtk')).toEqual(['rtk']) + expect(extractBashCommands('sudo')).toEqual(['sudo']) + }) + + it('keeps prefix when the next token is a flag', () => { + expect(extractBashCommands('nice -n 10 git push')).toEqual(['nice']) + }) + + it('skips env assignment that follows a wrapper prefix', () => { + expect(extractBashCommands('sudo NODE_ENV=production node server.js')).toEqual(['node']) + expect(extractBashCommands('time FOO=1 make build')).toEqual(['make']) + }) + + it('keeps prefix when the next token is quoted', () => { + expect(extractBashCommands('npx "@angular/cli" new app')).toEqual(['npx']) + expect(extractBashCommands("npx 'ts-node' script.ts")).toEqual(['npx']) + }) +}) + +describe('BASH_TOOLS', () => { + it('recognizes Bash', () => { expect(BASH_TOOLS.has('Bash')).toBe(true) }) + it('recognizes BashTool', () => { expect(BASH_TOOLS.has('BashTool')).toBe(true) }) + it('rejects unknown tools', () => { expect(BASH_TOOLS.has('Read')).toBe(false) }) +}) diff --git a/tests/blob-to-text.test.ts b/tests/blob-to-text.test.ts new file mode 100644 index 0000000..aeb7ce3 --- /dev/null +++ b/tests/blob-to-text.test.ts @@ -0,0 +1,53 @@ +import { describe, it, expect } from 'vitest' +import { blobToText, isSqliteBusyError } from '../src/sqlite.js' + +describe('blobToText', () => { + it('returns empty string for null', () => { + expect(blobToText(null)).toBe('') + }) + + it('returns empty string for undefined', () => { + expect(blobToText(undefined)).toBe('') + }) + + it('passes through strings unchanged', () => { + expect(blobToText('hello world')).toBe('hello world') + }) + + it('decodes valid UTF-8 Uint8Array', () => { + const buf = new TextEncoder().encode('café ☕') + expect(blobToText(buf)).toBe('café ☕') + }) + + it('replaces invalid UTF-8 bytes with U+FFFD instead of crashing', () => { + const buf = new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x80, 0xfe]) + const result = blobToText(buf) + expect(result).toContain('Hello') + expect(result).toContain('�') + }) + + it('handles truncated multi-byte sequence', () => { + // é in UTF-8 is [0xc3, 0xa9]. Truncate to just [0xc3]. + const buf = new Uint8Array([0x63, 0x61, 0x66, 0xc3]) + const result = blobToText(buf) + expect(result).toBe('caf�') + }) + + it('handles empty Uint8Array', () => { + expect(blobToText(new Uint8Array(0))).toBe('') + }) +}) + +describe('isSqliteBusyError', () => { + it('detects node:sqlite busy errors by errcode', () => { + expect(isSqliteBusyError({ code: 'ERR_SQLITE_ERROR', errcode: 5, errstr: 'database is locked' })).toBe(true) + }) + + it('detects sqlite locked messages', () => { + expect(isSqliteBusyError(new Error('SQLITE_LOCKED: database table is locked'))).toBe(true) + }) + + it('ignores unrelated sqlite errors', () => { + expect(isSqliteBusyError(new Error('no such table: session'))).toBe(false) + }) +}) diff --git a/tests/classifier.test.ts b/tests/classifier.test.ts new file mode 100644 index 0000000..3ef82b5 --- /dev/null +++ b/tests/classifier.test.ts @@ -0,0 +1,196 @@ +import { describe, it, expect } from 'vitest' + +import { classifyTurn } from '../src/classifier.js' +import type { ParsedApiCall, ParsedTurn } from '../src/types.js' + +function makeCall(opts: Partial<ParsedApiCall> & { tools?: string[]; skills?: string[] }): ParsedApiCall { + const tools = opts.tools ?? [] + return { + provider: 'claude', + model: 'Opus 4.7', + usage: { + inputTokens: 0, + outputTokens: 0, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + }, + costUSD: 0, + tools, + mcpTools: tools.filter(t => t.startsWith('mcp__')), + skills: opts.skills ?? [], + hasAgentSpawn: tools.includes('Agent'), + hasPlanMode: tools.includes('EnterPlanMode'), + speed: 'standard', + timestamp: '2026-05-04T00:00:00Z', + bashCommands: [], + deduplicationKey: 'k', + ...opts, + } +} + +function makeTurn(calls: ParsedApiCall[], userMessage = ''): ParsedTurn { + return { + userMessage, + assistantCalls: calls, + timestamp: '2026-05-04T00:00:00Z', + sessionId: 's1', + } +} + +describe('classifyTurn — Skill subCategory', () => { + it('attaches subCategory when a Skill tool fires alone (input.skill)', () => { + const turn = makeTurn([makeCall({ tools: ['Skill'], skills: ['init'] })]) + const c = classifyTurn(turn) + expect(c.category).toBe('general') + expect(c.subCategory).toBe('init') + }) + + it('attaches subCategory when skill identifier comes via input.name (extracted upstream)', () => { + const turn = makeTurn([makeCall({ tools: ['Skill'], skills: ['atelier'] })]) + const c = classifyTurn(turn) + expect(c.category).toBe('general') + expect(c.subCategory).toBe('atelier') + }) + + it('uses the first skill identifier when a single turn invokes multiple skills', () => { + const turn = makeTurn([makeCall({ tools: ['Skill', 'Skill'], skills: ['review', 'security-review'] })]) + const c = classifyTurn(turn) + expect(c.category).toBe('general') + expect(c.subCategory).toBe('review') + }) + + it('aggregates skills across multiple assistant calls in the same turn', () => { + const turn = makeTurn([ + makeCall({ tools: ['Skill'], skills: ['claude-api'] }), + makeCall({ tools: ['Skill'], skills: ['init'] }), + ]) + const c = classifyTurn(turn) + expect(c.category).toBe('general') + expect(c.subCategory).toBe('claude-api') + }) + + it('does not attach subCategory when the Skill tool fires but no skill name was extracted', () => { + const turn = makeTurn([makeCall({ tools: ['Skill'], skills: [] })]) + const c = classifyTurn(turn) + expect(c.category).toBe('general') + expect(c.subCategory).toBeUndefined() + }) + + it('does not attach subCategory when category is not general (e.g. Skill alongside Edit promotes to coding)', () => { + const turn = makeTurn([makeCall({ tools: ['Skill', 'Edit'], skills: ['init'] })]) + const c = classifyTurn(turn) + expect(c.category).toBe('coding') + expect(c.subCategory).toBeUndefined() + }) + + it('does not attach subCategory for non-Skill general turns', () => { + const turn = makeTurn([makeCall({ tools: [] })], 'just chatting') + const c = classifyTurn(turn) + expect(c.subCategory).toBeUndefined() + }) + + it('tolerates missing skills field on legacy ParsedApiCall shape', () => { + const baseCall = makeCall({ tools: ['Skill'], skills: ['init'] }) + const legacyCall = { ...baseCall } as unknown as ParsedApiCall & { skills?: string[] } + delete (legacyCall as { skills?: string[] }).skills + const c = classifyTurn(makeTurn([legacyCall])) + expect(c.category).toBe('general') + expect(c.subCategory).toBeUndefined() + }) +}) + +// Regression coverage for issue #196: feature verbs that lead a message +// were previously hijacked into 'debugging' just because the message contained +// an incidental "error" / "fix" / "issue" word later in the same sentence. +// Now whichever keyword pattern matches earliest wins. +describe('classifyTurn — feature vs debugging precedence (#196)', () => { + function codingTurn(userMessage: string): ParsedTurn { + return makeTurn([makeCall({ tools: ['Edit'] })], userMessage) + } + + it('classifies "add error handling" as feature, not debugging', () => { + const c = classifyTurn(codingTurn('add error handling to the auth module')) + expect(c.category).toBe('feature') + }) + + it('classifies "create an issue tracker" as feature, not debugging', () => { + const c = classifyTurn(codingTurn('create an issue tracker page in the dashboard')) + expect(c.category).toBe('feature') + }) + + it('classifies "implement the 404 page" as feature, not debugging', () => { + const c = classifyTurn(codingTurn('implement the 404 page with a friendly redirect')) + expect(c.category).toBe('feature') + }) + + it('still classifies "fix the layout for the new feature" as debugging', () => { + const c = classifyTurn(codingTurn('fix the layout for the new feature')) + expect(c.category).toBe('debugging') + }) + + it('still classifies a plain bug report as debugging', () => { + const c = classifyTurn(codingTurn('login is broken, traceback below')) + expect(c.category).toBe('debugging') + }) + + it('classifies "refactor the error handling" as refactoring', () => { + const c = classifyTurn(codingTurn('refactor the error handling so it is cleaner')) + expect(c.category).toBe('refactoring') + }) + + it('chat-only message starting with "add" stays feature even with "fix" later', () => { + const c = classifyTurn(makeTurn([], 'add a setting page; we will fix the styles after')) + expect(c.category).toBe('feature') + }) + + it('chat-only message starting with "fix" stays debugging even with "add" later', () => { + const c = classifyTurn(makeTurn([], 'fix the bug introduced when we added the new flag')) + expect(c.category).toBe('debugging') + }) +}) + +describe('classifyTurn — retry detection via toolSequence', () => { + it('detects retries from multi-call turns (Claude-style)', () => { + const turn = makeTurn([ + makeCall({ tools: ['Edit'] }), + makeCall({ tools: ['Bash'] }), + makeCall({ tools: ['Edit'] }), + ], 'fix the build') + const c = classifyTurn(turn) + expect(c.retries).toBe(1) + }) + + it('detects retries from toolSequence on a single call (Kiro/Goose-style)', () => { + const call = makeCall({ tools: ['Edit', 'Bash'] }) + call.toolSequence = [[{ tool: 'Edit' }], [{ tool: 'Bash' }], [{ tool: 'Edit' }]] + const turn = makeTurn([call], 'fix the build') + const c = classifyTurn(turn) + expect(c.retries).toBe(1) + }) + + it('returns 0 retries for single call without toolSequence', () => { + const call = makeCall({ tools: ['Edit', 'Bash'] }) + const turn = makeTurn([call], 'fix the build') + const c = classifyTurn(turn) + expect(c.retries).toBe(0) + }) + + it('counts multiple retries from toolSequence', () => { + const call = makeCall({ tools: ['Edit', 'Bash'] }) + call.toolSequence = [[{ tool: 'Edit' }], [{ tool: 'Bash' }], [{ tool: 'Edit' }], [{ tool: 'Bash' }], [{ tool: 'Edit' }]] + const turn = makeTurn([call], 'fix the build') + const c = classifyTurn(turn) + expect(c.retries).toBe(2) + }) + + it('ignores toolSequence with only one step', () => { + const call = makeCall({ tools: ['Edit', 'Bash'] }) + call.toolSequence = [[{ tool: 'Edit' }, { tool: 'Bash' }]] + const turn = makeTurn([call], 'fix the build') + const c = classifyTurn(turn) + expect(c.retries).toBe(0) + }) +}) diff --git a/tests/cli-date.test.ts b/tests/cli-date.test.ts new file mode 100644 index 0000000..f553c70 --- /dev/null +++ b/tests/cli-date.test.ts @@ -0,0 +1,169 @@ +import { afterEach, describe, it, expect, vi } from 'vitest' +import { + getDateRange, + PERIODS, + PERIOD_LABELS, + parsePeriodOrThrow, + periodInfoFromQuery, + toPeriod, + type Period, +} from '../src/cli-date.js' + +afterEach(() => { + vi.useRealTimers() +}) + +describe('getDateRange', () => { + it('"all" is bounded to the last 6 months, not epoch', () => { + const { range, label } = getDateRange('all') + const now = new Date() + + expect(label).toBe('Last 6 months') + + // Regression guard: must never silently fall back to epoch (the old + // dashboard bug) or any pre-2000 date. + expect(range.start.getFullYear()).toBeGreaterThan(2000) + + const monthsDiff = + (now.getFullYear() - range.start.getFullYear()) * 12 + + (now.getMonth() - range.start.getMonth()) + expect(monthsDiff).toBe(6) + expect(range.start.getDate()).toBe(1) + + // End is today, end of day. + expect(range.end.getHours()).toBe(23) + expect(range.end.getMinutes()).toBe(59) + }) + + it('"all" does not overflow past the target month at end-of-month', () => { + vi.useFakeTimers() + vi.setSystemTime(new Date(2026, 7, 31, 12, 0, 0)) + + const { range } = getDateRange('all') + + expect(range.start.getFullYear()).toBe(2026) + expect(range.start.getMonth()).toBe(1) + expect(range.start.getDate()).toBe(1) + }) + + it('"week" returns the last 7 days', () => { + const { range, label } = getDateRange('week') + expect(label).toBe('Last 7 Days') + // start = midnight 7 days ago, end = today 23:59:59.999 -> ~8 days span. + const diffDays = (range.end.getTime() - range.start.getTime()) / (1000 * 60 * 60 * 24) + expect(diffDays).toBeGreaterThanOrEqual(7) + expect(diffDays).toBeLessThanOrEqual(8) + }) + + it('"month" starts on day 1 of the current month', () => { + const { range } = getDateRange('month') + expect(range.start.getDate()).toBe(1) + expect(range.start.getHours()).toBe(0) + }) + + it('"30days" returns 30 days back', () => { + const { range, label } = getDateRange('30days') + expect(label).toBe('Last 30 Days') + const diffDays = (range.end.getTime() - range.start.getTime()) / (1000 * 60 * 60 * 24) + expect(diffDays).toBeGreaterThanOrEqual(30) + expect(diffDays).toBeLessThanOrEqual(31) + }) + + it('"today" starts at local midnight', () => { + const { range } = getDateRange('today') + expect(range.start.getHours()).toBe(0) + expect(range.start.getMinutes()).toBe(0) + expect(range.end.getHours()).toBe(23) + }) + + it('"yesterday" is supported (CLI-only convenience)', () => { + const { range, label } = getDateRange('yesterday') + expect(label).toMatch(/^Yesterday/) + expect(range.start.getHours()).toBe(0) + expect(range.end.getHours()).toBe(23) + }) + + it('unknown period exits with an error instead of silently falling back', () => { + expect(() => getDateRange('not-a-period')).toThrow() + }) +}) + +describe('PERIODS / PERIOD_LABELS', () => { + it('exposes the expected period set', () => { + expect(PERIODS).toEqual(['today', 'week', '30days', 'month', 'all']) + }) + + it('has a label for every period', () => { + for (const p of PERIODS) { + expect(PERIOD_LABELS[p]).toBeTruthy() + } + }) + + it('"all" tab label reflects the 6-month bound', () => { + // Short label used in the dashboard tab strip. The long-form label + // ("Last 6 months") comes from getDateRange().label. + expect(PERIOD_LABELS.all).toBe('6 Months') + }) +}) + +describe('parsePeriodOrThrow', () => { + it('round-trips known periods', () => { + const known: Period[] = ['today', 'week', '30days', 'month', 'all'] + for (const p of known) { + expect(parsePeriodOrThrow(p)).toBe(p) + } + }) + + it('throws on unknown input without calling process.exit', () => { + const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') }) + try { + expect(() => parsePeriodOrThrow('garbage')).toThrow(/Unknown period "garbage"/) + expect(exitSpy).not.toHaveBeenCalled() + } finally { + exitSpy.mockRestore() + } + }) +}) + +describe('periodInfoFromQuery', () => { + it('resolves a named period', () => { + const info = periodInfoFromQuery({ period: 'week' }, 'month') + expect(info.label).toBe('Last 7 Days') + }) + + it('throws for an invalid period without calling process.exit', () => { + const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') }) + try { + expect(() => periodInfoFromQuery({ period: 'garbage' }, 'month')).toThrow(/Unknown period "garbage"/) + expect(exitSpy).not.toHaveBeenCalled() + } finally { + exitSpy.mockRestore() + } + }) +}) + +describe('toPeriod', () => { + it('round-trips known periods', () => { + const known: Period[] = ['today', 'week', '30days', 'month', 'all'] + for (const p of known) { + expect(toPeriod(p)).toBe(p) + } + }) + + it('exits with an error on unknown input instead of silently falling back', () => { + // Previously toPeriod silently fell back to 'week' for any unrecognized + // value, which let typos like `-p mounth` produce a quiet 7-day report + // while the user thought they were viewing the month. The new behavior + // is to fail loudly via process.exit(1) after writing to stderr. + const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') }) as unknown as ReturnType<typeof vi.spyOn> + const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true) + try { + expect(() => toPeriod('garbage')).toThrow('exit') + expect(exitSpy).toHaveBeenCalledWith(1) + expect(stderrSpy).toHaveBeenCalled() + } finally { + exitSpy.mockRestore() + stderrSpy.mockRestore() + } + }) +}) diff --git a/tests/cli-deepseek-v4-pricing.test.ts b/tests/cli-deepseek-v4-pricing.test.ts new file mode 100644 index 0000000..02407d0 --- /dev/null +++ b/tests/cli-deepseek-v4-pricing.test.ts @@ -0,0 +1,133 @@ +import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { spawnSync } from 'node:child_process' + +import { describe, expect, it } from 'vitest' + +function runCli(args: string[], home: string) { + return spawnSync(process.execPath, ['--import', 'tsx', 'src/cli.ts', ...args], { + cwd: process.cwd(), + env: { + ...process.env, + CLAUDE_CONFIG_DIR: join(home, '.claude'), + HOME: home, + TZ: 'UTC', + }, + encoding: 'utf-8', + timeout: 30_000, + }) +} + +function userLine(content: string, timestamp: string): string { + return JSON.stringify({ + type: 'user', + sessionId: 'deepseek-v4-session', + timestamp, + cwd: '/tmp/deepseek-v4-validation', + message: { role: 'user', content }, + }) +} + +function assistantLine(model: string, timestamp: string, messageId: string, usage: Record<string, number>): string { + return JSON.stringify({ + type: 'assistant', + sessionId: 'deepseek-v4-session', + timestamp, + cwd: '/tmp/deepseek-v4-validation', + message: { + id: messageId, + type: 'message', + role: 'assistant', + model, + content: [ + { type: 'text', text: 'updated pricing code' }, + { type: 'tool_use', id: `tu-${messageId}`, name: 'Edit', input: { file_path: '/tmp/deepseek-v4-validation/pricing.ts', old_string: 'old', new_string: 'new' } }, + ], + usage, + }, + }) +} + +describe('CLI DeepSeek v4 Claude pricing regression', () => { + it('prices DeepSeek v4 Claude sessions even when the runtime LiteLLM cache lacks those models', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-deepseek-v4-cli-')) + + try { + const projectDir = join(home, '.claude', 'projects', 'deepseek-v4-validation') + const cacheDir = join(home, '.cache', 'codeburn') + await mkdir(projectDir, { recursive: true }) + await mkdir(cacheDir, { recursive: true }) + + await writeFile(join(cacheDir, 'litellm-pricing.json'), JSON.stringify({ + timestamp: Date.now(), + data: { + 'gpt-4o-mini': { + inputCostPerToken: 1.5e-7, + outputCostPerToken: 6e-7, + cacheWriteCostPerToken: 0, + cacheReadCostPerToken: 7.5e-8, + webSearchCostPerRequest: 0.01, + fastMultiplier: 1, + }, + }, + })) + + await writeFile( + join(projectDir, 'session.jsonl'), + [ + userLine('Use DeepSeek v4 through the Claude-compatible endpoint.', '2026-05-20T10:00:00.000Z'), + assistantLine('deepseek-v4-pro', '2026-05-20T10:01:00.000Z', 'deepseek-v4-pro', { + input_tokens: 2_477_914, + output_tokens: 762_994, + cache_read_input_tokens: 258_556_928, + cache_creation_input_tokens: 0, + }), + userLine('Validate the flash model path too.', '2026-05-20T10:02:00.000Z'), + assistantLine('deepseek-v4-flash', '2026-05-20T10:03:00.000Z', 'deepseek-v4-flash', { + input_tokens: 1_552_573, + output_tokens: 353_914, + cache_read_input_tokens: 48_388_608, + cache_creation_input_tokens: 0, + }), + ].join('\n') + '\n', + ) + + const result = runCli([ + '--format', 'json', + '--from', '2026-05-20', + '--to', '2026-05-20', + '--provider', 'claude', + ], home) + + expect(result.status, `stderr: ${result.stderr}`).toBe(0) + + const report = JSON.parse(result.stdout) as { + overview: { cost: number; calls: number; tokens: { cacheRead: number } } + models: Array<{ name: string; cost: number; calls: number; inputTokens: number; outputTokens: number; cacheReadTokens: number }> + } + const pro = report.models.find(m => m.name === 'DeepSeek v4 Pro') + const flash = report.models.find(m => m.name === 'DeepSeek v4 Flash') + + expect(report.overview.calls).toBe(2) + expect(report.overview.tokens.cacheRead).toBe(306_945_536) + expect(report.overview.cost).toBeCloseTo(3.13091, 5) + + expect(pro).toBeDefined() + expect(pro!.calls).toBe(1) + expect(pro!.inputTokens).toBe(2_477_914) + expect(pro!.outputTokens).toBe(762_994) + expect(pro!.cacheReadTokens).toBe(258_556_928) + expect(pro!.cost).toBeCloseTo(2.678966, 6) + + expect(flash).toBeDefined() + expect(flash!.calls).toBe(1) + expect(flash!.inputTokens).toBe(1_552_573) + expect(flash!.outputTokens).toBe(353_914) + expect(flash!.cacheReadTokens).toBe(48_388_608) + expect(flash!.cost).toBeCloseTo(0.451944, 6) + } finally { + await rm(home, { recursive: true, force: true }) + } + }) +}) diff --git a/tests/cli-devin-model-variants.test.ts b/tests/cli-devin-model-variants.test.ts new file mode 100644 index 0000000..007146e --- /dev/null +++ b/tests/cli-devin-model-variants.test.ts @@ -0,0 +1,98 @@ +import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { spawnSync } from 'node:child_process' + +import { describe, expect, it } from 'vitest' + +function runCli(args: string[], home: string) { + return spawnSync(process.execPath, ['--import', 'tsx', 'src/cli.ts', ...args], { + cwd: process.cwd(), + env: { + ...process.env, + HOME: home, + USERPROFILE: home, + HOMEPATH: home, + HOMEDRIVE: '', + CLAUDE_CONFIG_DIR: join(home, '.claude'), + CODEBURN_CACHE_DIR: join(home, '.cache', 'codeburn'), + TZ: 'UTC', + }, + encoding: 'utf-8', + timeout: 30_000, + }) +} + +describe('codeburn report Devin model variants', () => { + it('keeps friendly Devin effort-tier names in JSON model rows and efficiency rows', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-devin-models-')) + try { + await mkdir(join(home, '.config', 'codeburn'), { recursive: true }) + await writeFile(join(home, '.config', 'codeburn', 'config.json'), JSON.stringify({ + devin: { acuUsdRate: 1 }, + })) + + const transcriptsDir = join(home, '.local', 'share', 'devin', 'cli', 'transcripts') + await mkdir(transcriptsDir, { recursive: true }) + await writeFile(join(transcriptsDir, 'session-487.json'), JSON.stringify({ + schema_version: '1.4', + session_id: 'session-487', + agent: { model_name: 'GPT-5.4' }, + steps: [ + { + step_id: 1, + message: 'fix the model row', + metadata: { is_user_input: true, created_at: '2026-04-10T09:00:00.000Z' }, + }, + { + step_id: 2, + message: 'editing', + tool_calls: [{ function_name: 'Edit' }], + metadata: { + created_at: '2026-04-10T09:01:00.000Z', + committed_acu_cost: 0.25, + generation_model: 'gpt-5-3-codex-xhigh', + metrics: { input_tokens: 100, output_tokens: 25 }, + }, + }, + ], + })) + + const result = runCli([ + 'report', + '--format', + 'json', + '--from', + '2026-04-10', + '--to', + '2026-04-10', + '--provider', + 'devin', + ], home) + + expect(result.status, result.stderr).toBe(0) + const report = JSON.parse(result.stdout) as { + models: Array<{ + name: string + calls: number + cost: number + editTurns: number + oneShotTurns: number + costPerEdit: number | null + }> + } + + expect(report.models).toHaveLength(1) + expect(report.models[0]).toMatchObject({ + name: 'GPT-5.3 Codex (xhigh)', + calls: 1, + cost: 0.25, + editTurns: 1, + oneShotTurns: 1, + costPerEdit: 0.25, + }) + } finally { + await rm(home, { recursive: true, force: true }) + } + }) +}) diff --git a/tests/cli-export-date-range.test.ts b/tests/cli-export-date-range.test.ts new file mode 100644 index 0000000..73d9e4b --- /dev/null +++ b/tests/cli-export-date-range.test.ts @@ -0,0 +1,96 @@ +import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { spawnSync } from 'node:child_process' + +import { describe, expect, it } from 'vitest' + +function runCli(args: string[], home: string) { + return spawnSync(process.execPath, ['--import', 'tsx', 'src/cli.ts', ...args], { + cwd: process.cwd(), + env: { + ...process.env, + CLAUDE_CONFIG_DIR: join(home, '.claude'), + HOME: home, + TZ: 'UTC', + }, + encoding: 'utf-8', + }) +} + +function userLine(sessionId: string, timestamp: string): string { + return JSON.stringify({ + type: 'user', + sessionId, + timestamp, + message: { role: 'user', content: 'add feature' }, + }) +} + +function assistantLine(sessionId: string, timestamp: string, messageId: string): string { + return JSON.stringify({ + type: 'assistant', + sessionId, + timestamp, + message: { + id: messageId, + type: 'message', + role: 'assistant', + model: 'claude-sonnet-4-5', + content: [{ type: 'text', text: 'done' }], + usage: { + input_tokens: 1000, + output_tokens: 100, + }, + }, + }) +} + +describe('codeburn export custom date range', () => { + it('exports a single custom period filtered by --from/--to', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-export-')) + + try { + const projectDir = join(home, '.claude', 'projects', 'app') + await mkdir(projectDir, { recursive: true }) + await writeFile( + join(projectDir, 'in-range.jsonl'), + [ + userLine('in-range', '2026-04-10T09:00:00Z'), + assistantLine('in-range', '2026-04-10T09:01:00Z', 'msg-in-range'), + ].join('\n'), + ) + await writeFile( + join(projectDir, 'out-of-range.jsonl'), + [ + userLine('out-of-range', '2026-04-11T09:00:00Z'), + assistantLine('out-of-range', '2026-04-11T09:01:00Z', 'msg-out-of-range'), + ].join('\n'), + ) + + const outputPath = join(home, 'custom-export.json') + const result = runCli([ + 'export', + '--format', 'json', + '--from', '2026-04-10', + '--to', '2026-04-10', + '--provider', 'claude', + '--output', outputPath, + ], home) + + expect(result.status).toBe(0) + expect(result.stdout).toContain('Exported (2026-04-10 to 2026-04-10)') + + const exported = JSON.parse(await readFile(outputPath, 'utf-8')) as { + summary: Array<{ Period: string; Sessions: number }> + sessions: Array<{ 'Session ID': string }> + } + expect(exported.summary).toHaveLength(1) + expect(exported.summary[0]?.Period).toBe('2026-04-10 to 2026-04-10') + expect(exported.summary[0]?.Sessions).toBe(1) + expect(exported.sessions.map(s => s['Session ID'])).toEqual(['in-range']) + } finally { + await rm(home, { recursive: true, force: true }) + } + }) +}) diff --git a/tests/cli-json-daily.test.ts b/tests/cli-json-daily.test.ts new file mode 100644 index 0000000..34ad500 --- /dev/null +++ b/tests/cli-json-daily.test.ts @@ -0,0 +1,237 @@ +import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { spawnSync } from 'node:child_process' + +import { describe, expect, it } from 'vitest' + +function runCli(args: string[], home: string) { + return spawnSync(process.execPath, ['--import', 'tsx', 'src/cli.ts', ...args], { + cwd: process.cwd(), + env: { + ...process.env, + CLAUDE_CONFIG_DIR: join(home, '.claude'), + HOME: home, + TZ: 'UTC', + }, + encoding: 'utf-8', + }) +} + +function userLine(sessionId: string, timestamp: string): string { + return JSON.stringify({ + type: 'user', + sessionId, + timestamp, + message: { role: 'user', content: 'do the thing' }, + }) +} + +function assistantEditLine(sessionId: string, timestamp: string, messageId: string): string { + // Includes a tool_use of `Edit` so the parser flags this turn as hasEdits=true. + // Single edit-turn with no retry (one assistant message in the turn) → counts + // as one oneShotTurn. + return JSON.stringify({ + type: 'assistant', + sessionId, + timestamp, + message: { + id: messageId, + type: 'message', + role: 'assistant', + model: 'claude-sonnet-4-5', + content: [ + { type: 'text', text: 'editing' }, + { type: 'tool_use', id: 'tu-1', name: 'Edit', input: { file_path: '/tmp/x', old_string: 'a', new_string: 'b' } }, + ], + usage: { input_tokens: 1000, output_tokens: 100 }, + }, + }) +} + +function assistantNoEditLine(sessionId: string, timestamp: string, messageId: string): string { + // No edit tool — this turn does not count toward editTurns/oneShotTurns, + // but does count toward `turns` and `calls`. + return JSON.stringify({ + type: 'assistant', + sessionId, + timestamp, + message: { + id: messageId, + type: 'message', + role: 'assistant', + model: 'claude-sonnet-4-5', + content: [{ type: 'text', text: 'just chatting' }], + usage: { input_tokens: 200, output_tokens: 30 }, + }, + }) +} + +describe('codeburn report --format json daily[] one-shot fields (issue #279)', () => { + it('exposes per-day turns / editTurns / oneShotTurns / oneShotRate', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-json-daily-')) + + try { + const projectDir = join(home, '.claude', 'projects', 'app') + await mkdir(projectDir, { recursive: true }) + + // Day 1 (2026-04-10): one edit-turn (one-shot), one chat-turn + // Day 2 (2026-04-11): one edit-turn (one-shot) + await writeFile( + join(projectDir, 'session.jsonl'), + [ + userLine('s1', '2026-04-10T09:00:00Z'), + assistantEditLine('s1', '2026-04-10T09:01:00Z', 'm-d1-edit'), + userLine('s1', '2026-04-10T10:00:00Z'), + assistantNoEditLine('s1', '2026-04-10T10:01:00Z', 'm-d1-chat'), + userLine('s1', '2026-04-11T09:00:00Z'), + assistantEditLine('s1', '2026-04-11T09:01:00Z', 'm-d2-edit'), + ].join('\n'), + ) + + const result = runCli([ + '--format', 'json', + '--from', '2026-04-10', + '--to', '2026-04-11', + '--provider', 'claude', + ], home) + + expect(result.status).toBe(0) + + const report = JSON.parse(result.stdout) as { + daily: Array<{ + date: string + cost: number + calls: number + turns: number + editTurns: number + oneShotTurns: number + oneShotRate: number | null + }> + } + + expect(report.daily).toHaveLength(2) + + const day1 = report.daily.find(d => d.date === '2026-04-10') + expect(day1).toBeDefined() + expect(day1!.turns).toBe(2) + expect(day1!.editTurns).toBe(1) + expect(day1!.oneShotTurns).toBe(1) + expect(day1!.oneShotRate).toBe(100) + + const day2 = report.daily.find(d => d.date === '2026-04-11') + expect(day2).toBeDefined() + expect(day2!.turns).toBe(1) + expect(day2!.editTurns).toBe(1) + expect(day2!.oneShotTurns).toBe(1) + expect(day2!.oneShotRate).toBe(100) + } finally { + await rm(home, { recursive: true, force: true }) + } + }) + + it('reports null oneShotRate when the day has no edit turns', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-json-daily-')) + + try { + const projectDir = join(home, '.claude', 'projects', 'app') + await mkdir(projectDir, { recursive: true }) + + await writeFile( + join(projectDir, 'chat-only.jsonl'), + [ + userLine('s2', '2026-04-10T09:00:00Z'), + assistantNoEditLine('s2', '2026-04-10T09:01:00Z', 'm-chat-1'), + userLine('s2', '2026-04-10T09:30:00Z'), + assistantNoEditLine('s2', '2026-04-10T09:31:00Z', 'm-chat-2'), + ].join('\n'), + ) + + const result = runCli([ + '--format', 'json', + '--from', '2026-04-10', + '--to', '2026-04-10', + '--provider', 'claude', + ], home) + + expect(result.status).toBe(0) + const report = JSON.parse(result.stdout) as { + daily: Array<{ date: string; turns: number; editTurns: number; oneShotTurns: number; oneShotRate: number | null }> + } + const day = report.daily.find(d => d.date === '2026-04-10')! + expect(day.turns).toBe(2) + expect(day.editTurns).toBe(0) + expect(day.oneShotTurns).toBe(0) + // null, not 0 — the rate is undefined when no edits happened, and a + // chat-only day would otherwise read as 0% one-shot which is misleading. + expect(day.oneShotRate).toBeNull() + } finally { + await rm(home, { recursive: true, force: true }) + } + }) + + it('filters a single review day with --day', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-json-day-')) + + try { + const projectDir = join(home, '.claude', 'projects', 'app') + await mkdir(projectDir, { recursive: true }) + + // runCli pins TZ=UTC, so these exact boundaries exercise the inclusive + // start/end of the selected calendar day without local-offset drift. + await writeFile( + join(projectDir, 'day-selector.jsonl'), + [ + userLine('day-before', '2026-04-09T23:59:00Z'), + assistantNoEditLine('day-before', '2026-04-09T23:59:30Z', 'm-before'), + userLine('day-selected', '2026-04-10T00:00:00Z'), + assistantEditLine('day-selected', '2026-04-10T23:59:59Z', 'm-selected'), + userLine('day-after', '2026-04-11T00:00:00Z'), + assistantNoEditLine('day-after', '2026-04-11T00:00:30Z', 'm-after'), + ].join('\n'), + ) + + const result = runCli([ + '--format', 'json', + '--day', '2026-04-10', + '--provider', 'claude', + ], home) + + expect(result.status).toBe(0) + const report = JSON.parse(result.stdout) as { + period: string + periodKey: string + daily: Array<{ date: string; calls: number; editTurns: number }> + projects: Array<{ sessions: number; calls: number }> + } + + expect(report.period).toBe('Day (2026-04-10)') + expect(report.periodKey).toBe('day') + expect(report.daily.map(d => d.date)).toEqual(['2026-04-10']) + expect(report.daily[0]?.calls).toBe(1) + expect(report.daily[0]?.editTurns).toBe(1) + expect(report.projects[0]?.sessions).toBe(1) + expect(report.projects[0]?.calls).toBe(1) + } finally { + await rm(home, { recursive: true, force: true }) + } + }) + + it('rejects --day combined with --from/--to', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-json-day-')) + + try { + const result = runCli([ + '--format', 'json', + '--day', '2026-04-10', + '--from', '2026-04-10', + '--provider', 'claude', + ], home) + + expect(result.status).toBe(1) + expect(result.stderr).toContain('--day cannot be combined with --from or --to') + } finally { + await rm(home, { recursive: true, force: true }) + } + }) +}) diff --git a/tests/cli-model-savings.test.ts b/tests/cli-model-savings.test.ts new file mode 100644 index 0000000..e492ecb --- /dev/null +++ b/tests/cli-model-savings.test.ts @@ -0,0 +1,76 @@ +import { mkdtemp, readFile, rm } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { spawnSync } from 'node:child_process' + +import { describe, it, expect } from 'vitest' + +const CLI_TIMEOUT_MS = 10_000 + +function runCli(args: string[], home: string) { + return spawnSync(process.execPath, ['--import', 'tsx', 'src/cli.ts', ...args], { + cwd: process.cwd(), + env: { + ...process.env, + HOME: home, + USERPROFILE: home, + HOMEPATH: home, + HOMEDRIVE: '', + }, + encoding: 'utf-8', + }) +} + +function readConfig(home: string): Promise<Record<string, unknown>> { + return readFile(join(home, '.config', 'codeburn', 'config.json'), 'utf-8') + .then(raw => JSON.parse(raw) as Record<string, unknown>) +} + +describe('codeburn model-savings command', () => { + it('saves, lists, and removes a local-model savings mapping', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-savings-')) + try { + const set = runCli(['model-savings', 'llama3.1:8b', 'gpt-4o'], home) + expect(set.status).toBe(0) + expect(set.stdout).toContain('llama3.1:8b -> gpt-4o') + + const saved = await readConfig(home) + expect(saved.localModelSavings).toEqual({ 'llama3.1:8b': 'gpt-4o' }) + + const list = runCli(['model-savings', '--list'], home) + expect(list.status).toBe(0) + expect(list.stdout).toContain('llama3.1:8b -> gpt-4o') + + const remove = runCli(['model-savings', '--remove', 'llama3.1:8b'], home) + expect(remove.status).toBe(0) + + const after = await readConfig(home) + expect(after.localModelSavings).toBeUndefined() + } finally { + await rm(home, { recursive: true, force: true }) + } + }, CLI_TIMEOUT_MS) + + it('warns when the same model is also configured in modelAliases', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-savings-')) + try { + expect(runCli(['model-alias', 'llama3.1:8b', 'gpt-4o'], home).status).toBe(0) + const set = runCli(['model-savings', 'llama3.1:8b', 'gpt-4o'], home) + expect(set.status).toBe(0) + expect(set.stdout).toContain('savings take precedence') + } finally { + await rm(home, { recursive: true, force: true }) + } + }, CLI_TIMEOUT_MS) + + it('rejects a remove for an unknown mapping', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-savings-')) + try { + const result = runCli(['model-savings', '--remove', 'unknown:1b'], home) + expect(result.status).toBe(1) + expect(result.stderr).toContain('No savings mapping found') + } finally { + await rm(home, { recursive: true, force: true }) + } + }, CLI_TIMEOUT_MS) +}) diff --git a/tests/cli-plan.test.ts b/tests/cli-plan.test.ts new file mode 100644 index 0000000..14e2b12 --- /dev/null +++ b/tests/cli-plan.test.ts @@ -0,0 +1,150 @@ +import { mkdtemp, readFile, rm } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { spawnSync } from 'node:child_process' + +import { describe, it, expect } from 'vitest' + +const CLI_PLAN_TIMEOUT_MS = 10_000 + +function runCli(args: string[], home: string) { + return spawnSync(process.execPath, ['--import', 'tsx', 'src/cli.ts', ...args], { + cwd: process.cwd(), + env: { + ...process.env, + HOME: home, + USERPROFILE: home, // os.homedir() uses USERPROFILE on Windows + HOMEPATH: home, + HOMEDRIVE: '', + }, + encoding: 'utf-8', + }) +} + +describe('codeburn plan command', () => { + it('persists provider-keyed plans and clears on reset', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-plan-')) + + try { + const setResult = runCli(['plan', 'set', 'claude-max'], home) + expect(setResult.status).toBe(0) + + const setCodexResult = runCli(['plan', 'set', 'custom', '--monthly-usd', '200', '--provider', 'codex'], home) + expect(setCodexResult.status).toBe(0) + + const configPath = join(home, '.config', 'codeburn', 'config.json') + const configRaw = await readFile(configPath, 'utf-8') + const config = JSON.parse(configRaw) as { plans?: { claude?: { id?: string; monthlyUsd?: number }; codex?: { id?: string; monthlyUsd?: number } } } + expect(config.plans?.claude?.id).toBe('claude-max') + expect(config.plans?.claude?.monthlyUsd).toBe(200) + expect(config.plans?.codex?.id).toBe('custom') + expect(config.plans?.codex?.monthlyUsd).toBe(200) + + const resetResult = runCli(['plan', 'reset'], home) + expect(resetResult.status).toBe(0) + + const afterResetRaw = await readFile(configPath, 'utf-8') + const afterReset = JSON.parse(afterResetRaw) as { plan?: unknown; plans?: unknown } + expect(afterReset.plan).toBeUndefined() + expect(afterReset.plans).toBeUndefined() + } finally { + await rm(home, { recursive: true, force: true }) + } + }, CLI_PLAN_TIMEOUT_MS) + + it('resets one provider without removing other plans', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-plan-')) + + try { + expect(runCli(['plan', 'set', 'claude-max'], home).status).toBe(0) + expect(runCli(['plan', 'set', 'custom', '--monthly-usd', '200', '--provider', 'codex'], home).status).toBe(0) + expect(runCli(['plan', 'reset', '--provider', 'codex'], home).status).toBe(0) + + const configPath = join(home, '.config', 'codeburn', 'config.json') + const configRaw = await readFile(configPath, 'utf-8') + const config = JSON.parse(configRaw) as { plans?: { claude?: { id?: string }; codex?: unknown } } + expect(config.plans?.claude?.id).toBe('claude-max') + expect(config.plans?.codex).toBeUndefined() + } finally { + await rm(home, { recursive: true, force: true }) + } + }, CLI_PLAN_TIMEOUT_MS) + + it('resets the all-provider plan without removing provider-specific plans', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-plan-')) + + try { + expect(runCli(['plan', 'set', 'claude-max'], home).status).toBe(0) + expect(runCli(['plan', 'reset', '--provider', 'all'], home).status).toBe(0) + + const configPath = join(home, '.config', 'codeburn', 'config.json') + const configRaw = await readFile(configPath, 'utf-8') + const config = JSON.parse(configRaw) as { plans?: { claude?: { id?: string }; all?: unknown } } + expect(config.plans?.claude?.id).toBe('claude-max') + expect(config.plans?.all).toBeUndefined() + } finally { + await rm(home, { recursive: true, force: true }) + } + }, CLI_PLAN_TIMEOUT_MS) + + it('shows all configured plans as json', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-plan-')) + + try { + expect(runCli(['plan', 'set', 'claude-max'], home).status).toBe(0) + expect(runCli(['plan', 'set', 'custom', '--monthly-usd', '200', '--provider', 'codex'], home).status).toBe(0) + + const result = runCli(['plan', '--format', 'json'], home) + expect(result.status).toBe(0) + const payload = JSON.parse(result.stdout) as { id?: string; provider?: string; plans?: { claude?: { id?: string }; codex?: { id?: string } } } + expect(payload.id).toBe('claude-max') + expect(payload.provider).toBe('claude') + expect(payload.plans?.claude?.id).toBe('claude-max') + expect(payload.plans?.codex?.id).toBe('custom') + } finally { + await rm(home, { recursive: true, force: true }) + } + }, CLI_PLAN_TIMEOUT_MS) + + it('filters shown plans by provider', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-plan-')) + + try { + expect(runCli(['plan', 'set', 'claude-max'], home).status).toBe(0) + expect(runCli(['plan', 'set', 'custom', '--monthly-usd', '200', '--provider', 'codex'], home).status).toBe(0) + + const result = runCli(['plan', '--format', 'json', '--provider', 'codex'], home) + expect(result.status).toBe(0) + const payload = JSON.parse(result.stdout) as { id?: string; provider?: string; plans?: unknown } + expect(payload.id).toBe('custom') + expect(payload.provider).toBe('codex') + expect(payload.plans).toMatchObject({ codex: { id: 'custom' } }) + } finally { + await rm(home, { recursive: true, force: true }) + } + }, CLI_PLAN_TIMEOUT_MS) + + it('rejects all-provider scope for preset plans', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-plan-')) + + try { + const result = runCli(['plan', 'set', 'claude-max', '--provider', 'all'], home) + expect(result.status).toBe(1) + expect(result.stderr).toContain('omit --provider or use --provider claude') + } finally { + await rm(home, { recursive: true, force: true }) + } + }, CLI_PLAN_TIMEOUT_MS) + + it('shows invalid reset-day value in error output', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-plan-')) + + try { + const result = runCli(['plan', 'set', 'claude-max', '--reset-day', '99'], home) + expect(result.status).toBe(1) + expect(result.stderr).toContain('--reset-day must be an integer from 1 to 28; got 99.') + } finally { + await rm(home, { recursive: true, force: true }) + } + }, CLI_PLAN_TIMEOUT_MS) +}) diff --git a/tests/cli-price-override.test.ts b/tests/cli-price-override.test.ts new file mode 100644 index 0000000..cdbea13 --- /dev/null +++ b/tests/cli-price-override.test.ts @@ -0,0 +1,85 @@ +import { mkdtemp, readFile, rm } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { spawnSync } from 'node:child_process' + +import { describe, it, expect } from 'vitest' + +const CLI_TIMEOUT_MS = 10_000 + +function runCli(args: string[], home: string) { + return spawnSync(process.execPath, ['--import', 'tsx', 'src/cli.ts', ...args], { + cwd: process.cwd(), + env: { + ...process.env, + HOME: home, + USERPROFILE: home, + HOMEPATH: home, + HOMEDRIVE: '', + }, + encoding: 'utf-8', + }) +} + +function readConfig(home: string): Promise<Record<string, unknown>> { + return readFile(join(home, '.config', 'codeburn', 'config.json'), 'utf-8') + .then(raw => JSON.parse(raw) as Record<string, unknown>) +} + +describe('codeburn price-override command', () => { + it('saves, lists, and removes a model price override', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-price-override-')) + try { + const set = runCli([ + 'price-override', + 'unpriced-provider/test-model', + '--input', + '0.27', + '--output', + '1.10', + '--cache-read', + '0.03', + '--cache-creation', + '0.42', + ], home) + expect(set.status).toBe(0) + expect(set.stdout).toContain('unpriced-provider/test-model') + expect(set.stdout).toContain('USD per 1,000,000 tokens') + + const saved = await readConfig(home) + expect(saved.priceOverrides).toEqual({ + 'unpriced-provider/test-model': { + input: 0.27, + output: 1.1, + cacheRead: 0.03, + cacheCreation: 0.42, + }, + }) + + const list = runCli(['price-override', '--list'], home) + expect(list.status).toBe(0) + expect(list.stdout).toContain('unpriced-provider/test-model') + expect(list.stdout).toContain('input 0.27') + expect(list.stdout).toContain('output 1.1') + + const remove = runCli(['price-override', '--remove', 'unpriced-provider/test-model'], home) + expect(remove.status).toBe(0) + + const after = await readConfig(home) + expect(after.priceOverrides).toBeUndefined() + } finally { + await rm(home, { recursive: true, force: true }) + } + }, CLI_TIMEOUT_MS) + + it('rejects an invalid rate', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-cli-price-override-')) + try { + const result = runCli(['price-override', 'bad-rate-model', '--input', 'abc', '--output', '1'], home) + expect(result.status).toBe(1) + expect(result.stderr).toContain('Invalid --input') + } finally { + await rm(home, { recursive: true, force: true }) + } + }, CLI_TIMEOUT_MS) +}) diff --git a/tests/cli-provider-validation.test.ts b/tests/cli-provider-validation.test.ts new file mode 100644 index 0000000..4fa9089 --- /dev/null +++ b/tests/cli-provider-validation.test.ts @@ -0,0 +1,72 @@ +import { mkdtemp, rm } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { spawnSync } from 'node:child_process' + +import { afterEach, describe, expect, it } from 'vitest' + +import { allProviderNames, getAllProviders } from '../src/providers/index.js' + +let homes: string[] = [] + +afterEach(async () => { + while (homes.length > 0) { + const h = homes.pop() + if (h) await rm(h, { recursive: true, force: true }) + } +}) + +async function makeHome(): Promise<string> { + const home = await mkdtemp(join(tmpdir(), 'codeburn-provider-cli-')) + homes.push(home) + return home +} + +function runCli(args: string[], home: string) { + return spawnSync(process.execPath, ['--import', 'tsx', 'src/cli.ts', ...args], { + cwd: process.cwd(), + env: { ...process.env, HOME: home, CLAUDE_CONFIG_DIR: join(home, '.claude'), TZ: 'UTC' }, + encoding: 'utf-8', + timeout: 30_000, + }) +} + +describe('allProviderNames', () => { + it('is non-empty, sorted, and excludes the "all" sentinel', () => { + const names = allProviderNames() + expect(names.length).toBeGreaterThan(0) + expect([...names]).toEqual([...names].sort()) + expect(names).not.toContain('all') + }) + + it('covers every loadable provider (guards against lazy-list drift)', async () => { + const loaded = (await getAllProviders()).map(p => p.name) + const names = allProviderNames() + for (const name of loaded) { + expect(names).toContain(name) + } + }) +}) + +describe('codeburn --provider validation', () => { + it('rejects an unknown provider with a clear error and exit 1', async () => { + const home = await makeHome() + const res = runCli(['report', '--provider', 'claud', '-p', 'today'], home) + expect(res.status).toBe(1) + expect(res.stderr).toContain('unknown provider "claud"') + expect(res.stderr).toContain('Valid values: all,') + }) + + it('accepts a valid provider', async () => { + const home = await makeHome() + const res = runCli(['status', '--provider', 'claude', '--format', 'json'], home) + expect(res.status).toBe(0) + expect(res.stderr).not.toContain('unknown provider') + }) + + it('accepts the "all" sentinel', async () => { + const home = await makeHome() + const res = runCli(['status', '--provider', 'all', '--format', 'json'], home) + expect(res.status).toBe(0) + }) +}) diff --git a/tests/cli-proxy-path.test.ts b/tests/cli-proxy-path.test.ts new file mode 100644 index 0000000..85b354c --- /dev/null +++ b/tests/cli-proxy-path.test.ts @@ -0,0 +1,154 @@ +import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { spawnSync } from 'node:child_process' + +import { afterEach, describe, expect, it, vi } from 'vitest' + +// Each test spawns `tsx src/cli.ts` several times, which re-transpiles the CLI +// on every spawn. Under full-suite parallel load those spawns contend for CPU +// and can exceed the 5s default, so give this spawn-based file a timeout that +// matches the per-spawn cap below. The slowest test runs ~1.7s in isolation. +vi.setConfig({ testTimeout: 30_000 }) + +let homes: string[] = [] + +afterEach(async () => { + while (homes.length > 0) { + const h = homes.pop() + if (h) await rm(h, { recursive: true, force: true }) + } +}) + +async function makeHome(): Promise<string> { + const home = await mkdtemp(join(tmpdir(), 'codeburn-proxy-cli-')) + homes.push(home) + return home +} + +function runCli(args: string[], home: string) { + return spawnSync(process.execPath, ['--import', 'tsx', 'src/cli.ts', ...args], { + cwd: process.cwd(), + env: { ...process.env, HOME: home, CLAUDE_CONFIG_DIR: join(home, '.claude'), TZ: 'UTC' }, + encoding: 'utf-8', + timeout: 30_000, + }) +} + +const configPath = (home: string) => join(home, '.config', 'codeburn', 'config.json') +async function readConfig(home: string): Promise<Record<string, unknown>> { + return JSON.parse(await readFile(configPath(home), 'utf-8')) +} +async function writeConfig(home: string, obj: unknown): Promise<void> { + await mkdir(join(home, '.config', 'codeburn'), { recursive: true }) + await writeFile(configPath(home), JSON.stringify(obj), 'utf-8') +} + +describe('codeburn proxy-path CLI', () => { + it('adds, lists, dedupes, and removes a proxy path', async () => { + const home = await makeHome() + + expect(runCli(['proxy-path', '--list'], home).stdout).toContain('No proxy paths configured') + + const add = runCli(['proxy-path', '/work/copilot-repo'], home) + expect(add.status).toBe(0) + expect(add.stdout).toContain('Proxy path saved') + expect((await readConfig(home)).proxyPaths).toEqual(['/work/copilot-repo']) + + // Trailing-slash variant is the same path -> deduped, not a second entry. + const dup = runCli(['proxy-path', '/work/copilot-repo/'], home) + expect(dup.stdout).toContain('already configured') + expect((await readConfig(home)).proxyPaths).toEqual(['/work/copilot-repo']) + + expect(runCli(['proxy-path', '--list'], home).stdout).toContain('/work/copilot-repo') + + const rm = runCli(['proxy-path', '--remove', '/work/copilot-repo'], home) + expect(rm.status).toBe(0) + expect((await readConfig(home)).proxyPaths).toBeUndefined() + }) + + it('rejects a relative path and the filesystem root', async () => { + const home = await makeHome() + const rel = runCli(['proxy-path', './rel'], home) + expect(rel.status).toBe(1) + expect(rel.stderr).toContain('absolute') + + const root = runCli(['proxy-path', '/'], home) + expect(root.status).toBe(1) + }) + + it('errors (exit 1) when removing a path that is not configured', async () => { + const home = await makeHome() + const res = runCli(['proxy-path', '--remove', '/not/configured'], home) + expect(res.status).toBe(1) + expect(res.stderr).toContain('No proxy path found') + }) + + it('does not crash on a malformed config (proxyPaths as a non-array)', async () => { + const home = await makeHome() + await writeConfig(home, { proxyPaths: 42 }) + + const list = runCli(['proxy-path', '--list'], home) + expect(list.status).toBe(0) + expect(list.stderr).not.toMatch(/TypeError|is not iterable|is not a function/) + expect(list.stdout).toContain('No proxy paths configured') + + const add = runCli(['proxy-path', '/work/repo'], home) + expect(add.status).toBe(0) + expect(add.stderr).not.toMatch(/TypeError/) + // The garbage was discarded; only the valid absolute path persists. + expect((await readConfig(home)).proxyPaths).toEqual(['/work/repo']) + }) + + it('does not crash on a malformed config (proxyPaths array with non-string entries)', async () => { + const home = await makeHome() + await writeConfig(home, { proxyPaths: [42, null, '/work/keep'] }) + const add = runCli(['proxy-path', '/work/new'], home) + expect(add.status).toBe(0) + expect(add.stderr).not.toMatch(/TypeError|is not a function/) + expect((await readConfig(home)).proxyPaths).toEqual(['/work/keep', '/work/new']) + }) +}) + +describe('codeburn report --format json: proxy overview', () => { + async function writeClaudeSession(home: string, cwd: string): Promise<void> { + const dir = join(home, '.claude', 'projects', 'proxied') + await mkdir(dir, { recursive: true }) + const ts = new Date().toISOString() + const line = JSON.stringify({ + type: 'assistant', sessionId: 's1', timestamp: ts, cwd, + message: { + id: 'm1', type: 'message', role: 'assistant', model: 'claude-sonnet-4-6', + content: [{ type: 'text', text: 'hi' }], + usage: { input_tokens: 10000, output_tokens: 2000, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 }, + }, + }) + await writeFile(join(dir, 's1.jsonl'), line + '\n', 'utf-8') + } + + function overview(home: string): { cost: number; proxiedCost: number; netCost: number } { + const res = runCli(['report', '--period', 'all', '--format', 'json'], home) + expect(res.status).toBe(0) + return JSON.parse(res.stdout).overview + } + + it('reports proxiedCost == cost and netCost == 0 under a proxy path, and netCost == cost without one', async () => { + const home = await makeHome() + const cwd = '/proj/proxiedrepo' + await writeClaudeSession(home, cwd) + + // Baseline: no proxy config -> nothing attributed, net == cost. + const base = overview(home) + expect(base.cost).toBeGreaterThan(0) + expect(base.proxiedCost).toBe(0) + expect(base.netCost).toBeCloseTo(base.cost, 10) + + // With the proxy path -> full cost preserved, fully subscription-covered. + await writeConfig(home, { proxyPaths: [cwd] }) + const proxied = overview(home) + expect(proxied.cost).toBeCloseTo(base.cost, 10) // cost is never modified + expect(proxied.proxiedCost).toBeCloseTo(proxied.cost, 10) + expect(proxied.netCost).toBeCloseTo(0, 10) + expect(proxied.netCost).toBeCloseTo(proxied.cost - proxied.proxiedCost, 10) + }) +}) diff --git a/tests/cli-status-menubar.test.ts b/tests/cli-status-menubar.test.ts new file mode 100644 index 0000000..0ff96d9 --- /dev/null +++ b/tests/cli-status-menubar.test.ts @@ -0,0 +1,643 @@ +import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { delimiter as pathDelimiter, join } from 'node:path' +import { spawnSync } from 'node:child_process' + +import { describe, expect, it } from 'vitest' + +function runCli(args: string[], home: string, extraEnv: Record<string, string | undefined> = {}) { + return spawnSync(process.execPath, ['--import', 'tsx', 'src/cli.ts', ...args], { + cwd: process.cwd(), + env: { + ...process.env, + CLAUDE_CONFIG_DIR: join(home, '.claude'), + CODEBURN_CACHE_DIR: join(home, '.cache', 'codeburn'), + HOME: home, + TZ: 'UTC', + ...extraEnv, + }, + encoding: 'utf-8', + timeout: 30_000, + }) +} + +function userLine(sessionId: string, timestamp: string): string { + return JSON.stringify({ + type: 'user', + sessionId, + timestamp, + message: { role: 'user', content: 'do the thing' }, + }) +} + +function assistantLine(sessionId: string, timestamp: string, messageId: string): string { + return JSON.stringify({ + type: 'assistant', + sessionId, + timestamp, + message: { + id: messageId, + type: 'message', + role: 'assistant', + model: 'claude-sonnet-4-5', + content: [ + { type: 'text', text: 'done' }, + { type: 'tool_use', id: 'tu-1', name: 'Edit', input: { file_path: '/tmp/x', old_string: 'a', new_string: 'b' } }, + ], + usage: { input_tokens: 500, output_tokens: 50 }, + }, + }) +} + +describe('codeburn status --format menubar-json', () => { + it('returns valid MenubarPayload with expected top-level fields', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-')) + + try { + const projectDir = join(home, '.claude', 'projects', 'myapp') + await mkdir(projectDir, { recursive: true }) + + const now = new Date() + const h = now.getUTCHours() + const base = h >= 2 ? new Date(now.getTime() - 2 * 3600_000) : new Date(now.getTime() - h * 3600_000 - 300_000) + const ts1 = base.toISOString().replace(/\.\d+Z$/, 'Z') + const ts2 = new Date(base.getTime() + 60_000).toISOString().replace(/\.\d+Z$/, 'Z') + const ts3 = new Date(base.getTime() + 120_000).toISOString().replace(/\.\d+Z$/, 'Z') + const ts4 = new Date(base.getTime() + 180_000).toISOString().replace(/\.\d+Z$/, 'Z') + + await writeFile( + join(projectDir, 'session.jsonl'), + [ + userLine('s1', ts1), + assistantLine('s1', ts2, 'msg-1'), + userLine('s1', ts3), + assistantLine('s1', ts4, 'msg-2'), + ].join('\n'), + ) + + const result = runCli([ + 'status', + '--format', 'menubar-json', + '--period', 'today', + '--provider', 'all', + '--no-optimize', + ], home) + + expect(result.status, `stderr: ${result.stderr}`).toBe(0) + + const payload = JSON.parse(result.stdout) as Record<string, unknown> + + expect(payload).toHaveProperty('generated') + expect(payload).toHaveProperty('current') + expect(payload).toHaveProperty('optimize') + expect(payload).toHaveProperty('history') + + const current = payload['current'] as Record<string, unknown> + expect(current['cost']).toBeGreaterThan(0) + expect(current['calls']).toBe(2) + expect(current['sessions']).toBe(1) + expect(current).toHaveProperty('oneShotRate') + expect(current).toHaveProperty('topActivities') + expect(current).toHaveProperty('topModels') + expect(current).toHaveProperty('providers') + + const history = payload['history'] as { daily: unknown[] } + expect(Array.isArray(history.daily)).toBe(true) + } finally { + await rm(home, { recursive: true, force: true }) + } + }) + + it('filters menubar payloads to a selected review day with --day', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-day-')) + + try { + const projectDir = join(home, '.claude', 'projects', 'myapp') + await mkdir(projectDir, { recursive: true }) + + await writeFile( + join(projectDir, 'session.jsonl'), + [ + userLine('before', '2026-04-09T23:58:00Z'), + assistantLine('before', '2026-04-09T23:59:00Z', 'msg-before'), + userLine('selected', '2026-04-10T11:59:00Z'), + assistantLine('selected', '2026-04-10T12:00:00Z', 'msg-selected'), + userLine('after', '2026-04-11T00:00:00Z'), + assistantLine('after', '2026-04-11T00:01:00Z', 'msg-after'), + ].join('\n'), + ) + + const result = runCli([ + 'status', + '--format', 'menubar-json', + '--day', '2026-04-10', + '--provider', 'all', + '--no-optimize', + ], home) + + expect(result.status, `stderr: ${result.stderr}`).toBe(0) + + const payload = JSON.parse(result.stdout) as { + current: { + label: string + calls: number + sessions: number + topProjects: Array<{ sessions: number; sessionDetails: Array<{ date: string }> }> + } + } + + expect(payload.current.label).toBe('Day (2026-04-10)') + expect(payload.current.calls).toBe(1) + expect(payload.current.sessions).toBe(1) + expect(payload.current.topProjects).toHaveLength(1) + expect(payload.current.topProjects[0]?.sessions).toBe(1) + expect(payload.current.topProjects[0]?.sessionDetails.map(s => s.date)).toEqual(['2026-04-10']) + } finally { + await rm(home, { recursive: true, force: true }) + } + }) + + it('filters the whole menubar payload to a selected Claude config source', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-claude-config-')) + + try { + const work = join(home, 'claude-work') + const personal = join(home, 'claude-personal') + const slug = 'shared-app' + await mkdir(join(work, 'projects', slug), { recursive: true }) + await mkdir(join(personal, 'projects', slug), { recursive: true }) + + await writeFile( + join(work, 'projects', slug, 'work.jsonl'), + [ + userLine('work', '2026-04-10T11:59:00Z'), + assistantLine('work', '2026-04-10T12:00:00Z', 'msg-work'), + ].join('\n'), + ) + await writeFile( + join(personal, 'projects', slug, 'personal.jsonl'), + [ + userLine('personal', '2026-04-10T12:59:00Z'), + assistantLine('personal', '2026-04-10T13:00:00Z', 'msg-personal'), + ].join('\n'), + ) + + const env = { CLAUDE_CONFIG_DIRS: [work, personal].join(pathDelimiter) } + const allResult = runCli([ + 'status', + '--format', 'menubar-json', + '--period', 'all', + '--provider', 'all', + '--no-optimize', + ], home, env) + + expect(allResult.status, `stderr: ${allResult.stderr}`).toBe(0) + const allPayload = JSON.parse(allResult.stdout) as { + current: { calls: number; sessions: number } + claudeConfigs?: { selectedId: string | null; options: Array<{ id: string; label: string; path: string }> } + } + expect(allPayload.current.calls).toBe(2) + expect(allPayload.current.sessions).toBe(2) + expect(allPayload.claudeConfigs?.selectedId).toBeNull() + expect(allPayload.claudeConfigs?.options.map(o => o.label).sort()).toEqual(['claude-personal', 'claude-work']) + + const workSourceId = allPayload.claudeConfigs!.options.find(o => o.label === 'claude-work')!.id + const workResult = runCli([ + 'status', + '--format', 'menubar-json', + '--period', 'all', + '--provider', 'all', + '--claude-config-source', workSourceId, + '--no-optimize', + ], home, env) + + expect(workResult.status, `stderr: ${workResult.stderr}`).toBe(0) + const workPayload = JSON.parse(workResult.stdout) as { + current: { calls: number; sessions: number; providers: Record<string, number> } + history: { daily: Array<{ calls: number }> } + claudeConfigs?: { selectedId: string | null } + } + expect(workPayload.claudeConfigs?.selectedId).toBe(workSourceId) + expect(workPayload.current.calls).toBe(1) + expect(workPayload.current.sessions).toBe(1) + expect(Object.keys(workPayload.current.providers)).toEqual(['claude']) + expect(workPayload.history.daily.reduce((sum, d) => sum + d.calls, 0)).toBe(1) + + const invalidResult = runCli([ + 'status', + '--format', 'menubar-json', + '--period', 'all', + '--provider', 'all', + '--claude-config-source', 'claude-config:missing', + '--no-optimize', + ], home, env) + + expect(invalidResult.status, `stderr: ${invalidResult.stderr}`).toBe(0) + const invalidPayload = JSON.parse(invalidResult.stdout) as { + current: { calls: number } + claudeConfigs?: { selectedId: string | null } + } + expect(invalidPayload.current.calls).toBe(2) + expect(invalidPayload.claudeConfigs?.selectedId).toBeNull() + } finally { + await rm(home, { recursive: true, force: true }) + } + }) + + it('keeps idle Claude config options visible for the selected period', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-claude-config-idle-')) + + try { + const work = join(home, 'claude-work') + const personal = join(home, 'claude-personal') + await mkdir(join(work, 'projects', 'app'), { recursive: true }) + await mkdir(join(personal, 'projects', 'app'), { recursive: true }) + + await writeFile( + join(work, 'projects', 'app', 'work.jsonl'), + [ + userLine('work', '2026-04-10T11:59:00Z'), + assistantLine('work', '2026-04-10T12:00:00Z', 'msg-work'), + ].join('\n'), + ) + await writeFile( + join(personal, 'projects', 'app', 'personal.jsonl'), + [ + userLine('personal', '2026-04-09T11:59:00Z'), + assistantLine('personal', '2026-04-09T12:00:00Z', 'msg-personal'), + ].join('\n'), + ) + + const env = { CLAUDE_CONFIG_DIRS: [work, personal].join(pathDelimiter) } + const allResult = runCli([ + 'status', + '--format', 'menubar-json', + '--day', '2026-04-10', + '--provider', 'all', + '--no-optimize', + ], home, env) + + expect(allResult.status, `stderr: ${allResult.stderr}`).toBe(0) + const allPayload = JSON.parse(allResult.stdout) as { + current: { calls: number } + claudeConfigs?: { options: Array<{ id: string; label: string }> } + } + expect(allPayload.current.calls).toBe(1) + expect(allPayload.claudeConfigs?.options.map(o => o.label).sort()).toEqual(['claude-personal', 'claude-work']) + + const personalSourceId = allPayload.claudeConfigs!.options.find(o => o.label === 'claude-personal')!.id + const personalResult = runCli([ + 'status', + '--format', 'menubar-json', + '--day', '2026-04-10', + '--provider', 'all', + '--claude-config-source', personalSourceId, + '--no-optimize', + ], home, env) + + expect(personalResult.status, `stderr: ${personalResult.stderr}`).toBe(0) + const personalPayload = JSON.parse(personalResult.stdout) as { + current: { calls: number; sessions: number; providers: Record<string, number> } + claudeConfigs?: { selectedId: string | null } + } + expect(personalPayload.claudeConfigs?.selectedId).toBe(personalSourceId) + expect(personalPayload.current.calls).toBe(0) + expect(personalPayload.current.sessions).toBe(0) + expect(personalPayload.current.providers).toEqual({ claude: 0 }) + } finally { + await rm(home, { recursive: true, force: true }) + } + }) + + it('rejects --claude-config-source combined with a non-Claude --provider', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-cfg-provider-')) + try { + const work = join(home, 'claude-work') + const personal = join(home, 'claude-personal') + await mkdir(join(work, 'projects', 'app'), { recursive: true }) + await mkdir(join(personal, 'projects', 'app'), { recursive: true }) + const env = { CLAUDE_CONFIG_DIRS: [work, personal].join(pathDelimiter) } + + const result = runCli([ + 'status', '--format', 'menubar-json', '--period', 'all', + '--provider', 'codex', '--claude-config-source', 'claude-config:whatever', + '--no-optimize', + ], home, env) + + expect(result.status).not.toBe(0) + expect(result.stderr).toContain('--claude-config-source cannot be combined with --provider codex') + + // 'claude' is allowed (a config scopes Claude usage). + const okClaude = runCli([ + 'status', '--format', 'menubar-json', '--period', 'all', + '--provider', 'claude', '--no-optimize', + ], home, env) + expect(okClaude.status, `stderr: ${okClaude.stderr}`).toBe(0) + } finally { + await rm(home, { recursive: true, force: true }) + } + }) + + it('surfaces Claude Desktop sessions as their own bucket so config sum equals All', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-desktop-')) + try { + const work = join(home, 'claude-work') + const personal = join(home, 'claude-personal') + await mkdir(join(work, 'projects', 'app'), { recursive: true }) + await mkdir(join(personal, 'projects', 'app'), { recursive: true }) + await writeFile(join(work, 'projects', 'app', 'w.jsonl'), + [userLine('w', '2026-04-10T11:59:00Z'), assistantLine('w', '2026-04-10T12:00:00Z', 'mw')].join('\n')) + await writeFile(join(personal, 'projects', 'app', 'p.jsonl'), + [userLine('p', '2026-04-10T12:59:00Z'), assistantLine('p', '2026-04-10T13:00:00Z', 'mp')].join('\n')) + + // A fake Claude Desktop sessions tree. + const desktop = join(home, 'desktop-sessions') + const dProj = join(desktop, 'appid', 'ws', 'local_s1', '.claude', 'projects', 'space') + await mkdir(dProj, { recursive: true }) + await writeFile(join(dProj, 'd.jsonl'), + [userLine('d', '2026-04-10T13:59:00Z'), assistantLine('d', '2026-04-10T14:00:00Z', 'md')].join('\n')) + + const env = { + CLAUDE_CONFIG_DIRS: [work, personal].join(pathDelimiter), + CODEBURN_DESKTOP_SESSIONS_DIR: desktop, + } + const result = runCli([ + 'status', '--format', 'menubar-json', '--period', 'all', '--provider', 'all', '--no-optimize', + ], home, env) + expect(result.status, `stderr: ${result.stderr}`).toBe(0) + const payload = JSON.parse(result.stdout) as { + current: { calls: number } + claudeConfigs?: { options: Array<{ id: string; label: string }> } + } + // 3 sessions total: work + personal + desktop. + expect(payload.current.calls).toBe(3) + // The selector lists all three, including a Claude Desktop bucket. + const labels = payload.claudeConfigs?.options.map(o => o.label).sort() + expect(labels).toContain('Claude Desktop') + expect(labels).toHaveLength(3) + } finally { + await rm(home, { recursive: true, force: true }) + } + }) + + it('includes LingTai TUI usage and activity categories in menubar payloads', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-lingtai-')) + + try { + const lingtaiHome = join(home, '.lingtai') + const agentDir = join(lingtaiHome, 'agent') + await mkdir(join(agentDir, 'logs'), { recursive: true }) + await writeFile(join(agentDir, '.agent.json'), JSON.stringify({ + agent_id: 'agent-1', + agent_name: 'LingTai Agent', + llm: { model: 'gpt-4o' }, + })) + + const now = new Date() + const h = now.getUTCHours() + const base = h >= 2 ? new Date(now.getTime() - 2 * 3600_000) : new Date(now.getTime() - h * 3600_000 - 300_000) + const ts1 = base.toISOString().replace(/\.\d+Z$/, 'Z') + const ts2 = new Date(base.getTime() + 60_000).toISOString().replace(/\.\d+Z$/, 'Z') + const ts3 = new Date(base.getTime() + 120_000).toISOString().replace(/\.\d+Z$/, 'Z') + + await writeFile( + join(agentDir, 'logs', 'token_ledger.jsonl'), + [ + JSON.stringify({ source: 'main', ts: ts1, input: 1000, cached: 100, output: 100, model: 'gpt-4o' }), + JSON.stringify({ source: 'tc_wake', ts: ts2, input: 2000, cached: 500, output: 200, model: 'gpt-4o' }), + JSON.stringify({ source: 'summarize_apriori', ts: ts3, input: 1500, cached: 300, output: 150, model: 'gpt-4o' }), + ].join('\n') + '\n', + ) + + const result = runCli([ + 'status', + '--format', 'menubar-json', + '--period', 'today', + '--provider', 'lingtai-tui', + '--no-optimize', + ], home, { + LINGTAI_HOME: lingtaiHome, + LINGTAI_TUI_GLOBAL_DIR: join(home, '.lingtai-tui'), + }) + + expect(result.status, `stderr: ${result.stderr}`).toBe(0) + + const payload = JSON.parse(result.stdout) as { + current: { + cost: number + calls: number + providers: Record<string, number> + topActivities: Array<{ name: string; turns: number }> + } + } + + expect(payload.current.cost).toBeGreaterThan(0) + expect(payload.current.calls).toBe(3) + expect(payload.current.providers['lingtai tui']).toBeGreaterThan(0) + expect(payload.current.topActivities.map(a => a.name).sort()).toEqual([ + 'Conversation', + 'Delegation', + 'Planning', + ]) + } finally { + await rm(home, { recursive: true, force: true }) + } + }) + + it('attaches combined local-only usage for --scope combined and omits it for local scope', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-combined-')) + + try { + const projectDir = join(home, '.claude', 'projects', 'myapp') + await mkdir(projectDir, { recursive: true }) + + const now = new Date() + const h = now.getUTCHours() + const base = h >= 2 ? new Date(now.getTime() - 2 * 3600_000) : new Date(now.getTime() - h * 3600_000 - 300_000) + const ts1 = base.toISOString().replace(/\.\d+Z$/, 'Z') + const ts2 = new Date(base.getTime() + 60_000).toISOString().replace(/\.\d+Z$/, 'Z') + + await writeFile( + join(projectDir, 'session.jsonl'), + [ + userLine('s1', ts1), + assistantLine('s1', ts2, 'msg-1'), + ].join('\n'), + ) + + const combinedResult = runCli([ + 'status', + '--format', 'menubar-json', + '--scope', 'combined', + '--period', 'today', + '--provider', 'all', + '--no-optimize', + ], home) + + expect(combinedResult.status, `stderr: ${combinedResult.stderr}`).toBe(0) + + const payload = JSON.parse(combinedResult.stdout) as { + current: { + cost: number + calls: number + sessions: number + inputTokens: number + outputTokens: number + } + history: { + daily: Array<{ cacheWriteTokens?: number; cacheReadTokens?: number }> + } + combined?: { + perDevice: Array<{ + id: string + local: boolean + cost: number + calls: number + sessions: number + inputTokens: number + outputTokens: number + cacheCreateTokens: number + cacheReadTokens: number + totalTokens: number + }> + combined: { + cost: number + calls: number + sessions: number + inputTokens: number + outputTokens: number + cacheCreateTokens: number + cacheReadTokens: number + totalTokens: number + deviceCount: number + reachableCount: number + } + } + } + + expect(payload.combined).toBeDefined() + expect(payload.combined!.perDevice).toHaveLength(1) + const local = payload.combined!.perDevice[0]! + const cacheCreateTokens = payload.history.daily.reduce((sum, d) => sum + (d.cacheWriteTokens ?? 0), 0) + const cacheReadTokens = payload.history.daily.reduce((sum, d) => sum + (d.cacheReadTokens ?? 0), 0) + const totalTokens = payload.current.inputTokens + payload.current.outputTokens + cacheCreateTokens + cacheReadTokens + + expect(local).toMatchObject({ + id: 'local', + local: true, + cost: payload.current.cost, + calls: payload.current.calls, + sessions: payload.current.sessions, + inputTokens: payload.current.inputTokens, + outputTokens: payload.current.outputTokens, + cacheCreateTokens, + cacheReadTokens, + totalTokens, + }) + expect(payload.combined!.combined).toEqual({ + cost: payload.current.cost, + calls: payload.current.calls, + sessions: payload.current.sessions, + inputTokens: payload.current.inputTokens, + outputTokens: payload.current.outputTokens, + cacheCreateTokens, + cacheReadTokens, + totalTokens, + deviceCount: 1, + reachableCount: 1, + }) + + const localResult = runCli([ + 'status', + '--format', 'menubar-json', + '--scope', 'local', + '--period', 'today', + '--provider', 'all', + '--no-optimize', + ], home) + expect(localResult.status, `stderr: ${localResult.stderr}`).toBe(0) + expect(JSON.parse(localResult.stdout)).not.toHaveProperty('combined') + } finally { + await rm(home, { recursive: true, force: true }) + } + }) + + it.each([ + ['--provider', ['--provider', 'claude']], + ['--project', ['--project', 'x']], + ['--exclude', ['--exclude', 'y']], + ])('rejects combined scope with filtered local payloads from %s', async (_name, filterArgs) => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-combined-filter-')) + + try { + const result = runCli([ + 'status', + '--format', 'menubar-json', + '--scope', 'combined', + ...filterArgs, + '--no-optimize', + ], home) + + expect(result.status).toBe(1) + expect(result.stderr).toContain('error: --scope combined cannot be combined with --provider, --project, or --exclude (paired devices report unfiltered usage)') + } finally { + await rm(home, { recursive: true, force: true }) + } + }) + + it('rejects invalid menubar-json scope values', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-scope-')) + + try { + const result = runCli([ + 'status', + '--format', 'menubar-json', + '--scope', 'remote', + '--no-optimize', + ], home) + + expect(result.status).toBe(1) + expect(result.stderr).toContain('unknown scope "remote"') + } finally { + await rm(home, { recursive: true, force: true }) + } + }) + + it('still emits a valid combined menubar payload when the remotes store is corrupt', async () => { + const home = await mkdtemp(join(tmpdir(), 'codeburn-menubar-corrupt-remotes-')) + + try { + const projectDir = join(home, '.claude', 'projects', 'myapp') + await mkdir(projectDir, { recursive: true }) + const now = new Date() + const h = now.getUTCHours() + const base = h >= 2 ? new Date(now.getTime() - 2 * 3600_000) : new Date(now.getTime() - h * 3600_000 - 300_000) + const ts1 = base.toISOString().replace(/\.\d+Z$/, 'Z') + const ts2 = new Date(base.getTime() + 60_000).toISOString().replace(/\.\d+Z$/, 'Z') + await writeFile(join(projectDir, 'session.jsonl'), [userLine('s1', ts1), assistantLine('s1', ts2, 'msg-1')].join('\n')) + + // Corrupt the remotes store the combined path reads. The menubar must + // still get a valid payload (combined degrades to local-only). + const sharingDir = join(home, '.config', 'codeburn', 'sharing') + await mkdir(sharingDir, { recursive: true }) + await writeFile(join(sharingDir, 'remote-devices.json'), '{ this is : not valid json ]') + + const result = runCli([ + 'status', '--format', 'menubar-json', '--scope', 'combined', + '--period', 'today', '--no-optimize', + ], home) + + expect(result.status, `stderr: ${result.stderr}`).toBe(0) + const payload = JSON.parse(result.stdout) as { + current: { cost: number } + combined?: { perDevice: unknown[]; combined: { deviceCount: number; reachableCount: number } } + } + expect(payload.combined).toBeDefined() + expect(payload.combined!.perDevice).toHaveLength(1) + expect(payload.combined!.combined.deviceCount).toBe(1) + expect(payload.combined!.combined.reachableCount).toBe(1) + } finally { + await rm(home, { recursive: true, force: true }) + } + }) +}) diff --git a/tests/codex-cache-invalidation.test.ts b/tests/codex-cache-invalidation.test.ts new file mode 100644 index 0000000..cfba9c4 --- /dev/null +++ b/tests/codex-cache-invalidation.test.ts @@ -0,0 +1,108 @@ +// Regression for the codex stale-cache path (#478 follow-up, same class as +// the kiro bug #618/#619). session-cache.json serves unchanged session files +// without invoking the provider parser, so bumping CODEX_CACHE_VERSION alone +// does NOT re-attribute already-cached sessions. Registering `codex` in +// PROVIDER_PARSE_VERSIONS changes the provider envFingerprint, which discards +// the stale section and forces a re-parse. This exercises the full +// parseAllSessions pipeline against a cache seeded with the PRE-fix +// fingerprint and asserts the mcp-cli MCP attribution is recovered. + +import { describe, it, expect, beforeEach, afterAll, vi } from 'vitest' +import { mkdir, rm, readFile, writeFile } from 'fs/promises' +import { createHash } from 'crypto' +import { join } from 'path' + +import { clearSessionCache, parseAllSessions } from '../src/parser.js' + +const testRoot = vi.hoisted(() => { + const root = `${process.env['TMPDIR'] || '/tmp'}/codex-stale-repro-${process.pid}-${Date.now()}` + process.env['HOME'] = `${root}/home` + process.env['USERPROFILE'] = `${root}/home` + process.env['CODEX_HOME'] = `${root}/codex` + return root +}) + +const CODEX_HOME = join(testRoot, 'codex') +const CACHE_DIR = join(testRoot, 'cache') + +// computeEnvFingerprint('codex') as staged (no PROVIDER_PARSE_VERSIONS entry): +// hash of just CODEX_HOME. This is what sits in every existing user cache. +function preFixFingerprint(): string { + return createHash('sha256').update(`CODEX_HOME=${CODEX_HOME}`).digest('hex').slice(0, 16) +} + +beforeEach(() => { + process.env['HOME'] = join(testRoot, 'home') + process.env['USERPROFILE'] = join(testRoot, 'home') + process.env['CODEX_HOME'] = CODEX_HOME + process.env['CODEBURN_CACHE_DIR'] = CACHE_DIR +}) + +afterAll(async () => { + await rm(testRoot, { recursive: true, force: true }) +}) + +function allMcpServers(projects: Awaited<ReturnType<typeof parseAllSessions>>): string[] { + const servers: string[] = [] + for (const p of projects) { + for (const s of p.sessions) { + servers.push(...Object.keys(s.mcpBreakdown)) + } + } + return servers +} + +describe('codex parser change invalidates stale session-cache (#478/#513)', () => { + it('re-parses unchanged codex files after a parser attribution change', async () => { + const sessionDir = join(CODEX_HOME, 'sessions', '2026', '04', '14') + await mkdir(sessionDir, { recursive: true }) + await mkdir(CACHE_DIR, { recursive: true }) + const lines = [ + JSON.stringify({ type: 'session_meta', timestamp: '2026-04-14T10:00:00Z', payload: { session_id: 'sess-stale', model: 'gpt-5.5', cwd: '/Users/test/proj', originator: 'codex_cli_rs' } }), + JSON.stringify({ type: 'response_item', timestamp: '2026-04-14T10:00:10Z', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'call mcp via cli' }] } }), + JSON.stringify({ type: 'response_item', timestamp: '2026-04-14T10:00:30Z', payload: { type: 'function_call', name: 'exec_command', arguments: JSON.stringify({ command: "bash -lc \"mcp-cli call github get_issue '{}'\"" }) } }), + JSON.stringify({ type: 'event_msg', timestamp: '2026-04-14T10:01:00Z', payload: { type: 'token_count', info: { last_token_usage: { input_tokens: 300, output_tokens: 100 }, total_token_usage: { total_tokens: 400 } } } }), + ] + await writeFile(join(sessionDir, 'rollout-stale.jsonl'), lines.join('\n') + '\n') + + // Run 1: cold cache, fixed parser. MCP attribution present (sanity). + clearSessionCache() + const fresh = await parseAllSessions(undefined, 'codex') + expect(allMcpServers(fresh)).toContain('github') + + // Simulate a user whose session-cache.json was written by the PRE-fix + // release: pre-fix envFingerprint, unchanged file fingerprint, cached + // turns lack the mcp__ tool. Also reset codex-results.json to v4 so the + // provider (if it runs at all) must genuinely re-parse. + const cachePath = join(CACHE_DIR, 'session-cache.json') + const cache = JSON.parse(await readFile(cachePath, 'utf8')) + cache.providers.codex.envFingerprint = preFixFingerprint() + for (const f of Object.values(cache.providers.codex.files) as any[]) { + for (const turn of f.turns) { + for (const call of turn.calls) { + call.tools = call.tools.filter((t: string) => !t.startsWith('mcp__')) + if (call.toolSequence) { + call.toolSequence = call.toolSequence.filter((step: any[]) => !step.some(c => c.tool.startsWith('mcp__'))) + } + } + } + } + await writeFile(cachePath, JSON.stringify(cache)) + const codexCachePath = join(CACHE_DIR, 'codex-results.json') + const codexCache = JSON.parse(await readFile(codexCachePath, 'utf8')) + codexCache.version = 4 + for (const f of Object.values(codexCache.files) as any[]) { + for (const call of f.calls ?? []) { + call.tools = (call.tools ?? []).filter((t: string) => !t.startsWith('mcp__')) + } + } + await writeFile(codexCachePath, JSON.stringify(codexCache)) + + clearSessionCache() + const second = await parseAllSessions(undefined, 'codex') + // FIXED: `codex` is now in PROVIDER_PARSE_VERSIONS, so the pre-fix + // envFingerprint no longer matches, the stale section is discarded, the + // unchanged file re-parses, and the mcp-cli attribution reappears. + expect(allMcpServers(second)).toContain('github') + }) +}) diff --git a/tests/codex-credits.test.ts b/tests/codex-credits.test.ts new file mode 100644 index 0000000..cfa6c48 --- /dev/null +++ b/tests/codex-credits.test.ts @@ -0,0 +1,53 @@ +import { describe, expect, it } from 'vitest' +import { codexCredits, codexCreditRate } from '../src/codex-credits.js' + +describe('codexCreditRate', () => { + it('resolves the documented per-model rates', () => { + expect(codexCreditRate('gpt-5.5')).toEqual({ input: 125, cachedInput: 12.5, output: 750 }) + expect(codexCreditRate('gpt-5.4')).toEqual({ input: 62.5, cachedInput: 6.25, output: 375 }) + expect(codexCreditRate('gpt-5.4-mini')).toEqual({ input: 18.75, cachedInput: 1.875, output: 113 }) + }) + + it('tolerates codex suffix variants and casing', () => { + expect(codexCreditRate('GPT-5.5-codex')?.input).toBe(125) + expect(codexCreditRate('gpt-5.4-codex-mini')?.input).toBe(18.75) + }) + + it('returns null for models with no known credit rate', () => { + expect(codexCreditRate('gpt-4o')).toBeNull() + expect(codexCreditRate('claude-opus-4-8')).toBeNull() + }) +}) + +describe('codexCredits', () => { + it('charges 1M input tokens at the input rate', () => { + expect(codexCredits('gpt-5.5', { inputTokens: 1_000_000, cachedReadTokens: 0, outputTokens: 0 })).toBe(125) + }) + + it('charges 1M output tokens at the output rate', () => { + expect(codexCredits('gpt-5.5', { inputTokens: 0, cachedReadTokens: 0, outputTokens: 1_000_000 })).toBe(750) + }) + + it('charges cache-read tokens at the cheaper cached rate', () => { + expect(codexCredits('gpt-5.5', { inputTokens: 0, cachedReadTokens: 1_000_000, outputTokens: 0 })).toBe(12.5) + }) + + it('folds reasoning tokens into the output rate', () => { + // 500k output + 500k reasoning = 1M output-billed => 750 credits. + expect(codexCredits('gpt-5.5', { inputTokens: 0, cachedReadTokens: 0, outputTokens: 500_000, reasoningTokens: 500_000 })).toBe(750) + }) + + it('sums a mixed record (gpt-5.4)', () => { + // 2M input (125) + 1M cached (6.25) + 0.5M output (187.5) = 318.75 + const credits = codexCredits('gpt-5.4', { inputTokens: 2_000_000, cachedReadTokens: 1_000_000, outputTokens: 500_000 }) + expect(credits).toBeCloseTo(125 + 6.25 + 187.5, 6) + }) + + it('clamps negative / non-finite token counts to 0', () => { + expect(codexCredits('gpt-5.5', { inputTokens: -100, cachedReadTokens: NaN, outputTokens: 1_000_000 })).toBe(750) + }) + + it('returns null for an unknown model', () => { + expect(codexCredits('gpt-4o', { inputTokens: 1_000_000, cachedReadTokens: 0, outputTokens: 0 })).toBeNull() + }) +}) diff --git a/tests/compare-stats.test.ts b/tests/compare-stats.test.ts new file mode 100644 index 0000000..63d3534 --- /dev/null +++ b/tests/compare-stats.test.ts @@ -0,0 +1,570 @@ +import { mkdtemp, mkdir, rm, writeFile } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { aggregateModelStats, computeComparison, computeCategoryComparison, computeWorkingStyle, scanSelfCorrections, type ModelStats } from '../src/compare-stats.js' +import type { ProjectSummary, SessionSummary, ClassifiedTurn } from '../src/types.js' + +function makeTurn(model: string, cost: number, opts: { hasEdits?: boolean; retries?: number; outputTokens?: number; inputTokens?: number; cacheRead?: number; cacheWrite?: number; timestamp?: string; category?: string; hasAgentSpawn?: boolean; hasPlanMode?: boolean; speed?: 'standard' | 'fast'; tools?: string[] } = {}): ClassifiedTurn { + const defaultTools = opts.tools ?? (opts.hasEdits ? ['Edit'] : ['Read']) + return { + timestamp: opts.timestamp ?? '2026-04-15T10:00:00Z', + category: (opts.category ?? 'coding') as ClassifiedTurn['category'], + retries: opts.retries ?? 0, + hasEdits: opts.hasEdits ?? false, + userMessage: '', + assistantCalls: [{ + provider: 'claude', + model, + usage: { + inputTokens: opts.inputTokens ?? 100, + outputTokens: opts.outputTokens ?? 200, + cacheCreationInputTokens: opts.cacheWrite ?? 500, + cacheReadInputTokens: opts.cacheRead ?? 5000, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + }, + costUSD: cost, + tools: defaultTools, + mcpTools: [], + skills: [], + hasAgentSpawn: opts.hasAgentSpawn ?? false, + hasPlanMode: opts.hasPlanMode ?? false, + speed: opts.speed ?? 'standard' as const, + timestamp: opts.timestamp ?? '2026-04-15T10:00:00Z', + bashCommands: [], + deduplicationKey: `key-${Math.random()}`, + }], + } +} + +function makeProject(turns: ClassifiedTurn[]): ProjectSummary { + const session: SessionSummary = { + sessionId: 'test-session', + project: 'test-project', + firstTimestamp: turns[0]?.timestamp ?? '', + lastTimestamp: turns[turns.length - 1]?.timestamp ?? '', + totalCostUSD: turns.reduce((s, t) => s + t.assistantCalls.reduce((s2, c) => s2 + c.costUSD, 0), 0), + totalInputTokens: 0, + totalOutputTokens: 0, + totalCacheReadTokens: 0, + totalCacheWriteTokens: 0, + apiCalls: turns.reduce((s, t) => s + t.assistantCalls.length, 0), + turns, + modelBreakdown: {}, + toolBreakdown: {}, + mcpBreakdown: {}, + bashBreakdown: {}, + categoryBreakdown: {} as SessionSummary['categoryBreakdown'], + skillBreakdown: {} as SessionSummary['skillBreakdown'], + } + return { + project: 'test-project', + projectPath: '/test', + sessions: [session], + totalCostUSD: session.totalCostUSD, + totalApiCalls: session.apiCalls, + } +} + +describe('aggregateModelStats', () => { + it('aggregates calls, cost, and tokens per model', () => { + const project = makeProject([ + makeTurn('opus-4-6', 0.10, { outputTokens: 200, inputTokens: 50, cacheRead: 5000, cacheWrite: 500 }), + makeTurn('opus-4-6', 0.15, { outputTokens: 300, inputTokens: 80, cacheRead: 6000, cacheWrite: 600 }), + makeTurn('opus-4-7', 0.25, { outputTokens: 800, inputTokens: 100, cacheRead: 7000, cacheWrite: 700 }), + ]) + const stats = aggregateModelStats([project]) + const m6 = stats.find(s => s.model === 'opus-4-6')! + const m7 = stats.find(s => s.model === 'opus-4-7')! + + expect(m6.calls).toBe(2) + expect(m6.cost).toBeCloseTo(0.25) + expect(m6.outputTokens).toBe(500) + expect(m7.calls).toBe(1) + expect(m7.cost).toBeCloseTo(0.25) + expect(m7.outputTokens).toBe(800) + }) + + it('attributes turn-level metrics to the primary model', () => { + const project = makeProject([ + makeTurn('opus-4-6', 0.10, { hasEdits: true, retries: 0 }), + makeTurn('opus-4-6', 0.10, { hasEdits: true, retries: 2 }), + makeTurn('opus-4-7', 0.20, { hasEdits: true, retries: 0 }), + makeTurn('opus-4-7', 0.20, { hasEdits: false }), + ]) + const stats = aggregateModelStats([project]) + const m6 = stats.find(s => s.model === 'opus-4-6')! + const m7 = stats.find(s => s.model === 'opus-4-7')! + + expect(m6.editTurns).toBe(2) + expect(m6.oneShotTurns).toBe(1) + expect(m6.retries).toBe(2) + expect(m7.editTurns).toBe(1) + expect(m7.oneShotTurns).toBe(1) + expect(m7.totalTurns).toBe(2) + }) + + it('tracks firstSeen and lastSeen timestamps', () => { + const project = makeProject([ + makeTurn('opus-4-6', 0.10, { timestamp: '2026-04-10T08:00:00Z' }), + makeTurn('opus-4-6', 0.10, { timestamp: '2026-04-15T20:00:00Z' }), + ]) + const stats = aggregateModelStats([project]) + const m = stats.find(s => s.model === 'opus-4-6')! + expect(m.firstSeen).toBe('2026-04-10T08:00:00Z') + expect(m.lastSeen).toBe('2026-04-15T20:00:00Z') + }) + + it('filters out <synthetic> model entries', () => { + const project = makeProject([ + makeTurn('<synthetic>', 0, {}), + makeTurn('opus-4-6', 0.10, {}), + ]) + const stats = aggregateModelStats([project]) + expect(stats.find(s => s.model === '<synthetic>')).toBeUndefined() + expect(stats).toHaveLength(1) + }) + + it('returns empty array for no projects', () => { + expect(aggregateModelStats([])).toEqual([]) + }) + + it('tracks editCost for edit turns', () => { + const project = makeProject([ + makeTurn('opus-4-6', 0.10, { hasEdits: true }), + makeTurn('opus-4-6', 0.20, { hasEdits: true }), + makeTurn('opus-4-6', 0.50, { hasEdits: false }), + ]) + const stats = aggregateModelStats([project]) + const m = stats.find(s => s.model === 'opus-4-6')! + expect(m.editCost).toBeCloseTo(0.30) + }) + + it('sorts by cost descending', () => { + const project = makeProject([ + makeTurn('cheap-model', 0.01), + makeTurn('expensive-model', 5.00), + ]) + const stats = aggregateModelStats([project]) + expect(stats[0].model).toBe('expensive-model') + expect(stats[1].model).toBe('cheap-model') + }) +}) + +function makeStats(overrides: Partial<ModelStats> = {}): ModelStats { + return { + model: 'test-model', + calls: 100, + cost: 10, + outputTokens: 50000, + inputTokens: 10000, + cacheReadTokens: 20000, + cacheWriteTokens: 5000, + totalTurns: 200, + editTurns: 80, + oneShotTurns: 60, + retries: 20, + selfCorrections: 10, + editCost: 8, + firstSeen: '2026-04-01T00:00:00Z', + lastSeen: '2026-04-15T00:00:00Z', + ...overrides, + } +} + +describe('computeComparison', () => { + it('computes normalized metrics and picks winners correctly', () => { + const a = makeStats({ calls: 100, cost: 10, outputTokens: 50000, inputTokens: 10000, cacheReadTokens: 20000, cacheWriteTokens: 5000, editTurns: 80, oneShotTurns: 60, retries: 20, selfCorrections: 10, totalTurns: 200 }) + const b = makeStats({ calls: 100, cost: 8, outputTokens: 40000, inputTokens: 10000, cacheReadTokens: 20000, cacheWriteTokens: 5000, editTurns: 80, oneShotTurns: 60, retries: 20, selfCorrections: 10, totalTurns: 200 }) + const rows = computeComparison(a, b) + + const costRow = rows.find(r => r.label === 'Cost / call')! + expect(costRow.valueA).toBeCloseTo(0.1) + expect(costRow.valueB).toBeCloseTo(0.08) + expect(costRow.winner).toBe('b') + + const outputRow = rows.find(r => r.label === 'Output tok / call')! + expect(outputRow.valueA).toBe(500) + expect(outputRow.valueB).toBe(400) + expect(outputRow.winner).toBe('b') + }) + + it('returns null values for one-shot rate and retry rate when editTurns is zero', () => { + const a = makeStats({ editTurns: 0, oneShotTurns: 0, retries: 0 }) + const b = makeStats({ editTurns: 80, oneShotTurns: 60, retries: 20 }) + const rows = computeComparison(a, b) + + const oneShotRow = rows.find(r => r.label === 'One-shot rate')! + expect(oneShotRow.valueA).toBeNull() + expect(oneShotRow.winner).toBe('none') + + const retryRow = rows.find(r => r.label === 'Retry rate')! + expect(retryRow.valueA).toBeNull() + expect(retryRow.winner).toBe('none') + }) + + it('returns tie when values are equal', () => { + const a = makeStats({ calls: 100, cost: 10 }) + const b = makeStats({ calls: 100, cost: 10 }) + const rows = computeComparison(a, b) + + const costRow = rows.find(r => r.label === 'Cost / call')! + expect(costRow.winner).toBe('tie') + }) + + it('computes cost per edit correctly', () => { + const a = makeStats({ editTurns: 40, editCost: 4 }) + const b = makeStats({ editTurns: 80, editCost: 4 }) + const rows = computeComparison(a, b) + const editRow = rows.find(r => r.label === 'Cost / edit')! + expect(editRow.valueA).toBeCloseTo(0.10) + expect(editRow.valueB).toBeCloseTo(0.05) + expect(editRow.winner).toBe('b') + }) + + it('picks higher value as winner for cache hit rate', () => { + const a = makeStats({ inputTokens: 5000, cacheReadTokens: 30000, cacheWriteTokens: 5000 }) + const b = makeStats({ inputTokens: 10000, cacheReadTokens: 10000, cacheWriteTokens: 5000 }) + const rows = computeComparison(a, b) + + const cacheRow = rows.find(r => r.label === 'Cache hit rate')! + const totalA = 5000 + 30000 + 5000 + const totalB = 10000 + 10000 + 5000 + expect(cacheRow.valueA).toBeCloseTo(30000 / totalA * 100) + expect(cacheRow.valueB).toBeCloseTo(10000 / totalB * 100) + expect(cacheRow.winner).toBe('a') + }) +}) + +function jsonlLine(type: string, model: string, text: string, timestamp = '2026-04-15T10:00:00Z'): string { + if (type === 'assistant') { + return JSON.stringify({ + type: 'assistant', timestamp, + message: { model, content: [{ type: 'text', text }], id: `msg-${Math.random()}`, usage: { input_tokens: 0, output_tokens: 0 } }, + }) + } + return JSON.stringify({ type: 'user', timestamp, message: { role: 'user', content: text } }) +} + +describe('scanSelfCorrections', () => { + let tmpDir: string + + beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'codeburn-test-')) + }) + + afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) + }) + + it('counts apology patterns per model', async () => { + const sessionDir = join(tmpDir, 'session-abc') + await mkdir(sessionDir) + const lines = [ + jsonlLine('assistant', 'opus-4-6', 'I apologize for the confusion.'), + jsonlLine('assistant', 'opus-4-6', 'Here is the result.'), + jsonlLine('assistant', 'sonnet-4-6', 'I was wrong about that.'), + jsonlLine('user', '', 'Do this'), + ] + await writeFile(join(sessionDir, 'session.jsonl'), lines.join('\n') + '\n') + + const result = await scanSelfCorrections([tmpDir]) + expect(result.get('opus-4-6')).toBe(1) + expect(result.get('sonnet-4-6')).toBe(1) + }) + + it('does not count non-apology text', async () => { + const sessionDir = join(tmpDir, 'session-xyz') + await mkdir(sessionDir) + const lines = [ + jsonlLine('assistant', 'opus-4-6', 'Here is the updated code.'), + jsonlLine('assistant', 'opus-4-6', 'Let me fix that for you.'), + ] + await writeFile(join(sessionDir, 'session.jsonl'), lines.join('\n') + '\n') + + const result = await scanSelfCorrections([tmpDir]) + expect(result.get('opus-4-6')).toBeUndefined() + expect(result.size).toBe(0) + }) + + it('returns empty map for missing directory', async () => { + const result = await scanSelfCorrections([join(tmpDir, 'nonexistent')]) + expect(result.size).toBe(0) + }) + + it('returns empty map for empty directory', async () => { + const result = await scanSelfCorrections([tmpDir]) + expect(result.size).toBe(0) + }) + + it('scans subagent directories', async () => { + const sessionDir = join(tmpDir, 'session-sub') + const subagentsDir = join(sessionDir, 'subagents') + await mkdir(subagentsDir, { recursive: true }) + const lines = [ + jsonlLine('assistant', 'haiku-4-6', 'My mistake, let me redo that.'), + ] + await writeFile(join(subagentsDir, 'sub.jsonl'), lines.join('\n') + '\n') + + const result = await scanSelfCorrections([tmpDir]) + expect(result.get('haiku-4-6')).toBe(1) + }) + + it('skips <synthetic> models', async () => { + const sessionDir = join(tmpDir, 'session-synth') + await mkdir(sessionDir) + const lines = [ + jsonlLine('assistant', '<synthetic>', 'I apologize for the error.'), + ] + await writeFile(join(sessionDir, 'session.jsonl'), lines.join('\n') + '\n') + + const result = await scanSelfCorrections([tmpDir]) + expect(result.get('<synthetic>')).toBeUndefined() + expect(result.size).toBe(0) + }) + + it('accumulates counts across multiple sessions and directories', async () => { + const sessionA = join(tmpDir, 'session-a') + const sessionB = join(tmpDir, 'session-b') + await mkdir(sessionA) + await mkdir(sessionB) + + await writeFile(join(sessionA, 'a.jsonl'), [ + jsonlLine('assistant', 'opus-4-6', 'I was wrong.', '2026-04-15T10:00:00Z'), + jsonlLine('assistant', 'opus-4-6', 'My bad!', '2026-04-15T10:01:00Z'), + ].join('\n') + '\n') + + await writeFile(join(sessionB, 'b.jsonl'), [ + jsonlLine('assistant', 'opus-4-6', 'I apologize.', '2026-04-15T10:02:00Z'), + ].join('\n') + '\n') + + const result = await scanSelfCorrections([tmpDir]) + expect(result.get('opus-4-6')).toBe(3) + }) + + it('handles malformed JSON lines gracefully', async () => { + const sessionDir = join(tmpDir, 'session-bad') + await mkdir(sessionDir) + await writeFile(join(sessionDir, 'bad.jsonl'), [ + 'not valid json', + jsonlLine('assistant', 'opus-4-6', 'I apologize.'), + ].join('\n') + '\n') + + const result = await scanSelfCorrections([tmpDir]) + expect(result.get('opus-4-6')).toBe(1) + }) + + it('accepts multiple sessionDirs and merges counts', async () => { + const dir2 = await mkdtemp(join(tmpdir(), 'codeburn-test2-')) + try { + const sessionA = join(tmpDir, 'session-a') + const sessionB = join(dir2, 'session-b') + await mkdir(sessionA) + await mkdir(sessionB) + + await writeFile(join(sessionA, 'a.jsonl'), [ + jsonlLine('assistant', 'sonnet-4-6', 'My mistake.', '2026-04-15T10:00:00Z'), + ].join('\n') + '\n') + + await writeFile(join(sessionB, 'b.jsonl'), [ + jsonlLine('assistant', 'sonnet-4-6', 'I was wrong.', '2026-04-15T10:01:00Z'), + ].join('\n') + '\n') + + const result = await scanSelfCorrections([tmpDir, dir2]) + expect(result.get('sonnet-4-6')).toBe(2) + } finally { + await rm(dir2, { recursive: true, force: true }) + } + }) +}) + +describe('computeCategoryComparison', () => { + it('returns per-category one-shot rates for both models', () => { + const project = makeProject([ + makeTurn('model-a', 0.10, { hasEdits: true, retries: 0, category: 'coding' }), + makeTurn('model-a', 0.10, { hasEdits: true, retries: 1, category: 'coding' }), + makeTurn('model-b', 0.10, { hasEdits: true, retries: 0, category: 'coding' }), + makeTurn('model-b', 0.10, { hasEdits: true, retries: 0, category: 'coding' }), + makeTurn('model-a', 0.10, { hasEdits: true, retries: 0, category: 'debugging' }), + makeTurn('model-b', 0.10, { hasEdits: true, retries: 1, category: 'debugging' }), + ]) + const result = computeCategoryComparison([project], 'model-a', 'model-b') + + const coding = result.find(r => r.category === 'coding')! + expect(coding.editTurnsA).toBe(2) + expect(coding.oneShotRateA).toBeCloseTo(50) + expect(coding.editTurnsB).toBe(2) + expect(coding.oneShotRateB).toBeCloseTo(100) + expect(coding.winner).toBe('b') + + const debugging = result.find(r => r.category === 'debugging')! + expect(debugging.oneShotRateA).toBeCloseTo(100) + expect(debugging.oneShotRateB).toBeCloseTo(0) + expect(debugging.winner).toBe('a') + }) + + it('skips categories with no edit turns', () => { + const project = makeProject([ + makeTurn('model-a', 0.10, { hasEdits: false, category: 'conversation' }), + makeTurn('model-b', 0.10, { hasEdits: false, category: 'conversation' }), + makeTurn('model-a', 0.10, { hasEdits: true, category: 'coding' }), + ]) + const result = computeCategoryComparison([project], 'model-a', 'model-b') + expect(result.find(r => r.category === 'conversation')).toBeUndefined() + expect(result).toHaveLength(1) + }) + + it('sorts by total turns descending', () => { + const project = makeProject([ + makeTurn('model-a', 0.10, { hasEdits: true, category: 'coding' }), + makeTurn('model-a', 0.10, { hasEdits: true, category: 'coding' }), + makeTurn('model-a', 0.10, { hasEdits: true, category: 'coding' }), + makeTurn('model-b', 0.10, { hasEdits: true, category: 'coding' }), + makeTurn('model-a', 0.10, { hasEdits: true, category: 'debugging' }), + ]) + const result = computeCategoryComparison([project], 'model-a', 'model-b') + expect(result[0].category).toBe('coding') + }) + + it('returns null one-shot rate when model has no edits in category', () => { + const project = makeProject([ + makeTurn('model-a', 0.10, { hasEdits: true, category: 'coding' }), + makeTurn('model-b', 0.10, { hasEdits: false, category: 'coding' }), + ]) + const result = computeCategoryComparison([project], 'model-a', 'model-b') + const coding = result.find(r => r.category === 'coding')! + expect(coding.oneShotRateA).toBeCloseTo(100) + expect(coding.oneShotRateB).toBeNull() + expect(coding.winner).toBe('none') + }) +}) + +describe('computeWorkingStyle', () => { + it('computes delegation and planning rates', () => { + const project = makeProject([ + makeTurn('model-a', 0.10, { hasAgentSpawn: true }), + makeTurn('model-a', 0.10, {}), + makeTurn('model-a', 0.10, { hasPlanMode: true }), + makeTurn('model-b', 0.10, {}), + makeTurn('model-b', 0.10, {}), + ]) + const result = computeWorkingStyle([project], 'model-a', 'model-b') + + const delegation = result.find(r => r.label === 'Delegation rate')! + expect(delegation.valueA).toBeCloseTo(100 / 3) + expect(delegation.valueB).toBeCloseTo(0) + + const planning = result.find(r => r.label === 'Planning rate')! + expect(planning.valueA).toBeCloseTo(100 / 3) + expect(planning.valueB).toBeCloseTo(0) + }) + + it('computes avg tools per turn', () => { + const project = makeProject([ + makeTurn('model-a', 0.10, { hasEdits: true }), + makeTurn('model-a', 0.10, {}), + makeTurn('model-b', 0.10, { hasEdits: true }), + ]) + const result = computeWorkingStyle([project], 'model-a', 'model-b') + const tools = result.find(r => r.label === 'Avg tools / turn')! + expect(tools.valueA).toBeCloseTo(1) + expect(tools.valueB).toBeCloseTo(1) + }) + + it('computes fast mode usage', () => { + const project = makeProject([ + makeTurn('model-a', 0.10, { speed: 'fast' }), + makeTurn('model-a', 0.10, {}), + makeTurn('model-b', 0.10, { speed: 'fast' }), + makeTurn('model-b', 0.10, { speed: 'fast' }), + ]) + const result = computeWorkingStyle([project], 'model-a', 'model-b') + const fast = result.find(r => r.label === 'Fast mode usage')! + expect(fast.valueA).toBeCloseTo(50) + expect(fast.valueB).toBeCloseTo(100) + }) + + it('returns null for models with no turns', () => { + const project = makeProject([ + makeTurn('model-a', 0.10, {}), + ]) + const result = computeWorkingStyle([project], 'model-a', 'model-b') + const delegation = result.find(r => r.label === 'Delegation rate')! + expect(delegation.valueA).toBeCloseTo(0) + expect(delegation.valueB).toBeNull() + }) + + it('counts TaskCreate as planning', () => { + const project = makeProject([ + makeTurn('model-a', 0.10, { tools: ['TaskCreate'] }), + makeTurn('model-a', 0.10, { tools: ['Read'] }), + makeTurn('model-a', 0.10, { tools: ['Edit'] }), + ]) + const result = computeWorkingStyle([project], 'model-a', 'model-b') + const planning = result.find(r => r.label === 'Planning rate')! + expect(planning.valueA).toBeCloseTo(100 / 3) + }) + + it('counts TaskUpdate as planning', () => { + const project = makeProject([ + makeTurn('model-a', 0.10, { tools: ['TaskUpdate'] }), + makeTurn('model-a', 0.10, { tools: ['Read'] }), + ]) + const result = computeWorkingStyle([project], 'model-a', 'model-b') + const planning = result.find(r => r.label === 'Planning rate')! + expect(planning.valueA).toBeCloseTo(50) + }) + + it('counts TodoWrite as planning', () => { + const project = makeProject([ + makeTurn('model-a', 0.10, { tools: ['TodoWrite', 'Read'] }), + makeTurn('model-a', 0.10, { tools: ['Bash'] }), + ]) + const result = computeWorkingStyle([project], 'model-a', 'model-b') + const planning = result.find(r => r.label === 'Planning rate')! + expect(planning.valueA).toBeCloseTo(50) + }) + + it('counts turn with planning tool + edits as planning', () => { + const project = makeProject([ + makeTurn('model-a', 0.10, { tools: ['TaskCreate', 'Edit', 'Read'] }), + makeTurn('model-a', 0.10, { tools: ['Edit'] }), + ]) + const result = computeWorkingStyle([project], 'model-a', 'model-b') + const planning = result.find(r => r.label === 'Planning rate')! + expect(planning.valueA).toBeCloseTo(50) + }) + + it('does not count regular tools as planning', () => { + const project = makeProject([ + makeTurn('model-a', 0.10, { tools: ['Read', 'Grep', 'Glob'] }), + makeTurn('model-a', 0.10, { tools: ['Edit', 'Bash'] }), + makeTurn('model-a', 0.10, { tools: ['Agent'] }), + ]) + const result = computeWorkingStyle([project], 'model-a', 'model-b') + const planning = result.find(r => r.label === 'Planning rate')! + expect(planning.valueA).toBeCloseTo(0) + }) + + it('counts planning once per turn even with multiple planning tools', () => { + const project = makeProject([ + makeTurn('model-a', 0.10, { tools: ['TaskCreate', 'TaskUpdate', 'TaskCreate'] }), + makeTurn('model-a', 0.10, { tools: ['Read'] }), + ]) + const result = computeWorkingStyle([project], 'model-a', 'model-b') + const planning = result.find(r => r.label === 'Planning rate')! + expect(planning.valueA).toBeCloseTo(50) + }) + + it('hasPlanMode still triggers planning rate', () => { + const project = makeProject([ + makeTurn('model-a', 0.10, { hasPlanMode: true, tools: ['Read'] }), + makeTurn('model-a', 0.10, { tools: ['Read'] }), + ]) + const result = computeWorkingStyle([project], 'model-a', 'model-b') + const planning = result.find(r => r.label === 'Planning rate')! + expect(planning.valueA).toBeCloseTo(50) + }) +}) diff --git a/tests/content-utils.test.ts b/tests/content-utils.test.ts new file mode 100644 index 0000000..34a00ee --- /dev/null +++ b/tests/content-utils.test.ts @@ -0,0 +1,43 @@ +import { describe, it, expect } from 'vitest' +import { normalizeContentBlocks } from '../src/content-utils.js' + +describe('normalizeContentBlocks', () => { + it('passes an array of blocks through unchanged', () => { + const blocks = [{ type: 'text', text: 'hi' }, { type: 'tool_use', text: '' }] + expect(normalizeContentBlocks(blocks)).toBe(blocks) + }) + + it('wraps a string as a single text block (the issue #441 case)', () => { + expect(normalizeContentBlocks('hello world')).toEqual([{ type: 'text', text: 'hello world' }]) + }) + + it('returns an empty array for null / undefined', () => { + expect(normalizeContentBlocks(null)).toEqual([]) + expect(normalizeContentBlocks(undefined)).toEqual([]) + }) + + it('returns an empty array for other non-array values', () => { + // Defensive against corrupt records: a number/object content must not throw downstream. + expect(normalizeContentBlocks(42 as unknown as string)).toEqual([]) + expect(normalizeContentBlocks({ type: 'text' } as unknown as string)).toEqual([]) + }) + + it('drops null/undefined elements inside an array (avoids the same crash one level down)', () => { + const dirty = [{ type: 'text', text: 'ok' }, null, undefined, { type: 'tool_use' }] as unknown as Array<{ type?: string }> + const out = normalizeContentBlocks(dirty) + expect(out).toEqual([{ type: 'text', text: 'ok' }, { type: 'tool_use' }]) + expect(() => out.filter(b => b.type === 'text')).not.toThrow() + }) + + it('returns the same reference for a clean array (no copy)', () => { + const clean = [{ type: 'text', text: 'a' }, { type: 'tool_use' }] + expect(normalizeContentBlocks(clean)).toBe(clean) + }) + + it('the result is always safe to .filter/.some over', () => { + const inputs = ['a string', null, undefined, [{ type: 'text' }], [{ type: 'text' }, null]] as const + for (const input of inputs) { + expect(() => normalizeContentBlocks(input as never).filter(b => b.type === 'text')).not.toThrow() + } + }) +}) diff --git a/tests/currency-rounding.test.ts b/tests/currency-rounding.test.ts new file mode 100644 index 0000000..385e069 --- /dev/null +++ b/tests/currency-rounding.test.ts @@ -0,0 +1,106 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { convertCost, roundForActiveCurrency, getFractionDigits } from '../src/currency.js' +import { CurrencyState } from '../src/currency.js' +import * as currencyMod from '../src/currency.js' + +// We poke the module-level state directly via switchCurrency for these tests. +// Each test restores USD afterwards so it doesn't bleed. +async function setActive(code: string, rate: number): Promise<void> { + // switchCurrency does network + persistence; for unit tests we set the + // active state directly via the module's internal state. Since the module + // doesn't expose a setter, we go through getCurrency()'s state and patch. + // Instead use the public switchCurrency only when offline: nope, just + // exploit the fact that the module exports `getCurrency` which returns a + // ref. We can't easily mock fetch. So we test only convertCost (which uses + // active.rate) and rounding helpers — both pure functions of the state. + const state = currencyMod.getCurrency() + // @ts-expect-error — directly mutating for test + state.code = code + // @ts-expect-error + state.rate = rate + // @ts-expect-error + state.symbol = code +} + +beforeEach(async () => { + await setActive('USD', 1) +}) + +afterEach(async () => { + await setActive('USD', 1) +}) + +describe('convertCost — no rounding contract', () => { + it('returns unrounded float for USD (rate=1)', () => { + expect(convertCost(1.234567)).toBe(1.234567) + expect(convertCost(0.001)).toBe(0.001) + }) + + it('returns unrounded float for non-USD currencies', async () => { + await setActive('JPY', 150) + // 1 USD * 150 = 150, but a fractional input must NOT be rounded by convertCost. + expect(convertCost(0.123456)).toBeCloseTo(18.5184, 4) + expect(convertCost(1.5)).toBe(225) + }) + + it('rounding is the caller\'s responsibility (display vs export)', async () => { + // Regression guard: previously convertCost did its own rounding which + // produced ¥412.37 in CSV exports while the dashboard rendered ¥412. + // Confirm we now return the raw value and the caller decides. + await setActive('JPY', 150) + const raw = convertCost(2.7491) + expect(raw).toBe(412.365) // unrounded + expect(roundForActiveCurrency(raw)).toBe(412) // currency-aware rounding for export + }) +}) + +describe('roundForActiveCurrency', () => { + it('USD rounds to 2 decimals', async () => { + await setActive('USD', 1) + expect(roundForActiveCurrency(1.2345)).toBe(1.23) + expect(roundForActiveCurrency(1.235)).toBeCloseTo(1.24, 2) + expect(roundForActiveCurrency(0.005)).toBe(0.01) + }) + + it('JPY rounds to whole numbers', async () => { + await setActive('JPY', 150) + expect(roundForActiveCurrency(412.37)).toBe(412) + expect(roundForActiveCurrency(412.5)).toBe(413) + expect(roundForActiveCurrency(0.4)).toBe(0) + }) + + it('KRW rounds to whole numbers', async () => { + await setActive('KRW', 1300) + expect(roundForActiveCurrency(15999.7)).toBe(16000) + }) + + it('EUR rounds to 2 decimals like USD', async () => { + await setActive('EUR', 0.92) + expect(roundForActiveCurrency(1.2345)).toBe(1.23) + }) + + it('matches the display contract: roundForActiveCurrency(convertCost(x)) is what users see', async () => { + await setActive('JPY', 150) + // Dashboard displays via formatCost which uses getFractionDigits=0 for JPY. + // CSV exports must produce the same integer value, not a 2-decimal float. + expect(roundForActiveCurrency(convertCost(2.75))).toBe(413) + expect(roundForActiveCurrency(convertCost(2.745))).toBe(412) + }) +}) + +describe('getFractionDigits', () => { + it('returns 0 for zero-fraction currencies', () => { + expect(getFractionDigits('JPY')).toBe(0) + expect(getFractionDigits('KRW')).toBe(0) + expect(getFractionDigits('CLP')).toBe(0) + }) + + it('returns 2 for typical currencies', () => { + expect(getFractionDigits('USD')).toBe(2) + expect(getFractionDigits('EUR')).toBe(2) + expect(getFractionDigits('GBP')).toBe(2) + expect(getFractionDigits('INR')).toBe(2) + expect(getFractionDigits('CNY')).toBe(2) + expect(getFractionDigits('RON')).toBe(2) + }) +}) diff --git a/tests/daily-cache.test.ts b/tests/daily-cache.test.ts new file mode 100644 index 0000000..9892319 --- /dev/null +++ b/tests/daily-cache.test.ts @@ -0,0 +1,378 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import { readFile, rm } from 'fs/promises' +import { existsSync } from 'fs' +import { tmpdir } from 'os' +import { join } from 'path' + +import type { ProjectSummary } from '../src/types.js' + +import { + addNewDays, + DAILY_CACHE_VERSION, + type DailyCache, + type DailyEntry, + getDaysInRange, + ensureCacheHydrated, + loadDailyCache, + saveDailyCache, + withDailyCacheLock, +} from '../src/daily-cache.js' + +function emptyDay(date: string, cost = 0, calls = 0): DailyEntry { + return { + date, + cost, + savingsUSD: 0, + calls, + sessions: 0, + inputTokens: 0, + outputTokens: 0, + cacheReadTokens: 0, + cacheWriteTokens: 0, + editTurns: 0, + oneShotTurns: 0, + models: {}, + categories: {}, + providers: {}, + } +} + +const TMP_CACHE_ROOT = join(tmpdir(), `codeburn-cache-test-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`) + +beforeEach(() => { + process.env['CODEBURN_CACHE_DIR'] = TMP_CACHE_ROOT +}) + +afterEach(async () => { + vi.useRealTimers() + if (existsSync(TMP_CACHE_ROOT)) { + await rm(TMP_CACHE_ROOT, { recursive: true, force: true }) + } +}) + +describe('loadDailyCache', () => { + it('returns an empty cache when the file does not exist', async () => { + const cache = await loadDailyCache() + expect(cache.version).toBe(DAILY_CACHE_VERSION) + expect(cache.lastComputedDate).toBeNull() + expect(cache.days).toEqual([]) + }) + + it('returns an empty cache when the file contains invalid JSON', async () => { + const { writeFile, mkdir } = await import('fs/promises') + await mkdir(TMP_CACHE_ROOT, { recursive: true }) + await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.json'), 'not valid json{{', 'utf-8') + const cache = await loadDailyCache() + expect(cache.days).toEqual([]) + }) + + it('returns an empty cache and backs up when version is too old to migrate', async () => { + const saved = { + version: 1, + lastComputedDate: '2026-04-10', + days: [{ date: '2026-04-10', cost: 10, calls: 5 }], + } + const { writeFile, mkdir } = await import('fs/promises') + await mkdir(TMP_CACHE_ROOT, { recursive: true }) + await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.json'), JSON.stringify(saved), 'utf-8') + const cache = await loadDailyCache() + expect(cache.days).toEqual([]) + expect(cache.lastComputedDate).toBeNull() + expect(existsSync(join(TMP_CACHE_ROOT, 'daily-cache.json.v1.bak'))).toBe(true) + }) + + it('discards a v2 cache and starts fresh (provider rollups would be stale)', async () => { + // MIN_SUPPORTED_VERSION was raised to DAILY_CACHE_VERSION because the + // migration path cannot recompute the providers / categories / models + // rollups from session data (the cache does not retain raw sessions), + // so a migrated old cache would carry forward stale provider totals + // for the full retention window. Older caches now get discarded and + // recomputed from scratch on next run. + const saved = { + version: 2, + lastComputedDate: '2026-04-10', + days: [{ + date: '2026-04-10', cost: 10, calls: 5, sessions: 2, + inputTokens: 1000, outputTokens: 500, cacheReadTokens: 200, cacheWriteTokens: 100, + models: { 'claude-opus-4-6': { calls: 5, cost: 10, inputTokens: 1000, outputTokens: 500, cacheReadTokens: 200, cacheWriteTokens: 100 } }, + }], + } + const { writeFile, mkdir } = await import('fs/promises') + await mkdir(TMP_CACHE_ROOT, { recursive: true }) + await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.json'), JSON.stringify(saved), 'utf-8') + const cache = await loadDailyCache() + expect(cache.version).toBe(DAILY_CACHE_VERSION) + expect(cache.days).toEqual([]) + expect(cache.lastComputedDate).toBeNull() + // Old cache is renamed to .v2.bak rather than deleted. + expect(existsSync(join(TMP_CACHE_ROOT, 'daily-cache.json.v2.bak'))).toBe(true) + }) + + it('discards a v5 cache because cached Claude costs predate 1-hour cache pricing', async () => { + const saved = { + version: 5, + lastComputedDate: '2026-05-01', + days: [{ + date: '2026-05-01', + cost: 0.37575, + calls: 1, + sessions: 1, + inputTokens: 0, + outputTokens: 0, + cacheReadTokens: 0, + cacheWriteTokens: 60_120, + editTurns: 0, + oneShotTurns: 0, + models: { 'Opus 4.7': { calls: 1, cost: 0.37575, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 60_120 } }, + categories: {}, + providers: { claude: { calls: 1, cost: 0.37575 } }, + }], + } + const { writeFile, mkdir } = await import('fs/promises') + await mkdir(TMP_CACHE_ROOT, { recursive: true }) + await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.json'), JSON.stringify(saved), 'utf-8') + const cache = await loadDailyCache() + expect(cache.version).toBe(DAILY_CACHE_VERSION) + expect(cache.days).toEqual([]) + expect(cache.lastComputedDate).toBeNull() + expect(existsSync(join(TMP_CACHE_ROOT, 'daily-cache.json.v5.bak'))).toBe(true) + }) + + it('round-trips a valid cache through save and load', async () => { + const saved: DailyCache = { + version: DAILY_CACHE_VERSION, + savingsConfigHash: 'cfg-hash-1', + lastComputedDate: '2026-04-10', + days: [emptyDay('2026-04-09', 12.5, 40), emptyDay('2026-04-10', 7.25, 28)], + } + await saveDailyCache(saved) + const loaded = await loadDailyCache() + expect(loaded).toEqual(saved) + }) +}) + +describe('saveDailyCache', () => { + it('writes atomically so no temp file is left after a successful save', async () => { + const saved: DailyCache = { + version: DAILY_CACHE_VERSION, + savingsConfigHash: 'cfg-hash-1', + lastComputedDate: '2026-04-10', + days: [emptyDay('2026-04-10', 5)], + } + await saveDailyCache(saved) + const { readdir } = await import('fs/promises') + const files = await readdir(TMP_CACHE_ROOT) + const tempLeftovers = files.filter(f => f.endsWith('.tmp')) + expect(tempLeftovers).toEqual([]) + const finalFile = await readFile(join(TMP_CACHE_ROOT, 'daily-cache.json'), 'utf-8') + expect(JSON.parse(finalFile)).toEqual(saved) + }) +}) + +describe('addNewDays', () => { + it('returns a new cache with the added days sorted ascending by date', () => { + const base: DailyCache = { + version: DAILY_CACHE_VERSION, + savingsConfigHash: '', + lastComputedDate: '2026-04-08', + days: [emptyDay('2026-04-07', 3), emptyDay('2026-04-08', 5)], + } + const updated = addNewDays(base, [emptyDay('2026-04-10', 9), emptyDay('2026-04-09', 7)], '2026-04-10') + expect(updated.days.map(d => d.date)).toEqual(['2026-04-07', '2026-04-08', '2026-04-09', '2026-04-10']) + expect(updated.lastComputedDate).toBe('2026-04-10') + }) + + it('replaces existing days with incoming data (last write wins)', () => { + const base: DailyCache = { + version: DAILY_CACHE_VERSION, + savingsConfigHash: '', + lastComputedDate: '2026-04-08', + days: [emptyDay('2026-04-08', 5)], + } + const updated = addNewDays(base, [emptyDay('2026-04-08', 99)], '2026-04-08') + const aprilEight = updated.days.find(d => d.date === '2026-04-08')! + expect(aprilEight.cost).toBe(99) + }) + + it('does not regress lastComputedDate if incoming newestDate is older', () => { + const base: DailyCache = { + version: DAILY_CACHE_VERSION, + savingsConfigHash: '', + lastComputedDate: '2026-04-10', + days: [emptyDay('2026-04-10', 5)], + } + const updated = addNewDays(base, [emptyDay('2026-04-05', 3)], '2026-04-05') + expect(updated.lastComputedDate).toBe('2026-04-10') + }) + + it('skips prune when newestDate is malformed (does not silently drop all days)', () => { + // Regression guard: a corrupt newestDate string used to produce a NaN + // cutoff, which made `d.date >= "Invalid Date"` always false and + // wiped every cached day on the next merge. The guard now leaves + // the entries untouched so the next valid run can prune normally. + const base: DailyCache = { + version: DAILY_CACHE_VERSION, + savingsConfigHash: '', + lastComputedDate: '2026-04-10', + days: [emptyDay('2026-04-08', 1), emptyDay('2026-04-09', 2), emptyDay('2026-04-10', 3)], + } + const updated = addNewDays(base, [], 'not-a-date') + expect(updated.days.map(d => d.date)).toEqual(['2026-04-08', '2026-04-09', '2026-04-10']) + }) + + it('still prunes when newestDate is valid', () => { + const old = '2020-01-01' + const recent = '2026-04-10' + const base: DailyCache = { + version: DAILY_CACHE_VERSION, + savingsConfigHash: '', + lastComputedDate: recent, + days: [emptyDay(old, 1), emptyDay(recent, 2)], + } + const updated = addNewDays(base, [], recent) + // 730-day retention from 2026-04-10 → cutoff ~2024-04-11; 2020-01-01 must be gone. + expect(updated.days.find(d => d.date === old)).toBeUndefined() + expect(updated.days.find(d => d.date === recent)).toBeDefined() + }) +}) + +describe('getDaysInRange', () => { + const cache: DailyCache = { + version: DAILY_CACHE_VERSION, + savingsConfigHash: '', + lastComputedDate: '2026-04-10', + days: [ + emptyDay('2026-04-05', 1), + emptyDay('2026-04-06', 2), + emptyDay('2026-04-07', 3), + emptyDay('2026-04-08', 4), + emptyDay('2026-04-09', 5), + emptyDay('2026-04-10', 6), + ], + } + + it('returns inclusive start and end range', () => { + const days = getDaysInRange(cache, '2026-04-07', '2026-04-09') + expect(days.map(d => d.date)).toEqual(['2026-04-07', '2026-04-08', '2026-04-09']) + }) + + it('returns empty when range is entirely outside cache', () => { + expect(getDaysInRange(cache, '2026-03-01', '2026-03-10')).toEqual([]) + expect(getDaysInRange(cache, '2026-05-01', '2026-05-10')).toEqual([]) + }) + + it('clips to available cache days when range extends beyond', () => { + const days = getDaysInRange(cache, '2026-04-09', '2026-04-20') + expect(days.map(d => d.date)).toEqual(['2026-04-09', '2026-04-10']) + }) +}) + +describe('ensureCacheHydrated', () => { + it('does not recompute yesterday after it has already been cached', async () => { + vi.useFakeTimers() + vi.setSystemTime(new Date('2026-06-12T12:00:00.000Z')) + + const saved: DailyCache = { + version: DAILY_CACHE_VERSION, + savingsConfigHash: '', + lastComputedDate: '2026-06-11', + days: [emptyDay('2026-06-11', 5, 10)], + } + await saveDailyCache(saved) + + let parseCalls = 0 + const hydrated = await ensureCacheHydrated( + async () => { + parseCalls += 1 + return [] + }, + () => [], + ) + + expect(parseCalls).toBe(0) + expect(hydrated).toEqual(saved) + }) + + it('drops a cached today/future entry so it is recomputed live, keeping yesterday cached', async () => { + vi.useFakeTimers() + vi.setSystemTime(new Date('2026-06-12T12:00:00.000Z')) + + // A "today" entry can only exist via a backward clock change or a stale + // cache; it must be purged so today is served live, not from a frozen entry. + const saved: DailyCache = { + version: DAILY_CACHE_VERSION, + savingsConfigHash: '', + lastComputedDate: '2026-06-12', + days: [emptyDay('2026-06-11', 5, 10), emptyDay('2026-06-12', 9, 20)], + } + await saveDailyCache(saved) + + let parseCalls = 0 + const hydrated = await ensureCacheHydrated( + async () => { + parseCalls += 1 + return [] + }, + () => [], + ) + + expect(parseCalls).toBe(0) + expect(hydrated.days.map(d => d.date)).toEqual(['2026-06-11']) + expect(hydrated.lastComputedDate).toBe('2026-06-11') + }) +}) + +describe('withDailyCacheLock', () => { + it('serializes concurrent operations', async () => { + const sequence: string[] = [] + const op = async (tag: string): Promise<void> => { + await withDailyCacheLock(async () => { + sequence.push(`start-${tag}`) + await new Promise(r => setTimeout(r, 20)) + sequence.push(`end-${tag}`) + }) + } + await Promise.all([op('a'), op('b'), op('c')]) + for (let i = 0; i < sequence.length; i += 2) { + expect(sequence[i]?.startsWith('start-')).toBe(true) + expect(sequence[i + 1]?.startsWith('end-')).toBe(true) + expect(sequence[i]!.slice(6)).toBe(sequence[i + 1]!.slice(4)) + } + }) +}) + +describe('ensureCacheHydrated: savings config invalidation', () => { + it('discards cached days when the savingsConfigHash changes between calls', async () => { + // Seed a cache with a day OLDER than yesterday so the hydration window + // (which keeps `d.date < yesterdayStr`) actually retains it. + const twoDaysAgo = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000) + const twoDaysAgoStr = `${twoDaysAgo.getFullYear()}-${String(twoDaysAgo.getMonth() + 1).padStart(2, '0')}-${String(twoDaysAgo.getDate()).padStart(2, '0')}` + const seeded: DailyCache = { + version: DAILY_CACHE_VERSION, + savingsConfigHash: 'cfg-A', + lastComputedDate: twoDaysAgoStr, + days: [emptyDay(twoDaysAgoStr, 1.5, 3)], + } + await saveDailyCache(seeded) + + const parseSessions = async (): Promise<ProjectSummary[]> => [] + const aggregateDays = (): DailyEntry[] => [] + + // Hash mismatch → ensureCacheHydrated must drop the stale day and start fresh. + const rehydrated = await ensureCacheHydrated(parseSessions, aggregateDays, 'cfg-B') + expect(rehydrated.savingsConfigHash).toBe('cfg-B') + expect(rehydrated.days).toEqual([]) + + // Same hash → cached days survive. + const seeded2: DailyCache = { + version: DAILY_CACHE_VERSION, + savingsConfigHash: 'cfg-C', + lastComputedDate: twoDaysAgoStr, + days: [emptyDay(twoDaysAgoStr, 1.5, 3)], + } + await saveDailyCache(seeded2) + const preserved = await ensureCacheHydrated(parseSessions, aggregateDays, 'cfg-C') + expect(preserved.days).toHaveLength(1) + expect(preserved.days[0]!.date).toBe(twoDaysAgoStr) + }) +}) diff --git a/tests/dashboard.test.ts b/tests/dashboard.test.ts new file mode 100644 index 0000000..da802f1 --- /dev/null +++ b/tests/dashboard.test.ts @@ -0,0 +1,146 @@ +import { homedir } from 'os' + +import { describe, it, expect } from 'vitest' + +import { shortProject } from '../src/dashboard.js' +import { formatCost } from '../src/format.js' +import type { ProjectSummary, SessionSummary } from '../src/types.js' + +const EMPTY_CATEGORY_BREAKDOWN = { + coding: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + debugging: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + feature: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + refactoring: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + testing: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + exploration: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + planning: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + delegation: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + git: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + 'build/deploy': { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + conversation: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + brainstorming: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + general: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, +} satisfies SessionSummary['categoryBreakdown'] + +function makeSession(id: string, cost: number, timestamp = '2026-04-14T10:00:00Z'): SessionSummary { + return { + sessionId: id, + project: 'test-project', + firstTimestamp: timestamp, + lastTimestamp: timestamp, + totalCostUSD: cost, + totalInputTokens: 0, + totalOutputTokens: 0, + totalCacheReadTokens: 0, + totalCacheWriteTokens: 0, + apiCalls: 1, + turns: [], + modelBreakdown: {}, + toolBreakdown: {}, + mcpBreakdown: {}, + bashBreakdown: {}, + categoryBreakdown: { ...EMPTY_CATEGORY_BREAKDOWN }, + skillBreakdown: {}, + } +} + +function makeProject(name: string, sessions: SessionSummary[]): ProjectSummary { + return { + project: name, + projectPath: name, + sessions, + totalCostUSD: sessions.reduce((s, x) => s + x.totalCostUSD, 0), + totalApiCalls: sessions.reduce((s, x) => s + x.apiCalls, 0), + } +} + +// Logic replicated from TopSessions component +function getTopSessions(projects: ProjectSummary[], n = 5) { + const all = projects.flatMap(p => p.sessions.map(s => ({ ...s, projectPath: p.projectPath }))) + return [...all].sort((a, b) => b.totalCostUSD - a.totalCostUSD).slice(0, n) +} + +// Logic replicated from ProjectBreakdown component +function avgCostLabel(project: ProjectSummary): string { + return project.sessions.length > 0 + ? formatCost(project.totalCostUSD / project.sessions.length) + : '-' +} + +describe('TopSessions - top-5 selection', () => { + it('returns all sessions when fewer than 5 exist', () => { + const project = makeProject('proj', [ + makeSession('s1', 1.0), + makeSession('s2', 2.0), + ]) + const top = getTopSessions([project]) + expect(top).toHaveLength(2) + expect(top[0].totalCostUSD).toBe(2.0) + expect(top[1].totalCostUSD).toBe(1.0) + }) + + it('returns exactly 5 when more than 5 sessions exist', () => { + const sessions = [0.1, 0.5, 3.0, 1.0, 0.8, 2.0].map((cost, i) => + makeSession(`s${i}`, cost) + ) + const project = makeProject('proj', sessions) + const top = getTopSessions([project]) + expect(top).toHaveLength(5) + expect(top[0].totalCostUSD).toBe(3.0) + expect(top[4].totalCostUSD).toBe(0.5) + }) + + it('is stable on tied costs - preserves input order for equal values', () => { + const sessions = [ + makeSession('s1', 1.0), + makeSession('s2', 1.0), + makeSession('s3', 1.0), + ] + const project = makeProject('proj', sessions) + const top = getTopSessions([project]) + expect(top.map(s => s.sessionId)).toEqual(['s1', 's2', 's3']) + }) +}) + +describe('shortProject - path shortening', () => { + const home = homedir() + + it('preserves directory names containing dashes', () => { + expect(shortProject(`${home}/work/my-project`)).toBe('work/my-project') + }) + + it('preserves directory names containing dots', () => { + expect(shortProject(`${home}/work/my.app.io`)).toBe('work/my.app.io') + }) + + it('returns "home" for the home dir itself', () => { + expect(shortProject(home)).toBe('home') + }) + + it('does not strip a sibling whose name shares the home prefix', () => { + const sibling = `${home}-backup/proj` + expect(shortProject(sibling).endsWith('proj')).toBe(true) + expect(shortProject(sibling)).not.toMatch(/^-/) + }) + + it('keeps only the last 3 segments for deeply nested paths', () => { + expect(shortProject(`${home}/a/b/c/d/e/f`)).toBe('d/e/f') + }) + + it('handles paths outside the home dir', () => { + expect(shortProject('/opt/myproject')).toBe('opt/myproject') + }) +}) + +describe('avg/s in ProjectBreakdown', () => { + it('returns dash for a project with no sessions', () => { + const project = makeProject('proj', []) + expect(avgCostLabel(project)).toBe('-') + }) + + it('returns formatted average cost across sessions', () => { + const sessions = [makeSession('s1', 2.0), makeSession('s2', 4.0)] + const project = makeProject('proj', sessions) + expect(avgCostLabel(project)).toBe(formatCost(3.0)) + }) +}) diff --git a/tests/date-range-filter.test.ts b/tests/date-range-filter.test.ts new file mode 100644 index 0000000..e21b906 --- /dev/null +++ b/tests/date-range-filter.test.ts @@ -0,0 +1,141 @@ +import { afterEach, describe, it, expect, vi } from 'vitest' +import { formatDateRangeLabel, formatDayRangeLabel, parseDateRangeFlags, parseDayFlag, shiftDay } from '../src/cli-date.js' + +afterEach(() => { + vi.useRealTimers() +}) + +describe('parseDateRangeFlags', () => { + it('returns null when neither flag is provided', () => { + expect(parseDateRangeFlags(undefined, undefined)).toBeNull() + }) + + it('parses a symmetric range in local time', () => { + const range = parseDateRangeFlags('2026-04-07', '2026-04-10') + expect(range).not.toBeNull() + expect(range!.start.getFullYear()).toBe(2026) + expect(range!.start.getMonth()).toBe(3) + expect(range!.start.getDate()).toBe(7) + expect(range!.start.getHours()).toBe(0) + expect(range!.end.getDate()).toBe(10) + expect(range!.end.getHours()).toBe(23) + expect(range!.end.getMinutes()).toBe(59) + expect(range!.end.getSeconds()).toBe(59) + }) + + it('accepts --from alone (open-ended to today 23:59:59)', () => { + const range = parseDateRangeFlags('2026-04-01', undefined) + expect(range).not.toBeNull() + expect(range!.start.getDate()).toBe(1) + expect(range!.end.getHours()).toBe(23) + }) + + it('accepts --to alone with a 6-month default start', () => { + // Previously the missing --from defaulted to epoch (1970), opening a + // 55-year scan window that was almost never what the user meant. The + // default is now 6 months back from now, matching the dashboard's + // "6 Months" period boundary. + const range = parseDateRangeFlags(undefined, '2026-04-10') + expect(range).not.toBeNull() + expect(range!.start.getTime()).toBeGreaterThan(new Date(0).getTime()) + const sixMonthsMs = 6 * 31 * 24 * 60 * 60 * 1000 + const ageMs = Date.now() - range!.start.getTime() + expect(ageMs).toBeLessThanOrEqual(sixMonthsMs + 1000) + expect(ageMs).toBeGreaterThanOrEqual(sixMonthsMs - 1000) + expect(range!.end.getDate()).toBe(10) + }) + + it('throws when --from > --to', () => { + expect(() => parseDateRangeFlags('2026-04-10', '2026-04-07')) + .toThrow('--from must not be after --to') + }) + + it('throws on a non-ISO string', () => { + expect(() => parseDateRangeFlags('April 7', undefined)) + .toThrow('Invalid date format') + }) + + it('throws on wrong digit count', () => { + expect(() => parseDateRangeFlags('26-4-7', undefined)) + .toThrow('Invalid date format') + }) + + it('rejects month/day overflow instead of silently rolling forward', () => { + // Without overflow validation, JS Date silently turns Feb 31 into Mar 3 + // and 13/32 into 02/01 of the following year. That made `--from + // 2026-02-31 --to 2026-03-15` quietly drop sessions on Feb 28 - Mar 2. + expect(() => parseDateRangeFlags('2026-02-31', '2026-03-15')) + .toThrow('Invalid date "2026-02-31"') + expect(() => parseDateRangeFlags('2026-13-01', undefined)) + .toThrow('Invalid date "2026-13-01"') + expect(() => parseDateRangeFlags('2026-04-31', undefined)) + .toThrow('Invalid date "2026-04-31"') + expect(() => parseDateRangeFlags(undefined, '2026-02-30')) + .toThrow('Invalid date "2026-02-30"') + // Leap-day check: 2024 is a leap year, 2025 is not. + expect(parseDateRangeFlags('2024-02-29', '2024-03-01')).not.toBeNull() + expect(() => parseDateRangeFlags('2025-02-29', undefined)) + .toThrow('Invalid date "2025-02-29"') + }) + + it('same day is valid (start midnight, end 23:59:59)', () => { + const range = parseDateRangeFlags('2026-04-10', '2026-04-10') + expect(range).not.toBeNull() + expect(range!.start.getDate()).toBe(10) + expect(range!.end.getDate()).toBe(10) + }) + + it('formats custom range labels consistently', () => { + expect(formatDateRangeLabel('2026-04-07', '2026-04-10')).toBe('2026-04-07 to 2026-04-10') + expect(formatDateRangeLabel(undefined, '2026-04-10')).toBe('all to 2026-04-10') + expect(formatDateRangeLabel('2026-04-07', undefined)).toBe('2026-04-07 to today') + }) +}) + +describe('parseDayFlag', () => { + it('returns null when no day is provided', () => { + expect(parseDayFlag(undefined)).toBeNull() + }) + + it('parses an explicit day as local midnight through end of day', () => { + const selected = parseDayFlag('2026-04-10') + expect(selected).not.toBeNull() + expect(selected!.day).toBe('2026-04-10') + expect(selected!.label).toBe('Day (2026-04-10)') + expect(selected!.range.start.getFullYear()).toBe(2026) + expect(selected!.range.start.getMonth()).toBe(3) + expect(selected!.range.start.getDate()).toBe(10) + expect(selected!.range.start.getHours()).toBe(0) + expect(selected!.range.end.getDate()).toBe(10) + expect(selected!.range.end.getHours()).toBe(23) + expect(selected!.range.end.getMinutes()).toBe(59) + expect(selected!.range.end.getSeconds()).toBe(59) + }) + + it('resolves yesterday as the previous local calendar day after midnight', () => { + vi.useFakeTimers() + vi.setSystemTime(new Date(2026, 4, 23, 0, 5, 0)) + + const selected = parseDayFlag('yesterday') + + expect(selected!.day).toBe('2026-05-22') + expect(selected!.range.start.getDate()).toBe(22) + expect(selected!.range.end.getDate()).toBe(22) + }) + + it('supports today and day shifting', () => { + vi.useFakeTimers() + vi.setSystemTime(new Date(2026, 4, 23, 12, 0, 0)) + + expect(parseDayFlag('today')!.day).toBe('2026-05-23') + expect(formatDayRangeLabel('2026-05-22')).toBe('Day (2026-05-22)') + expect(shiftDay('2026-05-22', -1)).toBe('2026-05-21') + expect(shiftDay('2026-05-22', 1)).toBe('2026-05-23') + }) + + it('rejects malformed or overflowing day values', () => { + expect(() => parseDayFlag('May 22')).toThrow('Invalid date format') + expect(() => parseDayFlag('2026-02-31')).toThrow('Invalid date "2026-02-31"') + expect(() => shiftDay('2026-13-01', 1)).toThrow('Invalid date "2026-13-01"') + }) +}) diff --git a/tests/day-aggregator-savings.test.ts b/tests/day-aggregator-savings.test.ts new file mode 100644 index 0000000..a7a5f10 --- /dev/null +++ b/tests/day-aggregator-savings.test.ts @@ -0,0 +1,150 @@ +import { describe, expect, it } from 'vitest' + +import { aggregateProjectsIntoDays, buildPeriodDataFromDays } from '../src/day-aggregator.js' +import type { ParsedApiCall, ProjectSummary, SessionSummary, Turn } from '../src/types.js' + +function makeCall(timestamp: string, opts: { costUSD: number; savingsUSD?: number; savingsBaselineModel?: string; model?: string }): ParsedApiCall { + return { + provider: 'claude', + model: opts.model ?? 'local-model', + usage: { + inputTokens: 100, + outputTokens: 200, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 50, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + }, + costUSD: opts.costUSD, + savingsUSD: opts.savingsUSD, + savingsBaselineModel: opts.savingsBaselineModel, + tools: [], + mcpTools: [], + skills: [], + subagentTypes: [], + hasAgentSpawn: false, + hasPlanMode: false, + speed: 'standard', + timestamp, + bashCommands: [], + deduplicationKey: `dk-${timestamp}-${opts.costUSD}-${opts.savingsUSD ?? 0}`, + } +} + +function makeTurn(timestamp: string, calls: ParsedApiCall[], category: string = 'coding'): Turn { + return { + userMessage: 'u', + timestamp, + sessionId: 's', + category: category as Turn['category'], + retries: 0, + hasEdits: false, + assistantCalls: calls, + } as Turn +} + +function makeSession(sessions: SessionSummary[]): ProjectSummary { + const totalCostUSD = sessions.reduce((s, sess) => s + sess.totalCostUSD, 0) + const totalSavingsUSD = sessions.reduce((s, sess) => s + sess.totalSavingsUSD, 0) + const totalApiCalls = sessions.reduce((s, sess) => s + sess.apiCalls, 0) + return { + project: 'p', + projectPath: '/p', + sessions, + totalCostUSD, + totalSavingsUSD, + totalApiCalls, + } +} + +describe('aggregateProjectsIntoDays: savings totals', () => { + it('rolls up day, model, category, and provider savings separately from cost', () => { + const turn = makeTurn('2026-04-10T10:00:00', [ + makeCall('2026-04-10T10:00:00', { costUSD: 0, savingsUSD: 5, savingsBaselineModel: 'gpt-4o' }), + ]) + const turn2 = makeTurn('2026-04-10T10:01:00', [ + makeCall('2026-04-10T10:01:00', { costUSD: 2, savingsUSD: 0, model: 'gpt-4o' }), + ]) + const project: ProjectSummary = { + project: 'p', + projectPath: '/p', + sessions: [{ + sessionId: 's1', + project: 'p', + firstTimestamp: '2026-04-10T10:00:00', + lastTimestamp: '2026-04-10T10:01:00', + totalCostUSD: 2, + totalSavingsUSD: 5, + totalInputTokens: 200, + totalOutputTokens: 400, + totalCacheReadTokens: 100, + totalCacheWriteTokens: 0, + apiCalls: 2, + turns: [turn, turn2], + modelBreakdown: { 'Local Model': { calls: 1, costUSD: 0, savingsUSD: 5, tokens: { inputTokens: 100, outputTokens: 200, cacheCreationInputTokens: 0, cacheReadInputTokens: 50, cachedInputTokens: 0, reasoningTokens: 0, webSearchRequests: 0 } }, 'gpt-4o': { calls: 1, costUSD: 2, savingsUSD: 0, tokens: { inputTokens: 100, outputTokens: 200, cacheCreationInputTokens: 0, cacheReadInputTokens: 50, cachedInputTokens: 0, reasoningTokens: 0, webSearchRequests: 0 } } }, + toolBreakdown: {}, mcpBreakdown: {}, bashBreakdown: {}, + categoryBreakdown: { coding: { turns: 1, costUSD: 2, savingsUSD: 5, retries: 0, editTurns: 0, oneShotTurns: 0 } }, + skillBreakdown: {}, subagentBreakdown: {}, + }], + totalCostUSD: 2, + totalSavingsUSD: 5, + totalApiCalls: 2, + } + const days = aggregateProjectsIntoDays([project]) + expect(days).toHaveLength(1) + const day = days[0]! + expect(day.cost).toBe(2) + expect(day.savingsUSD).toBe(5) + expect(day.models['local-model']).toMatchObject({ calls: 1, cost: 0, savingsUSD: 5 }) + expect(day.models['gpt-4o']).toMatchObject({ calls: 1, cost: 2, savingsUSD: 0 }) + expect(day.providers['claude']).toMatchObject({ calls: 2, cost: 2, savingsUSD: 5 }) + expect(day.categories.coding).toMatchObject({ turns: 2, cost: 2, savingsUSD: 5 }) + }) +}) + +describe('buildPeriodDataFromDays: savings totals', () => { + it('threads savings through to model and category rollups', () => { + const days = [ + { + date: '2026-04-09', + cost: 2, + savingsUSD: 5, + calls: 1, + sessions: 1, + inputTokens: 100, + outputTokens: 200, + cacheReadTokens: 0, + cacheWriteTokens: 0, + editTurns: 0, + oneShotTurns: 0, + models: { 'local-model': { calls: 1, cost: 0, savingsUSD: 5, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 } }, + categories: { coding: { turns: 1, cost: 0, savingsUSD: 5, editTurns: 0, oneShotTurns: 0 } }, + providers: { claude: { calls: 1, cost: 0, savingsUSD: 5 } }, + }, + { + date: '2026-04-10', + cost: 3, + savingsUSD: 0, + calls: 1, + sessions: 1, + inputTokens: 100, + outputTokens: 200, + cacheReadTokens: 0, + cacheWriteTokens: 0, + editTurns: 0, + oneShotTurns: 0, + models: { 'gpt-4o': { calls: 1, cost: 3, savingsUSD: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 } }, + categories: { coding: { turns: 1, cost: 3, savingsUSD: 0, editTurns: 0, oneShotTurns: 0 } }, + providers: { claude: { calls: 1, cost: 3, savingsUSD: 0 } }, + }, + ] + const pd = buildPeriodDataFromDays(days, '7 Days') + expect(pd.savingsUSD).toBe(5) + const coding = pd.categories.find(c => c.name === 'Coding')! + expect(coding.savingsUSD).toBe(5) + const local = pd.models.find(m => m.name === 'local-model')! + expect(local.savingsUSD).toBe(5) + expect(local.cost).toBe(0) + }) +}) diff --git a/tests/day-aggregator.test.ts b/tests/day-aggregator.test.ts new file mode 100644 index 0000000..d20eb06 --- /dev/null +++ b/tests/day-aggregator.test.ts @@ -0,0 +1,310 @@ +import { describe, expect, it } from 'vitest' + +import { aggregateProjectsIntoDays, buildPeriodDataFromDays, dateKey } from '../src/day-aggregator.js' +import type { ProjectSummary } from '../src/types.js' + +function makeProject(overrides: Partial<ProjectSummary> & { sessions: ProjectSummary['sessions'] }): ProjectSummary { + return { + project: 'p', + projectPath: '/p', + totalCostUSD: overrides.sessions.reduce((s, sess) => s + sess.totalCostUSD, 0), + totalApiCalls: overrides.sessions.reduce((s, sess) => s + sess.apiCalls, 0), + ...overrides, + } +} + +function makeCall(timestamp: string, costUSD: number, model = 'Opus 4.7', provider = 'claude') { + return { + provider, + model, + usage: { + inputTokens: 100, + outputTokens: 200, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 50, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + }, + costUSD, + tools: [], + mcpTools: [], + skills: [], + hasAgentSpawn: false, + hasPlanMode: false, + speed: 'standard' as const, + timestamp, + bashCommands: [], + deduplicationKey: `dk-${timestamp}-${costUSD}`, + } +} + +describe('aggregateProjectsIntoDays', () => { + it('buckets api calls by calendar date derived from timestamp', () => { + const projects: ProjectSummary[] = [ + makeProject({ + sessions: [{ + sessionId: 's1', + project: 'p', + firstTimestamp: '2026-04-09T10:00:00', + lastTimestamp: '2026-04-10T08:00:00', + totalCostUSD: 10, + totalInputTokens: 0, + totalOutputTokens: 0, + totalCacheReadTokens: 0, + totalCacheWriteTokens: 0, + apiCalls: 2, + turns: [ + { + userMessage: 'hi', + timestamp: '2026-04-09T10:00:00', + sessionId: 's1', + category: 'coding', + retries: 0, + hasEdits: true, + assistantCalls: [ + makeCall('2026-04-09T10:00:00', 4), + makeCall('2026-04-10T08:00:00', 6), + ], + }, + ], + modelBreakdown: {}, + toolBreakdown: {}, + mcpBreakdown: {}, + bashBreakdown: {}, + categoryBreakdown: {} as never, + skillBreakdown: {} as never, + }], + }), + ] + + const days = aggregateProjectsIntoDays(projects) + expect(days.map(d => d.date)).toEqual(['2026-04-09', '2026-04-10']) + expect(days[0]!.cost).toBe(4) + expect(days[0]!.calls).toBe(1) + expect(days[1]!.cost).toBe(6) + expect(days[1]!.calls).toBe(1) + }) + + it('attributes category turns + editTurns + oneShotTurns to the first call date of the turn', () => { + const projects: ProjectSummary[] = [ + makeProject({ + sessions: [{ + sessionId: 's1', + project: 'p', + firstTimestamp: '2026-04-09T10:00:00', + lastTimestamp: '2026-04-09T10:05:00', + totalCostUSD: 3, + totalInputTokens: 0, + totalOutputTokens: 0, + totalCacheReadTokens: 0, + totalCacheWriteTokens: 0, + apiCalls: 1, + turns: [ + { + userMessage: 'hi', + timestamp: '2026-04-09T10:00:00', + sessionId: 's1', + category: 'coding', + retries: 0, + hasEdits: true, + assistantCalls: [makeCall('2026-04-09T10:00:00', 3)], + }, + ], + modelBreakdown: {}, + toolBreakdown: {}, + mcpBreakdown: {}, + bashBreakdown: {}, + categoryBreakdown: {} as never, + skillBreakdown: {} as never, + }], + }), + ] + const days = aggregateProjectsIntoDays(projects) + const day = days[0]! + expect(day.editTurns).toBe(1) + expect(day.oneShotTurns).toBe(1) + expect(day.categories['coding']).toEqual({ + turns: 1, + cost: 3, + savingsUSD: 0, + editTurns: 1, + oneShotTurns: 1, + }) + }) + + it('counts a session under its firstTimestamp date', () => { + const projects: ProjectSummary[] = [ + makeProject({ + sessions: [{ + sessionId: 's1', + project: 'p', + firstTimestamp: '2026-04-09T23:59:00', + lastTimestamp: '2026-04-10T00:10:00', + totalCostUSD: 1, + totalInputTokens: 0, totalOutputTokens: 0, totalCacheReadTokens: 0, totalCacheWriteTokens: 0, + apiCalls: 0, + turns: [], + modelBreakdown: {}, toolBreakdown: {}, mcpBreakdown: {}, bashBreakdown: {}, + categoryBreakdown: {} as never, + skillBreakdown: {} as never, + }], + }), + ] + const days = aggregateProjectsIntoDays(projects) + const expectedDate = dateKey('2026-04-09T23:59:00') + expect(days[0]!.date).toBe(expectedDate) + expect(days[0]!.sessions).toBe(1) + }) + + it('aggregates per-model and per-provider totals inside each day', () => { + const projects: ProjectSummary[] = [ + makeProject({ + sessions: [{ + sessionId: 's1', + project: 'p', + firstTimestamp: '2026-04-10T10:00:00', + lastTimestamp: '2026-04-10T10:00:00', + totalCostUSD: 10, + totalInputTokens: 0, totalOutputTokens: 0, totalCacheReadTokens: 0, totalCacheWriteTokens: 0, + apiCalls: 2, + turns: [ + { + userMessage: 'x', timestamp: '2026-04-10T10:00:00', sessionId: 's1', + category: 'coding', retries: 0, hasEdits: false, + assistantCalls: [ + makeCall('2026-04-10T10:00:00', 7, 'Opus 4.7', 'claude'), + makeCall('2026-04-10T10:00:00', 3, 'gpt-5', 'codex'), + ], + }, + ], + modelBreakdown: {}, toolBreakdown: {}, mcpBreakdown: {}, bashBreakdown: {}, + categoryBreakdown: {} as never, + skillBreakdown: {} as never, + }], + }), + ] + const days = aggregateProjectsIntoDays(projects) + const day = days[0]! + expect(day.models['Opus 4.7']).toEqual({ + calls: 1, cost: 7, savingsUSD: 0, + inputTokens: 100, outputTokens: 200, + cacheReadTokens: 50, cacheWriteTokens: 0, + }) + expect(day.models['gpt-5']).toEqual({ + calls: 1, cost: 3, savingsUSD: 0, + inputTokens: 100, outputTokens: 200, + cacheReadTokens: 50, cacheWriteTokens: 0, + }) + expect(day.providers['claude']).toEqual({ calls: 1, cost: 7, savingsUSD: 0 }) + expect(day.providers['codex']).toEqual({ calls: 1, cost: 3, savingsUSD: 0 }) + }) +}) + +describe('buildPeriodDataFromDays', () => { + function makeDay(date: string, cost: number) { + return { + date, + cost, + calls: 10, + sessions: 2, + inputTokens: 100, + outputTokens: 200, + cacheReadTokens: 300, + cacheWriteTokens: 0, + editTurns: 3, + oneShotTurns: 2, + models: { + 'Opus 4.7': { calls: 8, cost: cost * 0.8, savingsUSD: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 }, + 'Haiku 4.5': { calls: 2, cost: cost * 0.2, savingsUSD: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 }, + }, + categories: { 'coding': { turns: 2, cost: cost * 0.5, savingsUSD: 0, editTurns: 2, oneShotTurns: 1 } }, + providers: { 'claude': { calls: 10, cost, savingsUSD: 0 } }, + } + } + + it('sums cost, calls, sessions, tokens across days', () => { + const days = [makeDay('2026-04-09', 10), makeDay('2026-04-10', 20)] + const pd = buildPeriodDataFromDays(days, '7 Days') + expect(pd.label).toBe('7 Days') + expect(pd.cost).toBe(30) + expect(pd.calls).toBe(20) + expect(pd.sessions).toBe(4) + expect(pd.inputTokens).toBe(200) + expect(pd.outputTokens).toBe(400) + expect(pd.cacheReadTokens).toBe(600) + }) + + it('merges per-model totals across days and sorts by cost desc', () => { + const days = [makeDay('2026-04-09', 10), makeDay('2026-04-10', 20)] + const pd = buildPeriodDataFromDays(days, 'Today') + expect(pd.models[0]!.name).toBe('Opus 4.7') + expect(pd.models[0]!.cost).toBeCloseTo(24) + expect(pd.models[1]!.name).toBe('Haiku 4.5') + expect(pd.models[1]!.cost).toBeCloseTo(6) + }) + + it('merges per-category totals and keeps editTurns + oneShotTurns per category', () => { + const days = [makeDay('2026-04-09', 10), makeDay('2026-04-10', 20)] + const pd = buildPeriodDataFromDays(days, 'Today') + const coding = pd.categories.find(c => c.name === 'Coding')! + expect(coding.turns).toBe(4) + expect(coding.editTurns).toBe(4) + expect(coding.oneShotTurns).toBe(2) + expect(coding.cost).toBeCloseTo(15) + }) + + it('returns empty period totals when no days supplied', () => { + const pd = buildPeriodDataFromDays([], 'Today') + expect(pd.cost).toBe(0) + expect(pd.calls).toBe(0) + expect(pd.sessions).toBe(0) + expect(pd.categories).toEqual([]) + expect(pd.models).toEqual([]) + }) + + it('attributes a midnight-straddling turn to the first assistant call date, not the user message date', () => { + // Regression for the bug that shipped in 0.8.2-0.8.4: when a user message + // sat on one side of midnight and the assistant response landed on the other, + // day-aggregator.ts bucketed by assistant time but renderStatusBar bucketed + // by user time, so the menubar and `codeburn status` disagreed on Today. + // The invariant for both surfaces: a turn is counted on the day its first + // assistant call actually ran. + const userTs = '2026-04-20T23:58:00Z' + const assistantTs = '2026-04-21T00:30:00Z' + const assistantLocal = new Date(assistantTs) + const expectedDate = `${assistantLocal.getFullYear()}-${String(assistantLocal.getMonth() + 1).padStart(2, '0')}-${String(assistantLocal.getDate()).padStart(2, '0')}` + + const projects: ProjectSummary[] = [ + makeProject({ + sessions: [{ + sessionId: 's1', + project: 'p', + firstTimestamp: userTs, + lastTimestamp: assistantTs, + totalCostUSD: 5, + totalInputTokens: 0, totalOutputTokens: 0, totalCacheReadTokens: 0, totalCacheWriteTokens: 0, + apiCalls: 1, + turns: [{ + userMessage: 'ask', + timestamp: userTs, + sessionId: 's1', + category: 'coding', + retries: 0, + hasEdits: false, + assistantCalls: [makeCall(assistantTs, 5)], + }], + modelBreakdown: {}, toolBreakdown: {}, mcpBreakdown: {}, bashBreakdown: {}, + categoryBreakdown: {} as never, + skillBreakdown: {} as never, + }], + }), + ] + + const days = aggregateProjectsIntoDays(projects) + const costDay = days.find(d => d.cost === 5) + expect(costDay, 'turn cost must be bucketed somewhere').toBeDefined() + expect(costDay!.date).toBe(expectedDate) + expect(costDay!.calls).toBe(1) + }) +}) diff --git a/tests/export.test.ts b/tests/export.test.ts new file mode 100644 index 0000000..1980322 --- /dev/null +++ b/tests/export.test.ts @@ -0,0 +1,226 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, readFile, readdir, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { exportCsv, exportJson, type PeriodExport } from '../src/export.js' +import type { ProjectSummary } from '../src/types.js' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'export-test-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +function makeProject(projectPath: string): ProjectSummary { + return { + project: projectPath, + projectPath, + sessions: [ + { + sessionId: 'sess-001', + project: projectPath, + firstTimestamp: '2026-04-14T10:00:00Z', + lastTimestamp: '2026-04-14T10:01:00Z', + totalCostUSD: 1.23, + totalInputTokens: 100, + totalOutputTokens: 50, + totalCacheReadTokens: 0, + totalCacheWriteTokens: 0, + apiCalls: 1, + turns: [ + { + userMessage: '=SUM(1,2)', + timestamp: '2026-04-14T10:00:00Z', + sessionId: 'sess-001', + category: 'coding', + retries: 0, + hasEdits: true, + assistantCalls: [ + { + provider: 'claude', + model: '+danger-model', + usage: { + inputTokens: 100, + outputTokens: 50, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + }, + costUSD: 1.23, + tools: ['Read'], + mcpTools: [], + skills: [], + hasAgentSpawn: false, + hasPlanMode: false, + speed: 'standard', + timestamp: '2026-04-14T10:00:00Z', + bashCommands: ['@malicious'], + deduplicationKey: 'dedup-1', + }, + ], + }, + ], + modelBreakdown: { + '+danger-model': { + calls: 1, + costUSD: 1.23, + tokens: { + inputTokens: 100, + outputTokens: 50, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + }, + }, + }, + toolBreakdown: { + Read: { calls: 1 }, + }, + mcpBreakdown: {}, + bashBreakdown: { + '@malicious': { calls: 1 }, + }, + categoryBreakdown: { + coding: { turns: 1, costUSD: 1.23, retries: 0, editTurns: 1, oneShotTurns: 1 }, + debugging: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + feature: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + refactoring: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + testing: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + exploration: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + planning: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + delegation: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + git: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + 'build/deploy': { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + conversation: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + brainstorming: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + general: { turns: 0, costUSD: 0, retries: 0, editTurns: 0, oneShotTurns: 0 }, + }, + skillBreakdown: {}, + }, + ], + totalCostUSD: 1.23, + totalApiCalls: 1, + } +} + +describe('exportCsv', () => { + it('prefixes formula-like cells to prevent CSV injection', async () => { + const periods: PeriodExport[] = [ + { + label: '30 Days', + projects: [makeProject('=cmd,calc')], + }, + ] + + const outputPath = join(tmpDir, 'report.csv') + const folder = await exportCsv(periods, outputPath) + // exportCsv now writes a folder of clean one-table-per-file CSVs, so the formula-prefix + // guard is scattered across files. Concatenate them for the assertion surface. + const [projects, models, shell] = await Promise.all([ + readFile(join(folder, 'projects.csv'), 'utf-8'), + readFile(join(folder, 'models.csv'), 'utf-8'), + readFile(join(folder, 'shell-commands.csv'), 'utf-8'), + ]) + const content = projects + models + shell + + expect(content).toContain("\"'=cmd,calc\"") + expect(content).toContain("'+danger-model") + expect(content).toContain("'@malicious") + }) + + it('escapes tab and carriage-return prefixes in CSV cells', async () => { + const periods: PeriodExport[] = [ + { + label: '30 Days', + projects: [makeProject('\tcmd'), makeProject('\rcmd')], + }, + ] + + const outputPath = join(tmpDir, 'tab-cr.csv') + const folder = await exportCsv(periods, outputPath) + const projects = await readFile(join(folder, 'projects.csv'), 'utf-8') + expect(projects).toContain("'\tcmd") + expect(projects).toContain("'\rcmd") + }) + + it('includes per-model efficiency metrics', async () => { + const periods: PeriodExport[] = [ + { + label: '30 Days', + projects: [makeProject('app')], + }, + ] + + const outputPath = join(tmpDir, 'models.csv') + const folder = await exportCsv(periods, outputPath) + const models = await readFile(join(folder, 'models.csv'), 'utf-8') + + expect(models).toContain('Edit Turns') + expect(models).toContain('One-shot Rate (%)') + expect(models).toContain('Retries/Edit') + expect(models).toContain('Cost/Edit') + expect(models).toContain(',1,100,0,') + }) + + it('does not crash when periods array is empty', async () => { + const outputPath = join(tmpDir, 'empty.csv') + const folder = await exportCsv([], outputPath) + const entries = await readdir(folder) + expect(entries.length).toBeGreaterThanOrEqual(0) + }) + + it('describes detail files without hardcoding a 30-day window', async () => { + const periods: PeriodExport[] = [ + { + label: '2026-04-07 to 2026-04-10', + projects: [makeProject('app')], + }, + ] + + const outputPath = join(tmpDir, 'custom.csv') + const folder = await exportCsv(periods, outputPath) + const readme = await readFile(join(folder, 'README.txt'), 'utf-8') + + expect(readme).toContain('selected detail period') + expect(readme).not.toContain('30-day window') + }) + + it('writes MCP server usage to mcp.csv', async () => { + const project = makeProject('app') + project.sessions[0]!.mcpBreakdown = { node_repl: { calls: 5 } } + const periods: PeriodExport[] = [{ label: '30 Days', projects: [project] }] + + const folder = await exportCsv(periods, join(tmpDir, 'mcp.csv')) + const mcp = await readFile(join(folder, 'mcp.csv'), 'utf-8') + + expect(mcp).toContain('Server,Calls,Share (%)') + expect(mcp).toContain('node_repl,5,100') + }) +}) + +describe('exportJson', () => { + it('includes an mcp section with per-server usage', async () => { + const project = makeProject('app') + project.sessions[0]!.mcpBreakdown = { node_repl: { calls: 3 }, github: { calls: 1 } } + const periods: PeriodExport[] = [{ label: '30 Days', projects: [project] }] + + const outputPath = join(tmpDir, 'export.json') + const saved = await exportJson(periods, outputPath) + const data = JSON.parse(await readFile(saved, 'utf-8')) + + expect(Array.isArray(data.mcp)).toBe(true) + expect(data.mcp).toEqual([ + { Server: 'node_repl', Calls: 3, 'Share (%)': 75 }, + { Server: 'github', Calls: 1, 'Share (%)': 25 }, + ]) + }) +}) diff --git a/tests/fetch-utils.test.ts b/tests/fetch-utils.test.ts new file mode 100644 index 0000000..e613f8b --- /dev/null +++ b/tests/fetch-utils.test.ts @@ -0,0 +1,51 @@ +import { describe, it, expect, afterEach } from 'vitest' +import { createServer, type Server } from 'node:http' +import { type AddressInfo } from 'node:net' + +import { fetchWithTimeout } from '../src/fetch-utils.js' + +let server: Server + +afterEach(async () => { + await new Promise<void>(resolve => server?.close(() => resolve())) +}) + +function listen(handler: (respond: () => void) => void): Promise<string> { + return new Promise(resolve => { + server = createServer((_req, res) => handler(() => res.end('{"ok":true}'))) + server.listen(0, '127.0.0.1', () => { + const { port } = server.address() as AddressInfo + resolve(`http://127.0.0.1:${port}/`) + }) + }) +} + +describe('fetchWithTimeout', () => { + it('aborts when the server never responds, within the timeout window', async () => { + // Accept the request but never reply — the half-open-network case. + const url = await listen(() => { /* never respond */ }) + + const start = Date.now() + await expect(fetchWithTimeout(url, {}, 150)).rejects.toMatchObject({ name: 'TimeoutError' }) + const elapsed = Date.now() - start + + // Fails fast at ~the timeout, not hanging indefinitely. + expect(elapsed).toBeLessThan(2000) + }) + + it('returns the response when the server replies before the timeout', async () => { + const url = await listen(respond => respond()) + + const res = await fetchWithTimeout(url, {}, 2000) + expect(res.ok).toBe(true) + expect(await res.json()).toEqual({ ok: true }) + }) + + it('still aborts on timeout when the caller also passes a signal', async () => { + const url = await listen(() => { /* never respond */ }) + const controller = new AbortController() + + await expect(fetchWithTimeout(url, { signal: controller.signal }, 150)) + .rejects.toMatchObject({ name: 'TimeoutError' }) + }) +}) diff --git a/tests/fixtures/antigravity-cli-current/brain/fixture-current-cli/.system_generated/logs/transcript.jsonl b/tests/fixtures/antigravity-cli-current/brain/fixture-current-cli/.system_generated/logs/transcript.jsonl new file mode 100644 index 0000000..b642823 --- /dev/null +++ b/tests/fixtures/antigravity-cli-current/brain/fixture-current-cli/.system_generated/logs/transcript.jsonl @@ -0,0 +1,2 @@ +{"step_index":0,"source":"USER_EXPLICIT","type":"USER_INPUT","status":"DONE","created_at":"2026-06-21T13:32:13Z","content":"<USER_REQUEST>sanitized fixture prompt</USER_REQUEST>"} +{"step_index":1,"source":"MODEL","type":"PLANNER_RESPONSE","status":"DONE","created_at":"2026-06-21T13:32:14Z","content":"sanitized fixture response","thinking":"sanitized fixture reasoning"} diff --git a/tests/fixtures/antigravity-cli-current/gen-metadata.json b/tests/fixtures/antigravity-cli-current/gen-metadata.json new file mode 100644 index 0000000..d9742d8 --- /dev/null +++ b/tests/fixtures/antigravity-cli-current/gen-metadata.json @@ -0,0 +1,10 @@ +{ + "conversationId": "fixture-current-cli", + "layout": "~/.gemini/antigravity-cli/conversations/<conversation-id>.db with sibling brain/<conversation-id>/.system_generated/logs/transcript.jsonl", + "rows": [ + { + "idx": 0, + "hex": "120202032213666978747572652d63757272656e742d636c690ace01222508f80710b9ec0118da05301848930550475a12666978747572652d726573706f6e73652d319a011267656d696e692d70726f2d64656661756c74a201230a0d7472616a6563746f72795f69641212666978747572652d7472616a6563746f7279a201140a0b757365645f636c61756465120566616c7365a201140a0f6c6173745f737465705f696e646578120132a201230a0a6d6f64656c5f656e756d12154d4f44454c5f504c414345484f4c4445525f4d3136aa011547656d696e6920332e312050726f20284869676829" + } + ] +} diff --git a/tests/fixtures/cursor-agent/workspace-less/projects/agent-transcripts/1031d227-0c67-4e17-8954-0b6e2b3322f0/1031d227-0c67-4e17-8954-0b6e2b3322f0.jsonl b/tests/fixtures/cursor-agent/workspace-less/projects/agent-transcripts/1031d227-0c67-4e17-8954-0b6e2b3322f0/1031d227-0c67-4e17-8954-0b6e2b3322f0.jsonl new file mode 100644 index 0000000..d5a29e9 --- /dev/null +++ b/tests/fixtures/cursor-agent/workspace-less/projects/agent-transcripts/1031d227-0c67-4e17-8954-0b6e2b3322f0/1031d227-0c67-4e17-8954-0b6e2b3322f0.jsonl @@ -0,0 +1,2 @@ +{"role":"user","message":{"content":[{"type":"text","text":"<user_query>\nRun a quick smoke test\n</user_query>"}]}} +{"role":"assistant","message":{"content":[{"type":"text","text":"Smoke test passed."}]}} diff --git a/tests/fixtures/open-design/namespaces/release-stable/data/runs/run-mixed/events.jsonl b/tests/fixtures/open-design/namespaces/release-stable/data/runs/run-mixed/events.jsonl new file mode 100644 index 0000000..d8e5896 --- /dev/null +++ b/tests/fixtures/open-design/namespaces/release-stable/data/runs/run-mixed/events.jsonl @@ -0,0 +1,5 @@ +{"id":"evt-start","event":"start","timestamp":"2026-06-22T10:00:00.000Z","data":{"model":"openai-codex:gpt-5.5"}} +{"id":"evt-codex-usage","event":"agent","timestamp":1782122405000,"data":{"type":"usage","usage":{"input_tokens":1000,"output_tokens":200,"cached_read_tokens":50,"thought_tokens":25,"total_tokens":1200},"costUsd":null}} +{"id":"evt-status-glm","event":"agent","timestamp":"2026-06-22T10:00:10.000Z","data":{"type":"status","model":"glm-5.2"}} +{"id":"evt-glm-usage","event":"agent","timestamp":"2026-06-22T10:00:15.000Z","data":{"type":"usage","usage":{"input_tokens":3000,"output_tokens":400,"cached_read_tokens":100,"thought_tokens":60,"total_tokens":3560},"costUsd":null}} +{"id":"evt-glm-usage","event":"agent","timestamp":"2026-06-22T10:00:16.000Z","data":{"type":"usage","usage":{"input_tokens":9999,"output_tokens":9999,"cached_read_tokens":9999,"thought_tokens":9999,"total_tokens":39996},"costUsd":null}} diff --git a/tests/fixtures/open-design/namespaces/release-stable/data/runs/run-no-usage/events.jsonl b/tests/fixtures/open-design/namespaces/release-stable/data/runs/run-no-usage/events.jsonl new file mode 100644 index 0000000..aa3e0ed --- /dev/null +++ b/tests/fixtures/open-design/namespaces/release-stable/data/runs/run-no-usage/events.jsonl @@ -0,0 +1,3 @@ +{"id":"evt-start","event":"start","timestamp":"2026-06-22T11:00:00.000Z","data":{"model":"glm-5.2"}} +{"id":"evt-status","event":"agent","timestamp":"2026-06-22T11:00:05.000Z","data":{"type":"status","model":"openai-codex:gpt-5.5"}} +{"id":"evt-message","event":"agent","timestamp":"2026-06-22T11:00:10.000Z","data":{"type":"message","text":"no usage was emitted"}} diff --git a/tests/fixtures/open-design/namespaces/release-stable/data/runs/run-start-seeded/events.jsonl b/tests/fixtures/open-design/namespaces/release-stable/data/runs/run-start-seeded/events.jsonl new file mode 100644 index 0000000..a4d5aaa --- /dev/null +++ b/tests/fixtures/open-design/namespaces/release-stable/data/runs/run-start-seeded/events.jsonl @@ -0,0 +1,3 @@ +{"id":"evt-start","event":"start","timestamp":"2026-06-22T12:00:00.000Z","data":{"model":"glm-5.2"}} +{"id":"evt-before-transition","event":"agent","timestamp":"2026-06-22T12:00:05.000Z","data":{"type":"usage","usage":{"input_tokens":777,"output_tokens":33,"cached_read_tokens":7,"thought_tokens":3,"total_tokens":820},"costUsd":null}} +{"id":"evt-status","event":"agent","timestamp":"2026-06-22T12:00:10.000Z","data":{"type":"status","model":"openai-codex:gpt-5.5"}} diff --git a/tests/fixtures/security/proto-bash.jsonl b/tests/fixtures/security/proto-bash.jsonl new file mode 100644 index 0000000..8e6b5e7 --- /dev/null +++ b/tests/fixtures/security/proto-bash.jsonl @@ -0,0 +1 @@ +{"type":"assistant","sessionId":"security-test","timestamp":"2026-04-16T00:00:00Z","message":{"id":"pwn-bash","type":"message","role":"assistant","model":"claude-opus-4-6","content":[{"type":"tool_use","id":"b1","name":"Bash","input":{"command":"/x/__proto__"}}],"usage":{"input_tokens":1,"output_tokens":1}}} diff --git a/tests/fixtures/security/proto-model.jsonl b/tests/fixtures/security/proto-model.jsonl new file mode 100644 index 0000000..0aabf71 --- /dev/null +++ b/tests/fixtures/security/proto-model.jsonl @@ -0,0 +1 @@ +{"type":"assistant","sessionId":"security-test","timestamp":"2026-04-16T00:00:00Z","message":{"id":"pwn-model","type":"message","role":"assistant","model":"__proto__","content":[{"type":"text","text":"x"}],"usage":{"input_tokens":1,"output_tokens":1}}} diff --git a/tests/fixtures/security/proto-tool.jsonl b/tests/fixtures/security/proto-tool.jsonl new file mode 100644 index 0000000..a93a853 --- /dev/null +++ b/tests/fixtures/security/proto-tool.jsonl @@ -0,0 +1 @@ +{"type":"assistant","sessionId":"security-test","timestamp":"2026-04-16T00:00:00Z","message":{"id":"pwn-tool","type":"message","role":"assistant","model":"claude-opus-4-6","content":[{"type":"tool_use","id":"t1","name":"__proto__","input":{}}],"usage":{"input_tokens":1,"output_tokens":1}}} diff --git a/tests/fs-utils.test.ts b/tests/fs-utils.test.ts new file mode 100644 index 0000000..13e7464 --- /dev/null +++ b/tests/fs-utils.test.ts @@ -0,0 +1,195 @@ +import { describe, it, expect, afterEach, vi } from 'vitest' +import { mkdtemp, writeFile, rm } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' + +import { + MAX_SESSION_FILE_BYTES, + MAX_STREAM_SESSION_FILE_BYTES, + readSessionFile, + readSessionLines, +} from '../src/fs-utils.js' + +describe('readSessionFile', () => { + const tmpDirs: string[] = [] + + afterEach(async () => { + delete process.env.CODEBURN_VERBOSE + while (tmpDirs.length > 0) { + const d = tmpDirs.pop() + if (d) await rm(d, { recursive: true, force: true }) + } + }) + + async function tmpPath(content: string | Buffer): Promise<string> { + const base = await mkdtemp(join(tmpdir(), 'codeburn-fs-')) + tmpDirs.push(base) + const p = join(base, 'x.jsonl') + await writeFile(p, content) + return p + } + + it('returns content for small files via readFile fast path', async () => { + const p = await tmpPath('hello\nworld\n') + expect(await readSessionFile(p)).toBe('hello\nworld\n') + }) + + it('returns content for large files under the full-file cap', async () => { + const size = 8 * 1024 * 1024 + const p = await tmpPath(Buffer.alloc(size, 'a')) + const got = await readSessionFile(p) + expect(got).not.toBeNull() + expect(got!.length).toBe(size) + }) + + it('returns null and skips files over the cap', async () => { + const p = await tmpPath(Buffer.alloc(MAX_SESSION_FILE_BYTES + 1, 'b')) + expect(await readSessionFile(p)).toBeNull() + }) + + it('emits stderr warning under CODEBURN_VERBOSE=1 for skipped file', async () => { + process.env.CODEBURN_VERBOSE = '1' + const p = await tmpPath(Buffer.alloc(MAX_SESSION_FILE_BYTES + 1, 'c')) + const spy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true) + await readSessionFile(p) + expect(spy).toHaveBeenCalled() + const msg = (spy.mock.calls[0][0] as string) + expect(msg).toContain('codeburn') + expect(msg).toContain('oversize') + spy.mockRestore() + }) + + it('returns null on stat failure without throwing', async () => { + expect(await readSessionFile('/nonexistent/path/x.jsonl')).toBeNull() + }) +}) + +describe('readSessionLines', () => { + const tmpDirs: string[] = [] + + afterEach(async () => { + while (tmpDirs.length > 0) { + const d = tmpDirs.pop() + if (d) await rm(d, { recursive: true, force: true }) + } + }) + + async function tmpPath(content: string): Promise<string> { + const base = await mkdtemp(join(tmpdir(), 'codeburn-lines-')) + tmpDirs.push(base) + const p = join(base, 'session.jsonl') + await writeFile(p, content) + return p + } + + it('yields all lines from a file', async () => { + const p = await tmpPath('line1\nline2\nline3\n') + const lines: string[] = [] + for await (const line of readSessionLines(p)) lines.push(line) + expect(lines).toEqual(['line1', 'line2', 'line3']) + }) + + it('skips old large lines before materializing the full line', async () => { + const oldLine = `{"type":"assistant","timestamp":"2026-01-01T00:00:00Z","payload":"${'x'.repeat(100_000)}"}` + const newLine = '{"type":"assistant","timestamp":"2026-05-01T00:00:00Z"}' + const p = await tmpPath(`${oldLine}\n${newLine}\n`) + const lines: string[] = [] + for await (const line of readSessionLines(p, head => head.includes('2026-01-01'))) { + lines.push(line) + } + expect(lines).toEqual([newLine]) + }) + + it('yields large lines as Buffers when requested', async () => { + const largeLine = `{"type":"assistant","timestamp":"2026-05-01T00:00:00Z","payload":"${'x'.repeat(100_000)}"}` + const p = await tmpPath(`${largeLine}\nsmall\n`) + const lines: Array<string | Buffer> = [] + for await (const line of readSessionLines(p, undefined, { largeLineAsBuffer: true })) { + lines.push(line) + } + expect(Buffer.isBuffer(lines[0])).toBe(true) + expect(lines[1]).toBe('small') + }) + + it('does not leak file descriptors when generator is abandoned early', async () => { + const content = Array.from({ length: 1000 }, (_, i) => `line-${i}`).join('\n') + const p = await tmpPath(content) + const gen = readSessionLines(p) + await gen.next() + await gen.return(undefined) + }) + + it('reads from startByteOffset, yielding only lines after the offset', async () => { + const content = 'line1\nline2\nline3\n' + const p = await tmpPath(content) + const offset = Buffer.byteLength('line1\n') + const lines: string[] = [] + for await (const line of readSessionLines(p, undefined, { startByteOffset: offset })) { + lines.push(line) + } + expect(lines).toEqual(['line2', 'line3']) + }) + + it('byteOffsetTracker tracks position after last complete newline', async () => { + const content = 'aaa\nbbb\nccc\n' + const p = await tmpPath(content) + const tracker = { lastCompleteLineOffset: 0 } + const lines: string[] = [] + for await (const line of readSessionLines(p, undefined, { byteOffsetTracker: tracker })) { + lines.push(line) + } + expect(lines).toEqual(['aaa', 'bbb', 'ccc']) + expect(tracker.lastCompleteLineOffset).toBe(Buffer.byteLength(content)) + }) + + it('byteOffsetTracker accounts for startByteOffset', async () => { + const content = 'line1\nline2\nline3\n' + const p = await tmpPath(content) + const offset = Buffer.byteLength('line1\n') + const tracker = { lastCompleteLineOffset: 0 } + for await (const _line of readSessionLines(p, undefined, { startByteOffset: offset, byteOffsetTracker: tracker })) {} + expect(tracker.lastCompleteLineOffset).toBe(Buffer.byteLength(content)) + }) + + it('byteOffsetTracker excludes trailing partial line (no final newline)', async () => { + const content = 'line1\nline2\npartial' + const p = await tmpPath(content) + const tracker = { lastCompleteLineOffset: 0 } + for await (const _line of readSessionLines(p, undefined, { byteOffsetTracker: tracker })) {} + expect(tracker.lastCompleteLineOffset).toBe(Buffer.byteLength('line1\nline2\n')) + }) + + it('byteOffsetTracker updates for skipped lines too', async () => { + const content = 'skip-me\nkeep-me\n' + const p = await tmpPath(content) + const tracker = { lastCompleteLineOffset: 0 } + const lines: string[] = [] + for await (const line of readSessionLines(p, head => head.includes('skip-me'), { byteOffsetTracker: tracker })) { + lines.push(line) + } + expect(lines).toEqual(['keep-me']) + expect(tracker.lastCompleteLineOffset).toBe(Buffer.byteLength(content)) + }) + + it('reads files at or under the stream cap', async () => { + const p = await tmpPath('a\nb\nc\n') + const lines: string[] = [] + for await (const line of readSessionLines(p, undefined, { maxBytes: 1024 })) lines.push(line) + expect(lines).toEqual(['a', 'b', 'c']) + }) + + it('skips files over the stream cap and surfaces a notice without CODEBURN_VERBOSE', async () => { + const p = await tmpPath('a\nb\nc\n') + const spy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true) + const lines: string[] = [] + for await (const line of readSessionLines(p, undefined, { maxBytes: 1 })) lines.push(line) + expect(lines).toEqual([]) + expect(spy).toHaveBeenCalled() + expect(spy.mock.calls[0][0] as string).toContain('skipped oversize session') + spy.mockRestore() + }) + + it('stream cap is generous enough for multi-GB Codex sessions', () => { + expect(MAX_STREAM_SESSION_FILE_BYTES).toBe(4 * 1024 * 1024 * 1024) + }) +}) diff --git a/tests/guard-hooks.test.ts b/tests/guard-hooks.test.ts new file mode 100644 index 0000000..ef5d6b2 --- /dev/null +++ b/tests/guard-hooks.test.ts @@ -0,0 +1,371 @@ +import { afterAll, describe, expect, it } from 'vitest' +import { appendFile, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { dedupeStreamingMessageIds, parseApiCall, parseJsonlLine } from '../src/parser.js' +import { computeSessionUsage, emptyCache, readCache, writeAllow, writeCache } from '../src/guard/usage.js' +import { runGuardHook, runGuardStatusline } from '../src/guard/hooks.js' +import { writeGuardConfig, DEFAULT_GUARD_CONFIG } from '../src/guard/store.js' +import { buildFlags, matchFlag, writeFlags, type GuardFlags } from '../src/guard/flags.js' +import type { ProjectSummary } from '../src/types.js' + +const roots: string[] = [] +async function tmp(): Promise<string> { + const d = await mkdtemp(join(tmpdir(), 'codeburn-guard-hooks-')) + roots.push(d) + return d +} +afterAll(async () => { for (const r of roots) await rm(r, { recursive: true, force: true }) }) + +type Tool = { name: string; input?: Record<string, unknown> } +function assistantLine(id: string, o: { inTok?: number; outTok?: number; tools?: Tool[]; ts?: string } = {}): string { + const content: Record<string, unknown>[] = [{ type: 'text', text: 'ok' }] + for (const t of o.tools ?? []) content.push({ type: 'tool_use', id: `${t.name}-${id}`, name: t.name, input: t.input ?? {} }) + return JSON.stringify({ + type: 'assistant', + timestamp: o.ts ?? '2026-07-01T00:00:00.000Z', + message: { + model: 'claude-sonnet-4-20250514', + id, + type: 'message', + role: 'assistant', + usage: { input_tokens: o.inTok ?? 1_000_000, output_tokens: o.outTok ?? 200_000, cache_read_input_tokens: 0 }, + content, + }, + }) + '\n' +} + +async function transcript(lines: string[]): Promise<string> { + const dir = await tmp() + const path = join(dir, 'session.jsonl') + await writeFile(path, lines.join(''), 'utf-8') + return path +} + +const SID = 'sess-1' +function hookInput(path: string): string { + return JSON.stringify({ session_id: SID, transcript_path: path, hook_event_name: 'PreToolUse', tool_name: 'Bash' }) +} + +// The shipped pipeline's cost for a transcript: parse every line, dedupe +// streaming copies last-wins exactly like parseSessionFile does, sum call +// costs. The guard's incremental fold must match this to the cent. +async function shippedDedupedCost(path: string): Promise<number> { + const entries = (await readFile(path, 'utf-8')) + .split('\n') + .filter(l => l.trim()) + .map(l => parseJsonlLine(l)) + .filter((e): e is NonNullable<ReturnType<typeof parseJsonlLine>> => e !== null) + return dedupeStreamingMessageIds(entries).reduce((s, e) => s + (parseApiCall(e)?.costUSD ?? 0), 0) +} + +describe('incremental session cache', () => { + it('parses only the appended tail and totals match a cold parse', async () => { + const base = await tmp() + const path = await transcript([assistantLine('a'), assistantLine('b')]) + + const r1 = await computeSessionUsage(emptyCache(SID), path) + await writeCache(r1.cache, base) + expect(r1.resumedFrom).toBe(0) + expect(r1.cache.costUSD).toBeGreaterThan(0) + const offset1 = r1.cache.byteOffset + + await appendFile(path, assistantLine('c') + assistantLine('d'), 'utf-8') + const size = (await stat(path)).size + + const prev = await readCache(SID, base) + const r2 = await computeSessionUsage(prev, path) + + // Bytes-read assertion: the second pass resumed exactly where the first + // stopped and consumed only the appended region (not the whole file). + expect(r2.resumedFrom).toBe(offset1) + expect(r2.cache.byteOffset).toBe(size) + expect(r2.cache.byteOffset - r2.resumedFrom).toBeGreaterThan(0) + expect(r2.resumedFrom).toBeLessThan(size) + + const cold = await computeSessionUsage(emptyCache(SID), path) + expect(r2.cache.costUSD).toBeCloseTo(cold.cache.costUSD, 10) + expect(r2.cache.costUSD).toBeGreaterThan(r1.cache.costUSD) + }) + + it('resets to a cold parse when the transcript shrinks (rotation)', async () => { + const base = await tmp() + const path = await transcript([assistantLine('a'), assistantLine('b')]) + const r1 = await computeSessionUsage(emptyCache(SID), path) + await writeCache(r1.cache, base) + + await writeFile(path, assistantLine('z'), 'utf-8') // smaller file, new content + const r2 = await computeSessionUsage(await readCache(SID, base), path) + expect(r2.resumedFrom).toBe(0) + const cold = await computeSessionUsage(emptyCache(SID), path) + expect(r2.cache.costUSD).toBeCloseTo(cold.cache.costUSD, 10) + }) +}) + +describe('streaming duplicates (per-message-id replace)', () => { + it('counts a message written 3x with identical usage once, matching the shipped dedup', async () => { + const dup = assistantLine('msg-dup', { inTok: 500_000, outTok: 100_000 }) + const path = await transcript([dup, dup, dup, assistantLine('msg-other')]) + const singlePath = await transcript([dup, assistantLine('msg-other')]) + + const { cache } = await computeSessionUsage(emptyCache(SID), path) + expect(cache.costUSD).toBeCloseTo(await shippedDedupedCost(path), 10) + const single = await computeSessionUsage(emptyCache(SID), singlePath) + expect(cache.costUSD).toBeCloseTo(single.cache.costUSD, 10) + }) + + it('keeps the last copy when streamed usage grows', async () => { + const copies = [10_000, 50_000, 120_000].map(outTok => assistantLine('msg-grow', { outTok })) + const path = await transcript(copies) + const lastOnly = await transcript([copies[2]!]) + + const { cache } = await computeSessionUsage(emptyCache(SID), path) + expect(cache.costUSD).toBeCloseTo(await shippedDedupedCost(path), 10) + const last = await computeSessionUsage(emptyCache(SID), lastOnly) + expect(cache.costUSD).toBeCloseTo(last.cache.costUSD, 10) + }) + + it('replaces across incremental invocations when a later copy arrives', async () => { + const base = await tmp() + const path = await transcript([assistantLine('msg-x', { outTok: 20_000 })]) + const r1 = await computeSessionUsage(emptyCache(SID), path) + await writeCache(r1.cache, base) + + await appendFile(path, assistantLine('msg-x', { outTok: 90_000 }) + assistantLine('msg-y'), 'utf-8') + const r2 = await computeSessionUsage(await readCache(SID, base), path) + expect(r2.resumedFrom).toBe(r1.cache.byteOffset) + expect(r2.cache.costUSD).toBeCloseTo(await shippedDedupedCost(path), 10) + }) +}) + +describe('trailing complete line without newline', () => { + it('does not double count the line once it completes (A,B,C then D)', async () => { + const base = await tmp() + const a = assistantLine('msg-a') + const b = assistantLine('msg-b') + const c = assistantLine('msg-c') + const d = assistantLine('msg-d') + const dir = await tmp() + const path = join(dir, 'session.jsonl') + await writeFile(path, a + b + c.slice(0, -1), 'utf-8') // C complete but unterminated + + const r1 = await computeSessionUsage(emptyCache(SID), path) + await writeCache(r1.cache, base) + // C was folded, but the offset stops after B's newline. + expect(r1.cache.costUSD).toBeCloseTo(await shippedDedupedCost(path), 10) + expect(r1.cache.byteOffset).toBe((a + b).length) + + await appendFile(path, '\n' + d, 'utf-8') + const r2 = await computeSessionUsage(await readCache(SID, base), path) + // C is re-read as a replace, not a second add: totals equal a cold parse. + const cold = await computeSessionUsage(emptyCache(SID), path) + expect(r2.cache.costUSD).toBeCloseTo(cold.cache.costUSD, 10) + expect(r2.cache.costUSD).toBeCloseTo(await shippedDedupedCost(path), 10) + }) +}) + +describe('git commit detection', () => { + it('requires commit to be the git subcommand', async () => { + const cases: [string, boolean][] = [ + ['git commit -m x', true], + ['git -c user.name=x commit', true], + ['npm test && git commit -am done', true], + ['git add src\ngit commit -m "step"', true], // newline-separated multi-command Bash call + ['git log --grep commit', false], + ['git diff && echo commit', false], + ['echo git then commit', false], + ['git diff\ncommit notes to self', false], // commit on the next line is not a git subcommand + ] + for (const [command, expected] of cases) { + const path = await transcript([assistantLine('msg-1', { tools: [{ name: 'Bash', input: { command } }] })]) + const { cache } = await computeSessionUsage(emptyCache(SID), path) + expect(cache.sawGitCommit, command).toBe(expected) + } + }) +}) + +describe('budget hook (PreToolUse)', () => { + async function costOf(path: string): Promise<number> { + return (await computeSessionUsage(emptyCache(SID), path)).cache.costUSD + } + + it('stays silent below the soft cap', async () => { + const base = await tmp() + const path = await transcript([assistantLine('a')]) + const c = await costOf(path) + await writeGuardConfig({ ...DEFAULT_GUARD_CONFIG, softUSD: c * 2, hardUSD: c * 4 }, base) + expect(await runGuardHook('pretooluse', hookInput(path), { base })).toBe('') + }) + + it('warns once on the soft cap, then suppresses the repeat', async () => { + const base = await tmp() + const path = await transcript([assistantLine('a'), assistantLine('b')]) + const c = await costOf(path) + await writeGuardConfig({ ...DEFAULT_GUARD_CONFIG, softUSD: c * 0.5, hardUSD: c * 10 }, base) + + const first = await runGuardHook('pretooluse', hookInput(path), { base }) + expect(JSON.parse(first).systemMessage).toContain('soft cap') + const second = await runGuardHook('pretooluse', hookInput(path), { base }) + expect(second).toBe('') + }) + + it('blocks on the hard cap with a deny decision, and allow lifts it', async () => { + const base = await tmp() + const path = await transcript([assistantLine('a'), assistantLine('b')]) + const c = await costOf(path) + await writeGuardConfig({ ...DEFAULT_GUARD_CONFIG, softUSD: c * 0.2, hardUSD: c * 0.5 }, base) + + const blocked = JSON.parse(await runGuardHook('pretooluse', hookInput(path), { base })) + expect(blocked.hookSpecificOutput.hookEventName).toBe('PreToolUse') + expect(blocked.hookSpecificOutput.permissionDecision).toBe('deny') + expect(blocked.hookSpecificOutput.permissionDecisionReason).toContain('guard allow') + + await writeAllow(SID, base) + expect(await runGuardHook('pretooluse', hookInput(path), { base })).toBe('') + }) + + it('disables the cap when the threshold is null', async () => { + const base = await tmp() + const path = await transcript([assistantLine('a'), assistantLine('b')]) + await writeGuardConfig({ ...DEFAULT_GUARD_CONFIG, softUSD: null, hardUSD: null }, base) + expect(await runGuardHook('pretooluse', hookInput(path), { base })).toBe('') + }) +}) + +describe('yield checkpoint (Stop)', () => { + function stopInput(path: string): string { + return JSON.stringify({ session_id: SID, transcript_path: path, hook_event_name: 'Stop' }) + } + async function withCheckpoint(base: string, path: string): Promise<void> { + const c = (await computeSessionUsage(emptyCache(SID), path)).cache.costUSD + await writeGuardConfig({ ...DEFAULT_GUARD_CONFIG, checkpointUSD: c * 0.5 }, base) + } + + it('fires once for an expensive no-edit no-commit session', async () => { + const base = await tmp() + const path = await transcript([assistantLine('a'), assistantLine('b')]) + await withCheckpoint(base, path) + const first = JSON.parse(await runGuardHook('stop', stopInput(path), { base })) + expect(first.systemMessage).toContain('no edits or commits') + expect(await runGuardHook('stop', stopInput(path), { base })).toBe('') // once per session + }) + + it('stays silent when cost is below the checkpoint', async () => { + const base = await tmp() + const path = await transcript([assistantLine('a')]) + const c = (await computeSessionUsage(emptyCache(SID), path)).cache.costUSD + await writeGuardConfig({ ...DEFAULT_GUARD_CONFIG, checkpointUSD: c * 5 }, base) + expect(await runGuardHook('stop', stopInput(path), { base })).toBe('') + }) + + it('stays silent when the session made an edit', async () => { + const base = await tmp() + const path = await transcript([assistantLine('a', { tools: [{ name: 'Edit', input: { file_path: '/x' } }] }), assistantLine('b')]) + await withCheckpoint(base, path) + expect(await runGuardHook('stop', stopInput(path), { base })).toBe('') + }) + + it('stays silent when the session ran git commit', async () => { + const base = await tmp() + const path = await transcript([assistantLine('a', { tools: [{ name: 'Bash', input: { command: 'git commit -m wip' } }] }), assistantLine('b')]) + await withCheckpoint(base, path) + expect(await runGuardHook('stop', stopInput(path), { base })).toBe('') + }) +}) + +describe('session opener (SessionStart)', () => { + it('emits the matching opener text for a flagged project and nothing when stale', async () => { + const base = await tmp() + const projectPath = '/tmp/flagged-project' + const flags: GuardFlags = { generatedAt: new Date().toISOString(), projects: [{ path: projectPath, openers: ['DELIVERABLE OPENER'] }] } + await writeFlags(flags, base) + + const input = JSON.stringify({ session_id: SID, cwd: projectPath, hook_event_name: 'SessionStart', source: 'startup' }) + const out = JSON.parse(await runGuardHook('sessionstart', input, { base })) + expect(out.hookSpecificOutput.hookEventName).toBe('SessionStart') + expect(out.hookSpecificOutput.additionalContext).toBe('DELIVERABLE OPENER') + + // Unflagged cwd -> nothing. + const other = JSON.stringify({ session_id: SID, cwd: '/tmp/other', hook_event_name: 'SessionStart' }) + expect(await runGuardHook('sessionstart', other, { base })).toBe('') + + // Stale flag list (> 7 days) -> nothing. + const stale: GuardFlags = { generatedAt: new Date(Date.now() - 8 * 86_400_000).toISOString(), projects: flags.projects } + await writeFlags(stale, base) + expect(await runGuardHook('sessionstart', input, { base })).toBe('') + }) + + it('builds flags from optimize candidate detectors and matches by project path', async () => { + // A project whose only session has real spend but zero edit turns is a + // low-worth candidate; buildFlags should flag its projectPath. + const projects = [lowWorthProject()] + const flags = await buildFlags(projects as unknown as ProjectSummary[]) + expect(flags.projects.length).toBeGreaterThan(0) + expect(matchFlag(flags, '/repo/alpha').length).toBeGreaterThan(0) + expect(matchFlag(flags, '/repo/alpha/src')).toEqual(matchFlag(flags, '/repo/alpha')) // subdir matches + expect(matchFlag(flags, '/repo/beta')).toEqual([]) + }) +}) + +describe('fail-open: malformed stdin', () => { + it('every handler exits with empty output on garbage input', async () => { + const base = await tmp() + for (const ev of ['pretooluse', 'sessionstart', 'stop']) { + expect(await runGuardHook(ev, 'not json {', { base })).toBe('') + expect(await runGuardHook(ev, '', { base })).toBe('') + } + expect(await runGuardHook('unknownevent', JSON.stringify({ session_id: SID }), { base })).toBe('') + expect(await runGuardStatusline('not json {', { base })).toBe('') + }) + + it('handlers stay silent when the transcript path is missing', async () => { + const base = await tmp() + const noPath = JSON.stringify({ session_id: SID, hook_event_name: 'PreToolUse' }) + expect(await runGuardHook('pretooluse', noPath, { base })).toBe('') + expect(await runGuardHook('stop', noPath, { base })).toBe('') + }) +}) + +describe('statusline', () => { + it('prints one line with the session cost', async () => { + const base = await tmp() + const path = await transcript([assistantLine('a')]) + const out = await runGuardStatusline(JSON.stringify({ session_id: SID, transcript_path: path }), { base }) + expect(out.startsWith('codeburn guard $')).toBe(true) + expect(out).not.toContain('\n') + }) +}) + +// A minimal ProjectSummary shaped just enough for findLowWorthCandidates: +// meaningful cost, no delivery command, and no edit turns. +function lowWorthProject(): Record<string, unknown> { + const turn = { + userMessage: 'do a thing', + assistantCalls: [{ costUSD: 40, tools: [], bashCommands: [], timestamp: '2026-07-01T00:00:00Z' }], + timestamp: '2026-07-01T00:00:00Z', + sessionId: 's-alpha', + category: 'exploration', + retries: 0, + hasEdits: false, + } + const session = { + sessionId: 's-alpha', + project: 'alpha', + firstTimestamp: '2026-07-01T00:00:00Z', + lastTimestamp: '2026-07-01T01:00:00Z', + totalCostUSD: 40, + totalSavingsUSD: 0, + totalInputTokens: 100, totalOutputTokens: 100, totalReasoningTokens: 0, + totalCacheReadTokens: 0, totalCacheWriteTokens: 0, + apiCalls: 1, + turns: [turn], + modelBreakdown: {}, toolBreakdown: {}, mcpBreakdown: {}, bashBreakdown: {}, + categoryBreakdown: {}, skillBreakdown: {}, subagentBreakdown: {}, + } + return { + project: 'alpha', + projectPath: '/repo/alpha', + sessions: [session], + totalCostUSD: 40, totalSavingsUSD: 0, totalApiCalls: 1, totalProxiedCostUSD: 0, + } +} diff --git a/tests/guard-install.test.ts b/tests/guard-install.test.ts new file mode 100644 index 0000000..8c1e877 --- /dev/null +++ b/tests/guard-install.test.ts @@ -0,0 +1,158 @@ +import { afterAll, describe, expect, it } from 'vitest' +import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises' +import { existsSync } from 'node:fs' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { runAction } from '../src/act/apply.js' +import { readRecords } from '../src/act/journal.js' +import { + buildInstall, buildUninstall, inspectInstall, settingsPathFor, + GUARD_HOOK_PREFIX, GUARD_STATUSLINE_COMMAND, +} from '../src/guard/settings.js' + +const roots: string[] = [] +async function makeRoot(): Promise<{ settings: string; actionsDir: string }> { + const root = await mkdtemp(join(tmpdir(), 'codeburn-guard-install-')) + roots.push(root) + await mkdir(join(root, '.claude'), { recursive: true }) + return { settings: join(root, '.claude', 'settings.json'), actionsDir: join(root, 'actions') } +} +afterAll(async () => { for (const r of roots) await rm(r, { recursive: true, force: true }) }) + +function canonical(obj: unknown): string { + return JSON.stringify(obj, null, 2) + '\n' +} +async function readJson(path: string): Promise<any> { + return JSON.parse(await readFile(path, 'utf-8')) +} + +describe('settingsPathFor', () => { + it('resolves project (default) and global scopes', () => { + expect(settingsPathFor({ cwd: '/repo' })).toBe(join('/repo', '.claude', 'settings.json')) + expect(settingsPathFor({ project: '/x' })).toBe(join('/x', '.claude', 'settings.json')) + expect(settingsPathFor({ global: true })).toContain(join('.claude', 'settings.json')) + }) +}) + +describe('guard install', () => { + it('creates settings with all three hook events when none exists', async () => { + const { settings, actionsDir } = await makeRoot() + await rm(settings, { force: true }) + const built = buildInstall(settings) + expect(built.plan).not.toBeNull() + expect(built.plan!.kind).toBe('guard-install') + await runAction(built.plan!, actionsDir) + + const doc = await readJson(settings) + expect(Object.keys(doc.hooks).sort()).toEqual(['PreToolUse', 'SessionStart', 'Stop']) + expect(doc.hooks.PreToolUse[0].hooks[0].command).toBe(`${GUARD_HOOK_PREFIX} pretooluse`) + expect(doc.hooks.SessionStart[0].matcher).toBe('startup') + expect(doc.hooks.Stop[0].matcher).toBeUndefined() // Stop takes no matcher + // journaled + undoable + const records = await readRecords(actionsDir) + expect(records[0]!.kind).toBe('guard-install') + }) + + it('appends to pre-existing user hooks without disturbing them', async () => { + const { settings, actionsDir } = await makeRoot() + const original = canonical({ + hooks: { PreToolUse: [{ matcher: 'Bash', hooks: [{ type: 'command', command: 'my-own-hook.sh' }] }] }, + }) + await writeFile(settings, original) + + await runAction(buildInstall(settings).plan!, actionsDir) + const doc = await readJson(settings) + const commands = doc.hooks.PreToolUse.flatMap((g: any) => g.hooks.map((h: any) => h.command)) + expect(commands).toContain('my-own-hook.sh') + expect(commands).toContain(`${GUARD_HOOK_PREFIX} pretooluse`) + }) + + it('is idempotent: re-install adds nothing', async () => { + const { settings, actionsDir } = await makeRoot() + await rm(settings, { force: true }) + await runAction(buildInstall(settings).plan!, actionsDir) + const again = buildInstall(settings) + expect(again.plan).toBeNull() + expect(again.notes.join(' ')).toContain('already present') + }) + + it('configures the statusline only when none exists', async () => { + const { settings, actionsDir } = await makeRoot() + await rm(settings, { force: true }) + await runAction(buildInstall(settings, { statusline: true }).plan!, actionsDir) + expect((await readJson(settings)).statusLine.command).toBe(GUARD_STATUSLINE_COMMAND) + + // A pre-existing statusline is refused, not overwritten. + const { settings: s2, actionsDir: a2 } = await makeRoot() + await writeFile(s2, canonical({ statusLine: { type: 'command', command: 'my-statusline.sh' } })) + const built = buildInstall(s2, { statusline: true }) + expect(built.notes.join(' ')).toContain('statusline is already configured') + await runAction(built.plan!, a2) + expect((await readJson(s2)).statusLine.command).toBe('my-statusline.sh') + }) + + it('refuses to apply a plan when the settings file changed after it was built', async () => { + const { settings, actionsDir } = await makeRoot() + await writeFile(settings, canonical({ permissions: { allow: [] } })) + const built = buildInstall(settings) + expect(built.plan).not.toBeNull() + + const concurrent = canonical({ permissions: { allow: ['Bash(ls:*)'] } }) + await writeFile(settings, concurrent) + + await expect(runAction(built.plan!, actionsDir)).rejects.toThrow(/changed since the plan was built/) + expect(await readFile(settings, 'utf-8')).toBe(concurrent) // the concurrent edit survives + expect(await readRecords(actionsDir)).toEqual([]) // nothing journaled + }) +}) + +describe('guard uninstall', () => { + it('removes exactly our entries and restores byte-identical settings', async () => { + const { settings, actionsDir } = await makeRoot() + const original = canonical({ + permissions: { allow: [] }, + hooks: { PreToolUse: [{ matcher: 'Bash', hooks: [{ type: 'command', command: 'my-own-hook.sh' }] }] }, + }) + await writeFile(settings, original) + + await runAction(buildInstall(settings, { statusline: true }).plan!, actionsDir) + // ours are present now + const mid = inspectInstall(settings) + expect(mid.hooks.sort()).toEqual(['PreToolUse', 'SessionStart', 'Stop']) + expect(mid.statusline).toBe(true) + + await runAction(buildUninstall(settings).plan!, actionsDir) + expect(await readFile(settings, 'utf-8')).toBe(original) // byte-identical + const after = inspectInstall(settings) + expect(after.hooks).toEqual([]) + expect(after.statusline).toBe(false) + }) + + it('preserves a user hook that shares the PreToolUse array', async () => { + const { settings, actionsDir } = await makeRoot() + await writeFile(settings, canonical({ + hooks: { PreToolUse: [{ matcher: 'Bash', hooks: [{ type: 'command', command: 'my-own-hook.sh' }] }] }, + })) + await runAction(buildInstall(settings).plan!, actionsDir) + await runAction(buildUninstall(settings).plan!, actionsDir) + const doc = await readJson(settings) + const commands = doc.hooks.PreToolUse.flatMap((g: any) => g.hooks.map((h: any) => h.command)) + expect(commands).toEqual(['my-own-hook.sh']) + }) + + it('reports nothing to do on a settings file without our hooks', async () => { + const { settings } = await makeRoot() + await writeFile(settings, canonical({ hooks: {} })) + const built = buildUninstall(settings) + expect(built.plan).toBeNull() + expect(built.notes.join(' ')).toContain('no codeburn guard hooks') + }) + + it('reports nothing to do when the settings file is absent', async () => { + const { settings } = await makeRoot() + await rm(settings, { force: true }) + expect(existsSync(settings)).toBe(false) + const built = buildUninstall(settings) + expect(built.plan).toBeNull() + }) +}) diff --git a/tests/kiro-cache-invalidation.test.ts b/tests/kiro-cache-invalidation.test.ts new file mode 100644 index 0000000..725ba5b --- /dev/null +++ b/tests/kiro-cache-invalidation.test.ts @@ -0,0 +1,152 @@ +// Regression test for the Kiro stale-cache path (#618, #619). +// +// Before this fix the Kiro parser returned 0 turns for every IDE execution +// file that stores content under `context.messages[].entries`. Those empty +// results were cached in session-cache.json keyed by file fingerprint, so +// shipping a fixed parser alone is not enough: unchanged files would keep +// their cached `turns: []` forever. The fix registers kiro in +// PROVIDER_PARSE_VERSIONS, which changes the provider envFingerprint and +// makes `parseProviderSources` discard the stale section on first run. +// +// This test exercises the full `parseAllSessions` pipeline against a seeded +// session-cache.json, in both directions: +// - a cache seeded with the CURRENT fingerprint is honored (zero-turn entry +// stays, proving the seed is structurally valid and actually trusted) +// - a cache seeded with the PRE-FIX fingerprint is discarded and the file +// is re-parsed, recovering the calls the broken parser missed + +import { describe, it, expect, beforeEach, afterAll, vi } from 'vitest' +import { mkdir, rm, writeFile } from 'fs/promises' +import { createHash } from 'crypto' +import { join } from 'path' + +import { clearSessionCache, parseAllSessions } from '../src/parser.js' +import { + CACHE_VERSION, + computeEnvFingerprint, + fingerprintFile, + type SessionCache, +} from '../src/session-cache.js' + +// The kiro provider singleton captures homedir() when its module is first +// imported, so HOME must point at the test root before ../src/parser.js is +// evaluated. vi.hoisted runs ahead of the static imports above (but after +// tests/setup/env-isolation.ts, whose per-test beforeEach re-sandboxes env +// vars — anything read at *call* time, like CODEBURN_CACHE_DIR, must be +// re-asserted in this file's own beforeEach). +const testRoot = vi.hoisted(() => { + const root = `${process.env['TMPDIR'] || '/tmp'}/kiro-cache-inv-${process.pid}-${Date.now()}` + process.env['HOME'] = `${root}/home` + process.env['USERPROFILE'] = `${root}/home` + return root +}) + +const HOME = join(testRoot, 'home') +const CACHE_DIR = join(testRoot, 'cache') + +function kiroAgentDir(): string { + if (process.platform === 'darwin') { + return join(HOME, 'Library', 'Application Support', 'Kiro', 'User', 'globalStorage', 'kiro.kiroagent') + } + if (process.platform === 'win32') { + return join(HOME, 'AppData', 'Roaming', 'Kiro', 'User', 'globalStorage', 'kiro.kiroagent') + } + return join(HOME, '.config', 'Kiro', 'User', 'globalStorage', 'kiro.kiroagent') +} + +// What computeEnvFingerprint('kiro') returned before kiro had an entry in +// PROVIDER_PARSE_VERSIONS: no env vars, no parser version, i.e. a hash of +// zero parts. This is the fingerprint sitting in every pre-fix cache. +function preFixFingerprint(): string { + return createHash('sha256').update([].join('\0')).digest('hex').slice(0, 16) +} + +// Writes one IDE execution file in the context.messages[].entries format that +// the pre-fix parser turned into 0 turns, and returns its path. +async function seedExecutionFile(): Promise<string> { + const dir = join(kiroAgentDir(), 'a'.repeat(32), 'b'.repeat(32)) + await mkdir(dir, { recursive: true }) + const path = join(dir, 'exec-stale-001') + await writeFile(path, JSON.stringify({ + executionId: 'exec-stale-001', + workflowType: 'chat-agent', + status: 'succeed', + startTime: 1780000000000, + chatSessionId: 'session-stale-001', + context: { + messages: [ + { role: 'human', entries: [{ type: 'text', text: 'What is TypeScript?' }] }, + { role: 'bot', entries: [{ type: 'text', text: 'TypeScript is a typed superset of JavaScript.' }] }, + ], + }, + })) + return path +} + +async function seedCache(execPath: string, envFingerprint: string): Promise<void> { + const fp = await fingerprintFile(execPath) + if (!fp) throw new Error('failed to fingerprint seeded execution file') + const cache: SessionCache = { + version: CACHE_VERSION, + providers: { + kiro: { + envFingerprint, + files: { + [execPath]: { fingerprint: fp, mcpInventory: [], turns: [] }, + }, + }, + }, + } + await mkdir(CACHE_DIR, { recursive: true }) + await writeFile(join(CACHE_DIR, 'session-cache.json'), JSON.stringify(cache)) +} + +async function parseKiroCalls() { + const projects = await parseAllSessions(undefined, 'kiro') + return projects + .flatMap(p => p.sessions) + .flatMap(s => s.turns) + .flatMap(t => t.assistantCalls) +} + +beforeEach(async () => { + // Runs after env-isolation's global beforeEach, which cleared this var. + process.env['CODEBURN_CACHE_DIR'] = CACHE_DIR + clearSessionCache() + await rm(testRoot, { recursive: true, force: true }) +}) + +afterAll(async () => { + clearSessionCache() + await rm(testRoot, { recursive: true, force: true }) +}) + +describe('Kiro session cache invalidation', () => { + it('registers a kiro parser version in the env fingerprint', () => { + expect(computeEnvFingerprint('kiro')).not.toBe(preFixFingerprint()) + }) + + it('control: a zero-turn cache entry at the current fingerprint is honored', async () => { + const execPath = await seedExecutionFile() + await seedCache(execPath, computeEnvFingerprint('kiro')) + + const calls = await parseKiroCalls() + + // The seeded cache is structurally valid and trusted: the unchanged file + // is not re-parsed, so the stale zero-turn entry yields no calls. This + // guards the regression test below against passing for the wrong reason + // (an invalid or unread seed being silently ignored). + expect(calls).toHaveLength(0) + }) + + it('regression: a pre-fix cache fingerprint forces a re-parse that recovers the calls', async () => { + const execPath = await seedExecutionFile() + await seedCache(execPath, preFixFingerprint()) + + const calls = await parseKiroCalls() + + expect(calls).toHaveLength(1) + expect(calls[0]!.usage.inputTokens).toBeGreaterThan(0) + expect(calls[0]!.usage.outputTokens).toBeGreaterThan(0) + }) +}) diff --git a/tests/local-model-savings.test.ts b/tests/local-model-savings.test.ts new file mode 100644 index 0000000..fd8e9f9 --- /dev/null +++ b/tests/local-model-savings.test.ts @@ -0,0 +1,94 @@ +import { describe, it, expect, afterEach } from 'vitest' + +import { + calculateCost, + calculateLocalModelSavings, + getLocalModelSavingsConfigHash, + getLocalSavingsBaseline, + loadPricing, + setLocalModelSavings, +} from '../src/models.js' + +afterEach(() => setLocalModelSavings({})) + +describe('setLocalModelSavings / getLocalSavingsBaseline', () => { + it('returns undefined when no mapping is configured', () => { + setLocalModelSavings({}) + expect(getLocalSavingsBaseline('llama3.1:8b')).toBeUndefined() + }) + + it('returns the baseline name for a configured source model', () => { + setLocalModelSavings({ 'llama3.1:8b': 'gpt-4o' }) + expect(getLocalSavingsBaseline('llama3.1:8b')).toBe('gpt-4o') + }) + + it('uses Object.hasOwn so __proto__ cannot be coerced via the prototype chain', () => { + // Regression for the prototype-pollution test: a hostile model name + // like `__proto__` used to resolve to Object.prototype because plain + // object bracket lookup walks the prototype chain. + setLocalModelSavings({}) + expect(getLocalSavingsBaseline('__proto__')).toBeUndefined() + expect(getLocalSavingsBaseline('constructor')).toBeUndefined() + expect(getLocalSavingsBaseline('toString')).toBeUndefined() + }) + + it('refuses non-string keys defensively', () => { + setLocalModelSavings({}) + expect(getLocalSavingsBaseline('' as unknown as string)).toBeUndefined() + expect(getLocalSavingsBaseline(undefined as unknown as string)).toBeUndefined() + }) + + it('getLocalModelSavingsConfigHash is stable across sort order and empty for no mappings', () => { + setLocalModelSavings({}) + expect(getLocalModelSavingsConfigHash()).toBe('') + + setLocalModelSavings({ a: 'gpt-4o', b: 'claude-opus-4-6' }) + const h1 = getLocalModelSavingsConfigHash() + setLocalModelSavings({ b: 'claude-opus-4-6', a: 'gpt-4o' }) + const h2 = getLocalModelSavingsConfigHash() + expect(h1).toBe(h2) + expect(h1).not.toBe('') + }) + + it('changes the hash when the baseline mapping changes', () => { + setLocalModelSavings({ 'llama3.1:8b': 'gpt-4o' }) + const h1 = getLocalModelSavingsConfigHash() + setLocalModelSavings({ 'llama3.1:8b': 'gpt-5' }) + const h2 = getLocalModelSavingsConfigHash() + expect(h1).not.toBe(h2) + }) +}) + +describe('calculateLocalModelSavings', () => { + it('returns null when no mapping is configured for the model', () => { + setLocalModelSavings({}) + const out = calculateLocalModelSavings('llama3.1:8b', 1_000_000, 200_000, 0, 0, 0) + expect(out).toBeNull() + }) + + it('returns null when the baseline model is unknown to the pricing snapshot', () => { + setLocalModelSavings({ 'llama3.1:8b': 'unknown-paid-model-xyz' }) + const out = calculateLocalModelSavings('llama3.1:8b', 1_000, 1_000, 0, 0, 0) + expect(out).toBeNull() + }) + + it('returns the baseline cost as savings for a configured mapping', async () => { + await loadPricing() + setLocalModelSavings({ 'llama3.1:8b': 'gpt-4o' }) + const expected = calculateCost('gpt-4o', 1_000_000, 200_000, 50_000, 800_000, 0) + const out = calculateLocalModelSavings('llama3.1:8b', 1_000_000, 200_000, 50_000, 800_000, 0) + expect(out).not.toBeNull() + expect(out!.savingsUSD).toBeCloseTo(expected) + expect(out!.baselineModel).toBe('gpt-4o') + }) + + it('respects speed and web-search inputs in the baseline calculation', async () => { + await loadPricing() + setLocalModelSavings({ local: 'gpt-4o' }) + const standard = calculateLocalModelSavings('local', 1_000, 500, 0, 0, 2, 'standard') + expect(standard).not.toBeNull() + // Web search is a flat $0.01 per request, so the standard path with 2 + // web search requests should include 2 cents of counterfactual spend. + expect(standard!.savingsUSD).toBeGreaterThan(0.02) + }) +}) diff --git a/tests/mcp-coverage.test.ts b/tests/mcp-coverage.test.ts new file mode 100644 index 0000000..a19ddc4 --- /dev/null +++ b/tests/mcp-coverage.test.ts @@ -0,0 +1,656 @@ +import { describe, it, expect } from 'vitest' + +import { + aggregateMcpCoverage, + detectMcpProfileAdvisor, + detectMcpToolCoverage, + estimateMcpSchemaCost, +} from '../src/optimize.js' +import type { + ClassifiedTurn, + ParsedApiCall, + ProjectSummary, + SessionSummary, + TaskCategory, + TokenUsage, +} from '../src/types.js' + +// --------------------------------------------------------------------------- +// Test fixtures +// --------------------------------------------------------------------------- + +const ZERO_USAGE: TokenUsage = { + inputTokens: 0, + outputTokens: 0, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, +} + +function makeCall(opts: { + tools?: string[] + cacheCreation?: number + cacheRead?: number + cost?: number +} = {}): ParsedApiCall { + const tools = opts.tools ?? [] + return { + provider: 'claude', + model: 'Opus 4.7', + usage: { + ...ZERO_USAGE, + cacheCreationInputTokens: opts.cacheCreation ?? 0, + cacheReadInputTokens: opts.cacheRead ?? 0, + }, + costUSD: opts.cost ?? 0, + tools, + mcpTools: tools.filter(t => t.startsWith('mcp__')), + skills: [], + hasAgentSpawn: false, + hasPlanMode: false, + speed: 'standard', + timestamp: '2026-05-04T00:00:00Z', + bashCommands: [], + deduplicationKey: 'k', + } +} + +function makeTurn(calls: ParsedApiCall[]): ClassifiedTurn { + return { + userMessage: '', + assistantCalls: calls, + timestamp: '2026-05-04T00:00:00Z', + sessionId: 's1', + category: 'coding', + retries: 0, + hasEdits: false, + } +} + +function makeSession(opts: { + sessionId?: string + inventory?: string[] + turns?: ClassifiedTurn[] + mcpBreakdown?: Record<string, { calls: number }> +}): SessionSummary { + const turns = opts.turns ?? [] + const apiCalls = turns.reduce((s, t) => s + t.assistantCalls.length, 0) + const emptyCategoryBreakdown = {} as Record<TaskCategory, { turns: number; costUSD: number; retries: number; editTurns: number; oneShotTurns: number }> + return { + sessionId: opts.sessionId ?? 's1', + project: 'p', + firstTimestamp: '2026-05-04T00:00:00Z', + lastTimestamp: '2026-05-04T00:00:00Z', + totalCostUSD: 0, + totalInputTokens: 0, + totalOutputTokens: 0, + totalCacheReadTokens: 0, + totalCacheWriteTokens: 0, + apiCalls, + turns, + modelBreakdown: {}, + toolBreakdown: {}, + mcpBreakdown: opts.mcpBreakdown ?? {}, + bashBreakdown: {}, + categoryBreakdown: emptyCategoryBreakdown, + skillBreakdown: {}, + ...(opts.inventory ? { mcpInventory: opts.inventory } : {}), + } +} + +function project(sessions: SessionSummary[]): ProjectSummary { + return projectNamed('p', sessions) +} + +function projectNamed(name: string, sessions: SessionSummary[]): ProjectSummary { + return { + project: name, + projectPath: `/tmp/${name}`, + sessions, + totalCostUSD: 0, + totalApiCalls: sessions.reduce((s, ses) => s + ses.apiCalls, 0), + } +} + +// --------------------------------------------------------------------------- +// aggregateMcpCoverage +// --------------------------------------------------------------------------- + +describe('aggregateMcpCoverage', () => { + it('returns empty list when no session has MCP inventory', () => { + const projects = [project([makeSession({})])] + expect(aggregateMcpCoverage(projects)).toEqual([]) + }) + + it('reports per-server tools available, invoked, and unused', () => { + const inventory = [ + 'mcp__hf__hub_repo_search', + 'mcp__hf__paper_search', + 'mcp__hf__hf_doc_search', + ] + const turns = [ + makeTurn([makeCall({ tools: ['mcp__hf__hub_repo_search'] })]), + ] + const sessions = [ + makeSession({ inventory, turns, mcpBreakdown: { hf: { calls: 1 } } }), + ] + const result = aggregateMcpCoverage([project(sessions)]) + + expect(result).toHaveLength(1) + expect(result[0]!.server).toBe('hf') + expect(result[0]!.toolsAvailable).toBe(3) + expect(result[0]!.toolsInvoked).toBe(1) + expect(result[0]!.unusedTools).toEqual([ + 'mcp__hf__hf_doc_search', + 'mcp__hf__paper_search', + ]) + expect(result[0]!.coverageRatio).toBeCloseTo(1 / 3, 5) + expect(result[0]!.invocations).toBe(1) + expect(result[0]!.loadedSessions).toBe(1) + }) + + it('unions inventory across multiple sessions for the same server', () => { + const sessions = [ + makeSession({ sessionId: 'a', inventory: ['mcp__x__a', 'mcp__x__b'] }), + makeSession({ sessionId: 'b', inventory: ['mcp__x__b', 'mcp__x__c'] }), + ] + const result = aggregateMcpCoverage([project(sessions)]) + expect(result[0]!.toolsAvailable).toBe(3) + expect(result[0]!.loadedSessions).toBe(2) + }) + + it('separates servers with similar names', () => { + const sessions = [ + makeSession({ inventory: ['mcp__hf__a', 'mcp__hugface__a'] }), + ] + const result = aggregateMcpCoverage([project(sessions)]) + expect(result.map(r => r.server).sort()).toEqual(['hf', 'hugface']) + }) + + it('skips invocations without inventory (foreign server, no inventory observed)', () => { + // A server can show up only via a call. We still report it so the + // operator knows it was invoked, but coverage is 0/0 and it is not a + // candidate for the unused-coverage finding. + const turns = [makeTurn([makeCall({ tools: ['mcp__ghost__t1'] })])] + const sessions = [ + makeSession({ turns, mcpBreakdown: { ghost: { calls: 1 } } }), + ] + const result = aggregateMcpCoverage([project(sessions)]) + // No inventory entry -> aggregator drops the server from the report + // because we cannot reason about coverage without an inventory baseline. + expect(result).toEqual([]) + }) +}) + +// --------------------------------------------------------------------------- +// estimateMcpSchemaCost — cache-aware accounting +// --------------------------------------------------------------------------- + +describe('estimateMcpSchemaCost', () => { + it('charges first cacheCreation turn at full price, subsequent turns at cache-read', () => { + const turns = [ + makeTurn([makeCall({ cacheCreation: 50_000 })]), // first turn: write + makeTurn([makeCall({ cacheRead: 60_000 })]), // ongoing: read + makeTurn([makeCall({ cacheRead: 60_000 })]), + ] + const sessions = [makeSession({ + inventory: Array.from({ length: 30 }, (_, i) => `mcp__svc__t${i}`), + turns, + mcpBreakdown: { svc: { calls: 0 } }, + })] + // 30 unused tools * 400 token estimate = 12_000 schema tokens + // cap by call cache buckets so we never overclaim + const cost = estimateMcpSchemaCost(30, [project(sessions)], 'svc') + expect(cost.cacheWriteTokens).toBe(12_000) // capped by 50k creation, 12k schema fits + expect(cost.cacheReadTokens).toBe(24_000) // 12k + 12k across two ongoing turns + // effective = write * 1.25 + read * 0.10 (cache pricing) + expect(cost.effectiveInputTokens).toBeCloseTo(12_000 * 1.25 + 24_000 * 0.10, 5) + }) + + it('caps by available cache bucket so we never overclaim', () => { + const turns = [makeTurn([makeCall({ cacheCreation: 1_000 })])] + const sessions = [makeSession({ + inventory: Array.from({ length: 30 }, (_, i) => `mcp__svc__t${i}`), + turns, + mcpBreakdown: { svc: { calls: 0 } }, + })] + // 30*400 = 12k schema tokens, but the call only had 1k cache-creation, + // so we should not claim more than 1k of overhead for that turn. + const cost = estimateMcpSchemaCost(30, [project(sessions)], 'svc') + expect(cost.cacheWriteTokens).toBe(1_000) + }) + + it('returns zero when no unused tools', () => { + const sessions = [makeSession({ + inventory: ['mcp__svc__t1'], + turns: [makeTurn([makeCall({ cacheCreation: 5000 })])], + })] + const cost = estimateMcpSchemaCost(0, [project(sessions)], 'svc') + expect(cost).toEqual({ cacheWriteTokens: 0, cacheReadTokens: 0, effectiveInputTokens: 0 }) + }) + + it('counts cache write AND cache read on the same call', () => { + // A long session can have a cache rebuild mid-stream where one call + // reports both buckets. The estimator must charge both, not skip the + // read because of the write. + const turns = [makeTurn([ + makeCall({ cacheCreation: 50_000, cacheRead: 30_000 }), + ])] + const sessions = [makeSession({ + inventory: Array.from({ length: 30 }, (_, i) => `mcp__svc__t${i}`), + turns, + mcpBreakdown: { svc: { calls: 0 } }, + })] + const cost = estimateMcpSchemaCost(30, [project(sessions)], 'svc') + expect(cost.cacheWriteTokens).toBe(12_000) // capped at 50k creation + expect(cost.cacheReadTokens).toBe(12_000) // capped at 30k read + }) + + it('counts every cache rebuild, not just the first one', () => { + // Sessions that span more than 5 minutes can rebuild the cache + // multiple times. The estimator should treat every cacheCreation + // bucket as another write. + const turns = [makeTurn([ + makeCall({ cacheCreation: 50_000 }), + makeCall({ cacheCreation: 50_000 }), // rebuild after cache TTL + makeCall({ cacheRead: 60_000 }), + ])] + const sessions = [makeSession({ + inventory: Array.from({ length: 30 }, (_, i) => `mcp__svc__t${i}`), + turns, + mcpBreakdown: { svc: { calls: 0 } }, + })] + const cost = estimateMcpSchemaCost(30, [project(sessions)], 'svc') + expect(cost.cacheWriteTokens).toBe(24_000) // both rebuilds counted + expect(cost.cacheReadTokens).toBe(12_000) + }) + + it('skips sessions where the server was never loaded', () => { + const turns = [makeTurn([makeCall({ cacheCreation: 100_000 })])] + const sessions = [makeSession({ + inventory: ['mcp__other__t1'], + turns, + })] + const cost = estimateMcpSchemaCost(10, [project(sessions)], 'svc') + expect(cost.cacheWriteTokens).toBe(0) + }) + + it('requires observed inventory for the server, not just invocations', () => { + // Session invoked the server (mcpBreakdown set, mcpTools called) but + // never reported a deferred_tools_delta for it. Cost should be 0 to + // stay consistent with aggregateMcpCoverage's loadedSessions rule. + const turns = [makeTurn([ + makeCall({ tools: ['mcp__svc__t1'], cacheCreation: 100_000 }), + ])] + const sessions = [makeSession({ + // No inventory at all + turns, + mcpBreakdown: { svc: { calls: 1 } }, + })] + const cost = estimateMcpSchemaCost(10, [project(sessions)], 'svc') + expect(cost.cacheWriteTokens).toBe(0) + expect(cost.cacheReadTokens).toBe(0) + }) + + it('caps combined unused-schema budget across multiple flagged servers', () => { + // Two flagged servers, each with 30 unused tools (12k schema each = + // 24k combined). One call has a 50k cache-creation bucket. The + // combined cap means total write tokens reported is min(24k, 50k) = + // 24k, not 24k + 24k = 48k. + const inventory = [ + ...Array.from({ length: 30 }, (_, i) => `mcp__a__t${i}`), + ...Array.from({ length: 30 }, (_, i) => `mcp__b__t${i}`), + ] + const turns = [makeTurn([makeCall({ cacheCreation: 50_000 })])] + const sessions = [makeSession({ inventory, turns })] + const cost = estimateMcpSchemaCost( + { a: 30, b: 30 }, + [project(sessions)], + ['a', 'b'], + ) + expect(cost.cacheWriteTokens).toBe(24_000) + }) + + it('still works with the single-server signature (backward compat)', () => { + const turns = [makeTurn([makeCall({ cacheCreation: 50_000 })])] + const sessions = [makeSession({ + inventory: Array.from({ length: 30 }, (_, i) => `mcp__svc__t${i}`), + turns, + })] + const cost = estimateMcpSchemaCost(30, [project(sessions)], 'svc') + expect(cost.cacheWriteTokens).toBe(12_000) + }) +}) + +// --------------------------------------------------------------------------- +// detectMcpToolCoverage — finding emission with thresholds +// --------------------------------------------------------------------------- + +describe('detectMcpToolCoverage', () => { + it('returns null when no inventory exists at all', () => { + expect(detectMcpToolCoverage([project([makeSession({})])])).toBeNull() + }) + + it('does not flag a server with healthy coverage', () => { + const inventory = Array.from({ length: 20 }, (_, i) => `mcp__svc__t${i}`) + const turns = [makeTurn( + Array.from({ length: 8 }, (_, i) => makeCall({ tools: [`mcp__svc__t${i}`] })), + )] + const sessions = [ + makeSession({ sessionId: 'a', inventory, turns }), + makeSession({ sessionId: 'b', inventory, turns }), + ] + // 8/20 = 40% coverage, above the 20% threshold -> no finding + expect(detectMcpToolCoverage([project(sessions)])).toBeNull() + }) + + it('does not flag a server with too few tools (signal too noisy)', () => { + // Below MCP_COVERAGE_MIN_TOOLS=10 + const inventory = ['mcp__svc__a', 'mcp__svc__b'] + const sessions = [ + makeSession({ sessionId: 'a', inventory }), + makeSession({ sessionId: 'b', inventory }), + ] + expect(detectMcpToolCoverage([project(sessions)])).toBeNull() + }) + + it('does not flag if seen in only one session (insufficient evidence)', () => { + const inventory = Array.from({ length: 20 }, (_, i) => `mcp__svc__t${i}`) + const sessions = [makeSession({ inventory })] + expect(detectMcpToolCoverage([project(sessions)])).toBeNull() + }) + + it('flags a large server with low coverage across multiple sessions', () => { + const inventory = Array.from({ length: 30 }, (_, i) => `mcp__hf__t${i}`) + const turns = [makeTurn([ + makeCall({ tools: ['mcp__hf__t0'], cacheCreation: 100_000 }), + ])] + const sessions = [ + makeSession({ sessionId: 'a', inventory, turns, mcpBreakdown: { hf: { calls: 1 } } }), + makeSession({ sessionId: 'b', inventory, turns, mcpBreakdown: { hf: { calls: 1 } } }), + ] + const finding = detectMcpToolCoverage([project(sessions)]) + expect(finding).not.toBeNull() + expect(finding!.title).toContain('1 MCP server') + expect(finding!.title).toContain('low tool coverage') + expect(finding!.explanation).toContain('hf') + expect(finding!.explanation).toContain('1/30') + expect(finding!.fix.type).toBe('command') + expect((finding!.fix as { text: string }).text).toContain("claude mcp remove 'hf'") + expect(finding!.tokensSaved).toBeGreaterThan(0) + }) + + it('escalates impact to high when token waste crosses the threshold', () => { + const inventory = Array.from({ length: 60 }, (_, i) => `mcp__big__t${i}`) + // 60 tools * 400 tokens = 24k schema. With many sessions and large + // cache-creation buckets, total effective tokens easily clear 200k. + const turns = [makeTurn([ + makeCall({ tools: ['mcp__big__t0'], cacheCreation: 50_000 }), + makeCall({ cacheRead: 60_000 }), + makeCall({ cacheRead: 60_000 }), + ])] + // Need enough sessions so the per-session ~28.8k effective tokens + // (24k write + 48k read × 0.10) sum past the 200k high-impact threshold. + const sessions = Array.from({ length: 8 }, (_, i) => + makeSession({ sessionId: `s${i}`, inventory, turns, mcpBreakdown: { big: { calls: 1 } } }), + ) + const finding = detectMcpToolCoverage([project(sessions)]) + expect(finding).not.toBeNull() + expect(finding!.impact).toBe('high') + }) + + it('does not count invocation-only sessions toward loadedSessions', () => { + // Server `svc` has inventory in only one session, but is invoked in + // a second session that never observed the schema. Pre-fix this + // would have satisfied the >=2 session threshold; it must not now. + const inventory = Array.from({ length: 20 }, (_, i) => `mcp__svc__t${i}`) + const turns = [makeTurn([ + makeCall({ tools: ['mcp__svc__t0'], cacheCreation: 50_000 }), + ])] + const sessions = [ + makeSession({ sessionId: 'a', inventory, turns, mcpBreakdown: { svc: { calls: 1 } } }), + // No inventory — this shouldn't be considered a "loaded" session. + makeSession({ sessionId: 'b', turns, mcpBreakdown: { svc: { calls: 1 } } }), + ] + expect(detectMcpToolCoverage([project(sessions)])).toBeNull() + }) + + it('does not let invocations of un-inventoried tools inflate coverage', () => { + // Inventory has 20 tools, none invoked. Calls hit a 21st tool that + // never appeared in any deferred_tools_delta (could be a renamed/ + // removed tool from an older session config). Coverage must stay 0% + // and unusedCount must not go negative. + const inventory = Array.from({ length: 20 }, (_, i) => `mcp__svc__t${i}`) + const turns = [makeTurn([makeCall({ tools: ['mcp__svc__ghost'] })])] + const sessions = [ + makeSession({ sessionId: 'a', inventory, turns, mcpBreakdown: { svc: { calls: 1 } } }), + makeSession({ sessionId: 'b', inventory, turns, mcpBreakdown: { svc: { calls: 1 } } }), + ] + const result = aggregateMcpCoverage([project(sessions)]) + expect(result[0]!.toolsAvailable).toBe(20) + expect(result[0]!.toolsInvoked).toBe(0) + expect(result[0]!.coverageRatio).toBe(0) + expect(result[0]!.unusedTools).toHaveLength(20) + }) + + it('handles multiple flagged servers and pluralises the title', () => { + const sessions: SessionSummary[] = [] + for (const server of ['svc1', 'svc2']) { + const inventory = Array.from({ length: 20 }, (_, i) => `mcp__${server}__t${i}`) + const turns = [makeTurn([ + makeCall({ tools: [`mcp__${server}__t0`], cacheCreation: 50_000 }), + ])] + sessions.push( + makeSession({ sessionId: `${server}-a`, inventory, turns, mcpBreakdown: { [server]: { calls: 1 } } }), + makeSession({ sessionId: `${server}-b`, inventory, turns, mcpBreakdown: { [server]: { calls: 1 } } }), + ) + } + const finding = detectMcpToolCoverage([project(sessions)]) + expect(finding).not.toBeNull() + expect(finding!.title).toContain('2 MCP servers') + expect((finding!.fix as { text: string }).text.split('\n')).toHaveLength(2) + }) +}) + +// --------------------------------------------------------------------------- +// detectMcpProfileAdvisor — project-scoping recommendations +// --------------------------------------------------------------------------- + +describe('detectMcpProfileAdvisor', () => { + const smallInventory = Array.from({ length: 4 }, (_, i) => `mcp__github__t${i}`) + + it('flags a server loaded across projects but invoked only in one hot project', () => { + const hotTurns = [makeTurn([ + makeCall({ tools: ['mcp__github__t0'], cacheCreation: 10_000 }), + makeCall({ tools: ['mcp__github__t1'], cacheCreation: 10_000 }), + ])] + const coldTurns = [makeTurn([makeCall({ cacheCreation: 10_000 })])] + const projects = [ + projectNamed('api', [ + makeSession({ inventory: smallInventory, turns: hotTurns, mcpBreakdown: { github: { calls: 2 } } }), + ]), + projectNamed('web', [ + makeSession({ inventory: smallInventory, turns: coldTurns, mcpBreakdown: { github: { calls: 0 } } }), + ]), + projectNamed('docs', [ + makeSession({ inventory: smallInventory, turns: coldTurns, mcpBreakdown: { github: { calls: 0 } } }), + ]), + ] + + const finding = detectMcpProfileAdvisor(projects) + expect(finding).not.toBeNull() + expect(finding!.title).toContain('project-scoped') + expect(finding!.explanation).toContain('github') + expect(finding!.explanation).toContain('/tmp/api') + expect(finding!.explanation).toContain('/tmp/web') + expect(finding!.explanation).toContain('/tmp/docs') + expect(finding!.tokensSaved).toBe(4000) + expect(finding!.fix.type).toBe('paste') + if (finding!.fix.type === 'paste') { + expect(finding!.fix.destination).toBe('prompt') + expect(finding!.fix.text).toContain('Keep github available for /tmp/api') + expect(finding!.fix.text).toContain('/tmp/web') + expect(finding!.fix.text).toContain('/tmp/docs') + } + }) + + it('does not flag servers used evenly across loaded projects', () => { + const projects = ['api', 'web', 'docs'].map(name => projectNamed(name, [ + makeSession({ + inventory: smallInventory, + turns: [makeTurn([makeCall({ tools: ['mcp__github__t0'], cacheCreation: 10_000 })])], + mcpBreakdown: { github: { calls: 2 } }, + }), + ])) + + expect(detectMcpProfileAdvisor(projects)).toBeNull() + }) + + it('allows a hot profile shared by two projects', () => { + const projects = [ + projectNamed('api', [ + makeSession({ + inventory: smallInventory, + turns: [makeTurn([ + makeCall({ tools: ['mcp__github__t0'], cacheCreation: 10_000 }), + makeCall({ tools: ['mcp__github__t1'], cacheCreation: 10_000 }), + ])], + mcpBreakdown: { github: { calls: 2 } }, + }), + ]), + projectNamed('web', [ + makeSession({ + inventory: smallInventory, + turns: [makeTurn([ + makeCall({ tools: ['mcp__github__t0'], cacheCreation: 10_000 }), + makeCall({ tools: ['mcp__github__t1'], cacheCreation: 10_000 }), + ])], + mcpBreakdown: { github: { calls: 2 } }, + }), + ]), + projectNamed('docs', [ + makeSession({ + inventory: smallInventory, + turns: [makeTurn([makeCall({ cacheCreation: 10_000 })])], + mcpBreakdown: { github: { calls: 0 } }, + }), + ]), + projectNamed('playground', [ + makeSession({ + inventory: smallInventory, + turns: [makeTurn([makeCall({ cacheCreation: 10_000 })])], + mcpBreakdown: { github: { calls: 0 } }, + }), + ]), + ] + + const finding = detectMcpProfileAdvisor(projects) + expect(finding).not.toBeNull() + expect(finding!.explanation).toContain('/tmp/api') + expect(finding!.explanation).toContain('/tmp/web') + expect(finding!.explanation).toContain('/tmp/docs') + expect(finding!.explanation).toContain('/tmp/playground') + }) + + it('caps profile savings once when multiple candidate servers share cold sessions', () => { + const githubInventory = Array.from({ length: 4 }, (_, i) => `mcp__github__t${i}`) + const slackInventory = Array.from({ length: 4 }, (_, i) => `mcp__slack__t${i}`) + const inventory = [...githubInventory, ...slackInventory] + const projects = [ + projectNamed('api', [ + makeSession({ + inventory, + turns: [makeTurn([ + makeCall({ tools: ['mcp__github__t0'] }), + makeCall({ tools: ['mcp__github__t1'] }), + makeCall({ tools: ['mcp__slack__t0'] }), + makeCall({ tools: ['mcp__slack__t1'] }), + ])], + mcpBreakdown: { github: { calls: 2 }, slack: { calls: 2 } }, + }), + ]), + projectNamed('web', [ + makeSession({ + inventory, + turns: [makeTurn([makeCall({ cacheCreation: 2_000 })])], + mcpBreakdown: { github: { calls: 0 }, slack: { calls: 0 } }, + }), + ]), + projectNamed('docs', [ + makeSession({ + inventory, + turns: [makeTurn([makeCall({ cacheCreation: 2_000 })])], + mcpBreakdown: { github: { calls: 0 }, slack: { calls: 0 } }, + }), + ]), + ] + + const finding = detectMcpProfileAdvisor(projects) + expect(finding).not.toBeNull() + expect(finding!.title).toContain('2 MCP servers') + expect(finding!.explanation).toContain('github') + expect(finding!.explanation).toContain('slack') + expect(finding!.tokensSaved).toBe(5000) + }) + + it('requires at least three loaded projects before recommending a profile', () => { + const projects = [ + projectNamed('api', [ + makeSession({ + inventory: smallInventory, + turns: [makeTurn([makeCall({ tools: ['mcp__github__t0'], cacheCreation: 10_000 })])], + mcpBreakdown: { github: { calls: 2 } }, + }), + ]), + projectNamed('web', [ + makeSession({ + inventory: smallInventory, + turns: [makeTurn([makeCall({ cacheCreation: 10_000 })])], + mcpBreakdown: { github: { calls: 0 } }, + }), + ]), + ] + + expect(detectMcpProfileAdvisor(projects)).toBeNull() + }) + + it('does not duplicate low tool coverage findings for the same server', () => { + const inventory = Array.from({ length: 12 }, (_, i) => `mcp__huge__t${i}`) + const projects = [ + projectNamed('api', [ + makeSession({ + inventory, + turns: [makeTurn([makeCall({ tools: ['mcp__huge__t0'], cacheCreation: 20_000 })])], + mcpBreakdown: { huge: { calls: 3 } }, + }), + ]), + projectNamed('web', [ + makeSession({ + inventory, + turns: [makeTurn([makeCall({ cacheCreation: 20_000 })])], + mcpBreakdown: { huge: { calls: 0 } }, + }), + ]), + projectNamed('docs', [ + makeSession({ + inventory, + turns: [makeTurn([makeCall({ cacheCreation: 20_000 })])], + mcpBreakdown: { huge: { calls: 0 } }, + }), + ]), + ] + const coverage = [{ + server: 'huge', + toolsAvailable: 12, + toolsInvoked: 1, + unusedTools: Array.from({ length: 11 }, (_, i) => `mcp__huge__t${i + 1}`), + invocations: 3, + loadedSessions: 3, + coverageRatio: 1 / 12, + }] + + expect(detectMcpProfileAdvisor(projects, coverage)).toBeNull() + }) +}) diff --git a/tests/mcp-redact.test.ts b/tests/mcp-redact.test.ts new file mode 100644 index 0000000..2315708 --- /dev/null +++ b/tests/mcp-redact.test.ts @@ -0,0 +1,53 @@ +import { describe, expect, it } from 'vitest' +import { pseudonym, redactProjectNames } from '../src/mcp/redact.js' +import type { MenubarPayload } from '../src/menubar-json.js' + +function payload(): MenubarPayload { + const base = { + name: 'secret-client-repo', cost: 5, sessions: 2, avgCostPerSession: 2.5, + sessionDetails: [{ cost: 3, calls: 5, inputTokens: 100, outputTokens: 50, date: '2026-06-01', models: [{ name: 'Opus', cost: 3 }] }], + } + return { + generated: '', optimize: { findingCount: 0, savingsUSD: 0, topFindings: [] }, history: { daily: [] }, + current: { + label: 'Today', cost: 5, calls: 10, sessions: 2, oneShotRate: null, inputTokens: 0, outputTokens: 0, + cacheHitPercent: 0, topActivities: [], topModels: [], providers: {}, + topProjects: [base], modelEfficiency: [], + topSessions: [{ project: 'secret-client-repo', cost: 5, calls: 10, date: '2026-06-01' }], + retryTax: { totalUSD: 0, retries: 0, editTurns: 0, byModel: [] }, + routingWaste: { totalSavingsUSD: 0, baselineModel: '', baselineCostPerEdit: 0, byModel: [] }, + tools: [], skills: [], subagents: [], mcpServers: [], + }, + } as MenubarPayload +} + +describe('redact', () => { + it('pseudonym is stable and path-free', () => { + expect(pseudonym('a')).toBe(pseudonym('a')) + expect(pseudonym('secret-client-repo')).toMatch(/^project-[0-9a-f]{6}$/) + expect(pseudonym('a/b/c')).not.toContain('/') + }) + it('hashes project names by default, preserves numbers', () => { + const out = redactProjectNames(payload(), false) + expect(out.current.topProjects[0]!.name).toMatch(/^project-[0-9a-f]{6}$/) + expect(out.current.topSessions[0]!.project).toMatch(/^project-[0-9a-f]{6}$/) + expect(out.current.topProjects[0]!.cost).toBe(5) + }) + it('redacts session details when hashing', () => { + const out = redactProjectNames(payload(), false) + const details = out.current.topProjects[0]!.sessionDetails! + expect(details).toHaveLength(1) + expect(details[0]!.date).toBe('') + expect(details[0]!.models).toEqual([]) + expect(details[0]!.cost).toBe(3) + }) + it('same project name gets same pseudonym in topProjects and topSessions', () => { + const out = redactProjectNames(payload(), false) + expect(out.current.topProjects[0]!.name).toBe(out.current.topSessions[0]!.project) + }) + it('keeps real names and session details when include=true', () => { + const out = redactProjectNames(payload(), true) + expect(out.current.topProjects[0]!.name).toBe('secret-client-repo') + expect(out.current.topProjects[0]!.sessionDetails![0]!.date).toBe('2026-06-01') + }) +}) diff --git a/tests/mcp-server.test.ts b/tests/mcp-server.test.ts new file mode 100644 index 0000000..e022af2 --- /dev/null +++ b/tests/mcp-server.test.ts @@ -0,0 +1,60 @@ +import { describe, expect, it } from 'vitest' +import { Client } from '@modelcontextprotocol/sdk/client/index.js' +import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js' +import { createServer } from '../src/mcp/server.js' +import type { MenubarPayload } from '../src/menubar-json.js' + +function fakePayload(calls = 100): MenubarPayload { + return { + generated: '', optimize: { findingCount: 1, savingsUSD: 2, topFindings: [{ title: 'X', impact: 'high', savingsUSD: 2 }] }, history: { daily: [] }, + current: { + label: 'Today', cost: 9, calls, sessions: 1, oneShotRate: 0.5, inputTokens: 10, outputTokens: 5, cacheHitPercent: 50, + topActivities: [{ name: 'feature', cost: 9, turns: 5, oneShotRate: 0.5 }], topModels: [{ name: 'Opus 4.8', cost: 9, calls }], + providers: { 'claude code': 9 }, topProjects: [{ name: 'real-repo', cost: 9, sessions: 1, avgCostPerSession: 9, sessionDetails: [] }], + modelEfficiency: [], topSessions: [{ project: 'real-repo', cost: 9, calls, date: '2026-06-01' }], + retryTax: { totalUSD: 1, retries: 2, editTurns: 5, byModel: [{ name: 'Opus 4.8', taxUSD: 1, retries: 2, retriesPerEdit: 0.4 }] }, + routingWaste: { totalSavingsUSD: 1, baselineModel: 'Haiku 4.5', baselineCostPerEdit: 0.01, byModel: [] }, + tools: [], skills: [], subagents: [], mcpServers: [], + }, + } as MenubarPayload +} + +async function connect(aggregate: (p: unknown, o: unknown) => Promise<MenubarPayload>) { + const server = createServer({ version: 'test', aggregate: aggregate as never }) + const [a, b] = InMemoryTransport.createLinkedPair() + const client = new Client({ name: 'test', version: '1' }) + await Promise.all([server.connect(a), client.connect(b)]) + return client +} + +describe('mcp server', () => { + it('exposes exactly two read-only tools', async () => { + const client = await connect(async () => fakePayload()) + const { tools } = await client.listTools() + expect(tools.map(t => t.name).sort()).toEqual(['get_savings', 'get_usage']) + expect(tools.find(t => t.name === 'get_usage')!.annotations?.readOnlyHint).toBe(true) + }) + it('get_usage hashes project names by default', async () => { + const client = await connect(async () => fakePayload()) + const res = await client.callTool({ name: 'get_usage', arguments: { period: 'today', by: 'project' } }) + expect(JSON.stringify(res)).not.toContain('real-repo') + expect(JSON.stringify(res)).toMatch(/project-[0-9a-f]{6}/) + expect(res.isError).toBeFalsy() + }) + it('get_usage reveals names when opted in', async () => { + const client = await connect(async () => fakePayload()) + const res = await client.callTool({ name: 'get_usage', arguments: { period: 'today', by: 'project', include_project_names: true } }) + expect(JSON.stringify(res)).toContain('real-repo') + }) + it('empty data returns a friendly message, not a zero table', async () => { + const client = await connect(async () => fakePayload(0)) + const res = await client.callTool({ name: 'get_usage', arguments: { period: 'today' } }) + expect(String((res.content as Array<{ text: string }>)[0].text).toLowerCase()).toContain('no usage') + }) + it('aggregator failure surfaces as isError', async () => { + const client = await connect(async () => { throw new Error('boom') }) + const res = await client.callTool({ name: 'get_savings', arguments: {} }) + expect(res.isError).toBe(true) + expect(JSON.stringify(res)).toContain('boom') + }) +}) diff --git a/tests/mcp-tables.test.ts b/tests/mcp-tables.test.ts new file mode 100644 index 0000000..e0d32e4 --- /dev/null +++ b/tests/mcp-tables.test.ts @@ -0,0 +1,41 @@ +import { describe, expect, it } from 'vitest' +import { renderSummaryTable, renderBreakdownTable, renderSavingsTable } from '../src/mcp/tables.js' +import type { MenubarPayload } from '../src/menubar-json.js' + +function payload(): MenubarPayload { + return { + generated: '', optimize: { findingCount: 1, savingsUSD: 2.5, topFindings: [{ title: 'Trim system prompt', impact: 'high', savingsUSD: 2.5 }] }, history: { daily: [] }, + current: { + label: 'Last 7 Days', cost: 12.5, calls: 100, sessions: 4, oneShotRate: 0.5, inputTokens: 1000, outputTokens: 500, + cacheHitPercent: 80, topActivities: [{ name: 'feature', cost: 8, turns: 30, oneShotRate: 0.6 }], + topModels: [{ name: 'Opus 4.8', cost: 10, calls: 60 }], providers: { 'claude code': 12.5 }, + topProjects: [{ name: 'project-abc123', cost: 12.5, sessions: 4, avgCostPerSession: 3.125, sessionDetails: [] }], + modelEfficiency: [], topSessions: [], + retryTax: { totalUSD: 1.2, retries: 4, editTurns: 20, byModel: [{ name: 'Opus 4.8', taxUSD: 1.2, retries: 4, retriesPerEdit: 0.2 }] }, + routingWaste: { totalSavingsUSD: 3, baselineModel: 'Haiku 4.5', baselineCostPerEdit: 0.01, byModel: [{ name: 'Opus 4.8', costPerEdit: 0.05, editTurns: 20, actualUSD: 1, counterfactualUSD: 0.2, savingsUSD: 0.8 }] }, + tools: [], skills: [], subagents: [], mcpServers: [], + }, + } as MenubarPayload +} + +describe('tables', () => { + it('summary shows headline cost and top models', () => { + const t = renderSummaryTable(payload()) + expect(t).toContain('Last 7 Days') + expect(t).toContain('Opus 4.8') + expect(t).toContain('| Model | Cost | Calls |') + }) + it('breakdown by provider lists providers', () => { + expect(renderBreakdownTable(payload(), 'provider', 20)).toContain('claude code') + }) + it('breakdown handles empty dimension gracefully', () => { + const p = payload(); p.current.topActivities = [] + expect(renderBreakdownTable(p, 'task', 20)).toContain('no data') + }) + it('savings shows retry tax and routing waste', () => { + const t = renderSavingsTable(payload()) + expect(t).toContain('Retry tax') + expect(t).toContain('Routing waste') + expect(t).toContain('Trim system prompt') + }) +}) diff --git a/tests/menubar-installer.test.ts b/tests/menubar-installer.test.ts new file mode 100644 index 0000000..129fbac --- /dev/null +++ b/tests/menubar-installer.test.ts @@ -0,0 +1,163 @@ +import { describe, expect, it } from 'vitest' +import { + buildPersistentCodeburnLookupPath, + formatGitHubReleaseLookupError, + resolveLatestMenubarReleaseAssets, + resolveMenubarReleaseAssets, + resolvePersistentCodeburnPathFromWhichOutput, + resolveProxyUrlForUrl, + resolveVersionedMenubarReleaseAssets, + shouldFallbackToReleaseApi, + type ReleaseResponse, +} from '../src/menubar-installer.js' + +function asset(name: string) { + return { name, browser_download_url: `https://example.test/${name}` } +} + +describe('resolveMenubarReleaseAssets', () => { + it('ignores dev zips and pairs the checksum with the versioned zip', () => { + const release: ReleaseResponse = { + tag_name: 'mac-v0.9.8', + assets: [ + asset('CodeBurnMenubar-dev.zip'), + asset('CodeBurnMenubar-dev.zip.sha256'), + asset('CodeBurnMenubar-v0.9.8.zip'), + asset('CodeBurnMenubar-v0.9.8.zip.sha256'), + ], + } + + const resolved = resolveMenubarReleaseAssets(release) + + expect(resolved.zip.name).toBe('CodeBurnMenubar-v0.9.8.zip') + expect(resolved.checksum?.name).toBe('CodeBurnMenubar-v0.9.8.zip.sha256') + }) + + it('fails when a release only contains dev assets', () => { + const release: ReleaseResponse = { + tag_name: 'mac-v0.9.8', + assets: [ + asset('CodeBurnMenubar-dev.zip'), + asset('CodeBurnMenubar-dev.zip.sha256'), + ], + } + + expect(() => resolveMenubarReleaseAssets(release)).toThrow(/versioned zip/) + }) + + it('fails when the versioned checksum is missing', () => { + const release: ReleaseResponse = { + tag_name: 'mac-v0.9.8', + assets: [ + asset('CodeBurnMenubar-v0.9.8.zip'), + ], + } + + expect(() => resolveMenubarReleaseAssets(release)).toThrow(/Missing checksum/) + }) + + it('selects the newest mac release instead of the newest repo release', () => { + const releases: ReleaseResponse[] = [ + { + tag_name: 'v0.9.9', + assets: [ + asset('codeburn-0.9.9.tgz'), + ], + }, + { + tag_name: 'mac-v0.9.8', + assets: [ + asset('CodeBurnMenubar-v0.9.8.zip'), + asset('CodeBurnMenubar-v0.9.8.zip.sha256'), + ], + }, + ] + + const resolved = resolveLatestMenubarReleaseAssets(releases) + + expect(resolved.release.tag_name).toBe('mac-v0.9.8') + expect(resolved.zip.name).toBe('CodeBurnMenubar-v0.9.8.zip') + }) + + it('builds direct release asset URLs from the CLI version', () => { + const resolved = resolveVersionedMenubarReleaseAssets('0.9.15') + + expect(resolved.release.tag_name).toBe('mac-v0.9.15') + expect(resolved.zip.name).toBe('CodeBurnMenubar-v0.9.15.zip') + expect(resolved.zip.browser_download_url).toBe( + 'https://github.com/getagentseal/codeburn/releases/download/mac-v0.9.15/CodeBurnMenubar-v0.9.15.zip' + ) + expect(resolved.checksum.name).toBe('CodeBurnMenubar-v0.9.15.zip.sha256') + expect(resolved.checksum.browser_download_url).toBe( + 'https://github.com/getagentseal/codeburn/releases/download/mac-v0.9.15/CodeBurnMenubar-v0.9.15.zip.sha256' + ) + }) + + it('normalizes a leading v when building direct release URLs', () => { + const resolved = resolveVersionedMenubarReleaseAssets('v0.9.15') + + expect(resolved.release.tag_name).toBe('mac-v0.9.15') + expect(resolved.zip.name).toBe('CodeBurnMenubar-v0.9.15.zip') + }) + + it('falls back to the release API only for missing direct assets', () => { + expect(shouldFallbackToReleaseApi(404)).toBe(true) + expect(shouldFallbackToReleaseApi(410)).toBe(true) + expect(shouldFallbackToReleaseApi(403)).toBe(false) + expect(shouldFallbackToReleaseApi(429)).toBe(false) + expect(shouldFallbackToReleaseApi(500)).toBe(false) + }) + + it('explains likely rate limiting for GitHub API 403 and 429 errors', () => { + const headerValues: Record<string, string> = { + 'retry-after': '120', + 'x-ratelimit-reset': '1783539204', + } + const headers = { get: (name: string) => headerValues[name] ?? null } + + expect(formatGitHubReleaseLookupError(403, headers)).toContain( + 'GitHub may be rate limiting unauthenticated release API requests' + ) + expect(formatGitHubReleaseLookupError(403, headers)).toContain('retry-after=120') + expect(formatGitHubReleaseLookupError(429, headers)).toContain('x-ratelimit-reset=1783539204') + }) + + it('preserves the caller PATH when building the persistent CLI lookup PATH', () => { + const lookupPath = buildPersistentCodeburnLookupPath('/Users/me/.nvm/versions/node/v22.13.0/bin:/usr/bin') + + expect(lookupPath.split(':')).toContain('/Users/me/.nvm/versions/node/v22.13.0/bin') + expect(lookupPath.split(':')).toContain('/opt/homebrew/bin') + }) + + it('selects a persistent codeburn binary when npx is first in which output', () => { + const resolved = resolvePersistentCodeburnPathFromWhichOutput([ + '/Users/me/.npm/_npx/abcd/node_modules/.bin/codeburn', + '/Users/me/.nvm/versions/node/v22.13.0/bin/codeburn', + ].join('\n')) + + expect(resolved).toBe('/Users/me/.nvm/versions/node/v22.13.0/bin/codeburn') + }) + + it('shows the install guidance instead of a raw env failure when only npx is available', () => { + expect(() => resolvePersistentCodeburnPathFromWhichOutput( + '/Users/me/.npm/_npx/abcd/node_modules/.bin/codeburn' + )).toThrow(/Install CodeBurn globally first/) + }) + + it('uses HTTPS proxy for GitHub HTTPS downloads', () => { + const proxyUrl = resolveProxyUrlForUrl('https://api.github.com/repos/getagentseal/codeburn/releases', { + HTTPS_PROXY: 'http://proxy.company.test:8080', + }) + + expect(proxyUrl).toBe('http://proxy.company.test:8080') + }) + + it('bypasses proxy when NO_PROXY matches the download host', () => { + const proxyUrl = resolveProxyUrlForUrl('https://api.github.com/repos/getagentseal/codeburn/releases', { + HTTPS_PROXY: 'http://proxy.company.test:8080', + NO_PROXY: '.github.com', + }) + + expect(proxyUrl).toBeUndefined() + }) +}) diff --git a/tests/menubar-json.test.ts b/tests/menubar-json.test.ts new file mode 100644 index 0000000..e685b27 --- /dev/null +++ b/tests/menubar-json.test.ts @@ -0,0 +1,325 @@ +import { describe, expect, it } from 'vitest' + +import { buildMenubarPayload, type CombinedUsage, type PeriodData, type ProviderCost } from '../src/menubar-json.js' +import type { OptimizeResult } from '../src/optimize.js' + +function emptyPeriod(label: string): PeriodData { + return { + label, + cost: 0, + calls: 0, + sessions: 0, + inputTokens: 0, + outputTokens: 0, + cacheReadTokens: 0, + cacheWriteTokens: 0, + categories: [], + models: [], + } +} + +describe('buildMenubarPayload', () => { + it('emits the full schema with current-period metrics and iso timestamp', () => { + const period: PeriodData = { + label: '7 Days', + cost: 1248.01, + calls: 11231, + sessions: 97, + inputTokens: 19100, + outputTokens: 675600, + cacheReadTokens: 0, + cacheWriteTokens: 0, + categories: [], + models: [], + } + const payload = buildMenubarPayload(period, [], null) + + expect(payload.generated).toMatch(/^\d{4}-\d{2}-\d{2}T/) + expect(payload.current.label).toBe('7 Days') + expect(payload.current.cost).toBe(1248.01) + expect(payload.current.calls).toBe(11231) + expect(payload.current.sessions).toBe(97) + expect(payload.current.inputTokens).toBe(19100) + expect(payload.current.outputTokens).toBe(675600) + }) + + it('exposes period-scoped cache tokens on current, decoupled from the 365-day history backfill (#583)', () => { + const period: PeriodData = { + label: '30 Days', + cost: 5, calls: 10, sessions: 2, + inputTokens: 1000, outputTokens: 2000, + // What `report -p 30days` shows in the terminal for the same window. + cacheReadTokens: 1_391_100_000, + cacheWriteTokens: 42_000_000, + categories: [], models: [], + } + // history.daily is the full BACKFILL_DAYS (365) trend, whose cache totals are + // far larger than the selected period. The web cards used to sum these, which + // is the bug in #583. current must mirror the period, not the backfill. + const dailyHistory = [ + { date: '2025-07-15', cost: 0, savingsUSD: 0, calls: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 1_800_000_000, cacheWriteTokens: 60_000_000, topModels: [] }, + { date: '2026-06-30', cost: 0, savingsUSD: 0, calls: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 270_000_000, cacheWriteTokens: 12_000_000, topModels: [] }, + ] + const payload = buildMenubarPayload(period, [], null, dailyHistory) + + // current carries the period totals verbatim ... + expect(payload.current.cacheReadTokens).toBe(1_391_100_000) + expect(payload.current.cacheWriteTokens).toBe(42_000_000) + // ... and is independent of the larger history-backfill sum the cards used before. + const historyReadSum = dailyHistory.reduce((s, d) => s + d.cacheReadTokens, 0) + const historyWriteSum = dailyHistory.reduce((s, d) => s + d.cacheWriteTokens, 0) + expect(historyReadSum).toBeGreaterThan(payload.current.cacheReadTokens) + expect(historyWriteSum).toBeGreaterThan(payload.current.cacheWriteTokens) + }) + + it('computes per-category oneShotRate from editTurns and skips categories without edits', () => { + const period: PeriodData = { + label: 'Today', + cost: 0, calls: 0, sessions: 0, + inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, + categories: [ + { name: 'Coding', cost: 15.83, turns: 7, editTurns: 7, oneShotTurns: 6 }, + { name: 'Conversation', cost: 16.69, turns: 47, editTurns: 0, oneShotTurns: 0 }, + ], + models: [], + } + const payload = buildMenubarPayload(period, [], null) + + const coding = payload.current.topActivities.find(a => a.name === 'Coding')! + expect(coding.oneShotRate).toBeCloseTo(6 / 7) + + const conv = payload.current.topActivities.find(a => a.name === 'Conversation')! + expect(conv.oneShotRate).toBeNull() + }) + + it('computes aggregate oneShotRate across categories with edits', () => { + const period: PeriodData = { + label: 'Today', + cost: 0, calls: 0, sessions: 0, + inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, + categories: [ + { name: 'Coding', cost: 1, turns: 7, editTurns: 10, oneShotTurns: 8 }, + { name: 'Debugging', cost: 1, turns: 5, editTurns: 10, oneShotTurns: 6 }, + { name: 'Conversation', cost: 1, turns: 40, editTurns: 0, oneShotTurns: 0 }, + ], + models: [], + } + const payload = buildMenubarPayload(period, [], null) + expect(payload.current.oneShotRate).toBeCloseTo((8 + 6) / (10 + 10)) + }) + + it('returns null aggregate oneShotRate when no categories have editTurns', () => { + const period: PeriodData = { + label: 'Today', + cost: 0, calls: 0, sessions: 0, + inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, + categories: [{ name: 'Conversation', cost: 1, turns: 5, editTurns: 0, oneShotTurns: 0 }], + models: [], + } + const payload = buildMenubarPayload(period, [], null) + expect(payload.current.oneShotRate).toBeNull() + }) + + it('filters out the synthetic model and caps topModels at 20 so multi-model users see all their models', () => { + const models = Array.from({ length: 30 }, (_, i) => ({ + name: `Model${i}`, cost: 30 - i, calls: 100, + })) + const period: PeriodData = { + label: 'Today', + cost: 0, calls: 0, sessions: 0, + inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, + categories: [], + models: [{ name: '<synthetic>', cost: 99, calls: 0 }, ...models], + } + const payload = buildMenubarPayload(period, [], null) + expect(payload.current.topModels.find(m => m.name === '<synthetic>')).toBeUndefined() + expect(payload.current.topModels).toHaveLength(20) + expect(payload.current.topModels[0].name).toBe('Model0') + }) + + it('caps topActivities at 20 so all task categories can surface', () => { + const period: PeriodData = { + label: 'Today', + cost: 0, calls: 0, sessions: 0, + inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, + categories: Array.from({ length: 25 }, (_, i) => ({ + name: `Cat${i}`, cost: 1, turns: 1, editTurns: 1, oneShotTurns: 1, + })), + models: [], + } + const payload = buildMenubarPayload(period, [], null) + expect(payload.current.topActivities).toHaveLength(20) + }) + + it('computes cacheHitPercent from cache reads over input plus cache reads', () => { + const period: PeriodData = { + label: 'Today', + cost: 0, calls: 0, sessions: 0, + inputTokens: 100, + outputTokens: 200, + cacheReadTokens: 900, + cacheWriteTokens: 0, + categories: [], + models: [], + } + const payload = buildMenubarPayload(period, [], null) + expect(payload.current.cacheHitPercent).toBeCloseTo(90) + }) + + it('returns zero cacheHitPercent when there is no input or cache traffic', () => { + const payload = buildMenubarPayload(emptyPeriod('Today'), [], null) + expect(payload.current.cacheHitPercent).toBe(0) + }) + + it('handles null optimize as empty findings block', () => { + const payload = buildMenubarPayload(emptyPeriod('Today'), [], null) + expect(payload.optimize).toEqual({ findingCount: 0, savingsUSD: 0, topFindings: [] }) + }) + + it('converts tokensSaved to savingsUSD via costRate and caps topFindings at 10', () => { + const findings = Array.from({ length: 15 }, (_, i) => ({ + title: `F${i}`, explanation: '', impact: 'low' as const, tokensSaved: 1000, + fix: { type: 'paste' as const, label: '', text: '' }, + })) + const optimize: OptimizeResult = { + findings, + costRate: 0.00002, + healthScore: 60, + healthGrade: 'C', + } + const payload = buildMenubarPayload(emptyPeriod('Today'), [], optimize) + + expect(payload.optimize.findingCount).toBe(15) + expect(payload.optimize.topFindings).toHaveLength(10) + expect(payload.optimize.topFindings[0].title).toBe('F0') + expect(payload.optimize.topFindings[0].savingsUSD).toBeCloseTo(1000 * 0.00002) + expect(payload.optimize.savingsUSD).toBeCloseTo(15 * 1000 * 0.00002) + }) + + it('maps providers into a lowercased dict inside the current-period block', () => { + const providers: ProviderCost[] = [ + { name: 'Claude Code', cost: 76.45 }, + { name: 'Cursor', cost: 2.18 }, + { name: 'Codex', cost: 1.5 }, + ] + const payload = buildMenubarPayload(emptyPeriod('Today'), providers, null) + expect(payload.current.providers).toEqual({ 'claude code': 76.45, cursor: 2.18, codex: 1.5 }) + }) + + it('keeps zero-cost providers in the dict so installed-but-unused providers still render as tabs', () => { + const providers: ProviderCost[] = [ + { name: 'Claude', cost: 76.45 }, + { name: 'Codex', cost: 0 }, + { name: 'Cursor', cost: 2.18 }, + ] + const payload = buildMenubarPayload(emptyPeriod('Today'), providers, null) + expect(payload.current.providers).toEqual({ claude: 76.45, codex: 0, cursor: 2.18 }) + }) + + it('includes up to 365 daily history entries sorted ascending by date', () => { + const history = Array.from({ length: 400 }, (_, i) => { + const d = new Date(2025, 0, 1) + d.setDate(d.getDate() + i) + return { + date: d.toISOString().slice(0, 10), + cost: i, + calls: i * 10, + inputTokens: 0, + outputTokens: 0, + cacheReadTokens: 0, + cacheWriteTokens: 0, + topModels: [], + } + }) + const payload = buildMenubarPayload(emptyPeriod('Today'), [], null, history) + expect(payload.history.daily).toHaveLength(365) + expect(payload.history.daily[0]!.date < payload.history.daily[364]!.date).toBe(true) + expect(payload.history.daily[364]!.date).toBe(history[399]!.date) + }) + + it('preserves token fields in dailyHistory entries', () => { + const history = [ + { date: '2026-04-15', cost: 10, calls: 50, inputTokens: 100, outputTokens: 200, cacheReadTokens: 5000, cacheWriteTokens: 800, topModels: [{ name: 'Opus 4.7', cost: 8, calls: 40, inputTokens: 80, outputTokens: 160 }] }, + { date: '2026-04-16', cost: 20, calls: 75, inputTokens: 150, outputTokens: 350, cacheReadTokens: 8000, cacheWriteTokens: 1200, topModels: [] }, + ] + const payload = buildMenubarPayload(emptyPeriod('Today'), [], null, history) + expect(payload.history.daily[0]).toEqual(history[0]) + expect(payload.history.daily[1]).toEqual(history[1]) + }) + + it('returns empty history when none supplied', () => { + const payload = buildMenubarPayload(emptyPeriod('Today'), [], null) + expect(payload.history.daily).toEqual([]) + }) + + it('drops providers with negative cost defensively', () => { + const providers: ProviderCost[] = [ + { name: 'Claude', cost: 76.45 }, + { name: 'Broken', cost: -1 }, + ] + const payload = buildMenubarPayload(emptyPeriod('Today'), providers, null) + expect(payload.current.providers).toEqual({ claude: 76.45 }) + }) + + it('omits combined usage by default and accepts the documented combined shape when attached', () => { + const payload = buildMenubarPayload(emptyPeriod('Today'), [], null) + expect(payload).not.toHaveProperty('combined') + + const combined: CombinedUsage = { + perDevice: [ + { + id: 'local', + name: 'Mac Studio', + local: true, + cost: 1, + calls: 2, + sessions: 1, + inputTokens: 100, + outputTokens: 50, + cacheCreateTokens: 10, + cacheReadTokens: 20, + totalTokens: 180, + }, + ], + combined: { + cost: 1, + calls: 2, + sessions: 1, + inputTokens: 100, + outputTokens: 50, + cacheCreateTokens: 10, + cacheReadTokens: 20, + totalTokens: 180, + deviceCount: 1, + reachableCount: 1, + }, + } + payload.combined = combined + + expect(payload.combined).toEqual(combined) + }) + + it('emits Claude config selector metadata only when multiple configs are available', () => { + const oneConfig = buildMenubarPayload(emptyPeriod('Today'), [], null, undefined, undefined, undefined, undefined, { + selectedId: null, + options: [{ id: 'claude-config:a', label: 'claude-work', path: '/tmp/claude-work' }], + }) + expect(oneConfig).not.toHaveProperty('claudeConfigs') + + const twoConfigs = buildMenubarPayload(emptyPeriod('Today'), [], null, undefined, undefined, undefined, undefined, { + selectedId: 'claude-config:b', + options: [ + { id: 'claude-config:a', label: 'claude-work', path: '/tmp/claude-work' }, + { id: 'claude-config:b', label: 'claude-personal', path: '/tmp/claude-personal' }, + ], + }) + + expect(twoConfigs.claudeConfigs).toEqual({ + selectedId: 'claude-config:b', + options: [ + { id: 'claude-config:a', label: 'claude-work', path: '/tmp/claude-work' }, + { id: 'claude-config:b', label: 'claude-personal', path: '/tmp/claude-personal' }, + ], + }) + }) +}) diff --git a/tests/menubar-savings.test.ts b/tests/menubar-savings.test.ts new file mode 100644 index 0000000..ba416ab --- /dev/null +++ b/tests/menubar-savings.test.ts @@ -0,0 +1,91 @@ +import { describe, expect, it } from 'vitest' + +import { buildMenubarPayload, type LocalModelSavings, type PeriodData } from '../src/menubar-json.js' + +function basePeriod(overrides: Partial<PeriodData> = {}): PeriodData { + return { + label: '7 Days', + cost: 0, + savingsUSD: 0, + calls: 0, + sessions: 0, + inputTokens: 0, + outputTokens: 0, + cacheReadTokens: 0, + cacheWriteTokens: 0, + categories: [], + models: [], + ...overrides, + } +} + +describe('buildMenubarPayload: local-model savings', () => { + it('defaults localModelSavings to an empty block when no breakdown is provided', () => { + const payload = buildMenubarPayload(basePeriod(), [], null) + expect(payload.current.localModelSavings).toEqual({ totalUSD: 0, calls: 0, byModel: [], byProvider: [] }) + }) + + it('threads the localModelSavings breakdown into the payload when supplied', () => { + const breakdown: LocalModelSavings = { + totalUSD: 12.34, + calls: 7, + byModel: [ + { name: 'llama3.1:8b', calls: 4, actualUSD: 0, savingsUSD: 7.21, baselineModel: 'gpt-4o', inputTokens: 1234, outputTokens: 567 }, + { name: 'qwen2.5:32b', calls: 3, actualUSD: 0, savingsUSD: 5.13, baselineModel: 'claude-opus-4-6', inputTokens: 4321, outputTokens: 876 }, + ], + byProvider: [ + { name: 'ollama', calls: 7, savingsUSD: 12.34 }, + ], + } + const payload = buildMenubarPayload(basePeriod(), [], null, undefined, undefined, undefined, { + localModelSavings: breakdown, + }) + expect(payload.current.localModelSavings).toEqual(breakdown) + }) + + it('exposes savingsUSD and savingsBaselineModel on top models', () => { + const payload = buildMenubarPayload(basePeriod({ + models: [ + { name: 'Local Model', cost: 0, savingsUSD: 5, calls: 1 }, + { name: 'gpt-4o', cost: 2, savingsUSD: 0, calls: 1 }, + ], + }), [], null) + const local = payload.current.topModels.find(m => m.name === 'Local Model')! + expect(local.savingsUSD).toBe(5) + expect(local.cost).toBe(0) + const paid = payload.current.topModels.find(m => m.name === 'gpt-4o')! + expect(paid.savingsUSD).toBe(0) + }) + + it('surfaces savingsUSD on top projects and top sessions', () => { + const payload = buildMenubarPayload(basePeriod({ + cost: 2, + savingsUSD: 5, + projects: [ + { name: 'p', cost: 2, savingsUSD: 5, sessions: 1, sessionDetails: [{ cost: 2, savingsUSD: 5, calls: 1, inputTokens: 0, outputTokens: 0, date: '2026-04-10', models: [{ name: 'Local Model', cost: 0, savingsUSD: 5 }] }] }, + ], + topSessions: [{ project: 'p', cost: 2, savingsUSD: 5, calls: 1, date: '2026-04-10' }], + }), [], null) + const proj = payload.current.topProjects[0]! + expect(proj.savingsUSD).toBe(5) + expect(proj.sessionDetails[0]!.savingsUSD).toBe(5) + expect(proj.sessionDetails[0]!.models[0]!.savingsUSD).toBe(5) + const session = payload.current.topSessions[0]! + expect(session.savingsUSD).toBe(5) + }) + + it('emits savingsUSD and per-model breakdown in history entries', () => { + const payload = buildMenubarPayload(basePeriod(), [], null, [ + { date: '2026-04-10', cost: 2, savingsUSD: 5, calls: 1, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, topModels: [{ name: 'Local Model', cost: 0, savingsUSD: 5, calls: 1, inputTokens: 0, outputTokens: 0 }] }, + ]) + expect(payload.history.daily[0]!.savingsUSD).toBe(5) + expect(payload.history.daily[0]!.topModels[0]!.savingsUSD).toBe(5) + }) + + it('keeps topActivities savingsUSD aligned with category rollups', () => { + const payload = buildMenubarPayload(basePeriod({ + categories: [{ name: 'Coding', cost: 0, savingsUSD: 5, turns: 1, editTurns: 0, oneShotTurns: 0 }], + }), [], null) + expect(payload.current.topActivities[0]!.savingsUSD).toBe(5) + }) +}) diff --git a/tests/minimax.test.ts b/tests/minimax.test.ts new file mode 100644 index 0000000..cfc3e25 --- /dev/null +++ b/tests/minimax.test.ts @@ -0,0 +1,59 @@ +import { describe, it, expect } from 'vitest' + +import { getModelCosts, getShortModelName } from '../src/models.js' + +// Verifies MiniMax pricing loaded from FALLBACK_PRICING (no network call). +// pricingCache stays null until loadPricing() runs, so getModelCosts falls +// through to FALLBACK_PRICING which is what we want to validate here. + +describe('MiniMax model pricing', () => { + it('returns pricing for MiniMax-M2.7', () => { + const costs = getModelCosts('MiniMax-M2.7') + expect(costs).not.toBeNull() + expect(costs!.inputCostPerToken).toBe(0.3e-6) + expect(costs!.outputCostPerToken).toBe(1.2e-6) + expect(costs!.cacheReadCostPerToken).toBe(0.06e-6) + expect(costs!.cacheWriteCostPerToken).toBe(0.375e-6) + expect(costs!.fastMultiplier).toBe(1) + }) + + it('returns pricing for MiniMax-M2.7-highspeed', () => { + const costs = getModelCosts('MiniMax-M2.7-highspeed') + expect(costs).not.toBeNull() + expect(costs!.inputCostPerToken).toBe(0.6e-6) + expect(costs!.outputCostPerToken).toBe(2.4e-6) + expect(costs!.cacheReadCostPerToken).toBe(0.06e-6) + expect(costs!.cacheWriteCostPerToken).toBe(0.375e-6) + expect(costs!.fastMultiplier).toBe(1) + }) + + it('returns official pricing for MiniMax-M3', () => { + // MiniMax moved M3 to tiered pricing (platform.minimax.io pay-as-you-go): + // $0.3/$1.2 per M is the official standard tier (inputs up to 512K), with + // $0.6/$2.4 above 512K. The snapshot carries the standard tier, matching + // how other tiered models are priced here. + const costs = getModelCosts('MiniMax-M3') + expect(costs).not.toBeNull() + expect(costs!.inputCostPerToken).toBe(0.3e-6) + expect(costs!.outputCostPerToken).toBe(1.2e-6) + }) + + it('highspeed pricing is distinct from base model pricing', () => { + const base = getModelCosts('MiniMax-M2.7') + const fast = getModelCosts('MiniMax-M2.7-highspeed') + expect(fast!.inputCostPerToken).toBeGreaterThan(base!.inputCostPerToken) + expect(fast!.outputCostPerToken).toBeGreaterThan(base!.outputCostPerToken) + }) + + it('returns short name for MiniMax-M2.7', () => { + expect(getShortModelName('MiniMax-M2.7')).toBe('MiniMax M2.7') + }) + + it('returns short name for MiniMax-M2.7-highspeed', () => { + expect(getShortModelName('MiniMax-M2.7-highspeed')).toBe('MiniMax M2.7 Highspeed') + }) + + it('handles MiniMax model ID with date suffix', () => { + expect(getShortModelName('MiniMax-M2.7-20260101')).toBe('MiniMax M2.7') + }) +}) diff --git a/tests/model-efficiency.test.ts b/tests/model-efficiency.test.ts new file mode 100644 index 0000000..cd7ae89 --- /dev/null +++ b/tests/model-efficiency.test.ts @@ -0,0 +1,141 @@ +import { describe, expect, it } from 'vitest' + +import { aggregateModelEfficiency } from '../src/model-efficiency.js' +import type { ClassifiedTurn, ParsedApiCall, ProjectSummary, SessionSummary } from '../src/types.js' + +function call(model: string, costUSD = 1): ParsedApiCall { + return { + provider: 'claude', + model, + usage: { + inputTokens: 100, + outputTokens: 50, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + }, + costUSD, + tools: ['Edit'], + mcpTools: [], + skills: [], + hasAgentSpawn: false, + hasPlanMode: false, + speed: 'standard', + timestamp: '2026-05-05T00:00:00Z', + bashCommands: [], + deduplicationKey: `${model}-${costUSD}`, + } +} + +function turn(model: string, opts: { hasEdits?: boolean; retries?: number; costUSD?: number } = {}): ClassifiedTurn { + return { + userMessage: '', + assistantCalls: [call(model, opts.costUSD ?? 1)], + timestamp: '2026-05-05T00:00:00Z', + sessionId: 's1', + category: 'coding', + retries: opts.retries ?? 0, + hasEdits: opts.hasEdits ?? true, + } +} + +function multiModelTurn(calls: ParsedApiCall[], opts: { retries?: number; hasEdits?: boolean } = {}): ClassifiedTurn { + return { + userMessage: '', + assistantCalls: calls, + timestamp: '2026-05-05T00:00:00Z', + sessionId: 's1', + category: 'coding', + retries: opts.retries ?? 0, + hasEdits: opts.hasEdits ?? true, + } +} + +function project(turns: ClassifiedTurn[]): ProjectSummary { + const session: SessionSummary = { + sessionId: 's1', + project: 'app', + firstTimestamp: '2026-05-05T00:00:00Z', + lastTimestamp: '2026-05-05T00:00:00Z', + totalCostUSD: turns.reduce((sum, t) => sum + t.assistantCalls.reduce((s, c) => s + c.costUSD, 0), 0), + totalInputTokens: 0, + totalOutputTokens: 0, + totalCacheReadTokens: 0, + totalCacheWriteTokens: 0, + apiCalls: turns.reduce((sum, t) => sum + t.assistantCalls.length, 0), + turns, + modelBreakdown: {}, + toolBreakdown: {}, + mcpBreakdown: {}, + bashBreakdown: {}, + categoryBreakdown: {} as SessionSummary['categoryBreakdown'], + skillBreakdown: {}, + } + return { + project: 'app', + projectPath: '/app', + sessions: [session], + totalCostUSD: session.totalCostUSD, + totalApiCalls: session.apiCalls, + } +} + +describe('aggregateModelEfficiency', () => { + it('computes one-shot, retry, and cost-per-edit metrics by display model', () => { + const stats = aggregateModelEfficiency([project([ + turn('claude-sonnet-4-5', { hasEdits: true, retries: 0, costUSD: 2 }), + turn('claude-sonnet-4-5', { hasEdits: true, retries: 2, costUSD: 4 }), + turn('claude-opus-4-6', { hasEdits: true, retries: 0, costUSD: 10 }), + turn('claude-sonnet-4-5', { hasEdits: false, retries: 0, costUSD: 3 }), + ])]) + + const sonnet = stats.get('Sonnet 4.5') + expect(sonnet?.editTurns).toBe(2) + expect(sonnet?.oneShotTurns).toBe(1) + expect(sonnet?.oneShotRate).toBe(50) + expect(sonnet?.retriesPerEdit).toBe(1) + expect(sonnet?.costPerEditUSD).toBe(3) + + const opus = stats.get('Opus 4.6') + expect(opus?.oneShotRate).toBe(100) + }) + + it('returns no stats for non-edit turns', () => { + const stats = aggregateModelEfficiency([project([ + turn('claude-sonnet-4-5', { hasEdits: false }), + ])]) + + expect(stats.size).toBe(0) + }) + + it('attributes a multi-model turn to the first non-synthetic model', () => { + const stats = aggregateModelEfficiency([project([ + multiModelTurn([ + call('<synthetic>', 0), + call('claude-opus-4-6', 2), + call('claude-sonnet-4-5', 1), + ], { retries: 0, hasEdits: true }), + ])]) + + expect(stats.has('Opus 4.6')).toBe(true) + expect(stats.has('Sonnet 4.5')).toBe(false) + expect(stats.has('<synthetic>')).toBe(false) + const opus = stats.get('Opus 4.6')! + expect(opus.editTurns).toBe(1) + expect(opus.oneShotTurns).toBe(1) + expect(opus.costPerEditUSD).toBe(3) + }) + + it('skips a turn whose calls are all synthetic', () => { + const stats = aggregateModelEfficiency([project([ + multiModelTurn([ + call('<synthetic>', 0), + call('<synthetic>', 0), + ], { retries: 0, hasEdits: true }), + ])]) + + expect(stats.size).toBe(0) + }) +}) diff --git a/tests/models-hoist.test.ts b/tests/models-hoist.test.ts new file mode 100644 index 0000000..324e6ff --- /dev/null +++ b/tests/models-hoist.test.ts @@ -0,0 +1,132 @@ +import { describe, it, expect } from 'vitest' +import { calculateCost, getModelCosts, getShortModelName } from '../src/models.js' + +// Lock down the post-hoist refactor: every model name a real user has +// emitted in the last year should resolve to the same display name and +// the same costs as before. If this list grows or shrinks, the refactor +// is fine — it's the per-name resolution that must stay stable. +const KNOWN_NAMES = [ + 'claude-opus-4-7', + 'claude-opus-4-6', + 'claude-opus-4-5', + 'claude-sonnet-4-6', + 'claude-sonnet-4-5', + 'claude-haiku-4-5', + 'claude-3-5-sonnet', + 'claude-3-5-haiku', + 'claude-opus-4-7-20250101', + 'claude-sonnet-4-6-20250929', + 'anthropic/claude-opus-4-7', + 'anthropic--claude-4.6-opus', + 'anthropic--claude-4.6-sonnet', + 'claude-4.6-sonnet', + 'gpt-5', + 'gpt-5-mini', + 'gpt-5-nano', + 'gpt-5-pro', + 'gpt-5.1', + 'gpt-5.1-codex', + 'gpt-5.1-codex-mini', + 'gpt-5.2', + 'gpt-5.2-low', + 'gpt-5.3-codex', + 'gpt-5.4', + 'gpt-5.4-mini', + 'gpt-4o', + 'gpt-4o-mini', + 'gpt-4.1', + 'gpt-4.1-mini', + 'gpt-4.1-nano', + 'gemini-2.5-pro', + 'gemini-2.5-flash', + 'gemini-3.1-pro-preview', + 'gemini-3-flash-preview', + 'gemini-3.1-pro', + 'gemini-3-flash', + 'cursor-auto', + 'cursor-agent-auto', + 'copilot-auto', + 'copilot-openai-auto', + 'kiro-auto', + 'cline-auto', + 'qwen-auto', + 'kimi-auto', + 'kimi-for-coding', + 'kimi-k2-thinking-turbo', + 'kimi-k2.6', + 'o3', + 'o4-mini', + 'deepseek-coder', + 'deepseek-coder-max', + 'deepseek-r1', + 'MiniMax-M2.7', + 'MiniMax-M2.7-highspeed', +] + +describe('post-hoist resolution stability', () => { + it('every known model resolves to a non-empty short name', () => { + for (const name of KNOWN_NAMES) { + const short = getShortModelName(name) + expect(short, `short name for ${name}`).toBeTruthy() + expect(typeof short, `short name for ${name}`).toBe('string') + } + }) + + it('gpt-5-mini does NOT collide with gpt-5 (longest-prefix wins)', () => { + expect(getShortModelName('gpt-5-mini')).toBe('GPT-5 Mini') + expect(getShortModelName('gpt-5')).toBe('GPT-5') + expect(getShortModelName('gpt-5-nano')).toBe('GPT-5 Nano') + expect(getShortModelName('gpt-5-pro')).toBe('GPT-5 Pro') + }) + + it('gpt-5.1-codex-mini does NOT collapse to gpt-5.1-codex or gpt-5', () => { + expect(getShortModelName('gpt-5.1-codex-mini')).toBe('GPT-5.1 Codex Mini') + expect(getShortModelName('gpt-5.1-codex')).toBe('GPT-5.1 Codex') + expect(getShortModelName('gpt-5.1')).toBe('GPT-5.1') + }) + + it('claude-haiku-4-5 does NOT collapse to claude-haiku-4 or claude-3-5-haiku', () => { + expect(getShortModelName('claude-haiku-4-5')).toBe('Haiku 4.5') + expect(getShortModelName('claude-3-5-haiku')).toBe('Haiku 3.5') + }) + + it('kimi managed aliases resolve to priced Kimi models', () => { + expect(getShortModelName('kimi-auto')).toBe('Kimi (auto)') + expect(getShortModelName('kimi-for-coding')).toBe('Kimi K2 Thinking') + expect(getShortModelName('kimi-k2-thinking-turbo')).toBe('Kimi K2 Thinking Turbo') + expect(getShortModelName('kimi-k2.6')).toBe('Kimi K2.6') + expect(getModelCosts('kimi-auto')?.inputCostPerToken).toBeGreaterThan(0) + }) + + it('getModelCosts returns positive token costs for every known name', () => { + for (const name of KNOWN_NAMES) { + const c = getModelCosts(name) + expect(c, `costs for ${name}`).not.toBeNull() + expect(c!.inputCostPerToken).toBeGreaterThan(0) + expect(c!.outputCostPerToken).toBeGreaterThan(0) + } + }) + + it('calculateCost is stable for a typical Sonnet 4.6 turn', () => { + // 1k input, 2k output, 50k cache read — common Claude Code shape. + const cost = calculateCost('claude-sonnet-4-6', 1000, 2000, 0, 50_000, 0) + expect(cost).toBeGreaterThan(0) + expect(Number.isFinite(cost)).toBe(true) + }) + + it('calculateCost clamps NaN/negative inputs to 0', () => { + const c1 = calculateCost('claude-sonnet-4-6', NaN, 1000, 0, 0, 0) + const c2 = calculateCost('claude-sonnet-4-6', 0, 1000, 0, 0, 0) + expect(c1).toBe(c2) + const c3 = calculateCost('claude-sonnet-4-6', -1000, 1000, 0, 0, 0) + expect(c3).toBe(c2) + }) + + it('repeated calls return the same cost (memoized sort cache is consistent)', () => { + const a = getModelCosts('gpt-5-mini') + const b = getModelCosts('gpt-5-mini') + const c = getModelCosts('gpt-5-mini') + expect(a).toEqual(b) + expect(b).toEqual(c) + }) +}) diff --git a/tests/models-report.test.ts b/tests/models-report.test.ts new file mode 100644 index 0000000..0d3c780 --- /dev/null +++ b/tests/models-report.test.ts @@ -0,0 +1,513 @@ +import { describe, it, expect } from 'vitest' +import chalk from 'chalk' +import stripAnsi from 'strip-ansi' + +import { aggregateModels, renderTable, renderMarkdown, renderJson, renderCsv, type ModelReportRow } from '../src/models-report.js' +import type { + ProjectSummary, + SessionSummary, + ClassifiedTurn, + ParsedApiCall, + TokenUsage, + TaskCategory, +} from '../src/types.js' + +function emptyTokens(): TokenUsage { + return { + inputTokens: 0, + outputTokens: 0, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + } +} + +function makeCall(opts: { + provider: string + model: string + costUSD: number + input?: number + output?: number + cacheWrite?: number + cacheRead?: number +}): ParsedApiCall { + return { + provider: opts.provider, + model: opts.model, + usage: { + ...emptyTokens(), + inputTokens: opts.input ?? 0, + outputTokens: opts.output ?? 0, + cacheCreationInputTokens: opts.cacheWrite ?? 0, + cacheReadInputTokens: opts.cacheRead ?? 0, + }, + costUSD: opts.costUSD, + tools: [], + mcpTools: [], + skills: [], + hasAgentSpawn: false, + hasPlanMode: false, + speed: 'standard', + timestamp: '2026-05-09T00:00:00.000Z', + bashCommands: [], + deduplicationKey: `${opts.provider}-${opts.model}-${opts.costUSD}`, + } +} + +function makeTurn(category: TaskCategory, calls: ParsedApiCall[]): ClassifiedTurn { + return { + userMessage: 'test', + assistantCalls: calls, + timestamp: '2026-05-09T00:00:00.000Z', + sessionId: 's1', + category, + retries: 0, + hasEdits: false, + } +} + +function makeSession(turns: ClassifiedTurn[]): SessionSummary { + return { + sessionId: 's1', + project: 'p', + firstTimestamp: '2026-05-09T00:00:00.000Z', + lastTimestamp: '2026-05-09T00:00:00.000Z', + totalCostUSD: 0, + totalInputTokens: 0, + totalOutputTokens: 0, + totalCacheReadTokens: 0, + totalCacheWriteTokens: 0, + apiCalls: 0, + turns, + modelBreakdown: {}, + toolBreakdown: {}, + mcpBreakdown: {}, + bashBreakdown: {}, + categoryBreakdown: {} as SessionSummary['categoryBreakdown'], + skillBreakdown: {}, + } +} + +function makeProject(turns: ClassifiedTurn[]): ProjectSummary { + return { + project: 'p', + projectPath: '/tmp/p', + sessions: [makeSession(turns)], + totalCostUSD: 0, + totalApiCalls: 0, + } +} + +describe('aggregateModels', () => { + it('groups by (provider, model) and sorts by cost descending in default mode', async () => { + const project = makeProject([ + makeTurn('feature', [ + makeCall({ provider: 'claude', model: 'claude-sonnet-4-6', input: 1000, output: 200, cacheWrite: 500, cacheRead: 8000, costUSD: 5.0 }), + ]), + makeTurn('debugging', [ + makeCall({ provider: 'claude', model: 'claude-sonnet-4-6', input: 800, output: 100, cacheWrite: 300, cacheRead: 5000, costUSD: 3.5 }), + ]), + makeTurn('feature', [ + makeCall({ provider: 'codex', model: 'gpt-5', input: 600, output: 80, costUSD: 1.2 }), + ]), + ]) + const rows = await aggregateModels([project]) + expect(rows.map(r => `${r.provider}:${r.model}`)).toEqual(['claude:claude-sonnet-4-6', 'codex:gpt-5']) + const claudeRow = rows[0]! + expect(claudeRow.inputTokens).toBe(1800) + expect(claudeRow.outputTokens).toBe(300) + expect(claudeRow.cacheWriteTokens).toBe(800) + expect(claudeRow.cacheReadTokens).toBe(13000) + expect(claudeRow.costUSD).toBeCloseTo(8.5, 6) + expect(claudeRow.calls).toBe(2) + expect(claudeRow.totalTokens).toBe(1800 + 300 + 800 + 13000) + }) + + it('computes Codex credits per model and leaves non-Codex / unknown models null', async () => { + const rows = await aggregateModels([makeProject([ + // gpt-5.5: 1M non-cached input (125) + 1M cached read (12.5) + 1M output (750) = 887.5 credits + makeTurn('feature', [ + makeCall({ provider: 'codex', model: 'gpt-5.5', input: 1_000_000, output: 1_000_000, cacheRead: 1_000_000, costUSD: 9 }), + ]), + // codex but no known credit rate -> null + makeTurn('feature', [ + makeCall({ provider: 'codex', model: 'gpt-5', input: 1000, output: 80, costUSD: 1.2 }), + ]), + // non-codex provider -> null even if tokens present + makeTurn('feature', [ + makeCall({ provider: 'claude', model: 'claude-sonnet-4-6', input: 1000, output: 200, costUSD: 5 }), + ]), + ])]) + const byKey = Object.fromEntries(rows.map(r => [`${r.provider}:${r.model}`, r])) + expect(byKey['codex:gpt-5.5']!.credits).toBeCloseTo(887.5, 6) + expect(byKey['codex:gpt-5']!.credits).toBeNull() + expect(byKey['claude:claude-sonnet-4-6']!.credits).toBeNull() + }) + + it('includes credits in the JSON output', async () => { + const rows = await aggregateModels([makeProject([ + makeTurn('feature', [ + makeCall({ provider: 'codex', model: 'gpt-5.5', input: 0, output: 1_000_000, cacheRead: 0, costUSD: 9 }), + ]), + ])]) + const parsed = JSON.parse(renderJson(rows)) + expect(parsed[0].credits).toBeCloseTo(750, 6) + }) + + it('does not double-count cache reads when a provider sets both cache fields', async () => { + // Providers like codex/mux/codebuff populate cacheReadInputTokens AND + // cachedInputTokens with the same value (Anthropic vs OpenAI vocabulary for + // the same tokens). The report must count them once, not sum them. + const call = makeCall({ provider: 'mux', model: 'claude-opus-4-8', input: 100, output: 50, cacheRead: 4000, costUSD: 2.0 }) + call.usage.cachedInputTokens = 4000 // mirrors cacheReadInputTokens, as those providers do + + const rows = await aggregateModels([makeProject([makeTurn('feature', [call])])]) + expect(rows[0]!.cacheReadTokens).toBe(4000) // not 8000 + }) + + it('reports the dominant task type with its cost share in default mode', async () => { + const project = makeProject([ + makeTurn('feature', [makeCall({ provider: 'claude', model: 'claude-sonnet-4-6', costUSD: 6.0, input: 100, output: 20 })]), + makeTurn('debugging', [makeCall({ provider: 'claude', model: 'claude-sonnet-4-6', costUSD: 2.0, input: 50, output: 10 })]), + makeTurn('refactoring', [makeCall({ provider: 'claude', model: 'claude-sonnet-4-6', costUSD: 2.0, input: 50, output: 10 })]), + ]) + const rows = await aggregateModels([project]) + expect(rows[0]!.topCategory).toBe('feature') + expect(rows[0]!.topCategoryShare).toBeCloseTo(0.6, 3) + }) + + it('explodes rows by task in byTask mode and groups them so renderer can blank repeats', async () => { + const project = makeProject([ + makeTurn('feature', [makeCall({ provider: 'claude', model: 'claude-sonnet-4-6', costUSD: 6.0, input: 100, output: 20 })]), + makeTurn('debugging', [makeCall({ provider: 'claude', model: 'claude-sonnet-4-6', costUSD: 2.0, input: 50, output: 10 })]), + makeTurn('feature', [makeCall({ provider: 'codex', model: 'gpt-5', costUSD: 1.0, input: 60, output: 10 })]), + ]) + const rows = await aggregateModels([project], { byTask: true }) + expect(rows).toHaveLength(3) + // Group order: claude (8.0) before codex (1.0); within claude, feature (6.0) before debugging (2.0). + expect(rows.map(r => `${r.provider}:${r.model}:${r.category}`)).toEqual([ + 'claude:claude-sonnet-4-6:feature', + 'claude:claude-sonnet-4-6:debugging', + 'codex:gpt-5:feature', + ]) + }) + + it('respects taskFilter by excluding non-matching turns from every bucket', async () => { + const project = makeProject([ + makeTurn('feature', [makeCall({ provider: 'claude', model: 'claude-sonnet-4-6', costUSD: 5.0, input: 100, output: 20 })]), + makeTurn('debugging', [makeCall({ provider: 'claude', model: 'claude-sonnet-4-6', costUSD: 2.0, input: 50, output: 10 })]), + ]) + const rows = await aggregateModels([project], { taskFilter: 'feature' }) + expect(rows).toHaveLength(1) + expect(rows[0]!.costUSD).toBeCloseTo(5.0, 6) + }) + + it('applies topN and minCost filters', async () => { + const project = makeProject([ + makeTurn('feature', [makeCall({ provider: 'claude', model: 'claude-sonnet-4-6', costUSD: 5.0, input: 100, output: 20 })]), + makeTurn('feature', [makeCall({ provider: 'codex', model: 'gpt-5', costUSD: 0.5, input: 50, output: 10 })]), + makeTurn('feature', [makeCall({ provider: 'cursor', model: 'auto', costUSD: 0.001, input: 10, output: 1 })]), + ]) + const top = await aggregateModels([project], { topN: 1 }) + expect(top).toHaveLength(1) + const above = await aggregateModels([project], { minCost: 0.01 }) + expect(above.find(r => r.provider === 'cursor')).toBeUndefined() + }) + + it('counts reasoning tokens as output tokens', async () => { + const project = makeProject([ + makeTurn('feature', [ + { + provider: 'codex', + model: 'gpt-5', + usage: { ...emptyTokens(), inputTokens: 100, outputTokens: 50, reasoningTokens: 200 }, + costUSD: 1.0, + tools: [], + mcpTools: [], + skills: [], + hasAgentSpawn: false, + hasPlanMode: false, + speed: 'standard', + timestamp: '2026-05-09T00:00:00.000Z', + bashCommands: [], + deduplicationKey: 'k', + }, + ]), + ]) + const rows = await aggregateModels([project]) + expect(rows[0]!.outputTokens).toBe(250) + }) +}) + +describe('renderTable', () => { + function visibleWidth(line: string): number { + return stripAnsi(line).length + } + + function row(partial: Partial<ModelReportRow>): ModelReportRow { + return { + provider: 'claude', + providerDisplayName: 'Claude', + model: 'claude-sonnet-4-6', + modelDisplayName: 'Sonnet 4.6', + category: null, + inputTokens: 0, + outputTokens: 0, + cacheWriteTokens: 0, + cacheReadTokens: 0, + totalTokens: 0, + costUSD: 0, + savingsUSD: 0, + savingsBaselineModel: '', + calls: 0, + credits: null, + ...partial, + } + } + + it('blanks repeated provider/model cells in byTask mode but keeps them in default mode', () => { + const rows: ModelReportRow[] = [ + row({ category: 'feature', costUSD: 7.78, inputTokens: 512_000, outputTokens: 98_000, cacheWriteTokens: 1_400_000, cacheReadTokens: 6_200_000, totalTokens: 8_210_000 }), + row({ category: 'debugging', costUSD: 5.31, inputTokens: 380_000, outputTokens: 71_000, cacheWriteTokens: 920_000, cacheReadTokens: 4_100_000, totalTokens: 5_471_000 }), + ] + const out = renderTable(rows, { byTask: true, showTotals: false, terminalWidth: 200 }) + const lines = out.split('\n') + // Layout: top border, header, header-separator, data..., bottom border. + const dataLines = lines.slice(3, -1) + expect(dataLines[0]).toContain('Sonnet 4.6') + expect(dataLines[0]).toContain('Feature Dev') + expect(dataLines[1]).not.toContain('Sonnet 4.6') + expect(dataLines[1]).not.toContain('Claude') + expect(dataLines[1]).toContain('Debugging') + }) + + it('keeps provider/model cells on every row in default mode', () => { + const rows: ModelReportRow[] = [ + row({ topCategory: 'feature', topCategoryShare: 0.6, costUSD: 5.0 }), + row({ provider: 'codex', providerDisplayName: 'Codex', model: 'gpt-5', modelDisplayName: 'GPT-5', topCategory: 'debugging', topCategoryShare: 0.4, costUSD: 1.2 }), + ] + const out = renderTable(rows, { byTask: false, showTotals: false, terminalWidth: 200 }) + const dataLines = out.split('\n').slice(3, -1) + expect(dataLines[0]).toContain('Sonnet 4.6') + expect(dataLines[1]).toContain('GPT-5') + }) + + it('drops cache columns when terminal is narrow', () => { + const rows: ModelReportRow[] = [row({ topCategory: 'feature', topCategoryShare: 1, costUSD: 1 })] + const wide = renderTable(rows, { showTotals: false, terminalWidth: 200 }) + const narrow = renderTable(rows, { showTotals: false, terminalWidth: 80 }) + expect(wide).toContain('Cache Write') + expect(narrow).not.toContain('Cache Write') + expect(narrow).not.toContain('Cache Read') + }) + + it('expands table borders to the available terminal width by default', () => { + const rows: ModelReportRow[] = [ + row({ category: 'coding', costUSD: 1.0, inputTokens: 46_300, outputTokens: 3_700_000, cacheWriteTokens: 16_300_000, cacheReadTokens: 1_569_800_000, totalTokens: 1_589_800_000 }), + row({ category: 'delegation', costUSD: 0.5, inputTokens: 44_200, outputTokens: 1_900_000, cacheWriteTokens: 9_400_000, cacheReadTokens: 499_600_000, totalTokens: 511_000_000 }), + ] + const out = renderTable(rows, { byTask: true, showTotals: false, terminalWidth: 132 }) + const lines = out.split('\n') + expect(visibleWidth(lines[0]!)).toBe(132) + expect(visibleWidth(lines[1]!)).toBe(132) + expect(visibleWidth(lines.at(-1)!)).toBe(132) + }) + + it('keeps every colored table row aligned to the same visible width', () => { + const originalLevel = chalk.level + chalk.level = 1 + try { + const rows: ModelReportRow[] = [ + row({ category: 'coding', costUSD: 978.89, inputTokens: 46_300, outputTokens: 3_700_000, cacheWriteTokens: 16_300_000, cacheReadTokens: 1_569_800_000, totalTokens: 1_589_800_000 }), + row({ category: 'delegation', costUSD: 357.0, inputTokens: 44_200, outputTokens: 1_900_000, cacheWriteTokens: 9_400_000, cacheReadTokens: 499_600_000, totalTokens: 511_000_000 }), + row({ category: 'exploration', costUSD: 324.86, inputTokens: 96_800, outputTokens: 1_600_000, cacheWriteTokens: 16_600_000, cacheReadTokens: 359_400_000, totalTokens: 377_800_000 }), + ] + const out = renderTable(rows, { byTask: true, terminalWidth: 160 }) + const widths = out.split('\n').map(visibleWidth) + expect(new Set(widths)).toEqual(new Set([160])) + } finally { + chalk.level = originalLevel + } + }) + + it('can render compact tables when fullWidth is disabled', () => { + const rows: ModelReportRow[] = [ + row({ category: 'coding', costUSD: 1.0, inputTokens: 46_300, outputTokens: 3_700_000, totalTokens: 1_589_800_000 }), + ] + const out = renderTable(rows, { byTask: true, showTotals: false, terminalWidth: 160, fullWidth: false }) + expect(visibleWidth(out.split('\n')[0]!)).toBeLessThan(160) + }) + + it('emits a footer totals row by default and suppresses it under showTotals=false', () => { + const rows: ModelReportRow[] = [row({ costUSD: 1.0, inputTokens: 100, totalTokens: 100 })] + expect(renderTable(rows, { showTotals: true })).toContain('Total') + expect(renderTable(rows, { showTotals: false })).not.toMatch(/^\s*Total/m) + }) +}) + +describe('renderMarkdown', () => { + it('produces a GitHub-flavored markdown table with right-aligned numeric columns', () => { + const rows: ModelReportRow[] = [ + { + provider: 'claude', + providerDisplayName: 'Claude', + model: 'claude-sonnet-4-6', + modelDisplayName: 'Sonnet 4.6', + category: null, + topCategory: 'feature', + topCategoryShare: 0.6, + inputTokens: 100, + outputTokens: 50, + cacheWriteTokens: 0, + cacheReadTokens: 0, + totalTokens: 150, + costUSD: 1.5, + calls: 1, + }, + ] + const md = renderMarkdown(rows, { showTotals: false }) + const lines = md.split('\n') + expect(lines[0]).toBe('| Provider | Model | Top Task | Input | Output | Cache Write | Cache Read | Total | Cost | Saved |') + expect(lines[1]).toBe('| --- | --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |') + expect(lines[2]).toContain('| Claude |') + expect(lines[2]).toContain('`Sonnet 4.6`') + expect(lines[2]).toContain('Feature Dev (60%)') + }) + + it('escapes pipe characters in provider/model names', () => { + const rows: ModelReportRow[] = [ + { + provider: 'odd', + providerDisplayName: 'A|B', + model: 'm|n', + modelDisplayName: 'M|N', + category: null, + topCategory: 'feature', + topCategoryShare: 1, + inputTokens: 0, + outputTokens: 0, + cacheWriteTokens: 0, + cacheReadTokens: 0, + totalTokens: 0, + costUSD: 0, + calls: 0, + }, + ] + const md = renderMarkdown(rows, { showTotals: false }) + expect(md).toContain('A\\|B') + expect(md).toContain('M\\|N') + }) + + it('emits a bold totals row when showTotals is true', () => { + const rows: ModelReportRow[] = [ + { + provider: 'p', + providerDisplayName: 'P', + model: 'm', + modelDisplayName: 'M', + category: null, + topCategory: 'feature', + topCategoryShare: 1, + inputTokens: 100, + outputTokens: 50, + cacheWriteTokens: 0, + cacheReadTokens: 0, + totalTokens: 150, + costUSD: 1.5, + calls: 1, + }, + ] + const md = renderMarkdown(rows) + expect(md).toContain('**Total**') + }) +}) + +describe('renderJson', () => { + it('emits a JSON array with the documented field shape', () => { + const rows: ModelReportRow[] = [ + { + provider: 'claude', + providerDisplayName: 'Claude', + model: 'claude-sonnet-4-6', + modelDisplayName: 'Sonnet 4.6', + category: null, + topCategory: 'feature', + topCategoryCost: 6.0, + topCategoryShare: 0.6, + inputTokens: 100, + outputTokens: 50, + cacheWriteTokens: 0, + cacheReadTokens: 0, + totalTokens: 150, + costUSD: 1.5, + calls: 1, + }, + ] + const parsed = JSON.parse(renderJson(rows)) as Array<Record<string, unknown>> + expect(parsed).toHaveLength(1) + expect(parsed[0]).toMatchObject({ + provider: 'claude', + model: 'claude-sonnet-4-6', + modelDisplayName: 'Sonnet 4.6', + topCategory: 'feature', + inputTokens: 100, + outputTokens: 50, + totalTokens: 150, + calls: 1, + }) + }) +}) + +describe('renderCsv', () => { + it('produces a header row followed by one row per ModelReportRow', () => { + const rows: ModelReportRow[] = [ + { + provider: 'claude', + providerDisplayName: 'Claude', + model: 'claude-sonnet-4-6', + modelDisplayName: 'Sonnet 4.6', + category: null, + topCategory: 'feature', + topCategoryShare: 0.6, + inputTokens: 100, + outputTokens: 50, + cacheWriteTokens: 0, + cacheReadTokens: 0, + totalTokens: 150, + costUSD: 1.5, + savingsUSD: 0, + calls: 1, + }, + ] + const csv = renderCsv(rows) + const lines = csv.split('\n') + expect(lines[0]).toBe('provider,model,top_task,top_task_share,input_tokens,output_tokens,cache_write_tokens,cache_read_tokens,total_tokens,calls,cost_usd,savings_usd,savings_baseline_model') + expect(lines[1]).toBe('Claude,Sonnet 4.6,Feature Dev,0.6000,100,50,0,0,150,1,1.500000,0.000000,') + }) + + it('escapes commas in provider/model cells', () => { + const rows: ModelReportRow[] = [ + { + provider: 'weird', + providerDisplayName: 'Weird, Co.', + model: 'm', + modelDisplayName: 'M', + category: null, + topCategory: 'feature', + topCategoryShare: 1.0, + inputTokens: 0, + outputTokens: 0, + cacheWriteTokens: 0, + cacheReadTokens: 0, + totalTokens: 0, + costUSD: 0, + savingsUSD: 0, + calls: 0, + }, + ] + const csv = renderCsv(rows) + expect(csv.split('\n')[1]).toContain('"Weird, Co."') + }) +}) diff --git a/tests/models.test.ts b/tests/models.test.ts new file mode 100644 index 0000000..1f70385 --- /dev/null +++ b/tests/models.test.ts @@ -0,0 +1,790 @@ +import { mkdtemp, mkdir, rm, writeFile } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' +import { describe, it, expect, beforeAll, afterEach } from 'vitest' + +import { + findUnpricedModels, + getModelCosts, + getShortModelName, + calculateCost, + loadPricing, + setModelAliases, + setPriceOverrides, + setLocalModelSavings, + getLocalModelSavingsConfigHash, + getPriceOverridesConfigHash, +} from '../src/models.js' +import { getDailyCacheConfigHash } from '../src/usage-aggregator.js' + +beforeAll(async () => { + await loadPricing() +}) + +afterEach(() => { + setModelAliases({}) + setPriceOverrides({}) + setLocalModelSavings({}) +}) + +describe('getModelCosts', () => { + it('does not match short canonical against longer pricing key', () => { + const costs = getModelCosts('gpt-4') + if (costs) { + expect(costs.inputCostPerToken).not.toBe(2.5e-6) + } + }) + + it('returns correct pricing for gpt-4o vs gpt-4o-mini', () => { + const mini = getModelCosts('gpt-4o-mini') + const full = getModelCosts('gpt-4o') + expect(mini).not.toBeNull() + expect(full).not.toBeNull() + expect(mini!.inputCostPerToken).toBeLessThan(full!.inputCostPerToken) + }) + + it('returns fallback pricing for known Claude models', () => { + const costs = getModelCosts('claude-opus-4-6-20260205') + expect(costs).not.toBeNull() + expect(costs!.inputCostPerToken).toBe(5e-6) + }) + + it('prices lowercase glm-5.2 (Hermes spelling) the same as capitalized GLM-5.2', () => { + const lower = getModelCosts('glm-5.2') + const upper = getModelCosts('GLM-5.2') + expect(lower).not.toBeNull() + expect(upper).not.toBeNull() + expect(lower!.inputCostPerToken).toBe(upper!.inputCostPerToken) + expect(lower!.outputCostPerToken).toBe(upper!.outputCostPerToken) + }) +}) + +describe('getShortModelName', () => { + it('maps gpt-4o-mini correctly (not gpt-4o)', () => { + expect(getShortModelName('gpt-4o-mini-2024-07-18')).toBe('GPT-4o Mini') + }) + + it('maps gpt-4o correctly', () => { + expect(getShortModelName('gpt-4o-2024-08-06')).toBe('GPT-4o') + }) + + it('maps gpt-4.1-mini correctly (not gpt-4.1)', () => { + expect(getShortModelName('gpt-4.1-mini-2025-04-14')).toBe('GPT-4.1 Mini') + }) + + it('maps gpt-5.4-mini correctly (not gpt-5.4)', () => { + expect(getShortModelName('gpt-5.4-mini')).toBe('GPT-5.4 Mini') + }) + + // Regression for #461: spark is a distinct variant, not a reasoning suffix. + it('maps gpt-5.3-codex-spark to its own label (not GPT-5.3 Codex)', () => { + const name = getShortModelName('gpt-5.3-codex-spark') + expect(name).not.toBe('GPT-5.3 Codex') + expect(name).toBe('GPT-5.3 Codex Spark') + }) + + it('maps gpt-5.3-codex reasoning suffixes to the base label', () => { + expect(getShortModelName('gpt-5.3-codex-high')).toBe('GPT-5.3 Codex') + expect(getShortModelName('gpt-5.3-codex-low')).toBe('GPT-5.3 Codex') + }) + + it('maps claude-opus-4-6 with date suffix', () => { + expect(getShortModelName('claude-opus-4-6-20260205')).toBe('Opus 4.6') + }) + + // Regression for #420: claude-opus-4-8 must get its own line, not collapse + // into the generic "Opus 4" bucket via the shorter claude-opus-4 prefix. + it('maps claude-opus-4-8 to its own line (not Opus 4)', () => { + expect(getShortModelName('claude-opus-4-8')).toBe('Opus 4.8') + }) + + // A future version is derived from the id with no hand-maintained entry. + it('derives an unreleased claude version with no SHORT_NAMES entry', () => { + expect(getShortModelName('claude-sonnet-5-2')).toBe('Sonnet 5.2') + expect(getShortModelName('claude-haiku-5')).toBe('Haiku 5') + expect(getShortModelName('claude-opus-9-9-20300101')).toBe('Opus 9.9') + }) + + it('shows the real model name for pricing-sibling aliases, not the internal key', () => { + // GLM-5.2 (and its lowercase Hermes spelling) price via the glm-5p1 sibling; + // reports must show GLM-5.2, not the pricing key. + expect(getShortModelName('GLM-5.2')).toBe('GLM-5.2') + expect(getShortModelName('glm-5.2')).toBe('GLM-5.2') + expect(getShortModelName('glm-5p1')).toBe('GLM-5.2') + // Grok Build prices via the grok-build-0.1 sibling. + expect(getShortModelName('grok-build')).toBe('Grok Build') + expect(getShortModelName('grok-build-0.1')).toBe('Grok Build') + // grok-composer has no alias, just a missing display entry. + expect(getShortModelName('grok-composer-2.5-fast')).toBe('Grok Composer 2.5 Fast') + }) +}) + +describe('claude-fable-5 pricing + name', () => { + it('prices at $10/M input, $50/M output via models.dev/OpenRouter gap-fill', () => { + expect(calculateCost('claude-fable-5', 1_000_000, 0, 0, 0, 0)).toBeCloseTo(10, 6) + expect(calculateCost('claude-fable-5', 0, 1_000_000, 0, 0, 0)).toBeCloseTo(50, 6) + }) + it('shows its own display name', () => { + expect(getShortModelName('claude-fable-5')).toBe('Fable 5') + }) +}) + +describe('builtin aliases - getModelCosts', () => { + it('resolves anthropic--claude-4.6-opus', () => { + expect(getModelCosts('anthropic--claude-4.6-opus')).not.toBeNull() + }) + + it('resolves anthropic--claude-4.6-sonnet', () => { + expect(getModelCosts('anthropic--claude-4.6-sonnet')).not.toBeNull() + }) + + it('resolves anthropic--claude-4.5-opus', () => { + expect(getModelCosts('anthropic--claude-4.5-opus')).not.toBeNull() + }) + + it('resolves anthropic--claude-4.5-sonnet', () => { + expect(getModelCosts('anthropic--claude-4.5-sonnet')).not.toBeNull() + }) + + it('resolves anthropic--claude-4.5-haiku', () => { + expect(getModelCosts('anthropic--claude-4.5-haiku')).not.toBeNull() + }) + + it('resolves double-wrapped anthropic/anthropic--claude-4.6-opus', () => { + expect(getModelCosts('anthropic/anthropic--claude-4.6-opus')).not.toBeNull() + }) + + it('resolves double-wrapped anthropic/anthropic--claude-4.6-sonnet', () => { + expect(getModelCosts('anthropic/anthropic--claude-4.6-sonnet')).not.toBeNull() + }) + + it('resolves double-wrapped anthropic/anthropic--claude-4.5-haiku', () => { + expect(getModelCosts('anthropic/anthropic--claude-4.5-haiku')).not.toBeNull() + }) + + it('OMP opus resolves to same pricing as canonical claude-opus-4-6', () => { + expect(getModelCosts('anthropic--claude-4.6-opus')).toEqual(getModelCosts('claude-opus-4-6')) + }) + + it('OMP sonnet resolves to same pricing as canonical claude-sonnet-4-6', () => { + expect(getModelCosts('anthropic--claude-4.6-sonnet')).toEqual(getModelCosts('claude-sonnet-4-6')) + }) + + it('OMP haiku resolves to same pricing as canonical claude-haiku-4-5', () => { + expect(getModelCosts('anthropic--claude-4.5-haiku')).toEqual(getModelCosts('claude-haiku-4-5')) + }) +}) + +describe('builtin aliases - getShortModelName', () => { + it('anthropic--claude-4.6-opus -> Opus 4.6', () => { + expect(getShortModelName('anthropic--claude-4.6-opus')).toBe('Opus 4.6') + }) + + it('anthropic--claude-4.6-sonnet -> Sonnet 4.6', () => { + expect(getShortModelName('anthropic--claude-4.6-sonnet')).toBe('Sonnet 4.6') + }) + + it('anthropic--claude-4.5-opus -> Opus 4.5', () => { + expect(getShortModelName('anthropic--claude-4.5-opus')).toBe('Opus 4.5') + }) + + it('anthropic--claude-4.5-sonnet -> Sonnet 4.5', () => { + expect(getShortModelName('anthropic--claude-4.5-sonnet')).toBe('Sonnet 4.5') + }) + + it('anthropic--claude-4.5-haiku -> Haiku 4.5', () => { + expect(getShortModelName('anthropic--claude-4.5-haiku')).toBe('Haiku 4.5') + }) + + it('anthropic/anthropic--claude-4.6-opus -> Opus 4.6', () => { + expect(getShortModelName('anthropic/anthropic--claude-4.6-opus')).toBe('Opus 4.6') + }) +}) + +describe('Antigravity Gemini 3.5 Flash variants resolve to pricing', () => { + const variants = [ + 'gemini-3.5-flash', + 'gemini-3.5-flash-high', + 'gemini-3.5-flash-medium', + 'gemini-3.5-flash-low', + 'Gemini 3.5 Flash (High)', + ] + + for (const variant of variants) { + it(`${variant} resolves to Gemini 3.5 Flash`, () => { + expect(getModelCosts(variant)).toEqual(getModelCosts('gemini-3.5-flash')) + expect(getShortModelName(variant)).toBe('Gemini 3.5 Flash') + }) + } + + it('calculates non-zero cost for high thinking labels', () => { + expect(calculateCost('gemini-3.5-flash-high', 1000, 100, 0, 0, 0)).toBeGreaterThan(0) + }) +}) + +describe('user aliases via setModelAliases', () => { + it('user alias resolves for getModelCosts', () => { + setModelAliases({ 'my-internal-model': 'claude-sonnet-4-6' }) + expect(getModelCosts('my-internal-model')).toEqual(getModelCosts('claude-sonnet-4-6')) + }) + + it('user alias resolves for getShortModelName', () => { + setModelAliases({ 'my-internal-model': 'claude-opus-4-6' }) + expect(getShortModelName('my-internal-model')).toBe('Opus 4.6') + }) + + it('user alias overrides builtin', () => { + setModelAliases({ 'anthropic--claude-4.6-opus': 'claude-sonnet-4-5' }) + expect(getModelCosts('anthropic--claude-4.6-opus')).toEqual(getModelCosts('claude-sonnet-4-5')) + }) + + it('resetting aliases restores builtins', () => { + setModelAliases({ 'anthropic--claude-4.6-opus': 'claude-sonnet-4-5' }) + setModelAliases({}) + expect(getModelCosts('anthropic--claude-4.6-opus')).toEqual(getModelCosts('claude-opus-4-6')) + }) +}) + +describe('user price overrides', () => { + it('prices a model missing from the pricing snapshot', () => { + const model = 'zz-price-override-missing-model-390' + expect(getModelCosts(model)).toBeNull() + + setPriceOverrides({ + [model]: { input: 1.25, output: 2.5 }, + }) + + const costs = getModelCosts(model) + expect(costs).not.toBeNull() + expect(costs!.inputCostPerToken).toBe(1.25e-6) + expect(costs!.outputCostPerToken).toBe(2.5e-6) + expect(calculateCost(model, 1_000_000, 1_000_000, 0, 0, 0)).toBe(3.75) + }) + + it('wins over snapshot pricing and configured aliases', () => { + setModelAliases({ + 'price-override-aliased-model': 'claude-opus-4-6', + 'price-override-canonical-source': 'price-override-canonical-target', + }) + setPriceOverrides({ + 'gpt-4o': { input: 7, output: 8 }, + 'claude-opus-4-6': { input: 4, output: 5 }, + 'price-override-aliased-model': { input: 2, output: 3 }, + 'price-override-canonical-target': { input: 6, output: 7 }, + }) + + expect(getModelCosts('gpt-4o')!.inputCostPerToken).toBe(7e-6) + expect(getModelCosts('price-override-aliased-model')!.inputCostPerToken).toBe(2e-6) + expect(getModelCosts('price-override-canonical-source')!.inputCostPerToken).toBe(6e-6) + }) + + it('converts USD per 1,000,000 tokens to per-token ModelCosts exactly', () => { + const model = 'price-override-unit-conversion' + setPriceOverrides({ + [model]: { input: 1, output: 0 }, + }) + + expect(getModelCosts(model)!.inputCostPerToken).toBe(1e-6) + expect(calculateCost(model, 1_000_000, 0, 0, 0, 0)).toBe(1) + }) + + it('defaults cache rates from input pricing when omitted', () => { + const model = 'price-override-cache-defaults' + setPriceOverrides({ + [model]: { input: 10, output: 20 }, + }) + + const costs = getModelCosts(model) + expect(costs).not.toBeNull() + expect(costs!.cacheWriteCostPerToken).toBeCloseTo(12.5e-6, 12) + expect(costs!.cacheReadCostPerToken).toBeCloseTo(1e-6, 12) + }) + + it('wins for case-insensitive and prefix matches without shadowing a more-specific exact snapshot entry', () => { + const miniSnapshot = getModelCosts('gpt-5-mini') + expect(miniSnapshot).not.toBeNull() + + setPriceOverrides({ + 'gpt-5': { input: 91, output: 92 }, + }) + + expect(getModelCosts('GPT-5')!.inputCostPerToken).toBe(91e-6) + expect(getModelCosts('gpt-5-foo')!.inputCostPerToken).toBe(91e-6) + + const mini = getModelCosts('gpt-5-mini') + expect(mini).not.toBeNull() + expect(mini!.inputCostPerToken).toBe(miniSnapshot!.inputCostPerToken) + expect(mini!.outputCostPerToken).toBe(miniSnapshot!.outputCostPerToken) + }) + + it('includes builtin and user price overrides in the daily cache config hash', () => { + setLocalModelSavings({ local: 'gpt-4o' }) + setPriceOverrides({}) + + // The builtin overrides always participate, so a release that edits them + // invalidates cached daily costs even with no user overrides configured. + const builtinOnly = getPriceOverridesConfigHash() + expect(builtinOnly).toContain('builtin:') + expect(getPriceOverridesConfigHash()).toBe(builtinOnly) + const baseline = getDailyCacheConfigHash() + + setPriceOverrides({ 'price-hash-model': { input: 1, output: 2 } }) + const firstCombined = getDailyCacheConfigHash() + + setPriceOverrides({ 'price-hash-model': { input: 3, output: 2 } }) + const secondCombined = getDailyCacheConfigHash() + + expect(firstCombined).not.toBe(baseline) + expect(secondCombined).not.toBe(baseline) + expect(secondCombined).not.toBe(firstCombined) + }) +}) + +describe('calculateCost - OMP names produce non-zero cost', () => { + it('calculates cost for anthropic--claude-4.6-opus', () => { + expect(calculateCost('anthropic--claude-4.6-opus', 1000, 200, 0, 0, 0)).toBeGreaterThan(0) + }) + + it('calculates cost for anthropic/anthropic--claude-4.6-sonnet', () => { + expect(calculateCost('anthropic/anthropic--claude-4.6-sonnet', 1000, 200, 0, 0, 0)).toBeGreaterThan(0) + }) +}) + +describe('Warp Claude variants resolve to pricing', () => { + const cases: Array<[string, string]> = [ + ['claude-4-6-sonnet-high', 'claude-sonnet-4-6'], + ['claude-4-6-sonnet-low', 'claude-sonnet-4-6'], + ['claude-4-6-sonnet-medium', 'claude-sonnet-4-6'], + ['claude-4-6-sonnet-high-fast', 'claude-sonnet-4-6'], + ['claude-4-7-opus-xhigh', 'claude-opus-4-7'], + ['claude-4-7-opus-xhigh-fast', 'claude-opus-4-7'], + ] + + for (const [input, expectedAlias] of cases) { + it(`${input} resolves to ${expectedAlias} pricing`, () => { + const costs = getModelCosts(input) + expect(costs).not.toBeNull() + expect(costs!.inputCostPerToken).toBeGreaterThan(0) + const expected = getModelCosts(expectedAlias) + expect(expected).not.toBeNull() + expect(costs!.inputCostPerToken).toBe(expected!.inputCostPerToken) + expect(costs!.outputCostPerToken).toBe(expected!.outputCostPerToken) + }) + + it(`${input} calculates non-zero cost`, () => { + expect(calculateCost(input, 1000, 200, 0, 0, 0)).toBeGreaterThan(0) + }) + } +}) + +describe('calculateCost - Claude cache write durations', () => { + it('prices 1-hour cache writes at 1.6x the 5-minute cache write rate', () => { + const fiveMinute = calculateCost('claude-opus-4-7', 0, 0, 1_000_000, 0, 0) + const oneHour = calculateCost('claude-opus-4-7', 0, 0, 1_000_000, 0, 0, 'standard', 1_000_000) + const mixed = calculateCost('claude-opus-4-7', 0, 0, 100_000, 0, 0, 'standard', 60_000) + + expect(fiveMinute).toBeCloseTo(6.25, 6) + expect(oneHour).toBeCloseTo(10, 6) + expect(mixed).toBeCloseTo(0.85, 6) + }) +}) + +describe('existing model names still resolve', () => { + it('canonical claude-opus-4-6', () => { + expect(getModelCosts('claude-opus-4-6')).not.toBeNull() + }) + + it('canonical claude-sonnet-4-5', () => { + expect(getModelCosts('claude-sonnet-4-5')).not.toBeNull() + }) + + it('date-stamped claude-sonnet-4-20250514', () => { + expect(getModelCosts('claude-sonnet-4-20250514')).not.toBeNull() + }) + + it('pinned claude-sonnet-4-6@20250929', () => { + expect(getModelCosts('claude-sonnet-4-6@20250929')).not.toBeNull() + }) + + it('anthropic/-prefixed anthropic/claude-opus-4-6', () => { + expect(getModelCosts('anthropic/claude-opus-4-6')).not.toBeNull() + }) + + // #420: 4.8 has its own LiteLLM pricing tier ($5/$25), so it must not fall + // through the prefix match to the older, 3x-pricier claude-opus-4 ($15/$75). + it('claude-opus-4-8 prices at its own tier, not original claude-opus-4', () => { + const v48 = getModelCosts('claude-opus-4-8') + expect(v48).not.toBeNull() + // $5/$25 per M tokens — the 4.6/4.7 tier, not the original opus-4 $15/$75. + expect(v48!.inputCostPerToken).toBeCloseTo(0.000005, 12) + expect(v48!.outputCostPerToken).toBeCloseTo(0.000025, 12) + expect(v48!.inputCostPerToken).not.toEqual(getModelCosts('claude-opus-4')!.inputCostPerToken) + }) +}) + +// Issue #159: every model name Cursor emits in its SQLite database must +// resolve to a non-zero pricing entry, otherwise the dashboard shows $0 for +// that model. Each case asserts the resolved pricing identity matches the +// pricing of the expected canonical key, so an accidental alias swap (e.g. +// `claude-4.6-opus` aliased to a haiku entry) fails the test even though +// haiku also has positive pricing. +describe('Cursor model variants resolve to pricing', () => { + const cases: Array<[string, string]> = [ + // Sonnet family + ['claude-4-sonnet', 'claude-sonnet-4'], + ['claude-4-sonnet-1m', 'claude-sonnet-4'], + ['claude-4-sonnet-thinking', 'claude-sonnet-4-5'], + ['claude-4.5-sonnet', 'claude-sonnet-4-5'], + ['claude-4.5-sonnet-thinking', 'claude-sonnet-4-5'], + ['claude-4.6-sonnet', 'claude-sonnet-4-6'], + ['claude-4.6-sonnet-high', 'claude-sonnet-4-6'], + ['claude-4.6-sonnet-low', 'claude-sonnet-4-6'], + ['claude-4.6-sonnet-thinking', 'claude-sonnet-4-6'], + ['claude-4.6-sonnet-high-thinking', 'claude-sonnet-4-6'], + // Opus family + ['claude-4-opus', 'claude-opus-4'], + ['claude-4.5-opus', 'claude-opus-4-5'], + ['claude-4.5-opus-high', 'claude-opus-4-5'], + ['claude-4.5-opus-low', 'claude-opus-4-5'], + ['claude-4.5-opus-medium', 'claude-opus-4-5'], + ['claude-4.5-opus-high-thinking', 'claude-opus-4-5'], + ['claude-4.6-opus', 'claude-opus-4-6'], + ['claude-4.6-opus-fast-mode', 'claude-opus-4-6'], + ['claude-4.6-opus-high', 'claude-opus-4-6'], + ['claude-4.6-opus-low', 'claude-opus-4-6'], + ['claude-4.6-opus-medium', 'claude-opus-4-6'], + ['claude-4.6-opus-high-thinking', 'claude-opus-4-6'], + ['claude-4.7-opus', 'claude-opus-4-7'], + ['claude-opus-4-7-thinking-high', 'claude-opus-4-7'], + // Haiku family + ['claude-4.5-haiku', 'claude-haiku-4-5'], + ['claude-4.6-haiku', 'claude-haiku-4-5'], + // Cursor auto proxy + ['cursor-auto', 'claude-sonnet-4-5'], + // OpenAI variants Cursor emits + ['gpt-5', 'gpt-5'], + ['gpt-5-fast', 'gpt-5'], + ['gpt-5.2', 'gpt-5.2'], + ['gpt-5.2-low', 'gpt-5'], + // Direct LiteLLM hits where no alias is required + ['grok-code-fast-1', 'grok-code-fast-1'], + ['gemini-3-pro', 'gemini-3-pro-preview'], + ] + + for (const [input, expectedAlias] of cases) { + it(`${input} resolves to ${expectedAlias} pricing`, () => { + const costs = getModelCosts(input) + expect(costs, `${input} should resolve to pricing (and not produce $0 in the dashboard)`).not.toBeNull() + expect(costs!.inputCostPerToken).toBeGreaterThan(0) + expect(costs!.outputCostPerToken).toBeGreaterThan(0) + const expected = getModelCosts(expectedAlias) + expect(expected, `expected target ${expectedAlias} should itself resolve`).not.toBeNull() + // Identity check: the alias must produce the SAME pricing object as + // the canonical key, not just any non-zero pricing. Catches drift + // where a future edit re-points an alias at a wrong-but-positive entry. + expect(costs!.inputCostPerToken).toBe(expected!.inputCostPerToken) + expect(costs!.outputCostPerToken).toBe(expected!.outputCostPerToken) + }) + } +}) + +describe('Cursor house model pricing', () => { + const cases: Array<[string, { input: number; output: number; cacheWrite: number; cacheRead: number }]> = [ + ['composer-2.5', { input: 0.5, output: 2.5, cacheWrite: 0.5, cacheRead: 0.2 }], + ['composer-2', { input: 0.5, output: 2.5, cacheWrite: 0.5, cacheRead: 0.2 }], + ['composer-1.5', { input: 3.5, output: 17.5, cacheWrite: 3.5, cacheRead: 0.35 }], + ['composer-1', { input: 1.25, output: 10, cacheWrite: 1.25, cacheRead: 0.125 }], + ] + + for (const [model, rates] of cases) { + it(`${model} uses Cursor-published rates instead of Claude Sonnet proxy pricing`, () => { + const costs = getModelCosts(model) + expect(costs).not.toBeNull() + expect(costs!.inputCostPerToken).toBeCloseTo(rates.input * 1e-6, 12) + expect(costs!.outputCostPerToken).toBeCloseTo(rates.output * 1e-6, 12) + expect(costs!.cacheWriteCostPerToken).toBeCloseTo(rates.cacheWrite * 1e-6, 12) + expect(costs!.cacheReadCostPerToken).toBeCloseTo(rates.cacheRead * 1e-6, 12) + }) + } +}) + +// Regression: LiteLLM ships `snowflake/claude-4-opus` ($5/M, a gateway rate), +// which the bundler strips to a bare `claude-4-opus` snapshot key. Without the +// alias-precedence guard in getModelCosts, that bare reseller key shadows the +// curated alias `claude-4-opus -> claude-opus-4` and mis-prices Opus 4 at a +// third of its official list price. Pin the official number so a re-shadowing +// fails loudly rather than silently under-reporting spend. +describe('alias precedence over stripped reseller keys', () => { + it('claude-4-opus resolves to the official Opus 4 list price, not a gateway discount', () => { + const aliased = getModelCosts('claude-4-opus') + const canonical = getModelCosts('claude-opus-4') + expect(aliased).not.toBeNull() + expect(canonical).not.toBeNull() + expect(aliased!.inputCostPerToken).toBe(canonical!.inputCostPerToken) + expect(aliased!.outputCostPerToken).toBe(canonical!.outputCostPerToken) + expect(aliased!.inputCostPerToken).toBe(15e-6) + expect(aliased!.outputCostPerToken).toBe(75e-6) + }) + + it('the explicit provider prefix is still honored for the gateway rate', () => { + // The guard fires only for the bare name; a fully-qualified gateway id must + // still return that gateway's own price when LiteLLM publishes one. + const gateway = getModelCosts('snowflake/claude-4-opus') + const bare = getModelCosts('claude-4-opus') + expect(gateway).not.toBeNull() + expect(gateway!.inputCostPerToken).toBeLessThan(bare!.inputCostPerToken) + }) +}) + +// The case-insensitive index that lets `MiniMax-M3` reach a lowercase +// `minimax-m3` slug must NOT let a case-mismatched query resolve to one of +// LiteLLM's [0,0] price stubs (e.g. `GigaChat-2-Max`). Doing so would flip an +// honest null (which fires the "no pricing data, will show $0" warning) into a +// silent $0 and hide real spend. A case-EXACT query still finds the stub. +describe('zero-priced stubs do not satisfy case-insensitive lookup', () => { + it('a case-mismatched query to a [0,0] stub stays null', () => { + expect(getModelCosts('gigachat-2-max')).toBeNull() + }) + + it('the case-exact stub still resolves (just at zero cost)', () => { + const exact = getModelCosts('GigaChat-2-Max') + expect(exact).not.toBeNull() + expect(exact!.inputCostPerToken).toBe(0) + }) +}) + +describe('DeepSeek v4 models resolve to pricing', () => { + it('deepseek-v4-pro has current official discounted pricing', () => { + const costs = getModelCosts('deepseek-v4-pro') + expect(costs).not.toBeNull() + expect(costs!.inputCostPerToken).toBe(4.35e-7) + expect(costs!.outputCostPerToken).toBe(8.7e-7) + expect(costs!.cacheReadCostPerToken).toBe(3.625e-9) + expect(costs!.cacheWriteCostPerToken).toBe(0) + }) + + it('deepseek-v4-flash has current official pricing', () => { + const costs = getModelCosts('deepseek-v4-flash') + expect(costs).not.toBeNull() + expect(costs!.inputCostPerToken).toBe(1.4e-7) + expect(costs!.outputCostPerToken).toBe(2.8e-7) + expect(costs!.cacheReadCostPerToken).toBe(2.8e-9) + expect(costs!.cacheWriteCostPerToken).toBe(0) + }) + + it('provider-prefixed DeepSeek v4 names resolve to the same pricing', () => { + expect(getModelCosts('deepseek/deepseek-v4-pro')).toEqual(getModelCosts('deepseek-v4-pro')) + expect(getModelCosts('deepseek/deepseek-v4-flash')).toEqual(getModelCosts('deepseek-v4-flash')) + }) + + it('calculates non-zero costs for observed DeepSeek v4 Claude usage', () => { + const pro = calculateCost('deepseek-v4-pro', 2_477_914, 762_994, 0, 258_556_928, 0) + const flash = calculateCost('deepseek-v4-flash', 1_552_573, 353_914, 0, 48_388_608, 0) + + expect(pro).toBeCloseTo(2.68, 2) + expect(flash).toBeCloseTo(0.45, 2) + }) + + it('uses DeepSeek v4 display names', () => { + expect(getShortModelName('deepseek-v4-pro')).toBe('DeepSeek v4 Pro') + expect(getShortModelName('deepseek-v4-flash')).toBe('DeepSeek v4 Flash') + }) + + it('keeps bundled DeepSeek v4 fallback entries when runtime pricing cache is stale', async () => { + const cacheRoot = await mkdtemp(join(tmpdir(), 'codeburn-pricing-cache-')) + + try { + process.env['CODEBURN_CACHE_DIR'] = cacheRoot + await mkdir(cacheRoot, { recursive: true }) + await writeFile(join(cacheRoot, 'litellm-pricing.json'), JSON.stringify({ + timestamp: Date.now(), + data: { + 'gpt-4o-mini': { + inputCostPerToken: 9e-7, + outputCostPerToken: 1.8e-6, + cacheWriteCostPerToken: 0, + cacheReadCostPerToken: 9e-8, + webSearchCostPerRequest: 0.01, + fastMultiplier: 1, + }, + }, + }), 'utf-8') + + await loadPricing() + + expect(getModelCosts('gpt-4o-mini')!.inputCostPerToken).toBe(9e-7) + expect(getModelCosts('deepseek-v4-pro')!.inputCostPerToken).toBe(4.35e-7) + expect(getModelCosts('deepseek-v4-flash')!.inputCostPerToken).toBe(1.4e-7) + } finally { + await rm(cacheRoot, { recursive: true, force: true }) + await loadPricing() + } + }) +}) + +describe('provider pricing suffix variants', () => { + const cases: Array<[string, string]> = [ + ['GLM-4.7-TEE', 'glm-4.7'], + ['glm-4.7:thinking', 'glm-4.7'], + ['Kimi-K2.5-TEE', 'kimi-k2.5'], + ['deepseek-v4-pro:cloud', 'deepseek-v4-pro'], + ['glm-5:thinking', 'glm-5'], + ['kimi-k2.6:thinking', 'kimi-k2.6'], + ['deepseek-v4-flash:thinking', 'deepseek-v4-flash'], + ['minimax-m3:cloud', 'minimax-m3'], + ] + + for (const [input, expectedBase] of cases) { + it(`${input} resolves through ${expectedBase}`, () => { + const costs = getModelCosts(input) + const expected = getModelCosts(expectedBase) + expect(costs).not.toBeNull() + expect(expected).not.toBeNull() + expect(costs!.inputCostPerToken).toBe(expected!.inputCostPerToken) + expect(costs!.outputCostPerToken).toBe(expected!.outputCostPerToken) + }) + } + + it('does not strip arbitrary local runtime tags', () => { + expect(getModelCosts('qwen3.6:35b-a3b-bf16')).toBeNull() + }) + + it('does not strip free-tier markers into paid pricing', () => { + expect(getModelCosts('mimo-v2-flash:free')).toBeNull() + }) +}) + +describe('observed provider model aliases', () => { + const cases: Array<[string, string]> = [ + ['MiMo-V2-Flash', 'xiaomi/mimo-v2-flash'], + ['KAT-Coder-Pro-V1', 'kwaipilot/kat-coder-pro'], + ] + + for (const [input, expectedModel] of cases) { + it(`${input} resolves through ${expectedModel}`, () => { + const costs = getModelCosts(input) + const expected = getModelCosts(expectedModel) + expect(costs).not.toBeNull() + expect(expected).not.toBeNull() + expect(costs).toEqual(expected) + expect(calculateCost(input, 1_000_000, 1_000_000, 0, 0, 0)).toBeGreaterThan(0) + }) + } + + it('does not map dated Qwen3 Max to a reseller price without provider context', () => { + expect(getModelCosts('qwen3-max-2026-01-23')).toBeNull() + expect(calculateCost('qwen3-max-2026-01-23', 1_000_000, 1_000_000, 0, 0, 0)).toBe(0) + }) +}) + +describe('findUnpricedModels', () => { + it('flags an unknown paid-looking model with $0 cost and skips priced ones', () => { + const rows = [ + { model: 'claude-opus-4-6', calls: 10, cost: 2.5, tokens: 5000 }, + { model: 'zz-mystery-paid-model-999', calls: 3, cost: 0, tokens: 1200 }, + ] + const unpriced = findUnpricedModels(rows) + expect(unpriced).toEqual([{ model: 'zz-mystery-paid-model-999', calls: 3, tokens: 1200 }]) + }) + + it('never flags a row that carries real cost, even when the lookup misses', () => { + // Aggregation keys rows by display name; the lookup misses but the row was + // priced at parse time, so it must not be reported as unpriced. + const unpriced = findUnpricedModels([ + { model: 'Opus 4.8', calls: 100, cost: 42.5, tokens: 1_000_000 }, + { model: 'zz-unknown-but-priced-elsewhere', calls: 5, cost: 0.01, tokens: 500 }, + ]) + expect(unpriced).toEqual([]) + }) + + it('flags $0 display-name rows even when the raw id would price today', () => { + // Droid prices the lowercased display name ("claude sonnet 4.6" -> no + // pricing -> $0) and the parser keys the row by display name. Those + // tokens really entered the report at $0, so the row must be flagged + // even though claude-sonnet-4-6 itself is priced. + const unpriced = findUnpricedModels([ + { model: 'Sonnet 4.6', calls: 12, cost: 0, tokens: 500_000 }, + ]) + expect(unpriced).toEqual([{ model: 'Sonnet 4.6', calls: 12, tokens: 500_000 }]) + }) + + it('flags zero-rate pricing stubs but not explicit zero-rate user overrides', async () => { + // LiteLLM ships [0,0] stubs for models it lists but has no price for; + // a stub hit means "unknown price", not "free". + const cacheRoot = await mkdtemp(join(tmpdir(), 'codeburn-pricing-cache-')) + try { + process.env['CODEBURN_CACHE_DIR'] = cacheRoot + await writeFile(join(cacheRoot, 'litellm-pricing.json'), JSON.stringify({ + timestamp: Date.now(), + data: { + 'zz-zero-stub-model': { + inputCostPerToken: 0, + outputCostPerToken: 0, + cacheWriteCostPerToken: 0, + cacheReadCostPerToken: 0, + webSearchCostPerRequest: 0, + fastMultiplier: 1, + }, + }, + }), 'utf-8') + await loadPricing() + + expect(getModelCosts('zz-zero-stub-model')).not.toBeNull() + const rows = [{ model: 'zz-zero-stub-model', calls: 3, cost: 0, tokens: 1100 }] + expect(findUnpricedModels(rows)).toHaveLength(1) + + // An explicit user override at zero rates means "this model is free". + setPriceOverrides({ 'zz-zero-stub-model': { input: 0, output: 0 } }) + expect(findUnpricedModels(rows)).toEqual([]) + + // A prefix override cannot prove intent: getModelCosts resolves table + // hits before prefix overrides, so the $0 came from the stub, not the + // user. Still flagged. + setPriceOverrides({ 'zz-zero-stub': { input: 0, output: 0 } }) + expect(findUnpricedModels(rows)).toHaveLength(1) + } finally { + delete process.env['CODEBURN_CACHE_DIR'] + await rm(cacheRoot, { recursive: true, force: true }) + setPriceOverrides({}) + await loadPricing() + } + }) + + it('skips synthetic, empty, local-looking, and zero-usage rows', () => { + const unpriced = findUnpricedModels([ + { model: '<synthetic>', calls: 5, cost: 0, tokens: 100 }, + { model: '', calls: 5, cost: 0, tokens: 100 }, + { model: 'llama3.1:8b', calls: 5, cost: 0, tokens: 100 }, + { model: 'zz-quantized-model-bf16', calls: 5, cost: 0, tokens: 100 }, + { model: 'zz-no-usage-model', calls: 0, cost: 0, tokens: 0 }, + ]) + expect(unpriced).toEqual([]) + }) + + it('heals when the user configures an alias or a price override', () => { + const model = 'zz-proxy-renamed-model-x1' + expect(findUnpricedModels([{ model, calls: 1, cost: 0, tokens: 10 }])).toHaveLength(1) + + setModelAliases({ [model]: 'claude-opus-4-6' }) + expect(findUnpricedModels([{ model, calls: 1, cost: 0, tokens: 10 }])).toEqual([]) + setModelAliases({}) + + setPriceOverrides({ [model]: { input: 1, output: 2 } }) + expect(findUnpricedModels([{ model, calls: 1, cost: 0, tokens: 10 }])).toEqual([]) + }) + + it('skips models mapped via model-savings (intentionally $0)', () => { + const model = 'zz-my-local-runner' + expect(findUnpricedModels([{ model, calls: 1, cost: 0, tokens: 10 }])).toHaveLength(1) + setLocalModelSavings({ [model]: 'gpt-4o' }) + expect(findUnpricedModels([{ model, calls: 1, cost: 0, tokens: 10 }])).toEqual([]) + }) + + it('sorts by tokens, then calls', () => { + const unpriced = findUnpricedModels([ + { model: 'zz-small', calls: 9, cost: 0, tokens: 10 }, + { model: 'zz-big', calls: 1, cost: 0, tokens: 9999 }, + ]) + expect(unpriced.map(u => u.model)).toEqual(['zz-big', 'zz-small']) + }) +}) diff --git a/tests/optimize-apply.test.ts b/tests/optimize-apply.test.ts new file mode 100644 index 0000000..2b58228 --- /dev/null +++ b/tests/optimize-apply.test.ts @@ -0,0 +1,655 @@ +import { afterAll, describe, expect, it } from 'vitest' +import { mkdtemp, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises' +import { existsSync } from 'node:fs' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { createHash } from 'node:crypto' +import { PassThrough, Writable } from 'node:stream' + +import { planFor, planFindings, type PlanContext } from '../src/act/plans.js' +import { renderApplyList, runOptimizeApply, type ApplyOptions } from '../src/act/optimize-apply.js' +import { runAction } from '../src/act/apply.js' +import { undoAction } from '../src/act/undo.js' +import { readRecords, shortId } from '../src/act/journal.js' +import { + detectBloatedClaudeMd, + detectDuplicateReads, + detectJunkReads, + detectLowReadEditRatio, + detectMcpToolCoverage, +} from '../src/optimize.js' +import type { + FindingApply, + FindingId, + McpServerCoverage, + ToolCall, + WasteAction, + WasteFinding, +} from '../src/optimize.js' + +const roots: string[] = [] + +type Fixture = { root: string; home: string; project: string; actionsDir: string } + +async function makeFixture(): Promise<Fixture> { + const root = await mkdtemp(join(tmpdir(), 'codeburn-optimize-apply-')) + roots.push(root) + const home = join(root, 'home') + const project = join(root, 'project') + await mkdir(home, { recursive: true }) + await mkdir(project, { recursive: true }) + return { root, home, project, actionsDir: join(root, 'actions') } +} + +afterAll(async () => { + for (const root of roots) await rm(root, { recursive: true, force: true }) +}) + +function makeFinding(id: FindingId, fix: WasteAction, apply?: FindingApply): WasteFinding { + return { id, title: id, explanation: '', impact: 'medium', tokensSaved: 1000, fix, ...(apply ? { apply } : {}) } +} + +const CMD_FIX: WasteAction = { type: 'command', label: '', text: '' } + +async function hashTree(dir: string): Promise<string> { + const h = createHash('sha256') + async function walk(d: string): Promise<void> { + const entries = (await readdir(d, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name)) + for (const entry of entries) { + const full = join(d, entry.name) + if (entry.isDirectory()) { + h.update('D:' + full + '\n') + await walk(full) + } else { + h.update('F:' + full + '\n') + h.update(await readFile(full)) + } + } + } + await walk(dir) + return h.digest('hex') +} + +describe('mcp-remove plan', () => { + it('deletes exactly the named server, leaves other keys untouched, and undo restores byte-identical', async () => { + const fx = await makeFixture() + const claudeJson = join(fx.home, '.claude.json') + const original = JSON.stringify({ + mcpServers: { alpha: { command: 'a' }, beta: { command: 'b', args: ['x'] } }, + numFoo: 3, + nested: { keep: true }, + }, null, 2) + '\n' + await writeFile(claudeJson, original) + await writeFile(join(fx.project, '.mcp.json'), JSON.stringify({ mcpServers: { gamma: {} } }, null, 2) + '\n') + + const finding = makeFinding('mcp-low-coverage', CMD_FIX, { kind: 'mcp-remove', servers: ['beta'] }) + const plan = planFor(finding, { homeDir: fx.home, cwd: fx.project }) + expect(plan).not.toBeNull() + expect(plan!.changes).toHaveLength(1) + expect(plan!.changes[0]!.path).toBe(claudeJson) + + const rec = await runAction(plan!, fx.actionsDir) + + const after = JSON.parse(await readFile(claudeJson, 'utf-8')) + expect(after.mcpServers).toEqual({ alpha: { command: 'a' } }) + expect(after.numFoo).toBe(3) + expect(after.nested).toEqual({ keep: true }) + // Untouched sibling config file. + expect(JSON.parse(await readFile(join(fx.project, '.mcp.json'), 'utf-8')).mcpServers).toEqual({ gamma: {} }) + // 2-space indent + trailing newline contract. + expect(await readFile(claudeJson, 'utf-8')).toBe(JSON.stringify(after, null, 2) + '\n') + + await undoAction({ id: rec.id }, { actionsDir: fx.actionsDir }) + expect(await readFile(claudeJson, 'utf-8')).toBe(original) + }) +}) + +describe('mcp-project-scope plan', () => { + it('moves the entry from the global config into the keeper project .mcp.json, creating it when missing', async () => { + const fx = await makeFixture() + const claudeJson = join(fx.home, '.claude.json') + const serverValue = { command: 'srv', args: ['--flag'], env: { A: '1' } } + const original = JSON.stringify({ mcpServers: { srv: serverValue }, other: 1 }, null, 2) + '\n' + await writeFile(claudeJson, original) + + const keeper = join(fx.root, 'keeper') + await mkdir(keeper, { recursive: true }) + const keeperMcp = join(keeper, '.mcp.json') + expect(existsSync(keeperMcp)).toBe(false) + + const finding = makeFinding('mcp-project-scope', { type: 'paste', destination: 'prompt', label: '', text: '' }, { + kind: 'mcp-project-scope', + servers: [{ server: 'srv', keepProjects: [keeper], removeProjects: [] }], + }) + const plan = planFor(finding, { homeDir: fx.home, cwd: fx.project }) + expect(plan).not.toBeNull() + + const rec = await runAction(plan!, fx.actionsDir) + + expect(JSON.parse(await readFile(claudeJson, 'utf-8')).mcpServers).toEqual({}) + expect(existsSync(keeperMcp)).toBe(true) + expect(JSON.parse(await readFile(keeperMcp, 'utf-8')).mcpServers).toEqual({ srv: serverValue }) + + await undoAction({ id: rec.id }, { actionsDir: fx.actionsDir }) + expect(await readFile(claudeJson, 'utf-8')).toBe(original) + expect(existsSync(keeperMcp)).toBe(false) + }) +}) + +describe('unparseable config file', () => { + it('reports the parse error, skips that server, and still applies the servers it can read', async () => { + const fx = await makeFixture() + const claudeJson = join(fx.home, '.claude.json') + await writeFile(claudeJson, JSON.stringify({ mcpServers: { good: { command: 'g' } } }, null, 2) + '\n') + const brokenMcp = join(fx.project, '.mcp.json') + await writeFile(brokenMcp, '{ this is not valid json,,, ') + + const finding = makeFinding('mcp-low-coverage', CMD_FIX, { kind: 'mcp-remove', servers: ['good', 'bad'] }) + const { plan, notes } = planFindings([finding], { homeDir: fx.home, cwd: fx.project })[0]! + + expect(notes.some(n => /could not parse/.test(n) && n.includes('.mcp.json'))).toBe(true) + expect(notes.some(n => n.includes('bad'))).toBe(true) + expect(plan).not.toBeNull() + expect(plan!.changes.map(c => c.path)).toEqual([claudeJson]) + + await runAction(plan!, fx.actionsDir) + expect(JSON.parse(await readFile(claudeJson, 'utf-8')).mcpServers).toEqual({}) + // The broken file is left exactly as-is. + expect(await readFile(brokenMcp, 'utf-8')).toBe('{ this is not valid json,,, ') + }) +}) + +describe('archive plan', () => { + it('archives a skill dir and an agent file, round-trips undo, and suffixes a colliding name with -2', async () => { + const fx = await makeFixture() + const skillsDir = join(fx.home, '.claude', 'skills') + const agentsDir = join(fx.home, '.claude', 'agents') + await mkdir(join(skillsDir, 'foo'), { recursive: true }) + await writeFile(join(skillsDir, 'foo', 'SKILL.md'), 'skill body') + // Pre-existing archive with the same name forces the -2 suffix. + await mkdir(join(skillsDir, '.archived', 'foo'), { recursive: true }) + await writeFile(join(skillsDir, '.archived', 'foo', 'SKILL.md'), 'old archived') + await mkdir(agentsDir, { recursive: true }) + await writeFile(join(agentsDir, 'bar.md'), 'agent body') + + const skillFinding = makeFinding('unused-skills', CMD_FIX, { kind: 'archive', names: ['foo'] }) + const skillPlan = planFor(skillFinding, { homeDir: fx.home, cwd: fx.project }) + expect(skillPlan!.changes[0]).toMatchObject({ + op: 'move', + path: join(skillsDir, 'foo'), + movedTo: join(skillsDir, '.archived', 'foo-2'), + }) + const skillRec = await runAction(skillPlan!, fx.actionsDir) + expect(existsSync(join(skillsDir, 'foo'))).toBe(false) + expect(await readFile(join(skillsDir, '.archived', 'foo-2', 'SKILL.md'), 'utf-8')).toBe('skill body') + // The pre-existing archive is preserved. + expect(await readFile(join(skillsDir, '.archived', 'foo', 'SKILL.md'), 'utf-8')).toBe('old archived') + + const agentFinding = makeFinding('unused-agents', CMD_FIX, { kind: 'archive', names: ['bar'] }) + const agentPlan = planFor(agentFinding, { homeDir: fx.home, cwd: fx.project }) + expect(agentPlan!.changes[0]).toMatchObject({ + op: 'move', + path: join(agentsDir, 'bar.md'), + movedTo: join(agentsDir, '.archived', 'bar.md'), + }) + const agentRec = await runAction(agentPlan!, fx.actionsDir) + expect(existsSync(join(agentsDir, 'bar.md'))).toBe(false) + + await undoAction({ id: agentRec.id }, { actionsDir: fx.actionsDir }) + await undoAction({ id: skillRec.id }, { actionsDir: fx.actionsDir }) + expect(await readFile(join(agentsDir, 'bar.md'), 'utf-8')).toBe('agent body') + expect(await readFile(join(skillsDir, 'foo', 'SKILL.md'), 'utf-8')).toBe('skill body') + expect(existsSync(join(skillsDir, '.archived', 'foo-2'))).toBe(false) + }) +}) + +describe('claude-md rule plan', () => { + it('appends a fresh marker block, replaces it in place on re-apply, and undo removes it', async () => { + const fx = await makeFixture() + const claudeMd = join(fx.project, 'CLAUDE.md') + const original = '# Project\n\nExisting rules.\n' + await writeFile(claudeMd, original) + + const first = makeFinding('read-edit-ratio', { type: 'paste', destination: 'claude-md', label: '', text: 'Read before editing.' }) + const firstPlan = planFor(first, { homeDir: fx.home, cwd: fx.project }) + const firstRec = await runAction(firstPlan!, fx.actionsDir) + + let body = await readFile(claudeMd, 'utf-8') + expect(body).toContain('# Project') + expect(body).toContain('') + expect(body).toContain('Read before editing.') + expect(body).toContain('') + + // Second apply with the same id replaces the block instead of duplicating. + const second = makeFinding('read-edit-ratio', { type: 'paste', destination: 'claude-md', label: '', text: 'Read first, then edit.' }) + const secondPlan = planFor(second, { homeDir: fx.home, cwd: fx.project }) + const secondRec = await runAction(secondPlan!, fx.actionsDir) + + body = await readFile(claudeMd, 'utf-8') + expect(body.match(/codeburn:begin read-edit-ratio/g)).toHaveLength(1) + expect(body).toContain('Read first, then edit.') + expect(body).not.toContain('Read before editing.') + + await undoAction({ id: secondRec.id }, { actionsDir: fx.actionsDir }) + await undoAction({ id: firstRec.id }, { actionsDir: fx.actionsDir }) + expect(await readFile(claudeMd, 'utf-8')).toBe(original) + }) +}) + +describe('shell-config plan', () => { + it('writes the bash cap inside # markers to the rc chosen from $SHELL', async () => { + const fx = await makeFixture() + const finding = makeFinding('bash-output-cap', { type: 'paste', destination: 'shell-config', label: '', text: 'export BASH_MAX_OUTPUT_LENGTH=15000' }) + const plan = planFor(finding, { homeDir: fx.home, cwd: fx.project, shell: '/bin/zsh' }) + expect(plan!.changes[0]!.path).toBe(join(fx.home, '.zshrc')) + + await runAction(plan!, fx.actionsDir) + const body = await readFile(join(fx.home, '.zshrc'), 'utf-8') + expect(body).toBe('# codeburn:begin bash-output-cap\nexport BASH_MAX_OUTPUT_LENGTH=15000\n# codeburn:end bash-output-cap\n') + }) +}) + +describe('dry-run', () => { + it('leaves the fixture tree byte-identical when only planning', async () => { + const fx = await makeFixture() + await writeFile(join(fx.home, '.claude.json'), JSON.stringify({ mcpServers: { s: { command: 'c' } } }, null, 2) + '\n') + await mkdir(join(fx.home, '.claude', 'skills', 'ghost'), { recursive: true }) + await writeFile(join(fx.home, '.claude', 'skills', 'ghost', 'SKILL.md'), 'x') + await writeFile(join(fx.project, 'CLAUDE.md'), '# rules\n') + + const findings: WasteFinding[] = [ + makeFinding('mcp-low-coverage', CMD_FIX, { kind: 'mcp-remove', servers: ['s'] }), + makeFinding('unused-skills', CMD_FIX, { kind: 'archive', names: ['ghost'] }), + makeFinding('read-edit-ratio', { type: 'paste', destination: 'claude-md', label: '', text: 'rule' }), + makeFinding('bash-output-cap', { type: 'paste', destination: 'shell-config', label: '', text: 'export BASH_MAX_OUTPUT_LENGTH=15000' }), + ] + + const before = await hashTree(fx.root) + const plans = planFindings(findings, { homeDir: fx.home, cwd: fx.project, shell: '/bin/zsh' }) + // Exercise the exact rendering the dry-run path prints. + renderApplyList(plans.filter(p => p.plan !== null), plans.filter(p => p.plan === null), 0.000002) + const after = await hashTree(fx.root) + + expect(plans.every(p => p.plan !== null)).toBe(true) + expect(after).toBe(before) + }) +}) + +describe('finding-id regression guard', () => { + const KEBAB = /^[a-z0-9]+(-[a-z0-9]+)*$/ + const KNOWN: ReadonlySet<FindingId> = new Set<FindingId>([ + 'read-edit-ratio', 'build-folder-reads', 'redundant-rereads', 'warmup-heavy', + 'unused-mcp', 'mcp-low-coverage', 'mcp-project-scope', 'retry-heavy-capabilities', + 'low-worth-sessions', 'context-heavy-sessions', 'cost-outliers', 'claude-md-too-long', + 'bash-output-cap', 'unused-agents', 'unused-skills', 'unused-commands', + ]) + + it('every finding produced by a detector run carries a stable, known, non-empty id', async () => { + const fx = await makeFixture() + const bigClaudeMd = '# Rules\n' + Array.from({ length: 260 }, (_, i) => `- rule ${i}`).join('\n') + '\n' + await writeFile(join(fx.project, 'CLAUDE.md'), bigClaudeMd) + + function read(file: string, session = 's1'): ToolCall { + return { name: 'Read', input: { file_path: file }, sessionId: session, project: 'p' } + } + const calls: ToolCall[] = [ + read('/p/node_modules/a.js'), read('/p/node_modules/b.js'), read('/p/dist/c.js'), + ...Array.from({ length: 6 }, () => read('/p/src/app.ts')), + ...Array.from({ length: 10 }, (): ToolCall => ({ name: 'Edit', input: {}, sessionId: 's1', project: 'p' })), + ] + const coverage: McpServerCoverage[] = [{ + server: 'x', toolsAvailable: 20, toolsInvoked: 1, + unusedTools: Array.from({ length: 19 }, (_, i) => `mcp__x__t${i}`), + invocations: 1, loadedSessions: 3, coverageRatio: 0.05, + }] + + const findings = [ + detectLowReadEditRatio(calls), + detectJunkReads(calls), + detectDuplicateReads(calls), + detectBloatedClaudeMd(new Set([fx.project])), + detectMcpToolCoverage([], coverage), + ].filter((f): f is WasteFinding => f !== null) + + expect(findings.length).toBeGreaterThanOrEqual(5) + for (const f of findings) { + expect(f.id).toBeTruthy() + expect(f.id).toMatch(KEBAB) + expect(KNOWN.has(f.id)).toBe(true) + } + const ids = findings.map(f => f.id) + expect(new Set(ids).size).toBe(ids.length) + }) +}) + +describe('unused-mcp plan', () => { + it('builds a remove-everywhere plan, including other projects[*] entries', async () => { + const fx = await makeFixture() + const claudeJson = join(fx.home, '.claude.json') + await writeFile(claudeJson, JSON.stringify({ + mcpServers: { u: { command: 'u' } }, + projects: { '/some/other': { mcpServers: { u: { command: 'u' }, keepme: {} } } }, + }, null, 2) + '\n') + + const finding = makeFinding('unused-mcp', CMD_FIX, { kind: 'mcp-remove', servers: ['u'] }) + const plan = planFor(finding, { homeDir: fx.home, cwd: fx.project }) + expect(plan).not.toBeNull() + expect(plan!.kind).toBe('mcp-remove') + + await runAction(plan!, fx.actionsDir) + const after = JSON.parse(await readFile(claudeJson, 'utf-8')) + expect(after.mcpServers).toEqual({}) + expect(after.projects['/some/other'].mcpServers).toEqual({ keepme: {} }) + }) +}) + +describe('BOM handling', () => { + it('parses a config file with a UTF-8 BOM', async () => { + const fx = await makeFixture() + const claudeJson = join(fx.home, '.claude.json') + await writeFile(claudeJson, '' + JSON.stringify({ mcpServers: { b: {} }, keep: 1 }, null, 2) + '\n') + + const { plan, notes } = planFindings( + [makeFinding('mcp-low-coverage', CMD_FIX, { kind: 'mcp-remove', servers: ['b'] })], + { homeDir: fx.home, cwd: fx.project }, + )[0]! + expect(notes).toEqual([]) + expect(plan).not.toBeNull() + const written = JSON.parse(String(plan!.changes[0]!.content)) + expect(written).toEqual({ mcpServers: {}, keep: 1 }) + }) +}) + +// --------------------------------------------------------------------------- +// runOptimizeApply end-to-end (injected stdio, crafted findings, fixture home) +// --------------------------------------------------------------------------- + +const ANSI = /\[[0-9;]*m/g + +type Io = { + input: PassThrough + output: Writable + errorOutput: Writable + stdout(): string + stderr(): string +} + +function makeIo(answer?: string): Io { + const input = new PassThrough() + input.end(answer ?? '') + const outChunks: Buffer[] = [] + const errChunks: Buffer[] = [] + const output = new Writable({ write(c, _e, cb) { outChunks.push(Buffer.from(c)); cb() } }) + const errorOutput = new Writable({ write(c, _e, cb) { errChunks.push(Buffer.from(c)); cb() } }) + return { + input, + output, + errorOutput, + stdout: () => Buffer.concat(outChunks).toString('utf-8').replace(ANSI, ''), + stderr: () => Buffer.concat(errChunks).toString('utf-8').replace(ANSI, ''), + } +} + +function applyOpts(fx: Fixture, io: Io, extra: Partial<ApplyOptions> & { findings: WasteFinding[] }): ApplyOptions { + const ctx: PlanContext = { homeDir: fx.home, cwd: fx.project, shell: '/bin/zsh' } + return { + ctx, + actionsDir: fx.actionsDir, + input: io.input, + output: io.output, + errorOutput: io.errorOutput, + ...extra, + } +} + +// One mcp server, one skill, one shell cap: three appliable findings in a +// stable 1/2/3 order for the picker tests. +async function threeFindingFixture(): Promise<{ fx: Fixture; findings: WasteFinding[] }> { + const fx = await makeFixture() + await writeFile(join(fx.home, '.claude.json'), JSON.stringify({ mcpServers: { a: { command: 'a' } } }, null, 2) + '\n') + await mkdir(join(fx.home, '.claude', 'skills', 'foo'), { recursive: true }) + await writeFile(join(fx.home, '.claude', 'skills', 'foo', 'SKILL.md'), 'x') + const findings: WasteFinding[] = [ + makeFinding('mcp-low-coverage', CMD_FIX, { kind: 'mcp-remove', servers: ['a'] }), + makeFinding('unused-skills', CMD_FIX, { kind: 'archive', names: ['foo'] }), + makeFinding('bash-output-cap', { type: 'paste', destination: 'shell-config', label: '', text: 'export BASH_MAX_OUTPUT_LENGTH=15000' }), + ] + return { fx, findings } +} + +describe('runOptimizeApply end-to-end', () => { + it('--yes applies every plan and prints journal short ids with the undo hint', async () => { + const { fx, findings } = await threeFindingFixture() + const io = makeIo() + await runOptimizeApply([], undefined, applyOpts(fx, io, { findings, yes: true })) + + const records = await readRecords(fx.actionsDir) + expect(records).toHaveLength(3) + const out = io.stdout() + for (const rec of records) { + expect(out).toContain(`Applied ${shortId(rec.id)}`) + expect(out).toContain(`Undo anytime: codeburn act undo ${shortId(rec.id)}`) + } + expect(JSON.parse(await readFile(join(fx.home, '.claude.json'), 'utf-8')).mcpServers).toEqual({}) + expect(existsSync(join(fx.home, '.claude', 'skills', '.archived', 'foo'))).toBe(true) + expect(existsSync(join(fx.home, '.zshrc'))).toBe(true) + }) + + it('interactive pick "2" applies only the second plan', async () => { + const { fx, findings } = await threeFindingFixture() + const io = makeIo('2\n') + await runOptimizeApply([], undefined, applyOpts(fx, io, { findings })) + + const records = await readRecords(fx.actionsDir) + expect(records).toHaveLength(1) + expect(records[0]!.kind).toBe('archive-skill') + expect(JSON.parse(await readFile(join(fx.home, '.claude.json'), 'utf-8')).mcpServers).toEqual({ a: { command: 'a' } }) + expect(existsSync(join(fx.home, '.zshrc'))).toBe(false) + }) + + it('interactive pick "1,3" applies the first and third plans', async () => { + const { fx, findings } = await threeFindingFixture() + const io = makeIo('1,3\n') + await runOptimizeApply([], undefined, applyOpts(fx, io, { findings })) + + const records = await readRecords(fx.actionsDir) + expect(records.map(r => r.kind).sort()).toEqual(['mcp-remove', 'shell-config']) + expect(existsSync(join(fx.home, '.claude', 'skills', 'foo'))).toBe(true) + }) + + it('a garbage answer applies nothing and prints the empty outcome', async () => { + const { fx, findings } = await threeFindingFixture() + const io = makeIo('wat\n') + await runOptimizeApply([], undefined, applyOpts(fx, io, { findings })) + + expect(await readRecords(fx.actionsDir)).toHaveLength(0) + expect(io.stdout()).toContain('Nothing applied.') + }) + + it('EOF at the prompt prints "Nothing applied." and leaves the exit code untouched', async () => { + const { fx, findings } = await threeFindingFixture() + const io = makeIo() + const prevExit = process.exitCode + await runOptimizeApply([], undefined, applyOpts(fx, io, { findings })) + + expect(process.exitCode).toBe(prevExit) + expect(io.stdout()).toContain('Nothing applied.') + expect(await readRecords(fx.actionsDir)).toHaveLength(0) + }) + + it('--only restricts the applied set', async () => { + const { fx, findings } = await threeFindingFixture() + const io = makeIo() + await runOptimizeApply([], undefined, applyOpts(fx, io, { findings, yes: true, only: 'unused-skills' })) + + const records = await readRecords(fx.actionsDir) + expect(records).toHaveLength(1) + expect(records[0]!.kind).toBe('archive-skill') + expect(JSON.parse(await readFile(join(fx.home, '.claude.json'), 'utf-8')).mcpServers).toEqual({ a: { command: 'a' } }) + }) + + it('--only with an unknown or not-appliable id errors with the valid ids and exit code 2', async () => { + const { fx, findings } = await threeFindingFixture() + const io = makeIo() + const prevExit = process.exitCode + try { + await runOptimizeApply([], undefined, applyOpts(fx, io, { findings, yes: true, only: 'read-edit-ratio' })) + + expect(process.exitCode).toBe(2) + const err = io.stderr() + expect(err).toContain('read-edit-ratio') + expect(err).toContain('Appliable ids for this run:') + expect(err).toContain('mcp-low-coverage') + expect(await readRecords(fx.actionsDir)).toHaveLength(0) + expect(io.stdout()).not.toContain('No appliable config-class fixes') + } finally { + process.exitCode = prevExit + } + }) + + it('--yes skips claude-md plans with a reason unless explicitly selected via --only', async () => { + const { fx, findings } = await threeFindingFixture() + const claudeMdFinding = makeFinding('read-edit-ratio', { type: 'paste', destination: 'claude-md', label: '', text: 'Read first.' }) + const io = makeIo() + await runOptimizeApply([], undefined, applyOpts(fx, io, { findings: [claudeMdFinding, ...findings], yes: true })) + + expect(io.stdout()).toContain('Skipped read-edit-ratio: CLAUDE.md edits are not applied with --yes') + expect(existsSync(join(fx.project, 'CLAUDE.md'))).toBe(false) + expect((await readRecords(fx.actionsDir)).map(r => r.kind)).not.toContain('claude-md-rule') + + const fx2 = await makeFixture() + const io2 = makeIo() + await runOptimizeApply([], undefined, applyOpts(fx2, io2, { findings: [claudeMdFinding], yes: true, only: 'read-edit-ratio' })) + + expect((await readRecords(fx2.actionsDir)).map(r => r.kind)).toEqual(['claude-md-rule']) + expect(await readFile(join(fx2.project, 'CLAUDE.md'), 'utf-8')).toContain('') + }) + + it('project-scope leaves unrelated projects[*] entries untouched and previews the cold removals', async () => { + const fx = await makeFixture() + const claudeJson = join(fx.home, '.claude.json') + const serverValue = { command: 'srv' } + await writeFile(claudeJson, JSON.stringify({ + mcpServers: { srv: serverValue }, + projects: { + '/cold/one': { mcpServers: { srv: serverValue } }, + '/unrelated/proj': { mcpServers: { srv: serverValue, keepme: {} } }, + }, + }, null, 2) + '\n') + const keeper = join(fx.root, 'keeper') + await mkdir(keeper, { recursive: true }) + + const finding = makeFinding('mcp-project-scope', CMD_FIX, { + kind: 'mcp-project-scope', + servers: [{ server: 'srv', keepProjects: [keeper], removeProjects: ['/cold/one'] }], + }) + const io = makeIo() + await runOptimizeApply([], undefined, applyOpts(fx, io, { findings: [finding], yes: true })) + + expect(io.stdout()).toContain('(removes srv from 1 project entry: /cold/one)') + + const after = JSON.parse(await readFile(claudeJson, 'utf-8')) + expect(after.mcpServers).toEqual({}) + expect(after.projects['/cold/one'].mcpServers).toEqual({}) + expect(after.projects['/unrelated/proj'].mcpServers).toEqual({ srv: serverValue, keepme: {} }) + expect(JSON.parse(await readFile(join(keeper, '.mcp.json'), 'utf-8')).mcpServers).toEqual({ srv: serverValue }) + }) + + it('surfaces parse-error notes when every plan resolves to null', async () => { + const fx = await makeFixture() + await writeFile(join(fx.home, '.claude.json'), 'not json{{{') + const finding = makeFinding('mcp-low-coverage', CMD_FIX, { kind: 'mcp-remove', servers: ['ghost'] }) + const io = makeIo() + await runOptimizeApply([], undefined, applyOpts(fx, io, { findings: [finding], yes: true })) + + const out = io.stdout() + expect(out).toContain('No appliable config-class fixes') + expect(out).toContain('could not parse') + expect(out).toContain('.claude.json') + expect(await readRecords(fx.actionsDir)).toHaveLength(0) + }) + + it('renders notes under manual findings alongside appliable ones', async () => { + const fx = await makeFixture() + await writeFile(join(fx.home, '.claude.json'), 'not json{{{') + await mkdir(join(fx.home, '.claude', 'skills', 'foo'), { recursive: true }) + await writeFile(join(fx.home, '.claude', 'skills', 'foo', 'SKILL.md'), 'x') + const findings: WasteFinding[] = [ + makeFinding('mcp-low-coverage', CMD_FIX, { kind: 'mcp-remove', servers: ['ghost'] }), + makeFinding('unused-skills', CMD_FIX, { kind: 'archive', names: ['foo'] }), + ] + const io = makeIo() + await runOptimizeApply([], undefined, applyOpts(fx, io, { findings, dryRun: true })) + + const out = io.stdout() + expect(out).toContain('[mcp-low-coverage] manual') + expect(out).toContain('could not parse') + }) +}) + +describe('stale-plan detection', () => { + it('rejects when the target changed after the plan was built, leaving nothing behind', async () => { + const fx = await makeFixture() + const claudeJson = join(fx.home, '.claude.json') + await writeFile(claudeJson, JSON.stringify({ mcpServers: { s: {} } }, null, 2) + '\n') + const plan = planFor( + makeFinding('mcp-low-coverage', CMD_FIX, { kind: 'mcp-remove', servers: ['s'] }), + { homeDir: fx.home, cwd: fx.project }, + ) + expect(plan).not.toBeNull() + + const interim = JSON.stringify({ mcpServers: { s: {}, addedMeanwhile: {} } }, null, 2) + '\n' + await writeFile(claudeJson, interim) + + await expect(runAction(plan!, fx.actionsDir)).rejects.toThrow(/changed since the plan was built; re-run codeburn optimize --apply/) + expect(await readFile(claudeJson, 'utf-8')).toBe(interim) + expect(await readRecords(fx.actionsDir)).toHaveLength(0) + const backups = await readdir(join(fx.actionsDir, 'backups')).catch(() => []) + expect(backups).toEqual([]) + }) + + it('rejects a plan expecting an absent file when the file appeared', async () => { + const fx = await makeFixture() + const claudeMd = join(fx.project, 'CLAUDE.md') + const plan = planFor( + makeFinding('read-edit-ratio', { type: 'paste', destination: 'claude-md', label: '', text: 'rule' }), + { homeDir: fx.home, cwd: fx.project }, + ) + expect(plan!.changes[0]).toMatchObject({ op: 'create', expectedHash: null }) + + await writeFile(claudeMd, '# appeared meanwhile\n') + + await expect(runAction(plan!, fx.actionsDir)).rejects.toThrow(/changed since the plan was built/) + expect(await readFile(claudeMd, 'utf-8')).toBe('# appeared meanwhile\n') + expect(await readRecords(fx.actionsDir)).toHaveLength(0) + }) + + it('applies when the target still matches the expected hash', async () => { + const fx = await makeFixture() + const claudeJson = join(fx.home, '.claude.json') + await writeFile(claudeJson, JSON.stringify({ mcpServers: { s: {} } }, null, 2) + '\n') + const plan = planFor( + makeFinding('mcp-low-coverage', CMD_FIX, { kind: 'mcp-remove', servers: ['s'] }), + { homeDir: fx.home, cwd: fx.project }, + ) + expect(plan!.changes[0]!.op === 'move' ? undefined : plan!.changes[0]!.expectedHash).toMatch(/^[0-9a-f]{64}$/) + + const rec = await runAction(plan!, fx.actionsDir) + expect(rec.status).toBe('applied') + expect(JSON.parse(await readFile(claudeJson, 'utf-8')).mcpServers).toEqual({}) + }) + + it('a change without expectedHash skips validation (framework back-compat)', async () => { + const fx = await makeFixture() + const p = join(fx.home, 'free.txt') + await writeFile(p, 'anything at all') + + const rec = await runAction({ + kind: 'claude-md-rule', + description: 'no expected hash', + changes: [{ op: 'edit', path: p, content: 'overwritten' }], + }, fx.actionsDir) + expect(rec.status).toBe('applied') + expect(await readFile(p, 'utf-8')).toBe('overwritten') + }) +}) diff --git a/tests/optimize-fs.test.ts b/tests/optimize-fs.test.ts new file mode 100644 index 0000000..2364e08 --- /dev/null +++ b/tests/optimize-fs.test.ts @@ -0,0 +1,425 @@ +import { describe, it, expect, afterAll, beforeEach, vi } from 'vitest' +import { mkdtempSync, rmSync, mkdirSync, writeFileSync, utimesSync } from 'fs' +import { tmpdir } from 'os' +import { join } from 'path' +import * as fsUtils from '../src/fs-utils.js' + +vi.mock('os', async () => { + const actual = await vi.importActual<typeof import('os')>('os') + const fs = await vi.importActual<typeof import('fs')>('fs') + const fakeHome = fs.mkdtempSync(actual.tmpdir() + '/codeburn-home-') + fs.mkdirSync(fakeHome + '/.claude', { recursive: true }) + process.env['CODEBURN_TEST_FAKE_HOME'] = fakeHome + return { ...actual, homedir: () => fakeHome } +}) + +const FAKE_HOME_FOR_MOCK = process.env['CODEBURN_TEST_FAKE_HOME']! + +import { + detectBloatedClaudeMd, + detectUnusedMcp, + detectBashBloat, + detectGhostCommands, + loadMcpConfigs, + scanJsonlFile, + scanAndDetect, + type ToolCall, +} from '../src/optimize.js' +import { + estimateContextBudget, + discoverProjectCwd, +} from '../src/context-budget.js' + +// ============================================================================ +// Helpers for filesystem fixtures +// ============================================================================ + +const FIXTURE_ROOTS: string[] = [FAKE_HOME_FOR_MOCK] + +function makeFixtureRoot(): string { + const dir = mkdtempSync(join(tmpdir(), 'codeburn-test-')) + FIXTURE_ROOTS.push(dir) + return dir +} + +function writeFile(path: string, content: string): void { + mkdirSync(join(path, '..'), { recursive: true }) + writeFileSync(path, content) +} + +function touchOld(path: string, daysAgo: number): void { + const past = new Date(Date.now() - daysAgo * 24 * 60 * 60 * 1000) + utimesSync(path, past, past) +} + +afterAll(() => { + for (const dir of FIXTURE_ROOTS) { + rmSync(dir, { recursive: true, force: true }) + } +}) + +// ============================================================================ +// detectBloatedClaudeMd (including @-import expansion) +// ============================================================================ + +describe('detectBloatedClaudeMd', () => { + it('flags a CLAUDE.md with more than 200 lines', () => { + const root = makeFixtureRoot() + const projectDir = join(root, 'myapp') + mkdirSync(projectDir, { recursive: true }) + const content = Array.from({ length: 300 }, (_, i) => `line ${i}`).join('\n') + writeFile(join(projectDir, 'CLAUDE.md'), content) + const finding = detectBloatedClaudeMd(new Set([projectDir])) + expect(finding).not.toBeNull() + }) + + it('expands @-imports and counts transitive load', () => { + const root = makeFixtureRoot() + const projectDir = join(root, 'myapp') + mkdirSync(projectDir, { recursive: true }) + writeFile( + join(projectDir, 'CLAUDE.md'), + 'line 1\nline 2\n@./rules.md\n@./conventions.md\n', + ) + writeFile(join(projectDir, 'rules.md'), Array.from({ length: 120 }, (_, i) => `rule ${i}`).join('\n')) + writeFile(join(projectDir, 'conventions.md'), Array.from({ length: 120 }, (_, i) => `conv ${i}`).join('\n')) + const finding = detectBloatedClaudeMd(new Set([projectDir])) + expect(finding).not.toBeNull() + expect(finding!.explanation).toContain('2 @-imports') + }) + + it('does not flag a lean CLAUDE.md under 200 lines with no imports', () => { + const root = makeFixtureRoot() + const projectDir = join(root, 'myapp') + mkdirSync(projectDir, { recursive: true }) + writeFile(join(projectDir, 'CLAUDE.md'), 'just a few\nlines\nhere\n') + expect(detectBloatedClaudeMd(new Set([projectDir]))).toBeNull() + }) + + it('does not recurse infinitely on circular @-imports', () => { + const root = makeFixtureRoot() + const projectDir = join(root, 'myapp') + mkdirSync(projectDir, { recursive: true }) + writeFile(join(projectDir, 'CLAUDE.md'), '@./a.md\n') + writeFile(join(projectDir, 'a.md'), '@./b.md\n') + writeFile(join(projectDir, 'b.md'), '@./a.md\n') + expect(() => detectBloatedClaudeMd(new Set([projectDir]))).not.toThrow() + }) + + it('ignores @ tokens that are not paths (emails, npm scopes)', () => { + const root = makeFixtureRoot() + const projectDir = join(root, 'myapp') + mkdirSync(projectDir, { recursive: true }) + writeFile( + join(projectDir, 'CLAUDE.md'), + Array.from({ length: 250 }, (_, i) => + i === 10 ? '@user@example.com' : + i === 20 ? '@org/package' : + `line ${i}` + ).join('\n'), + ) + const finding = detectBloatedClaudeMd(new Set([projectDir])) + expect(finding).not.toBeNull() + // "with N @-imports" suffix appears only when non-zero imports were resolved + expect(finding!.explanation).not.toMatch(/with \d+ @-import/) + }) +}) + +// ============================================================================ +// loadMcpConfigs + detectUnusedMcp +// ============================================================================ + +describe('loadMcpConfigs', () => { + it('returns empty map when no configs exist', () => { + const root = makeFixtureRoot() + const servers = loadMcpConfigs([root]) + expect(servers.size).toBe(0) + }) + + it('reads servers from project .mcp.json', () => { + const root = makeFixtureRoot() + const projectDir = join(root, 'myapp') + mkdirSync(projectDir, { recursive: true }) + writeFile(join(projectDir, '.mcp.json'), JSON.stringify({ + mcpServers: { foo: { command: 'foo' }, bar: { command: 'bar' } }, + })) + const servers = loadMcpConfigs([projectDir]) + expect(servers.has('foo')).toBe(true) + expect(servers.has('bar')).toBe(true) + }) + + it('normalizes server names by replacing colons with underscores', () => { + const root = makeFixtureRoot() + const projectDir = join(root, 'myapp') + mkdirSync(projectDir, { recursive: true }) + writeFile(join(projectDir, '.mcp.json'), JSON.stringify({ + mcpServers: { 'plugin:context7:context7': { command: 'ctx' } }, + })) + const servers = loadMcpConfigs([projectDir]) + expect(servers.has('plugin_context7_context7')).toBe(true) + expect(servers.get('plugin_context7_context7')!.original).toBe('plugin:context7:context7') + }) + + it('handles malformed JSON without crashing', () => { + const root = makeFixtureRoot() + const projectDir = join(root, 'myapp') + mkdirSync(projectDir, { recursive: true }) + writeFile(join(projectDir, '.mcp.json'), '{ not valid json') + expect(() => loadMcpConfigs([projectDir])).not.toThrow() + expect(loadMcpConfigs([projectDir]).size).toBe(0) + }) +}) + +describe('detectUnusedMcp', () => { + it('flags servers configured but never called', () => { + const root = makeFixtureRoot() + const projectDir = join(root, 'myapp') + mkdirSync(projectDir, { recursive: true }) + writeFile(join(projectDir, '.mcp.json'), JSON.stringify({ + mcpServers: { ghost: { command: 'x' } }, + })) + const configFile = join(projectDir, '.mcp.json') + touchOld(configFile, 30) + const finding = detectUnusedMcp([], [], new Set([projectDir])) + expect(finding).not.toBeNull() + expect(finding!.explanation).toContain('ghost') + }) + + it('does not flag servers configured within 24 hours', () => { + const root = makeFixtureRoot() + const projectDir = join(root, 'myapp') + mkdirSync(projectDir, { recursive: true }) + writeFile(join(projectDir, '.mcp.json'), JSON.stringify({ + mcpServers: { freshly_added: { command: 'x' } }, + })) + expect(detectUnusedMcp([], [], new Set([projectDir]))).toBeNull() + }) + + it('does not flag servers that were called', () => { + const root = makeFixtureRoot() + const projectDir = join(root, 'myapp') + mkdirSync(projectDir, { recursive: true }) + writeFile(join(projectDir, '.mcp.json'), JSON.stringify({ + mcpServers: { used: { command: 'x' } }, + })) + touchOld(join(projectDir, '.mcp.json'), 30) + const calls: ToolCall[] = [ + { name: 'mcp__used__some_tool', input: {}, sessionId: 's1', project: 'p1' }, + ] + expect(detectUnusedMcp(calls, [], new Set([projectDir]))).toBeNull() + }) +}) + +// ============================================================================ +// detectBashBloat +// ============================================================================ + +describe('detectBashBloat', () => { + it('flags when env var is unset (uses default 30K)', () => { + const finding = detectBashBloat() + expect(finding).not.toBeNull() + expect(finding!.impact).toBe('medium') + }) + + it('does not flag when env var is at recommended 15K', () => { + process.env['BASH_MAX_OUTPUT_LENGTH'] = '15000' + expect(detectBashBloat()).toBeNull() + }) + + it('does not flag when env var is below recommended', () => { + process.env['BASH_MAX_OUTPUT_LENGTH'] = '10000' + expect(detectBashBloat()).toBeNull() + }) + + it('flags when env var is above 15K', () => { + process.env['BASH_MAX_OUTPUT_LENGTH'] = '50000' + const finding = detectBashBloat() + expect(finding).not.toBeNull() + }) +}) + +// ============================================================================ +// detectGhostCommands (the pure-function ghost detector) +// ============================================================================ + +describe('detectGhostCommands', () => { + it('returns null when no commands are defined', async () => { + expect(await detectGhostCommands([])).toBeNull() + }) + + it('does not match /tmp or /usr or other path prefixes as command usage', async () => { + const messages = [ + 'check /tmp/debug.log', + 'look at /usr/local/bin', + 'rm -rf /var/cache', + ] + expect(await detectGhostCommands(messages)).toBeNull() + }) + + it('matches <command-name> tags in user messages', async () => { + const messages = ['<command-name>review</command-name>'] + expect(await detectGhostCommands(messages)).toBeNull() + }) +}) + +// ============================================================================ +// scanJsonlFile +// ============================================================================ + +describe('scanJsonlFile', () => { + it('returns empty result for nonexistent file', async () => { + const result = await scanJsonlFile('/nonexistent/path.jsonl', 'p1', undefined) + expect(result.calls).toEqual([]) + expect(result.cwds).toEqual([]) + expect(result.apiCalls).toEqual([]) + expect(result.userMessages).toEqual([]) + }) + + it('parses tool_use blocks from assistant entries', async () => { + const root = makeFixtureRoot() + const filePath = join(root, 'session.jsonl') + const now = new Date().toISOString() + const lines = [ + JSON.stringify({ + type: 'assistant', + timestamp: now, + message: { + content: [{ type: 'tool_use', name: 'Read', input: { file_path: '/x/foo.ts' } }], + }, + }), + ] + writeFile(filePath, lines.join('\n')) + const result = await scanJsonlFile(filePath, 'p1', undefined) + expect(result.calls).toHaveLength(1) + expect(result.calls[0].name).toBe('Read') + }) + + it('skips malformed JSONL lines without crashing', async () => { + const root = makeFixtureRoot() + const filePath = join(root, 'session.jsonl') + writeFile(filePath, 'this is not json\n{broken\n{"type":"assistant","message":{"content":[]}}\n') + const result = await scanJsonlFile(filePath, 'p1', undefined) + expect(result.calls).toEqual([]) + }) + + it('uses readSessionLines (streaming) rather than readSessionFile (full-string load)', async () => { + const readSessionLinesSpy = vi.spyOn(fsUtils, 'readSessionLines') + const readSessionFileSpy = vi.spyOn(fsUtils, 'readSessionFile') + const root = makeFixtureRoot() + const filePath = join(root, 'session.jsonl') + const now = new Date().toISOString() + writeFile(filePath, JSON.stringify({ + type: 'assistant', timestamp: now, + message: { content: [{ type: 'tool_use', name: 'Bash', input: {} }] }, + })) + await scanJsonlFile(filePath, 'p1', undefined) + expect(readSessionLinesSpy).toHaveBeenCalledWith(filePath, undefined, { largeLineAsBuffer: true }) + expect(readSessionFileSpy).not.toHaveBeenCalled() + readSessionLinesSpy.mockRestore() + readSessionFileSpy.mockRestore() + }) + + it('processes all entries in a large multi-line file without truncation', async () => { + const root = makeFixtureRoot() + const filePath = join(root, 'session.jsonl') + const now = new Date().toISOString() + const ENTRY_COUNT = 500 + const lines = Array.from({ length: ENTRY_COUNT }, (_, i) => + JSON.stringify({ + type: 'assistant', + timestamp: now, + message: { content: [{ type: 'tool_use', name: 'Read', input: { file_path: `/file-${i}.ts` } }] }, + }), + ) + writeFile(filePath, lines.join('\n')) + const result = await scanJsonlFile(filePath, 'p1', undefined) + expect(result.calls).toHaveLength(ENTRY_COUNT) + }) + + it('respects date-range filter for assistant entries', async () => { + const root = makeFixtureRoot() + const filePath = join(root, 'session.jsonl') + const old = '2020-01-01T00:00:00Z' + const now = new Date().toISOString() + writeFile(filePath, [ + JSON.stringify({ + type: 'assistant', timestamp: old, + message: { content: [{ type: 'tool_use', name: 'Read', input: { file_path: '/old' } }] }, + }), + JSON.stringify({ + type: 'assistant', timestamp: now, + message: { content: [{ type: 'tool_use', name: 'Read', input: { file_path: '/new' } }] }, + }), + ].join('\n')) + const today = new Date() + const start = new Date(today.getFullYear(), today.getMonth(), today.getDate()) + const result = await scanJsonlFile(filePath, 'p1', { start, end: today }) + expect(result.calls).toHaveLength(1) + expect((result.calls[0].input as Record<string, unknown>).file_path).toBe('/new') + }) +}) + +// ============================================================================ +// scanAndDetect (top-level integration) +// ============================================================================ + +describe('scanAndDetect', () => { + it('returns healthy result for empty projects', async () => { + const result = await scanAndDetect([]) + expect(result.findings).toEqual([]) + expect(result.healthScore).toBe(100) + expect(result.healthGrade).toBe('A') + expect(result.costRate).toBe(0) + }) +}) + +// ============================================================================ +// context-budget +// ============================================================================ + +describe('estimateContextBudget', () => { + it('returns only system base when project has no config', async () => { + const root = makeFixtureRoot() + const budget = await estimateContextBudget(root) + expect(budget.total).toBeGreaterThan(0) + expect(budget.mcpTools.count).toBe(0) + expect(budget.skills.count).toBe(0) + }) + + it('includes MCP tools from project .mcp.json', async () => { + const root = makeFixtureRoot() + writeFile(join(root, '.mcp.json'), JSON.stringify({ + mcpServers: { a: { command: 'x' }, b: { command: 'x' } }, + })) + const budget = await estimateContextBudget(root) + expect(budget.mcpTools.count).toBeGreaterThan(0) + }) + + it('includes memory file tokens from CLAUDE.md', async () => { + const root = makeFixtureRoot() + writeFile(join(root, 'CLAUDE.md'), 'Project context for Claude.\n') + const budget = await estimateContextBudget(root) + expect(budget.memory.count).toBeGreaterThan(0) + expect(budget.memory.tokens).toBeGreaterThan(0) + }) +}) + +describe('discoverProjectCwd', () => { + it('returns null for empty directory', async () => { + const root = makeFixtureRoot() + expect(await discoverProjectCwd(root)).toBeNull() + }) + + it('returns null for directory with no jsonl files', async () => { + const root = makeFixtureRoot() + writeFile(join(root, 'readme.txt'), 'hi') + expect(await discoverProjectCwd(root)).toBeNull() + }) + + it('extracts cwd from the first jsonl entry', async () => { + const root = makeFixtureRoot() + const entry = JSON.stringify({ type: 'assistant', cwd: '/Users/test/project', timestamp: new Date().toISOString() }) + writeFile(join(root, 'session.jsonl'), entry + '\n') + expect(await discoverProjectCwd(root)).toBe('/Users/test/project') + }) +}) diff --git a/tests/optimize.test.ts b/tests/optimize.test.ts new file mode 100644 index 0000000..352cf3c --- /dev/null +++ b/tests/optimize.test.ts @@ -0,0 +1,1184 @@ +import { describe, it, expect } from 'vitest' + +import { + detectJunkReads, + detectDuplicateReads, + detectLowReadEditRatio, + detectCacheBloat, + detectBloatedClaudeMd, + detectContextBloat, + detectCapabilityReliability, + detectLowWorthSessions, + detectSessionOutliers, + computeHealth, + computeTrend, + buildOptimizeJsonReport, + type ToolCall, + type ApiCallMeta, + type WasteFinding, + type OptimizeResult, +} from '../src/optimize.js' +import type { ProjectSummary } from '../src/types.js' + +function call(name: string, input: Record<string, unknown>, sessionId = 's1', project = 'p1'): ToolCall { + return { name, input, sessionId, project } +} + +function emptyProjects(): ProjectSummary[] { + return [] +} + +function projectWithSessions(costs: number[], project = 'app'): ProjectSummary { + const sessions = costs.map((cost, i) => { + const tokens = Math.round(cost * 1000) + return { + sessionId: `s${i + 1}`, + project, + firstTimestamp: `2026-05-${String(i + 1).padStart(2, '0')}T10:00:00Z`, + lastTimestamp: `2026-05-${String(i + 1).padStart(2, '0')}T10:30:00Z`, + totalCostUSD: cost, + totalInputTokens: tokens, + totalOutputTokens: tokens, + totalCacheReadTokens: 0, + totalCacheWriteTokens: 0, + apiCalls: 1, + turns: [], + modelBreakdown: {}, + toolBreakdown: {}, + mcpBreakdown: {}, + bashBreakdown: {}, + categoryBreakdown: {} as ProjectSummary['sessions'][number]['categoryBreakdown'], + skillBreakdown: {}, + } + }) + + return { + project, + projectPath: `/tmp/${project}`, + sessions, + totalCostUSD: costs.reduce((sum, cost) => sum + cost, 0), + totalApiCalls: sessions.length, + } +} + +type TestSession = ProjectSummary['sessions'][number] + +function contextSession( + i: number, + overrides: Partial<TestSession>, + project = 'app', +): TestSession { + return { + sessionId: `s${i + 1}`, + project, + firstTimestamp: `2026-05-${String(i + 1).padStart(2, '0')}T10:00:00Z`, + lastTimestamp: `2026-05-${String(i + 1).padStart(2, '0')}T10:30:00Z`, + totalCostUSD: 1, + totalInputTokens: 0, + totalOutputTokens: 0, + totalCacheReadTokens: 0, + totalCacheWriteTokens: 0, + apiCalls: 1, + turns: [], + modelBreakdown: {}, + toolBreakdown: {}, + mcpBreakdown: {}, + bashBreakdown: {}, + categoryBreakdown: {} as TestSession['categoryBreakdown'], + skillBreakdown: {}, + ...overrides, + } +} + +function projectWithContextSessions(sessions: TestSession[], project = 'app'): ProjectSummary { + return { + project, + projectPath: `/tmp/${project}`, + sessions, + totalCostUSD: sessions.reduce((sum, session) => sum + session.totalCostUSD, 0), + totalApiCalls: sessions.reduce((sum, session) => sum + session.apiCalls, 0), + } +} + +describe('detectJunkReads', () => { + it('returns null below minimum threshold', () => { + const calls = [ + call('Read', { file_path: '/x/node_modules/a.js' }), + call('Read', { file_path: '/x/node_modules/b.js' }), + ] + expect(detectJunkReads(calls)).toBeNull() + }) + + it('flags when threshold is met', () => { + const calls = [ + call('Read', { file_path: '/x/node_modules/a.js' }), + call('Read', { file_path: '/x/node_modules/b.js' }), + call('Read', { file_path: '/x/.git/config' }), + ] + const finding = detectJunkReads(calls) + expect(finding).not.toBeNull() + expect(finding!.impact).toBe('low') + }) + + it('scales impact with read count', () => { + const make = (n: number) => Array.from({ length: n }, (_, i) => + call('Read', { file_path: `/x/node_modules/file-${i}.js` }) + ) + expect(detectJunkReads(make(25))!.impact).toBe('high') + expect(detectJunkReads(make(10))!.impact).toBe('medium') + }) + + it('ignores non-junk paths', () => { + const calls = [ + call('Read', { file_path: '/x/src/a.ts' }), + call('Read', { file_path: '/x/src/b.ts' }), + call('Read', { file_path: '/x/README.md' }), + ] + expect(detectJunkReads(calls)).toBeNull() + }) + + it('ignores non-read tools', () => { + const calls = [ + call('Edit', { file_path: '/x/node_modules/a.js' }), + call('Bash', { command: 'ls node_modules' }), + call('Grep', { pattern: 'test', path: '/x/node_modules' }), + ] + expect(detectJunkReads(calls)).toBeNull() + }) + + it('handles missing file_path gracefully', () => { + const calls = [ + call('Read', {}), + call('Read', { file_path: null as unknown as string }), + ] + expect(detectJunkReads(calls)).toBeNull() + }) + + it('suggests CLAUDE.md advice listing detected and common junk dirs', () => { + const calls = Array.from({ length: 5 }, () => call('Read', { file_path: '/x/node_modules/a.js' })) + const finding = detectJunkReads(calls)! + expect(finding.fix.type).toBe('paste') + if (finding.fix.type === 'paste') { + expect(finding.fix.text).toContain('node_modules') + // Issue #277: every paste-style fix should declare its destination so + // users can tell a permanent CLAUDE.md rule from a one-time session + // opener at a glance. + expect(finding.fix.destination).toBe('claude-md') + } + expect(finding.fix.label).toContain('CLAUDE.md') + }) +}) + +describe('detectDuplicateReads', () => { + it('counts same file read multiple times in same session', () => { + const calls = [ + ...Array.from({ length: 4 }, () => call('Read', { file_path: '/src/a.ts' }, 's1')), + ...Array.from({ length: 4 }, () => call('Read', { file_path: '/src/b.ts' }, 's1')), + ] + const finding = detectDuplicateReads(calls) + expect(finding).not.toBeNull() + }) + + it('does not count across sessions', () => { + const calls = [ + call('Read', { file_path: '/src/a.ts' }, 's1'), + call('Read', { file_path: '/src/a.ts' }, 's2'), + call('Read', { file_path: '/src/a.ts' }, 's3'), + ] + expect(detectDuplicateReads(calls)).toBeNull() + }) + + it('excludes junk directory reads', () => { + const calls = Array.from({ length: 10 }, () => + call('Read', { file_path: '/x/node_modules/foo.js' }, 's1') + ) + expect(detectDuplicateReads(calls)).toBeNull() + }) + + it('returns null for single reads', () => { + const calls = [ + call('Read', { file_path: '/src/a.ts' }, 's1'), + call('Read', { file_path: '/src/b.ts' }, 's1'), + ] + expect(detectDuplicateReads(calls)).toBeNull() + }) +}) + +describe('detectLowReadEditRatio', () => { + it('returns null below minimum edit count', () => { + const calls = [ + call('Edit', {}), + call('Edit', {}), + call('Read', {}), + ] + expect(detectLowReadEditRatio(calls)).toBeNull() + }) + + it('returns null when ratio is healthy', () => { + const calls = [ + ...Array.from({ length: 40 }, () => call('Read', {})), + ...Array.from({ length: 10 }, () => call('Edit', {})), + ] + expect(detectLowReadEditRatio(calls)).toBeNull() + }) + + it('flags when edits outpace reads', () => { + const calls = [ + ...Array.from({ length: 5 }, () => call('Read', {})), + ...Array.from({ length: 10 }, () => call('Edit', {})), + ] + const finding = detectLowReadEditRatio(calls) + expect(finding).not.toBeNull() + expect(finding!.impact).toBe('high') + }) + + it('counts Grep and Glob as reads for ratio', () => { + const calls = [ + ...Array.from({ length: 40 }, () => call('Grep', {})), + ...Array.from({ length: 10 }, () => call('Edit', {})), + ] + expect(detectLowReadEditRatio(calls)).toBeNull() + }) + + it('counts Write as edit', () => { + const calls = [ + ...Array.from({ length: 15 }, () => call('Read', {})), + ...Array.from({ length: 10 }, () => call('Write', {})), + ] + const finding = detectLowReadEditRatio(calls) + expect(finding).not.toBeNull() + }) +}) + +describe('detectCacheBloat', () => { + it('returns null below minimum api calls', () => { + const apiCalls: ApiCallMeta[] = [ + { cacheCreationTokens: 80000, version: '2.1.100' }, + { cacheCreationTokens: 80000, version: '2.1.100' }, + ] + expect(detectCacheBloat(apiCalls, emptyProjects())).toBeNull() + }) + + it('returns null when median is close to baseline', () => { + const apiCalls: ApiCallMeta[] = Array.from({ length: 20 }, () => ({ + cacheCreationTokens: 50000, + version: '2.1.98', + })) + expect(detectCacheBloat(apiCalls, emptyProjects())).toBeNull() + }) + + it('flags when median exceeds 1.4x baseline', () => { + const apiCalls: ApiCallMeta[] = Array.from({ length: 20 }, () => ({ + cacheCreationTokens: 80000, + version: '2.1.100', + })) + const finding = detectCacheBloat(apiCalls, emptyProjects()) + expect(finding).not.toBeNull() + }) +}) + +describe('detectBloatedClaudeMd', () => { + it('returns null when no projects have CLAUDE.md', () => { + const result = detectBloatedClaudeMd(new Set(['/nonexistent/path'])) + expect(result).toBeNull() + }) + + it('returns null for empty project set', () => { + const result = detectBloatedClaudeMd(new Set()) + expect(result).toBeNull() + }) +}) + +describe('detectContextBloat', () => { + it('returns null below the input/context token floor', () => { + const project = projectWithContextSessions([ + contextSession(0, { + totalInputTokens: 74_999, + totalOutputTokens: 100, + }), + ]) + + expect(detectContextBloat([project])).toBeNull() + }) + + it('returns null when output is proportionate to input/context tokens', () => { + const project = projectWithContextSessions([ + contextSession(0, { + totalInputTokens: 100_000, + totalOutputTokens: 5_000, + }), + ]) + + expect(detectContextBloat([project])).toBeNull() + }) + + it('discounts cache reads when estimating context pressure', () => { + const project = projectWithContextSessions([ + contextSession(0, { + totalInputTokens: 5_000, + totalCacheReadTokens: 700_000, + totalOutputTokens: 5_000, + }), + ]) + + expect(detectContextBloat([project])).toBeNull() + }) + + it('weights cache writes when estimating context pressure', () => { + const project = projectWithContextSessions([ + contextSession(0, { + totalInputTokens: 10_000, + totalCacheWriteTokens: 80_000, + totalOutputTokens: 3_000, + }), + ]) + + const finding = detectContextBloat([project]) + expect(finding).not.toBeNull() + expect(finding!.explanation).toContain('110.0K effective input/cache') + expect(finding!.tokensSaved).toBe(65_000) + }) + + it('flags sessions where input/cache tokens swamp output', () => { + const project = projectWithContextSessions([ + contextSession(0, { + totalInputTokens: 90_000, + totalCacheReadTokens: 30_000, + totalOutputTokens: 2_000, + }), + ]) + + const finding = detectContextBloat([project]) + expect(finding).not.toBeNull() + expect(finding!.title).toContain('context-heavy session') + expect(finding!.explanation).toContain('app/s1') + expect(finding!.explanation).toContain('93.0K effective input/cache') + expect(finding!.explanation).toContain('46.5:1') + expect(finding!.impact).toBe('low') + expect(finding!.tokensSaved).toBe(63_000) + }) + + it('uses medium impact between the low and high tiers', () => { + const project = projectWithContextSessions( + Array.from({ length: 4 }, (_, i) => contextSession(i, { + totalInputTokens: 80_000, + totalOutputTokens: 1_000, + })), + ) + + const finding = detectContextBloat([project]) + expect(finding).not.toBeNull() + expect(finding!.impact).toBe('medium') + }) + + it('uses high impact at 10 or more candidates regardless of total size', () => { + const project = projectWithContextSessions( + Array.from({ length: 10 }, (_, i) => contextSession(i, { + totalInputTokens: 80_000, + totalOutputTokens: 1_000, + })), + ) + + const finding = detectContextBloat([project]) + expect(finding).not.toBeNull() + expect(finding!.impact).toBe('high') + }) + + it('includes context growth from the previous session when it is large', () => { + const project = projectWithContextSessions([ + contextSession(0, { + totalInputTokens: 20_000, + totalOutputTokens: 1_000, + }), + contextSession(1, { + totalInputTokens: 100_000, + totalOutputTokens: 2_000, + }), + ]) + + const finding = detectContextBloat([project]) + expect(finding).not.toBeNull() + expect(finding!.explanation).toContain('5.0x previous session input') + }) + + it('calculates context growth within each project only', () => { + const finding = detectContextBloat([ + projectWithContextSessions([ + contextSession(0, { + totalInputTokens: 20_000, + totalOutputTokens: 1_000, + }), + contextSession(1, { + totalInputTokens: 100_000, + totalOutputTokens: 2_000, + }), + ], 'app'), + projectWithContextSessions([ + contextSession(0, { + totalInputTokens: 100_000, + totalOutputTokens: 2_000, + }, 'api'), + ], 'api'), + ]) + + expect(finding).not.toBeNull() + expect(finding!.explanation.match(/previous session input/g)).toHaveLength(1) + }) + + it('summarizes additional candidates after the preview limit', () => { + const project = projectWithContextSessions( + Array.from({ length: 6 }, (_, i) => contextSession(i, { + totalInputTokens: 80_000 + i * 10_000, + totalOutputTokens: 1_000, + })), + ) + + const finding = detectContextBloat([project]) + expect(finding).not.toBeNull() + expect(finding!.explanation).toContain('app/s6') + expect(finding!.explanation).toContain('; +1 more') + expect(finding!.impact).toBe('high') + }) + + it('uses high impact for one very large context-heavy session', () => { + const project = projectWithContextSessions([ + contextSession(0, { + totalInputTokens: 600_000, + totalOutputTokens: 10_000, + }), + ]) + + const finding = detectContextBloat([project]) + expect(finding).not.toBeNull() + expect(finding!.impact).toBe('high') + }) + + it('handles zero-output sessions without dividing by zero', () => { + const project = projectWithContextSessions([ + contextSession(0, { + totalInputTokens: 80_000, + totalOutputTokens: 0, + }), + ]) + + const finding = detectContextBloat([project]) + expect(finding).not.toBeNull() + expect(finding!.explanation).toContain('1000+:1') + expect(finding!.tokensSaved).toBe(80_000) + }) + + it('caps display ratio at 1000+:1 for non-zero-output sessions too', () => { + const project = projectWithContextSessions([ + contextSession(0, { + totalInputTokens: 5_000_000, + totalOutputTokens: 100, + }), + ]) + + const finding = detectContextBloat([project]) + expect(finding).not.toBeNull() + expect(finding!.explanation).toContain('1000+:1') + }) + + it('suppresses the growth ratio when the previous session is more than 7 days back', () => { + const project = projectWithContextSessions([ + { + ...contextSession(0, { totalInputTokens: 20_000, totalOutputTokens: 1_000 }), + firstTimestamp: '2026-05-01T10:00:00Z', + lastTimestamp: '2026-05-01T10:30:00Z', + }, + { + ...contextSession(1, { totalInputTokens: 100_000, totalOutputTokens: 2_000 }), + firstTimestamp: '2026-05-15T10:00:00Z', + lastTimestamp: '2026-05-15T10:30:00Z', + }, + ]) + + const finding = detectContextBloat([project]) + expect(finding).not.toBeNull() + expect(finding!.explanation).not.toContain('previous session input') + }) + + it('anchors growth even when the previous session is below the reporting threshold', () => { + const project = projectWithContextSessions([ + contextSession(0, { totalInputTokens: 20_000, totalOutputTokens: 1_000 }), + contextSession(1, { totalInputTokens: 100_000, totalOutputTokens: 2_000 }), + ]) + + const finding = detectContextBloat([project]) + expect(finding).not.toBeNull() + // The first session sits below CONTEXT_BLOAT_MIN_INPUT_TOKENS (75K) and + // is not itself a candidate, but the growth-from-previous comparison for + // the second session must still anchor against it. + expect(finding!.explanation).toContain('5.0x previous session input') + }) + + it('honors excludedSessionIds passed by the orchestrator', () => { + const project = projectWithContextSessions([ + contextSession(0, { + totalInputTokens: 90_000, + totalCacheReadTokens: 30_000, + totalOutputTokens: 2_000, + }), + ]) + + const finding = detectContextBloat([project], new Set(['s1'])) + expect(finding).toBeNull() + }) +}) + +type LowWorthTurn = TestSession['turns'][number] + +function lowWorthTurn(overrides: Partial<LowWorthTurn> = {}): LowWorthTurn { + return { + userMessage: 'do the work', + assistantCalls: [], + timestamp: '2026-05-01T10:00:00Z', + sessionId: 's1', + category: 'coding', + retries: 0, + hasEdits: false, + ...overrides, + } +} + +function lowWorthSession(cost: number, i: number, overrides: Partial<TestSession> = {}, project = 'app'): TestSession { + const tokens = Math.round(cost * 1000) + return { + sessionId: `s${i + 1}`, + project, + firstTimestamp: `2026-05-${String(i + 1).padStart(2, '0')}T10:00:00Z`, + lastTimestamp: `2026-05-${String(i + 1).padStart(2, '0')}T10:30:00Z`, + totalCostUSD: cost, + totalInputTokens: tokens, + totalOutputTokens: tokens, + totalCacheReadTokens: 0, + totalCacheWriteTokens: 0, + apiCalls: 1, + turns: [], + modelBreakdown: {}, + toolBreakdown: {}, + mcpBreakdown: {}, + bashBreakdown: {}, + categoryBreakdown: {} as TestSession['categoryBreakdown'], + skillBreakdown: {}, + ...overrides, + } +} + +function projectWithLowWorthSessions(sessions: TestSession[], project = 'app'): ProjectSummary { + return { + project, + projectPath: `/tmp/${project}`, + sessions, + totalCostUSD: sessions.reduce((sum, s) => sum + s.totalCostUSD, 0), + totalApiCalls: sessions.reduce((sum, s) => sum + s.apiCalls, 0), + } +} + +describe('detectLowWorthSessions', () => { + it('returns null for cheap sessions', () => { + const project = projectWithLowWorthSessions([ + lowWorthSession(1.99, 0, { turns: [lowWorthTurn({ hasEdits: false })] }), + ]) + expect(detectLowWorthSessions([project])).toBeNull() + }) + + it('does not flag the no-edit cost boundary', () => { + const project = projectWithLowWorthSessions([ + lowWorthSession(2.99, 0, { turns: [lowWorthTurn({ hasEdits: false })] }), + ]) + expect(detectLowWorthSessions([project])).toBeNull() + }) + + it('flags expensive sessions with no edit turns', () => { + const project = projectWithLowWorthSessions([ + lowWorthSession(4, 0, { turns: [lowWorthTurn({ hasEdits: false })] }), + ]) + const finding = detectLowWorthSessions([project]) + expect(finding).not.toBeNull() + expect(finding!.title).toContain('possibly low-worth') + expect(finding!.explanation).toContain('app/s1') + expect(finding!.explanation).toContain('no edit turns') + // sessionTokenTotal = input + output + cache. The lowWorthSession helper + // sets input=output=cost*1000, so the savings ceiling is 2x cost*1000. + expect(finding!.tokensSaved).toBe(8_000) + }) + + it('flags retry-heavy sessions', () => { + const project = projectWithLowWorthSessions([ + lowWorthSession(2.5, 0, { + turns: [ + lowWorthTurn({ hasEdits: true, retries: 1 }), + lowWorthTurn({ hasEdits: true, retries: 2 }), + ], + }), + ]) + const finding = detectLowWorthSessions([project]) + expect(finding).not.toBeNull() + expect(finding!.explanation).toContain('3 retries') + }) + + it('estimates recoverable tokens by retry fraction for sessions with edits', () => { + // 4 turns, 2 retries spread across 2 edits, 0 one-shot edits → trips the + // 'no one-shot edit turns' reason. totalTurns=4, fraction=2/4=0.5, + // sessionTokenTotal=8K, so recoverable savings ceiling is 4K — half the + // session, not the full ceiling that no-edit sessions get. + const project = projectWithLowWorthSessions([ + lowWorthSession(4, 0, { + turns: [ + lowWorthTurn({ hasEdits: true, retries: 1 }), + lowWorthTurn({ hasEdits: true, retries: 1 }), + lowWorthTurn({ hasEdits: false }), + lowWorthTurn({ hasEdits: false }), + ], + }), + ]) + const finding = detectLowWorthSessions([project]) + expect(finding).not.toBeNull() + expect(finding!.tokensSaved).toBe(4_000) + }) + + it('uses full session tokens as the savings ceiling for no-edit sessions', () => { + const project = projectWithLowWorthSessions([ + lowWorthSession(4, 0, { turns: [lowWorthTurn({ hasEdits: false })] }), + ]) + const finding = detectLowWorthSessions([project]) + // No edits at all -> entire session is at risk. sessionTokenTotal = 8K. + expect(finding!.tokensSaved).toBe(8_000) + }) + + it('keeps all reasons that apply to the same session', () => { + const project = projectWithLowWorthSessions([ + lowWorthSession(4, 0, { + turns: [ + lowWorthTurn({ hasEdits: false, retries: 1 }), + lowWorthTurn({ hasEdits: false, retries: 2 }), + ], + }), + ]) + const finding = detectLowWorthSessions([project]) + expect(finding).not.toBeNull() + expect(finding!.explanation).toContain('no edit turns') + expect(finding!.explanation).toContain('3 retries') + }) + + it('flags edit sessions with retries but no one-shot edit turns via categoryBreakdown', () => { + const project = projectWithLowWorthSessions([ + lowWorthSession(2.25, 0, { + categoryBreakdown: { + coding: { turns: 2, costUSD: 2.25, retries: 2, editTurns: 2, oneShotTurns: 0 }, + } as TestSession['categoryBreakdown'], + }), + ]) + const finding = detectLowWorthSessions([project]) + expect(finding).not.toBeNull() + expect(finding!.explanation).toContain('no one-shot edit turns') + }) + + it('skips sessions with a git delivery command', () => { + const project = projectWithLowWorthSessions([ + lowWorthSession(8, 0, { + turns: [lowWorthTurn({ hasEdits: false })], + bashBreakdown: { 'cd /tmp/app && git commit -m "ship fix"': { calls: 1 } }, + }), + ]) + expect(detectLowWorthSessions([project])).toBeNull() + }) + + it('skips sessions with gh pr create', () => { + const project = projectWithLowWorthSessions([ + lowWorthSession(8, 0, { + turns: [lowWorthTurn({ hasEdits: false })], + bashBreakdown: { 'gh pr create --fill': { calls: 1 } }, + }), + ]) + expect(detectLowWorthSessions([project])).toBeNull() + }) + + it('does not treat read-only git commands as delivery', () => { + const project = projectWithLowWorthSessions([ + lowWorthSession(8, 0, { + turns: [lowWorthTurn({ hasEdits: false })], + bashBreakdown: { 'git tag -l': { calls: 1 } }, + }), + ]) + expect(detectLowWorthSessions([project])).not.toBeNull() + }) + + it('does not treat dry-run git commands as delivery', () => { + const project = projectWithLowWorthSessions([ + lowWorthSession(8, 0, { + turns: [lowWorthTurn({ hasEdits: false })], + bashBreakdown: { 'git push --dry-run origin main': { calls: 1 } }, + }), + ]) + expect(detectLowWorthSessions([project])).not.toBeNull() + }) + + it('does not treat git commit-tree as a delivery command', () => { + // Regex must match `git commit` only, not `git commit-tree` / + // `git commit-graph`. Without the (?:\s|$|--) lookahead this would be a + // false positive and the session would silently skip detection. + const project = projectWithLowWorthSessions([ + lowWorthSession(8, 0, { + turns: [lowWorthTurn({ hasEdits: false })], + bashBreakdown: { 'git commit-tree HEAD^{tree}': { calls: 1 } }, + }), + ]) + expect(detectLowWorthSessions([project])).not.toBeNull() + }) + + it('still treats `git commit --amend` as a delivery command', () => { + const project = projectWithLowWorthSessions([ + lowWorthSession(8, 0, { + turns: [lowWorthTurn({ hasEdits: false })], + bashBreakdown: { 'git commit --amend --no-edit': { calls: 1 } }, + }), + ]) + expect(detectLowWorthSessions([project])).toBeNull() + }) + + it('uses low impact for a single small candidate', () => { + const project = projectWithLowWorthSessions([ + lowWorthSession(4, 0, { turns: [lowWorthTurn({ hasEdits: false })] }), + ]) + const finding = detectLowWorthSessions([project]) + expect(finding!.impact).toBe('low') + }) + + it('uses medium impact between low and high tiers', () => { + const project = projectWithLowWorthSessions( + Array.from({ length: 3 }, (_, i) => lowWorthSession(4, i, { + turns: [lowWorthTurn({ hasEdits: false })], + })), + ) + const finding = detectLowWorthSessions([project]) + expect(finding!.impact).toBe('medium') + }) + + it('uses high impact at 10 or more candidates', () => { + const project = projectWithLowWorthSessions( + Array.from({ length: 10 }, (_, i) => lowWorthSession(3, i, { + turns: [lowWorthTurn({ hasEdits: false })], + })), + ) + const finding = detectLowWorthSessions([project]) + expect(finding!.impact).toBe('high') + }) + + it('summarizes additional candidates after the preview limit', () => { + const project = projectWithLowWorthSessions( + Array.from({ length: 6 }, (_, i) => lowWorthSession(4 + i, i, { + turns: [lowWorthTurn({ hasEdits: false })], + })), + ) + const finding = detectLowWorthSessions([project]) + expect(finding!.explanation).toContain('; +1 more') + }) +}) + +type ReliabilityCall = LowWorthTurn['assistantCalls'][number] + +function reliabilityCall(overrides: Partial<ReliabilityCall> = {}): ReliabilityCall { + return { + provider: 'claude', + model: 'claude-sonnet-4-5', + usage: { + inputTokens: 1000, + outputTokens: 0, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + }, + costUSD: 0.01, + tools: ['Edit'], + mcpTools: [], + skills: [], + hasAgentSpawn: false, + hasPlanMode: false, + speed: 'standard', + timestamp: '2026-05-01T10:00:00Z', + bashCommands: [], + deduplicationKey: 'call', + ...overrides, + } +} + +function reliabilityTurn( + i: number, + overrides: Partial<LowWorthTurn> & { call?: Partial<ReliabilityCall> } = {}, +): LowWorthTurn { + const { call: callOverrides, ...turnOverrides } = overrides + return lowWorthTurn({ + userMessage: `turn ${i}`, + assistantCalls: [reliabilityCall({ + timestamp: `2026-05-01T10:${String(i).padStart(2, '0')}:00Z`, + deduplicationKey: `call-${i}`, + ...callOverrides, + })], + timestamp: `2026-05-01T10:${String(i).padStart(2, '0')}:00Z`, + sessionId: 's1', + hasEdits: true, + retries: 0, + ...turnOverrides, + }) +} + +function projectWithReliabilityTurns(turns: LowWorthTurn[], project = 'app'): ProjectSummary { + return projectWithLowWorthSessions([ + lowWorthSession(1, 0, { + turns, + totalInputTokens: turns.length * 1000, + totalOutputTokens: 0, + totalCacheReadTokens: 0, + totalCacheWriteTokens: 0, + apiCalls: turns.length, + }, project), + ], project) +} + +describe('detectCapabilityReliability', () => { + it('flags retry-heavy skills from actual Skill call metadata', () => { + const turns = Array.from({ length: 5 }, (_, i) => reliabilityTurn(i, { + retries: i < 3 ? 1 : 0, + call: { tools: ['Edit', 'Skill'], skills: ['reviewer'] }, + })) + + const finding = detectCapabilityReliability([projectWithReliabilityTurns(turns)]) + + expect(finding).not.toBeNull() + expect(finding!.title).toContain('skill') + expect(finding!.explanation).toContain('skill reviewer') + expect(finding!.explanation).toContain('3/5 edit turns retried (60%)') + expect(finding!.explanation).toContain('correlation report') + expect(finding!.tokensSaved).toBe(1500) + expect(finding!.fix.type).toBe('paste') + if (finding!.fix.type === 'paste') expect(finding!.fix.destination).toBe('prompt') + }) + + it('flags retry-heavy MCP servers from invoked MCP tools', () => { + const turns = Array.from({ length: 5 }, (_, i) => reliabilityTurn(i, { + retries: i < 3 ? 1 : 0, + call: { + tools: ['Edit', 'mcp__ci__run'], + mcpTools: ['mcp__ci__run'], + }, + })) + + const finding = detectCapabilityReliability([projectWithReliabilityTurns(turns)]) + + expect(finding).not.toBeNull() + expect(finding!.title).toContain('MCP server') + expect(finding!.explanation).toContain('MCP server ci') + expect(finding!.explanation).toContain('3 retries') + }) + + it('does not flag healthy capabilities with mostly one-shot edit turns', () => { + const turns = Array.from({ length: 5 }, (_, i) => reliabilityTurn(i, { + retries: i === 0 ? 1 : 0, + call: { tools: ['Edit', 'Skill'], skills: ['healthy'] }, + })) + + expect(detectCapabilityReliability([projectWithReliabilityTurns(turns)])).toBeNull() + }) + + it('does not treat subCategory alone as skill evidence', () => { + const turns = Array.from({ length: 5 }, (_, i) => reliabilityTurn(i, { + retries: 1, + subCategory: 'legacy-skill-label', + call: { tools: ['Edit'], skills: [] }, + })) + + expect(detectCapabilityReliability([projectWithReliabilityTurns(turns)])).toBeNull() + }) + + it('does not double-count the same retry-heavy turn across MCP and skill candidates', () => { + const turns = Array.from({ length: 5 }, (_, i) => reliabilityTurn(i, { + retries: i < 3 ? 1 : 0, + call: { + tools: ['Edit', 'Skill', 'mcp__ci__run'], + mcpTools: ['mcp__ci__run'], + skills: ['reviewer'], + }, + })) + + const finding = detectCapabilityReliability([projectWithReliabilityTurns(turns)]) + + expect(finding).not.toBeNull() + expect(finding!.title).toContain('2 MCP/skill capabilities') + expect(finding!.explanation).toContain('MCP server ci') + expect(finding!.explanation).toContain('skill reviewer') + // Three retry-heavy turns at 1K effective tokens each, counted once at + // the 50% recoverable ceiling even though two flagged capabilities share + // every turn. + expect(finding!.tokensSaved).toBe(1500) + }) + + it('ignores read-only retry turns for capability reliability', () => { + const turns = Array.from({ length: 5 }, (_, i) => reliabilityTurn(i, { + hasEdits: false, + retries: 1, + call: { tools: ['Read', 'Skill'], skills: ['reader'] }, + })) + + expect(detectCapabilityReliability([projectWithReliabilityTurns(turns)])).toBeNull() + }) +}) + +describe('detectSessionOutliers', () => { + it('returns null when there are too few sessions for a project baseline', () => { + expect(detectSessionOutliers([projectWithSessions([0.5, 4])])).toBeNull() + }) + + it('returns null when no session exceeds twice the project average', () => { + expect(detectSessionOutliers([projectWithSessions([1, 1.2, 1.4, 1.6])])).toBeNull() + }) + + it('does not flag the exact 2x boundary', () => { + expect(detectSessionOutliers([projectWithSessions([1, 1, 2])])).toBeNull() + }) + + it('flags sessions costing more than twice their project average', () => { + const finding = detectSessionOutliers([projectWithSessions([1, 1, 1, 10])]) + expect(finding).not.toBeNull() + expect(finding!.title).toContain('high-cost session outlier') + expect(finding!.explanation).toContain('app/s4') + expect(finding!.impact).toBe('medium') + expect(finding!.tokensSaved).toBeGreaterThan(0) + }) + + it('ignores tiny absolute-cost outliers', () => { + expect(detectSessionOutliers([projectWithSessions([0.01, 0.01, 0.01, 0.2])])).toBeNull() + }) + + it('isolates baselines per project', () => { + const finding = detectSessionOutliers([ + projectWithSessions([8, 9, 10], 'web'), + projectWithSessions([1, 1, 1, 12], 'api'), + ]) + + expect(finding).not.toBeNull() + expect(finding!.explanation).toContain('api/s4') + expect(finding!.explanation).not.toContain('web/') + }) + + it('excludes sessions already flagged by detectContextBloat', () => { + const project = projectWithSessions([1, 1, 1, 10]) + const excluded = new Set(['s4']) + expect(detectSessionOutliers([project], excluded)).toBeNull() + }) + + it('still flags cost outliers that are not context-bloat candidates', () => { + const project = projectWithSessions([1, 1, 1, 10]) + const excluded = new Set(['some-other-session']) + const finding = detectSessionOutliers([project], excluded) + expect(finding).not.toBeNull() + expect(finding!.explanation).toContain('app/s4') + }) +}) + +describe('computeHealth', () => { + it('returns A with 100 for no findings', () => { + const { score, grade } = computeHealth([]) + expect(score).toBe(100) + expect(grade).toBe('A') + }) + + function mockFinding(impact: 'high' | 'medium' | 'low'): WasteFinding { + return { + title: 't', explanation: 'e', impact, tokensSaved: 1000, + fix: { type: 'paste', label: 'l', text: 't' }, + } + } + + it('one low finding stays at A', () => { + const { score, grade } = computeHealth([mockFinding('low')]) + expect(score).toBe(97) + expect(grade).toBe('A') + }) + + it('two high findings drop to C', () => { + const { score, grade } = computeHealth([mockFinding('high'), mockFinding('high')]) + expect(score).toBe(70) + expect(grade).toBe('C') + }) + + it('caps penalty at 80 to prevent score below 20', () => { + const findings = Array.from({ length: 20 }, () => mockFinding('high')) + const { score } = computeHealth(findings) + expect(score).toBe(20) + }) + + it('progresses grades predictably', () => { + expect(computeHealth([mockFinding('low')]).grade).toBe('A') + expect(computeHealth([mockFinding('medium')]).grade).toBe('A') + expect(computeHealth([mockFinding('medium'), mockFinding('medium')]).grade).toBe('B') + expect(computeHealth([mockFinding('high'), mockFinding('high'), mockFinding('high')]).grade).toBe('C') + expect(computeHealth([mockFinding('high'), mockFinding('high'), mockFinding('high'), mockFinding('high'), mockFinding('high')]).grade).toBe('F') + }) +}) + +describe('computeTrend', () => { + const window = 48 * 60 * 60 * 1000 + const baselineWindow = 5 * 24 * 60 * 60 * 1000 + + it('returns active when no recent activity detected', () => { + const trend = computeTrend({ + recentCount: 0, recentWindowMs: window, + baselineCount: 100, baselineWindowMs: baselineWindow, + hasRecentActivity: false, + }) + expect(trend).toBe('active') + }) + + it('returns resolved when recent activity exists but zero waste in it', () => { + const trend = computeTrend({ + recentCount: 0, recentWindowMs: window, + baselineCount: 100, baselineWindowMs: baselineWindow, + hasRecentActivity: true, + }) + expect(trend).toBe('resolved') + }) + + it('returns improving when recent rate is less than half of baseline rate', () => { + const trend = computeTrend({ + recentCount: 5, recentWindowMs: window, + baselineCount: 100, baselineWindowMs: baselineWindow, + hasRecentActivity: true, + }) + expect(trend).toBe('improving') + }) + + it('returns active when recent rate matches baseline rate', () => { + const recentRate = 100 / baselineWindow + const recentCount = Math.ceil(recentRate * window) + const trend = computeTrend({ + recentCount, recentWindowMs: window, + baselineCount: 100, baselineWindowMs: baselineWindow, + hasRecentActivity: true, + }) + expect(trend).toBe('active') + }) + + it('returns active when baseline is empty (new finding)', () => { + const trend = computeTrend({ + recentCount: 10, recentWindowMs: window, + baselineCount: 0, baselineWindowMs: baselineWindow, + hasRecentActivity: true, + }) + expect(trend).toBe('active') + }) +}) + +describe('paste-fix destination tagging (issue #277)', () => { + // Walks every emitted finding's fix and asserts that `paste`-type actions + // declare a destination. Future detectors that ship a paste fix without a + // destination get caught here so users never see an unlabeled "here's a + // suggestion" block again. + function checkAllPasteFixesHaveDestination(findings: WasteFinding[]) { + for (const f of findings) { + if (f.fix.type === 'paste') { + expect( + f.fix.destination, + `finding "${f.title}" has paste fix without destination — pick one of: claude-md / session-opener / prompt / shell-config` + ).toBeDefined() + expect(['claude-md', 'session-opener', 'prompt', 'shell-config']) + .toContain(f.fix.destination) + } + } + } + + it('detectJunkReads emits a tagged paste fix', () => { + const calls = Array.from({ length: 5 }, () => call('Read', { file_path: '/x/node_modules/a.js' })) + checkAllPasteFixesHaveDestination([detectJunkReads(calls)!]) + }) + + it('detectDuplicateReads emits a tagged paste fix', () => { + const calls = [ + ...Array.from({ length: 6 }, () => call('Read', { file_path: '/src/a.ts' }, 's1')), + ...Array.from({ length: 6 }, () => call('Read', { file_path: '/src/b.ts' }, 's1')), + ...Array.from({ length: 6 }, () => call('Read', { file_path: '/src/c.ts' }, 's1')), + ] + checkAllPasteFixesHaveDestination([detectDuplicateReads(calls)!]) + }) + + it('detectLowReadEditRatio emits a tagged paste fix', () => { + const calls = [ + ...Array.from({ length: 5 }, () => call('Edit', { file_path: '/src/a.ts' })), + ...Array.from({ length: 5 }, () => call('Edit', { file_path: '/src/b.ts' })), + ...Array.from({ length: 5 }, () => call('Edit', { file_path: '/src/c.ts' })), + ...Array.from({ length: 5 }, () => call('Edit', { file_path: '/src/d.ts' })), + ...Array.from({ length: 5 }, () => call('Edit', { file_path: '/src/e.ts' })), + ] + const finding = detectLowReadEditRatio(calls) + if (finding) checkAllPasteFixesHaveDestination([finding]) + }) +}) + +describe('buildOptimizeJsonReport', () => { + it('serializes setup health, savings, and fix details for integrations', () => { + const result: OptimizeResult = { + costRate: 0.00002, + healthScore: 72, + healthGrade: 'C', + findings: [ + { + title: 'Trim stale context', + explanation: 'Old instructions are loaded every turn.', + impact: 'medium', + tokensSaved: 50_000, + trend: 'active', + fix: { + type: 'paste', + label: 'Add guardrail', + text: 'Prefer short context.', + destination: 'claude-md', + }, + }, + ], + } + const range = { + start: new Date('2026-05-01T00:00:00.000Z'), + end: new Date('2026-05-08T00:00:00.000Z'), + } + + const report = buildOptimizeJsonReport( + [projectWithSessions([3, 2])], + '7 Days', + result, + range, + ) + + expect(report.period).toEqual({ + label: '7 Days', + start: '2026-05-01T00:00:00.000Z', + end: '2026-05-08T00:00:00.000Z', + }) + expect(report.summary).toMatchObject({ + healthScore: 72, + healthGrade: 'C', + findingCount: 1, + periodCostUSD: 5, + sessions: 2, + calls: 2, + potentialSavingsTokens: 50_000, + potentialSavingsCostUSD: 1, + potentialSavingsPercent: 20, + costRateUSD: 0.00002, + }) + expect(report.findings[0]).toMatchObject({ + title: 'Trim stale context', + severity: 'medium', + trend: 'active', + tokensSaved: 50_000, + estimatedSavingsUSD: 1, + fix: { + type: 'paste', + destination: 'claude-md', + }, + }) + }) +}) diff --git a/tests/otel-cache-aggregation.test.ts b/tests/otel-cache-aggregation.test.ts new file mode 100644 index 0000000..912263d --- /dev/null +++ b/tests/otel-cache-aggregation.test.ts @@ -0,0 +1,202 @@ +// Regression test for the OTel multi-conversation cache overwrite bug. +// +// Root cause: `parseProviderSources` in parser.ts calls +// `delete section.files[source.path]` +// at the START of every loop iteration over changedSources. When multiple OTel +// conversations from the same agent-traces.db share the same path key, each +// iteration wiped the merged turns accumulated by all previous iterations, so +// only the LAST conversation's data survived — a ~434x cost undercount in +// practice (observed: $0.19 vs ~$85 ground truth from OTel DB). +// +// This test exercises the full `parseAllSessions` pipeline to catch any future +// regression at the aggregation layer, not just the provider-level parser. + +import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest' +import { mkdtemp, rm } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' +import { createRequire } from 'node:module' + +import { isSqliteAvailable } from '../src/sqlite.js' +import { clearSessionCache, parseAllSessions } from '../src/parser.js' + +const requireForTest = createRequire(import.meta.url) + +type TestDb = { + exec(sql: string): void + prepare(sql: string): { run(...p: unknown[]): void } + close(): void +} + +function createOtelDb(dbPath: string): void { + const { DatabaseSync } = requireForTest('node:sqlite') as { DatabaseSync: new (path: string) => TestDb } + const db = new DatabaseSync(dbPath) + db.exec(` + CREATE TABLE spans ( + span_id TEXT PRIMARY KEY NOT NULL, + trace_id TEXT NOT NULL, + operation_name TEXT, + start_time_ms INTEGER NOT NULL DEFAULT 0, + response_model TEXT + ); + CREATE TABLE span_attributes ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + span_id TEXT NOT NULL, + key TEXT NOT NULL, + value TEXT + ); + `) + db.close() +} + +interface ConvSpec { + spanId: string + traceId: string + convId: string + model: string + input: number + output: number + cacheRead: number + cacheCreate: number + startTimeMs?: number +} + +function insertConversation(dbPath: string, spec: ConvSpec): void { + const { DatabaseSync } = requireForTest('node:sqlite') as { DatabaseSync: new (path: string) => TestDb } + const db = new DatabaseSync(dbPath) + db.prepare( + `INSERT INTO spans (span_id, trace_id, operation_name, start_time_ms, response_model) + VALUES (?, ?, ?, ?, ?)` + ).run(spec.spanId, spec.traceId, 'chat', spec.startTimeMs ?? Date.now(), spec.model) + + const attrStmt = db.prepare( + `INSERT INTO span_attributes (span_id, key, value) VALUES (?, ?, ?)` + ) + const attrs: Record<string, string | number> = { + 'gen_ai.conversation.id': spec.convId, + 'gen_ai.response.model': spec.model, + 'gen_ai.usage.input_tokens': spec.input, + 'gen_ai.usage.output_tokens': spec.output, + 'gen_ai.usage.cache_read.input_tokens': spec.cacheRead, + 'gen_ai.usage.cache_creation.input_tokens': spec.cacheCreate, + } + for (const [key, value] of Object.entries(attrs)) { + attrStmt.run(spec.spanId, key, String(value)) + } + db.close() +} + +describe.skipIf(!isSqliteAvailable())( + 'OTel multi-conversation cache aggregation (regression for 434x undercount)', + () => { + let tmpHome: string + let tmpCache: string + let dbPath: string + + beforeEach(async () => { + tmpHome = await mkdtemp(join(tmpdir(), 'cb-otel-agg-home-')) + tmpCache = await mkdtemp(join(tmpdir(), 'cb-otel-agg-cache-')) + dbPath = join(tmpHome, 'agent-traces.db') + + process.env['HOME'] = tmpHome + process.env['CODEBURN_CACHE_DIR'] = tmpCache + + vi.stubEnv('CODEBURN_COPILOT_OTEL_DB', dbPath) + vi.stubEnv('CODEBURN_COPILOT_DISABLE_OTEL', '') + // Redirect JSONL and transcript dirs to nonexistent paths so real + // developer session files don't contaminate the test results. + vi.stubEnv('CODEBURN_COPILOT_SESSION_STATE_DIR', join(tmpHome, 'no-jsonl')) + vi.stubEnv('CODEBURN_COPILOT_WS_STORAGE_DIR', join(tmpHome, 'no-ws')) + }) + + afterEach(async () => { + clearSessionCache() + vi.unstubAllEnvs() + await rm(tmpHome, { recursive: true, force: true }) + await rm(tmpCache, { recursive: true, force: true }) + }) + + it('preserves cache tokens from all conversations, not just the last one', async () => { + // Pricing for claude-haiku-4-5 (per litellm-snapshot.json): + // input: $1.00 / M → 1e-6 + // output: $5.00 / M → 5e-6 + // cache_read: $0.10 / M → 1e-7 + // cache_write: $1.25 / M → 1.25e-6 + createOtelDb(dbPath) + + const conversations: ConvSpec[] = [ + { spanId: 'span-1', traceId: 'trace-1', convId: 'conv-1', model: 'claude-haiku-4-5-20251001', + input: 1_000, output: 100, cacheRead: 50_000, cacheCreate: 500 }, + { spanId: 'span-2', traceId: 'trace-2', convId: 'conv-2', model: 'claude-haiku-4-5-20251001', + input: 2_000, output: 200, cacheRead: 60_000, cacheCreate: 600 }, + { spanId: 'span-3', traceId: 'trace-3', convId: 'conv-3', model: 'claude-haiku-4-5-20251001', + input: 3_000, output: 300, cacheRead: 70_000, cacheCreate: 700 }, + ] + for (const c of conversations) insertConversation(dbPath, c) + + const projects = await parseAllSessions(undefined, 'copilot') + const allCalls = projects + .flatMap(p => p.sessions) + .flatMap(s => s.turns) + .flatMap(t => t.assistantCalls) + + // All three conversations must be present — before the fix only 1 survived. + expect(allCalls).toHaveLength(3) + + const totalInput = allCalls.reduce((s, c) => s + c.usage.inputTokens, 0) + const totalOutput = allCalls.reduce((s, c) => s + c.usage.outputTokens, 0) + const totalCacheRead = allCalls.reduce((s, c) => s + c.usage.cacheReadInputTokens, 0) + const totalCacheCreate = allCalls.reduce((s, c) => s + c.usage.cacheCreationInputTokens, 0) + + expect(totalInput).toBe(6_000) // 1 000 + 2 000 + 3 000 + expect(totalOutput).toBe(600) // 100 + 200 + 300 + expect(totalCacheRead).toBe(180_000) // 50k + 60k + 70k — all must survive + expect(totalCacheCreate).toBe(1_800) // 500 + 600 + 700 + + // Pre-fix regression check: if only the last conversation survived, + // totalCacheRead would be 70 000 (the last one). Assert it's 180 000. + expect(totalCacheRead).toBeGreaterThan(100_000) + + // Cost sanity: input+output+cacheRead+cacheCreate with haiku-4-5 pricing + // 6000 * 1e-6 = 0.006 + // 600 * 5e-6 = 0.003 + // 180k * 1e-7 = 0.018 + // 1800 * 1.25e-6 = 0.00225 + // total ≈ $0.029 + const totalCostUSD = allCalls.reduce((s, c) => s + c.costUSD, 0) + expect(totalCostUSD).toBeCloseTo(0.029, 2) + }) + + it('second run from disk cache also delivers all conversations', async () => { + // Ensures the merged result written to the session-cache.json survives + // a reload and yields the same aggregated data on repeat invocations. + createOtelDb(dbPath) + + const conversations: ConvSpec[] = [ + { spanId: 'span-a', traceId: 'trace-a', convId: 'conv-a', model: 'claude-haiku-4-5-20251001', + input: 500, output: 50, cacheRead: 25_000, cacheCreate: 250 }, + { spanId: 'span-b', traceId: 'trace-b', convId: 'conv-b', model: 'claude-haiku-4-5-20251001', + input: 500, output: 50, cacheRead: 25_000, cacheCreate: 250 }, + ] + for (const c of conversations) insertConversation(dbPath, c) + + // First run — parses and writes disk cache + await parseAllSessions(undefined, 'copilot') + + // Clear in-memory cache only, leaving disk cache intact + clearSessionCache() + + // Second run — should read from disk cache + const projects = await parseAllSessions(undefined, 'copilot') + const allCalls = projects + .flatMap(p => p.sessions) + .flatMap(s => s.turns) + .flatMap(t => t.assistantCalls) + + expect(allCalls).toHaveLength(2) + + const totalCacheRead = allCalls.reduce((s, c) => s + c.usage.cacheReadInputTokens, 0) + expect(totalCacheRead).toBe(50_000) // 25k + 25k from both conversations + }) + } +) diff --git a/tests/overview.test.ts b/tests/overview.test.ts new file mode 100644 index 0000000..89d6d75 --- /dev/null +++ b/tests/overview.test.ts @@ -0,0 +1,151 @@ +import { describe, it, expect } from 'vitest' + +import { renderOverview } from '../src/overview.js' +import type { ProjectSummary } from '../src/types.js' + +function makeProject(opts: { + project: string + projectPath: string + cost: number + calls: number + model: string + provider: string + tokens: { input: number; output: number; cacheR: number; cacheW: number } +}): ProjectSummary { + const usage = { + inputTokens: opts.tokens.input, + outputTokens: opts.tokens.output, + cacheReadInputTokens: opts.tokens.cacheR, + cacheCreationInputTokens: opts.tokens.cacheW, + } + return { + project: opts.project, + projectPath: opts.projectPath, + totalCostUSD: opts.cost, + totalSavingsUSD: 0, + totalProxiedCostUSD: 0, + totalApiCalls: opts.calls, + sessions: [{ + sessionId: 's1', + project: opts.project, + totalInputTokens: opts.tokens.input, + totalOutputTokens: opts.tokens.output, + totalCacheReadTokens: opts.tokens.cacheR, + totalCacheWriteTokens: opts.tokens.cacheW, + apiCalls: opts.calls, + modelBreakdown: { [opts.model]: { calls: opts.calls, costUSD: opts.cost, savingsUSD: 0, tokens: usage } }, + categoryBreakdown: { coding: { turns: 1, costUSD: opts.cost, savingsUSD: 0, retries: 0, editTurns: 1, oneShotTurns: 1 } }, + toolBreakdown: { Bash: { calls: 5 }, Read: { calls: 2 } }, + mcpBreakdown: {}, + bashBreakdown: {}, + skillBreakdown: {}, + subagentBreakdown: {}, + turns: [{ + userMessage: 'hi', + timestamp: '2026-06-15T10:00:00Z', + sessionId: 's1', + category: 'coding', + retries: 0, + hasEdits: true, + assistantCalls: [{ provider: opts.provider, model: opts.model, costUSD: opts.cost, usage }], + }], + }], + } as unknown as ProjectSummary +} + +describe('renderOverview', () => { + it('renders the detailed sections from real aggregation', () => { + const out = renderOverview([makeProject({ + project: 'myproject', + projectPath: '/Users/test/myproject', + cost: 12.5, + calls: 3, + model: 'claude-opus-4-8', + provider: 'claude', + tokens: { input: 1000, output: 200, cacheR: 5000, cacheW: 100 }, + })], { label: 'June 2026', color: false }) + + for (const section of ['Totals', 'By tool', 'Top models', 'Highest-value days', 'Top projects', 'Daily', 'By activity', 'Tools']) { + expect(out).toContain(section) + } + expect(out).toContain('Opus 4.8') // model display name + expect(out).toContain('claude') // provider in By tool + expect(out).toContain('myproject') // clean project name from path basename + expect(out).toContain('$12.50') + expect(out).toContain('2026-06-15') + expect(out).toContain('Coding') + expect(out).toContain('Bash') + }) + + it('uses thousands separators and a B unit, and strips color in no-color mode', () => { + const out = renderOverview([makeProject({ + project: 'big', + projectPath: '/Users/test/big', + cost: 1234.56, + calls: 10, + model: 'claude-opus-4-8', + provider: 'claude', + tokens: { input: 1_000_000, output: 1_000_000, cacheR: 2_000_000_000, cacheW: 0 }, + })], { label: 'June 2026', color: false }) + + expect(out).toContain('$1,234.56') + // tokens render as full, comma-grouped numbers (not abbreviated) + expect(out).toContain('2,002,000,000') + // no-color mode must not emit ANSI escape codes + // eslint-disable-next-line no-control-regex + expect(out).not.toMatch(/\[/) + }) + + it('reports no usage for an empty range', () => { + const out = renderOverview([], { label: 'June 2026', color: false }) + expect(out).toContain('No usage found for June 2026') + }) + + it('does not split a slug-only Claude project path into fake path segments', () => { + const out = renderOverview([makeProject({ + project: 'Projects-Content-OS', + projectPath: 'Projects/Content/OS', + cost: 3.25, + calls: 1, + model: 'claude-sonnet-4-5', + provider: 'claude', + tokens: { input: 1000, output: 200, cacheR: 0, cacheW: 0 }, + })], { label: 'June 2026', color: false }) + + expect(out).toContain('Projects-Content-OS') + expect(out).not.toContain(' OS ') + }) +}) + +describe('renderOverview unpriced models', () => { + it('warns when a model with usage has no pricing data', () => { + const out = renderOverview([makeProject({ + project: 'mystery', + projectPath: '/Users/test/mystery', + cost: 0, + calls: 4, + model: 'zz-mystery-paid-model-999', + provider: 'claude', + tokens: { input: 1000, output: 200, cacheR: 0, cacheW: 0 }, + })], { label: 'June 2026', color: false }) + + expect(out).toContain('Unpriced') + expect(out).toContain('1 model at $0') + expect(out).toContain('zz-mystery-paid-model-999') + expect(out).toContain('codeburn model-alias') + }) + + it('stays silent when every model is priced', () => { + const out = renderOverview([makeProject({ + project: 'priced', + projectPath: '/Users/test/priced', + cost: 5, + calls: 2, + model: 'claude-opus-4-8', + provider: 'claude', + tokens: { input: 100, output: 50, cacheR: 0, cacheW: 0 }, + })], { label: 'June 2026', color: false }) + + expect(out).not.toContain('Unpriced') + }) +}) diff --git a/tests/parser-claude-cwd.test.ts b/tests/parser-claude-cwd.test.ts new file mode 100644 index 0000000..9a379db --- /dev/null +++ b/tests/parser-claude-cwd.test.ts @@ -0,0 +1,577 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm, utimes } from 'fs/promises' +import { join, relative } from 'path' +import { tmpdir, homedir } from 'os' + +import { parseAllSessions } from '../src/parser.js' +import type { DateRange } from '../src/types.js' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'claude-cwd-test-')) + process.env['CLAUDE_CONFIG_DIR'] = tmpDir + // Point desktop sessions at an empty subdir by default so real sessions + // on the developer's machine do not bleed into the unit tests. + process.env['CODEBURN_DESKTOP_SESSIONS_DIR'] = join(tmpDir, 'desktop-sessions') +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +function dayRange(day: string): DateRange { + return { + start: new Date(`${day}T00:00:00.000Z`), + end: new Date(`${day}T23:59:59.999Z`), + } +} + +async function writeClaudeSession( + projectSlug: string, + sessionId: string, + cwd: string, + timestamp: string, + usage: Record<string, unknown> = { input_tokens: 100, output_tokens: 50 }, + model = 'claude-sonnet-4-5', +): Promise<void> { + const projectDir = join(tmpDir, 'projects', projectSlug) + await mkdir(projectDir, { recursive: true }) + const filePath = join(projectDir, `${sessionId}.jsonl`) + await writeFile(filePath, JSON.stringify({ + type: 'assistant', + sessionId, + timestamp, + cwd, + message: { + id: `msg-${sessionId}`, + type: 'message', + role: 'assistant', + model, + content: [], + usage, + }, + }) + '\n') + + const mtime = new Date(timestamp) + await utimes(filePath, mtime, mtime) +} + +describe('Claude cwd project paths', () => { + it('uses the JSONL cwd as the canonical project path instead of the lossy directory slug', async () => { + await writeClaudeSession( + 'c--AI-LAB-OPENCLAW', + 'windows-session', + 'C:\\AI_LAB\\OPENCLAW', + '2099-05-01T12:00:00.000Z', + ) + + const projects = await parseAllSessions(dayRange('2099-05-01'), 'claude') + + expect(projects).toHaveLength(1) + expect(projects[0]!.projectPath).toBe('C:\\AI_LAB\\OPENCLAW') + expect(projects[0]!.projectPath).not.toBe('c//AI/LAB/OPENCLAW') + expect(projects[0]!.totalApiCalls).toBe(1) + }) + + it('groups Windows cwd case and slash variants into one project', async () => { + await writeClaudeSession( + 'windows-openclaw-a', + 'upper-backslash', + 'C:\\AI_LAB\\OPENCLAW', + '2099-05-02T10:00:00.000Z', + ) + await writeClaudeSession( + 'windows-openclaw-b', + 'lower-forward-slash', + 'c:/AI_LAB/OPENCLAW/', + '2099-05-02T11:00:00.000Z', + ) + + const projects = await parseAllSessions(dayRange('2099-05-02'), 'claude') + + expect(projects).toHaveLength(1) + expect(projects[0]!.sessions).toHaveLength(2) + expect(projects[0]!.totalApiCalls).toBe(2) + expect(projects[0]!.sessions.map(s => s.sessionId).sort()).toEqual([ + 'lower-forward-slash', + 'upper-backslash', + ]) + }) + + it('prefers the canonical cwd path even when mixed with slug-only sessions in the same directory', async () => { + const slug = 'c--AI-LAB-OPENCLAW' + const projectDir = join(tmpDir, 'projects', slug) + await mkdir(projectDir, { recursive: true }) + const noCwdPath = join(projectDir, 'a-no-cwd.jsonl') + await writeFile(noCwdPath, JSON.stringify({ + type: 'assistant', + sessionId: 'no-cwd', + timestamp: '2099-05-03T10:00:00.000Z', + message: { + id: 'msg-no-cwd', type: 'message', role: 'assistant', + model: 'claude-sonnet-4-5', content: [], + usage: { input_tokens: 100, output_tokens: 50 }, + }, + }) + '\n') + await utimes(noCwdPath, new Date('2099-05-03T10:00:00.000Z'), new Date('2099-05-03T10:00:00.000Z')) + + await writeClaudeSession(slug, 'b-with-cwd', 'C:\\AI_LAB\\OPENCLAW', '2099-05-03T11:00:00.000Z') + + const projects = await parseAllSessions(dayRange('2099-05-03'), 'claude') + + expect(projects).toHaveLength(1) + expect(projects[0]!.sessions).toHaveLength(2) + expect(projects[0]!.projectPath).toBe('C:\\AI_LAB\\OPENCLAW') + expect(projects[0]!.projectPath).not.toBe('c//AI/LAB/OPENCLAW') + }) + + it('falls back to the slug-derived path when cwd is null, missing, or empty', async () => { + const slug = 'fallback-slug' + const projectDir = join(tmpDir, 'projects', slug) + await mkdir(projectDir, { recursive: true }) + + async function writeWith(name: string, sessionId: string, cwdField: unknown, ts: string) { + const filePath = join(projectDir, `${name}.jsonl`) + const obj: Record<string, unknown> = { + type: 'assistant', sessionId, timestamp: ts, + message: { + id: `msg-${sessionId}`, type: 'message', role: 'assistant', + model: 'claude-sonnet-4-5', content: [], + usage: { input_tokens: 100, output_tokens: 50 }, + }, + } + if (cwdField !== undefined) obj.cwd = cwdField + await writeFile(filePath, JSON.stringify(obj) + '\n') + await utimes(filePath, new Date(ts), new Date(ts)) + } + + await writeWith('null-cwd', 's-null', null, '2099-05-04T10:00:00.000Z') + await writeWith('empty-cwd', 's-empty', '', '2099-05-04T10:30:00.000Z') + await writeWith('whitespace-cwd', 's-ws', ' ', '2099-05-04T11:00:00.000Z') + await writeWith('missing-cwd', 's-miss', undefined, '2099-05-04T11:30:00.000Z') + + const projects = await parseAllSessions(dayRange('2099-05-04'), 'claude') + + expect(projects).toHaveLength(1) + expect(projects[0]!.sessions).toHaveLength(4) + expect(projects[0]!.projectPath).toBe('fallback-slug') + }) + + it('keeps a hyphenated slug intact when cwd is absent', async () => { + const slug = 'Projects-Content-OS' + const projectDir = join(tmpDir, 'projects', slug) + await mkdir(projectDir, { recursive: true }) + const filePath = join(projectDir, 'no-cwd.jsonl') + await writeFile(filePath, JSON.stringify({ + type: 'assistant', + sessionId: 'no-cwd', + timestamp: '2099-05-09T10:00:00.000Z', + message: { + id: 'msg-no-cwd', + type: 'message', + role: 'assistant', + model: 'claude-sonnet-4-5', + content: [], + usage: { input_tokens: 100, output_tokens: 50 }, + }, + }) + '\n') + await utimes(filePath, new Date('2099-05-09T10:00:00.000Z'), new Date('2099-05-09T10:00:00.000Z')) + + const projects = await parseAllSessions(dayRange('2099-05-09'), 'claude') + + expect(projects).toHaveLength(1) + expect(projects[0]!.project).toBe(slug) + expect(projects[0]!.projectPath).toBe(slug) + expect(projects[0]!.projectPath).not.toBe('Projects/Content/OS') + }) + + it('does not group sibling projects under a parent directory that merely contains .git', async () => { + const projectsRoot = join(tmpDir, 'Projects') + const swiftbar = join(projectsRoot, 'Swiftbar') + const contentOs = join(projectsRoot, 'Content-OS') + await mkdir(join(projectsRoot, '.git'), { recursive: true }) + await mkdir(swiftbar, { recursive: true }) + await mkdir(contentOs, { recursive: true }) + + await writeClaudeSession( + 'tmp-Projects-Swiftbar', + 'swiftbar-session', + swiftbar, + '2099-05-10T10:00:00.000Z', + ) + await writeClaudeSession( + 'tmp-Projects-Content-OS', + 'content-os-session', + contentOs, + '2099-05-10T11:00:00.000Z', + ) + + const projects = await parseAllSessions(dayRange('2099-05-10'), 'claude') + const projectPaths = projects.map(project => project.projectPath).sort() + + expect(projects).toHaveLength(2) + expect(projectPaths).toEqual([contentOs, swiftbar].sort()) + expect(projectPaths).not.toContain(projectsRoot) + }) + + it('groups git worktrees under the main repository project', async () => { + const mainRepo = join(tmpDir, 'repos', 'codeburn') + const worktreeA = join(tmpDir, 'worktrees', 'codeburn-feature-a') + const worktreeB = join(tmpDir, 'worktrees', 'codeburn-feature-b') + await mkdir(join(mainRepo, '.git', 'worktrees', 'feature-a'), { recursive: true }) + await mkdir(join(mainRepo, '.git', 'worktrees', 'feature-b'), { recursive: true }) + await mkdir(worktreeA, { recursive: true }) + await mkdir(worktreeB, { recursive: true }) + await writeFile(join(worktreeA, '.git'), `gitdir: ${join(mainRepo, '.git', 'worktrees', 'feature-a')}\n`) + await writeFile(join(worktreeB, '.git'), `gitdir: ${relative(worktreeB, join(mainRepo, '.git', 'worktrees', 'feature-b'))}\n`) + + await writeClaudeSession( + 'tmp-worktrees-codeburn-feature-a', + 'worktree-a-session', + worktreeA, + '2099-05-07T10:00:00.000Z', + ) + await writeClaudeSession( + 'tmp-worktrees-codeburn-feature-b', + 'worktree-b-session', + worktreeB, + '2099-05-07T11:00:00.000Z', + ) + + const projects = await parseAllSessions(dayRange('2099-05-07'), 'claude') + + expect(projects).toHaveLength(1) + expect(projects[0]!.project).toBe('codeburn') + expect(projects[0]!.projectPath).toBe(mainRepo) + expect(projects[0]!.sessions).toHaveLength(2) + expect(projects[0]!.totalApiCalls).toBe(2) + expect(projects[0]!.sessions.map(s => s.sessionId).sort()).toEqual([ + 'worktree-a-session', + 'worktree-b-session', + ]) + }) + + it('does not group separate-git-dir projects that are not git worktrees', async () => { + const externalGitDir = join(tmpDir, 'external-git-dirs', 'project.git') + const projectDir = join(tmpDir, 'standalone', 'separate-git-dir') + await mkdir(externalGitDir, { recursive: true }) + await mkdir(projectDir, { recursive: true }) + await writeFile(join(projectDir, '.git'), `gitdir: ${externalGitDir}\n`) + + await writeClaudeSession( + 'tmp-standalone-separate-git-dir', + 'separate-git-dir-session', + projectDir, + '2099-05-08T10:00:00.000Z', + ) + + const projects = await parseAllSessions(dayRange('2099-05-08'), 'claude') + + expect(projects).toHaveLength(1) + expect(projects[0]!.projectPath).toBe(projectDir) + expect(projects[0]!.project).toBe('tmp-standalone-separate-git-dir') + }) +}) + +describe('Claude cache creation pricing', () => { + it('prices 1-hour cache writes from usage.cache_creation at the 2x input rate', async () => { + await writeClaudeSession( + 'cache-pricing', + 'one-hour-cache', + '/tmp/cache-pricing', + '2099-05-05T10:00:00.000Z', + { + input_tokens: 0, + output_tokens: 0, + cache_creation_input_tokens: 60_120, + cache_creation: { + ephemeral_5m_input_tokens: 0, + ephemeral_1h_input_tokens: 60_120, + }, + }, + 'claude-opus-4-7', + ) + + const projects = await parseAllSessions(dayRange('2099-05-05'), 'claude') + + expect(projects).toHaveLength(1) + expect(projects[0]!.sessions[0]!.totalCacheWriteTokens).toBe(60_120) + expect(projects[0]!.totalCostUSD).toBeCloseTo(0.6012, 6) + }) + + it('falls back to the legacy 5-minute cache write rate when split fields are absent', async () => { + await writeClaudeSession( + 'legacy-cache-pricing', + 'legacy-cache', + '/tmp/legacy-cache-pricing', + '2099-05-06T10:00:00.000Z', + { + input_tokens: 0, + output_tokens: 0, + cache_creation_input_tokens: 60_120, + }, + 'claude-opus-4-7', + ) + + const projects = await parseAllSessions(dayRange('2099-05-06'), 'claude') + + expect(projects).toHaveLength(1) + expect(projects[0]!.sessions[0]!.totalCacheWriteTokens).toBe(60_120) + expect(projects[0]!.totalCostUSD).toBeCloseTo(0.37575, 6) + }) +}) + +// ── Helpers for Cowork local-agent-mode session fixtures ──────────────── + +async function writeCoworkSession(opts: { + desktopSessionsDir: string + appId: string + workspaceId: string + sessionId: string + spaceName?: string + spaceId?: string + userSelectedFolders?: string[] + title?: string + claudeSessionId: string + timestamp: string + usage?: Record<string, unknown> + model?: string +}): Promise<void> { + const { + desktopSessionsDir, appId, workspaceId, sessionId, + spaceName, spaceId, userSelectedFolders, title, + claudeSessionId, timestamp, + usage = { input_tokens: 100, output_tokens: 50 }, + model = 'claude-sonnet-4-5', + } = opts + + const workspaceDir = join(desktopSessionsDir, appId, workspaceId) + + // spaces.json — written only when a space is defined + await mkdir(workspaceDir, { recursive: true }) + if (spaceId && spaceName) { + await writeFile(join(workspaceDir, 'spaces.json'), JSON.stringify({ + spaces: [{ id: spaceId, name: spaceName, folders: [], projects: [] }], + })) + } + + // local_<sessionId>.json — session metadata + const outputsDir = join(workspaceDir, sessionId, 'outputs') + const sessionMeta: Record<string, unknown> = { + sessionId, + cwd: outputsDir, + title: title ?? (spaceName ? `Test session for ${spaceName}` : 'Untitled session'), + } + if (spaceId) sessionMeta['spaceId'] = spaceId + if (userSelectedFolders) sessionMeta['userSelectedFolders'] = userSelectedFolders + await writeFile(join(workspaceDir, `${sessionId}.json`), JSON.stringify(sessionMeta)) + + // .claude/projects/<slug>/session.jsonl — the actual token-bearing session + const projectSlug = outputsDir.replace(/[/\\]/g, '-').replace(/^-/, '') + const projectDir = join(workspaceDir, sessionId, '.claude', 'projects', projectSlug) + await mkdir(projectDir, { recursive: true }) + const filePath = join(projectDir, `${claudeSessionId}.jsonl`) + await writeFile(filePath, JSON.stringify({ + type: 'assistant', + sessionId: claudeSessionId, + timestamp, + cwd: outputsDir, + message: { + id: `msg-${claudeSessionId}`, + type: 'message', + role: 'assistant', + model, + content: [], + usage, + }, + }) + '\n') + const mtime = new Date(timestamp) + await utimes(filePath, mtime, mtime) +} + +describe('Claude Cowork local-agent-mode session grouping', () => { + it('groups multiple Cowork sessions from the same space under the space name', async () => { + const desktopSessionsDir = join(tmpDir, 'desktop-sessions') + const spaceId = 'space-001' + const spaceName = 'Project1' + + await writeCoworkSession({ + desktopSessionsDir, + appId: 'app-abc', + workspaceId: 'ws-001', + sessionId: 'local_aaaa', + spaceName, + spaceId, + claudeSessionId: 'session-a', + timestamp: '2099-06-01T10:00:00.000Z', + }) + + await writeCoworkSession({ + desktopSessionsDir, + appId: 'app-abc', + workspaceId: 'ws-001', + sessionId: 'local_bbbb', + spaceName, + spaceId, + claudeSessionId: 'session-b', + timestamp: '2099-06-01T11:00:00.000Z', + }) + + const projects = await parseAllSessions(dayRange('2099-06-01'), 'claude') + + expect(projects).toHaveLength(1) + expect(projects[0]!.project).toBe(spaceName) + expect(projects[0]!.sessions).toHaveLength(2) + expect(projects[0]!.sessions.map(s => s.sessionId).sort()).toEqual([ + 'session-a', + 'session-b', + ]) + }) + + it('keeps sessions from different spaces in separate projects', async () => { + const desktopSessionsDir = join(tmpDir, 'desktop-sessions') + + // Each space gets its own workspace so their spaces.json files don't overwrite each other. + await writeCoworkSession({ + desktopSessionsDir, + appId: 'app-abc', + workspaceId: 'ws-001', + sessionId: 'local_cccc', + spaceName: 'Project1', + spaceId: 'space-001', + claudeSessionId: 'session-c', + timestamp: '2099-06-02T10:00:00.000Z', + }) + + await writeCoworkSession({ + desktopSessionsDir, + appId: 'app-abc', + workspaceId: 'ws-002', + sessionId: 'local_dddd', + spaceName: 'Project2', + spaceId: 'space-002', + claudeSessionId: 'session-d', + timestamp: '2099-06-02T11:00:00.000Z', + }) + + const projects = await parseAllSessions(dayRange('2099-06-02'), 'claude') + + expect(projects).toHaveLength(2) + const names = projects.map(p => p.project).sort() + expect(names).toEqual(['Project1', 'Project2']) + }) + + it('falls back to userSelectedFolders[0] basename when no spaceId is set', async () => { + const desktopSessionsDir = join(tmpDir, 'desktop-sessions') + + await writeCoworkSession({ + desktopSessionsDir, + appId: 'app-abc', + workspaceId: 'ws-003', + sessionId: 'local_eeee', + userSelectedFolders: ['/home/user/projects/ParentFolder/SubFolder'], + title: 'Some session title', + claudeSessionId: 'session-e', + timestamp: '2099-06-03T10:00:00.000Z', + }) + + const projects = await parseAllSessions(dayRange('2099-06-03'), 'claude') + + expect(projects).toHaveLength(1) + expect(projects[0]!.project).toBe('SubFolder') + expect(projects[0]!.sessions).toHaveLength(1) + }) + + it('falls back to title when no spaceId and no userSelectedFolders', async () => { + const desktopSessionsDir = join(tmpDir, 'desktop-sessions') + + await writeCoworkSession({ + desktopSessionsDir, + appId: 'app-abc', + workspaceId: 'ws-004', + sessionId: 'local_ffff', + title: 'A standalone session task', + claudeSessionId: 'session-f', + timestamp: '2099-06-04T10:00:00.000Z', + }) + + const projects = await parseAllSessions(dayRange('2099-06-04'), 'claude') + + expect(projects).toHaveLength(1) + expect(projects[0]!.project).toBe('A standalone session task') + expect(projects[0]!.sessions).toHaveLength(1) + }) + + it('groups container-mode sessions (cwd=/sessions/<name>) under the space name', async () => { + const desktopSessionsDir = join(tmpDir, 'desktop-sessions') + const workspaceDir = join(desktopSessionsDir, 'app-abc', 'ws-006') + const sessionId = 'local_hhhh' + + // Set up workspace metadata (spaces.json + session .json with spaceId) + await mkdir(workspaceDir, { recursive: true }) + await writeFile(join(workspaceDir, 'spaces.json'), JSON.stringify({ + spaces: [{ id: 'space-001', name: 'Project1', folders: [], projects: [] }], + })) + const containerCwd = '/sessions/trusting-inspiring-ritchie' + await writeFile(join(workspaceDir, `${sessionId}.json`), JSON.stringify({ + sessionId, spaceId: 'space-001', cwd: containerCwd, title: 'Container session', + })) + + // Container-mode: project slug is derived from the container cwd, not outputs/ + const containerSlug = containerCwd.replace(/\//g, '-').replace(/^-/, '') + const projectDir = join(workspaceDir, sessionId, '.claude', 'projects', containerSlug) + await mkdir(projectDir, { recursive: true }) + const filePath = join(projectDir, 'container-session.jsonl') + await writeFile(filePath, JSON.stringify({ + type: 'assistant', + sessionId: 'container-session', + timestamp: '2099-06-06T10:00:00.000Z', + cwd: containerCwd, + message: { + id: 'msg-container', type: 'message', role: 'assistant', + model: 'claude-sonnet-4-5', content: [], + usage: { input_tokens: 100, output_tokens: 50 }, + }, + }) + '\n') + await utimes(filePath, new Date('2099-06-06T10:00:00.000Z'), new Date('2099-06-06T10:00:00.000Z')) + + const projects = await parseAllSessions(dayRange('2099-06-06'), 'claude') + + expect(projects).toHaveLength(1) + expect(projects[0]!.project).toBe('Project1') + expect(projects[0]!.projectPath).toBe('Project1') + expect(projects[0]!.sessions).toHaveLength(1) + }) + + it('falls back to sanitized directory slug when no session metadata exists', async () => { + const desktopSessionsDir = join(tmpDir, 'desktop-sessions') + const workspaceDir = join(desktopSessionsDir, 'app-abc', 'ws-005') + const sessionId = 'local_gggg' + const outputsDir = join(workspaceDir, sessionId, 'outputs') + const projectSlug = outputsDir.replace(/[/\\]/g, '-').replace(/^-/, '') + const projectDir = join(workspaceDir, sessionId, '.claude', 'projects', projectSlug) + await mkdir(projectDir, { recursive: true }) + + // No spaces.json or session .json at all + const filePath = join(projectDir, 'no-meta-session.jsonl') + await writeFile(filePath, JSON.stringify({ + type: 'assistant', + sessionId: 'no-meta-session', + timestamp: '2099-06-05T10:00:00.000Z', + cwd: outputsDir, + message: { + id: 'msg-no-meta', type: 'message', role: 'assistant', + model: 'claude-sonnet-4-5', content: [], + usage: { input_tokens: 100, output_tokens: 50 }, + }, + }) + '\n') + await utimes(filePath, new Date('2099-06-05T10:00:00.000Z'), new Date('2099-06-05T10:00:00.000Z')) + + const projects = await parseAllSessions(dayRange('2099-06-05'), 'claude') + + expect(projects).toHaveLength(1) + expect(projects[0]!.project).toBe(projectSlug) + expect(projects[0]!.sessions).toHaveLength(1) + }) +}) diff --git a/tests/parser-compact-entry.test.ts b/tests/parser-compact-entry.test.ts new file mode 100644 index 0000000..6777d94 --- /dev/null +++ b/tests/parser-compact-entry.test.ts @@ -0,0 +1,434 @@ +import { describe, it, expect } from 'vitest' + +import { compactEntry } from '../src/parser.js' +import type { JournalEntry } from '../src/types.js' + +function entry(overrides: Partial<JournalEntry> & Record<string, unknown>): JournalEntry { + return { type: 'user', ...overrides } as JournalEntry +} + +describe('compactEntry', () => { + it('preserves type, timestamp, sessionId, cwd', () => { + const raw = entry({ type: 'user', timestamp: 't1', sessionId: 's1', cwd: '/foo' }) + const c = compactEntry(raw) + expect(c.type).toBe('user') + expect(c.timestamp).toBe('t1') + expect(c.sessionId).toBe('s1') + expect(c.cwd).toBe('/foo') + }) + + it('strips unknown catch-all fields', () => { + const raw = entry({ + type: 'assistant', + toolResult: { type: 'tool_result', content: 'x'.repeat(10_000) }, + someHugeField: 'y'.repeat(10_000), + }) + const c = compactEntry(raw) + expect((c as Record<string, unknown>)['toolResult']).toBeUndefined() + expect((c as Record<string, unknown>)['someHugeField']).toBeUndefined() + }) + + it('preserves deferred_tools_delta attachment with copied names', () => { + const raw = entry({ + type: 'attachment', + attachment: { + type: 'deferred_tools_delta', + addedNames: ['mcp__svc__t1', 'Bash'], + extraData: 'should be dropped', + }, + }) + const c = compactEntry(raw) + const att = (c as Record<string, unknown>)['attachment'] as Record<string, unknown> + expect(att['type']).toBe('deferred_tools_delta') + expect(att['addedNames']).toEqual(['mcp__svc__t1', 'Bash']) + expect(att['extraData']).toBeUndefined() + }) + + it('copies addedNames into a new array (not by reference)', () => { + const originalNames = ['mcp__a__b', 'Bash'] + const raw = entry({ + type: 'attachment', + attachment: { type: 'deferred_tools_delta', addedNames: originalNames }, + }) + const c = compactEntry(raw) + const att = (c as Record<string, unknown>)['attachment'] as { addedNames: string[] } + expect(att.addedNames).not.toBe(originalNames) + expect(att.addedNames).toEqual(originalNames) + }) + + it('caps addedNames at 1000 entries', () => { + const names = Array.from({ length: 2000 }, (_, i) => `mcp__svc__t${i}`) + const raw = entry({ + type: 'attachment', + attachment: { type: 'deferred_tools_delta', addedNames: names }, + }) + const c = compactEntry(raw) + const att = (c as Record<string, unknown>)['attachment'] as { addedNames: string[] } + expect(att.addedNames).toHaveLength(1000) + }) + + it('filters non-string entries from addedNames', () => { + const raw = entry({ + type: 'attachment', + attachment: { type: 'deferred_tools_delta', addedNames: [42, null, 'mcp__a__b', undefined] }, + }) + const c = compactEntry(raw) + const att = (c as Record<string, unknown>)['attachment'] as { addedNames: string[] } + expect(att.addedNames).toEqual(['mcp__a__b']) + }) + + it('drops non-deferred_tools_delta attachments', () => { + const raw = entry({ + type: 'attachment', + attachment: { type: 'other', data: 'x'.repeat(10_000) }, + }) + const c = compactEntry(raw) + expect((c as Record<string, unknown>)['attachment']).toBeUndefined() + }) + + it('caps user message string content at 2000', () => { + const longText = 'a'.repeat(5000) + const raw = entry({ + type: 'user', + message: { role: 'user' as const, content: longText }, + }) + const c = compactEntry(raw) + expect(c.message!.role).toBe('user') + const content = (c.message as { content: string }).content + expect(content.length).toBe(2000) + }) + + it('caps total user text across all blocks at 2000', () => { + const raw = entry({ + type: 'user', + message: { + role: 'user' as const, + content: [ + { type: 'text' as const, text: 'a'.repeat(1500) }, + { type: 'text' as const, text: 'b'.repeat(1500) }, + { type: 'text' as const, text: 'c'.repeat(1500) }, + { type: 'image' as const, source: 'big data' }, + ], + }, + }) + const c = compactEntry(raw) + const content = (c.message as { content: Array<{ type: string; text: string }> }).content + expect(content).toHaveLength(2) + expect(content[0]!.text.length).toBe(1500) + expect(content[1]!.text.length).toBe(500) + }) + + it('compacts assistant tool_use blocks, dropping text and thinking, preserving id', () => { + const raw = entry({ + type: 'assistant', + timestamp: 't1', + message: { + type: 'message' as const, + role: 'assistant' as const, + model: 'claude-opus-4-6', + id: 'msg_123', + usage: { input_tokens: 100, output_tokens: 200 }, + content: [ + { type: 'text', text: 'x'.repeat(50_000) }, + { type: 'thinking', thinking: 'y'.repeat(50_000) }, + { type: 'tool_use', id: 'tu1', name: 'Read', input: { file_path: '/foo', huge: 'z'.repeat(10_000) } }, + { type: 'tool_use', id: 'tu2', name: 'Edit', input: { old_string: 'a'.repeat(5000), new_string: 'b'.repeat(5000) } }, + ], + }, + }) + const c = compactEntry(raw) + const msg = c.message as { content: Array<{ type: string; id?: string; name?: string; input?: Record<string, unknown> }> } + expect(msg.content).toHaveLength(2) + expect(msg.content[0]!.name).toBe('Read') + expect(msg.content[0]!.id).toBe('tu1') + expect(msg.content[0]!.input).toEqual({ file_path: '/foo' }) + expect(msg.content[1]!.name).toBe('Edit') + expect(msg.content[1]!.id).toBe('tu2') + expect(msg.content[1]!.input).toEqual({}) + }) + + it('caps tool_use blocks at 500 per message', () => { + const blocks = Array.from({ length: 600 }, (_, i) => ({ + type: 'tool_use' as const, + id: `tu${i}`, + name: `Tool${i}`, + input: {}, + })) + const raw = entry({ + type: 'assistant', + message: { + type: 'message' as const, + role: 'assistant' as const, + model: 'claude-opus-4-6', + usage: { input_tokens: 10, output_tokens: 10 }, + content: blocks, + }, + }) + const c = compactEntry(raw) + const msg = c.message as { content: unknown[] } + expect(msg.content).toHaveLength(500) + }) + + it('preserves model, usage (destructured), and id on assistant messages', () => { + const raw = entry({ + type: 'assistant', + message: { + type: 'message' as const, + role: 'assistant' as const, + model: 'claude-opus-4-6', + id: 'msg_abc', + usage: { + input_tokens: 50, + output_tokens: 100, + cache_read_input_tokens: 25, + extraGarbage: 'should not survive', + }, + content: [], + }, + }) + const c = compactEntry(raw) + const msg = c.message as { model: string; id: string; usage: Record<string, unknown> } + expect(msg.model).toBe('claude-opus-4-6') + expect(msg.id).toBe('msg_abc') + expect(msg.usage['input_tokens']).toBe(50) + expect(msg.usage['output_tokens']).toBe(100) + expect(msg.usage['cache_read_input_tokens']).toBe(25) + expect(msg.usage['extraGarbage']).toBeUndefined() + }) + + it('deep-copies usage nested objects, stripping extra keys', () => { + const cacheCreation = { ephemeral_5m_input_tokens: 100, ephemeral_1h_input_tokens: 200, extraJunk: 'big' } + const serverToolUse = { web_search_requests: 3, web_fetch_requests: 1, extraJunk: 'big' } + const raw = entry({ + type: 'assistant', + message: { + type: 'message' as const, + role: 'assistant' as const, + model: 'claude-opus-4-6', + usage: { + input_tokens: 10, + output_tokens: 10, + speed: 'fast', + cache_creation: cacheCreation, + server_tool_use: serverToolUse, + }, + content: [], + }, + }) + const c = compactEntry(raw) + const msg = c.message as { usage: Record<string, unknown> } + expect(msg.usage['speed']).toBe('fast') + const cc = msg.usage['cache_creation'] as Record<string, unknown> + expect(cc['ephemeral_5m_input_tokens']).toBe(100) + expect(cc['ephemeral_1h_input_tokens']).toBe(200) + expect(cc['extraJunk']).toBeUndefined() + expect(cc).not.toBe(cacheCreation) + const stu = msg.usage['server_tool_use'] as Record<string, unknown> + expect(stu['web_search_requests']).toBe(3) + expect(stu['web_fetch_requests']).toBe(1) + expect(stu['extraJunk']).toBeUndefined() + expect(stu).not.toBe(serverToolUse) + }) + + it('keeps Skill input.skill and input.name, type-checked and capped', () => { + const raw = entry({ + type: 'assistant', + message: { + type: 'message' as const, + role: 'assistant' as const, + model: 'claude-opus-4-6', + usage: { input_tokens: 10, output_tokens: 10 }, + content: [ + { type: 'tool_use', id: 'tu', name: 'Skill', input: { skill: 'graphify', args: 'huge arg data' } }, + ], + }, + }) + const c = compactEntry(raw) + const msg = c.message as { content: Array<{ input: Record<string, unknown> }> } + expect(msg.content[0]!.input['skill']).toBe('graphify') + expect(msg.content[0]!.input['args']).toBeUndefined() + }) + + it('rejects non-string Skill input.skill and caps long names', () => { + const raw = entry({ + type: 'assistant', + message: { + type: 'message' as const, + role: 'assistant' as const, + model: 'claude-opus-4-6', + usage: { input_tokens: 10, output_tokens: 10 }, + content: [ + { type: 'tool_use', id: 'tu1', name: 'Skill', input: { skill: { malicious: 'x'.repeat(10_000) } } }, + { type: 'tool_use', id: 'tu2', name: 'Skill', input: { skill: 'a'.repeat(500) } }, + ], + }, + }) + const c = compactEntry(raw) + const msg = c.message as { content: Array<{ input: Record<string, unknown> }> } + expect(msg.content[0]!.input['skill']).toBeUndefined() + expect((msg.content[1]!.input['skill'] as string).length).toBe(200) + }) + + it('keeps Bash input.command capped at 2000 for bash command extraction', () => { + const longCmd = 'npm run build && '.repeat(200) + const raw = entry({ + type: 'assistant', + message: { + type: 'message' as const, + role: 'assistant' as const, + model: 'claude-opus-4-6', + usage: { input_tokens: 10, output_tokens: 10 }, + content: [ + { type: 'tool_use', id: 'tu', name: 'Bash', input: { command: longCmd, description: 'big desc' } }, + ], + }, + }) + const c = compactEntry(raw) + const msg = c.message as { content: Array<{ input: Record<string, unknown> }> } + const cmd = msg.content[0]!.input['command'] as string + expect(cmd.length).toBe(2000) + expect(msg.content[0]!.input['description']).toBeUndefined() + }) + + it('keeps Read file_path capped and drops unrelated input fields', () => { + const raw = entry({ + type: 'assistant', + message: { + type: 'message' as const, + role: 'assistant' as const, + model: 'claude-opus-4-6', + usage: { input_tokens: 10, output_tokens: 10 }, + content: [ + { type: 'tool_use', id: 'tu', name: 'Read', input: { file_path: '/tmp/' + 'x'.repeat(3000), content: 'big' } }, + ], + }, + }) + const c = compactEntry(raw) + const msg = c.message as { content: Array<{ input: Record<string, unknown> }> } + expect((msg.content[0]!.input['file_path'] as string).length).toBe(2000) + expect(msg.content[0]!.input['content']).toBeUndefined() + }) + + it('keeps Agent subagent_type capped and drops prompt text', () => { + const raw = entry({ + type: 'assistant', + message: { + type: 'message' as const, + role: 'assistant' as const, + model: 'claude-opus-4-6', + usage: { input_tokens: 10, output_tokens: 10 }, + content: [ + { type: 'tool_use', id: 'tu', name: 'Agent', input: { subagent_type: 'reviewer'.repeat(50), prompt: 'big' } }, + ], + }, + }) + const c = compactEntry(raw) + const msg = c.message as { content: Array<{ input: Record<string, unknown> }> } + expect((msg.content[0]!.input['subagent_type'] as string).length).toBe(200) + expect(msg.content[0]!.input['prompt']).toBeUndefined() + }) + + it('handles entry with no message field', () => { + const raw = entry({ type: 'system', timestamp: 't1', cwd: '/x' }) + const c = compactEntry(raw) + expect(c.type).toBe('system') + expect(c.timestamp).toBe('t1') + expect(c.message).toBeUndefined() + }) + + it('handles assistant message with no usage (non-standard)', () => { + const raw = entry({ + type: 'assistant', + message: { + type: 'message' as const, + role: 'assistant' as const, + model: 'claude-opus-4-6', + content: [{ type: 'text', text: 'response' }], + }, + }) + const c = compactEntry(raw) + expect(c.message).toBeUndefined() + }) + + it('handles unexpected message role (neither user nor assistant)', () => { + const raw = entry({ + type: 'system', + message: { role: 'system' as never, content: 'sys prompt' }, + }) + const c = compactEntry(raw) + expect(c.message).toBeUndefined() + }) + + it('tolerates null elements in user content array', () => { + const raw = entry({ + type: 'user', + message: { + role: 'user' as const, + content: [null, undefined, { type: 'text', text: 'ok' }, 42, { type: 'text' }] as never, + }, + }) + const c = compactEntry(raw) + const content = (c.message as { content: Array<{ text: string }> }).content + expect(content).toHaveLength(1) + expect(content[0]!.text).toBe('ok') + }) + + it('tolerates assistant content that is not an array', () => { + const raw = entry({ + type: 'assistant', + message: { + type: 'message' as const, + role: 'assistant' as const, + model: 'claude-opus-4-6', + usage: { input_tokens: 10, output_tokens: 10 }, + content: 'not an array' as never, + }, + }) + const c = compactEntry(raw) + const msg = c.message as { content: unknown[] } + expect(msg.content).toEqual([]) + }) + + it('tolerates null elements in assistant content array', () => { + const raw = entry({ + type: 'assistant', + message: { + type: 'message' as const, + role: 'assistant' as const, + model: 'claude-opus-4-6', + usage: { input_tokens: 10, output_tokens: 10 }, + content: [null, { type: 'tool_use', id: 'tu1', name: 'Read', input: {} }, undefined] as never, + }, + }) + const c = compactEntry(raw) + const msg = c.message as { content: Array<{ name: string }> } + expect(msg.content).toHaveLength(1) + expect(msg.content[0]!.name).toBe('Read') + }) + + it('memory reduction: compacted entry is much smaller than raw', () => { + const hugeContent = Array.from({ length: 20 }, (_, i) => ({ + type: i % 2 === 0 ? 'text' : 'tool_result', + text: 'x'.repeat(100_000), + content: 'y'.repeat(100_000), + })) + const raw = entry({ + type: 'assistant', + timestamp: '2026-01-01T00:00:00', + message: { + type: 'message' as const, + role: 'assistant' as const, + model: 'claude-opus-4-6', + id: 'msg_1', + usage: { input_tokens: 1000, output_tokens: 500 }, + content: hugeContent as never, + }, + toolResult: { content: 'z'.repeat(500_000) }, + }) + const rawSize = JSON.stringify(raw).length + const compacted = compactEntry(raw) + const compactedSize = JSON.stringify(compacted).length + expect(rawSize).toBeGreaterThan(2_000_000) + expect(compactedSize).toBeLessThan(500) + }) +}) diff --git a/tests/parser-filter.test.ts b/tests/parser-filter.test.ts new file mode 100644 index 0000000..4c34722 --- /dev/null +++ b/tests/parser-filter.test.ts @@ -0,0 +1,82 @@ +import { describe, it, expect } from 'vitest' + +import { filterProjectsByName } from '../src/parser.js' +import type { ProjectSummary } from '../src/types.js' + +function makeProject(project: string, projectPath = project): ProjectSummary { + return { + project, + projectPath, + sessions: [], + totalCostUSD: 0, + totalApiCalls: 0, + } +} + +describe('filterProjectsByName', () => { + const projects = [ + makeProject('codeburn', '/Users/alice/codeburn'), + makeProject('AgentSeal', '/Users/alice/projects/AgentSeal'), + makeProject('dashboard', '/Users/alice/AgentSeal/dashboard'), + makeProject('sandbox', '/tmp/sandbox'), + ] + + it('returns all projects when no filters given', () => { + expect(filterProjectsByName(projects)).toEqual(projects) + expect(filterProjectsByName(projects, [], [])).toEqual(projects) + expect(filterProjectsByName(projects, undefined, undefined)).toEqual(projects) + }) + + it('include matches project name (case-insensitive substring)', () => { + const result = filterProjectsByName(projects, ['codeburn']) + expect(result.map(p => p.project)).toEqual(['codeburn']) + }) + + it('include is case-insensitive', () => { + const result = filterProjectsByName(projects, ['AGENTSEAL']) + expect(result.map(p => p.project).sort()).toEqual(['AgentSeal', 'dashboard']) + }) + + it('include matches substring in path when name does not match', () => { + const result = filterProjectsByName(projects, ['alice/projects']) + expect(result.map(p => p.project)).toEqual(['AgentSeal']) + }) + + it('include uses OR semantics across patterns', () => { + const result = filterProjectsByName(projects, ['codeburn', 'sandbox']) + expect(result.map(p => p.project).sort()).toEqual(['codeburn', 'sandbox']) + }) + + it('exclude removes matching projects (AND-negation across patterns)', () => { + const result = filterProjectsByName(projects, undefined, ['codeburn', 'sandbox']) + expect(result.map(p => p.project).sort()).toEqual(['AgentSeal', 'dashboard']) + }) + + it('exclude matches path substring', () => { + const result = filterProjectsByName(projects, undefined, ['/tmp']) + expect(result.map(p => p.project)).not.toContain('sandbox') + }) + + it('exclude is applied after include', () => { + const result = filterProjectsByName(projects, ['AgentSeal'], ['dashboard']) + expect(result.map(p => p.project)).toEqual(['AgentSeal']) + }) + + it('returns empty array when no project matches include', () => { + expect(filterProjectsByName(projects, ['does-not-exist'])).toEqual([]) + }) + + it('empty-string pattern matches every project', () => { + const resultInclude = filterProjectsByName(projects, ['']) + expect(resultInclude).toHaveLength(projects.length) + const resultExclude = filterProjectsByName(projects, undefined, ['']) + expect(resultExclude).toEqual([]) + }) + + it('does not mutate the input array', () => { + const input = [makeProject('a'), makeProject('b')] + const snapshot = [...input] + filterProjectsByName(input, ['a'], ['b']) + expect(input).toEqual(snapshot) + }) +}) diff --git a/tests/parser-gemini-cache.test.ts b/tests/parser-gemini-cache.test.ts new file mode 100644 index 0000000..c2542b6 --- /dev/null +++ b/tests/parser-gemini-cache.test.ts @@ -0,0 +1,126 @@ +import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' + +import { afterEach, beforeEach, describe, expect, it } from 'vitest' + +import { clearSessionCache, parseAllSessions } from '../src/parser.js' +import { CACHE_VERSION, computeEnvFingerprint } from '../src/session-cache.js' +import type { DateRange } from '../src/types.js' + +let home: string +let cacheDir: string + +beforeEach(async () => { + home = await mkdtemp(join(tmpdir(), 'codeburn-gemini-home-')) + cacheDir = await mkdtemp(join(tmpdir(), 'codeburn-gemini-cache-')) + process.env['HOME'] = home + process.env['CODEBURN_CACHE_DIR'] = cacheDir +}) + +afterEach(async () => { + clearSessionCache() + await rm(home, { recursive: true, force: true }) + await rm(cacheDir, { recursive: true, force: true }) +}) + +describe('Gemini session cache migration', () => { + it('reparses cached legacy aggregate Gemini entries into granular calls', async () => { + const chatsDir = join(home, '.gemini', 'tmp', 'project-a', 'chats') + await mkdir(chatsDir, { recursive: true }) + const sessionPath = join(chatsDir, 'session-2026-05-16.json') + await writeFile(sessionPath, JSON.stringify({ + sessionId: 'gemini-session-1', + startTime: '2026-05-16T10:00:00.000Z', + messages: [ + { id: 'u1', timestamp: '2026-05-16T10:00:00.000Z', type: 'user', content: 'work' }, + { + id: 'g1', + timestamp: '2026-05-16T10:00:05.000Z', + type: 'gemini', + content: 'first', + model: 'gemini-3.1-pro-preview', + tokens: { input: 10, output: 5 }, + }, + { + id: 'g2', + timestamp: '2026-05-16T10:00:10.000Z', + type: 'gemini', + content: 'second', + model: 'gemini-3.1-pro-preview', + tokens: { input: 12, output: 6 }, + }, + ], + })) + + const fileStat = await stat(sessionPath) + await writeFile(join(cacheDir, 'session-cache.json'), JSON.stringify({ + version: CACHE_VERSION, + providers: { + gemini: { + envFingerprint: computeEnvFingerprint('gemini'), + files: { + [sessionPath]: { + fingerprint: { + dev: fileStat.dev, + ino: fileStat.ino, + mtimeMs: fileStat.mtimeMs, + sizeBytes: fileStat.size, + }, + mcpInventory: [], + turns: [{ + timestamp: '2026-05-16T10:00:00.000Z', + sessionId: 'gemini-session-1', + userMessage: 'work', + calls: [{ + provider: 'gemini', + model: 'gemini-3.1-pro-preview', + usage: { + inputTokens: 22, + outputTokens: 11, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + cacheCreationOneHourTokens: 0, + }, + speed: 'standard', + timestamp: '2026-05-16T10:00:00.000Z', + tools: [], + bashCommands: [], + skills: [], + deduplicationKey: 'gemini:gemini-session-1', + }], + }], + }, + }, + }, + }, + })) + + const range: DateRange = { + start: new Date('2026-05-16T00:00:00.000Z'), + end: new Date('2026-05-16T23:59:59.999Z'), + } + + const projects = await parseAllSessions(range, 'gemini') + const keys = projects.flatMap(project => + project.sessions.flatMap(session => + session.turns.flatMap(turn => turn.assistantCalls.map(call => call.deduplicationKey)), + ), + ) + + expect(projects[0]!.totalApiCalls).toBe(2) + expect(keys).toEqual([ + 'gemini:gemini-session-1:g1', + 'gemini:gemini-session-1:g2', + ]) + + const savedCache = JSON.parse(await readFile(join(cacheDir, 'session-cache.json'), 'utf-8')) + const savedKeys = savedCache.providers.gemini.files[sessionPath].turns.flatMap((turn: { calls: Array<{ deduplicationKey: string }> }) => + turn.calls.map(call => call.deduplicationKey), + ) + expect(savedKeys).toEqual(keys) + }) +}) diff --git a/tests/parser-large-json-scanner.test.ts b/tests/parser-large-json-scanner.test.ts new file mode 100644 index 0000000..af0668b --- /dev/null +++ b/tests/parser-large-json-scanner.test.ts @@ -0,0 +1,87 @@ +import { describe, expect, it } from 'vitest' + +import { parseJsonlLine } from '../src/parser.js' + +function largeUserLine(): string { + return JSON.stringify({ + type: 'user', + sessionId: 's1', + timestamp: '2026-05-01T00:00:00Z', + cwd: '/repo', + message: { + role: 'user', + content: [ + { type: 'image', source: { data: 'x'.repeat(40_000) } }, + { type: 'text', text: 'hello ' + 'a'.repeat(3000) }, + ], + }, + }) +} + +function largeAssistantLine(): string { + return JSON.stringify({ + type: 'assistant', + sessionId: 's1', + timestamp: '2026-05-01T00:00:01Z', + cwd: '/repo', + message: { + id: 'm1', + type: 'message', + role: 'assistant', + model: 'claude-sonnet-4-5', + content: [ + { type: 'text', text: 'x'.repeat(40_000) }, + { type: 'tool_use', id: 'read1', name: 'Read', input: { file_path: '/tmp/file.ts', content: 'drop me' } }, + { type: 'tool_use', id: 'agent1', name: 'Agent', input: { subagent_type: 'reviewer', prompt: 'drop me' } }, + ], + usage: { + input_tokens: 100, + output_tokens: 20, + cache_read_input_tokens: 300, + }, + }, + }) +} + +describe('large JSONL compact scanner', () => { + it('extracts user text from array content without full JSON.parse', () => { + const parsed = parseJsonlLine(largeUserLine()) + expect(parsed?.type).toBe('user') + const content = parsed?.message?.role === 'user' ? parsed.message.content : '' + expect(content).toBeTypeOf('string') + expect((content as string).startsWith('hello ')).toBe(true) + expect((content as string).length).toBe(2000) + }) + + it('extracts capped tool inputs needed by optimize', () => { + const parsed = parseJsonlLine(Buffer.from(largeAssistantLine())) + const msg = parsed?.message + expect(msg?.role).toBe('assistant') + if (msg?.role !== 'assistant') return + expect(msg.usage.input_tokens).toBe(100) + expect(msg.usage.output_tokens).toBe(20) + expect(msg.usage.cache_read_input_tokens).toBe(300) + expect(msg.content).toEqual([ + { type: 'tool_use', id: 'read1', name: 'Read', input: { file_path: '/tmp/file.ts' } }, + { type: 'tool_use', id: 'agent1', name: 'Agent', input: { subagent_type: 'reviewer' } }, + ]) + }) + + it('extracts deferred MCP inventory from large attachment lines', () => { + const line = JSON.stringify({ + type: 'attachment', + sessionId: 's1', + timestamp: '2026-05-01T00:00:02Z', + padding: 'x'.repeat(40_000), + attachment: { + type: 'deferred_tools_delta', + addedNames: ['Bash', 'mcp__svc__tool'], + }, + }) + const parsed = parseJsonlLine(Buffer.from(line)) as Record<string, unknown> + expect(parsed['attachment']).toEqual({ + type: 'deferred_tools_delta', + addedNames: ['Bash', 'mcp__svc__tool'], + }) + }) +}) diff --git a/tests/parser-large-session.test.ts b/tests/parser-large-session.test.ts new file mode 100644 index 0000000..9ef1b8b --- /dev/null +++ b/tests/parser-large-session.test.ts @@ -0,0 +1,236 @@ +import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' + +import { describe, expect, it, beforeEach, afterEach } from 'vitest' + +import { parseAllSessions, clearSessionCache } from '../src/parser.js' +import type { DateRange } from '../src/types.js' + +let home: string + +beforeEach(async () => { + home = await mkdtemp(join(tmpdir(), 'codeburn-large-')) + process.env['CLAUDE_CONFIG_DIR'] = join(home, '.claude') +}) + +afterEach(async () => { + clearSessionCache() + await rm(home, { recursive: true, force: true }) +}) + +function userLine(sessionId: string, timestamp: string, textSize = 100): string { + return JSON.stringify({ + type: 'user', + sessionId, + timestamp, + cwd: '/projects/app', + message: { role: 'user', content: 'x'.repeat(textSize) }, + }) +} + +function assistantLine(sessionId: string, timestamp: string, messageId: string, opts?: { + contentSize?: number + toolCount?: number +}): string { + const contentSize = opts?.contentSize ?? 0 + const toolCount = opts?.toolCount ?? 1 + const content: unknown[] = [] + if (contentSize > 0) { + content.push({ type: 'text', text: 'y'.repeat(contentSize) }) + content.push({ type: 'thinking', thinking: 'z'.repeat(contentSize) }) + } + for (let i = 0; i < toolCount; i++) { + content.push({ + type: 'tool_use', + id: `tu-${i}`, + name: i === 0 ? 'Edit' : 'Read', + input: { file_path: '/tmp/x', big: 'w'.repeat(contentSize) }, + }) + } + return JSON.stringify({ + type: 'assistant', + sessionId, + timestamp, + message: { + id: messageId, + type: 'message', + role: 'assistant', + model: 'claude-sonnet-4-5', + content, + usage: { input_tokens: 1000, output_tokens: 100 }, + }, + }) +} + +function messageFirstLargeAssistantLine(sessionId: string, timestamp: string, messageId: string): string { + const hugeText = 'y'.repeat(3_000_000) + return `{"parentUuid":"u1","isSidechain":false,"message":{"model":"claude-sonnet-4-5","id":"${messageId}","type":"message","role":"assistant","content":[{"type":"text","text":"${hugeText}"},{"type":"tool_use","id":"tu-large","name":"Edit","input":{"file_path":"/tmp/x","old_string":"a","new_string":"b"}}],"usage":{"input_tokens":1000,"output_tokens":100,"cache_read_input_tokens":5000}},"uuid":"a1","timestamp":"${timestamp}","type":"assistant","sessionId":"${sessionId}","cwd":"/projects/app"}` +} + +function attachmentLine(sessionId: string, timestamp: string): string { + return JSON.stringify({ + type: 'attachment', + sessionId, + timestamp, + attachment: { + type: 'deferred_tools_delta', + addedNames: ['Bash', 'Edit', 'Read', 'mcp__hf__hub_search'], + }, + }) +} + +describe('parseAllSessions with large Claude fixture', () => { + it('correctly parses sessions with bulky text/thinking/tool_result blocks', async () => { + const projectDir = join(home, '.claude', 'projects', 'bigapp') + await mkdir(projectDir, { recursive: true }) + + const lines: string[] = [] + lines.push(attachmentLine('s1', '2026-04-10T09:00:00Z')) + for (let i = 0; i < 50; i++) { + const ts = `2026-04-10T${String(9 + Math.floor(i / 10)).padStart(2, '0')}:${String((i % 10) * 5).padStart(2, '0')}:00Z` + lines.push(userLine('s1', ts, 5000)) + lines.push(assistantLine('s1', ts.replace(':00Z', ':30Z'), `msg-${i}`, { + contentSize: 50_000, + toolCount: 3, + })) + } + + await writeFile(join(projectDir, 'session.jsonl'), lines.join('\n')) + + const range: DateRange = { + start: new Date('2026-04-10T00:00:00Z'), + end: new Date('2026-04-10T23:59:59Z'), + } + + const projects = await parseAllSessions(range, 'claude') + + expect(projects.length).toBeGreaterThan(0) + const proj = projects[0]! + expect(proj.totalApiCalls).toBe(50) + expect(proj.totalCostUSD).toBeGreaterThan(0) + + const sess = proj.sessions[0]! + expect(sess.turns.length).toBe(50) + + for (const turn of sess.turns) { + expect(turn.userMessage.length).toBeLessThanOrEqual(2000) + expect(turn.assistantCalls.length).toBe(1) + const call = turn.assistantCalls[0]! + expect(call.tools).toContain('Edit') + expect(call.tools).toContain('Read') + expect(call.model).toBe('claude-sonnet-4-5') + } + + expect(sess.mcpInventory).toContain('mcp__hf__hub_search') + }) + + it('handles malformed JSONL lines without crashing', async () => { + const projectDir = join(home, '.claude', 'projects', 'baddata') + await mkdir(projectDir, { recursive: true }) + + const lines = [ + 'not json at all', + '{"type": "user", "sessionId": "s1", "timestamp": "2026-04-10T10:00:00Z", "message": {"role": "user", "content": [null, {"type": "text", "text": "hello"}, 42]}}', + '{"type": "assistant", "sessionId": "s1", "timestamp": "2026-04-10T10:01:00Z", "message": {"id": "m1", "type": "message", "role": "assistant", "model": "claude-sonnet-4-5", "content": "not-an-array", "usage": {"input_tokens": 100, "output_tokens": 50}}}', + '{"type": "assistant", "sessionId": "s1", "timestamp": "2026-04-10T10:02:00Z", "message": {"id": "m2", "type": "message", "role": "assistant", "model": "claude-sonnet-4-5", "content": [null, {"type": "tool_use", "id": "t1", "name": "Read", "input": {}}], "usage": {"input_tokens": 100, "output_tokens": 50}}}', + ] + + await writeFile(join(projectDir, 'session.jsonl'), lines.join('\n')) + + const range: DateRange = { + start: new Date('2026-04-10T00:00:00Z'), + end: new Date('2026-04-10T23:59:59Z'), + } + + const projects = await parseAllSessions(range, 'claude') + expect(projects.length).toBeGreaterThan(0) + + const sess = projects[0]!.sessions[0]! + expect(sess.apiCalls).toBeGreaterThanOrEqual(1) + }) + + it('discovers direct Claude subagent JSONL files under a project directory', async () => { + const projectDir = join(home, '.claude', 'projects', 'direct-subagents') + const subagentsDir = join(projectDir, 'subagents') + await mkdir(subagentsDir, { recursive: true }) + + const lines = [ + userLine('subagent-session', '2026-04-10T10:00:00Z', 100), + assistantLine('subagent-session', '2026-04-10T10:01:00Z', 'subagent-msg', { + contentSize: 0, + toolCount: 2, + }), + ] + await writeFile(join(subagentsDir, 'worker.jsonl'), lines.join('\n')) + + const range: DateRange = { + start: new Date('2026-04-10T00:00:00Z'), + end: new Date('2026-04-10T23:59:59Z'), + } + + const projects = await parseAllSessions(range, 'claude') + + expect(projects).toHaveLength(1) + const session = projects[0]!.sessions[0]! + expect(session.sessionId).toBe('worker') + expect(session.apiCalls).toBe(1) + expect(session.toolBreakdown['Edit']?.calls).toBe(1) + expect(session.toolBreakdown['Read']?.calls).toBe(1) + }) + + it('discovers nested Claude subagent JSONL files under a direct subagents directory', async () => { + const projectDir = join(home, '.claude', 'projects', 'nested-subagents') + const nestedSubagentsDir = join(projectDir, 'subagents', 'subagents') + await mkdir(nestedSubagentsDir, { recursive: true }) + + const lines = [ + userLine('nested-subagent-session', '2026-04-10T11:00:00Z', 100), + assistantLine('nested-subagent-session', '2026-04-10T11:01:00Z', 'nested-subagent-msg', { + contentSize: 0, + toolCount: 1, + }), + ] + await writeFile(join(nestedSubagentsDir, 'worker.jsonl'), lines.join('\n')) + + const range: DateRange = { + start: new Date('2026-04-10T00:00:00Z'), + end: new Date('2026-04-10T23:59:59Z'), + } + + const projects = await parseAllSessions(range, 'claude') + + expect(projects).toHaveLength(1) + const session = projects[0]!.sessions[0]! + expect(session.sessionId).toBe('worker') + expect(session.apiCalls).toBe(1) + expect(session.toolBreakdown['Edit']?.calls).toBe(1) + }) + + it('parses huge message-first assistant lines without full JSON.parse expansion', async () => { + const projectDir = join(home, '.claude', 'projects', 'messagefirst') + await mkdir(projectDir, { recursive: true }) + + const lines = [ + userLine('s1', '2026-04-10T10:00:00Z', 100), + messageFirstLargeAssistantLine('s1', '2026-04-10T10:00:01Z', 'msg-large'), + ] + + await writeFile(join(projectDir, 'session.jsonl'), lines.join('\n')) + + const range: DateRange = { + start: new Date('2026-04-10T00:00:00Z'), + end: new Date('2026-04-10T23:59:59Z'), + } + + const projects = await parseAllSessions(range, 'claude') + expect(projects.length).toBeGreaterThan(0) + + const sess = projects[0]!.sessions[0]! + expect(sess.apiCalls).toBe(1) + expect(sess.totalInputTokens).toBe(1000) + expect(sess.totalOutputTokens).toBe(100) + expect(sess.totalCacheReadTokens).toBe(5000) + expect(sess.toolBreakdown['Edit']?.calls).toBe(1) + }) +}) diff --git a/tests/parser-local-savings.test.ts b/tests/parser-local-savings.test.ts new file mode 100644 index 0000000..ae5dd25 --- /dev/null +++ b/tests/parser-local-savings.test.ts @@ -0,0 +1,131 @@ +import { mkdtemp, mkdir, rm, writeFile } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' +import { afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest' + +import { + setLocalModelSavings, + setModelAliases, + loadPricing, +} from '../src/models.js' +import { parseAllSessions, clearSessionCache } from '../src/parser.js' +import type { DateRange } from '../src/types.js' + +const FIXTURE_DAY = Date.UTC(2026, 3, 16) +const RANGE_START = new Date(FIXTURE_DAY - 24 * 60 * 60 * 1000) +const RANGE_END = new Date(FIXTURE_DAY + 24 * 60 * 60 * 1000) + +function makeRange(): DateRange { + return { start: RANGE_START, end: RANGE_END } +} + +let tmpDirs: string[] = [] + +beforeAll(async () => { + await loadPricing() +}) + +beforeEach(() => { + setLocalModelSavings({}) + setModelAliases({}) +}) + +afterEach(async () => { + delete (Object.prototype as Record<string, unknown>).calls + clearSessionCache() + while (tmpDirs.length > 0) { + const d = tmpDirs.pop() + if (d) await rm(d, { recursive: true, force: true }) + } +}) + +async function setupLocalModelSession(modelName: string): Promise<string> { + const base = await mkdtemp(join(tmpdir(), 'codeburn-savings-')) + tmpDirs.push(base) + const projectDir = join(base, 'projects', 'p') + await mkdir(projectDir, { recursive: true }) + // Use a synthetic local-style model name and a small known token count. + const file = join(projectDir, 's1.jsonl') + const ts = '2026-04-16T10:00:00.000Z' + const line = JSON.stringify({ + type: 'assistant', + timestamp: ts, + sessionId: 's1', + message: { + type: 'message', + role: 'assistant', + model: modelName, + id: 'msg-1', + content: [], + usage: { + input_tokens: 1000, + output_tokens: 200, + cache_creation_input_tokens: 0, + cache_read_input_tokens: 0, + }, + }, + }) + await writeFile(file, line + '\n', 'utf-8') + process.env['CLAUDE_CONFIG_DIR'] = base + return base +} + +describe('local-model savings: end-to-end', () => { + it('keeps an unconfigured local model at $0 with no savings recorded', async () => { + await setupLocalModelSession('llama3.1:8b') + const projects = await parseAllSessions(makeRange(), 'all') + const allCalls = projects.flatMap(p => p.sessions.flatMap(s => s.turns.flatMap(t => t.assistantCalls))) + expect(allCalls.length).toBeGreaterThan(0) + for (const c of allCalls) { + expect(c.costUSD).toBe(0) + expect(c.savingsUSD ?? 0).toBe(0) + expect(c.isLocalSavings).toBeFalsy() + } + }) + + it('records savings and forces cost to 0 when a local model has a savings mapping', async () => { + await setupLocalModelSession('llama3.1:8b') + setLocalModelSavings({ 'llama3.1:8b': 'gpt-4o' }) + clearSessionCache() + const projects = await parseAllSessions(makeRange(), 'all') + const allCalls = projects.flatMap(p => p.sessions.flatMap(s => s.turns.flatMap(t => t.assistantCalls))) + expect(allCalls.length).toBeGreaterThan(0) + for (const c of allCalls) { + expect(c.costUSD).toBe(0) + expect(c.savingsUSD).toBeGreaterThan(0) + expect(c.savingsBaselineModel).toBe('gpt-4o') + expect(c.isLocalSavings).toBe(true) + } + // Session and project rollups surface the savings total. + const totalSavings = projects.reduce((s, p) => s + p.totalSavingsUSD, 0) + expect(totalSavings).toBeGreaterThan(0) + }) + + it('does not apply savings for a model that has no mapping', async () => { + await setupLocalModelSession('qwen2.5:32b') + setLocalModelSavings({ 'unrelated:1b': 'gpt-4o' }) + clearSessionCache() + const projects = await parseAllSessions(makeRange(), 'all') + const allCalls = projects.flatMap(p => p.sessions.flatMap(s => s.turns.flatMap(t => t.assistantCalls))) + for (const c of allCalls) { + expect(c.savingsUSD ?? 0).toBe(0) + } + }) + + it('forces a $0 cost even when the same model is also in modelAliases', async () => { + // The local-savings path is meant to win for actual cost: spending + // config semantics say "this is local, track counterfactual", so + // even a stale modelAliases entry must not cause us to charge real + // dollars for a local call. + await setupLocalModelSession('llama3.1:8b') + setModelAliases({ 'llama3.1:8b': 'gpt-4o' }) + setLocalModelSavings({ 'llama3.1:8b': 'gpt-4o' }) + clearSessionCache() + const projects = await parseAllSessions(makeRange(), 'all') + const allCalls = projects.flatMap(p => p.sessions.flatMap(s => s.turns.flatMap(t => t.assistantCalls))) + for (const c of allCalls) { + expect(c.costUSD).toBe(0) + expect(c.savingsUSD).toBeGreaterThan(0) + } + }) +}) diff --git a/tests/parser-mcp-inventory.test.ts b/tests/parser-mcp-inventory.test.ts new file mode 100644 index 0000000..cbbe34c --- /dev/null +++ b/tests/parser-mcp-inventory.test.ts @@ -0,0 +1,126 @@ +import { describe, it, expect } from 'vitest' + +import { extractMcpInventory } from '../src/parser.js' +import type { JournalEntry } from '../src/types.js' + +function entry(overrides: Partial<JournalEntry> & Record<string, unknown>): JournalEntry { + return { type: 'attachment', ...overrides } as JournalEntry +} + +describe('extractMcpInventory', () => { + it('returns empty array when no entries have an attachment', () => { + expect(extractMcpInventory([entry({ type: 'user' })])).toEqual([]) + }) + + it('returns empty array when no deferred_tools_delta is present', () => { + expect(extractMcpInventory([ + entry({ attachment: { type: 'something_else', addedNames: ['mcp__a__b'] } }), + ])).toEqual([]) + }) + + it('extracts mcp__server__tool names from a single delta', () => { + const result = extractMcpInventory([ + entry({ + attachment: { + type: 'deferred_tools_delta', + addedNames: ['Bash', 'Edit', 'mcp__hf__hub_repo_search', 'mcp__hf__paper_search'], + }, + }), + ]) + expect(result).toEqual(['mcp__hf__hub_repo_search', 'mcp__hf__paper_search']) + }) + + it('filters out built-in tools (no mcp__ prefix)', () => { + const result = extractMcpInventory([ + entry({ + attachment: { + type: 'deferred_tools_delta', + addedNames: ['Bash', 'Edit', 'WebFetch', 'mcp__svc__t1'], + }, + }), + ]) + expect(result).toEqual(['mcp__svc__t1']) + }) + + it('rejects malformed names: empty server segment', () => { + const result = extractMcpInventory([ + entry({ + attachment: { + type: 'deferred_tools_delta', + addedNames: ['mcp____tool', 'mcp__svc__t1'], + }, + }), + ]) + expect(result).toEqual(['mcp__svc__t1']) + }) + + it('rejects malformed names: missing tool segment (no second `__`)', () => { + const result = extractMcpInventory([ + entry({ + attachment: { + type: 'deferred_tools_delta', + addedNames: ['mcp__server', 'mcp__svc__t1'], + }, + }), + ]) + expect(result).toEqual(['mcp__svc__t1']) + }) + + it('rejects malformed names: empty tool segment (trailing `__`)', () => { + const result = extractMcpInventory([ + entry({ + attachment: { + type: 'deferred_tools_delta', + addedNames: ['mcp__server__', 'mcp__svc__t1'], + }, + }), + ]) + expect(result).toEqual(['mcp__svc__t1']) + }) + + it('unions across multiple delta entries (incremental adds)', () => { + const result = extractMcpInventory([ + entry({ attachment: { type: 'deferred_tools_delta', addedNames: ['mcp__a__t1'] } }), + entry({ attachment: { type: 'deferred_tools_delta', addedNames: ['mcp__a__t2', 'mcp__b__t1'] } }), + ]) + expect(result).toEqual(['mcp__a__t1', 'mcp__a__t2', 'mcp__b__t1']) + }) + + it('deduplicates names seen in multiple deltas', () => { + const result = extractMcpInventory([ + entry({ attachment: { type: 'deferred_tools_delta', addedNames: ['mcp__a__t1', 'mcp__a__t1'] } }), + entry({ attachment: { type: 'deferred_tools_delta', addedNames: ['mcp__a__t1'] } }), + ]) + expect(result).toEqual(['mcp__a__t1']) + }) + + it('tolerates missing or non-string addedNames', () => { + const result = extractMcpInventory([ + entry({ attachment: { type: 'deferred_tools_delta' } }), + entry({ attachment: { type: 'deferred_tools_delta', addedNames: 'not-an-array' } }), + entry({ attachment: { type: 'deferred_tools_delta', addedNames: [42, null, 'mcp__svc__t1', undefined] } }), + ]) + expect(result).toEqual(['mcp__svc__t1']) + }) + + it('tolerates malformed attachment object', () => { + const result = extractMcpInventory([ + entry({ attachment: null }), + entry({ attachment: 'string-not-object' }), + entry({ attachment: { type: 'deferred_tools_delta', addedNames: ['mcp__svc__t1'] } }), + ]) + expect(result).toEqual(['mcp__svc__t1']) + }) + + it('returns names in sorted order', () => { + const result = extractMcpInventory([ + entry({ + attachment: { + type: 'deferred_tools_delta', + addedNames: ['mcp__zzz__a', 'mcp__aaa__z', 'mcp__mmm__m'], + }, + }), + ]) + expect(result).toEqual(['mcp__aaa__z', 'mcp__mmm__m', 'mcp__zzz__a']) + }) +}) diff --git a/tests/parser-number-helpers.test.ts b/tests/parser-number-helpers.test.ts new file mode 100644 index 0000000..53e1c32 --- /dev/null +++ b/tests/parser-number-helpers.test.ts @@ -0,0 +1,53 @@ +import { describe, expect, it } from 'vitest' + +import { isPositiveNumber, safeNumber } from '../src/parser.js' + +describe('safeNumber', () => { + it('returns positive finite numbers unchanged', () => { + expect(safeNumber(1)).toBe(1) + expect(safeNumber(0.25)).toBe(0.25) + }) + + it('normalizes non-positive numbers to zero', () => { + expect(safeNumber(0)).toBe(0) + expect(safeNumber(-1)).toBe(0) + }) + + it('normalizes non-finite numbers to zero', () => { + expect(safeNumber(Number.NaN)).toBe(0) + expect(safeNumber(Number.POSITIVE_INFINITY)).toBe(0) + expect(safeNumber(Number.NEGATIVE_INFINITY)).toBe(0) + }) + + it('normalizes non-number values to zero', () => { + expect(safeNumber('12')).toBe(0) + expect(safeNumber(null)).toBe(0) + expect(safeNumber(undefined)).toBe(0) + expect(safeNumber({ value: 12 })).toBe(0) + }) +}) + +describe('isPositiveNumber', () => { + it('returns true for positive finite numbers', () => { + expect(isPositiveNumber(1)).toBe(true) + expect(isPositiveNumber(0.25)).toBe(true) + }) + + it('returns false for zero and negative numbers', () => { + expect(isPositiveNumber(0)).toBe(false) + expect(isPositiveNumber(-1)).toBe(false) + }) + + it('returns false for non-finite numbers', () => { + expect(isPositiveNumber(Number.NaN)).toBe(false) + expect(isPositiveNumber(Number.POSITIVE_INFINITY)).toBe(false) + expect(isPositiveNumber(Number.NEGATIVE_INFINITY)).toBe(false) + }) + + it('returns false for non-number values', () => { + expect(isPositiveNumber('12')).toBe(false) + expect(isPositiveNumber(null)).toBe(false) + expect(isPositiveNumber(undefined)).toBe(false) + expect(isPositiveNumber({ value: 12 })).toBe(false) + }) +}) diff --git a/tests/parser-proxy-codex-only.test.ts b/tests/parser-proxy-codex-only.test.ts new file mode 100644 index 0000000..1bb9264 --- /dev/null +++ b/tests/parser-proxy-codex-only.test.ts @@ -0,0 +1,75 @@ +import { mkdtemp, mkdir, rm, writeFile } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' +import { afterEach, expect, it } from 'vitest' + +// A non-Claude provider records its project path with the leading slash stripped +// ("Users/test/x"), while a configured proxy path keeps it ("/Users/test/x"). +// Matching must be leading-slash agnostic, or a Codex-ONLY project under a proxy +// path is silently reported as out-of-pocket even though the SAME path is flagged +// when a Claude session happens to co-exist there (covered by the merge test) — +// i.e. attribution would depend on incidental provider co-location. +// +// This lives in its own file because the codex provider captures CODEX_HOME when +// its module is first evaluated; isolating it gives a fresh module graph that +// reads the env set below before the dynamic import. + +const CWD = '/Users/test/codexonlyproxied' +let tmpDirs: string[] = [] + +afterEach(async () => { + while (tmpDirs.length > 0) { + const d = tmpDirs.pop() + if (d) await rm(d, { recursive: true, force: true }) + } +}) + +it('flags a Codex-only project under a proxy path (leading-slash agnostic match)', async () => { + // Codex fixture (the only sessions present). + const home = await mkdtemp(join(tmpdir(), 'codeburn-codexonly-')) + tmpDirs.push(home) + const dir = join(home, 'sessions', '2026', '04', '16') + await mkdir(dir, { recursive: true }) + const meta = JSON.stringify({ + type: 'session_meta', timestamp: '2026-04-16T10:00:00Z', + payload: { cwd: CWD, originator: 'codex-cli', session_id: 'codex-1', model: 'gpt-5.3-codex' }, + }) + const tokens = JSON.stringify({ + type: 'event_msg', timestamp: '2026-04-16T10:01:00Z', + payload: { + type: 'token_count', + info: { + model: 'gpt-5.3-codex', + last_token_usage: { input_tokens: 1000, cached_input_tokens: 0, output_tokens: 200, reasoning_output_tokens: 0, total_tokens: 1200 }, + total_token_usage: { input_tokens: 1000, cached_input_tokens: 0, output_tokens: 200, reasoning_output_tokens: 0, total_tokens: 1200 }, + }, + }, + }) + await writeFile(join(dir, 'rollout-codex-1.jsonl'), meta + '\n' + tokens + '\n', 'utf-8') + process.env['CODEX_HOME'] = home + + // Empty Claude dir so the only project is the Codex one. + const claudeEmpty = await mkdtemp(join(tmpdir(), 'codeburn-codexonly-claude-')) + tmpDirs.push(claudeEmpty) + await mkdir(join(claudeEmpty, 'projects'), { recursive: true }) + process.env['CLAUDE_CONFIG_DIR'] = claudeEmpty + + // Import AFTER env is set so the codex provider reads CODEX_HOME. + const { parseAllSessions, clearSessionCache } = await import('../src/parser.js') + const { setProxyPaths, loadPricing } = await import('../src/models.js') + await loadPricing() + setProxyPaths([CWD]) + clearSessionCache() + + const range = { start: new Date(Date.UTC(2026, 3, 15)), end: new Date(Date.UTC(2026, 3, 17)) } + const projects = await parseAllSessions(range, 'all') + + const codex = projects.find(p => p.sessions.some(s => s.turns.some(t => t.assistantCalls.some(c => c.provider === 'codex')))) + expect(codex).toBeDefined() + expect(codex!.totalCostUSD).toBeGreaterThan(0) + // The fix: leading-slash agnostic matching flags the Codex-only project. + expect(codex!.totalProxiedCostUSD).toBeCloseTo(codex!.totalCostUSD, 10) + + setProxyPaths([]) + clearSessionCache() +}) diff --git a/tests/parser-proxy-merge.test.ts b/tests/parser-proxy-merge.test.ts new file mode 100644 index 0000000..a0d8dc9 --- /dev/null +++ b/tests/parser-proxy-merge.test.ts @@ -0,0 +1,104 @@ +import { mkdtemp, mkdir, rm, writeFile } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' +import { afterEach, describe, expect, it } from 'vitest' + +// Regression guard for the cross-provider merge in parseAllSessions: when the +// same repo is used with Claude Code AND another tool (Codex), the two +// ProjectSummaries merge by canonical path and totalCostUSD is summed. The +// merge must RE-DERIVE totalProxiedCostUSD from the final path+cost, or only +// the first-seen provider's proxied amount survives and net out-of-pocket is +// overstated — silently reintroducing the exact bug issue #417 fixes. +// +// The codex provider captures its sessions dir (CODEX_HOME) when its module is +// first evaluated, so this file sets the env and creates fixtures BEFORE a +// dynamic import of the parser. A hyphen-free cwd is used so codex's +// sanitize/unsanitize path round-trips to the same merge key as Claude. + +const MERGE_CWD = '/Users/test/proxiedmerge' +let tmpDirs: string[] = [] + +afterEach(async () => { + while (tmpDirs.length > 0) { + const d = tmpDirs.pop() + if (d) await rm(d, { recursive: true, force: true }) + } +}) + +async function writeClaudeFixture(cwd: string): Promise<void> { + const base = await mkdtemp(join(tmpdir(), 'codeburn-merge-claude-')) + tmpDirs.push(base) + const dir = join(base, 'projects', 'p') + await mkdir(dir, { recursive: true }) + const line = JSON.stringify({ + type: 'assistant', + timestamp: '2026-04-16T10:00:00.000Z', + sessionId: 's1', + cwd, + message: { + type: 'message', role: 'assistant', model: 'claude-sonnet-4-6', id: 'm1', content: [], + usage: { input_tokens: 1000, output_tokens: 200, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 }, + }, + }) + await writeFile(join(dir, 's1.jsonl'), line + '\n', 'utf-8') + process.env['CLAUDE_CONFIG_DIR'] = base +} + +async function writeCodexFixture(cwd: string): Promise<void> { + const home = await mkdtemp(join(tmpdir(), 'codeburn-merge-codex-')) + tmpDirs.push(home) + const dir = join(home, 'sessions', '2026', '04', '16') + await mkdir(dir, { recursive: true }) + const meta = JSON.stringify({ + type: 'session_meta', timestamp: '2026-04-16T10:00:00Z', + payload: { cwd, originator: 'codex-cli', session_id: 'codex-1', model: 'gpt-5.3-codex' }, + }) + const tokens = JSON.stringify({ + type: 'event_msg', timestamp: '2026-04-16T10:01:00Z', + payload: { + type: 'token_count', + info: { + model: 'gpt-5.3-codex', + last_token_usage: { input_tokens: 1000, cached_input_tokens: 0, output_tokens: 200, reasoning_output_tokens: 0, total_tokens: 1200 }, + total_token_usage: { input_tokens: 1000, cached_input_tokens: 0, output_tokens: 200, reasoning_output_tokens: 0, total_tokens: 1200 }, + }, + }, + }) + await writeFile(join(dir, 'rollout-codex-1.jsonl'), meta + '\n' + tokens + '\n', 'utf-8') + process.env['CODEX_HOME'] = home +} + +describe('proxy pricing: cross-provider merge', () => { + it('re-derives proxied == total when Claude and Codex sessions merge under a proxy path', async () => { + await writeClaudeFixture(MERGE_CWD) + await writeCodexFixture(MERGE_CWD) + + // Import AFTER env is set so the codex provider reads CODEX_HOME. + const { parseAllSessions, clearSessionCache } = await import('../src/parser.js') + const { setProxyPaths, loadPricing } = await import('../src/models.js') + await loadPricing() + setProxyPaths([MERGE_CWD]) + clearSessionCache() + + const range = { start: new Date(Date.UTC(2026, 3, 15)), end: new Date(Date.UTC(2026, 3, 17)) } + const projects = await parseAllSessions(range, 'all') + + // Sanity: both providers landed in a single merged project (proves the + // cross-provider merge path actually ran, not just a lone Claude project). + expect(projects).toHaveLength(1) + const merged = projects[0]! + const providers = new Set( + merged.sessions.flatMap(s => s.turns.flatMap(t => t.assistantCalls.map(c => c.provider))), + ) + expect(providers.has('claude')).toBe(true) + expect(providers.has('codex')).toBe(true) + + // The fix: the whole merged total is subscription-covered, not just the + // first provider's slice. Without the merge re-derivation this is < total. + expect(merged.totalProxiedCostUSD).toBeCloseTo(merged.totalCostUSD, 10) + expect(merged.totalCostUSD - merged.totalProxiedCostUSD).toBeCloseTo(0, 10) + + setProxyPaths([]) + clearSessionCache() + }) +}) diff --git a/tests/parser-proxy-pricing.test.ts b/tests/parser-proxy-pricing.test.ts new file mode 100644 index 0000000..26df51b --- /dev/null +++ b/tests/parser-proxy-pricing.test.ts @@ -0,0 +1,264 @@ +import { mkdtemp, mkdir, rm, writeFile } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' +import { afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest' + +import { setProxyPaths, isProxiedPath, getProxyPathsConfigHash, setLocalModelSavings, setModelAliases, loadPricing } from '../src/models.js' +import { parseAllSessions, clearSessionCache, filterProjectsByDateRange } from '../src/parser.js' +import type { DateRange, ProjectSummary } from '../src/types.js' + +// ── Part A: isProxiedPath matching rule (pure) ───────────────────────────── + +describe('isProxiedPath: path matching rule', () => { + beforeEach(() => setProxyPaths([])) + afterEach(() => setProxyPaths([])) + + it('never matches when no proxy paths are configured', () => { + expect(isProxiedPath('/Users/me/work/acme')).toBe(false) + }) + + it('matches an exact path', () => { + setProxyPaths(['/Users/me/work/acme']) + expect(isProxiedPath('/Users/me/work/acme')).toBe(true) + }) + + it('matches a child directory under the prefix', () => { + setProxyPaths(['/Users/me/work']) + expect(isProxiedPath('/Users/me/work/acme/sub')).toBe(true) + }) + + it('does NOT match across a partial path segment (boundary guard)', () => { + // The single most important negative: a string prefix that is not a + // directory-segment boundary must not silently zero unrelated spend. + setProxyPaths(['/Users/me/proj']) + expect(isProxiedPath('/Users/me/project-unrelated')).toBe(false) + }) + + it('is tolerant of trailing slashes on both config and cwd', () => { + setProxyPaths(['/Users/me/work/']) + expect(isProxiedPath('/Users/me/work')).toBe(true) + expect(isProxiedPath('/Users/me/work/')).toBe(true) + }) + + it('is case-insensitive (macOS/Windows default filesystems)', () => { + setProxyPaths(['/Users/Me/Work']) + expect(isProxiedPath('/users/me/work/acme')).toBe(true) + }) + + it('matches a Windows-style config against a forward-slash cwd', () => { + setProxyPaths(['C:\\Users\\me\\work']) + expect(isProxiedPath('C:/Users/me/work/acme')).toBe(true) + }) + + it('never matches an empty/undefined/null cwd', () => { + setProxyPaths(['/Users/me/work']) + expect(isProxiedPath('')).toBe(false) + expect(isProxiedPath(undefined)).toBe(false) + expect(isProxiedPath(null)).toBe(false) + }) + + it('drops a root "/" entry so it can never match everything', () => { + setProxyPaths(['/']) + expect(isProxiedPath('/Users/me/anything')).toBe(false) + }) + + it('drops blank / non-string entries', () => { + setProxyPaths(['', ' ', undefined as unknown as string, '/Users/me/work']) + expect(isProxiedPath('/Users/me/work/x')).toBe(true) + expect(isProxiedPath('/somewhere/else')).toBe(false) + }) + + it('matches when any one of several configured paths matches', () => { + setProxyPaths(['/Users/me/a', '/Users/me/b']) + expect(isProxiedPath('/Users/me/b/deep')).toBe(true) + expect(isProxiedPath('/Users/me/c')).toBe(false) + }) + + it('is reset by setProxyPaths([])', () => { + setProxyPaths(['/Users/me/work']) + expect(isProxiedPath('/Users/me/work')).toBe(true) + setProxyPaths([]) + expect(isProxiedPath('/Users/me/work')).toBe(false) + }) + + it('matches a leading-slash-stripped cwd (non-Claude provider path form)', () => { + // Codex/unsanitizePath project paths drop the leading slash; the configured + // path keeps it. Matching must be agnostic to that difference. + setProxyPaths(['/Users/me/work']) + expect(isProxiedPath('Users/me/work/acme')).toBe(true) + expect(isProxiedPath('Users/me/work')).toBe(true) + }) +}) + +describe('getProxyPathsConfigHash: cache-key stability', () => { + beforeEach(() => setProxyPaths([])) + afterEach(() => setProxyPaths([])) + + it('is empty when unconfigured', () => { + expect(getProxyPathsConfigHash()).toBe('') + }) + + it('is order-independent', () => { + setProxyPaths(['/a', '/b']) + const h1 = getProxyPathsConfigHash() + setProxyPaths(['/b', '/a']) + expect(getProxyPathsConfigHash()).toBe(h1) + }) + + it('does NOT collide two materially different sets (delimited join)', () => { + // Regression guard: a separator-less join would make {'/a','/b'} and + // {'/a/b'} hash identically and let the session cache serve stale numbers. + setProxyPaths(['/a', '/b']) + const h1 = getProxyPathsConfigHash() + setProxyPaths(['/a/b']) + expect(getProxyPathsConfigHash()).not.toBe(h1) + }) +}) + +// ── Part B: end-to-end attribution through parseAllSessions ──────────────── + +const FIXTURE_DAY = Date.UTC(2026, 3, 16) +const RANGE_START = new Date(FIXTURE_DAY - 24 * 60 * 60 * 1000) +const RANGE_END = new Date(FIXTURE_DAY + 24 * 60 * 60 * 1000) +const makeRange = (): DateRange => ({ start: RANGE_START, end: RANGE_END }) + +// A stable, non-existent absolute path: resolveCanonicalProjectPath finds no +// .git ancestor and returns it unchanged, so projectPath is predictable. +const FIXTURE_CWD = '/private/var/eywa-proxy-fixture/acme' + +let tmpDirs: string[] = [] + +beforeAll(async () => { + await loadPricing() +}) + +beforeEach(() => { + setProxyPaths([]) + setLocalModelSavings({}) + setModelAliases({}) + clearSessionCache() +}) + +afterEach(async () => { + setProxyPaths([]) + clearSessionCache() + while (tmpDirs.length > 0) { + const d = tmpDirs.pop() + if (d) await rm(d, { recursive: true, force: true }) + } +}) + +async function setupProxiedSession(cwd: string = FIXTURE_CWD): Promise<void> { + const base = await mkdtemp(join(tmpdir(), 'codeburn-proxy-')) + tmpDirs.push(base) + const projectDir = join(base, 'projects', 'p') + await mkdir(projectDir, { recursive: true }) + const line = JSON.stringify({ + type: 'assistant', + timestamp: '2026-04-16T10:00:00.000Z', + sessionId: 's1', + cwd, + message: { + type: 'message', + role: 'assistant', + model: 'claude-sonnet-4-6', + id: 'msg-1', + content: [], + usage: { input_tokens: 1000, output_tokens: 200, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 }, + }, + }) + await writeFile(join(projectDir, 's1.jsonl'), line + '\n', 'utf-8') + process.env['CLAUDE_CONFIG_DIR'] = base +} + +const allCalls = (projects: ProjectSummary[]) => + projects.flatMap(p => p.sessions.flatMap(s => s.turns.flatMap(t => t.assistantCalls))) + +describe('proxy pricing: end-to-end through parseAllSessions', () => { + it('attributes nothing as proxied when no proxy paths are configured', async () => { + await setupProxiedSession() + const projects = await parseAllSessions(makeRange(), 'all') + const total = projects.reduce((s, p) => s + p.totalCostUSD, 0) + const proxied = projects.reduce((s, p) => s + p.totalProxiedCostUSD, 0) + expect(total).toBeGreaterThan(0) + expect(proxied).toBe(0) + }) + + it('flags the full cost as proxied when the project is under a proxy path, WITHOUT altering costUSD', async () => { + await setupProxiedSession() + setProxyPaths([FIXTURE_CWD]) + clearSessionCache() + const projects = await parseAllSessions(makeRange(), 'all') + + const total = projects.reduce((s, p) => s + p.totalCostUSD, 0) + const proxied = projects.reduce((s, p) => s + p.totalProxiedCostUSD, 0) + expect(total).toBeGreaterThan(0) + // "Full cost, flagged": the billable figure is preserved, the same amount + // is reported as subscription-covered, so net out-of-pocket is 0. + expect(proxied).toBeCloseTo(total, 10) + expect(total - proxied).toBeCloseTo(0, 10) + + // The raw per-call cost is never destroyed — it stays at the full API rate. + const calls = allCalls(projects) + expect(calls.length).toBeGreaterThan(0) + for (const c of calls) expect(c.costUSD).toBeGreaterThan(0) + }) + + it('matches a parent prefix on a segment boundary', async () => { + await setupProxiedSession() + setProxyPaths(['/private/var/eywa-proxy-fixture']) + clearSessionCache() + const projects = await parseAllSessions(makeRange(), 'all') + const proxied = projects.reduce((s, p) => s + p.totalProxiedCostUSD, 0) + expect(proxied).toBeGreaterThan(0) + }) + + it('does NOT flag a sibling path that is only a string prefix (no spend silently zeroed)', async () => { + await setupProxiedSession() + // '/private/var/eywa-proxy-fixture/ac' is a string prefix of '.../acme' + // but not a directory-segment boundary — must not match. + setProxyPaths(['/private/var/eywa-proxy-fixture/ac']) + clearSessionCache() + const projects = await parseAllSessions(makeRange(), 'all') + const total = projects.reduce((s, p) => s + p.totalCostUSD, 0) + const proxied = projects.reduce((s, p) => s + p.totalProxiedCostUSD, 0) + expect(total).toBeGreaterThan(0) + expect(proxied).toBe(0) + }) + + it('attributes nothing when a different, unrelated path is configured', async () => { + await setupProxiedSession() + setProxyPaths(['/Users/someone/else']) + clearSessionCache() + const projects = await parseAllSessions(makeRange(), 'all') + const proxied = projects.reduce((s, p) => s + p.totalProxiedCostUSD, 0) + expect(proxied).toBe(0) + }) + + it('preserves proxy attribution after date-range filtering (filterProjectsByDateRange)', async () => { + await setupProxiedSession() + setProxyPaths([FIXTURE_CWD]) + clearSessionCache() + const projects = await parseAllSessions(makeRange(), 'all') + const filtered = filterProjectsByDateRange(projects, makeRange()) + expect(filtered.length).toBeGreaterThan(0) + const total = filtered.reduce((s, p) => s + p.totalCostUSD, 0) + const proxied = filtered.reduce((s, p) => s + p.totalProxiedCostUSD, 0) + expect(total).toBeGreaterThan(0) + expect(proxied).toBeCloseTo(total, 10) + }) + + it('does not serve stale proxy attribution from the in-memory cache after proxyPaths changes', async () => { + // parseAllSessions caches ProjectSummary[] for 180s keyed partly on the + // proxy-config hash. Toggling proxyPaths must change the key so the second + // call recomputes rather than returning the pre-change (proxied=0) result. + await setupProxiedSession() + const before = await parseAllSessions(makeRange(), 'all') + expect(before.reduce((s, p) => s + p.totalProxiedCostUSD, 0)).toBe(0) + + setProxyPaths([FIXTURE_CWD]) // deliberately NO clearSessionCache() + const after = await parseAllSessions(makeRange(), 'all') + const proxied = after.reduce((s, p) => s + p.totalProxiedCostUSD, 0) + expect(proxied).toBeGreaterThan(0) + }) +}) diff --git a/tests/parser-skip-line.test.ts b/tests/parser-skip-line.test.ts new file mode 100644 index 0000000..f023f46 --- /dev/null +++ b/tests/parser-skip-line.test.ts @@ -0,0 +1,86 @@ +import { describe, it, expect } from 'vitest' + +import { shouldSkipLine } from '../src/parser.js' + +const threshold = '2026-04-01T00:00:00.000Z' + +function makeLine(type: string, timestamp: string, payloadSize = 0): string { + const payload = payloadSize > 0 ? `,"content":"${'x'.repeat(payloadSize)}"` : '' + return `{"type":"${type}","sessionId":"s1","timestamp":"${timestamp}"${payload}}` +} + +function makeLineWithLongCwd(type: string, timestamp: string, cwdLength: number): string { + const cwd = '/projects/' + 'a'.repeat(cwdLength) + return `{"type":"${type}","sessionId":"s1","cwd":"${cwd}","timestamp":"${timestamp}","message":{"role":"user","content":"hi"}}` +} + +describe('shouldSkipLine', () => { + it('skips old user lines', () => { + expect(shouldSkipLine(makeLine('user', '2026-03-01T10:00:00Z'), threshold)).toBe(true) + }) + + it('skips old assistant lines', () => { + expect(shouldSkipLine(makeLine('assistant', '2026-03-15T10:00:00Z'), threshold)).toBe(true) + }) + + it('does not skip in-range user lines', () => { + expect(shouldSkipLine(makeLine('user', '2026-04-05T10:00:00Z'), threshold)).toBe(false) + }) + + it('does not skip in-range assistant lines', () => { + expect(shouldSkipLine(makeLine('assistant', '2026-04-10T10:00:00Z'), threshold)).toBe(false) + }) + + it('never skips attachment lines regardless of timestamp', () => { + expect(shouldSkipLine(makeLine('attachment', '2026-01-01T00:00:00Z'), threshold)).toBe(false) + }) + + it('never skips system lines regardless of timestamp', () => { + expect(shouldSkipLine(makeLine('system', '2026-01-01T00:00:00Z'), threshold)).toBe(false) + }) + + it('never skips summary lines regardless of timestamp', () => { + expect(shouldSkipLine(makeLine('summary', '2026-01-01T00:00:00Z'), threshold)).toBe(false) + }) + + it('does not skip lines with no timestamp field', () => { + expect(shouldSkipLine('{"type":"user","sessionId":"s1"}', threshold)).toBe(false) + }) + + it('does not skip lines with unparseable timestamp', () => { + expect(shouldSkipLine('{"type":"user","timestamp":"bad"}', threshold)).toBe(false) + }) + + it('does not skip malformed JSON', () => { + expect(shouldSkipLine('not json at all', threshold)).toBe(false) + }) + + it('only reads top-level type and timestamp fields', () => { + const line = '{"message":{"type":"assistant","timestamp":"2026-03-01T10:00:00Z"},"type":"user","timestamp":"2026-04-05T10:00:00Z"}' + expect(shouldSkipLine(line, threshold)).toBe(false) + }) + + it('handles timestamp pushed past 200 chars by long cwd', () => { + const line = makeLineWithLongCwd('user', '2026-03-01T10:00:00Z', 300) + expect(line.indexOf('"timestamp"')).toBeGreaterThan(200) + expect(shouldSkipLine(line, threshold)).toBe(true) + }) + + it('handles timestamp at the edge of the 2048 head window', () => { + const line = makeLineWithLongCwd('user', '2026-03-01T10:00:00Z', 1900) + expect(line.indexOf('"timestamp"')).toBeGreaterThan(1900) + expect(shouldSkipLine(line, threshold)).toBe(true) + }) + + it('returns false when timestamp is beyond the head window', () => { + const line = makeLineWithLongCwd('user', '2026-03-01T10:00:00Z', 2100) + expect(line.indexOf('"timestamp"')).toBeGreaterThan(2048) + expect(shouldSkipLine(line, threshold)).toBe(false) + }) + + it('skips old assistant line with large payload without parsing it', () => { + const line = makeLine('assistant', '2026-02-01T10:00:00Z', 50_000_000) + expect(line.length).toBeGreaterThan(50_000_000) + expect(shouldSkipLine(line, threshold)).toBe(true) + }) +}) diff --git a/tests/parser-subagent-collection.test.ts b/tests/parser-subagent-collection.test.ts new file mode 100644 index 0000000..890809e --- /dev/null +++ b/tests/parser-subagent-collection.test.ts @@ -0,0 +1,61 @@ +import { mkdtemp, mkdir, rm, writeFile } from 'fs/promises' +import { tmpdir } from 'os' +import { join, basename } from 'path' + +import { describe, it, expect, beforeEach, afterEach } from 'vitest' + +import { collectJsonlFiles, readAgentType } from '../src/parser.js' + +let root: string +beforeEach(async () => { root = await mkdtemp(join(tmpdir(), 'codeburn-collect-')) }) +afterEach(async () => { await rm(root, { recursive: true, force: true }) }) + +describe('collectJsonlFiles', () => { + // Regression for #470: workflow/ultracode subagent transcripts live nested at + // `<session>/subagents/workflows/<wf>/agent-*.jsonl`. A flat scan dropped them, + // so usage went uncounted whenever the workflow feature was on. + it('collects nested workflow subagent transcripts, not just top-level subagent files', async () => { + const sessionDir = join(root, 'session-1') + const wfDir = join(sessionDir, 'subagents', 'workflows', 'wf_abc') + await mkdir(wfDir, { recursive: true }) + + await writeFile(join(root, 'session-1.jsonl'), '{}\n') + await writeFile(join(sessionDir, 'subagents', 'agent-direct.jsonl'), '{}\n') + await writeFile(join(wfDir, 'agent-nested.jsonl'), '{}\n') + // Sidecar metadata must never be picked up as a transcript. + await writeFile(join(wfDir, 'agent-nested.meta.json'), '{}\n') + + const found = (await collectJsonlFiles(root)).map(f => basename(f)).sort() + + expect(found).toContain('session-1.jsonl') + expect(found).toContain('agent-direct.jsonl') + expect(found).toContain('agent-nested.jsonl') + expect(found).not.toContain('agent-nested.meta.json') + }) + + it('returns an empty list for a missing directory without throwing', async () => { + await expect(collectJsonlFiles(join(root, 'does-not-exist'))).resolves.toEqual([]) + }) +}) + +describe('readAgentType (Claude-scoped agent-type detection)', () => { + it('reads agentType from a subagent transcript’s sibling .meta.json', async () => { + const dir = join(root, 'session', 'subagents') + await mkdir(dir, { recursive: true }) + await writeFile(join(dir, 'agent-x.jsonl'), '{}\n') + await writeFile(join(dir, 'agent-x.meta.json'), JSON.stringify({ agentType: 'Explore' })) + expect(await readAgentType(join(dir, 'agent-x.jsonl'))).toBe('Explore') + }) + + it('falls back to workflow-subagent for nested workflow agents without a meta', async () => { + const dir = join(root, 'session', 'subagents', 'workflows', 'wf_1') + await mkdir(dir, { recursive: true }) + await writeFile(join(dir, 'agent-y.jsonl'), '{}\n') + expect(await readAgentType(join(dir, 'agent-y.jsonl'))).toBe('workflow-subagent') + }) + + it('returns undefined for an ordinary (non-subagent) session file', async () => { + await writeFile(join(root, 'session.jsonl'), '{}\n') + expect(await readAgentType(join(root, 'session.jsonl'))).toBeUndefined() + }) +}) diff --git a/tests/parser.test.ts b/tests/parser.test.ts new file mode 100644 index 0000000..1a2a4ec --- /dev/null +++ b/tests/parser.test.ts @@ -0,0 +1,414 @@ +// Tests for durable-source monotonic cost behaviour (PR #477 / copilot-otel). +// Five scenarios: +// (a) file-purge monotonic — copilot JSONL file deleted → total unchanged +// (b) OTel-prune monotonic — OTel DB rows pruned → total unchanged +// (c) no double-count — same source parsed twice → counted once +// (d) non-durable evicts — deleted source for non-durable provider IS removed +// (e) 90-day age-out — orphan ≥ 91d old is pruned; ≤ 89d is retained + +import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm, unlink } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' +import { createRequire } from 'node:module' + +import { isSqliteAvailable } from '../src/sqlite.js' +import { clearSessionCache, parseAllSessions } from '../src/parser.js' +import { loadCache, saveCache } from '../src/session-cache.js' +import type { SessionSource, SessionParser, ParsedProviderCall } from '../src/providers/types.js' + +// ── Synthetic provider state ─────────────────────────────────────────────── +// Module-level so the vi.mock factory closure captures them by reference and +// tests can mutate them freely without re-creating the mock. +let _synthSources: SessionSource[] = [] +let _synthDurable = false +let _synthYields: ParsedProviderCall[] = [] + +vi.mock('../src/providers/index.js', async (importOriginal) => { + type Mod = typeof import('../src/providers/index.js') + const actual = await importOriginal<Mod>() + return { + ...actual, + async discoverAllSessions(filter?: string) { + // Pass through for specific non-synthetic providers; inject synthetic + // sources only when filter is undefined/'all'/'test-synthetic'. + if (filter && filter !== 'all' && filter !== 'test-synthetic') { + return actual.discoverAllSessions(filter) + } + const base = filter === 'test-synthetic' + ? [] + : await actual.discoverAllSessions(filter) + return [..._synthSources, ...base] + }, + async getProvider(name: string) { + if (name === 'test-synthetic') { + return { + name: 'test-synthetic', + displayName: 'Test Synthetic', + durableSources: _synthDurable, + modelDisplayName: (m: string) => m, + toolDisplayName: (t: string) => t, + async discoverSessions() { return _synthSources }, + createSessionParser(_s: SessionSource, _k: Set<string>): SessionParser { + return { + async *parse(): AsyncGenerator<ParsedProviderCall> { + for (const call of _synthYields) { + // Respect seenKeys so that when multiple sources share the same + // dedup key, only the first source yields it (mirrors real parsers). + if (_k.has(call.deduplicationKey)) continue + _k.add(call.deduplicationKey) + yield call + } + }, + } + }, + } + } + return actual.getProvider(name) + }, + } +}) + +// ── OTel DB helpers ─────────────────────────────────────────────────────── +const requireForTest = createRequire(import.meta.url) +type TestDb = { + exec(sql: string): void + prepare(sql: string): { run(...p: unknown[]): void } + close(): void +} + +function createOtelDb(dbPath: string): void { + const { DatabaseSync } = requireForTest('node:sqlite') as { + DatabaseSync: new (path: string) => TestDb + } + const db = new DatabaseSync(dbPath) + db.exec(` + CREATE TABLE spans ( + span_id TEXT PRIMARY KEY NOT NULL, + trace_id TEXT NOT NULL, + operation_name TEXT, + start_time_ms INTEGER NOT NULL DEFAULT 0, + response_model TEXT + ); + CREATE TABLE span_attributes ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + span_id TEXT NOT NULL, + key TEXT NOT NULL, + value TEXT + ); + `) + db.close() +} + +interface OtelConvSpec { + spanId: string + traceId: string + convId: string + model: string + input: number + output: number + startTimeMs?: number +} + +function insertOtelConv(dbPath: string, spec: OtelConvSpec): void { + const { DatabaseSync } = requireForTest('node:sqlite') as { + DatabaseSync: new (path: string) => TestDb + } + const db = new DatabaseSync(dbPath) + db.prepare( + `INSERT INTO spans (span_id, trace_id, operation_name, start_time_ms, response_model) + VALUES (?, ?, ?, ?, ?)` + ).run(spec.spanId, spec.traceId, 'chat', spec.startTimeMs ?? Date.now(), spec.model) + const attr = db.prepare( + `INSERT INTO span_attributes (span_id, key, value) VALUES (?, ?, ?)` + ) + const attrs: Record<string, string | number> = { + 'gen_ai.conversation.id': spec.convId, + 'gen_ai.response.model': spec.model, + 'gen_ai.usage.input_tokens': spec.input, + 'gen_ai.usage.output_tokens': spec.output, + 'gen_ai.usage.cache_read.input_tokens': 0, + 'gen_ai.usage.cache_creation.input_tokens': 0, + } + for (const [k, v] of Object.entries(attrs)) attr.run(spec.spanId, k, String(v)) + db.close() +} + +// ── Copilot JSONL helpers ───────────────────────────────────────────────── +async function createJsonlSession( + sessionStateDir: string, + sessionId: string, + outputTokens: number, +): Promise<string> { + const dir = join(sessionStateDir, sessionId) + await mkdir(dir, { recursive: true }) + await writeFile(join(dir, 'workspace.yaml'), `id: ${sessionId}\ncwd: /home/user/testproj\n`) + const lines = [ + JSON.stringify({ type: 'session.model_change', timestamp: '2026-05-01T10:00:00Z', data: { newModel: 'gpt-4.1' } }), + JSON.stringify({ type: 'user.message', timestamp: '2026-05-01T10:00:05Z', data: { content: 'hello', interactionId: 'int-1' } }), + JSON.stringify({ type: 'assistant.message', timestamp: '2026-05-01T10:00:10Z', data: { messageId: 'msg-1', outputTokens, interactionId: 'int-1', toolRequests: [] } }), + ] + await writeFile(join(dir, 'events.jsonl'), lines.join('\n') + '\n') + return join(dir, 'events.jsonl') +} + +// ── Helpers ─────────────────────────────────────────────────────────────── +function totalCost(projects: Awaited<ReturnType<typeof parseAllSessions>>): number { + return projects + .flatMap(p => p.sessions) + .flatMap(s => s.turns) + .flatMap(t => t.assistantCalls) + .reduce((s, c) => s + c.costUSD, 0) +} + +function totalOutput(projects: Awaited<ReturnType<typeof parseAllSessions>>): number { + return projects + .flatMap(p => p.sessions) + .flatMap(s => s.turns) + .flatMap(t => t.assistantCalls) + .reduce((s, c) => s + c.usage.outputTokens, 0) +} + +// ── Common env setup ────────────────────────────────────────────────────── +let tmpHome: string +let tmpCache: string + +beforeEach(async () => { + tmpHome = await mkdtemp(join(tmpdir(), 'cb-parser-test-home-')) + tmpCache = await mkdtemp(join(tmpdir(), 'cb-parser-test-cache-')) + + process.env['HOME'] = tmpHome + process.env['CODEBURN_CACHE_DIR'] = tmpCache + + // Reset synthetic provider state + _synthSources = [] + _synthDurable = false + _synthYields = [] +}) + +afterEach(async () => { + clearSessionCache() + vi.unstubAllEnvs() + + _synthSources = [] + + await rm(tmpHome, { recursive: true, force: true }) + await rm(tmpCache, { recursive: true, force: true }) +}) + +// ═══════════════════════════════════════════════════════════════════════════ +// (a) File-purge monotonic: copilot JSONL file deleted → total unchanged +// ═══════════════════════════════════════════════════════════════════════════ +describe('(a) copilot JSONL file-purge monotonic', () => { + it('preserves monthly total after events.jsonl is deleted', async () => { + const sessionStateDir = join(tmpHome, 'session-state') + await mkdir(sessionStateDir, { recursive: true }) + + vi.stubEnv('CODEBURN_COPILOT_SESSION_STATE_DIR', sessionStateDir) + vi.stubEnv('CODEBURN_COPILOT_DISABLE_OTEL', '1') + vi.stubEnv('CODEBURN_COPILOT_WS_STORAGE_DIR', join(tmpHome, 'no-ws')) + + const eventsPath = await createJsonlSession(sessionStateDir, 'sess-del', 200) + + // First parse: file exists → cached + const proj1 = await parseAllSessions(undefined, 'copilot') + const out1 = totalOutput(proj1) + expect(out1).toBe(200) + + // Delete the source file (simulates VS Code / CLI pruning it) + await unlink(eventsPath) + clearSessionCache() + + // Second parse: file gone but copilot is durable → total must not drop + const proj2 = await parseAllSessions(undefined, 'copilot') + const out2 = totalOutput(proj2) + expect(out2).toBeGreaterThanOrEqual(out1) + expect(out2).toBe(out1) + }) +}) + +// ═══════════════════════════════════════════════════════════════════════════ +// (b) OTel-prune monotonic: OTel DB rows pruned → total unchanged +// ═══════════════════════════════════════════════════════════════════════════ +describe.skipIf(!isSqliteAvailable())( + '(b) OTel DB-prune monotonic', + () => { + it('preserves total after one conversation is pruned from the OTel DB', async () => { + const dbPath = join(tmpHome, 'agent-traces.db') + vi.stubEnv('CODEBURN_COPILOT_OTEL_DB', dbPath) + vi.stubEnv('CODEBURN_COPILOT_DISABLE_OTEL', '') + vi.stubEnv('CODEBURN_COPILOT_SESSION_STATE_DIR', join(tmpHome, 'no-jsonl')) + vi.stubEnv('CODEBURN_COPILOT_WS_STORAGE_DIR', join(tmpHome, 'no-ws')) + + // DB with two conversations + createOtelDb(dbPath) + insertOtelConv(dbPath, { spanId: 's1', traceId: 't1', convId: 'prune-c1', model: 'gpt-4.1', input: 500, output: 50 }) + insertOtelConv(dbPath, { spanId: 's2', traceId: 't2', convId: 'prune-c2', model: 'gpt-4.1', input: 1000, output: 100 }) + + const proj1 = await parseAllSessions(undefined, 'copilot') + const out1 = totalOutput(proj1) + expect(out1).toBe(150) // 50 + 100 + + // Simulate OTel pruning conv-1 from the DB: rebuild DB with only conv-2 + clearSessionCache() + await rm(dbPath) + createOtelDb(dbPath) + insertOtelConv(dbPath, { spanId: 's2', traceId: 't2', convId: 'prune-c2', model: 'gpt-4.1', input: 1000, output: 100 }) + + // Second parse: DB was rebuilt without conv-1. The union-merge in + // parseProviderSources keeps conv-1's turns in the cache (since its + // dedup keys are not re-emitted by the re-parse) → total must not drop. + const proj2 = await parseAllSessions(undefined, 'copilot') + const out2 = totalOutput(proj2) + expect(out2).toBeGreaterThanOrEqual(out1) + expect(out2).toBe(out1) + }) + } +) + +// ═══════════════════════════════════════════════════════════════════════════ +// (c) No double-count: same fully-present source parsed twice → counted once +// ═══════════════════════════════════════════════════════════════════════════ +describe.skipIf(!isSqliteAvailable())( + '(c) OTel source parsed twice is counted once', + () => { + it('second parse of unchanged DB yields same total, not double', async () => { + const dbPath = join(tmpHome, 'agent-traces.db') + vi.stubEnv('CODEBURN_COPILOT_OTEL_DB', dbPath) + vi.stubEnv('CODEBURN_COPILOT_DISABLE_OTEL', '') + vi.stubEnv('CODEBURN_COPILOT_SESSION_STATE_DIR', join(tmpHome, 'no-jsonl')) + vi.stubEnv('CODEBURN_COPILOT_WS_STORAGE_DIR', join(tmpHome, 'no-ws')) + + createOtelDb(dbPath) + insertOtelConv(dbPath, { spanId: 'dedup-s1', traceId: 'dedup-t1', convId: 'dedup-c1', model: 'gpt-4.1', input: 300, output: 30 }) + + const proj1 = await parseAllSessions(undefined, 'copilot') + expect(totalOutput(proj1)).toBe(30) + + clearSessionCache() + + // Second parse — disk cache is populated, fingerprint unchanged + const proj2 = await parseAllSessions(undefined, 'copilot') + expect(totalOutput(proj2)).toBe(30) // NOT 60 + }) + } +) + +// ═══════════════════════════════════════════════════════════════════════════ +// (d) Non-durable evicts: deleted source for non-durable provider is removed +// ═══════════════════════════════════════════════════════════════════════════ +describe('(d) non-durable provider evicts deleted sources', () => { + it('removes cache entry for a path that leaves discoverSessions()', async () => { + // Two real temp files as source paths (fingerprintFile needs them to exist) + const fileA = join(tmpHome, 'synth-a.txt') + const fileB = join(tmpHome, 'synth-b.txt') + await writeFile(fileA, 'placeholder-a') + await writeFile(fileB, 'placeholder-b') + + const dedupA = 'synth-dedup-evict-a' + const dedupB = 'synth-dedup-evict-b' + + const makeCall = (deduplicationKey: string): ParsedProviderCall => ({ + provider: 'test-synthetic', model: 'gpt-4o', + inputTokens: 10, outputTokens: 5, + cacheCreationInputTokens: 0, cacheReadInputTokens: 0, + cachedInputTokens: 0, reasoningTokens: 0, webSearchRequests: 0, + costUSD: 0.001, tools: [], bashCommands: [], + timestamp: new Date().toISOString(), + speed: 'standard', + deduplicationKey, + userMessage: 'test', sessionId: 'synth-sess', + }) + + _synthDurable = false + _synthSources = [ + { path: fileA, project: 'test', provider: 'test-synthetic' }, + { path: fileB, project: 'test', provider: 'test-synthetic' }, + ] + _synthYields = [makeCall(dedupA)] + + // First parse: both sources present → data for A cached + const proj1 = await parseAllSessions(undefined, 'test-synthetic') + expect(totalOutput(proj1)).toBeGreaterThan(0) + + clearSessionCache() + + // Remove A from discovered sources (simulates file-gone + discoverSessions skips it). + // B stays so sources.length > 0 → eviction loop fires. + _synthSources = [{ path: fileB, project: 'test', provider: 'test-synthetic' }] + _synthYields = [] // B yields nothing (empty file) + + const proj2 = await parseAllSessions(undefined, 'test-synthetic') + // A's cache entry must be evicted → total should be 0 + expect(totalOutput(proj2)).toBe(0) + }) +}) + +// ═══════════════════════════════════════════════════════════════════════════ +// (e) 90-day age-out: orphan ≥ 91d old is pruned; ≤ 89d is retained +// ═══════════════════════════════════════════════════════════════════════════ +describe('(e) 90-day age-out for durable providers', () => { + it('prunes an orphaned cache entry whose newest call is 91 days old', async () => { + const synthFile = join(tmpHome, 'synth-age.txt') + await writeFile(synthFile, 'placeholder') + + const ts91dAgo = new Date(Date.now() - 91 * 24 * 60 * 60 * 1000).toISOString() + + _synthDurable = true + _synthSources = [{ path: synthFile, project: 'test', provider: 'test-synthetic' }] + _synthYields = [{ + provider: 'test-synthetic', model: 'gpt-4o', + inputTokens: 10, outputTokens: 8, + cacheCreationInputTokens: 0, cacheReadInputTokens: 0, + cachedInputTokens: 0, reasoningTokens: 0, webSearchRequests: 0, + costUSD: 0.002, tools: [], bashCommands: [], + timestamp: ts91dAgo, + speed: 'standard', + deduplicationKey: 'synth-age-out-91d', + userMessage: 'old', sessionId: 'synth-old', + }] + + // First parse: cached with 91d-old timestamp → immediately pruned by 90-day check + const proj1 = await parseAllSessions(undefined, 'test-synthetic') + expect(totalOutput(proj1)).toBe(0) // pruned right away + + // Confirm: entry is not in the persistent cache after first parse + clearSessionCache() + _synthSources = [] // no longer discovered + const proj2 = await parseAllSessions(undefined, 'test-synthetic') + expect(totalOutput(proj2)).toBe(0) + }) + + it('retains an orphaned cache entry whose newest call is 89 days old', async () => { + const synthFile = join(tmpHome, 'synth-retain.txt') + await writeFile(synthFile, 'placeholder') + + const ts89dAgo = new Date(Date.now() - 89 * 24 * 60 * 60 * 1000).toISOString() + + _synthDurable = true + _synthSources = [{ path: synthFile, project: 'test', provider: 'test-synthetic' }] + _synthYields = [{ + provider: 'test-synthetic', model: 'gpt-4o', + inputTokens: 10, outputTokens: 7, + cacheCreationInputTokens: 0, cacheReadInputTokens: 0, + cachedInputTokens: 0, reasoningTokens: 0, webSearchRequests: 0, + costUSD: 0.002, tools: [], bashCommands: [], + timestamp: ts89dAgo, + speed: 'standard', + deduplicationKey: 'synth-retain-89d', + userMessage: 'recent-ish', sessionId: 'synth-recent', + }] + + // First parse: cached with 89d-old timestamp → NOT pruned (within 90d window) + const proj1 = await parseAllSessions(undefined, 'test-synthetic') + expect(totalOutput(proj1)).toBe(7) + + // Remove source (simulate it being orphaned) + clearSessionCache() + _synthSources = [] // no longer discovered → orphan pass handles it + + // Second parse: orphan with 89d timestamp → retained + counted via orphan pass + const proj2 = await parseAllSessions(undefined, 'test-synthetic') + expect(totalOutput(proj2)).toBe(7) + }) +}) diff --git a/tests/plan-usage.test.ts b/tests/plan-usage.test.ts new file mode 100644 index 0000000..eabfe5a --- /dev/null +++ b/tests/plan-usage.test.ts @@ -0,0 +1,343 @@ +import { mkdtemp, rm } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' + +import { describe, it, expect, vi, beforeEach } from 'vitest' + +import { savePlan } from '../src/config.js' +import { activePlansFromMap, computePeriodFromResetDay, getPlanUsage, getPlanUsageFromProjects, getPlanUsages } from '../src/plan-usage.js' +import type { ProjectSummary } from '../src/types.js' + +const { parseAllSessionsMock } = vi.hoisted(() => ({ + parseAllSessionsMock: vi.fn(), +})) + +vi.mock('../src/parser.js', () => ({ + parseAllSessions: parseAllSessionsMock, +})) + +describe('computePeriodFromResetDay', () => { + it('uses current month when today is on/after reset day', () => { + const { periodStart, periodEnd } = computePeriodFromResetDay(1, new Date('2026-04-17T10:00:00.000Z')) + expect(periodStart.getFullYear()).toBe(2026) + expect(periodStart.getMonth()).toBe(3) + expect(periodStart.getDate()).toBe(1) + expect(periodEnd.getMonth()).toBe(4) + expect(periodEnd.getDate()).toBe(1) + }) + + it('uses previous month when today is before reset day', () => { + const { periodStart, periodEnd } = computePeriodFromResetDay(15, new Date('2026-04-03T10:00:00.000Z')) + expect(periodStart.getMonth()).toBe(2) + expect(periodStart.getDate()).toBe(15) + expect(periodEnd.getMonth()).toBe(3) + expect(periodEnd.getDate()).toBe(15) + }) + + it('clamps reset day into 1..28', () => { + const { periodStart } = computePeriodFromResetDay(99, new Date('2026-04-27T10:00:00.000Z')) + expect(periodStart.getDate()).toBe(28) + }) +}) + +describe('getPlanUsage', () => { + beforeEach(() => { + parseAllSessionsMock.mockReset() + }) + + it('passes provider filter from plan and computes status', async () => { + parseAllSessionsMock.mockResolvedValue([ + { + totalCostUSD: 160, + sessions: [], + }, + ]) + + const usage = await getPlanUsage({ + id: 'claude-max', + monthlyUsd: 200, + provider: 'claude', + resetDay: 1, + setAt: '2026-04-01T00:00:00.000Z', + }, new Date('2026-04-10T10:00:00.000Z')) + + expect(parseAllSessionsMock).toHaveBeenCalledWith( + expect.objectContaining({ start: expect.any(Date), end: expect.any(Date) }), + 'claude', + ) + expect(usage.spentApiEquivalentUsd).toBe(160) + expect(usage.percentUsed).toBe(80) + expect(usage.status).toBe('near') + }) + + it('projects using median daily spend (not mean)', async () => { + const dailyCosts = [1, 100, 1, 100, 1, 100, 1] + const turns = dailyCosts.map((cost, idx) => ({ + timestamp: `2026-04-${String(idx + 1).padStart(2, '0')}T12:00:00.000Z`, + assistantCalls: [{ costUSD: cost }], + })) + + parseAllSessionsMock.mockResolvedValue([ + { + totalCostUSD: dailyCosts.reduce((sum, value) => sum + value, 0), + sessions: [{ turns }], + }, + ]) + + const usage = await getPlanUsage({ + id: 'custom', + monthlyUsd: 500, + provider: 'all', + resetDay: 1, + setAt: '2026-04-01T00:00:00.000Z', + }, new Date('2026-04-07T12:00:00.000Z')) + + // Median(1,100,1,100,1,100,1) = 1, so remaining 23 days adds 23. + expect(Math.round(usage.projectedMonthUsd)).toBe(327) + expect(parseAllSessionsMock).toHaveBeenCalledWith( + expect.objectContaining({ start: expect.any(Date), end: expect.any(Date) }), + 'all', + ) + }) + + it('computes plan usage from pre-fetched projects', () => { + const usage = getPlanUsageFromProjects({ + id: 'custom', + monthlyUsd: 100, + provider: 'all', + resetDay: 1, + setAt: '2026-04-01T00:00:00.000Z', + }, [ + { + totalCostUSD: 40, + sessions: [ + { + turns: [ + { timestamp: '2026-04-02T12:00:00.000Z', assistantCalls: [{ costUSD: 20 }] }, + { timestamp: '2026-04-03T12:00:00.000Z', assistantCalls: [{ costUSD: 20 }] }, + ], + }, + ], + }, + ], new Date('2026-04-10T10:00:00.000Z')) + + expect(usage.spentApiEquivalentUsd).toBe(40) + expect(usage.budgetUsd).toBe(100) + expect(usage.status).toBe('under') + }) + + it('projects month-end spend from API call timestamps', () => { + const usage = getPlanUsageFromProjects({ + id: 'custom', + monthlyUsd: 100, + provider: 'all', + resetDay: 1, + setAt: '2026-04-01T00:00:00.000Z', + }, [ + { + project: 'codeburn', + projectPath: '/tmp/codeburn', + totalCostUSD: 10, + totalApiCalls: 1, + sessions: [ + { + turns: [ + { + timestamp: '2026-03-31T23:59:00.000Z', + assistantCalls: [{ costUSD: 10, timestamp: '2026-04-01T10:00:00.000Z' }], + }, + ], + }, + ], + }, + ] as ProjectSummary[], new Date('2026-04-01T12:00:00.000Z')) + + expect(Math.round(usage.projectedMonthUsd)).toBe(300) + }) + + it('returns active plans in provider display order', () => { + const plans = activePlansFromMap({ + codex: { + id: 'custom', + monthlyUsd: 200, + provider: 'codex', + resetDay: 1, + setAt: '2026-04-01T00:00:00.000Z', + }, + claude: { + id: 'claude-max', + monthlyUsd: 200, + provider: 'claude', + resetDay: 1, + setAt: '2026-04-01T00:00:00.000Z', + }, + cursor: { + id: 'none', + monthlyUsd: 0, + provider: 'cursor', + resetDay: 1, + setAt: '2026-04-01T00:00:00.000Z', + }, + }) + + expect(plans.map(plan => plan.provider)).toEqual(['claude', 'codex']) + }) + + it('keeps the provider-specific parser filter for one active plan', async () => { + const dir = await mkdtemp(join(tmpdir(), 'codeburn-plan-usage-test-')) + process.env['HOME'] = dir + + try { + await savePlan({ + id: 'claude-max', + monthlyUsd: 200, + provider: 'claude', + resetDay: 1, + setAt: '2026-04-01T00:00:00.000Z', + }) + + parseAllSessionsMock.mockResolvedValue([ + { + project: 'codeburn', + projectPath: '/tmp/codeburn', + totalCostUSD: 80, + totalApiCalls: 1, + sessions: [], + }, + ] satisfies ProjectSummary[]) + + const usages = await getPlanUsages(new Date('2026-04-10T12:00:00.000Z')) + + expect(parseAllSessionsMock).toHaveBeenCalledTimes(1) + expect(parseAllSessionsMock).toHaveBeenCalledWith( + expect.objectContaining({ start: expect.any(Date), end: expect.any(Date) }), + 'claude', + ) + expect(usages).toHaveLength(1) + expect(usages[0]?.spentApiEquivalentUsd).toBe(80) + } finally { + await rm(dir, { recursive: true, force: true }) + } + }) + + it('computes multiple active plan usages from one all-provider parse', async () => { + const dir = await mkdtemp(join(tmpdir(), 'codeburn-plan-usage-test-')) + process.env['HOME'] = dir + + try { + await savePlan({ + id: 'claude-max', + monthlyUsd: 200, + provider: 'claude', + resetDay: 1, + setAt: '2026-04-01T00:00:00.000Z', + }) + await savePlan({ + id: 'custom', + monthlyUsd: 100, + provider: 'codex', + resetDay: 1, + setAt: '2026-04-01T00:00:00.000Z', + }) + + parseAllSessionsMock.mockResolvedValue([ + { + project: 'codeburn', + projectPath: '/tmp/codeburn', + totalCostUSD: 150, + totalApiCalls: 2, + sessions: [ + { + sessionId: 'session-1', + project: 'codeburn', + firstTimestamp: '2026-04-03T10:00:00.000Z', + lastTimestamp: '2026-04-03T11:00:00.000Z', + totalCostUSD: 150, + totalInputTokens: 0, + totalOutputTokens: 0, + totalCacheReadTokens: 0, + totalCacheWriteTokens: 0, + apiCalls: 2, + modelBreakdown: {}, + toolBreakdown: {}, + mcpBreakdown: {}, + bashBreakdown: {}, + categoryBreakdown: {}, + skillBreakdown: {}, + turns: [ + { + userMessage: 'work', + timestamp: '2026-04-03T10:00:00.000Z', + sessionId: 'session-1', + category: 'coding', + retries: 0, + hasEdits: true, + assistantCalls: [ + { + provider: 'claude', + model: 'claude-opus-4-7', + usage: { + inputTokens: 0, + outputTokens: 0, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + }, + costUSD: 100, + tools: [], + mcpTools: [], + skills: [], + hasAgentSpawn: false, + hasPlanMode: false, + speed: 'standard', + timestamp: '2026-04-03T10:00:00.000Z', + bashCommands: [], + deduplicationKey: 'claude-1', + }, + { + provider: 'codex', + model: 'gpt-5.5', + usage: { + inputTokens: 0, + outputTokens: 0, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + }, + costUSD: 50, + tools: [], + mcpTools: [], + skills: [], + hasAgentSpawn: false, + hasPlanMode: false, + speed: 'standard', + timestamp: '2026-04-03T11:00:00.000Z', + bashCommands: [], + deduplicationKey: 'codex-1', + }, + ], + }, + ], + }, + ], + }, + ] satisfies ProjectSummary[]) + + const usages = await getPlanUsages(new Date('2026-04-10T12:00:00.000Z')) + + expect(parseAllSessionsMock).toHaveBeenCalledTimes(1) + expect(parseAllSessionsMock).toHaveBeenCalledWith( + expect.objectContaining({ start: expect.any(Date), end: expect.any(Date) }), + 'all', + ) + expect(usages.map(usage => usage.plan.provider)).toEqual(['claude', 'codex']) + expect(usages.map(usage => usage.spentApiEquivalentUsd)).toEqual([100, 50]) + } finally { + await rm(dir, { recursive: true, force: true }) + } + }) +}) diff --git a/tests/plans.test.ts b/tests/plans.test.ts new file mode 100644 index 0000000..ca4553b --- /dev/null +++ b/tests/plans.test.ts @@ -0,0 +1,178 @@ +import { mkdtemp, rm } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' + +import { describe, it, expect } from 'vitest' + +import { clearPlan, readPlan, readPlans, saveConfig, savePlan } from '../src/config.js' +import { getPresetPlan, isPlanId, isPlanProvider } from '../src/plans.js' + +describe('plan presets', () => { + it('resolves builtin presets', () => { + expect(getPresetPlan('claude-pro')).toMatchObject({ id: 'claude-pro', monthlyUsd: 20, provider: 'claude' }) + expect(getPresetPlan('claude-max')).toMatchObject({ id: 'claude-max', monthlyUsd: 200, provider: 'claude' }) + expect(getPresetPlan('cursor-pro')).toMatchObject({ id: 'cursor-pro', monthlyUsd: 20, provider: 'cursor' }) + expect(getPresetPlan('custom')).toBeNull() + }) + + it('validates ids and providers', () => { + expect(isPlanId('claude-pro')).toBe(true) + expect(isPlanId('none')).toBe(true) + expect(isPlanId('bad-plan')).toBe(false) + + expect(isPlanProvider('all')).toBe(true) + expect(isPlanProvider('claude')).toBe(true) + expect(isPlanProvider('invalid')).toBe(false) + }) +}) + +describe('plan config persistence', () => { + it('round-trips per-provider plans and clears one provider at a time', async () => { + const dir = await mkdtemp(join(tmpdir(), 'codeburn-plan-test-')) + process.env['HOME'] = dir + + try { + await savePlan({ + id: 'claude-max', + monthlyUsd: 200, + provider: 'claude', + resetDay: 12, + setAt: '2026-04-17T12:00:00.000Z', + }) + await savePlan({ + id: 'custom', + monthlyUsd: 200, + provider: 'codex', + resetDay: 1, + setAt: '2026-04-18T12:00:00.000Z', + }) + + const plans = await readPlans() + expect(plans.claude).toMatchObject({ + id: 'claude-max', + monthlyUsd: 200, + provider: 'claude', + resetDay: 12, + }) + expect(plans.codex).toMatchObject({ + id: 'custom', + monthlyUsd: 200, + provider: 'codex', + resetDay: 1, + }) + expect(await readPlan()).toMatchObject({ id: 'claude-max', provider: 'claude' }) + + await clearPlan('codex') + expect((await readPlans()).codex).toBeUndefined() + expect((await readPlans()).claude).toMatchObject({ id: 'claude-max' }) + + await clearPlan('all') + expect((await readPlans()).claude).toMatchObject({ id: 'claude-max' }) + + await clearPlan() + expect(await readPlan()).toBeUndefined() + expect(await readPlans()).toEqual({}) + } finally { + await rm(dir, { recursive: true, force: true }) + } + }) + + it('reads legacy single-plan config as a provider-keyed plan map', async () => { + const dir = await mkdtemp(join(tmpdir(), 'codeburn-plan-test-')) + process.env['HOME'] = dir + + try { + await saveConfig({ + plan: { + id: 'cursor-pro', + monthlyUsd: 20, + provider: 'cursor', + resetDay: 3, + setAt: '2026-04-17T12:00:00.000Z', + }, + }) + + const plans = await readPlans() + expect(plans.cursor).toMatchObject({ + id: 'cursor-pro', + monthlyUsd: 20, + provider: 'cursor', + resetDay: 3, + }) + } finally { + await rm(dir, { recursive: true, force: true }) + } + }) + + it('drops a hand-edited all plan when provider-specific plans are present', async () => { + const dir = await mkdtemp(join(tmpdir(), 'codeburn-plan-test-')) + process.env['HOME'] = dir + + try { + await saveConfig({ + plans: { + all: { + id: 'custom', + monthlyUsd: 300, + resetDay: 1, + setAt: '2026-04-17T12:00:00.000Z', + }, + claude: { + id: 'claude-max', + monthlyUsd: 200, + resetDay: 1, + setAt: '2026-04-18T12:00:00.000Z', + }, + }, + }) + + const plans = await readPlans() + expect(plans.all).toBeUndefined() + expect(plans.claude).toMatchObject({ id: 'claude-max', provider: 'claude' }) + expect(await readPlan()).toMatchObject({ id: 'claude-max', provider: 'claude' }) + } finally { + await rm(dir, { recursive: true, force: true }) + } + }) + + it('does not allow an all-provider plan to overlap provider-specific plans', async () => { + const dir = await mkdtemp(join(tmpdir(), 'codeburn-plan-test-')) + process.env['HOME'] = dir + + try { + await savePlan({ + id: 'custom', + monthlyUsd: 100, + provider: 'all', + resetDay: 1, + setAt: '2026-04-17T12:00:00.000Z', + }) + await savePlan({ + id: 'claude-max', + monthlyUsd: 200, + provider: 'claude', + resetDay: 1, + setAt: '2026-04-18T12:00:00.000Z', + }) + + expect(await readPlans()).toMatchObject({ + claude: { id: 'claude-max' }, + }) + expect((await readPlans()).all).toBeUndefined() + + await savePlan({ + id: 'custom', + monthlyUsd: 300, + provider: 'all', + resetDay: 1, + setAt: '2026-04-19T12:00:00.000Z', + }) + expect(await readPlans()).toMatchObject({ + all: { id: 'custom', monthlyUsd: 300 }, + }) + expect((await readPlans()).claude).toBeUndefined() + } finally { + await rm(dir, { recursive: true, force: true }) + } + }) +}) diff --git a/tests/pricing-fallback-data.test.ts b/tests/pricing-fallback-data.test.ts new file mode 100644 index 0000000..6e2ec01 --- /dev/null +++ b/tests/pricing-fallback-data.test.ts @@ -0,0 +1,35 @@ +import { describe, it, expect } from 'vitest' + +import fallback from '../src/data/pricing-fallback.json' assert { type: 'json' } + +// The gap-fill fallback is generated from models.dev / OpenRouter. These assert +// the bundler's hygiene guarantees on the committed artifact, so a future +// rebundle that regresses them fails CI rather than shipping bad pricing. +describe('pricing-fallback.json data hygiene', () => { + const entries = Object.entries(fallback as Record<string, (number | null)[]>) + + it('is non-empty', () => { + expect(entries.length).toBeGreaterThan(50) + }) + + it('has no negative rates (OpenRouter -1 "variable price" sentinels)', () => { + const bad = entries.filter(([, v]) => (v[0] ?? 0) < 0 || (v[1] ?? 0) < 0 || (v[2] ?? 0) < 0 || (v[3] ?? 0) < 0) + expect(bad.map(([k]) => k)).toEqual([]) + }) + + it('has no entry that is free on both input and output', () => { + const bad = entries.filter(([, v]) => v[0] === 0 && v[1] === 0) + expect(bad.map(([k]) => k)).toEqual([]) + }) + + it('has no unreachable @pin or date-suffixed keys', () => { + const bad = entries.filter(([k]) => /@/.test(k) || /\d{8}$/.test(k)) + expect(bad.map(([k]) => k)).toEqual([]) + }) + + it('stores per-token rates (no per-million values leaked through)', () => { + // A per-million value would be >= 1; real per-token rates are tiny. + const bad = entries.filter(([, v]) => (v[0] ?? 0) >= 1 || (v[1] ?? 0) >= 1) + expect(bad.map(([k]) => k)).toEqual([]) + }) +}) diff --git a/tests/provider-registry.test.ts b/tests/provider-registry.test.ts new file mode 100644 index 0000000..1c346dd --- /dev/null +++ b/tests/provider-registry.test.ts @@ -0,0 +1,171 @@ +import { describe, it, expect, vi } from 'vitest' +import { providers, getAllProviders, getProvider, safeDiscoverSessions, discoverAllSessions } from '../src/providers/index.js' +import type { Provider } from '../src/providers/types.js' + +function fakeProvider(name: string, discover: Provider['discoverSessions']): Provider { + return { + name, + displayName: name, + modelDisplayName: (m: string) => m, + toolDisplayName: (t: string) => t, + discoverSessions: discover, + } as unknown as Provider +} + +describe('provider registry', () => { + it('has core providers registered synchronously', () => { + expect(providers.map(p => p.name)).toEqual(['claude', 'cline', 'codebuff', 'codex', 'copilot', 'devin', 'droid', 'gemini', 'hermes', 'ibm-bob', 'kilo-code', 'kiro', 'kimi', 'lingtai-tui', 'mistral-vibe', 'mux', 'openclaw', 'open-design', 'pi', 'omp', 'qwen', 'roo-code', 'zerostack', 'grok']) + }) + + it('codebuff tool display names normalize codebuff-native names to canonical set', () => { + const codebuff = providers.find(p => p.name === 'codebuff')! + expect(codebuff.toolDisplayName('read_files')).toBe('Read') + expect(codebuff.toolDisplayName('code_search')).toBe('Grep') + expect(codebuff.toolDisplayName('str_replace')).toBe('Edit') + expect(codebuff.toolDisplayName('run_terminal_command')).toBe('Bash') + expect(codebuff.toolDisplayName('spawn_agents')).toBe('Agent') + expect(codebuff.toolDisplayName('write_todos')).toBe('TodoWrite') + expect(codebuff.toolDisplayName('unknown_tool')).toBe('unknown_tool') + }) + + it('codebuff model display names cover known agent tiers', () => { + const codebuff = providers.find(p => p.name === 'codebuff')! + expect(codebuff.modelDisplayName('codebuff')).toBe('Codebuff') + expect(codebuff.modelDisplayName('codebuff-base2')).toBe('Codebuff Base 2') + expect(codebuff.modelDisplayName('some-future-model')).toBe('some-future-model') + }) + + it('includes sqlite providers after async load', async () => { + const all = await getAllProviders() + const names = all.map(p => p.name) + expect(names).toContain('claude') + expect(names).toContain('codex') + expect(names).toContain('forge') + expect(names).toContain('warp') + expect(names.length).toBeGreaterThanOrEqual(2) + }) + + it('forge is available through async provider loading', async () => { + const forge = await getProvider('forge') + expect(forge).toBeDefined() + expect(forge!.name).toBe('forge') + }) + + it('warp model and tool display names are normalized', async () => { + const warp = await getProvider('warp') + expect(warp).toBeDefined() + expect(warp!.modelDisplayName('warp-auto-efficient')).toBe('Warp Auto (efficient)') + expect(warp!.modelDisplayName('gpt-5.3-codex')).toBe('GPT-5.3 Codex') + expect(warp!.toolDisplayName('run_command')).toBe('Bash') + }) + + it('opencode model display names strip provider prefix', async () => { + const all = await getAllProviders() + const oc = all.find(p => p.name === 'opencode') + if (!oc) return + expect(oc.modelDisplayName('anthropic/claude-opus-4-6-20260205')).toBe('Opus 4.6') + expect(oc.modelDisplayName('google/gemini-2.5-pro')).toBe('Gemini 2.5 Pro') + }) + + it('opencode tool display names normalize builtins', async () => { + const all = await getAllProviders() + const oc = all.find(p => p.name === 'opencode') + if (!oc) return + expect(oc.toolDisplayName('bash')).toBe('Bash') + expect(oc.toolDisplayName('edit')).toBe('Edit') + expect(oc.toolDisplayName('task')).toBe('Agent') + expect(oc.toolDisplayName('unknown_tool')).toBe('unknown_tool') + }) + + it('claude tool display names are identity', () => { + const claude = providers.find(p => p.name === 'claude')! + expect(claude.toolDisplayName('Bash')).toBe('Bash') + expect(claude.toolDisplayName('Read')).toBe('Read') + }) + + it('codex tool display names are normalized', () => { + const codex = providers.find(p => p.name === 'codex')! + expect(codex.toolDisplayName('exec_command')).toBe('Bash') + expect(codex.toolDisplayName('read_file')).toBe('Read') + expect(codex.toolDisplayName('write_file')).toBe('Edit') + expect(codex.toolDisplayName('spawn_agent')).toBe('Agent') + }) + + it('codex model display names are human-readable', () => { + const codex = providers.find(p => p.name === 'codex')! + expect(codex.modelDisplayName('gpt-5.4')).toBe('GPT-5.4') + expect(codex.modelDisplayName('gpt-5.4-mini')).toBe('GPT-5.4 Mini') + expect(codex.modelDisplayName('gpt-5.3-codex')).toBe('GPT-5.3 Codex') + expect(codex.modelDisplayName('gpt-5.5')).toBe('GPT-5.5') + }) + + it('claude model display names are human-readable', () => { + const claude = providers.find(p => p.name === 'claude')! + expect(claude.modelDisplayName('claude-opus-4-6-20260205')).toBe('Opus 4.6') + expect(claude.modelDisplayName('claude-sonnet-4-6')).toBe('Sonnet 4.6') + }) + + it('kimi model and tool display names are normalized', () => { + const kimi = providers.find(p => p.name === 'kimi')! + expect(kimi.modelDisplayName('kimi-auto')).toBe('Kimi (auto)') + expect(kimi.modelDisplayName('kimi-k2-thinking-turbo')).toBe('Kimi K2 Thinking Turbo') + expect(kimi.toolDisplayName('Shell')).toBe('Bash') + expect(kimi.toolDisplayName('WriteFile')).toBe('Write') + }) + + it('lingtai-tui model display names are normalized', () => { + const lingtai = providers.find(p => p.name === 'lingtai-tui')! + expect(lingtai.displayName).toBe('LingTai TUI') + expect(lingtai.modelDisplayName('claude-sonnet-4-6')).toBe('Sonnet 4.6') + expect(lingtai.toolDisplayName('custom_tool')).toBe('custom_tool') + }) + + it('cursor model display names handle auto mode', async () => { + const all = await getAllProviders() + const cursor = all.find(p => p.name === 'cursor')! + expect(cursor.modelDisplayName('cursor-auto')).toBe('Cursor (auto)') + expect(cursor.modelDisplayName('claude-4.5-opus-high-thinking')).toBe('Opus 4.5 (Thinking)') + expect(cursor.modelDisplayName('grok-code-fast-1')).toBe('Grok Code Fast') + expect(cursor.modelDisplayName('unknown-model')).toBe('unknown-model') + }) + + describe('provider-discovery isolation', () => { + it('safeDiscoverSessions returns [] and warns once instead of propagating', async () => { + const warn = vi.spyOn(process.stderr, 'write').mockReturnValue(true) + const boom = fakeProvider('boom-helper', async () => { throw new Error('crafted file blew up') }) + try { + await expect(safeDiscoverSessions(boom)).resolves.toEqual([]) + expect(warn.mock.calls.length).toBeGreaterThanOrEqual(1) + expect(String(warn.mock.calls[0]![0])).toContain('boom-helper') + // Deduped on repeat within the same run: no additional warning. + const afterFirst = warn.mock.calls.length + await safeDiscoverSessions(boom) + expect(warn.mock.calls.length).toBe(afterFirst) + } finally { + warn.mockRestore() + } + }) + + it('discoverAllSessions drops a throwing provider but keeps the healthy ones', async () => { + const warn = vi.spyOn(process.stderr, 'write').mockReturnValue(true) + const boom = fakeProvider('boom-loop', async () => { throw new Error('kaboom') }) + const ok1 = fakeProvider('ok1', async () => [{ path: '/a.jsonl', project: 'p1', provider: 'ok1' }]) + const ok2 = fakeProvider('ok2', async () => [{ path: '/b.jsonl', project: 'p2', provider: 'ok2' }]) + try { + // A throwing provider in the middle must not abort the loop. + const sources = await discoverAllSessions('all', [ok1, boom, ok2]) + expect(sources.map(s => s.path)).toEqual(['/a.jsonl', '/b.jsonl']) + expect(warn.mock.calls.some(c => String(c[0]).includes('boom-loop'))).toBe(true) + } finally { + warn.mockRestore() + } + }) + + it('discoverAllSessions honors the provider filter', async () => { + const ok1 = fakeProvider('keep', async () => [{ path: '/keep.jsonl', project: 'k', provider: 'keep' }]) + const ok2 = fakeProvider('drop', async () => [{ path: '/drop.jsonl', project: 'd', provider: 'drop' }]) + const sources = await discoverAllSessions('keep', [ok1, ok2]) + expect(sources.map(s => s.path)).toEqual(['/keep.jsonl']) + }) + }) +}) diff --git a/tests/provider-turn-grouping.test.ts b/tests/provider-turn-grouping.test.ts new file mode 100644 index 0000000..d9dd0d6 --- /dev/null +++ b/tests/provider-turn-grouping.test.ts @@ -0,0 +1,158 @@ +import { mkdir, mkdtemp, rm, writeFile } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' + +import type { DateRange } from '../src/types.js' + +let home: string +let cacheDir: string +let vibeHome: string +let clearParserCache: (() => void) | undefined + +beforeEach(async () => { + home = await mkdtemp(join(tmpdir(), 'codeburn-turn-group-home-')) + cacheDir = await mkdtemp(join(tmpdir(), 'codeburn-turn-group-cache-')) + vibeHome = await mkdtemp(join(tmpdir(), 'codeburn-turn-group-vibe-')) + process.env['HOME'] = home + process.env['CODEBURN_CACHE_DIR'] = cacheDir + process.env['VIBE_HOME'] = vibeHome +}) + +afterEach(async () => { + clearParserCache?.() + clearParserCache = undefined + vi.resetModules() + await rm(home, { recursive: true, force: true }) + await rm(cacheDir, { recursive: true, force: true }) + await rm(vibeHome, { recursive: true, force: true }) +}) + +function dayRange(): DateRange { + return { + start: new Date('2026-05-16T00:00:00.000Z'), + end: new Date('2026-05-16T23:59:59.999Z'), + } +} + +async function loadParser() { + vi.resetModules() + const parser = await import('../src/parser.js') + clearParserCache = parser.clearSessionCache + return parser.parseAllSessions +} + +describe('provider turn grouping', () => { + it('groups Gemini assistant messages under their user turn so retries are counted', async () => { + const chatsDir = join(home, '.gemini', 'tmp', 'project-a', 'chats') + await mkdir(chatsDir, { recursive: true }) + await writeFile(join(chatsDir, 'session-gemini.json'), JSON.stringify({ + sessionId: 'gemini-session-1', + startTime: '2026-05-16T10:00:00.000Z', + messages: [ + { id: 'u1', timestamp: '2026-05-16T10:00:00.000Z', type: 'user', content: 'implement parser update in src/parser.ts' }, + { + id: 'g1', + timestamp: '2026-05-16T10:00:05.000Z', + type: 'gemini', + content: 'editing', + model: 'gemini-3.1-pro-preview', + tokens: { input: 100, output: 30 }, + toolCalls: [{ id: 't1', name: 'edit_file', args: { path: 'src/parser.ts' } }], + }, + { + id: 'g2', + timestamp: '2026-05-16T10:00:10.000Z', + type: 'gemini', + content: 'testing', + model: 'gemini-3.1-pro-preview', + tokens: { input: 80, output: 20 }, + toolCalls: [{ id: 't2', name: 'run_command', args: { command: 'npm test' } }], + }, + { + id: 'g3', + timestamp: '2026-05-16T10:00:15.000Z', + type: 'gemini', + content: 'fixing after test', + model: 'gemini-3.1-pro-preview', + tokens: { input: 90, output: 25 }, + toolCalls: [{ id: 't3', name: 'edit_file', args: { path: 'src/parser.ts' } }], + }, + ], + })) + + const parseAllSessions = await loadParser() + const projects = await parseAllSessions(dayRange(), 'gemini') + const session = projects[0]!.sessions[0]! + const turn = session.turns[0]! + + expect(session.turns).toHaveLength(1) + expect(turn.assistantCalls.map(call => call.deduplicationKey)).toEqual([ + 'gemini:gemini-session-1:g1', + 'gemini:gemini-session-1:g2', + 'gemini:gemini-session-1:g3', + ]) + expect(turn.hasEdits).toBe(true) + expect(turn.retries).toBe(1) + expect(session.categoryBreakdown[turn.category].editTurns).toBe(1) + expect(session.categoryBreakdown[turn.category].oneShotTurns).toBe(0) + }) + + it('groups Mistral Vibe assistant messages and uses Vibe session_cost when present', async () => { + const sessionDir = join(vibeHome, 'logs', 'session', 'session_20260516_100000_vibe') + await mkdir(sessionDir, { recursive: true }) + await writeFile(join(sessionDir, 'meta.json'), JSON.stringify({ + session_id: 'vibe-session-1', + start_time: '2026-05-16T10:00:00.000Z', + end_time: '2026-05-16T10:01:00.000Z', + environment: { working_directory: '/Users/test/project-a' }, + stats: { + session_prompt_tokens: 300, + session_completion_tokens: 90, + session_cost: 0.123456, + input_price_per_million: 100, + output_price_per_million: 100, + }, + config: { active_model: 'mistral-medium-3.5', models: [] }, + title: 'vibe parser update', + })) + await writeFile(join(sessionDir, 'messages.jsonl'), [ + { role: 'user', content: 'implement parser update in src/providers/mistral-vibe.ts', message_id: 'u1' }, + { + role: 'assistant', + content: 'editing', + message_id: 'a1', + tool_calls: [{ id: 't1', type: 'function', function: { name: 'search_replace', arguments: '{"file_path":"src/providers/mistral-vibe.ts"}' } }], + }, + { + role: 'assistant', + content: 'testing', + message_id: 'a2', + tool_calls: [{ id: 't2', type: 'function', function: { name: 'bash', arguments: '{"command":"npm test"}' } }], + }, + { + role: 'assistant', + content: 'fixing after test', + message_id: 'a3', + tool_calls: [{ id: 't3', type: 'function', function: { name: 'write_file', arguments: '{"path":"src/providers/mistral-vibe.ts"}' } }], + }, + ].map(message => JSON.stringify(message)).join('\n') + '\n') + + const parseAllSessions = await loadParser() + const projects = await parseAllSessions(dayRange(), 'mistral-vibe') + const session = projects[0]!.sessions[0]! + const turn = session.turns[0]! + + expect(session.turns).toHaveLength(1) + expect(turn.assistantCalls.map(call => call.deduplicationKey)).toEqual([ + 'mistral-vibe:vibe-session-1:a1', + 'mistral-vibe:vibe-session-1:a2', + 'mistral-vibe:vibe-session-1:a3', + ]) + expect(turn.retries).toBe(1) + expect(session.totalCostUSD).toBeCloseTo(0.123456, 8) + expect(session.totalInputTokens).toBe(300) + expect(session.totalOutputTokens).toBe(90) + expect(session.categoryBreakdown[turn.category].oneShotTurns).toBe(0) + }) +}) diff --git a/tests/providers/antigravity.test.ts b/tests/providers/antigravity.test.ts new file mode 100644 index 0000000..e98fd59 --- /dev/null +++ b/tests/providers/antigravity.test.ts @@ -0,0 +1,608 @@ +import { mkdtemp, mkdir, readFile, rm, writeFile } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' +import { createRequire } from 'node:module' +import { describe, expect, it } from 'vitest' + +import { isSqliteAvailable } from '../../src/sqlite.js' +import { + antigravityAppDataDirFromSourcePath, + antigravityCascadeIdFromPath, + createAntigravityProvider, + discoverAntigravitySessionSources, + extractAntigravityAppDataDirFromLine, + extractAntigravityGeneratorMetadata, + extractAntigravityModelMap, + getAntigravityStatusLineEventsPath, + parseAntigravityServerInfo, + parseAntigravityServerInfoFromLine, + recordAntigravityStatusLinePayload, + shouldReparseAntigravitySource, +} from '../../src/providers/antigravity.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +const requireForTest = createRequire(import.meta.url) + +type CurrentCliFixture = { + conversationId: string + rows: Array<{ idx: number; hex: string }> +} + +type TestDb = { + exec(sql: string): void + prepare(sql: string): { run(...params: unknown[]): void } + close(): void +} + +function createCurrentAntigravityCliDb(dbPath: string, fixture: CurrentCliFixture): void { + const { DatabaseSync: Database } = requireForTest('node:sqlite') + const db = new Database(dbPath) as TestDb + try { + db.exec('CREATE TABLE gen_metadata (idx integer, data blob, size integer NOT NULL DEFAULT 0, PRIMARY KEY (idx))') + db.exec('CREATE TABLE trajectory_metadata_blob (id text DEFAULT "main", data blob, PRIMARY KEY (id))') + db.prepare('INSERT INTO trajectory_metadata_blob (id, data) VALUES (?, ?)').run( + 'main', + Buffer.from('file:///Users/example/private-project'), + ) + for (const row of fixture.rows) { + const data = Buffer.from(row.hex, 'hex') + db.prepare('INSERT INTO gen_metadata (idx, data, size) VALUES (?, ?, ?)').run(row.idx, data, data.length) + } + } finally { + db.close() + } +} + +async function collectAntigravityCalls(source: { path: string; project: string; provider: string }): Promise<ParsedProviderCall[]> { + const parser = createAntigravityProvider().createSessionParser(source, new Set()) + const calls: ParsedProviderCall[] = [] + for await (const call of parser.parse()) calls.push(call) + return calls +} + +describe('antigravity provider helpers', () => { + it('parses legacy https server flags from POSIX process args', () => { + const server = parseAntigravityServerInfoFromLine( + '/Applications/Antigravity.app/language_server_macos_arm --app_data_dir antigravity --https_server_port 57101 --csrf_token 01234567-89ab-cdef-0123-456789abcdef', + ) + + expect(server).toEqual({ + port: 57101, + csrfToken: '01234567-89ab-cdef-0123-456789abcdef', + }) + }) + + it('parses Windows extension server flags and equals syntax', () => { + const server = parseAntigravityServerInfoFromLine( + 'C:\\Users\\Admin\\AppData\\Local\\Programs\\Antigravity\\resources\\app\\extensions\\antigravity\\bin\\language_server_windows_x64.exe --extension_server_port=62225 --extension_server_csrf_token=abcdef01-2345-6789-abcd-ef0123456789', + ) + + expect(server).toEqual({ + port: 62225, + csrfToken: 'abcdef01-2345-6789-abcd-ef0123456789', + }) + }) + + it('parses Windows extension server flags and space syntax', () => { + const server = parseAntigravityServerInfo([ + 'node something-unrelated', + 'language_server_windows_x64.exe --app_data_dir C:\\Users\\Admin\\.gemini\\antigravity --extension_server_port 62300 --extension_server_csrf_token fedcba98-7654-3210-fedc-ba9876543210', + ]) + + expect(server).toEqual({ + port: 62300, + csrfToken: 'fedcba98-7654-3210-fedc-ba9876543210', + }) + }) + + it('parses quoted flag values', () => { + const server = parseAntigravityServerInfoFromLine( + 'Antigravity language_server_windows_x64.exe --extension_server_port "62301" --extension_server_csrf_token "fedcba98-7654-3210-fedc-ba9876543211"', + ) + + expect(server).toEqual({ + port: 62301, + csrfToken: 'fedcba98-7654-3210-fedc-ba9876543211', + }) + }) + + it('normalizes app_data_dir from app and CLI process args', () => { + expect(extractAntigravityAppDataDirFromLine( + 'language_server --app_data_dir antigravity --https_server_port 0 --csrf_token 01234567-89ab-cdef-0123-456789abcdef', + )).toBe('antigravity') + + expect(extractAntigravityAppDataDirFromLine( + 'language_server --app_data_dir /Users/dev/.gemini/antigravity-cli --https_server_port 0 --csrf_token 01234567-89ab-cdef-0123-456789abcdef', + )).toBe('antigravity-cli') + + expect(extractAntigravityAppDataDirFromLine( + 'language_server.exe --app_data_dir "C:\\Users\\Admin\\.gemini\\antigravity-cli" --extension_server_port 62225 --extension_server_csrf_token abcdef01-2345-6789-abcd-ef0123456789', + )).toBe('antigravity-cli') + + expect(extractAntigravityAppDataDirFromLine( + 'language_server_windows_x64.exe --app_data_dir antigravity-ide --extension_server_port 8720 --extension_server_csrf_token 39800f1b-343a-40b0-8eb5-850702450346', + )).toBe('antigravity-ide') + }) + + it('accepts Antigravity 2 ephemeral port zero', () => { + const server = parseAntigravityServerInfoFromLine( + 'antigravity language_server_macos_arm --https_server_port 0 --csrf_token 01234567-89ab-cdef-0123-456789abcdef', + ) + + expect(server).toEqual({ + port: 0, + csrfToken: '01234567-89ab-cdef-0123-456789abcdef', + }) + }) + + it('matches language-server and antigravity markers case-insensitively', () => { + const server = parseAntigravityServerInfoFromLine( + 'ANTIGRAVITY LANGUAGE_SERVER_WINDOWS_X64.EXE --extension_server_port 62302 --extension_server_csrf_token fedcba98-7654-3210-fedc-ba9876543212', + ) + + expect(server).toEqual({ + port: 62302, + csrfToken: 'fedcba98-7654-3210-fedc-ba9876543212', + }) + }) + + it('ignores process args without an antigravity marker', () => { + expect(parseAntigravityServerInfoFromLine( + 'language_server --extension_server_port 62300 --extension_server_csrf_token fedcba98-7654-3210-fedc-ba9876543210', + )).toBeNull() + }) + + it('ignores invalid ports', () => { + expect(parseAntigravityServerInfoFromLine( + 'antigravity language_server --extension_server_port 99999 --extension_server_csrf_token fedcba98-7654-3210-fedc-ba9876543210', + )).toBeNull() + }) + + it('ignores chained flag names as values', () => { + expect(parseAntigravityServerInfoFromLine( + 'antigravity language_server --extension_server_port=--extension_server_csrf_token --extension_server_csrf_token fedcba98-7654-3210-fedc-ba9876543210', + )).toBeNull() + }) + + it('ignores implausibly short CSRF tokens', () => { + expect(parseAntigravityServerInfoFromLine( + 'antigravity language_server --extension_server_port 62300 --extension_server_csrf_token short', + )).toBeNull() + }) + + it('extracts model maps from wrapped and unwrapped RPC responses', () => { + expect(extractAntigravityModelMap({ + response: { models: { high: { model: 'MODEL_PLACEHOLDER_M7' } } }, + })).toEqual({ MODEL_PLACEHOLDER_M7: 'high' }) + + expect(extractAntigravityModelMap({ + models: { low: { model: 'MODEL_PLACEHOLDER_M8' } }, + })).toEqual({ MODEL_PLACEHOLDER_M8: 'low' }) + expect(extractAntigravityModelMap({ + models: { bad: null, good: { model: 'MODEL_PLACEHOLDER_M9' } }, + })).toEqual({ MODEL_PLACEHOLDER_M9: 'good' }) + expect(extractAntigravityModelMap({ + models: { 'gemini-3-flash-agent': { model: 'MODEL_PLACEHOLDER_M133', displayName: 'Gemini 3.5 Flash (High)' } }, + })).toEqual({ MODEL_PLACEHOLDER_M133: 'gemini-3.5-flash-high' }) + expect(extractAntigravityModelMap(null)).toEqual({}) + }) + + it('extracts generator metadata from wrapped and unwrapped RPC responses', () => { + const metadata = [{ + chatModel: { + model: 'gemini-3-pro', + usage: { + model: 'gemini-3-pro', + inputTokens: '10', + outputTokens: '4', + apiProvider: 'google', + }, + }, + }] + + expect(extractAntigravityGeneratorMetadata({ response: { generatorMetadata: metadata } })).toEqual(metadata) + expect(extractAntigravityGeneratorMetadata({ generatorMetadata: metadata })).toEqual(metadata) + expect(extractAntigravityGeneratorMetadata({ response: { generatorMetadata: null } })).toEqual([]) + expect(extractAntigravityGeneratorMetadata(null)).toEqual([]) + }) + + it('derives cascade ids from legacy .pb and Antigravity 2 .db files', () => { + expect(antigravityCascadeIdFromPath('/tmp/123.pb')).toBe('123') + expect(antigravityCascadeIdFromPath('/tmp/456.db')).toBe('456') + expect(antigravityCascadeIdFromPath('/tmp/789.db-wal')).toBe('789.db-wal') + }) + + it('routes app and CLI source paths to matching Antigravity app data dirs', () => { + expect(antigravityAppDataDirFromSourcePath( + '/Users/dev/.gemini/antigravity/conversations/session.db', + )).toBe('antigravity') + + expect(antigravityAppDataDirFromSourcePath( + '/Users/dev/.gemini/antigravity-cli/conversations/session.pb', + )).toBe('antigravity-cli') + + expect(antigravityAppDataDirFromSourcePath( + 'C:\\Users\\Admin\\.gemini\\antigravity-cli\\implicit\\session.pb', + )).toBe('antigravity-cli') + + expect(antigravityAppDataDirFromSourcePath( + '/Users/dev/.gemini/antigravity-ide/conversations/session.db', + )).toBe('antigravity-ide') + + expect(antigravityAppDataDirFromSourcePath( + 'C:\\Users\\Admin\\.gemini\\antigravity-ide\\implicit\\session.pb', + )).toBe('antigravity-ide') + }) + + it('discovers legacy .pb files and Antigravity 2 .db files only', async () => { + const dir = await mkdtemp(join(tmpdir(), 'codeburn-antigravity-')) + + try { + await writeFile(join(dir, 'legacy.pb'), '') + await writeFile(join(dir, 'antigravity-2.db'), '') + await writeFile(join(dir, 'uppercase.DB'), '') + await writeFile(join(dir, 'antigravity-2.db-wal'), '') + await mkdir(join(dir, 'directory.pb')) + + const sources = await discoverAntigravitySessionSources([{ + dir, + project: 'test-project', + extensions: ['.pb', '.db'], + }]) + + expect(sources).toEqual([ + { path: join(dir, 'antigravity-2.db'), project: 'test-project', provider: 'antigravity' }, + { path: join(dir, 'legacy.pb'), project: 'test-project', provider: 'antigravity' }, + { path: join(dir, 'uppercase.DB'), project: 'test-project', provider: 'antigravity' }, + ]) + } finally { + await rm(dir, { recursive: true, force: true }) + } + }) + + it('discovers antigravity-ide conversation and implicit files', async () => { + const tempHome = await mkdtemp(join(tmpdir(), 'codeburn-home-')) + const conversationsDir = join(tempHome, '.gemini', 'antigravity-ide', 'conversations') + const implicitDir = join(tempHome, '.gemini', 'antigravity-ide', 'implicit') + + await mkdir(conversationsDir, { recursive: true }) + await mkdir(implicitDir, { recursive: true }) + + await writeFile(join(conversationsDir, 'session1.db'), '') + await writeFile(join(implicitDir, 'session2.pb'), '') + + const roots = [ + { + dir: conversationsDir, + project: 'antigravity-ide', + extensions: ['.pb', '.db'] as const, + }, + { + dir: implicitDir, + project: 'antigravity-ide', + extensions: ['.pb'] as const, + }, + ] + + const sources = await discoverAntigravitySessionSources(roots) + expect(sources).toEqual([ + { path: join(conversationsDir, 'session1.db'), project: 'antigravity-ide', provider: 'antigravity' }, + { path: join(implicitDir, 'session2.pb'), project: 'antigravity-ide', provider: 'antigravity' }, + ]) + + await rm(tempHome, { recursive: true, force: true }) + }) + + it('displays Gemini 3.5 Flash thinking variants as the base model', () => { + const provider = createAntigravityProvider() + + expect(provider.modelDisplayName('gemini-3.5-flash')).toBe('Gemini 3.5 Flash') + expect(provider.modelDisplayName('gemini-3.5-flash-high')).toBe('Gemini 3.5 Flash') + expect(provider.modelDisplayName('gemini-3.5-flash-medium')).toBe('Gemini 3.5 Flash') + expect(provider.modelDisplayName('gemini-3.5-flash-low')).toBe('Gemini 3.5 Flash') + expect(provider.modelDisplayName('Gemini 3.5 Flash (High)')).toBe('Gemini 3.5 Flash') + }) + + it('captures exact Antigravity CLI statusLine usage as fallback calls', async () => { + const dir = await mkdtemp(join(tmpdir(), 'codeburn-antigravity-statusline-')) + process.env['CODEBURN_CACHE_DIR'] = dir + + try { + const payload = { + conversation_id: 'ce061468-2e2b-4c6f-bf4f-e072bd5fa986', + session_id: 'session-1', + cwd: '/workspace/project', + model: { + id: 'Gemini 3.5 Flash (High)', + display_name: 'Gemini 3.5 Flash (High)', + }, + context_window: { + current_usage: { + input_tokens: 28407, + output_tokens: 137, + cache_creation_input_tokens: 0, + cache_read_input_tokens: 0, + }, + }, + } + + expect(await recordAntigravityStatusLinePayload(payload)).toBe(true) + expect(await recordAntigravityStatusLinePayload(payload)).toBe(true) + + const recorded = await readFile(getAntigravityStatusLineEventsPath(), 'utf-8') + expect(recorded).not.toContain('/workspace/project') + expect(JSON.parse(recorded.split(/\r?\n/)[0]!)).not.toHaveProperty('cwd') + + const source = { + path: getAntigravityStatusLineEventsPath(), + project: 'antigravity-cli', + provider: 'antigravity', + } + + const parser = createAntigravityProvider().createSessionParser(source, new Set()) + const calls = [] + for await (const call of parser.parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]).toMatchObject({ + provider: 'antigravity', + model: 'Gemini 3.5 Flash (High)', + inputTokens: 28407, + outputTokens: 137, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + sessionId: 'ce061468-2e2b-4c6f-bf4f-e072bd5fa986', + project: 'antigravity-cli', + }) + expect(calls[0]!.projectPath).toBeUndefined() + expect(calls[0]!.costUSD).toBeGreaterThan(0) + } finally { + await rm(dir, { recursive: true, force: true }) + } + }) + + it('skips statusLine fallback calls when RPC cache already covered the conversation', async () => { + const dir = await mkdtemp(join(tmpdir(), 'codeburn-antigravity-statusline-rpc-dedup-')) + process.env['CODEBURN_CACHE_DIR'] = dir + + try { + expect(await recordAntigravityStatusLinePayload({ + conversation_id: 'rpc-covered-conversation', + session_id: 'session-1', + model: 'Gemini 3.5 Flash (High)', + context_window: { + current_usage: { + input_tokens: 1000, + output_tokens: 100, + cache_creation_input_tokens: 0, + cache_read_input_tokens: 0, + }, + }, + })).toBe(true) + + const parser = createAntigravityProvider().createSessionParser({ + path: getAntigravityStatusLineEventsPath(), + project: 'antigravity-cli', + provider: 'antigravity', + }, new Set(['antigravity:rpc-covered-conversation:0'])) + + const calls = [] + for await (const call of parser.parse()) calls.push(call) + + expect(calls).toEqual([]) + } finally { + await rm(dir, { recursive: true, force: true }) + } + }) + + it('skips singleton statusLine snapshots and deltas monotonic usage', async () => { + const dir = await mkdtemp(join(tmpdir(), 'codeburn-antigravity-statusline-runs-')) + process.env['CODEBURN_CACHE_DIR'] = dir + + const basePayload = { + conversation_id: 'statusline-runs', + session_id: 'session-1', + model: 'Gemini 3.5 Flash (High)', + } + + const withUsage = ( + input_tokens: number, + output_tokens: number, + cache_read_input_tokens = 0, + ) => ({ + ...basePayload, + context_window: { + current_usage: { + input_tokens, + output_tokens, + cache_creation_input_tokens: 0, + cache_read_input_tokens, + }, + }, + }) + + try { + expect(await recordAntigravityStatusLinePayload(withUsage(100, 10))).toBe(true) + expect(await recordAntigravityStatusLinePayload(withUsage(200, 20))).toBe(true) + expect(await recordAntigravityStatusLinePayload(withUsage(200, 20))).toBe(true) + expect(await recordAntigravityStatusLinePayload(withUsage(300, 30, 50))).toBe(true) + + const parser = createAntigravityProvider().createSessionParser({ + path: getAntigravityStatusLineEventsPath(), + project: 'antigravity-cli', + provider: 'antigravity', + }, new Set()) + + const calls = [] + for await (const call of parser.parse()) calls.push(call) + + expect(calls).toHaveLength(2) + expect(calls.map(call => [call.inputTokens, call.outputTokens, call.cacheReadInputTokens])).toEqual([ + [200, 20, 0], + [100, 10, 50], + ]) + expect(calls.map(call => call.cachedInputTokens)).toEqual([0, 0]) + } finally { + await rm(dir, { recursive: true, force: true }) + } + }) + + it('treats non-monotonic statusLine usage as a new request snapshot', async () => { + const dir = await mkdtemp(join(tmpdir(), 'codeburn-antigravity-statusline-reset-')) + process.env['CODEBURN_CACHE_DIR'] = dir + + const payload = ( + input_tokens: number, + output_tokens: number, + cache_read_input_tokens = 0, + ) => ({ + conversation_id: 'statusline-reset', + session_id: 'session-1', + model: 'Gemini 3.5 Flash (High)', + context_window: { + current_usage: { + input_tokens, + output_tokens, + cache_creation_input_tokens: 0, + cache_read_input_tokens, + }, + }, + }) + + try { + expect(await recordAntigravityStatusLinePayload(payload(1000, 100))).toBe(true) + expect(await recordAntigravityStatusLinePayload(payload(1000, 100))).toBe(true) + expect(await recordAntigravityStatusLinePayload(payload(200, 30, 500))).toBe(true) + + const parser = createAntigravityProvider().createSessionParser({ + path: getAntigravityStatusLineEventsPath(), + project: 'antigravity-cli', + provider: 'antigravity', + }, new Set()) + + const calls = [] + for await (const call of parser.parse()) calls.push(call) + + expect(calls).toHaveLength(2) + expect(calls.map(call => [call.inputTokens, call.outputTokens, call.cacheReadInputTokens])).toEqual([ + [1000, 100, 0], + [200, 30, 500], + ]) + } finally { + await rm(dir, { recursive: true, force: true }) + } + }) + + it('always reparses append-only statusLine sources but not unchanged cached cascades', () => { + const statusLinePath = getAntigravityStatusLineEventsPath() + + expect(shouldReparseAntigravitySource(statusLinePath, 1)).toBe(true) + expect(shouldReparseAntigravitySource('/tmp/antigravity/conversation.pb', 0)).toBe(true) + expect(shouldReparseAntigravitySource('/tmp/antigravity/conversation.pb', 1)).toBe(false) + }) + + it('parses current Antigravity CLI SQLite conversations with non-zero token usage', async () => { + if (!isSqliteAvailable()) return + + const tempHome = await mkdtemp(join(tmpdir(), 'codeburn-antigravity-current-cli-')) + const cacheDir = join(tempHome, 'cache') + const previousCacheDir = process.env['CODEBURN_CACHE_DIR'] + process.env['CODEBURN_CACHE_DIR'] = cacheDir + + try { + const fixture = JSON.parse(await readFile( + new URL('../fixtures/antigravity-cli-current/gen-metadata.json', import.meta.url), + 'utf-8', + )) as CurrentCliFixture + const conversationsDir = join(tempHome, '.gemini', 'antigravity-cli', 'conversations') + const logsDir = join( + tempHome, + '.gemini', + 'antigravity-cli', + 'brain', + fixture.conversationId, + '.system_generated', + 'logs', + ) + + await mkdir(conversationsDir, { recursive: true }) + await mkdir(logsDir, { recursive: true }) + await writeFile( + join(logsDir, 'transcript.jsonl'), + await readFile( + new URL( + '../fixtures/antigravity-cli-current/brain/fixture-current-cli/.system_generated/logs/transcript.jsonl', + import.meta.url, + ), + 'utf-8', + ), + ) + + const dbPath = join(conversationsDir, `${fixture.conversationId}.db`) + createCurrentAntigravityCliDb(dbPath, fixture) + + const sources = await discoverAntigravitySessionSources([{ + dir: conversationsDir, + project: 'antigravity-cli', + extensions: ['.pb', '.db'], + }]) + expect(sources).toEqual([{ path: dbPath, project: 'antigravity-cli', provider: 'antigravity' }]) + + const calls = await collectAntigravityCalls(sources[0]!) + + expect(calls.length).toBeGreaterThanOrEqual(1) + expect(calls[0]).toMatchObject({ + provider: 'antigravity', + model: 'gemini-3.1-pro-high', + inputTokens: 30265, + outputTokens: 659, + reasoningTokens: 71, + sessionId: fixture.conversationId, + project: 'antigravity-cli', + }) + expect(calls[0]!.projectPath).toBeUndefined() + expect(calls[0]!.costUSD).toBeGreaterThan(0) + } finally { + if (previousCacheDir === undefined) delete process.env['CODEBURN_CACHE_DIR'] + else process.env['CODEBURN_CACHE_DIR'] = previousCacheDir + await rm(tempHome, { recursive: true, force: true }) + } + }) + + it('deduplicates current SQLite rows against RPC response ids with hyphens', async () => { + if (!isSqliteAvailable()) return + + const tempHome = await mkdtemp(join(tmpdir(), 'codeburn-antigravity-current-cli-dedup-')) + const cacheDir = join(tempHome, 'cache') + const previousCacheDir = process.env['CODEBURN_CACHE_DIR'] + process.env['CODEBURN_CACHE_DIR'] = cacheDir + + try { + const fixture = JSON.parse(await readFile( + new URL('../fixtures/antigravity-cli-current/gen-metadata.json', import.meta.url), + 'utf-8', + )) as CurrentCliFixture + const conversationsDir = join(tempHome, '.gemini', 'antigravity-cli', 'conversations') + + await mkdir(conversationsDir, { recursive: true }) + + const dbPath = join(conversationsDir, `${fixture.conversationId}.db`) + createCurrentAntigravityCliDb(dbPath, fixture) + + const parser = createAntigravityProvider().createSessionParser({ + path: dbPath, + project: 'antigravity-cli', + provider: 'antigravity', + }, new Set([`antigravity:${fixture.conversationId}:fixture-response-1`])) + const calls = [] + for await (const call of parser.parse()) calls.push(call) + + expect(calls).toEqual([]) + } finally { + if (previousCacheDir === undefined) delete process.env['CODEBURN_CACHE_DIR'] + else process.env['CODEBURN_CACHE_DIR'] = previousCacheDir + await rm(tempHome, { recursive: true, force: true }) + } + }) +}) diff --git a/tests/providers/claude-config-dirs.test.ts b/tests/providers/claude-config-dirs.test.ts new file mode 100644 index 0000000..b6abcb5 --- /dev/null +++ b/tests/providers/claude-config-dirs.test.ts @@ -0,0 +1,377 @@ +import { mkdtemp, mkdir, rm, writeFile } from 'fs/promises' +import { delimiter as pathDelimiter, join } from 'path' +import { tmpdir, homedir } from 'os' + +import { describe, it, expect, beforeEach, afterEach } from 'vitest' + +import { claude } from '../../src/providers/claude.js' +import { clearSessionCache, filterProjectsByClaudeConfigSource, parseAllSessions } from '../../src/parser.js' + +let tmpRoot: string +const savedEnv = { + CLAUDE_CONFIG_DIR: process.env['CLAUDE_CONFIG_DIR'], + CLAUDE_CONFIG_DIRS: process.env['CLAUDE_CONFIG_DIRS'], + HOME: process.env['HOME'], +} + +beforeEach(async () => { + clearSessionCache() + tmpRoot = await mkdtemp(join(tmpdir(), 'codeburn-claude-multi-')) + // Point HOME at a scratch dir so the default `~/.claude` fallback resolves + // somewhere we control. Without this, a stray `~/.claude` on the test + // machine could leak into discovery. + process.env['HOME'] = join(tmpRoot, 'home') + await mkdir(process.env['HOME'], { recursive: true }) + delete process.env['CLAUDE_CONFIG_DIR'] + delete process.env['CLAUDE_CONFIG_DIRS'] +}) + +afterEach(async () => { + clearSessionCache() + for (const [k, v] of Object.entries(savedEnv)) { + if (v === undefined) delete process.env[k] + else process.env[k] = v + } + await rm(tmpRoot, { recursive: true, force: true }) +}) + +async function makeConfigDir(name: string, projectSlugs: string[]): Promise<string> { + const dir = join(tmpRoot, name) + for (const slug of projectSlugs) { + const projectDir = join(dir, 'projects', slug) + await mkdir(projectDir, { recursive: true }) + // Discovery only checks for the project subdirectory. A real session + // file is not required; the parser is exercised separately below. + } + return dir +} + +async function writeSession(configDir: string, slug: string, sessionId: string, lines: string[]): Promise<void> { + const dir = join(configDir, 'projects', slug) + await mkdir(dir, { recursive: true }) + await writeFile(join(dir, `${sessionId}.jsonl`), lines.join('\n')) +} + +function summaryLine(sessionId: string, cwd: string): string { + return JSON.stringify({ + type: 'summary', + summary: 'test', + leafUuid: 'l', + sessionId, + cwd, + timestamp: '2026-05-09T00:00:00.000Z', + }) +} + +function userLine(uuid: string, sessionId: string, cwd: string, text: string): string { + return JSON.stringify({ + type: 'user', + uuid, + sessionId, + cwd, + timestamp: '2026-05-09T00:00:01.000Z', + message: { role: 'user', content: text }, + }) +} + +function assistantLine(uuid: string, parentUuid: string, sessionId: string, cwd: string): string { + return JSON.stringify({ + type: 'assistant', + uuid, + parentUuid, + sessionId, + cwd, + timestamp: '2026-05-09T00:00:02.000Z', + message: { + id: `msg_${uuid}`, + type: 'message', + role: 'assistant', + model: 'claude-sonnet-4-6', + content: [{ type: 'text', text: 'reply' }], + usage: { input_tokens: 100, output_tokens: 50 }, + }, + }) +} + +describe('claude provider — CLAUDE_CONFIG_DIRS discovery', () => { + it('falls back to ~/.claude when no env var is set', async () => { + const homeDir = process.env['HOME']! + await mkdir(join(homeDir, '.claude', 'projects', '-Users-you-app'), { recursive: true }) + + const sources = await claude.discoverSessions() + const projectDirs = sources.map(s => s.path) + expect(projectDirs).toContain(join(homeDir, '.claude', 'projects', '-Users-you-app')) + }) + + it('honors CLAUDE_CONFIG_DIR for a single override', async () => { + const dir = await makeConfigDir('claude-work', ['-Users-you-app']) + process.env['CLAUDE_CONFIG_DIR'] = dir + + const sources = await claude.discoverSessions() + expect(sources.some(s => s.path === join(dir, 'projects', '-Users-you-app'))).toBe(true) + // The default `~/.claude` should NOT also be scanned when the override is set. + expect(sources.every(s => !s.path.startsWith(join(process.env['HOME']!, '.claude')))).toBe(true) + }) + + it('CLAUDE_CONFIG_DIRS overrides CLAUDE_CONFIG_DIR and walks every dir in the list', async () => { + const work = await makeConfigDir('claude-work', ['-Users-you-app']) + const personal = await makeConfigDir('claude-personal', ['-Users-you-app']) + const single = await makeConfigDir('claude-other', ['-Users-you-other']) + + process.env['CLAUDE_CONFIG_DIR'] = single + process.env['CLAUDE_CONFIG_DIRS'] = [work, personal].join(pathDelimiter) + + const sources = await claude.discoverSessions() + const paths = sources.map(s => s.path) + expect(paths).toContain(join(work, 'projects', '-Users-you-app')) + expect(paths).toContain(join(personal, 'projects', '-Users-you-app')) + // CLAUDE_CONFIG_DIR should be ignored once CLAUDE_CONFIG_DIRS is non-empty. + expect(paths.some(p => p.startsWith(single))).toBe(false) + }) + + it('emits the same project name for the same slug across dirs (so parser merges)', async () => { + const work = await makeConfigDir('claude-work', ['-Users-you-app']) + const personal = await makeConfigDir('claude-personal', ['-Users-you-app']) + process.env['CLAUDE_CONFIG_DIRS'] = [work, personal].join(pathDelimiter) + + const sources = await claude.discoverSessions() + const ourSources = sources.filter(s => + s.path === join(work, 'projects', '-Users-you-app') || + s.path === join(personal, 'projects', '-Users-you-app'), + ) + expect(ourSources).toHaveLength(2) + expect(new Set(ourSources.map(s => s.project))).toEqual(new Set(['-Users-you-app'])) + expect(new Set(ourSources.map(s => s.sourceKind))).toEqual(new Set(['claude-config'])) + expect(new Set(ourSources.map(s => s.sourceLabel))).toEqual(new Set(['claude-work', 'claude-personal'])) + expect(ourSources.every(s => typeof s.sourceId === 'string' && s.sourceId.startsWith('claude-config:'))).toBe(true) + }) + + it('tolerates a non-existent dir in the list without dropping the real ones', async () => { + const real = await makeConfigDir('claude-real', ['-Users-you-app']) + const fake = join(tmpRoot, 'does-not-exist') + process.env['CLAUDE_CONFIG_DIRS'] = [real, fake].join(pathDelimiter) + + const sources = await claude.discoverSessions() + expect(sources.some(s => s.path === join(real, 'projects', '-Users-you-app'))).toBe(true) + }) + + it('dedupes when the same dir appears twice in CLAUDE_CONFIG_DIRS', async () => { + const dir = await makeConfigDir('claude-once', ['-Users-you-app']) + process.env['CLAUDE_CONFIG_DIRS'] = [dir, dir].join(pathDelimiter) + + const sources = await claude.discoverSessions() + const ourSources = sources.filter(s => s.path === join(dir, 'projects', '-Users-you-app')) + expect(ourSources).toHaveLength(1) + }) + + it('skips empty entries (leading, trailing, doubled delimiters)', async () => { + const dir = await makeConfigDir('claude-only', ['-Users-you-app']) + process.env['CLAUDE_CONFIG_DIRS'] = `${pathDelimiter}${dir}${pathDelimiter}${pathDelimiter}` + + const sources = await claude.discoverSessions() + expect(sources.some(s => s.path === join(dir, 'projects', '-Users-you-app'))).toBe(true) + }) + + it('expands ~ in CLAUDE_CONFIG_DIR', async () => { + const homeDir = process.env['HOME']! + await mkdir(join(homeDir, 'custom-claude', 'projects', '-Users-you-app'), { recursive: true }) + process.env['CLAUDE_CONFIG_DIR'] = '~/custom-claude' + + const sources = await claude.discoverSessions() + expect(sources.some(s => s.path === join(homeDir, 'custom-claude', 'projects', '-Users-you-app'))).toBe(true) + }) + + it('falls back to CLAUDE_CONFIG_DIR when CLAUDE_CONFIG_DIRS is set but empty', async () => { + const single = await makeConfigDir('claude-fallback', ['-Users-you-app']) + process.env['CLAUDE_CONFIG_DIR'] = single + process.env['CLAUDE_CONFIG_DIRS'] = '' + + const sources = await claude.discoverSessions() + expect(sources.some(s => s.path === join(single, 'projects', '-Users-you-app'))).toBe(true) + }) + + it('skips entries that point at a file rather than a directory', async () => { + const real = await makeConfigDir('claude-real', ['-Users-you-app']) + const filePath = join(tmpRoot, 'not-a-dir.txt') + await writeFile(filePath, 'this is not a config dir') + process.env['CLAUDE_CONFIG_DIRS'] = [real, filePath].join(pathDelimiter) + + const sources = await claude.discoverSessions() + expect(sources.some(s => s.path === join(real, 'projects', '-Users-you-app'))).toBe(true) + expect(sources.every(s => !s.path.startsWith(filePath))).toBe(true) + }) +}) + +describe('claude provider — config.json claudeConfigDirs (menubar-driven)', () => { + async function writeConfigJson(value: unknown): Promise<void> { + const dir = join(process.env['HOME']!, '.config', 'codeburn') + await mkdir(dir, { recursive: true }) + await writeFile(join(dir, 'config.json'), JSON.stringify({ claudeConfigDirs: value })) + } + + it('honors claudeConfigDirs from config.json when no env var is set', async () => { + const work = await makeConfigDir('claude-work', ['-Users-you-app']) + const personal = await makeConfigDir('claude-personal', ['-Users-you-app']) + await writeConfigJson([work, personal]) + + const sources = await claude.discoverSessions() + const paths = sources.map(s => s.path) + expect(paths).toContain(join(work, 'projects', '-Users-you-app')) + expect(paths).toContain(join(personal, 'projects', '-Users-you-app')) + }) + + it('lets env CLAUDE_CONFIG_DIRS override config.json', async () => { + const fromEnv = await makeConfigDir('claude-env', ['-Users-you-app']) + const fromFile = await makeConfigDir('claude-file', ['-Users-you-app']) + await writeConfigJson([fromFile]) + process.env['CLAUDE_CONFIG_DIRS'] = fromEnv + + const sources = await claude.discoverSessions() + expect(sources.some(s => s.path === join(fromEnv, 'projects', '-Users-you-app'))).toBe(true) + expect(sources.every(s => !s.path.startsWith(fromFile))).toBe(true) + }) + + it('lets env CLAUDE_CONFIG_DIR override config.json', async () => { + const fromEnv = await makeConfigDir('claude-env', ['-Users-you-app']) + const fromFile = await makeConfigDir('claude-file', ['-Users-you-app']) + await writeConfigJson([fromFile]) + process.env['CLAUDE_CONFIG_DIR'] = fromEnv + + const sources = await claude.discoverSessions() + expect(sources.some(s => s.path === join(fromEnv, 'projects', '-Users-you-app'))).toBe(true) + expect(sources.every(s => !s.path.startsWith(fromFile))).toBe(true) + }) + + it('falls back to ~/.claude when config.json claudeConfigDirs is empty', async () => { + const homeDir = process.env['HOME']! + await mkdir(join(homeDir, '.claude', 'projects', '-Users-you-app'), { recursive: true }) + await writeConfigJson([]) + + const sources = await claude.discoverSessions() + expect(sources.some(s => s.path === join(homeDir, '.claude', 'projects', '-Users-you-app'))).toBe(true) + }) + + it('expands ~ in config.json entries', async () => { + const homeDir = process.env['HOME']! + await mkdir(join(homeDir, 'cfg-claude', 'projects', '-Users-you-app'), { recursive: true }) + await writeConfigJson(['~/cfg-claude']) + + const sources = await claude.discoverSessions() + expect(sources.some(s => s.path === join(homeDir, 'cfg-claude', 'projects', '-Users-you-app'))).toBe(true) + }) + + it('ignores non-string and blank entries in config.json', async () => { + const real = await makeConfigDir('claude-real', ['-Users-you-app']) + await writeConfigJson([real, 42, '', ' ', null]) + + const sources = await claude.discoverSessions() + expect(sources.some(s => s.path === join(real, 'projects', '-Users-you-app'))).toBe(true) + }) + + it('falls back to ~/.claude when claudeConfigDirs is not an array', async () => { + const homeDir = process.env['HOME']! + await mkdir(join(homeDir, '.claude', 'projects', '-Users-you-app'), { recursive: true }) + await writeConfigJson('not-an-array') + + const sources = await claude.discoverSessions() + expect(sources.some(s => s.path === join(homeDir, '.claude', 'projects', '-Users-you-app'))).toBe(true) + }) +}) + +describe('claude parser — multi-dir aggregation (issue #208 option 1)', () => { + it('merges sessions from two config dirs into a single ProjectSummary when the canonical cwd matches', async () => { + const work = await makeConfigDir('claude-work', []) + const personal = await makeConfigDir('claude-personal', []) + process.env['CLAUDE_CONFIG_DIRS'] = [work, personal].join(pathDelimiter) + + // Both accounts touch the same real project path. Same cwd -> same merge key. + const slug = '-Users-you-shared-app' + const cwd = '/Users/you/shared-app' + await writeSession(work, slug, 'sess-work', [ + summaryLine('sess-work', cwd), + userLine('u1', 'sess-work', cwd, 'hi from work'), + assistantLine('a1', 'u1', 'sess-work', cwd), + ]) + await writeSession(personal, slug, 'sess-personal', [ + summaryLine('sess-personal', cwd), + userLine('u2', 'sess-personal', cwd, 'hi from personal'), + assistantLine('a2', 'u2', 'sess-personal', cwd), + ]) + + const projects = await parseAllSessions(undefined, 'claude') + const matches = projects.filter(p => p.project === slug) + expect(matches).toHaveLength(1) + expect(matches[0]!.totalApiCalls).toBe(2) + // Two sessions, one from each dir, both rolled up. + expect(matches[0]!.sessions.map(s => s.sessionId).sort()).toEqual(['sess-personal', 'sess-work']) + // No `account` or `accountPath` field should appear on the ProjectSummary + // — option 1 explicitly avoids attribution. + expect((matches[0]! as Record<string, unknown>)['account']).toBeUndefined() + expect((matches[0]! as Record<string, unknown>)['accountPath']).toBeUndefined() + }) + + it('keeps source metadata on merged sessions so one Claude config can be selected', async () => { + const work = await makeConfigDir('claude-work', []) + const personal = await makeConfigDir('claude-personal', []) + process.env['CLAUDE_CONFIG_DIRS'] = [work, personal].join(pathDelimiter) + + const slug = '-Users-you-shared-app' + const cwd = '/Users/you/shared-app' + await writeSession(work, slug, 'sess-work', [ + summaryLine('sess-work', cwd), + userLine('u1', 'sess-work', cwd, 'hi from work'), + assistantLine('a1', 'u1', 'sess-work', cwd), + ]) + await writeSession(personal, slug, 'sess-personal', [ + summaryLine('sess-personal', cwd), + userLine('u2', 'sess-personal', cwd, 'hi from personal'), + assistantLine('a2', 'u2', 'sess-personal', cwd), + ]) + + const projects = await parseAllSessions(undefined, 'claude') + const merged = projects.find(p => p.project === slug) + expect(merged).toBeDefined() + expect(merged!.sessions).toHaveLength(2) + + const sourceIds = new Map(merged!.sessions.map(s => [s.source?.label, s.source?.id])) + const workSourceId = sourceIds.get('claude-work') + expect(workSourceId).toBeDefined() + + const workOnly = filterProjectsByClaudeConfigSource(projects, workSourceId!) + expect(workOnly).toHaveLength(1) + expect(workOnly[0]!.project).toBe(slug) + expect(workOnly[0]!.totalApiCalls).toBe(1) + expect(workOnly[0]!.sessions.map(s => s.sessionId)).toEqual(['sess-work']) + expect(workOnly[0]!.sessions[0]!.source?.label).toBe('claude-work') + }) + + // Documents the path-aware merge behavior: the mergedMap in parseAllSessions + // now keys by normalized cwd path (crossProviderKey), not by slug. Two dirs + // can share the same slug but have different underlying cwds — those stay + // separate because they represent genuinely different repositories. In real + // Claude usage different cwds always produce different slugs anyway, so this + // scenario is contrived, but the test pins the new behavior explicitly. + it('keeps sessions with the same slug but different cwds as separate projects', async () => { + const work = await makeConfigDir('claude-work', []) + const personal = await makeConfigDir('claude-personal', []) + process.env['CLAUDE_CONFIG_DIRS'] = [work, personal].join(pathDelimiter) + + const slug = '-Users-you-app' + await writeSession(work, slug, 'sess-work', [ + summaryLine('sess-work', '/Users/you/work-app'), + userLine('u1', 'sess-work', '/Users/you/work-app', 'work'), + assistantLine('a1', 'u1', 'sess-work', '/Users/you/work-app'), + ]) + await writeSession(personal, slug, 'sess-personal', [ + summaryLine('sess-personal', '/Users/you/personal-app'), + userLine('u2', 'sess-personal', '/Users/you/personal-app', 'personal'), + assistantLine('a2', 'u2', 'sess-personal', '/Users/you/personal-app'), + ]) + + const projects = await parseAllSessions(undefined, 'claude') + const matches = projects.filter(p => p.project === slug) + // Different cwds → different crossProviderKey → two separate project rows. + expect(matches).toHaveLength(2) + expect(matches.every(m => m.totalApiCalls === 1)).toBe(true) + }) +}) diff --git a/tests/providers/cline.test.ts b/tests/providers/cline.test.ts new file mode 100644 index 0000000..d739b96 --- /dev/null +++ b/tests/providers/cline.test.ts @@ -0,0 +1,139 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm, utimes } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { cline, createClineProvider } from '../../src/providers/cline.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +async function writeTask(baseDir: string, taskId: string, opts?: { + tokensIn?: number + tokensOut?: number + model?: string + userMessage?: string + cost?: number +}): Promise<string> { + const taskDir = join(baseDir, 'tasks', taskId) + await mkdir(taskDir, { recursive: true }) + + const messages: unknown[] = [] + if (opts?.userMessage) { + messages.push({ type: 'say', say: 'user_feedback', text: opts.userMessage, ts: 1700000000000 }) + } + const usage: Record<string, unknown> = { + tokensIn: opts?.tokensIn ?? 100, + tokensOut: opts?.tokensOut ?? 50, + } + if (opts?.cost !== undefined) usage.cost = opts.cost + messages.push({ type: 'say', say: 'api_req_started', text: JSON.stringify(usage), ts: 1700000001000 }) + + const modelTag = opts?.model ? `<model>${opts.model}</model>` : '' + const history = [ + { role: 'user', content: [{ type: 'text', text: `hello\n<environment_details>\n${modelTag}\n</environment_details>` }] }, + ] + + await writeFile(join(taskDir, 'ui_messages.json'), JSON.stringify(messages)) + await writeFile(join(taskDir, 'api_conversation_history.json'), JSON.stringify(history)) + + return taskDir +} + +describe('cline provider - discovery', () => { + beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'cline-test-')) + }) + + afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) + }) + + it('discovers Cline tasks from VS Code globalStorage and home data roots', async () => { + const vscodeDir = join(tmpDir, 'globalStorage') + const homeDataDir = join(tmpDir, 'cline-data') + await writeTask(vscodeDir, 'task-vscode') + await writeTask(homeDataDir, 'task-home') + + const provider = createClineProvider([vscodeDir, homeDataDir]) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(2) + expect(sessions.map(s => s.provider)).toEqual(['cline', 'cline']) + expect(sessions.map(s => s.project)).toEqual(['Cline', 'Cline']) + expect(sessions.map(s => s.path).sort()).toEqual([ + join(homeDataDir, 'tasks', 'task-home'), + join(vscodeDir, 'tasks', 'task-vscode'), + ].sort()) + }) + + it('deduplicates the same task id across roots by keeping the newest task directory', async () => { + const vscodeDir = join(tmpDir, 'globalStorage') + const homeDataDir = join(tmpDir, 'cline-data') + const oldTask = await writeTask(vscodeDir, 'task-same') + const newTask = await writeTask(homeDataDir, 'task-same') + await utimes(join(oldTask, 'ui_messages.json'), new Date('2026-01-01T00:00:00Z'), new Date('2026-01-01T00:00:00Z')) + await utimes(join(newTask, 'ui_messages.json'), new Date('2026-02-01T00:00:00Z'), new Date('2026-02-01T00:00:00Z')) + + const provider = createClineProvider([vscodeDir, homeDataDir]) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.path).toBe(newTask) + }) + + it('skips task directories without ui_messages.json', async () => { + const vscodeDir = join(tmpDir, 'globalStorage') + await mkdir(join(vscodeDir, 'tasks', 'task-no-ui'), { recursive: true }) + + const provider = createClineProvider(vscodeDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(0) + }) +}) + +describe('cline provider - parsing', () => { + beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'cline-test-')) + }) + + afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) + }) + + it('parses Cline usage with cline provider identity', async () => { + const taskDir = await writeTask(tmpDir, 'task-parse', { + tokensIn: 200, + tokensOut: 100, + model: 'anthropic/claude-sonnet-4-5', + userMessage: 'build the feature', + cost: 0.07, + }) + + const source = { path: taskDir, project: 'Cline', provider: 'cline' } + const calls: ParsedProviderCall[] = [] + for await (const call of cline.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.provider).toBe('cline') + expect(calls[0]!.model).toBe('claude-sonnet-4-5') + expect(calls[0]!.inputTokens).toBe(200) + expect(calls[0]!.outputTokens).toBe(100) + expect(calls[0]!.costUSD).toBe(0.07) + expect(calls[0]!.userMessage).toBe('build the feature') + expect(calls[0]!.deduplicationKey).toMatch(/^cline:task-parse:/) + }) +}) + +describe('cline provider - metadata', () => { + it('has correct name and displayName', () => { + expect(cline.name).toBe('cline') + expect(cline.displayName).toBe('Cline') + }) + + it('passes through model and tool display names', () => { + expect(cline.modelDisplayName('claude-sonnet-4-5')).toBe('claude-sonnet-4-5') + expect(cline.toolDisplayName('read_file')).toBe('read_file') + }) +}) diff --git a/tests/providers/codebuff.test.ts b/tests/providers/codebuff.test.ts new file mode 100644 index 0000000..eb6b234 --- /dev/null +++ b/tests/providers/codebuff.test.ts @@ -0,0 +1,480 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { createCodebuffProvider } from '../../src/providers/codebuff.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'codebuff-test-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +type ToolBlock = { + type: 'tool' + toolName: string + input?: Record<string, unknown> +} + +type TextBlock = { type: 'text'; content: string } + +type Block = ToolBlock | TextBlock + +type AiOpts = { + id?: string + credits?: number + timestamp?: string + blocks?: Block[] + metadata?: Record<string, unknown> +} + +function aiMessage(opts: AiOpts = {}) { + const m: Record<string, unknown> = { + id: opts.id ?? 'msg-ai-1', + variant: 'ai', + content: '', + timestamp: opts.timestamp ?? '2026-04-14T10:00:30.000Z', + } + if (opts.blocks !== undefined) m['blocks'] = opts.blocks + if (opts.credits !== undefined) m['credits'] = opts.credits + if (opts.metadata !== undefined) m['metadata'] = opts.metadata + return m +} + +function userMessage(content: string, timestamp?: string) { + return { + id: 'msg-user-1', + variant: 'user', + content, + timestamp: timestamp ?? '2026-04-14T10:00:10.000Z', + } +} + +async function writeChat( + baseDir: string, + projectName: string, + chatId: string, + messages: unknown[], + runState?: unknown, +): Promise<string> { + const chatDir = join(baseDir, 'projects', projectName, 'chats', chatId) + await mkdir(chatDir, { recursive: true }) + await writeFile(join(chatDir, 'chat-messages.json'), JSON.stringify(messages)) + if (runState !== undefined) { + await writeFile(join(chatDir, 'run-state.json'), JSON.stringify(runState)) + } + return chatDir +} + +describe('codebuff provider - session discovery', () => { + it('discovers sessions under projects/<name>/chats/<chatId>/', async () => { + await writeChat( + tmpDir, + 'myproject', + '2026-04-14T10-00-00.000Z', + [userMessage('hi'), aiMessage({ credits: 10 })], + { sessionState: { projectContext: { cwd: '/Users/test/myproject' } } }, + ) + + const provider = createCodebuffProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.provider).toBe('codebuff') + expect(sessions[0]!.project).toBe('myproject') + expect(sessions[0]!.path).toContain('2026-04-14T10-00-00.000Z') + }) + + it('uses the cwd basename from run-state.json when present', async () => { + await writeChat( + tmpDir, + 'sanitized-folder', + '2026-04-14T11-00-00.000Z', + [aiMessage({ credits: 5 })], + { sessionState: { projectContext: { cwd: '/Users/test/real-project' } } }, + ) + + const provider = createCodebuffProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.project).toBe('real-project') + }) + + it('falls back to the folder name when run-state.json is missing', async () => { + await writeChat(tmpDir, 'fallback-project', '2026-04-14T12-00-00.000Z', [ + aiMessage({ credits: 3 }), + ]) + + const provider = createCodebuffProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.project).toBe('fallback-project') + }) + + it('discovers sessions across multiple projects', async () => { + await writeChat(tmpDir, 'proj-a', '2026-04-14T10-00-00.000Z', [aiMessage({ credits: 1 })]) + await writeChat(tmpDir, 'proj-b', '2026-04-14T10-30-00.000Z', [aiMessage({ credits: 2 })]) + + const provider = createCodebuffProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(2) + const projects = sessions.map(s => s.project).sort() + expect(projects).toEqual(['proj-a', 'proj-b']) + }) + + it('returns empty for a non-existent directory', async () => { + const provider = createCodebuffProvider('/nonexistent/codebuff-path') + const sessions = await provider.discoverSessions() + expect(sessions).toEqual([]) + }) + + it('skips chat folders without chat-messages.json', async () => { + const chatDir = join(tmpDir, 'projects', 'proj', 'chats', '2026-04-14T10-00-00.000Z') + await mkdir(chatDir, { recursive: true }) + // No chat-messages.json created. + + const provider = createCodebuffProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toEqual([]) + }) +}) + +describe('codebuff provider - JSONL parsing', () => { + it('yields one call per assistant message with credits, mapping codebuff tools to canonical names', async () => { + const chatDir = await writeChat( + tmpDir, + 'proj', + '2026-04-14T10-00-00.000Z', + [ + userMessage('implement the feature'), + aiMessage({ + credits: 42, + metadata: { + runState: { sessionState: { mainAgentState: { agentType: 'base2' } } }, + }, + blocks: [ + { type: 'tool', toolName: 'read_files', input: {} }, + { type: 'tool', toolName: 'str_replace', input: {} }, + { type: 'tool', toolName: 'run_terminal_command', input: { command: 'npm test' } }, + { type: 'tool', toolName: 'suggest_followups', input: {} }, + ], + }), + ], + ) + + const provider = createCodebuffProvider(tmpDir) + const source = { path: chatDir, project: 'proj', provider: 'codebuff' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.provider).toBe('codebuff') + expect(call.model).toBe('codebuff-base2') + expect(call.userMessage).toBe('implement the feature') + // `suggest_followups` is intentionally dropped from the tool breakdown. + expect(call.tools).toEqual(['Read', 'Edit', 'Bash']) + expect(call.bashCommands).toContain('npm') + // Credits × $0.01 = $0.42 when token counts are absent. + expect(call.costUSD).toBeCloseTo(0.42, 6) + expect(call.inputTokens).toBe(0) + expect(call.outputTokens).toBe(0) + }) + + it('prefers direct metadata.usage tokens when available and still records credits', async () => { + const chatDir = await writeChat(tmpDir, 'proj', '2026-04-14T10-00-00.000Z', [ + aiMessage({ + credits: 10, + metadata: { + model: 'claude-haiku-4-5-20251001', + usage: { + inputTokens: 5000, + outputTokens: 2000, + cacheCreationInputTokens: 1000, + cacheReadInputTokens: 500, + }, + }, + }), + ]) + + const provider = createCodebuffProvider(tmpDir) + const source = { path: chatDir, project: 'proj', provider: 'codebuff' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.model).toBe('claude-haiku-4-5-20251001') + expect(call.inputTokens).toBe(5000) + expect(call.outputTokens).toBe(2000) + expect(call.cacheCreationInputTokens).toBe(1000) + expect(call.cacheReadInputTokens).toBe(500) + expect(call.cachedInputTokens).toBe(500) + // With real token counts the calculated cost takes precedence over credits. + expect(call.costUSD).toBeGreaterThan(0) + }) + + it('falls back to providerOptions.codebuff.usage in the stashed RunState history', async () => { + const chatDir = await writeChat(tmpDir, 'proj', '2026-04-14T10-00-00.000Z', [ + aiMessage({ + credits: 7, + metadata: { + runState: { + sessionState: { + mainAgentState: { + messageHistory: [ + { role: 'user' }, + { + role: 'assistant', + providerOptions: { + codebuff: { + model: 'openai/gpt-4o', + usage: { + prompt_tokens: 2000, + completion_tokens: 800, + prompt_tokens_details: { cached_tokens: 400 }, + }, + }, + }, + }, + ], + }, + }, + }, + }, + }), + ]) + + const provider = createCodebuffProvider(tmpDir) + const source = { path: chatDir, project: 'proj', provider: 'codebuff' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe('openai/gpt-4o') + expect(calls[0]!.inputTokens).toBe(2000) + expect(calls[0]!.outputTokens).toBe(800) + expect(calls[0]!.cacheReadInputTokens).toBe(400) + }) + + it('skips assistant messages with no credits and no tokens', async () => { + const chatDir = await writeChat(tmpDir, 'proj', '2026-04-14T10-00-00.000Z', [ + aiMessage({ blocks: [{ type: 'text', content: 'mode-divider' }] }), + ]) + + const provider = createCodebuffProvider(tmpDir) + const source = { path: chatDir, project: 'proj', provider: 'codebuff' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(0) + }) + + it('deduplicates calls seen across multiple parses', async () => { + const chatDir = await writeChat(tmpDir, 'proj', '2026-04-14T10-00-00.000Z', [ + aiMessage({ id: 'msg-dup', credits: 3 }), + ]) + + const provider = createCodebuffProvider(tmpDir) + const source = { path: chatDir, project: 'proj', provider: 'codebuff' } + const seenKeys = new Set<string>() + + const firstRun: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, seenKeys).parse()) { + firstRun.push(call) + } + + const secondRun: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, seenKeys).parse()) { + secondRun.push(call) + } + + expect(firstRun).toHaveLength(1) + expect(secondRun).toHaveLength(0) + }) + + it('yields one call per assistant message in a multi-turn chat, preserving user messages', async () => { + const chatDir = await writeChat(tmpDir, 'proj', '2026-04-14T10-00-00.000Z', [ + userMessage('first question'), + aiMessage({ id: 'a1', credits: 5, timestamp: '2026-04-14T10:00:30.000Z' }), + userMessage('second question', '2026-04-14T10:01:00.000Z'), + aiMessage({ id: 'a2', credits: 8, timestamp: '2026-04-14T10:01:30.000Z' }), + ]) + + const provider = createCodebuffProvider(tmpDir) + const source = { path: chatDir, project: 'proj', provider: 'codebuff' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(2) + expect(calls[0]!.userMessage).toBe('first question') + expect(calls[0]!.costUSD).toBeCloseTo(0.05, 6) + expect(calls[1]!.userMessage).toBe('second question') + expect(calls[1]!.costUSD).toBeCloseTo(0.08, 6) + }) + + it('handles a missing chat-messages.json gracefully', async () => { + const provider = createCodebuffProvider(tmpDir) + const source = { + path: join(tmpDir, 'projects', 'missing', 'chats', 'nope'), + project: 'missing', + provider: 'codebuff', + } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + expect(calls).toHaveLength(0) + }) + + it('skips a malformed chat-messages.json without throwing', async () => { + const chatDir = join(tmpDir, 'projects', 'proj', 'chats', '2026-04-14T10-00-00.000Z') + await mkdir(chatDir, { recursive: true }) + await writeFile(join(chatDir, 'chat-messages.json'), 'not-valid-json') + + const provider = createCodebuffProvider(tmpDir) + const source = { path: chatDir, project: 'proj', provider: 'codebuff' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + expect(calls).toHaveLength(0) + }) +}) + +describe('codebuff provider - sessionId channel scoping', () => { + it('produces distinct sessionIds for the same chatId across different channel roots', async () => { + const chatId = '2026-04-14T10-00-00.000Z' + const channelA = join(tmpDir, 'manicode') + const channelB = join(tmpDir, 'manicode-dev') + const cwd = '/Users/test/shared-project' + const runState = { sessionState: { projectContext: { cwd } } } + + const chatDirA = await writeChat( + channelA, + 'shared-project', + chatId, + [userMessage('hi'), aiMessage({ credits: 5 })], + runState, + ) + const chatDirB = await writeChat( + channelB, + 'shared-project', + chatId, + [userMessage('hi'), aiMessage({ credits: 5 })], + runState, + ) + + const providerA = createCodebuffProvider(channelA) + const providerB = createCodebuffProvider(channelB) + + const sourceA = { path: chatDirA, project: 'shared-project', provider: 'codebuff' } + const sourceB = { path: chatDirB, project: 'shared-project', provider: 'codebuff' } + + const callsA: ParsedProviderCall[] = [] + for await (const call of providerA.createSessionParser(sourceA, new Set()).parse()) { + callsA.push(call) + } + const callsB: ParsedProviderCall[] = [] + for await (const call of providerB.createSessionParser(sourceB, new Set()).parse()) { + callsB.push(call) + } + + expect(callsA).toHaveLength(1) + expect(callsB).toHaveLength(1) + // The whole point of the fix: same chatId + same project should NOT + // collapse into a single session when the chats live under different + // channel roots. + expect(callsA[0]!.sessionId).not.toBe(callsB[0]!.sessionId) + expect(callsA[0]!.sessionId).toBe(`manicode/${chatId}`) + expect(callsB[0]!.sessionId).toBe(`manicode-dev/${chatId}`) + // The sessionId must not contain ':' -- src/parser.ts keys sessions as + // `${provider}:${sessionId}:${project}` and reconstructs the session via + // `key.split(':')[1]`, so a colon would truncate the id downstream. + expect(callsA[0]!.sessionId).not.toContain(':') + expect(callsB[0]!.sessionId).not.toContain(':') + }) + + it('includes the channel name in the sessionId', async () => { + const chatId = '2026-04-14T10-00-00.000Z' + const channelRoot = join(tmpDir, 'manicode-staging') + const chatDir = await writeChat(channelRoot, 'proj', chatId, [aiMessage({ credits: 3 })]) + + const provider = createCodebuffProvider(channelRoot) + const source = { path: chatDir, project: 'proj', provider: 'codebuff' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(1) + expect(calls[0]!.sessionId).toBe(`manicode-staging/${chatId}`) + expect(calls[0]!.sessionId).not.toContain(':') + }) + + it('falls back to the chatId when the path does not match the expected structure', async () => { + const chatId = '2026-04-14T10-00-00.000Z' + // Not the canonical <channel>/projects/<proj>/chats/<chatId> layout. + const chatDir = join(tmpDir, 'oddly-shaped', chatId) + await mkdir(chatDir, { recursive: true }) + await writeFile( + join(chatDir, 'chat-messages.json'), + JSON.stringify([aiMessage({ credits: 2 })]), + ) + + const provider = createCodebuffProvider(tmpDir) + const source = { path: chatDir, project: 'proj', provider: 'codebuff' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(1) + expect(calls[0]!.sessionId).toBe(chatId) + }) +}) + +describe('codebuff provider - display names', () => { + const provider = createCodebuffProvider('/tmp') + + it('has the correct identifiers', () => { + expect(provider.name).toBe('codebuff') + expect(provider.displayName).toBe('Codebuff') + }) + + it('maps known Codebuff tiers to readable names', () => { + expect(provider.modelDisplayName('codebuff')).toBe('Codebuff') + expect(provider.modelDisplayName('codebuff-base2')).toBe('Codebuff Base 2') + expect(provider.modelDisplayName('codebuff-lite')).toBe('Codebuff Lite') + }) + + it('returns the raw name for unknown models', () => { + expect(provider.modelDisplayName('claude-sonnet-4-6')).toBe('claude-sonnet-4-6') + }) + + it('normalizes tool names to the canonical set', () => { + expect(provider.toolDisplayName('read_files')).toBe('Read') + expect(provider.toolDisplayName('str_replace')).toBe('Edit') + expect(provider.toolDisplayName('run_terminal_command')).toBe('Bash') + expect(provider.toolDisplayName('unknown_tool')).toBe('unknown_tool') + }) +}) diff --git a/tests/providers/codex.test.ts b/tests/providers/codex.test.ts new file mode 100644 index 0000000..86f1176 --- /dev/null +++ b/tests/providers/codex.test.ts @@ -0,0 +1,593 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { createCodexProvider } from '../../src/providers/codex.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'codex-test-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +function sessionMeta(opts: { cwd?: string; originator?: string; session_id?: string; model?: string; forked_from_id?: string; timestamp?: string } = {}) { + return JSON.stringify({ + type: 'session_meta', + timestamp: opts.timestamp ?? '2026-04-14T10:00:00Z', + payload: { + cwd: opts.cwd ?? '/Users/test/myproject', + originator: opts.originator ?? 'codex-cli', + session_id: opts.session_id ?? 'sess-001', + model: opts.model ?? 'gpt-5.3-codex', + ...(opts.forked_from_id ? { forked_from_id: opts.forked_from_id } : {}), + }, + }) +} + +function tokenCount(opts: { + timestamp?: string + last?: { input?: number; cached?: number; output?: number; reasoning?: number } + total?: { input?: number; cached?: number; output?: number; reasoning?: number; total?: number } + model?: string +}) { + return JSON.stringify({ + type: 'event_msg', + timestamp: opts.timestamp ?? '2026-04-14T10:01:00Z', + payload: { + type: 'token_count', + info: { + model: opts.model, + last_token_usage: opts.last ? { + input_tokens: opts.last.input ?? 0, + cached_input_tokens: opts.last.cached ?? 0, + output_tokens: opts.last.output ?? 0, + reasoning_output_tokens: opts.last.reasoning ?? 0, + total_tokens: (opts.last.input ?? 0) + (opts.last.cached ?? 0) + (opts.last.output ?? 0) + (opts.last.reasoning ?? 0), + } : undefined, + total_token_usage: opts.total ? { + input_tokens: opts.total.input ?? 0, + cached_input_tokens: opts.total.cached ?? 0, + output_tokens: opts.total.output ?? 0, + reasoning_output_tokens: opts.total.reasoning ?? 0, + total_tokens: opts.total.total ?? ((opts.total.input ?? 0) + (opts.total.cached ?? 0) + (opts.total.output ?? 0) + (opts.total.reasoning ?? 0)), + } : undefined, + }, + }, + }) +} + +function functionCall(name: string, timestamp?: string) { + return JSON.stringify({ + type: 'response_item', + timestamp: timestamp ?? '2026-04-14T10:00:30Z', + payload: { type: 'function_call', name }, + }) +} + +function mcpToolCallEnd(server: string, tool: string, timestamp?: string) { + return JSON.stringify({ + type: 'event_msg', + timestamp: timestamp ?? '2026-04-14T10:00:30Z', + payload: { + type: 'mcp_tool_call_end', + call_id: 'call-1', + invocation: { server, tool, arguments: {} }, + duration: '1.2s', + result: { Ok: { content: [] } }, + }, + }) +} + +function userMessage(text: string, timestamp?: string) { + return JSON.stringify({ + type: 'response_item', + timestamp: timestamp ?? '2026-04-14T10:00:00Z', + payload: { + type: 'message', + role: 'user', + content: [{ type: 'input_text', text }], + }, + }) +} + +async function writeSession(dir: string, date: string, filename: string, lines: string[]) { + const [year, month, day] = date.split('-') + const sessionDir = join(dir, 'sessions', year!, month!, day!) + await mkdir(sessionDir, { recursive: true }) + const filePath = join(sessionDir, filename) + await writeFile(filePath, lines.join('\n') + '\n') + return filePath +} + +describe('codex provider - model display names', () => { + it('maps gpt-5.3-codex-spark to its own label', () => { + const provider = createCodexProvider(tmpDir) + const name = provider.modelDisplayName('gpt-5.3-codex-spark') + expect(name).not.toBe('GPT-5.3 Codex') + expect(name).toBe('GPT-5.3 Codex Spark') + }) + + it('maps gpt-5.3-codex reasoning suffixes to the base label', () => { + const provider = createCodexProvider(tmpDir) + expect(provider.modelDisplayName('gpt-5.3-codex-high')).toBe('GPT-5.3 Codex') + expect(provider.modelDisplayName('gpt-5.3-codex-low')).toBe('GPT-5.3 Codex') + }) +}) + +describe('codex provider - session discovery', () => { + it('discovers sessions in YYYY/MM/DD structure', async () => { + await writeSession(tmpDir, '2026-04-14', 'rollout-abc123.jsonl', [ + sessionMeta({ cwd: '/Users/test/myproject' }), + tokenCount({ last: { input: 100, output: 50 }, total: { total: 150 } }), + ]) + + const provider = createCodexProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.provider).toBe('codex') + expect(sessions[0]!.project).toBe('Users-test-myproject') + expect(sessions[0]!.path).toContain('rollout-abc123.jsonl') + }) + + it('returns empty for non-existent directory', async () => { + const provider = createCodexProvider('/nonexistent/path/that/does/not/exist') + const sessions = await provider.discoverSessions() + expect(sessions).toEqual([]) + }) + + it('accepts case-insensitive originator (Codex Desktop)', async () => { + await writeSession(tmpDir, '2026-04-14', 'rollout-desktop.jsonl', [ + sessionMeta({ originator: 'Codex Desktop' }), + tokenCount({ last: { input: 100, output: 50 }, total: { total: 150 } }), + ]) + + const provider = createCodexProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(1) + }) + + it('accepts session_meta lines larger than 16 KB (Codex CLI 0.128+)', async () => { + // Codex CLI 0.128+ embeds the full base_instructions / system prompt in the + // first session_meta line, often pushing it past 20 KB. Regression guard + // against a fixed-size buffer in readFirstLine. + const bigPayload = JSON.stringify({ + type: 'session_meta', + timestamp: '2026-05-02T00:00:00Z', + payload: { + cwd: '/Users/test/big', + originator: 'codex-tui', + session_id: 'sess-big', + model: 'gpt-5.5', + base_instructions: { text: 'x'.repeat(40_000) }, + }, + }) + await writeSession(tmpDir, '2026-05-02', 'rollout-big.jsonl', [ + bigPayload, + tokenCount({ last: { input: 100, output: 50 }, total: { total: 150 } }), + ]) + + const provider = createCodexProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(1) + expect(sessions[0]!.path).toContain('rollout-big.jsonl') + // Confirm the large meta line was actually parsed (cwd extracted), + // not just that some path was registered. + expect(sessions[0]!.project).toBe('Users-test-big') + }) + + it('handles a session_meta line without trailing newline', async () => { + const [year, month, day] = '2026-05-02'.split('-') + const sessionDir = join(tmpDir, 'sessions', year!, month!, day!) + await mkdir(sessionDir, { recursive: true }) + // Write a single session_meta line, deliberately without a trailing \n. + await writeFile( + join(sessionDir, 'rollout-no-nl.jsonl'), + JSON.stringify({ + type: 'session_meta', + timestamp: '2026-05-02T00:00:00Z', + payload: { + cwd: '/Users/test/nonl', + originator: 'codex-tui', + session_id: 'sess-nonl', + model: 'gpt-5.5', + }, + }), + ) + const provider = createCodexProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(1) + expect(sessions[0]!.project).toBe('Users-test-nonl') + }) + + it('handles a session_meta line that spans multiple stream chunks', async () => { + // createReadStream defaults to a 64 KiB highWaterMark, so a >64 KiB first + // line forces readline to assemble the line across chunk boundaries. + const bigPayload = JSON.stringify({ + type: 'session_meta', + timestamp: '2026-05-02T00:00:00Z', + payload: { + cwd: '/Users/test/multichunk', + originator: 'codex-tui', + session_id: 'sess-multichunk', + model: 'gpt-5.5', + base_instructions: { text: 'y'.repeat(120_000) }, + }, + }) + await writeSession(tmpDir, '2026-05-02', 'rollout-multichunk.jsonl', [ + bigPayload, + tokenCount({ last: { input: 100, output: 50 }, total: { total: 150 } }), + ]) + const provider = createCodexProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(1) + expect(sessions[0]!.project).toBe('Users-test-multichunk') + }) + + it('rejects truncated/torn first-line writes without throwing', async () => { + // Simulate a partial write where Codex started the session_meta object + // but hasn't flushed the rest yet (no closing brace, no newline). + const [year, month, day] = '2026-05-02'.split('-') + const sessionDir = join(tmpDir, 'sessions', year!, month!, day!) + await mkdir(sessionDir, { recursive: true }) + await writeFile( + join(sessionDir, 'rollout-torn.jsonl'), + '{"type":"session_meta","timestamp":"2026-05-02T00:00:00Z","payload":{"cwd":"/x","originator":"codex-tui","session_id":"s","model":"gpt', + ) + const provider = createCodexProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(0) + }) + + it('returns no sessions for an empty rollout file', async () => { + const [year, month, day] = '2026-05-02'.split('-') + const sessionDir = join(tmpDir, 'sessions', year!, month!, day!) + await mkdir(sessionDir, { recursive: true }) + await writeFile(join(sessionDir, 'rollout-empty.jsonl'), '') + const provider = createCodexProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(0) + }) + + it('skips files without codex session_meta', async () => { + const [year, month, day] = '2026-04-14'.split('-') + const sessionDir = join(tmpDir, 'sessions', year!, month!, day!) + await mkdir(sessionDir, { recursive: true }) + await writeFile( + join(sessionDir, 'rollout-bad.jsonl'), + JSON.stringify({ type: 'other', payload: {} }) + '\n', + ) + + const provider = createCodexProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toEqual([]) + }) +}) + +describe('codex provider - JSONL parsing', () => { + it('extracts token usage from last_token_usage', async () => { + const filePath = await writeSession(tmpDir, '2026-04-14', 'rollout-parse.jsonl', [ + sessionMeta({ session_id: 'sess-parse', model: 'gpt-5.3-codex' }), + userMessage('fix the bug'), + functionCall('exec_command'), + functionCall('read_file'), + tokenCount({ + timestamp: '2026-04-14T10:01:00Z', + last: { input: 500, cached: 100, output: 200, reasoning: 50 }, + total: { total: 850 }, + }), + ]) + + const provider = createCodexProvider(tmpDir) + const source = { path: filePath, project: 'test', provider: 'codex' } + const parser = provider.createSessionParser(source, new Set()) + const calls: ParsedProviderCall[] = [] + for await (const call of parser.parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.provider).toBe('codex') + expect(call.model).toBe('gpt-5.3-codex') + expect(call.inputTokens).toBe(400) + expect(call.cachedInputTokens).toBe(100) + expect(call.cacheReadInputTokens).toBe(100) + expect(call.outputTokens).toBe(200) + expect(call.reasoningTokens).toBe(50) + expect(call.tools).toEqual(['Bash', 'Read']) + expect(call.userMessage).toBe('fix the bug') + expect(call.sessionId).toBe('sess-parse') + expect(call.costUSD).toBeGreaterThan(0) + expect(call.deduplicationKey).toContain('codex:') + }) + + it('attributes MCP calls emitted as event_msg/mcp_tool_call_end', async () => { + const filePath = await writeSession(tmpDir, '2026-04-14', 'rollout-mcp.jsonl', [ + sessionMeta({ session_id: 'sess-mcp', model: 'gpt-5.5' }), + userMessage('look up the issue'), + mcpToolCallEnd('github', 'get_issue'), + tokenCount({ + timestamp: '2026-04-14T10:01:00Z', + last: { input: 300, output: 100 }, + total: { total: 400 }, + }), + ]) + + const provider = createCodexProvider(tmpDir) + const source = { path: filePath, project: 'test', provider: 'codex' } + const parser = provider.createSessionParser(source, new Set()) + const calls: ParsedProviderCall[] = [] + for await (const call of parser.parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(1) + expect(calls[0]!.tools).toEqual(['mcp__github__get_issue']) + }) + + it('attributes CLI-wrapped MCP calls (mcp-cli call server tool) to MCP + Bash', async () => { + const execStr = (command: string) => JSON.stringify({ + type: 'response_item', + timestamp: '2026-04-14T10:00:30Z', + payload: { type: 'function_call', name: 'exec_command', arguments: JSON.stringify({ command }) }, + }) + // command as an array (Codex sometimes logs argv form). + const execArr = (command: string[]) => JSON.stringify({ + type: 'response_item', + timestamp: '2026-04-14T10:00:30Z', + payload: { type: 'function_call', name: 'exec_command', arguments: JSON.stringify({ command }) }, + }) + const filePath = await writeSession(tmpDir, '2026-04-14', 'rollout-mcpcli.jsonl', [ + sessionMeta({ session_id: 'sess-mcpcli', model: 'gpt-5.5' }), + userMessage('look up an issue via the MCP CLI'), + // Real invocation forms that MUST attribute to MCP: + execStr("bash -lc \"mcp-cli call github get_issue '{\\\"id\\\": 5}'\""), // bash -lc wrapper + execStr('mcp-cli -c ./mcp.json call linear list_issues'), // flags before subcommand + execArr(['mcp-cli', 'call', 'slack', 'post_message', '{}']), // argv array form + // Lookups and unrelated commands that must NOT attribute: + execStr('mcp-cli info github'), + execStr('mcp-cli grep "*issue*"'), + execStr('my-mcp-cli-wrapper call github get_issue'), // not the mcp-cli binary + execStr('ls -la'), + tokenCount({ timestamp: '2026-04-14T10:01:00Z', last: { input: 300, output: 100 }, total: { total: 400 } }), + ]) + + const provider = createCodexProvider(tmpDir) + const source = { path: filePath, project: 'test', provider: 'codex' } + const parser = provider.createSessionParser(source, new Set()) + const calls: ParsedProviderCall[] = [] + for await (const call of parser.parse()) calls.push(call) + + expect(calls).toHaveLength(1) + const tools = calls[0]!.tools + // Every exec still counts as Bash (7 exec_commands total). + expect(tools.filter(t => t === 'Bash')).toHaveLength(7) + // Exactly the three `call` invocations attribute to MCP; info/grep/wrapper/ls do not. + expect(tools.filter(t => t.startsWith('mcp__')).sort()).toEqual([ + 'mcp__github__get_issue', + 'mcp__linear__list_issues', + 'mcp__slack__post_message', + ]) + }) + + it('normalizes Codex subagent tool calls to Agent', async () => { + const filePath = await writeSession(tmpDir, '2026-04-14', 'rollout-agent.jsonl', [ + sessionMeta({ session_id: 'sess-agent', model: 'gpt-5.5' }), + userMessage('delegate the review'), + functionCall('spawn_agent'), + functionCall('wait_agent'), + functionCall('close_agent'), + tokenCount({ + timestamp: '2026-04-14T10:01:00Z', + last: { input: 300, output: 100 }, + total: { total: 400 }, + }), + ]) + + const provider = createCodexProvider(tmpDir) + const source = { path: filePath, project: 'test', provider: 'codex' } + const parser = provider.createSessionParser(source, new Set()) + const calls: ParsedProviderCall[] = [] + for await (const call of parser.parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(1) + expect(calls[0]!.tools).toEqual(['Agent', 'Agent', 'Agent']) + }) + + it('skips duplicate token_count events', async () => { + const filePath = await writeSession(tmpDir, '2026-04-14', 'rollout-dedup.jsonl', [ + sessionMeta(), + tokenCount({ + timestamp: '2026-04-14T10:01:00Z', + last: { input: 500, output: 200 }, + total: { total: 700 }, + }), + tokenCount({ + timestamp: '2026-04-14T10:01:01Z', + last: { input: 500, output: 200 }, + total: { total: 700 }, + }), + tokenCount({ + timestamp: '2026-04-14T10:02:00Z', + last: { input: 300, output: 100 }, + total: { total: 1100 }, + }), + ]) + + const provider = createCodexProvider(tmpDir) + const source = { path: filePath, project: 'test', provider: 'codex' } + const parser = provider.createSessionParser(source, new Set()) + const calls: ParsedProviderCall[] = [] + for await (const call of parser.parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(2) + expect(calls[0]!.inputTokens).toBe(500) + expect(calls[1]!.inputTokens).toBe(300) + }) + + it('does not drop the first event when total_token_usage is omitted (cumulativeTotal=0)', async () => { + // Regression for the prevCumulativeTotal-initialized-to-0 bug. Sessions + // that emit only last_token_usage (no total_token_usage) report + // cumulativeTotal=0 on every event. With a 0-initialized prev, the first + // event matched the dedup guard and was silently dropped, losing the + // session's opening turn. The null sentinel fixes this. + const filePath = await writeSession(tmpDir, '2026-04-14', 'rollout-zero-total.jsonl', [ + sessionMeta(), + tokenCount({ + timestamp: '2026-04-14T10:01:00Z', + last: { input: 500, output: 200 }, + // No `total` — info.total_token_usage will be undefined. + }), + tokenCount({ + timestamp: '2026-04-14T10:01:01Z', + last: { input: 100, output: 50 }, + }), + ]) + + const provider = createCodexProvider(tmpDir) + const source = { path: filePath, project: 'test', provider: 'codex' } + const parser = provider.createSessionParser(source, new Set()) + const calls: ParsedProviderCall[] = [] + for await (const call of parser.parse()) { + calls.push(call) + } + + // Both events should produce calls — the first with input=500, second + // with input=100. With the buggy 0-init, only the second would survive + // (or neither, depending on equality timing). + expect(calls.length).toBeGreaterThanOrEqual(1) + expect(calls[0]!.inputTokens).toBe(500) + }) + + it('still dedups consecutive zero-cumulative duplicates', async () => { + // The other half of the regression: two consecutive events with the + // same cumulativeTotal (here both 0 because total_token_usage is + // omitted) and identical last_token_usage must NOT both ingest. The + // second is a duplicate. + const filePath = await writeSession(tmpDir, '2026-04-14', 'rollout-zero-dup.jsonl', [ + sessionMeta(), + tokenCount({ + timestamp: '2026-04-14T10:01:00Z', + last: { input: 500, output: 200 }, + }), + tokenCount({ + timestamp: '2026-04-14T10:01:01Z', + last: { input: 500, output: 200 }, + }), + ]) + + const provider = createCodexProvider(tmpDir) + const source = { path: filePath, project: 'test', provider: 'codex' } + const parser = provider.createSessionParser(source, new Set()) + const calls: ParsedProviderCall[] = [] + for await (const call of parser.parse()) { + calls.push(call) + } + expect(calls).toHaveLength(1) + }) +}) + +describe('codex provider - forked session dedupe', () => { + // Aggregate every discovered session through ONE shared seenKeys, exactly as + // the real provider report does, then sum the global token total. + async function aggregateTokens(dir: string): Promise<{ tokens: number; calls: number }> { + const provider = createCodexProvider(dir) + const sessions = (await provider.discoverSessions()).sort((a, b) => (a.path < b.path ? -1 : 1)) + const seenKeys = new Set<string>() + let tokens = 0 + let calls = 0 + for (const s of sessions) { + for await (const c of provider.createSessionParser(s, seenKeys).parse()) { + calls++ + tokens += c.inputTokens + c.outputTokens + c.cachedInputTokens + c.reasoningTokens + } + } + return { tokens, calls } + } + + it('does not double-count a fork that replays the parent past the 5s cutoff', async () => { + // Parent does 1100 tokens of real work. The fork replays both events with + // timestamps well beyond the 5s fork cutoff, then adds one genuine event + // (+400). The replays must collide with the parent and drop, so the global + // total is 1500 -- not 2600 (which keying on the fork's own session id would + // produce by double-counting the replayed history). + await writeSession(tmpDir, '2026-04-14', 'rollout-1-parent.jsonl', [ + sessionMeta({ session_id: 'sess-parent' }), + tokenCount({ timestamp: '2026-04-14T10:00:01Z', last: { input: 700 }, total: { total: 700 } }), + tokenCount({ timestamp: '2026-04-14T10:00:02Z', last: { input: 400 }, total: { total: 1100 } }), + ]) + await writeSession(tmpDir, '2026-04-14', 'rollout-2-fork.jsonl', [ + sessionMeta({ session_id: 'sess-fork', forked_from_id: 'sess-parent' }), + tokenCount({ timestamp: '2026-04-14T10:00:10Z', last: { input: 700 }, total: { total: 700 } }), + tokenCount({ timestamp: '2026-04-14T10:00:11Z', last: { input: 400 }, total: { total: 1100 } }), + tokenCount({ timestamp: '2026-04-14T10:00:12Z', last: { input: 400 }, total: { total: 1500 } }), + ]) + + const { tokens } = await aggregateTokens(tmpDir) + expect(tokens).toBe(1500) + }) + + it('keeps a genuine divergent fork event that shares a cumulative total with the parent', async () => { + // Parent reaches cumulative 1600 via input (last input 500). The fork replays + // 700 and 1100, then does genuinely different work that also reaches + // cumulative 1600 but via OUTPUT (last output 500). Keying on cumulativeTotal + // alone would collide the fork's 1600 with the parent's 1600 and drop it + // (undercount, losing 500). The content-addressed key keeps both. + await writeSession(tmpDir, '2026-04-14', 'rollout-1-parent.jsonl', [ + sessionMeta({ session_id: 'sess-parent' }), + tokenCount({ timestamp: '2026-04-14T10:00:01Z', last: { input: 700 }, total: { total: 700 } }), + tokenCount({ timestamp: '2026-04-14T10:00:02Z', last: { input: 400 }, total: { total: 1100 } }), + tokenCount({ timestamp: '2026-04-14T10:00:03Z', last: { input: 500 }, total: { input: 1600, total: 1600 } }), + ]) + await writeSession(tmpDir, '2026-04-14', 'rollout-2-fork.jsonl', [ + sessionMeta({ session_id: 'sess-fork', forked_from_id: 'sess-parent' }), + tokenCount({ timestamp: '2026-04-14T10:00:10Z', last: { input: 700 }, total: { total: 700 } }), + tokenCount({ timestamp: '2026-04-14T10:00:11Z', last: { input: 400 }, total: { total: 1100 } }), + tokenCount({ timestamp: '2026-04-14T10:00:12Z', last: { output: 500 }, total: { input: 1100, output: 500, total: 1600 } }), + ]) + + const { tokens } = await aggregateTokens(tmpDir) + // parent 1600 + fork's genuine +500 = 2100; replays (700, 1100) dropped. + expect(tokens).toBe(2100) + }) + + it('does not overcount a total-only fork whose replay straddles the 5s cutoff', async () => { + // The dedupe key must be derived from the cumulative token breakdown, not + // per-event deltas. In the fallback branch (events with total_token_usage + // but no last_token_usage), the delta is computed against a running `prev`. + // A fork skips replays within 5s of the fork (prev NOT advanced), so a + // replay kept just past the cutoff would compute a different delta than the + // parent did and, with a delta-based key, fail to dedupe -> double-count. + // The cumulative totals are copied verbatim, so a cumulative-based key + // collides regardless of the cutoff. Parent does 300 tokens; the fork is a + // pure replay (no new work), so the global total must stay 300. + await writeSession(tmpDir, '2026-04-14', 'rollout-1-parent.jsonl', [ + sessionMeta({ session_id: 'sess-parent' }), + tokenCount({ timestamp: '2026-04-14T10:00:01Z', total: { input: 100, total: 100 } }), + tokenCount({ timestamp: '2026-04-14T10:00:02Z', total: { input: 200, total: 200 } }), + tokenCount({ timestamp: '2026-04-14T10:00:03Z', total: { input: 300, total: 300 } }), + ]) + await writeSession(tmpDir, '2026-04-14', 'rollout-2-fork.jsonl', [ + sessionMeta({ session_id: 'sess-fork', forked_from_id: 'sess-parent' }), + // 10:00:01 is within the 5s cutoff -> skipped (prev not advanced). + tokenCount({ timestamp: '2026-04-14T10:00:01Z', total: { input: 100, total: 100 } }), + // These land past the cutoff and replay the parent's cumulative totals. + tokenCount({ timestamp: '2026-04-14T10:00:08Z', total: { input: 200, total: 200 } }), + tokenCount({ timestamp: '2026-04-14T10:00:09Z', total: { input: 300, total: 300 } }), + ]) + + const { tokens } = await aggregateTokens(tmpDir) + expect(tokens).toBe(300) + }) +}) diff --git a/tests/providers/copilot.test.ts b/tests/providers/copilot.test.ts new file mode 100644 index 0000000..89586a5 --- /dev/null +++ b/tests/providers/copilot.test.ts @@ -0,0 +1,1825 @@ +import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm } from 'fs/promises' +import { join, posix, win32 } from 'path' +import { tmpdir } from 'os' +import { createRequire } from 'node:module' + +import { copilot, createCopilotProvider, getVSCodeGlobalStorageDirs, getVSCodeWorkspaceStorageDirs } from '../../src/providers/copilot.js' +import { isSqliteAvailable } from '../../src/sqlite.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +async function createSessionDir(sessionId: string, lines: string[], cwd = '/home/user/myproject') { + const sessionDir = join(tmpDir, sessionId) + await mkdir(sessionDir, { recursive: true }) + await writeFile(join(sessionDir, 'workspace.yaml'), `id: ${sessionId}\ncwd: ${cwd}\n`) + await writeFile(join(sessionDir, 'events.jsonl'), lines.join('\n') + '\n') + return join(sessionDir, 'events.jsonl') +} + +function modelChange(newModel: string, previousModel?: string) { + return JSON.stringify({ type: 'session.model_change', timestamp: '2026-04-15T10:00:01Z', data: { newModel, previousModel } }) +} + +function userMessage(content: string) { + return JSON.stringify({ type: 'user.message', timestamp: '2026-04-15T10:00:10Z', data: { content, interactionId: 'int-1' } }) +} + +function assistantMessage(opts: { messageId: string; outputTokens: number; tools?: string[]; timestamp?: string }) { + return JSON.stringify({ + type: 'assistant.message', + timestamp: opts.timestamp ?? '2026-04-15T10:00:15Z', + data: { + messageId: opts.messageId, + outputTokens: opts.outputTokens, + interactionId: 'int-1', + toolRequests: (opts.tools ?? []).map(name => ({ name, toolCallId: `call-${name}`, type: 'function' })), + }, + }) +} + +function transcriptSessionStart(sessionId: string) { + return JSON.stringify({ type: 'session.start', data: { sessionId, producer: 'copilot-agent' } }) +} + +function transcriptUserMessage(content: string) { + return JSON.stringify({ type: 'user.message', data: { content, attachments: [] } }) +} + +function transcriptAssistantMessage(opts: { messageId: string; content?: string; reasoningText?: string; toolCallIds?: string[]; toolNames?: string[] }) { + return JSON.stringify({ + type: 'assistant.message', + data: { + messageId: opts.messageId, + content: opts.content ?? '', + reasoningText: opts.reasoningText ?? '', + toolRequests: (opts.toolCallIds ?? []).map((id, i) => ({ + toolCallId: id, + name: opts.toolNames?.[i] ?? (i === 0 ? 'read_file' : 'run_in_terminal'), + type: 'function', + })), + }, + }) +} + +function chatSessionSampleRequest(overrides: Record<string, unknown> = {}) { + return { + requestId: 'request_8c8ce017-6e3f-460a-9931-5a16825d231a', + modelId: 'copilot/claude-sonnet-4.6', + completionTokens: 490, + result: { + metadata: { + promptTokens: 32543, + outputTokens: 60, + resolvedModel: 'claude-sonnet-4-6', + toolCallRounds: [{ thinking: { tokens: 0 }, modelId: 'claude-sonnet-4.6' }], + agentId: 'github.copilot.editsAgent', + }, + }, + ...overrides, + } +} + +async function createChatSessionFile(filePath: string, entries: unknown[]) { + await writeFile(filePath, entries.map(entry => JSON.stringify(entry)).join('\n') + '\n') +} + +async function collectCalls(source: { path: string; project: string; provider: string; sourceType?: string }, seenKeys = new Set<string>()) { + const calls: ParsedProviderCall[] = [] + for await (const call of copilot.createSessionParser(source, seenKeys).parse()) calls.push(call) + return calls +} + +describe('copilot provider - JSONL parsing', () => { + beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'copilot-test-')) + }) + + afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) + }) + + it('parses a basic assistant message', async () => { + const eventsPath = await createSessionDir('sess-001', [ + modelChange('gpt-4.1'), + userMessage('write a function'), + assistantMessage({ messageId: 'msg-1', outputTokens: 150 }), + ]) + + const source = { path: eventsPath, project: 'myproject', provider: 'copilot' } + const calls: ParsedProviderCall[] = [] + for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.provider).toBe('copilot') + expect(call.model).toBe('gpt-4.1') + expect(call.outputTokens).toBe(150) + expect(call.inputTokens).toBe(0) + expect(call.userMessage).toBe('write a function') + expect(call.sessionId).toBe('sess-001') + expect(call.bashCommands).toEqual([]) + expect(call.costUSD).toBeGreaterThan(0) + }) + + it('tracks model changes mid-session', async () => { + const eventsPath = await createSessionDir('sess-002', [ + modelChange('gpt-5-mini'), + userMessage('first'), + assistantMessage({ messageId: 'msg-1', outputTokens: 50, timestamp: '2026-04-15T10:00:10Z' }), + modelChange('gpt-4.1', 'gpt-5-mini'), + userMessage('second'), + assistantMessage({ messageId: 'msg-2', outputTokens: 80, timestamp: '2026-04-15T10:01:00Z' }), + ]) + + const source = { path: eventsPath, project: 'test', provider: 'copilot' } + const calls: ParsedProviderCall[] = [] + for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(2) + expect(calls[0]!.model).toBe('gpt-5-mini') + expect(calls[1]!.model).toBe('gpt-4.1') + }) + + it('extracts tool names from toolRequests', async () => { + const eventsPath = await createSessionDir('sess-003', [ + modelChange('gpt-4.1'), + userMessage('run tests'), + assistantMessage({ messageId: 'msg-1', outputTokens: 60, tools: ['bash', 'read_file', 'write_file'] }), + ]) + + const source = { path: eventsPath, project: 'test', provider: 'copilot' } + const calls: ParsedProviderCall[] = [] + for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls[0]!.tools).toEqual(['Bash', 'Read', 'Edit']) + }) + + it('normalizes Copilot MCP tool names from toolRequests', async () => { + const eventsPath = await createSessionDir('sess-mcp-tools', [ + modelChange('gpt-4.1'), + userMessage('list MCP-backed tasks and issues'), + assistantMessage({ + messageId: 'msg-1', + outputTokens: 60, + tools: ['github-mcp-server-list_issues', 'cyberday-get_tasks', 'mempalace-mempalace_search', 'bash'], + }), + ]) + + const source = { path: eventsPath, project: 'test', provider: 'copilot' } + const calls: ParsedProviderCall[] = [] + for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls[0]!.tools).toEqual([ + 'mcp__github_mcp_server__list_issues', + 'mcp__cyberday__get_tasks', + 'mcp__mempalace__mempalace_search', + 'Bash', + ]) + }) + + it('does not crash on malformed toolRequests (string / null / missing)', async () => { + // Regression guard: a corrupt session previously aborted the whole file's + // parse loop because .map was called on a non-array. The fix coerces any + // non-array shape (string, null, missing) to []. We mix one corrupt event + // between two healthy events and assert both healthy events still parse. + const corruptToolRequestsString = JSON.stringify({ + type: 'assistant.message', + timestamp: '2026-04-15T10:00:15Z', + data: { messageId: 'corrupt-string', outputTokens: 50, toolRequests: 'not an array' }, + }) + const corruptToolRequestsNull = JSON.stringify({ + type: 'assistant.message', + timestamp: '2026-04-15T10:00:16Z', + data: { messageId: 'corrupt-null', outputTokens: 50, toolRequests: null }, + }) + const eventsPath = await createSessionDir('sess-corrupt', [ + modelChange('gpt-4.1'), + assistantMessage({ messageId: 'msg-before', outputTokens: 100 }), + corruptToolRequestsString, + corruptToolRequestsNull, + assistantMessage({ messageId: 'msg-after', outputTokens: 200 }), + ]) + + const source = { path: eventsPath, project: 'test', provider: 'copilot' } + const calls: ParsedProviderCall[] = [] + for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call) + + // The healthy messages BEFORE and AFTER the corrupt events both parse — + // proving that the corrupt event no longer aborts the per-file parse loop. + // Pre-fix, .map on a non-array threw and we'd see < 4 calls. + expect(calls).toHaveLength(4) + expect(calls.find(c => c.outputTokens === 100)).toBeDefined() // msg-before + expect(calls.find(c => c.outputTokens === 200)).toBeDefined() // msg-after + // Corrupt events produce calls with empty tools, not crashes. + const corruptCalls = calls.filter(c => c.outputTokens === 50) + expect(corruptCalls.length).toBe(2) + for (const c of corruptCalls) { + expect(c.tools).toEqual([]) + } + }) + + it('ignores malformed non-string tool names', async () => { + const malformedToolName = JSON.stringify({ + type: 'assistant.message', + timestamp: '2026-04-15T10:00:15Z', + data: { + messageId: 'malformed-tool-name', + outputTokens: 50, + toolRequests: [null, { name: 123, toolCallId: 'call-bad', type: 'function' }], + }, + }) + const eventsPath = await createSessionDir('sess-malformed-tool-name', [ + modelChange('gpt-4.1'), + malformedToolName, + assistantMessage({ messageId: 'msg-after', outputTokens: 100, tools: ['github-mcp-server-list_issues'] }), + ]) + + const source = { path: eventsPath, project: 'test', provider: 'copilot' } + const calls: ParsedProviderCall[] = [] + for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(2) + expect(calls[0]!.tools).toEqual([]) + expect(calls[1]!.tools).toEqual(['mcp__github_mcp_server__list_issues']) + }) + + it('skips assistant messages with zero outputTokens', async () => { + const eventsPath = await createSessionDir('sess-004', [ + modelChange('gpt-4.1'), + assistantMessage({ messageId: 'msg-empty', outputTokens: 0 }), + assistantMessage({ messageId: 'msg-real', outputTokens: 42 }), + ]) + + const source = { path: eventsPath, project: 'test', provider: 'copilot' } + const calls: ParsedProviderCall[] = [] + for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.outputTokens).toBe(42) + }) + + it('deduplicates messages across parser runs', async () => { + const eventsPath = await createSessionDir('sess-005', [ + modelChange('gpt-4.1'), + assistantMessage({ messageId: 'msg-dup', outputTokens: 100 }), + ]) + + const source = { path: eventsPath, project: 'test', provider: 'copilot' } + const seenKeys = new Set<string>() + + const calls1: ParsedProviderCall[] = [] + for await (const call of copilot.createSessionParser(source, seenKeys).parse()) calls1.push(call) + + const calls2: ParsedProviderCall[] = [] + for await (const call of copilot.createSessionParser(source, seenKeys).parse()) calls2.push(call) + + expect(calls1).toHaveLength(1) + expect(calls2).toHaveLength(0) + }) + + it('returns empty for missing file', async () => { + const source = { path: '/nonexistent/events.jsonl', project: 'test', provider: 'copilot' } + const calls: ParsedProviderCall[] = [] + for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call) + expect(calls).toHaveLength(0) + }) + + it('skips assistant messages before the first model_change event', async () => { + const eventsPath = await createSessionDir('sess-no-model', [ + assistantMessage({ messageId: 'msg-early', outputTokens: 50 }), + modelChange('gpt-4.1'), + assistantMessage({ messageId: 'msg-after', outputTokens: 80 }), + ]) + + const source = { path: eventsPath, project: 'test', provider: 'copilot' } + const calls: ParsedProviderCall[] = [] + for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.outputTokens).toBe(80) + expect(calls[0]!.model).toBe('gpt-4.1') + }) + + it('infers OpenAI auto bucket for transcript toolCallId prefix call_', async () => { + const eventsPath = await createSessionDir('sess-tr-call', [ + transcriptSessionStart('sess-tr-call'), + transcriptUserMessage('check model inference'), + transcriptAssistantMessage({ + messageId: 'msg-1', + content: 'done', + toolCallIds: ['call_abc123'], + }), + ]) + + const source = { path: eventsPath, project: 'test', provider: 'copilot' } + const calls: ParsedProviderCall[] = [] + for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe('copilot-openai-auto') + }) + + it('infers Anthropic auto bucket for transcript toolCallId prefixes tooluse_/toolu_vrtx_', async () => { + const eventsPath = await createSessionDir('sess-tr-claude', [ + transcriptSessionStart('sess-tr-claude'), + transcriptUserMessage('check model inference'), + transcriptAssistantMessage({ + messageId: 'msg-1', + content: 'done', + toolCallIds: ['tooluse_XY', 'toolu_vrtx_01ABC'], + }), + ]) + + const source = { path: eventsPath, project: 'test', provider: 'copilot' } + const calls: ParsedProviderCall[] = [] + for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe('copilot-anthropic-auto') + }) + + it('chooses the dominant inferred transcript model when prefixes are mixed', async () => { + const eventsPath = await createSessionDir('sess-tr-mixed', [ + transcriptSessionStart('sess-tr-mixed'), + transcriptUserMessage('mixed'), + transcriptAssistantMessage({ + messageId: 'msg-1', + content: 'one', + toolCallIds: ['toolu_bdrk_123'], + }), + transcriptAssistantMessage({ + messageId: 'msg-2', + content: 'two', + toolCallIds: ['call_1'], + }), + transcriptAssistantMessage({ + messageId: 'msg-3', + content: 'three', + toolCallIds: ['call_2'], + }), + ]) + + const source = { path: eventsPath, project: 'test', provider: 'copilot' } + const calls: ParsedProviderCall[] = [] + for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(3) + expect(calls.every(c => c.model === 'copilot-openai-auto')).toBe(true) + }) + + it('normalizes Copilot MCP tool names from VS Code transcripts', async () => { + const eventsPath = await createSessionDir('sess-tr-mcp-tools', [ + transcriptSessionStart('sess-tr-mcp-tools'), + transcriptUserMessage('use GitHub MCP'), + transcriptAssistantMessage({ + messageId: 'msg-1', + content: 'done', + toolCallIds: ['call_abc123', 'call_def456'], + toolNames: ['github-mcp-server-list_issues', 'read_file'], + }), + ]) + + const source = { path: eventsPath, project: 'test', provider: 'copilot' } + const calls: ParsedProviderCall[] = [] + for await (const call of copilot.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.tools).toEqual(['mcp__github_mcp_server__list_issues', 'Read']) + }) +}) + +describe('copilot provider - chatSessions parsing', () => { + beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'copilot-chatsessions-test-')) + vi.stubEnv('CODEBURN_COPILOT_DISABLE_OTEL', '1') + }) + + afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) + vi.unstubAllEnvs() + }) + + it('parses sample journal token counts and cost', async () => { + const filePath = join(tmpDir, 'sample.jsonl') + await createChatSessionFile(filePath, [ + { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'chat-session-1', requests: [] } }, + { kind: 2, k: ['requests'], v: [chatSessionSampleRequest()] }, + ]) + + const calls = await collectCalls({ path: filePath, project: 'myproject', provider: 'copilot', sourceType: 'chatsession' }) + + expect(calls).toHaveLength(1) + expect(calls[0]!.inputTokens).toBe(32543) + expect(calls[0]!.outputTokens).toBe(60) + expect(calls[0]!.model).toBe('claude-sonnet-4-6') + expect(calls[0]!.costUSD).toBeGreaterThan(0) + }) + + it('returns no calls for an empty reconstructed requests array', async () => { + const filePath = join(tmpDir, 'empty.jsonl') + await createChatSessionFile(filePath, [ + { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'chat-empty', requests: [] } }, + ]) + + const calls = await collectCalls({ path: filePath, project: 'myproject', provider: 'copilot', sourceType: 'chatsession' }) + + expect(calls).toHaveLength(0) + }) + + it('discovers and parses emptyWindowChatSessions from globalStorage', async () => { + const globalDir = join(tmpDir, 'globalStorage') + const emptyWindowDir = join(globalDir, 'emptyWindowChatSessions') + await mkdir(emptyWindowDir, { recursive: true }) + const filePath = join(emptyWindowDir, 'empty-window.jsonl') + await createChatSessionFile(filePath, [ + { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'empty-window-session', requests: [] } }, + { kind: 2, k: ['requests'], v: [chatSessionSampleRequest()] }, + ]) + + const provider = createCopilotProvider('/nonexistent/legacy', '/nonexistent/ws', globalDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.project).toBe('copilot-chat') + expect((sessions[0] as { sourceType?: string }).sourceType).toBe('chatsession') + + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(sessions[0]!, new Set()).parse()) calls.push(call) + expect(calls).toHaveLength(1) + expect(calls[0]!.inputTokens).toBe(32543) + }) + + it('skips chatSessions discovery when an OTel source is present', async () => { + if (!isSqliteAvailable()) return + + vi.unstubAllEnvs() + const dbPath = join(tmpDir, 'agent-traces.db') + vi.stubEnv('CODEBURN_COPILOT_OTEL_DB', dbPath) + vi.stubEnv('CODEBURN_COPILOT_DISABLE_OTEL', '') + createOtelDb(dbPath) + insertSpan(dbPath, { + spanId: 'span-chatsession-skip', + traceId: 'trace-chatsession-skip', + operationName: 'chat', + startTimeMs: 1000, + attrs: { + 'gen_ai.conversation.id': 'conv-chatsession-skip', + 'gen_ai.response.model': 'gpt-4.1', + 'gen_ai.usage.input_tokens': 100, + 'gen_ai.usage.output_tokens': 10, + }, + }) + + const wsDir = join(tmpDir, 'vscode-ws') + const hashDir = join(wsDir, 'abc123') + const workspaceChatSessionsDir = join(hashDir, 'chatSessions') + const globalDir = join(tmpDir, 'globalStorage') + const emptyWindowDir = join(globalDir, 'emptyWindowChatSessions') + await mkdir(workspaceChatSessionsDir, { recursive: true }) + await mkdir(emptyWindowDir, { recursive: true }) + await writeFile(join(hashDir, 'workspace.json'), JSON.stringify({ folder: 'file:///home/user/myapp' })) + await createChatSessionFile(join(workspaceChatSessionsDir, 'workspace.jsonl'), [ + { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'chat-workspace', requests: [] } }, + { kind: 2, k: ['requests'], v: [chatSessionSampleRequest()] }, + ]) + await createChatSessionFile(join(emptyWindowDir, 'empty-window.jsonl'), [ + { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'chat-empty-window', requests: [] } }, + { kind: 2, k: ['requests'], v: [chatSessionSampleRequest({ requestId: 'request-empty-window' })] }, + ]) + + const provider = createCopilotProvider('/nonexistent/legacy', wsDir, globalDir) + const sources = await provider.discoverSessions() + + expect(sources.filter(s => (s as { sourceType?: string }).sourceType === 'otel')).toHaveLength(1) + expect(sources.filter(s => (s as { sourceType?: string }).sourceType === 'chatsession')).toHaveLength(0) + }) + + it('applies append-then-edit journal updates', async () => { + const filePath = join(tmpDir, 'append-edit.jsonl') + await createChatSessionFile(filePath, [ + { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'chat-edit', requests: [] } }, + { kind: 2, k: ['requests'], v: [chatSessionSampleRequest()] }, + { kind: 1, k: ['requests', 0, 'result', 'metadata', 'outputTokens'], v: 88 }, + ]) + + const calls = await collectCalls({ path: filePath, project: 'myproject', provider: 'copilot', sourceType: 'chatsession' }) + + expect(calls).toHaveLength(1) + expect(calls[0]!.outputTokens).toBe(88) + }) + + it('deduplicates by requestId across parser runs', async () => { + const filePath = join(tmpDir, 'dedupe.jsonl') + await createChatSessionFile(filePath, [ + { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'chat-dedupe', requests: [] } }, + { kind: 2, v: [chatSessionSampleRequest()] }, + ]) + const source = { path: filePath, project: 'myproject', provider: 'copilot', sourceType: 'chatsession' } + const seenKeys = new Set<string>() + + const calls1 = await collectCalls(source, seenKeys) + const calls2 = await collectCalls(source, seenKeys) + + expect(calls1).toHaveLength(1) + expect(calls2).toHaveLength(0) + }) + + it('ignores prototype-pollution journal paths without crashing', async () => { + const filePath = join(tmpDir, 'proto.jsonl') + await createChatSessionFile(filePath, [ + { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'chat-proto', requests: [] } }, + { kind: 1, k: ['__proto__', 'polluted'], v: true }, + { kind: 1, k: ['constructor', 'prototype', 'polluted'], v: true }, + { kind: 2, k: ['requests'], v: [chatSessionSampleRequest()] }, + ]) + + expect(({} as { polluted?: unknown }).polluted).toBeUndefined() + const calls = await collectCalls({ path: filePath, project: 'myproject', provider: 'copilot', sourceType: 'chatsession' }) + + expect(calls).toHaveLength(1) + expect(({} as { polluted?: unknown }).polluted).toBeUndefined() + }) + + it('skips legacy transcripts for a workspace hash that has chatSessions', async () => { + const wsDir = join(tmpDir, 'vscode-ws') + const hashDir = join(wsDir, 'abc123') + const chatSessionsDir = join(hashDir, 'chatSessions') + const transcriptsDir = join(hashDir, 'GitHub.copilot-chat', 'transcripts') + await mkdir(chatSessionsDir, { recursive: true }) + await mkdir(transcriptsDir, { recursive: true }) + await writeFile(join(hashDir, 'workspace.json'), JSON.stringify({ folder: 'file:///home/user/myapp' })) + await createChatSessionFile(join(chatSessionsDir, 'chat.jsonl'), [ + { kind: 0, v: { version: 3, creationDate: 1780157113020, sessionId: 'chat-modern', requests: [] } }, + { kind: 2, k: ['requests'], v: [chatSessionSampleRequest()] }, + ]) + await writeFile(join(transcriptsDir, 'legacy.jsonl'), transcriptSessionStart('legacy') + '\n') + + const provider = createCopilotProvider('/nonexistent/legacy', wsDir, '/nonexistent/global') + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect((sessions[0] as { sourceType?: string }).sourceType).toBe('chatsession') + expect(sessions[0]!.path).toContain(`${join('abc123', 'chatSessions')}`) + }) +}) + +describe('copilot provider - discoverSessions', () => { + beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'copilot-test-')) + // Disable OTel discovery so tests aren't contaminated by real sessions + vi.stubEnv('CODEBURN_COPILOT_DISABLE_OTEL', '1') + }) + + afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) + vi.unstubAllEnvs() + }) + + it('discovers sessions from directory', async () => { + await createSessionDir('sess-disc-001', [modelChange('gpt-4.1')]) + await createSessionDir('sess-disc-002', [modelChange('gpt-4.1')]) + + const provider = createCopilotProvider(tmpDir, '/nonexistent/vscode') + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(2) + expect(sessions.every(s => s.provider === 'copilot')).toBe(true) + expect(sessions.every(s => s.path.endsWith('events.jsonl'))).toBe(true) + }) + + it('reads project name from workspace.yaml cwd', async () => { + await createSessionDir('sess-disc-003', [modelChange('gpt-4.1')], '/home/user/myapp') + + const provider = createCopilotProvider(tmpDir, '/nonexistent/vscode') + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.project).toBe('myapp') + }) + + it('strips quotes and trailing comments from workspace.yaml cwd', async () => { + const sessionDir = join(tmpDir, 'sess-quoted') + await mkdir(sessionDir, { recursive: true }) + await writeFile(join(sessionDir, 'workspace.yaml'), 'cwd: "/home/user/myapp" # project root\n') + await writeFile(join(sessionDir, 'events.jsonl'), '\n') + + const provider = createCopilotProvider(tmpDir, '/nonexistent/vscode') + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.project).toBe('myapp') + }) + + it('returns empty when directory does not exist', async () => { + const provider = createCopilotProvider('/nonexistent/path', '/nonexistent/vscode') + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(0) + }) + + it('skips entries without events.jsonl', async () => { + const emptyDir = join(tmpDir, 'empty-session') + await mkdir(emptyDir, { recursive: true }) + + const provider = createCopilotProvider(tmpDir, '/nonexistent/vscode') + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(0) + }) + + it('discovers VS Code workspace transcripts', async () => { + const wsDir = join(tmpDir, 'vscode-ws') + const transcriptsDir = join(wsDir, 'abc123', 'GitHub.copilot-chat', 'transcripts') + await mkdir(transcriptsDir, { recursive: true }) + await writeFile(join(wsDir, 'abc123', 'workspace.json'), JSON.stringify({ folder: 'file:///home/user/myapp' })) + await writeFile(join(transcriptsDir, 'session-1.jsonl'), JSON.stringify({ type: 'session.start', data: { sessionId: 's1', producer: 'copilot-agent' } }) + '\n') + + const provider = createCopilotProvider('/nonexistent/legacy', wsDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.project).toBe('myapp') + expect(sessions[0]!.path).toContain('session-1.jsonl') + }) + + it('includes VSCodium workspaceStorage paths on all supported platforms', () => { + expect(getVSCodeWorkspaceStorageDirs('/Users/test', 'darwin')).toContain( + posix.join('/Users/test', 'Library', 'Application Support', 'VSCodium', 'User', 'workspaceStorage'), + ) + expect(getVSCodeWorkspaceStorageDirs('C:\\Users\\test', 'win32')).toContain( + win32.join('C:\\Users\\test', 'AppData', 'Roaming', 'VSCodium', 'User', 'workspaceStorage'), + ) + expect(getVSCodeWorkspaceStorageDirs('/home/test', 'linux')).toContain( + posix.join('/home/test', '.config', 'VSCodium', 'User', 'workspaceStorage'), + ) + }) + + it('includes VSCodium globalStorage paths on all supported platforms', () => { + expect(getVSCodeGlobalStorageDirs('/Users/test', 'darwin')).toContain( + posix.join('/Users/test', 'Library', 'Application Support', 'VSCodium', 'User', 'globalStorage'), + ) + expect(getVSCodeGlobalStorageDirs('C:\\Users\\test', 'win32')).toContain( + win32.join('C:\\Users\\test', 'AppData', 'Roaming', 'VSCodium', 'User', 'globalStorage'), + ) + expect(getVSCodeGlobalStorageDirs('/home/test', 'linux')).toContain( + posix.join('/home/test', '.config', 'VSCodium', 'User', 'globalStorage'), + ) + }) +}) + +describe('copilot provider - metadata', () => { + it('has correct name and displayName', () => { + expect(copilot.name).toBe('copilot') + expect(copilot.displayName).toBe('Copilot') + }) + + it('normalizes tool display names', () => { + expect(copilot.toolDisplayName('bash')).toBe('Bash') + expect(copilot.toolDisplayName('read_file')).toBe('Read') + expect(copilot.toolDisplayName('write_file')).toBe('Edit') + expect(copilot.toolDisplayName('web_search')).toBe('WebSearch') + expect(copilot.toolDisplayName('github-mcp-server-list_issues')).toBe('mcp__github_mcp_server__list_issues') + expect(copilot.toolDisplayName('unknown_tool')).toBe('unknown_tool') + }) + + it('normalizes model display names', () => { + expect(copilot.modelDisplayName('gpt-4.1')).toBe('GPT-4.1') + expect(copilot.modelDisplayName('gpt-4.1-mini')).toBe('GPT-4.1 Mini') + expect(copilot.modelDisplayName('gpt-4.1-nano')).toBe('GPT-4.1 Nano') + expect(copilot.modelDisplayName('gpt-5-mini')).toBe('GPT-5 Mini') + expect(copilot.modelDisplayName('o3')).toBe('o3') + expect(copilot.modelDisplayName('o4-mini')).toBe('o4-mini') + expect(copilot.modelDisplayName('copilot-openai-auto')).toBe('Copilot (OpenAI auto)') + expect(copilot.modelDisplayName('copilot-anthropic-auto')).toBe('Copilot (Anthropic auto)') + expect(copilot.modelDisplayName('unknown-model-xyz')).toBe('unknown-model-xyz') + }) + + it('longest-prefix match wins for versioned model IDs', () => { + // gpt-5-mini-2026-01-01 must match gpt-5-mini, not gpt-5 + expect(copilot.modelDisplayName('gpt-5-mini-2026-01-01')).toBe('GPT-5 Mini') + expect(copilot.modelDisplayName('gpt-4.1-mini-2026-01-01')).toBe('GPT-4.1 Mini') + }) +}) + +// --------------------------------------------------------------------------- +// OTel cache token tests +// +// These tests verify that the OTel SQLite parser correctly extracts +// cacheReadInputTokens and cacheCreationInputTokens from the agent-traces.db +// schema, and that multiple conversations from the same DB file are each +// parsed independently with their full cache token data intact. +// +// This is the regression guard for the bug documented in DEBUG_HANDOFF.md: +// cache tokens were extracted during parsing but lost in aggregation because +// all conversations shared the same file path key in the session cache. +// --------------------------------------------------------------------------- + +const requireForTest = createRequire(import.meta.url) + +type TestDb = { + exec(sql: string): void + prepare(sql: string): { run(...params: unknown[]): void } + close(): void +} + +/** Creates a minimal agent-traces.db schema matching the VS Code Copilot Chat OTel store. */ +function createOtelDb(dbPath: string): void { + const { DatabaseSync } = requireForTest('node:sqlite') as { DatabaseSync: new (path: string) => TestDb } + const db = new DatabaseSync(dbPath) + db.exec(` + CREATE TABLE spans ( + span_id TEXT PRIMARY KEY NOT NULL, + trace_id TEXT NOT NULL, + operation_name TEXT, + start_time_ms INTEGER NOT NULL DEFAULT 0, + response_model TEXT + ); + CREATE TABLE span_attributes ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + span_id TEXT NOT NULL, + key TEXT NOT NULL, + value TEXT + ); + `) + db.close() +} + +interface SpanDef { + spanId: string + traceId: string + operationName: string + startTimeMs?: number + responseModel?: string + attrs: Record<string, string | number> +} + +function insertSpan(dbPath: string, span: SpanDef): void { + const { DatabaseSync } = requireForTest('node:sqlite') as { DatabaseSync: new (path: string) => TestDb } + const db = new DatabaseSync(dbPath) + db.prepare( + `INSERT INTO spans (span_id, trace_id, operation_name, start_time_ms, response_model) + VALUES (?, ?, ?, ?, ?)` + ).run(span.spanId, span.traceId, span.operationName, span.startTimeMs ?? 0, span.responseModel ?? null) + const attrStmt = db.prepare( + `INSERT INTO span_attributes (span_id, key, value) VALUES (?, ?, ?)` + ) + for (const [key, value] of Object.entries(span.attrs)) { + attrStmt.run(span.spanId, key, String(value)) + } + db.close() +} + +describe('copilot provider - OTel cache token parsing', () => { + let tmpDir: string + let dbPath: string + + beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'copilot-otel-test-')) + dbPath = join(tmpDir, 'agent-traces.db') + vi.stubEnv('CODEBURN_COPILOT_OTEL_DB', dbPath) + vi.stubEnv('CODEBURN_COPILOT_DISABLE_OTEL', '') + }) + + afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) + vi.unstubAllEnvs() + }) + + it('skips tests when node:sqlite is unavailable', () => { + if (!isSqliteAvailable()) return + // Placeholder — subsequent tests use isSqliteAvailable guard + }) + + it('extracts cache tokens from a single OTel conversation', async () => { + if (!isSqliteAvailable()) return + + createOtelDb(dbPath) + insertSpan(dbPath, { + spanId: 'span-001', + traceId: 'trace-001', + operationName: 'chat', + startTimeMs: 1000, + responseModel: 'gpt-4.1', + attrs: { + 'gen_ai.conversation.id': 'conv-001', + 'gen_ai.response.model': 'gpt-4.1', + 'gen_ai.usage.input_tokens': 1000, + 'gen_ai.usage.output_tokens': 200, + 'gen_ai.usage.cache_read.input_tokens': 50000, + 'gen_ai.usage.cache_creation.input_tokens': 500, + }, + }) + + const provider = createCopilotProvider('/nonexistent/jsonl', '/nonexistent/ws') + const sources = await provider.discoverSessions() + + const otelSources = sources.filter(s => s.path.startsWith(dbPath)) + expect(otelSources).toHaveLength(1) + expect(otelSources[0]!.provider).toBe('copilot') + + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(otelSources[0]!, new Set()).parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.model).toBe('gpt-4.1') + expect(call.inputTokens).toBe(1000) + expect(call.outputTokens).toBe(200) + expect(call.cacheReadInputTokens).toBe(50000) + expect(call.cacheCreationInputTokens).toBe(500) + expect(call.costUSD).toBeGreaterThan(0) + }) + + it('discovers one source per OTel DB file (not per conversation)', async () => { + if (!isSqliteAvailable()) return + + createOtelDb(dbPath) + + // Two independent conversations in the same DB + insertSpan(dbPath, { + spanId: 'span-a1', traceId: 'trace-a', operationName: 'chat', startTimeMs: 1000, + attrs: { + 'gen_ai.conversation.id': 'conv-alpha', + 'gen_ai.response.model': 'gpt-4.1', + 'gen_ai.usage.input_tokens': 800, + 'gen_ai.usage.output_tokens': 100, + 'gen_ai.usage.cache_read.input_tokens': 40000, + 'gen_ai.usage.cache_creation.input_tokens': 400, + }, + }) + insertSpan(dbPath, { + spanId: 'span-b1', traceId: 'trace-b', operationName: 'chat', startTimeMs: 2000, + attrs: { + 'gen_ai.conversation.id': 'conv-beta', + 'gen_ai.response.model': 'claude-sonnet-4', + 'gen_ai.usage.input_tokens': 600, + 'gen_ai.usage.output_tokens': 80, + 'gen_ai.usage.cache_read.input_tokens': 30000, + 'gen_ai.usage.cache_creation.input_tokens': 300, + }, + }) + + const provider = createCopilotProvider('/nonexistent/jsonl', '/nonexistent/ws') + const sources = await provider.discoverSessions() + + // One source per DB file (not per conversation) + const otelSources = sources.filter(s => s.path === dbPath) + expect(otelSources).toHaveLength(1) + expect(otelSources[0]!.path).toBe(dbPath) + + // But the parser still yields calls from BOTH conversations + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(otelSources[0]!, new Set()).parse()) { + calls.push(call) + } + expect(calls).toHaveLength(2) + const sessionIds = new Set(calls.map(c => c.sessionId)) + expect(sessionIds.size).toBe(2) + }) + + it('preserves cache tokens when parsing multiple conversations from one DB', async () => { + if (!isSqliteAvailable()) return + + createOtelDb(dbPath) + + insertSpan(dbPath, { + spanId: 'span-c1', traceId: 'trace-c', operationName: 'chat', startTimeMs: 1000, + attrs: { + 'gen_ai.conversation.id': 'conv-c', + 'gen_ai.response.model': 'gpt-4.1', + 'gen_ai.usage.input_tokens': 500, + 'gen_ai.usage.output_tokens': 100, + 'gen_ai.usage.cache_read.input_tokens': 20000, + 'gen_ai.usage.cache_creation.input_tokens': 200, + }, + }) + insertSpan(dbPath, { + spanId: 'span-d1', traceId: 'trace-d', operationName: 'chat', startTimeMs: 2000, + attrs: { + 'gen_ai.conversation.id': 'conv-d', + 'gen_ai.response.model': 'gpt-4.1', + 'gen_ai.usage.input_tokens': 700, + 'gen_ai.usage.output_tokens': 150, + 'gen_ai.usage.cache_read.input_tokens': 35000, + 'gen_ai.usage.cache_creation.input_tokens': 350, + }, + }) + + const provider = createCopilotProvider('/nonexistent/jsonl', '/nonexistent/ws') + const sources = await provider.discoverSessions() + // One source per DB file — the parser iterates all conversations internally + const otelSource = sources.find(s => s.path === dbPath) + expect(otelSource).toBeDefined() + const allCalls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(otelSource!, new Set()).parse()) { + allCalls.push(call) + } + + expect(allCalls).toHaveLength(2) + + const totalCacheRead = allCalls.reduce((sum, c) => sum + c.cacheReadInputTokens, 0) + const totalCacheCreate = allCalls.reduce((sum, c) => sum + c.cacheCreationInputTokens, 0) + + // Both conversations' cache tokens must survive end-to-end + expect(totalCacheRead).toBe(55000) // 20000 + 35000 + expect(totalCacheCreate).toBe(550) // 200 + 350 + }) + + it('includes tool names from execute_tool spans in the same trace', async () => { + if (!isSqliteAvailable()) return + + createOtelDb(dbPath) + // chat span + insertSpan(dbPath, { + spanId: 'span-e1', traceId: 'trace-e', operationName: 'chat', startTimeMs: 1000, + attrs: { + 'gen_ai.conversation.id': 'conv-e', + 'gen_ai.response.model': 'gpt-4.1', + 'gen_ai.usage.input_tokens': 300, + 'gen_ai.usage.output_tokens': 50, + 'gen_ai.usage.cache_read.input_tokens': 10000, + 'gen_ai.usage.cache_creation.input_tokens': 100, + }, + }) + // execute_tool span in the same trace + insertSpan(dbPath, { + spanId: 'span-e2', traceId: 'trace-e', operationName: 'execute_tool', startTimeMs: 1500, + attrs: { + 'gen_ai.tool.name': 'readFile', + }, + }) + + const provider = createCopilotProvider('/nonexistent/jsonl', '/nonexistent/ws') + const sources = await provider.discoverSessions() + const src = sources.find(s => s.path.startsWith(dbPath)) + expect(src).toBeDefined() + + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(src!, new Set()).parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(1) + expect(calls[0]!.tools).toContain('Read') + expect(calls[0]!.cacheReadInputTokens).toBe(10000) + }) + + it('skips OTel spans with zero input and output tokens', async () => { + if (!isSqliteAvailable()) return + + createOtelDb(dbPath) + insertSpan(dbPath, { + spanId: 'span-f1', traceId: 'trace-f', operationName: 'chat', startTimeMs: 1000, + attrs: { + 'gen_ai.conversation.id': 'conv-f', + 'gen_ai.response.model': 'gpt-4.1', + 'gen_ai.usage.input_tokens': 0, + 'gen_ai.usage.output_tokens': 0, + 'gen_ai.usage.cache_read.input_tokens': 50000, + 'gen_ai.usage.cache_creation.input_tokens': 500, + }, + }) + + const provider = createCopilotProvider('/nonexistent/jsonl', '/nonexistent/ws') + const sources = await provider.discoverSessions() + const src = sources.find(s => s.path.startsWith(dbPath)) + expect(src).toBeDefined() + + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(src!, new Set()).parse()) { + calls.push(call) + } + // Span with zero input AND output tokens is skipped + expect(calls).toHaveLength(0) + }) + + it('OTel source path equals the plain DB file path and durableSources is true', async () => { + if (!isSqliteAvailable()) return + + createOtelDb(dbPath) + insertSpan(dbPath, { + spanId: 'span-g1', traceId: 'trace-g', operationName: 'chat', startTimeMs: 1000, + attrs: { + 'gen_ai.conversation.id': 'conv-g', + 'gen_ai.response.model': 'gpt-4.1', + 'gen_ai.usage.input_tokens': 100, + 'gen_ai.usage.output_tokens': 10, + 'gen_ai.usage.cache_read.input_tokens': 0, + 'gen_ai.usage.cache_creation.input_tokens': 0, + }, + }) + + const provider = createCopilotProvider('/nonexistent/jsonl', '/nonexistent/ws') + + // durableSources must be true on the copilot provider + expect(provider.durableSources).toBe(true) + + const sources = await provider.discoverSessions() + const otelSrc = sources.find(s => s.path.startsWith(dbPath)) + expect(otelSrc).toBeDefined() + + // Path is the plain DB file path (no #otel-conv= compound suffix) + expect(otelSrc!.path).toBe(dbPath) + + // Parser must open the DB and produce results for all conversations + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(otelSrc!, new Set()).parse()) { + calls.push(call) + } + expect(calls).toHaveLength(1) + expect(calls[0]!.inputTokens).toBe(100) + }) + + it('attributes genuine subagents but excludes the root agent', async () => { + if (!isSqliteAvailable()) return + + createOtelDb(dbPath) + + // Root agent turn: chat span + invoke_agent WITHOUT a parent session. + insertSpan(dbPath, { + spanId: 'span-root-chat', traceId: 'trace-root', operationName: 'chat', startTimeMs: 1000, + attrs: { + 'gen_ai.conversation.id': 'conv-h', + 'gen_ai.response.model': 'gpt-4.1', + 'gen_ai.usage.input_tokens': 400, + 'gen_ai.usage.output_tokens': 60, + 'gen_ai.usage.cache_read.input_tokens': 0, + 'gen_ai.usage.cache_creation.input_tokens': 0, + }, + }) + insertSpan(dbPath, { + spanId: 'span-root-agent', traceId: 'trace-root', operationName: 'invoke_agent', startTimeMs: 1010, + attrs: { + 'gen_ai.conversation.id': 'conv-h', + 'gen_ai.agent.name': 'GitHub Copilot Chat', + }, + }) + + // Genuine subagent: its own trace holds the subagent's chat span plus an + // invoke_agent span carrying copilot_chat.parent_chat_session_id. + insertSpan(dbPath, { + spanId: 'span-sub-chat', traceId: 'trace-sub', operationName: 'chat', startTimeMs: 2000, + attrs: { + 'gen_ai.conversation.id': 'conv-h', + 'gen_ai.response.model': 'claude-haiku-4.5', + 'gen_ai.usage.input_tokens': 250, + 'gen_ai.usage.output_tokens': 30, + 'gen_ai.usage.cache_read.input_tokens': 0, + 'gen_ai.usage.cache_creation.input_tokens': 0, + }, + }) + insertSpan(dbPath, { + spanId: 'span-sub-agent', traceId: 'trace-sub', operationName: 'invoke_agent', startTimeMs: 2010, + attrs: { + 'gen_ai.conversation.id': 'conv-h', + 'gen_ai.agent.name': 'Explore', + 'copilot_chat.parent_chat_session_id': 'conv-h', + }, + }) + + const provider = createCopilotProvider('/nonexistent/jsonl', '/nonexistent/ws') + const sources = await provider.discoverSessions() + const src = sources.find(s => s.path.startsWith(dbPath)) + expect(src).toBeDefined() + + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(src!, new Set()).parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(2) + const rootCall = calls.find(c => c.model === 'gpt-4.1')! + const subCall = calls.find(c => c.model === 'claude-haiku-4.5')! + + // Root agent must NOT surface as a subagent + expect(rootCall.subagentTypes ?? []).not.toContain('GitHub Copilot Chat') + expect(rootCall.subagentTypes ?? []).toHaveLength(0) + + // Genuine subagent is attributed to its own call + expect(subCall.subagentTypes).toEqual(['Explore']) + }) + + it('normalises multi-line OTel shell scripts, dropping control-flow keywords', async () => { + if (!isSqliteAvailable()) return + + createOtelDb(dbPath) + insertSpan(dbPath, { + spanId: 'span-sh-chat', traceId: 'trace-sh', operationName: 'chat', startTimeMs: 1000, + attrs: { + 'gen_ai.conversation.id': 'conv-sh', + 'gen_ai.response.model': 'gpt-4.1', + 'gen_ai.usage.input_tokens': 100, + 'gen_ai.usage.output_tokens': 10, + 'gen_ai.usage.cache_read.input_tokens': 0, + 'gen_ai.usage.cache_creation.input_tokens': 0, + }, + }) + // A full multi-line script with control flow and newline-separated commands, + // exactly as the OTel store records it. + insertSpan(dbPath, { + spanId: 'span-sh-tool', traceId: 'trace-sh', operationName: 'execute_tool', startTimeMs: 1500, + attrs: { + 'gen_ai.tool.name': 'run_in_terminal', + 'gen_ai.tool.call.arguments': JSON.stringify({ + command: 'for f in *.ts; do\n echo "$f"\ndone\ngit status\nnpm test', + }), + }, + }) + + const provider = createCopilotProvider('/nonexistent/jsonl', '/nonexistent/ws') + const sources = await provider.discoverSessions() + const src = sources.find(s => s.path.startsWith(dbPath)) + expect(src).toBeDefined() + + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(src!, new Set()).parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(1) + const bash = calls[0]!.bashCommands + // Real commands separated by newlines/`;` are captured + expect(bash).toEqual(expect.arrayContaining(['echo', 'git', 'npm'])) + // Control-flow keywords are NOT reported as commands + for (const kw of ['for', 'do', 'done']) { + expect(bash).not.toContain(kw) + } + }) +}) + +// --------------------------------------------------------------------------- +// JetBrains (IntelliJ / PyCharm / …) session parsing +// --------------------------------------------------------------------------- +// +// The JetBrains Copilot plugin persists sessions to a Nitrite (H2 MVStore) .db +// (~/.config/github-copilot/<ide>/<kind>/<storeId>/copilot-*-nitrite.db) of +// Java-serialized documents. Assistant replies are nested-escaped +// {"__first__":{"type":"Subgraph",…}} blobs; the model and projectName are +// separate serialized fields. These helpers reproduce that on-disk shape so +// tests exercise the real regex/scan extraction path. + +describe('copilot provider - JetBrains parsing', () => { + beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'copilot-jetbrains-test-')) + vi.stubEnv('CODEBURN_COPILOT_DISABLE_OTEL', '1') + }) + + afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) + vi.unstubAllEnvs() + }) + + // A JetBrains source: session content lives in the Nitrite .db. + function jbDbSource(path: string, sessionId: string, mtime = '2026-07-03T12:00:00.000Z') { + return { + path, project: 'copilot-jetbrains', provider: 'copilot', sourceType: 'jetbrains', + sessionId, storeId: sessionId, dbPath: path, mtime, + } as unknown as { path: string; project: string; provider: string; sourceType?: string } + } + + // ---- Nitrite .db parsing ---- + + // Build an assistant response blob in the real nested-escaped shape: + // {"__first__":{"type":"Subgraph","value":"{\"<uuid>\":{\"type\":\"Value\", + // \"value\":\"{\\\"type\\\":\\\"Markdown\\\",\\\"data\\\":\\\"{\\\\\\\"text\\\\\\\":...}\"}"}} + function jbAssistantBlob(text: string, opts: { model?: string; errored?: boolean; files?: string[] } = {}) { + const innerMd = { type: 'Markdown', data: JSON.stringify({ text, annotations: [] }) } + const valueMap: Record<string, unknown> = { + 'a1b2c3d4-0000-0000-0000-000000000001': { type: 'Value', value: JSON.stringify(innerMd) }, + } + if (opts.model) valueMap['__model__'] = { type: 'Value', value: `{"model":"${opts.model}"}` } + // Files the turn referenced — project is derived from these file:// paths. + if (opts.files) { + valueMap['__refs__'] = { + type: 'Value', + value: JSON.stringify({ type: 'References', data: opts.files.map((f) => `file://${f}`).join(' ') }), + } + } + const outer: Record<string, unknown> = { + __first__: { type: 'Subgraph', value: JSON.stringify(valueMap) }, + } + if (opts.errored) { + // Real failed turns store the error under a type:"Error" record with a + // `message` field (NOT a Markdown `text`), so it is not billable output. + outer['__err__'] = { + type: 'Value', + value: JSON.stringify({ type: 'Error', message: 'Sorry, an error occurred while generating a response' }), + } + } + return JSON.stringify(outer) + } + + // An AGENT-MODE assistant blob: the reply lives in an AgentRound record, and + // (as in real agent sessions) the Markdown record holds the USER's prompt, + // which must NOT be counted as the reply. `rounds` is a list of AgentRound + // replies (a single blob can carry several); a pure tool-call round has ''. + function jbAgentBlob(rounds: string[], opts: { model?: string; userPrompt?: string; errored?: boolean } = {}) { + const valueMap: Record<string, unknown> = {} + let n = 0 + // The user prompt as a Markdown record — a decoy the reply extractor must + // skip in agent mode (real stores put the prompt here, not the answer). + if (opts.userPrompt !== undefined) { + const md = { type: 'Markdown', data: JSON.stringify({ text: opts.userPrompt, annotations: [] }) } + valueMap[`u0000000-0000-0000-0000-00000000000${n++}`] = { type: 'Value', value: JSON.stringify(md) } + } + for (const reply of rounds) { + const ar = { type: 'AgentRound', data: JSON.stringify({ roundId: n, reply, toolCalls: [] }) } + valueMap[`a0000000-0000-0000-0000-00000000000${n++}`] = { type: 'Value', value: JSON.stringify(ar) } + } + if (opts.model) valueMap['__model__'] = { type: 'Value', value: `{"model":"${opts.model}"}` } + const outer: Record<string, unknown> = { __first__: { type: 'Subgraph', value: JSON.stringify(valueMap) } } + if (opts.errored) { + outer['__err__'] = { + type: 'Value', + value: JSON.stringify({ type: 'Error', message: 'Sorry, an error occurred while generating a response' }), + } + } + return JSON.stringify(outer) + } + + // A conversation title record in the real framing: `$<GUID>…name…value<TITLE>t\x00\x06source`. + function jbConversationRecord(guid: string, title: string) { + return `$${guid}t\x00\x04namesq\x00\x01?@\x00\x00w\x00\x00t\x00value t\x00${title}t\x00\x06sourcet\x00copilotx` + } + + // Assemble a minimal Nitrite-.db-shaped buffer: MVStore header + entity-class + // anchor + optional conversation records + assistant blobs. When a blob is + // preceded by a conversation record, turns attribute to that conversation. + function jbDbContent(blobs: string[], conversations: string[] = []) { + return ( + 'H:2,block:9,blockSize:1000,format:3\n' + + 'com.github.copilot.agent.session.persistence.nitrite.entity.NtAgentTurn\n' + + conversations.join('\n') + '\n' + + blobs.join('\nt\x00\x00model\n') + + '\n' + ) + } + + async function createJetBrainsDb(root: string, ide: string, kind: string, storeId: string, content: string) { + const dir = join(root, ide, kind, storeId) + await mkdir(dir, { recursive: true }) + const dbName = + kind === 'chat-agent-sessions' + ? 'copilot-agent-sessions-nitrite.db' + : kind === 'chat-edit-sessions' + ? 'copilot-edit-sessions-nitrite.db' + : 'copilot-chat-nitrite.db' + await writeFile(join(dir, dbName), content) + return join(dir, dbName) + } + + // The plugin-recorded project label, in the real Java-serialized framing: + // the field key `projectName` followed by TC_STRING `0x74 <u16 len> <value>`, + // then the sibling `user` field. This is what extractJetBrainsProjectName reads. + function jbProjectNameField(name: string) { + // TC_STRING length is the UTF-8 BYTE count (the .db is written UTF-8 and + // read back as latin1), not the JS UTF-16 code-unit count. + const len = Buffer.byteLength(name, 'utf8') + const hi = String.fromCharCode((len >> 8) & 0xff) + const lo = String.fromCharCode(len & 0xff) + return `t\x00\x0bprojectName\x74${hi}${lo}${name}t\x00\x04usert\x00\x08dev-user` + } + + it('parses assistant turns from a Nitrite .db and estimates cost', async () => { + const content = jbDbContent([ + jbAssistantBlob('Hello! How can I help you today?'), + jbAssistantBlob('Here is a longer architecture overview with plenty of detail.', { model: 'claude-opus-4.5' }), + ]) + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-1', content) + + const calls = await collectCalls(jbDbSource(dbPath, 'conv-1')) + expect(calls).toHaveLength(2) + expect(calls[0]!.outputTokens).toBeGreaterThan(0) + expect(calls[0]!.costIsEstimated).toBe(true) + expect(calls[0]!.inputTokens).toBe(0) + // Per-turn model recovered from inside the blob, normalised dots→dashes. + expect(calls[1]!.model).toBe('claude-opus-4-5') + expect(calls[1]!.costUSD).toBeGreaterThan(0) + // Dedup keys are conversation-scoped, content-derived, and distinct. + expect(calls[0]!.deduplicationKey).toMatch(/^copilot:jb:conv-1:[0-9a-f]{12}:1$/) + expect(calls[1]!.deduplicationKey).toMatch(/^copilot:jb:conv-1:[0-9a-f]{12}:1$/) + expect(calls[0]!.deduplicationKey).not.toBe(calls[1]!.deduplicationKey) + }) + + it('recovers a reply containing quotes without garbling or duplicating it', async () => { + // Regression: the unescape loop must run extraction ONLY on the final, + // fully-unescaped form. Accumulating matches at every depth would union a + // half-unescaped (quote-truncated) capture with the full one, producing a + // garbled duplicate and inflating the token/cost estimate. + const reply = 'Use `printf "%s"` to print, then check "status" here.' + const content = jbDbContent([jbAssistantBlob(reply, { model: 'claude-opus-4.5' })]) + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-quote', content) + + const calls = await collectCalls(jbDbSource(dbPath, 'conv-quote')) + expect(calls).toHaveLength(1) + // Token estimate reflects the true reply length (CHARS_PER_TOKEN = 4), not + // an inflated garbled copy. + expect(calls[0]!.outputTokens).toBe(Math.ceil(reply.length / 4)) + }) + + it('counts a multibyte UTF-8 reply by codepoints, not latin1 bytes', async () => { + // The .db is read as latin1; the parser must re-decode to UTF-8 so a + // multibyte char counts as one codepoint for the token estimate. + const reply = 'café ☕ déjà vu — naïve façade' // several multibyte chars + const content = jbDbContent([jbAssistantBlob(reply, { model: 'claude-opus-4.5' })]) + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-utf8', content) + + const calls = await collectCalls(jbDbSource(dbPath, 'conv-utf8')) + expect(calls).toHaveLength(1) + expect(calls[0]!.outputTokens).toBe(Math.ceil(reply.length / 4)) + }) + + it('extracts agent-mode replies from AgentRound (not the user prompt Markdown)', async () => { + // Agent-mode sessions (e.g. PyCharm) store the reply in an AgentRound record; + // the Markdown record holds the USER prompt. The reply extractor must read + // the AgentRound reply and ignore the prompt — otherwise the turn bills $0 + // (reply never found) or bills the user's words as output. + const reply = "Here's a quick summary of this repo: it does X, Y, and Z." + const content = jbDbContent([ + jbAgentBlob([reply], { model: 'claude-opus-4.5', userPrompt: 'summarise this repo' }), + ]) + const dbPath = await createJetBrainsDb(tmpDir, 'py', 'chat-agent-sessions', 'conv-agent', content) + + const calls = await collectCalls(jbDbSource(dbPath, 'conv-agent')) + expect(calls).toHaveLength(1) + // Priced from the AgentRound reply, not the (shorter) user prompt. + expect(calls[0]!.outputTokens).toBe(Math.ceil(reply.length / 4)) + expect(calls[0]!.costUSD).toBeGreaterThan(0) + expect(calls[0]!.model).toBe('claude-opus-4-5') + }) + + it('skips pure tool-call agent rounds (empty reply → no billable output)', async () => { + // A round that only issued tool calls has reply:'' — it contributes nothing, + // exactly like a Steps-only ask-mode blob. + const content = jbDbContent([jbAgentBlob([''], { model: 'claude-opus-4.5' })]) + const dbPath = await createJetBrainsDb(tmpDir, 'py', 'chat-agent-sessions', 'conv-toolonly', content) + const calls = await collectCalls(jbDbSource(dbPath, 'conv-toolonly')) + expect(calls).toHaveLength(0) + }) + + it('a failed agent turn bills $0 and never counts the user prompt as the reply', async () => { + // Failed agent turn: empty AgentRound reply + an error marker + a user-prompt + // Markdown record. The parser must NOT fall back to the Markdown (that would + // bill the user's words); an agent blob is agent mode regardless of whether + // its reply is empty, so this is an errored turn → $0. + const content = jbDbContent([ + jbAgentBlob([''], { model: 'claude-opus-4.5', userPrompt: 'do the thing', errored: true }), + ]) + const dbPath = await createJetBrainsDb(tmpDir, 'py', 'chat-agent-sessions', 'conv-agenterr', content) + const calls = await collectCalls(jbDbSource(dbPath, 'conv-agenterr')) + expect(calls).toHaveLength(1) + expect(calls[0]!.outputTokens).toBe(0) + expect(calls[0]!.costUSD).toBe(0) + }) + + it('collects multiple AgentRound replies within one blob', async () => { + // A multi-round agent turn: the first round explores (tool call, empty + // reply), the second answers. Both non-empty replies are joined. + const content = jbDbContent([ + jbAgentBlob(['Let me explore the project.', '', 'Done — here is what it does.'], { + model: 'claude-opus-4.5', + }), + ]) + const dbPath = await createJetBrainsDb(tmpDir, 'py', 'chat-agent-sessions', 'conv-multiround', content) + const calls = await collectCalls(jbDbSource(dbPath, 'conv-multiround')) + expect(calls).toHaveLength(1) + const joined = 'Let me explore the project.\nDone — here is what it does.' + expect(calls[0]!.outputTokens).toBe(Math.ceil(joined.length / 4)) + }) + + it('treats errored turns as $0 (failed generation, no billable output)', async () => { + const content = jbDbContent([ + jbAssistantBlob('', { errored: true }), + jbAssistantBlob('A real successful reply.', { model: 'claude-opus-4.5' }), + ]) + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-err', content) + + const calls = await collectCalls(jbDbSource(dbPath, 'conv-err')) + expect(calls).toHaveLength(2) + const errored = calls.find((c) => c.outputTokens === 0) + const good = calls.find((c) => c.outputTokens > 0) + expect(errored).toBeDefined() + expect(errored!.costUSD).toBe(0) + expect(good).toBeDefined() + expect(good!.costUSD).toBeGreaterThan(0) + }) + + it('de-duplicates repeated byte-copies of the same reply within a .db', async () => { + const content = jbDbContent([ + jbAssistantBlob('identical reply text stored twice'), + jbAssistantBlob('identical reply text stored twice'), + ]) + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-dup', content) + + const calls = await collectCalls(jbDbSource(dbPath, 'conv-dup')) + expect(calls).toHaveLength(1) + }) + + it('skips Steps/progress-only assistant blobs (no billable text)', async () => { + const stepsBlob = JSON.stringify({ + __first__: { + type: 'Subgraph', + value: JSON.stringify({ x: { type: 'Value', value: JSON.stringify({ type: 'Steps', data: '[]' }) } }), + }, + }) + const content = jbDbContent([stepsBlob, jbAssistantBlob('The only real answer.')]) + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-steps', content) + + const calls = await collectCalls(jbDbSource(dbPath, 'conv-steps')) + expect(calls).toHaveLength(1) + expect(calls[0]!.outputTokens).toBeGreaterThan(0) + }) + + it('per-turn model differences within one .db (opus vs gpt) are priced separately', async () => { + const content = jbDbContent([ + jbAssistantBlob('Opus answer with enough words to score tokens.', { model: 'claude-opus-4.5' }), + jbAssistantBlob('GPT answer with enough words to score tokens.', { model: 'gpt-5.3' }), + ]) + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-multi', content) + + const calls = await collectCalls(jbDbSource(dbPath, 'conv-multi')) + expect(calls).toHaveLength(2) + expect(calls.map((c) => c.model).sort()).toEqual(['claude-opus-4-5', 'gpt-5.3']) + }) + + it('splits one .db into sessions by conversation; project = repo, title = session label', async () => { + const guidA = '6acf5299-f9f7-404f-812d-dbe8300e1e5b' + const guidB = '485825c0-3331-46a7-acb2-c71875ad6640' + // Conversation A references a file in a real git repo; B touches no files. + const repoDir = join(tmpDir, 'container', 'web-api') + await mkdir(join(repoDir, '.git'), { recursive: true }) + await mkdir(join(repoDir, 'src'), { recursive: true }) + const fileA = join(repoDir, 'src', 'Main.java') + // Interleave each conversation record before its own turns (turns attribute + // to the nearest preceding conversation GUID). Title evolves default→final. + const content = + 'H:2,block:9,blockSize:1000,format:3\n' + + 'com.github.copilot.agent.session.persistence.nitrite.entity.NtAgentTurn\n' + + jbConversationRecord(guidA, 'New Agent Session') + '\n' + + jbConversationRecord(guidA, 'Understanding the API Architecture') + '\n' + + jbAssistantBlob('Answer about the web API.', { model: 'claude-opus-4.5', files: [fileA] }) + '\n' + + jbConversationRecord(guidB, 'Exploring the Controller Layer in Spring Boot') + '\n' + + jbAssistantBlob('Answer about the controller layer breakdown.', { model: 'gpt-5.3' }) + '\n' + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'multi-conv', content) + + const calls = await collectCalls(jbDbSource(dbPath, 'multi-conv')) + expect(calls).toHaveLength(2) + const bySession = new Map(calls.map((c) => [c.sessionId, c])) + // Sessions are split by conversation GUID. + expect(bySession.has(guidA)).toBe(true) + expect(bySession.has(guidB)).toBe(true) + // Project = the git repo root of the referenced file; else the generic + // bucket when the chat touched no files. + expect(bySession.get(guidA)!.project).toBe('web-api') + expect(bySession.get(guidB)!.project).toBe('copilot-jetbrains') + // The conversation TITLE is the session label (userMessage), NOT the project. + expect(bySession.get(guidA)!.userMessage).toBe('Understanding the API Architecture') + expect(bySession.get(guidB)!.userMessage).toBe('Exploring the Controller Layer in Spring Boot') + // Titles must never appear as project names (they are chat threads). + expect(calls.map((c) => c.project)).not.toContain('Understanding the API Architecture') + }) + + it('is idempotent across re-parses of the same .db (shared seenKeys)', async () => { + const content = jbDbContent([jbAssistantBlob('first reply'), jbAssistantBlob('second reply')]) + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-idem', content) + + const seen = new Set<string>() + const first = await collectCalls(jbDbSource(dbPath, 'conv-idem'), seen) + const second = await collectCalls(jbDbSource(dbPath, 'conv-idem'), seen) + expect(first).toHaveLength(2) + expect(second).toHaveLength(0) + }) + + it('discovers a store dir with a Nitrite .db', async () => { + const content = jbDbContent([jbAssistantBlob('hi there')]) + await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'db-only', content) + + const provider = createCopilotProvider('/nonexistent/legacy', '/nonexistent/ws', '/nonexistent/global', tmpDir) + const sessions = await provider.discoverSessions() + const jb = sessions.filter((s) => (s as { sourceType?: string }).sourceType === 'jetbrains') + expect(jb).toHaveLength(1) + expect((jb[0] as { dbPath?: string }).dbPath).toContain('copilot-agent-sessions-nitrite.db') + }) + + it('infers project as the git repo root of a referenced file (deep subdir → repo root)', async () => { + // Create a real git repo on disk so the .git walk-up can resolve it. + const repoDir = join(tmpDir, 'container', 'myapp') + await mkdir(join(repoDir, '.git'), { recursive: true }) + await mkdir(join(repoDir, 'src', 'a'), { recursive: true }) + const fileA = join(repoDir, 'src', 'a', 'One.ts') + const content = jbDbContent([ + jbAssistantBlob('Editing files in a real repo.', { model: 'gpt-4.1', files: [fileA] }), + ]) + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-gitwalk', content) + + const calls = await collectCalls(jbDbSource(dbPath, 'conv-gitwalk')) + expect(calls).toHaveLength(1) + // Project = basename of the nearest ancestor with .git (the repo root + // 'myapp'), NOT the deep subdir 'a'/'src' or the container dir. + expect(calls[0]!.project).toBe('myapp') + expect(calls[0]!.model).toBe('gpt-4.1') + }) + + it('falls back to copilot-jetbrains when no referenced file resolves to a git repo', async () => { + const content = jbDbContent([ + jbAssistantBlob('Editing a file outside any repo.', { + model: 'gpt-4.1', + files: ['/nonexistent/no-repo-here/src/One.ts'], + }), + ]) + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-norepo', content) + const calls = await collectCalls(jbDbSource(dbPath, 'conv-norepo')) + expect(calls).toHaveLength(1) + expect(calls[0]!.project).toBe('copilot-jetbrains') + }) + + it('resolves a git repo whose name contains a space', async () => { + const repoDir = join(tmpDir, 'My Project') + await mkdir(join(repoDir, '.git'), { recursive: true }) + await mkdir(join(repoDir, 'src'), { recursive: true }) + const file = join(repoDir, 'src', 'One.ts') + const content = jbDbContent([ + jbAssistantBlob('Reading a file in a spaced repo.', { model: 'gpt-4.1', files: [file] }), + ]) + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-space', content) + const calls = await collectCalls(jbDbSource(dbPath, 'conv-space')) + expect(calls).toHaveLength(1) + expect(calls[0]!.project).toBe('My Project') + }) + + it('discovers JetBrains sessions across IDE dirs and session kinds', async () => { + const content = jbDbContent([jbAssistantBlob('Hello from agent mode.', { model: 'claude-opus-4.5' })]) + await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'a1', content) + await createJetBrainsDb(tmpDir, 'intellij', 'chat-agent-sessions', 'b1', content) + + const provider = createCopilotProvider('/nonexistent/legacy', '/nonexistent/ws', '/nonexistent/global', tmpDir) + const sessions = await provider.discoverSessions() + const jb = sessions.filter((s) => (s as { sourceType?: string }).sourceType === 'jetbrains') + expect(jb.map((s) => (s as { sessionId?: string }).sessionId).sort()).toEqual(['a1', 'b1']) + }) + + it('does not crash on a corrupt/truncated .db', async () => { + const dbPath = await createJetBrainsDb( + tmpDir, + 'iu', + 'chat-agent-sessions', + 'conv-corrupt', + 'H:2,block:9\ncom.github.copilot.agent.session.persistence.nitrite.entity.NtAgentTurn\n{"__first__":{"type":"Subgraph"' // truncated, unbalanced + ) + const calls = await collectCalls(jbDbSource(dbPath, 'conv-corrupt')) + expect(Array.isArray(calls)).toBe(true) // no throw; may be empty + }) + + // ---- projectName field (JetBrains Copilot 1.12+) ---- + + it('uses the plugin-recorded projectName over the file-path git-walk', async () => { + // Same store carries both a projectName AND a file ref; projectName wins. + const repoDir = join(tmpDir, 'container', 'walkable-repo') + await mkdir(join(repoDir, '.git'), { recursive: true }) + const file = join(repoDir, 'Main.java') + const content = jbDbContent([ + jbProjectNameField('shared-utils'), + jbAssistantBlob('An answer referencing a file in a real git repo.', { + model: 'claude-opus-4.5', + files: [file], + }), + ]) + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-pn', content) + // discoverSessions populates source.projectName; feed the resolved source. + const provider = createCopilotProvider('/nonexistent/legacy', '/nonexistent/ws', '/nonexistent/global', tmpDir) + const sessions = await provider.discoverSessions() + const src = sessions.find((s) => (s as { storeId?: string }).storeId === 'conv-pn')! + expect((src as { projectName?: string }).projectName).toBe('shared-utils') + const calls = await collectCalls(src as never) + expect(calls.length).toBeGreaterThan(0) + // projectName beats the git-walk result (`walkable-repo`). + expect(calls.every((c) => c.project === 'shared-utils')).toBe(true) + }) + + it('joins projectName across kind dirs by store id (turns in agent, name in edit)', async () => { + // The billable turns live in chat-agent-sessions but carry NO projectName; + // the sibling chat-edit-sessions store (same id) records it. Discovery must + // join them so the agent session is labelled with the real repo. + const storeId = 'store-xyz-123' + const agentContent = jbDbContent([ + jbAssistantBlob('Architecture overview of the repo, no file refs at all.', { model: 'claude-opus-4.5' }), + ]) + await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', storeId, agentContent) + // Edit-kind store: has the projectName, but no billable turns. + const editContent = jbDbContent([], []) + jbProjectNameField('web-api') + await createJetBrainsDb(tmpDir, 'iu', 'chat-edit-sessions', storeId, editContent) + + const provider = createCopilotProvider('/nonexistent/legacy', '/nonexistent/ws', '/nonexistent/global', tmpDir) + const sessions = await provider.discoverSessions() + const jb = sessions.filter((s) => (s as { sourceType?: string }).sourceType === 'jetbrains') + // Every source for this store id inherits the sibling-recorded name. + for (const s of jb) { + expect((s as { projectName?: string }).projectName).toBe('web-api') + } + const agentSrc = jb.find((s) => ((s as { dbPath?: string }).dbPath ?? '').includes('chat-agent-sessions'))! + const calls = await collectCalls(agentSrc as never) + expect(calls.length).toBeGreaterThan(0) + expect(calls.every((c) => c.project === 'web-api')).toBe(true) + }) + + it('falls back to git-walk then bucket when no projectName is recorded', async () => { + // No projectName, no file refs → the honest generic bucket (older plugins). + const content = jbDbContent([jbAssistantBlob('A reply with no project signal at all.')]) + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'conv-nopn', content) + const provider = createCopilotProvider('/nonexistent/legacy', '/nonexistent/ws', '/nonexistent/global', tmpDir) + const sessions = await provider.discoverSessions() + const src = sessions.find((s) => (s as { storeId?: string }).storeId === 'conv-nopn')! + expect((src as { projectName?: string }).projectName).toBeUndefined() + const calls = await collectCalls(src as never) + expect(calls.every((c) => c.project === 'copilot-jetbrains')).toBe(true) + }) + + it('extractJetBrainsProjectName reads the length-prefixed value, immune to embedded quotes', async () => { + // A value containing a quote/newline must not truncate: length-prefixed read. + const tricky = 'weird"name' + const raw = jbDbContent([jbAssistantBlob('x')]) + jbProjectNameField(tricky) + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-sessions', 'conv-tricky', raw) + const provider = createCopilotProvider('/nonexistent/legacy', '/nonexistent/ws', '/nonexistent/global', tmpDir) + const sessions = await provider.discoverSessions() + const src = sessions.find((s) => (s as { storeId?: string }).storeId === 'conv-tricky')! + expect((src as { projectName?: string }).projectName).toBe(tricky) + }) + + it('reads a non-ASCII (multibyte UTF-8) projectName', async () => { + // The value is length-delimited in UTF-8 bytes and re-decoded latin1→utf8, + // so a repo name with multibyte characters must round-trip intact. + const name = 'проект-café' + const raw = jbDbContent([jbAssistantBlob('x')]) + jbProjectNameField(name) + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-sessions', 'conv-utf8name', raw) + const provider = createCopilotProvider('/nonexistent/legacy', '/nonexistent/ws', '/nonexistent/global', tmpDir) + const sessions = await provider.discoverSessions() + const src = sessions.find((s) => (s as { storeId?: string }).storeId === 'conv-utf8name')! + expect((src as { projectName?: string }).projectName).toBe(name) + }) + + // --------------------------------------------------------------------------- + // Old plugin format (≤1.5.x, e.g. 1.5.59-243) + // --------------------------------------------------------------------------- + // In the old plugin all session turns live inside ONE large binary-framed + // outer Nitrite document. Each turn's response is stored as a UUID-keyed + // Value entry containing an AgentRound record (one escaping level deeper than + // the __first__/Subgraph format used by plugins ≥1.12.x). + + /** + * Build an outer Nitrite document in the old plugin format. + * The document is preceded by a single binary byte (0x81) and starts with a + * UUID-keyed Value entry. Each AgentRound is stored as a Value whose value + * field is a JSON string containing {\"type\":\"AgentRound\",\"data\":\"...\"} + * (one level of JSON-string escaping from the document root). + */ + function jbOldFormatDoc(rounds: Array<{ reply: string; model?: string }>, opts: { upperUuid?: boolean } = {}) { + const cased = (u: string) => (opts.upperUuid ? u.toUpperCase() : u) + const entries: Record<string, unknown> = {} + // Lead entry (mimics the References record always present in real DBs) + entries[cased('0f383f5c-f169-4fee-9115-c06d4dd8985f')] = { + type: 'Value', + value: JSON.stringify({ type: 'References', data: '[]' }), + } + rounds.forEach((r, i) => { + const uuid = cased(`ccadf30b-fa34-4387-9f14-0a5f63457d${String(i).padStart(2, '0')}`) + const agentRoundData = JSON.stringify({ roundId: i + 1, reply: r.reply, toolCalls: [] }) + const agentRoundValue = JSON.stringify({ type: 'AgentRound', data: agentRoundData }) + entries[uuid] = { type: 'Value', value: agentRoundValue } + if (r.model) { + const modelUuid = cased(`bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbb${String(i).padStart(4, '0')}`) + entries[modelUuid] = { type: 'Value', value: `{"model":"${r.model}"}` } + } + }) + // Binary framing byte (0x81) followed by the JSON document + return '\x81' + JSON.stringify(entries) + } + + it('parses agent turns from old plugin format (≤1.5.x, no __first__ blobs)', async () => { + // The old plugin stores all turns in one big outer Nitrite document with a + // binary framing byte. The fallback path must find and parse it. + const convGuid = '17a5d71b-27f7-4937-8803-7fc2cbb705cb' + const convRecord = jbConversationRecord(convGuid, 'Understanding HBase Architecture') + const oldFormatContent = + 'H:2,block:8,blockSize:1000,format:3\n' + + 'com.github.copilot.agent.session.persistence.nitrite.entity.NtAgentTurn\n' + + convRecord + '\n' + + jbOldFormatDoc([ + { reply: "I'll scan the repository to find the top-level project structure.", model: 'gpt-4.1' }, + { reply: "Now I'll open the README to explain architecture." }, + { reply: '' }, // empty reply (pure tool-call round) — must not produce a call + ]) + + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'old-fmt-1', oldFormatContent) + const calls = await collectCalls(jbDbSource(dbPath, 'old-fmt-1')) + + // The fallback emits one call per outer document (all replies joined). + expect(calls).toHaveLength(1) + expect(calls[0]!.costIsEstimated).toBe(true) + // The two NON-EMPTY rounds are captured and joined; the empty (tool-call) + // round contributes nothing. Assert the exact combined token count so the + // test fails if either reply is dropped or the empty round leaks in. + const joined = + "I'll scan the repository to find the top-level project structure.\n" + + "Now I'll open the README to explain architecture." + expect(calls[0]!.outputTokens).toBe(Math.ceil(joined.length / 4)) + // The session label is the conversation TITLE, not the reply text. + expect(calls[0]!.userMessage).toBe('Understanding HBase Architecture') + }) + + it('parses old plugin format when the outer-doc UUIDs are uppercase hex', async () => { + // The outer-doc detection must be case-insensitive: an uppercase UUID must + // not make the whole session fall through to $0. + const convRecord = jbConversationRecord('27b6e82c-38f8-4048-9914-8fd3dcc816dc', 'Conv Upper') + const content = + 'H:2,block:8,blockSize:1000,format:3\n' + + 'com.github.copilot.agent.session.persistence.nitrite.entity.NtAgentTurn\n' + + convRecord + '\n' + + jbOldFormatDoc([{ reply: 'An uppercase-UUID reply with enough words to score.' }], { upperUuid: true }) + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'old-fmt-upper', content) + const calls = await collectCalls(jbDbSource(dbPath, 'old-fmt-upper')) + expect(calls).toHaveLength(1) + expect(calls[0]!.outputTokens).toBeGreaterThan(0) + }) + + it('old plugin format: does not parse when __first__ blobs already yield turns (no double-count)', async () => { + // When the newer __first__/Subgraph path finds turns, the old-format fallback + // must not run (turns.length > 0 prevents it). + const content = jbDbContent([ + jbAgentBlob(['A reply from the new format.']), + ]) + const dbPath = await createJetBrainsDb(tmpDir, 'iu', 'chat-agent-sessions', 'new-fmt-guard', content) + const calls = await collectCalls(jbDbSource(dbPath, 'new-fmt-guard')) + // Only the one Subgraph-format turn — no old-format duplicates + expect(calls).toHaveLength(1) + expect(calls[0]!.outputTokens).toBeGreaterThan(0) + }) +}) + +describe('copilot provider - JetBrains dedup key stability across store rewrites', () => { + beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'copilot-jetbrains-dedup-')) + vi.stubEnv('CODEBURN_COPILOT_DISABLE_OTEL', '1') + }) + + afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) + vi.unstubAllEnvs() + }) + + function jbDedupSource(path: string, sessionId: string) { + return { + path, project: 'copilot-jetbrains', provider: 'copilot', sourceType: 'jetbrains', + sessionId, storeId: sessionId, dbPath: path, mtime: '2026-07-03T12:00:00.000Z', + } as unknown as { path: string; project: string; provider: string; sourceType?: string } + } + + function blobFor(text: string) { + const innerMd = { type: 'Markdown', data: JSON.stringify({ text, annotations: [] }) } + const valueMap = { 'a1b2c3d4-0000-0000-0000-000000000001': { type: 'Value', value: JSON.stringify(innerMd) } } + return JSON.stringify({ __first__: { type: 'Subgraph', value: JSON.stringify(valueMap) } }) + } + + function dbContent(blobs: string[]) { + return ( + 'H:2,block:9,blockSize:1000,format:3\n' + + 'com.github.copilot.agent.session.persistence.nitrite.entity.NtAgentTurn\n' + + '\n' + blobs.join('\nt\x00\x00model\n') + '\n' + ) + } + + it('a compaction that moves a new blob ahead of an old one must not re-bill the old turn', async () => { + // copilot is a durable provider: cached turns are never deleted, and a + // re-parse appends any dedup key it has not seen. MVStore compaction can + // rewrite the file with blobs in a different byte order. If dedup keys were + // positional (conversation + scan index), a rewrite that puts a NEW turn + // before an OLD one would hand the new turn the old turn's key (skipped as + // already-seen) and re-emit the old turn under a fresh index — billing it + // twice and never billing the new turn. Content-derived keys are immune. + const oldReply = 'The original answer, long enough to carry a token estimate.' + const newReply = 'A fresh answer written after the compaction happened.' + + const dir = join(tmpDir, 'iu', 'chat-agent-sessions', 'conv-rewrite') + await mkdir(dir, { recursive: true }) + const dbPath = join(dir, 'copilot-agent-sessions-nitrite.db') + + const seen = new Set<string>() + + // Scan 1: the store holds only the old turn. + await writeFile(dbPath, dbContent([blobFor(oldReply)])) + const first = await collectCalls(jbDedupSource(dbPath, 'conv-rewrite'), seen) + expect(first).toHaveLength(1) + expect(first[0]!.outputTokens).toBe(Math.ceil(oldReply.length / 4)) + + // Scan 2: compaction rewrote the file — the new turn now sits BEFORE the + // old one in byte order. + await writeFile(dbPath, dbContent([blobFor(newReply), blobFor(oldReply)])) + const second = await collectCalls(jbDedupSource(dbPath, 'conv-rewrite'), seen) + + // Exactly the new turn must be billed — once, at its own length. The old + // turn is already cached and must not re-enter under a different key. + expect(second).toHaveLength(1) + expect(second[0]!.outputTokens).toBe(Math.ceil(newReply.length / 4)) + }) +}) diff --git a/tests/providers/crush.test.ts b/tests/providers/crush.test.ts new file mode 100644 index 0000000..b86f535 --- /dev/null +++ b/tests/providers/crush.test.ts @@ -0,0 +1,317 @@ +import { mkdtemp, rm, mkdir, writeFile } from 'fs/promises' +import { mkdirSync } from 'fs' +import { join } from 'path' +import { tmpdir } from 'os' +import { createRequire } from 'node:module' + +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { isSqliteAvailable } from '../../src/sqlite.js' +import { createCrushProvider } from '../../src/providers/crush.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +const requireForTest = createRequire(import.meta.url) + +type TestDb = { + exec(sql: string): void + prepare(sql: string): { run(...params: unknown[]): void } + close(): void +} + +let tmpRoot: string + +beforeEach(async () => { + tmpRoot = await mkdtemp(join(tmpdir(), 'crush-test-')) +}) + +afterEach(async () => { + await rm(tmpRoot, { recursive: true, force: true }) +}) + +// CREATE TABLE statements taken verbatim from charmbracelet/crush@v0.66.1 +// internal/db/migrations/20250424200609_initial.sql, with subsequent ALTERs +// folded in (summary_message_id, provider on messages, is_summary_message, +// todos on sessions). Keeping the literal upstream column ordering and +// constraints makes drift easy to spot. +function createCrushDb(dir: string): string { + mkdirSync(dir, { recursive: true }) + const dbPath = join(dir, 'crush.db') + const { DatabaseSync: Database } = requireForTest('node:sqlite') + const db = new Database(dbPath) + db.exec(` + CREATE TABLE IF NOT EXISTS sessions ( + id TEXT PRIMARY KEY, + parent_session_id TEXT, + title TEXT NOT NULL, + message_count INTEGER NOT NULL DEFAULT 0 CHECK (message_count >= 0), + prompt_tokens INTEGER NOT NULL DEFAULT 0 CHECK (prompt_tokens >= 0), + completion_tokens INTEGER NOT NULL DEFAULT 0 CHECK (completion_tokens >= 0), + cost REAL NOT NULL DEFAULT 0.0 CHECK (cost >= 0.0), + updated_at INTEGER NOT NULL, + created_at INTEGER NOT NULL, + summary_message_id TEXT, + todos TEXT + ) + `) + db.exec(` + CREATE TABLE IF NOT EXISTS messages ( + id TEXT PRIMARY KEY, + session_id TEXT NOT NULL, + role TEXT NOT NULL, + parts TEXT NOT NULL DEFAULT '[]', + model TEXT, + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + finished_at INTEGER, + provider TEXT, + is_summary_message INTEGER DEFAULT 0 NOT NULL, + FOREIGN KEY (session_id) REFERENCES sessions (id) ON DELETE CASCADE + ) + `) + db.close() + return dbPath +} + +function withTestDb(dbPath: string, fn: (db: TestDb) => void): void { + const { DatabaseSync: Database } = requireForTest('node:sqlite') + const db = new Database(dbPath) + try { + fn(db) + } finally { + db.close() + } +} + +type SessionFixture = { + id: string + parentId?: string | null + promptTokens?: number + completionTokens?: number + cost?: number + createdAt?: number + updatedAt?: number + messageCount?: number +} + +function insertSession(db: TestDb, s: SessionFixture): void { + db.prepare(` + INSERT INTO sessions (id, parent_session_id, title, message_count, prompt_tokens, completion_tokens, cost, created_at, updated_at) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) + `).run( + s.id, + s.parentId ?? null, + 'test session', + s.messageCount ?? 0, + s.promptTokens ?? 0, + s.completionTokens ?? 0, + s.cost ?? 0, + s.createdAt ?? 1_700_000_000, + s.updatedAt ?? s.createdAt ?? 1_700_000_000, + ) +} + +function insertMessage(db: TestDb, sessionId: string, role: string, model: string | null, id: string): void { + db.prepare(` + INSERT INTO messages (id, session_id, role, parts, model, created_at, updated_at) + VALUES (?, ?, ?, '[]', ?, ?, ?) + `).run(id, sessionId, role, model, 1_700_000_000, 1_700_000_000) +} + +async function writeRegistry(globalDataDir: string, entries: Record<string, { path: string; data_dir: string }>): Promise<void> { + await mkdir(globalDataDir, { recursive: true }) + await writeFile(join(globalDataDir, 'projects.json'), JSON.stringify(entries)) +} + +async function collect(parser: { parse(): AsyncGenerator<ParsedProviderCall> }): Promise<ParsedProviderCall[]> { + const out: ParsedProviderCall[] = [] + for await (const call of parser.parse()) out.push(call) + return out +} + +describe('crush provider', () => { + it('reports correct identity', () => { + const p = createCrushProvider() + expect(p.name).toBe('crush') + expect(p.displayName).toBe('Crush') + expect(p.modelDisplayName('gpt-5')).toBe('gpt-5') + }) + + it('returns no sessions when registry is missing', async () => { + const globalData = join(tmpRoot, 'crush-global') + process.env['CRUSH_GLOBAL_DATA'] = globalData + const p = createCrushProvider() + const sessions = await p.discoverSessions() + expect(sessions).toEqual([]) + }) + + it('returns no sessions when registry is malformed JSON', async () => { + const globalData = join(tmpRoot, 'crush-global') + await mkdir(globalData, { recursive: true }) + await writeFile(join(globalData, 'projects.json'), '{ not json') + process.env['CRUSH_GLOBAL_DATA'] = globalData + const p = createCrushProvider() + const sessions = await p.discoverSessions() + expect(sessions).toEqual([]) + }) + + it('discovers root sessions with cost or tokens, skipping zero rows and child sessions', async () => { + if (!isSqliteAvailable()) return + + const projectDir = join(tmpRoot, 'project-a') + const dbPath = createCrushDb(join(projectDir, '.crush')) + withTestDb(dbPath, db => { + insertSession(db, { id: 'root-with-cost', cost: 0.42, promptTokens: 100, completionTokens: 50, createdAt: 1_700_000_001 }) + insertSession(db, { id: 'root-no-spend', cost: 0, promptTokens: 0, completionTokens: 0, createdAt: 1_700_000_002 }) + insertSession(db, { id: 'child', parentId: 'root-with-cost', cost: 0.01, createdAt: 1_700_000_003 }) + insertSession(db, { id: 'root-tokens-only', cost: 0, promptTokens: 5, completionTokens: 5, createdAt: 1_700_000_004 }) + }) + + const globalData = join(tmpRoot, 'crush-global') + await writeRegistry(globalData, { + 'proj-a': { path: projectDir, data_dir: '.crush' }, + }) + process.env['CRUSH_GLOBAL_DATA'] = globalData + + const p = createCrushProvider() + const sessions = await p.discoverSessions() + const ids = sessions.map(s => s.path.split(':').pop()).sort() + expect(ids).toEqual(['root-tokens-only', 'root-with-cost']) + expect(sessions.every(s => s.provider === 'crush')).toBe(true) + }) + + it('parses a session into a ParsedProviderCall with real tokens, cost, and dominant model', async () => { + if (!isSqliteAvailable()) return + + const projectDir = join(tmpRoot, 'project-b') + const dbPath = createCrushDb(join(projectDir, '.crush')) + withTestDb(dbPath, db => { + insertSession(db, { + id: 'sess-1', + promptTokens: 1234, + completionTokens: 567, + cost: 0.0789, + createdAt: 1_700_000_010, + updatedAt: 1_700_000_999, + }) + // Most-used model wins. + insertMessage(db, 'sess-1', 'assistant', 'claude-sonnet-4-6', 'm1') + insertMessage(db, 'sess-1', 'assistant', 'claude-sonnet-4-6', 'm2') + insertMessage(db, 'sess-1', 'assistant', 'gpt-5', 'm3') + }) + + const globalData = join(tmpRoot, 'crush-global') + await writeRegistry(globalData, { + 'proj-b': { path: projectDir, data_dir: '.crush' }, + }) + process.env['CRUSH_GLOBAL_DATA'] = globalData + + const p = createCrushProvider() + const sources = await p.discoverSessions() + expect(sources).toHaveLength(1) + + const calls = await collect(p.createSessionParser(sources[0]!, new Set())) + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.provider).toBe('crush') + expect(call.model).toBe('claude-sonnet-4-6') + expect(call.inputTokens).toBe(1234) + expect(call.outputTokens).toBe(567) + expect(call.costUSD).toBeCloseTo(0.0789, 6) + expect(call.sessionId).toBe('sess-1') + expect(call.deduplicationKey).toBe('crush:sess-1') + // Crush stores epoch seconds; 1_700_000_999 sec → 2023-11-14T22:29:59.000Z. + expect(call.timestamp).toBe(new Date(1_700_000_999 * 1000).toISOString()) + }) + + it('falls back to "unknown" when no message has a model', async () => { + if (!isSqliteAvailable()) return + + const projectDir = join(tmpRoot, 'project-c') + const dbPath = createCrushDb(join(projectDir, '.crush')) + withTestDb(dbPath, db => { + insertSession(db, { id: 'sess-no-model', cost: 0.05, promptTokens: 10, completionTokens: 5, createdAt: 1_700_000_500 }) + insertMessage(db, 'sess-no-model', 'user', null, 'm1') + insertMessage(db, 'sess-no-model', 'assistant', null, 'm2') + }) + + const globalData = join(tmpRoot, 'crush-global') + await writeRegistry(globalData, { + 'proj-c': { path: projectDir, data_dir: '.crush' }, + }) + process.env['CRUSH_GLOBAL_DATA'] = globalData + + const p = createCrushProvider() + const sources = await p.discoverSessions() + const calls = await collect(p.createSessionParser(sources[0]!, new Set())) + expect(calls[0]!.model).toBe('unknown') + }) + + it('respects seenKeys for deduplication', async () => { + if (!isSqliteAvailable()) return + + const projectDir = join(tmpRoot, 'project-d') + const dbPath = createCrushDb(join(projectDir, '.crush')) + withTestDb(dbPath, db => { + insertSession(db, { id: 'sess-dup', cost: 0.10, promptTokens: 100, completionTokens: 50, createdAt: 1_700_000_700 }) + }) + + const globalData = join(tmpRoot, 'crush-global') + await writeRegistry(globalData, { + 'proj-d': { path: projectDir, data_dir: '.crush' }, + }) + process.env['CRUSH_GLOBAL_DATA'] = globalData + + const p = createCrushProvider() + const sources = await p.discoverSessions() + const seen = new Set<string>() + const first = await collect(p.createSessionParser(sources[0]!, seen)) + expect(first).toHaveLength(1) + + const second = await collect(p.createSessionParser(sources[0]!, seen)) + expect(second).toHaveLength(0) + }) + + it('accepts an array-shaped projects.json (legacy format)', async () => { + if (!isSqliteAvailable()) return + + const projectDir = join(tmpRoot, 'project-e') + const dbPath = createCrushDb(join(projectDir, '.crush')) + withTestDb(dbPath, db => { + insertSession(db, { id: 'sess-arr', cost: 0.01, promptTokens: 1, completionTokens: 1, createdAt: 1_700_000_800 }) + }) + + const globalData = join(tmpRoot, 'crush-global') + await mkdir(globalData, { recursive: true }) + await writeFile( + join(globalData, 'projects.json'), + JSON.stringify([{ path: projectDir, data_dir: '.crush' }]), + ) + process.env['CRUSH_GLOBAL_DATA'] = globalData + + const p = createCrushProvider() + const sources = await p.discoverSessions() + expect(sources).toHaveLength(1) + }) + + it('ignores registry entries whose db is missing', async () => { + if (!isSqliteAvailable()) return + + const globalData = join(tmpRoot, 'crush-global') + await writeRegistry(globalData, { + 'ghost': { path: join(tmpRoot, 'does-not-exist'), data_dir: '.crush' }, + }) + process.env['CRUSH_GLOBAL_DATA'] = globalData + + const p = createCrushProvider() + const sources = await p.discoverSessions() + expect(sources).toEqual([]) + }) + + it('is registered via getAllProviders', async () => { + if (!isSqliteAvailable()) return + const { getAllProviders } = await import('../../src/providers/index.js') + const providers = await getAllProviders() + const found = providers.find(p => p.name === 'crush') + expect(found).toBeDefined() + expect(found!.displayName).toBe('Crush') + }) +}) diff --git a/tests/providers/cursor-agent.test.ts b/tests/providers/cursor-agent.test.ts new file mode 100644 index 0000000..78b7282 --- /dev/null +++ b/tests/providers/cursor-agent.test.ts @@ -0,0 +1,329 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import { mkdtemp, mkdir, readFile, rm, writeFile } from 'fs/promises' +import { existsSync } from 'fs' +import { join } from 'path' +import { tmpdir } from 'os' + +import { getAllProviders } from '../../src/providers/index.js' +import { createCursorAgentProvider } from '../../src/providers/cursor-agent.js' +import type { ParsedProviderCall, Provider, SessionSource } from '../../src/providers/types.js' +import { isSqliteAvailable } from '../../src/sqlite.js' + +const CHARS_PER_TOKEN = 4 +const CURSOR_AGENT_DEFAULT_MODEL = 'cursor-agent-auto' +const FIXED_UUID = '123e4567-e89b-12d3-a456-426614174000' + +const skipUnlessSqlite = isSqliteAvailable() ? describe : describe.skip + +type TestDb = { + exec(sql: string): void + prepare(sql: string): { run(...params: unknown[]): void } + close(): void +} + +let tempRoots: string[] = [] + +beforeEach(() => { + tempRoots = [] +}) + +afterEach(async () => { + await Promise.all(tempRoots.filter(existsSync).map((dir) => rm(dir, { recursive: true, force: true }))) +}) + +async function makeBaseDir(): Promise<string> { + const dir = await mkdtemp(join(tmpdir(), 'cursor-agent-test-')) + tempRoots.push(dir) + return dir +} + +async function collectCalls(provider: Provider, source: SessionSource): Promise<ParsedProviderCall[]> { + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + return calls +} + +function withTestDb(dbPath: string, fn: (db: TestDb) => void): void { + const { DatabaseSync: Database } = require('node:sqlite') + const db = new Database(dbPath) + fn(db) + db.close() +} + +describe('cursor-agent provider', () => { + it('is registered', async () => { + const all = await getAllProviders() + const provider = all.find((p) => p.name === 'cursor-agent') + + expect(provider).toBeDefined() + expect(provider?.displayName).toBe('Cursor Agent') + }) + + it('maps default model to Cursor (auto) label', () => { + const provider = createCursorAgentProvider('/tmp/nonexistent-cursor-agent-fixture') + expect(provider.modelDisplayName('cursor-agent-auto')).toBe('Cursor (auto)') + }) + + it('maps known models and appends estimation label', () => { + const provider = createCursorAgentProvider('/tmp/nonexistent-cursor-agent-fixture') + + expect(provider.modelDisplayName('claude-4.5-opus-high-thinking')).toBe('Opus 4.5 (Thinking) (est.)') + expect(provider.modelDisplayName('claude-4.6-sonnet')).toBe('Sonnet 4.6 (est.)') + expect(provider.modelDisplayName('composer-1')).toBe('Composer 1 (est.)') + }) + + it('falls through to raw model name for unknown models with single est. suffix', () => { + const provider = createCursorAgentProvider('/tmp/nonexistent-cursor-agent-fixture') + + expect(provider.modelDisplayName('claude-5-future-model')).toBe('claude-5-future-model (est.)') + expect(provider.modelDisplayName('gpt-9')).toBe('gpt-9 (est.)') + }) + + it('returns identity for tool display name', () => { + const provider = createCursorAgentProvider('/tmp/nonexistent-cursor-agent-fixture') + expect(provider.toolDisplayName('cursor:edit')).toBe('cursor:edit') + }) + + it('returns empty discovery when projects dir is missing', async () => { + const baseDir = await makeBaseDir() + const provider = createCursorAgentProvider(baseDir) + const sources = await provider.discoverSessions() + + expect(sources).toEqual([]) + }) + + it('discovers a single transcript', async () => { + const baseDir = await makeBaseDir() + const transcriptDir = join(baseDir, 'projects', 'test-proj', 'agent-transcripts') + await mkdir(transcriptDir, { recursive: true }) + const transcriptPath = join(transcriptDir, `${FIXED_UUID}.txt`) + await writeFile(transcriptPath, 'user:\n<user_query>hello</user_query>\nA:\nworld\n') + + const provider = createCursorAgentProvider(baseDir) + const sources = await provider.discoverSessions() + + expect(sources).toHaveLength(1) + expect(sources[0]!.provider).toBe('cursor-agent') + expect(sources[0]!.path).toBe(transcriptPath) + }) + + it('discovers transcripts across multiple projects', async () => { + const baseDir = await makeBaseDir() + const transcriptA = join(baseDir, 'projects', 'proj-one', 'agent-transcripts') + const transcriptB = join(baseDir, 'projects', 'proj-two', 'agent-transcripts') + await mkdir(transcriptA, { recursive: true }) + await mkdir(transcriptB, { recursive: true }) + await writeFile(join(transcriptA, `${FIXED_UUID}.txt`), 'user:\n<user_query>a</user_query>\nA:\na\n') + await writeFile(join(transcriptB, `${FIXED_UUID}.txt`), 'user:\n<user_query>b</user_query>\nA:\nb\n') + + const provider = createCursorAgentProvider(baseDir) + const sources = await provider.discoverSessions() + + expect(sources).toHaveLength(2) + expect(sources.every((s) => s.provider === 'cursor-agent')).toBe(true) + }) + + it('does not scan a workspace root when agent-transcripts is missing', async () => { + const baseDir = await makeBaseDir() + const workspaceRoot = join(baseDir, 'projects', 'workspace-without-transcripts') + await mkdir(workspaceRoot, { recursive: true }) + await writeFile( + join(workspaceRoot, 'extension-state.txt'), + 'user:\n<user_query>not a transcript</user_query>\nA:\nnot a cursor-agent answer\n', + ) + + const provider = createCursorAgentProvider(baseDir) + const sources = await provider.discoverSessions() + + expect(sources).toEqual([]) + }) + + it('prefers jsonl over same-session txt inside UUID transcript dirs', async () => { + const baseDir = await makeBaseDir() + const sessionDir = join(baseDir, 'projects', 'proj-with-duplicates', 'agent-transcripts', FIXED_UUID) + const jsonlPath = join(sessionDir, `${FIXED_UUID}.jsonl`) + const txtPath = join(sessionDir, `${FIXED_UUID}.txt`) + await mkdir(sessionDir, { recursive: true }) + await writeFile( + jsonlPath, + '{"role":"user","message":{"content":[{"type":"text","text":"<user_query>jsonl wins</user_query>"}]}}\n{"role":"assistant","message":{"content":[{"type":"text","text":"jsonl answer"}]}}\n', + ) + await writeFile(txtPath, 'user:\n<user_query>txt duplicate</user_query>\nA:\ntxt answer\n') + + const provider = createCursorAgentProvider(baseDir) + const sources = await provider.discoverSessions() + + expect(sources).toHaveLength(1) + expect(sources[0]!.path).toBe(jsonlPath) + }) + + it('parses one user/assistant pair with estimated token counts', async () => { + const baseDir = await makeBaseDir() + const transcriptDir = join(baseDir, 'projects', 'my-proj', 'agent-transcripts') + await mkdir(transcriptDir, { recursive: true }) + + const userText = 'explain parser output' + const assistantText = 'first line\nsecond line' + const transcriptPath = join(transcriptDir, `${FIXED_UUID}.txt`) + + await writeFile( + transcriptPath, + `user:\n<user_query>${userText}</user_query>\nA:\n${assistantText}\n` + ) + + const provider = createCursorAgentProvider(baseDir) + const source = (await provider.discoverSessions())[0]! + const calls = await collectCalls(provider, source) + + expect(calls).toHaveLength(1) + expect(calls[0]!.provider).toBe('cursor-agent') + expect(calls[0]!.model).toBe(CURSOR_AGENT_DEFAULT_MODEL) + expect(calls[0]!.inputTokens).toBe(Math.ceil(userText.length / CHARS_PER_TOKEN)) + expect(calls[0]!.outputTokens).toBe(Math.ceil(assistantText.length / CHARS_PER_TOKEN)) + expect(calls[0]!.reasoningTokens).toBe(0) + expect(calls[0]!.deduplicationKey).toBe(`cursor-agent:${FIXED_UUID}:0`) + }) + + it('parses without sqlite db and defaults model', async () => { + const baseDir = await makeBaseDir() + const transcriptDir = join(baseDir, 'projects', 'fallback-proj', 'agent-transcripts') + await mkdir(transcriptDir, { recursive: true }) + const transcriptPath = join(transcriptDir, `${FIXED_UUID}.txt`) + + await writeFile(transcriptPath, 'user:\n<user_query>hello world</user_query>\nA:\n[Thinking]private\nvisible\n') + + const provider = createCursorAgentProvider(baseDir) + const source = (await provider.discoverSessions())[0]! + const calls = await collectCalls(provider, source) + + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe(CURSOR_AGENT_DEFAULT_MODEL) + expect(calls[0]!.reasoningTokens).toBe(2) + expect(calls[0]!.outputTokens).toBe(2) + }) + + it('skips unrecognized transcript format and writes stderr message', async () => { + const baseDir = await makeBaseDir() + const transcriptDir = join(baseDir, 'projects', 'bad-proj', 'agent-transcripts') + await mkdir(transcriptDir, { recursive: true }) + const transcriptPath = join(transcriptDir, `${FIXED_UUID}.txt`) + await writeFile(transcriptPath, 'no markers in this transcript') + + const provider = createCursorAgentProvider(baseDir) + const source = (await provider.discoverSessions())[0]! + const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true) + + const calls = await collectCalls(provider, source) + + expect(calls).toHaveLength(0) + expect(stderrSpy).toHaveBeenCalled() + expect(String(stderrSpy.mock.calls[0]?.[0] ?? '')).toContain('unrecognized cursor-agent transcript format') + + stderrSpy.mockRestore() + }) + + it('warns only once for the same unrecognized transcript', async () => { + const baseDir = await makeBaseDir() + const transcriptDir = join(baseDir, 'projects', 'bad-proj-repeat', 'agent-transcripts') + await mkdir(transcriptDir, { recursive: true }) + const transcriptPath = join(transcriptDir, 'repeat-bad.txt') + await writeFile(transcriptPath, 'no cursor-agent markers here') + + const provider = createCursorAgentProvider(baseDir) + const source = (await provider.discoverSessions())[0]! + const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true) + + await collectCalls(provider, source) + await collectCalls(provider, source) + + const warnings = stderrSpy.mock.calls + .map(call => String(call[0] ?? '')) + .filter(message => message.includes('unrecognized cursor-agent transcript format')) + expect(warnings).toHaveLength(1) + + stderrSpy.mockRestore() + }) + + it('discovers jsonl transcripts stored directly under project dir (workspace-less layout)', async () => { + const baseDir = await makeBaseDir() + const fixtureRoot = join(import.meta.dirname, '../fixtures/cursor-agent/workspace-less') + const sessionDir = join(baseDir, 'projects', 'agent-transcripts', '1031d227-0c67-4e17-8954-0b6e2b3322f0') + await mkdir(sessionDir, { recursive: true }) + await writeFile( + join(sessionDir, '1031d227-0c67-4e17-8954-0b6e2b3322f0.jsonl'), + await readFile( + join( + fixtureRoot, + 'projects/agent-transcripts/1031d227-0c67-4e17-8954-0b6e2b3322f0/1031d227-0c67-4e17-8954-0b6e2b3322f0.jsonl', + ), + 'utf-8', + ), + ) + + const provider = createCursorAgentProvider(baseDir) + const sources = await provider.discoverSessions() + + expect(sources).toHaveLength(1) + expect(sources[0]!.project).toBe('transcripts') + expect(sources[0]!.path.endsWith('.jsonl')).toBe(true) + + const calls = await collectCalls(provider, sources[0]!) + expect(calls).toHaveLength(1) + expect(calls[0]!.sessionId).toBe('1031d227-0c67-4e17-8954-0b6e2b3322f0') + expect(calls[0]!.userMessage).toBe('Run a quick smoke test') + expect(calls[0]!.costUSD).toBeGreaterThan(0) + }) + + it('falls back to stable sha1 conversation id for non-uuid filenames', async () => { + const baseDir = await makeBaseDir() + const transcriptDir = join(baseDir, 'projects', 'sha-proj', 'agent-transcripts') + await mkdir(transcriptDir, { recursive: true }) + const transcriptPath = join(transcriptDir, 'not-a-uuid.txt') + await writeFile(transcriptPath, 'user:\n<user_query>test</user_query>\nA:\nresult\n') + + const provider = createCursorAgentProvider(baseDir) + const source = (await provider.discoverSessions())[0]! + + const callsFirst = await collectCalls(provider, source) + const callsSecond = await collectCalls(provider, source) + + expect(callsFirst).toHaveLength(1) + expect(callsSecond).toHaveLength(1) + expect(callsFirst[0]!.sessionId).toHaveLength(16) + expect(callsFirst[0]!.deduplicationKey.startsWith('cursor-agent:')).toBe(true) + expect(callsFirst[0]!.sessionId).toBe(callsSecond[0]!.sessionId) + expect(callsFirst[0]!.deduplicationKey).toBe(callsSecond[0]!.deduplicationKey) + }) +}) + +skipUnlessSqlite('cursor-agent sqlite metadata', () => { + it('uses model metadata from ai-code-tracking db when present', async () => { + const baseDir = await makeBaseDir() + const transcriptDir = join(baseDir, 'projects', 'proj-with-db', 'agent-transcripts') + const aiTrackingDir = join(baseDir, 'ai-tracking') + await mkdir(transcriptDir, { recursive: true }) + await mkdir(aiTrackingDir, { recursive: true }) + + await writeFile( + join(transcriptDir, `${FIXED_UUID}.txt`), + 'user:\n<user_query>estimate cost</user_query>\nA:\nanswer\n' + ) + + const dbPath = join(aiTrackingDir, 'ai-code-tracking.db') + withTestDb(dbPath, (db) => { + db.exec('CREATE TABLE conversation_summaries (conversationId TEXT, title TEXT, tldr TEXT, model TEXT, mode TEXT, updatedAt INTEGER)') + db.prepare('INSERT INTO conversation_summaries (conversationId, title, tldr, model, mode, updatedAt) VALUES (?, ?, ?, ?, ?, ?)') + .run(FIXED_UUID, 'Demo title', '', 'claude-4.6-sonnet', 'agent', 1735689600000) + }) + + const provider = createCursorAgentProvider(baseDir) + const source = (await provider.discoverSessions())[0]! + const calls = await collectCalls(provider, source) + + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe('claude-4.6-sonnet') + expect(calls[0]!.timestamp).toBe('2025-01-01T00:00:00.000Z') + }) +}) diff --git a/tests/providers/cursor-bubble-dedup.test.ts b/tests/providers/cursor-bubble-dedup.test.ts new file mode 100644 index 0000000..a164eeb --- /dev/null +++ b/tests/providers/cursor-bubble-dedup.test.ts @@ -0,0 +1,176 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, rm, writeFile } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' + +import { isSqliteAvailable, openDatabase } from '../../src/sqlite.js' +import { getAllProviders } from '../../src/providers/index.js' +import type { Provider, ParsedProviderCall } from '../../src/providers/types.js' + +/// Pinned regression for the v3 bubble-dedup fix. The previous (v2) code used +/// the bubble row's mutable token counts as part of the deduplication key, so +/// the same bubble was counted twice once Cursor wrote the streaming-complete +/// final token totals on top of the streaming-in-progress row. v3 switched to +/// the SQLite primary `key` column (which is the stable bubbleId:<id>:<id> +/// path) so re-parsing the same DB after token updates produces zero new +/// calls. This test: +/// 1. Builds a tmp SQLite DB with the cursorDiskKV schema and one bubble row +/// with low token counts (the streaming-in-progress shape). +/// 2. Parses it through the cursor provider. Asserts one call. +/// 3. Mutates the row in place to higher token counts (the streaming-complete +/// shape) without changing the SQLite key. +/// 4. Re-parses with the SAME seenKeys set. Asserts zero new calls. +/// If a future refactor brings back token-count-based dedup, the second parse +/// will produce a duplicate call and this test will fail. + +const skipReason = isSqliteAvailable() + ? null + : 'node:sqlite not available — needs Node 22+; skipping' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'cursor-dedup-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +function buildBubbleValue(opts: { + conversationId: string + text: string + inputTokens: number + outputTokens: number + type: 1 | 2 + createdAt?: string +}): string { + return JSON.stringify({ + type: opts.type, + conversationId: opts.conversationId, + text: opts.text, + tokenCount: { + inputTokens: opts.inputTokens, + outputTokens: opts.outputTokens, + }, + createdAt: opts.createdAt ?? new Date().toISOString(), + modelId: 'gpt-5', + capabilityType: 'composer', + }) +} + +async function createCursorTestDb(): Promise<string> { + // Cursor uses a non-extension state DB filename (state.vscdb in the real app); + // any path works for openDatabase as long as we set up the schema and the + // directory layout the parser expects. The parser only checks the DB + // contents — discovery is bypassed because we hand it the path directly. + const dbPath = join(tmpDir, 'state.vscdb') + await writeFile(dbPath, '') + // Use the underlying node:sqlite to create the schema. + // We need cursorDiskKV with key + value columns. + const Module = await import('node:module') + const requireForSqlite = Module.createRequire(import.meta.url) + const { DatabaseSync } = requireForSqlite('node:sqlite') as { + DatabaseSync: new (path: string) => { + exec(sql: string): void + prepare(sql: string): { run(...p: unknown[]): unknown } + close(): void + } + } + const db = new DatabaseSync(dbPath) + db.exec('CREATE TABLE cursorDiskKV (key TEXT PRIMARY KEY, value TEXT)') + + // Single assistant bubble (type=2). The parser yields one ParsedProviderCall + // per bubbleId:% row, so a multi-row fixture would muddy the dedup count; + // we keep the test surface minimal — one bubble through one parse, then + // the same bubble again after token mutation. + const bubbleKey = 'bubbleId:abc-123:bubble-xyz' + db.prepare('INSERT INTO cursorDiskKV (key, value) VALUES (?, ?)').run( + bubbleKey, + buildBubbleValue({ + conversationId: 'abc-123', + text: 'def hello(): pass', + inputTokens: 100, + outputTokens: 20, + type: 2, + }) + ) + + db.close() + return dbPath +} + +async function updateAssistantBubbleTokens(dbPath: string, inputTokens: number, outputTokens: number): Promise<void> { + const Module = await import('node:module') + const requireForSqlite = Module.createRequire(import.meta.url) + const { DatabaseSync } = requireForSqlite('node:sqlite') as { + DatabaseSync: new (path: string) => { + prepare(sql: string): { run(...p: unknown[]): unknown } + close(): void + } + } + const db = new DatabaseSync(dbPath) + db.prepare('UPDATE cursorDiskKV SET value = ? WHERE key = ?').run( + buildBubbleValue({ + conversationId: 'abc-123', + text: 'def hello(): pass', + inputTokens, + outputTokens, + type: 2, + }), + 'bubbleId:abc-123:bubble-xyz' + ) + db.close() +} + +async function getCursorProvider(): Promise<Provider> { + const all = await getAllProviders() + const p = all.find(p => p.name === 'cursor') + if (!p) throw new Error('cursor provider not registered') + return p +} + +describe.skipIf(skipReason !== null)('cursor bubble dedup (regression for v3 fix)', () => { + it('does not double-count when bubble token counts mutate between parses', async () => { + const dbPath = await createCursorTestDb() + const provider = await getCursorProvider() + + // First parse: streaming-in-progress shape. + const seenKeys = new Set<string>() + const source = { path: dbPath, project: 'test-project', provider: 'cursor' } + const firstRunCalls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, seenKeys).parse()) { + firstRunCalls.push(call) + } + expect(firstRunCalls.length).toBe(1) + + // Cursor mutates the same bubble row to its final token totals when the + // stream completes. Simulate by updating in place. The SQLite primary + // key stays the same. + await updateAssistantBubbleTokens(dbPath, 250, 80) + + // Second parse with the SAME seenKeys: must yield zero new calls. If the + // dedup key were derived from token counts (the v2 bug), this would + // produce a duplicate. + const secondRunCalls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, seenKeys).parse()) { + secondRunCalls.push(call) + } + expect(secondRunCalls.length).toBe(0) + }) + + it('does not yield the same bubble twice within a single parser run', async () => { + const dbPath = await createCursorTestDb() + const provider = await getCursorProvider() + const seenKeys = new Set<string>() + const source = { path: dbPath, project: 'test-project', provider: 'cursor' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, seenKeys).parse()) { + calls.push(call) + } + // One bubble in the DB → one call. (The user message row at type=1 is + // not surfaced as a separate ParsedProviderCall; it's threaded into the + // assistant call's userMessage field.) + expect(calls.length).toBe(1) + }) +}) diff --git a/tests/providers/cursor-large-db-cap.test.ts b/tests/providers/cursor-large-db-cap.test.ts new file mode 100644 index 0000000..7b60c3d --- /dev/null +++ b/tests/providers/cursor-large-db-cap.test.ts @@ -0,0 +1,129 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, rm, writeFile } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' + +import { isSqliteAvailable } from '../../src/sqlite.js' +import { getAllProviders } from '../../src/providers/index.js' +import type { Provider, ParsedProviderCall } from '../../src/providers/types.js' +import type { DateRange } from '../../src/types.js' + +/// Regression for #482: the Cursor scan must not drop in-range sessions just +/// because the DB has more bubbles than the scan budget. The old code kept the +/// most-recent MAX_BUBBLES rows *by ROWID* and warned unconditionally; the new +/// code pages the requested time window and only truncates (with a warning) +/// when the in-range scan genuinely exceeds the budget. We shrink the budget +/// via CODEBURN_CURSOR_MAX_BUBBLES so a tiny fixture exercises the capped path. + +const skipReason = isSqliteAvailable() ? null : 'node:sqlite not available — needs Node 22+; skipping' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'cursor-cap-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +type Bubble = { conversationId: string; createdAt: string; model: string; tokens: number } + +/// Inserts assistant bubbles in array order, so ROWID follows array index. +async function createDb(bubbles: Bubble[]): Promise<string> { + const dbPath = join(tmpDir, 'state.vscdb') + await writeFile(dbPath, '') + const Module = await import('node:module') + const requireForSqlite = Module.createRequire(import.meta.url) + const { DatabaseSync } = requireForSqlite('node:sqlite') as { + DatabaseSync: new (path: string) => { + exec(sql: string): void + prepare(sql: string): { run(...p: unknown[]): unknown } + close(): void + } + } + const db = new DatabaseSync(dbPath) + db.exec('CREATE TABLE cursorDiskKV (key TEXT PRIMARY KEY, value TEXT)') + const stmt = db.prepare('INSERT INTO cursorDiskKV (key, value) VALUES (?, ?)') + bubbles.forEach((b, i) => { + stmt.run( + `bubbleId:${b.conversationId}:bubble-${i}`, + JSON.stringify({ + type: 2, + conversationId: b.conversationId, + text: 'def hello(): pass', + tokenCount: { inputTokens: b.tokens, outputTokens: b.tokens }, + createdAt: b.createdAt, + modelInfo: { modelName: b.model }, + }), + ) + }) + db.close() + return dbPath +} + +async function getCursorProvider(): Promise<Provider> { + const p = (await getAllProviders()).find(p => p.name === 'cursor') + if (!p) throw new Error('cursor provider not registered') + return p +} + +async function parse(dbPath: string, range: DateRange): Promise<ParsedProviderCall[]> { + const provider = await getCursorProvider() + const source = { path: dbPath, project: 'test', provider: 'cursor' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set<string>(), range).parse()) { + calls.push(call) + } + return calls +} + +const iso = (daysAgo: number) => new Date(Date.now() - daysAgo * 24 * 60 * 60 * 1000).toISOString() +const last30Days = (): DateRange => ({ start: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000), end: new Date() }) +const last120Days = (): DateRange => ({ start: new Date(Date.now() - 120 * 24 * 60 * 60 * 1000), end: new Date() }) + +describe.skipIf(skipReason !== null)('cursor large-DB scan cap (#482)', () => { + it('keeps in-range sessions even when they have low ROWIDs and the DB is over budget', async () => { + // In-range bubbles inserted FIRST (low ROWID); out-of-range bubbles inserted + // LATER (high ROWID). The old "most-recent N by ROWID" cap would scan only + // the high-ROWID out-of-range rows and drop the in-range ones entirely. + const dbPath = await createDb([ + { conversationId: 'recent-A', createdAt: iso(1), model: 'gpt-5', tokens: 100 }, + { conversationId: 'recent-B', createdAt: iso(2), model: 'gpt-5', tokens: 100 }, + { conversationId: 'old-C', createdAt: iso(300), model: 'gpt-5', tokens: 100 }, + { conversationId: 'old-D', createdAt: iso(300), model: 'gpt-5', tokens: 100 }, + ]) + process.env['CODEBURN_CURSOR_MAX_BUBBLES'] = '2' // total 4 > budget 2 -> capped path + + const calls = await parse(dbPath, last30Days()) + // Both in-range sessions are present (the old ROWID cap returned 0 here). + expect(calls.length).toBe(2) + }) + + it('returns the whole window when in-range bubbles fit the budget (over-budget DB)', async () => { + const dbPath = await createDb([ + { conversationId: 'A', createdAt: iso(1), model: 'gpt-5', tokens: 100 }, + { conversationId: 'B', createdAt: iso(2), model: 'gpt-5', tokens: 100 }, + { conversationId: 'old', createdAt: iso(300), model: 'gpt-5', tokens: 100 }, + { conversationId: 'older', createdAt: iso(301), model: 'gpt-5', tokens: 100 }, + ]) + process.env['CODEBURN_CURSOR_MAX_BUBBLES'] = '3' // total 4 > budget 3, but in-range 2 <= 3 + const calls = await parse(dbPath, last30Days()) + expect(calls.length).toBe(2) // both in-range, none truncated + }) + + it('truncates to the budget and keeps the newest in-range bubbles when over budget', async () => { + // Four in-range bubbles, oldest->newest by ROWID; budget 2 keeps the two newest. + const dbPath = await createDb([ + { conversationId: 'd1', createdAt: iso(40), model: 'old-model', tokens: 100 }, + { conversationId: 'd2', createdAt: iso(30), model: 'old-model', tokens: 100 }, + { conversationId: 'd3', createdAt: iso(2), model: 'new-model', tokens: 100 }, + { conversationId: 'd4', createdAt: iso(1), model: 'new-model', tokens: 100 }, + ]) + process.env['CODEBURN_CURSOR_MAX_BUBBLES'] = '2' // total 4 > budget 2 + const calls = await parse(dbPath, last120Days()) + expect(calls.length).toBe(2) + // Budget keeps the highest-ROWID (newest-inserted) bubbles. + expect(calls.every(c => c.model === 'new-model')).toBe(true) + }) +}) diff --git a/tests/providers/cursor-real-tokens.test.ts b/tests/providers/cursor-real-tokens.test.ts new file mode 100644 index 0000000..7870745 --- /dev/null +++ b/tests/providers/cursor-real-tokens.test.ts @@ -0,0 +1,412 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, rm } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' +import { createRequire } from 'node:module' + +import { + createCursorProvider, + clearCursorWorkspaceMapCache, +} from '../../src/providers/cursor.js' +import { isSqliteAvailable } from '../../src/sqlite.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +const requireForTest = createRequire(import.meta.url) + +const skipReason = isSqliteAvailable() + ? null + : 'node:sqlite not available — needs Node 22+; skipping' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'cursor-tokens-test-')) + clearCursorWorkspaceMapCache() +}) + +afterEach(async () => { + clearCursorWorkspaceMapCache() + await rm(tmpDir, { recursive: true, force: true }) +}) + +function buildDb(fn: (db: { + exec(sql: string): void + prepare(sql: string): { run(...params: unknown[]): void } + close(): void +}) => void): string { + const dbPath = join(tmpDir, 'state.vscdb') + const { DatabaseSync: Database } = requireForTest('node:sqlite') + const db = new Database(dbPath) + db.exec('CREATE TABLE cursorDiskKV (key TEXT PRIMARY KEY, value BLOB)') + db.exec('CREATE TABLE ItemTable (key TEXT UNIQUE, value BLOB)') + fn(db) + db.close() + return dbPath +} + +function insertBubble(db: { + prepare(sql: string): { run(...params: unknown[]): void } +}, opts: { + composerId: string + bubbleUuid: string + type: 1 | 2 + text: string + model?: string + inputTokens?: number + outputTokens?: number + createdAt?: string + requestId?: string + codeBlocks?: string +}): void { + const key = `bubbleId:${opts.composerId}:${opts.bubbleUuid}` + const value = JSON.stringify({ + type: opts.type, + conversationId: '', + createdAt: opts.createdAt ?? new Date().toISOString(), + tokenCount: { + inputTokens: opts.inputTokens ?? 0, + outputTokens: opts.outputTokens ?? 0, + }, + modelInfo: opts.model ? { modelName: opts.model } : undefined, + text: opts.text, + codeBlocks: opts.codeBlocks ?? '[]', + requestId: opts.requestId, + }) + db.prepare('INSERT INTO cursorDiskKV (key, value) VALUES (?, ?)').run(key, value) +} + +function insertComposerData(db: { + prepare(sql: string): { run(...params: unknown[]): void } +}, opts: { + composerId: string + totalUsedTokens?: number | null + contextTokensUsed?: number | null + createdAt?: number +}): void { + const key = `composerData:${opts.composerId}` + const breakdown = opts.totalUsedTokens !== undefined + ? { totalUsedTokens: opts.totalUsedTokens } + : {} + const value = JSON.stringify({ + promptTokenBreakdown: breakdown, + contextTokensUsed: opts.contextTokensUsed ?? undefined, + createdAt: opts.createdAt ?? undefined, + }) + db.prepare('INSERT INTO cursorDiskKV (key, value) VALUES (?, ?)').run(key, value) +} + +function insertAgentKv(db: { + prepare(sql: string): { run(...params: unknown[]): void } +}, opts: { + blobId: string + role: string + content: unknown + requestId?: string +}): void { + const key = `agentKv:blob:${opts.blobId}` + const value = JSON.stringify({ + role: opts.role, + content: opts.content, + providerOptions: opts.requestId + ? { cursor: { requestId: opts.requestId } } + : undefined, + }) + db.prepare('INSERT INTO cursorDiskKV (key, value) VALUES (?, ?)').run(key, value) +} + +async function collectCalls(provider: ReturnType<typeof createCursorProvider>, dbPath: string): Promise<ParsedProviderCall[]> { + const source = { path: dbPath, project: 'test', provider: 'cursor' as const } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + return calls +} + +describe.skipIf(skipReason !== null)('cursor real context tokens (#575)', () => { + it('credits composerData.promptTokenBreakdown.totalUsedTokens as input', async () => { + const composerId = 'aaaa1111-2222-3333-4444-555566667777' + const dbPath = buildDb((db) => { + insertComposerData(db, { composerId, totalUsedTokens: 50000 }) + insertBubble(db, { + composerId, bubbleUuid: 'b1', type: 1, text: 'user prompt', + inputTokens: 0, outputTokens: 0, + }) + insertBubble(db, { + composerId, bubbleUuid: 'b2', type: 2, text: 'assistant reply', + model: 'claude-4.6-sonnet', inputTokens: 0, outputTokens: 0, + }) + }) + + const provider = createCursorProvider(dbPath) + const calls = await collectCalls(provider, dbPath) + + const credited = calls.find(c => c.inputTokens === 50000) + expect(credited).toBeDefined() + expect(credited!.deduplicationKey).toBe(`cursor:composer-input:${composerId}`) + expect(credited!.costIsEstimated).toBe(true) + }) + + it('credits real input tokens once per conversation, not per bubble', async () => { + const composerId = 'bbbb1111-2222-3333-4444-555566667777' + const dbPath = buildDb((db) => { + insertComposerData(db, { composerId, totalUsedTokens: 30000 }) + insertBubble(db, { composerId, bubbleUuid: 'b1', type: 1, text: 'turn 1' }) + insertBubble(db, { composerId, bubbleUuid: 'b2', type: 2, text: 'reply 1', model: 'gpt-5' }) + insertBubble(db, { composerId, bubbleUuid: 'b3', type: 1, text: 'turn 2' }) + insertBubble(db, { composerId, bubbleUuid: 'b4', type: 2, text: 'reply 2', model: 'gpt-5' }) + }) + + const provider = createCursorProvider(dbPath) + const calls = await collectCalls(provider, dbPath) + + const credited = calls.filter(c => c.inputTokens === 30000) + expect(credited.length).toBe(1) + // The metered conversation's user-bubble text must not be counted on top. + const inputTotal = calls.reduce((s, c) => s + c.inputTokens, 0) + expect(inputTotal).toBe(30000) + }) + + it('anchors the conversation record to composerData.createdAt, independent of the parse window', async () => { + const composerId = 'ab121111-2222-3333-4444-555566667777' + const startMs = Date.parse('2026-06-01T10:00:00.000Z') + const dbPath = buildDb((db) => { + insertComposerData(db, { composerId, totalUsedTokens: 20000, createdAt: startMs }) + insertBubble(db, { composerId, bubbleUuid: 'b1', type: 1, text: 'later turn' }) + }) + + const provider = createCursorProvider(dbPath) + const calls = await collectCalls(provider, dbPath) + + const credited = calls.find(c => c.inputTokens === 20000) + expect(credited).toBeDefined() + expect(credited!.timestamp).toBe(new Date(startMs).toISOString()) + }) + + it('falls back to text estimation when no composerData exists', async () => { + const composerId = 'cccc1111-2222-3333-4444-555566667777' + const dbPath = buildDb((db) => { + insertBubble(db, { + composerId, bubbleUuid: 'b1', type: 1, text: 'hello world this is a test', + }) + }) + + const provider = createCursorProvider(dbPath) + const calls = await collectCalls(provider, dbPath) + + const userCall = calls.find(c => c.inputTokens > 0) + expect(userCall).toBeDefined() + expect(userCall!.inputTokens).toBe(Math.ceil('hello world this is a test'.length / 4)) + }) + + it('uses contextTokensUsed when totalUsedTokens is null', async () => { + const composerId = 'dddd1111-2222-3333-4444-555566667777' + const dbPath = buildDb((db) => { + insertComposerData(db, { composerId, totalUsedTokens: null, contextTokensUsed: 42000 }) + insertBubble(db, { composerId, bubbleUuid: 'b1', type: 1, text: 'prompt' }) + insertBubble(db, { composerId, bubbleUuid: 'b2', type: 2, text: 'reply', model: 'gpt-5' }) + }) + + const provider = createCursorProvider(dbPath) + const calls = await collectCalls(provider, dbPath) + + const credited = calls.find(c => c.inputTokens === 42000) + expect(credited).toBeDefined() + }) + + it('uses contextTokensUsed when totalUsedTokens is present but zero', async () => { + const composerId = 'de001111-2222-3333-4444-555566667777' + const dbPath = buildDb((db) => { + insertComposerData(db, { composerId, totalUsedTokens: 0, contextTokensUsed: 42000 }) + insertBubble(db, { composerId, bubbleUuid: 'b1', type: 1, text: 'prompt' }) + }) + + const provider = createCursorProvider(dbPath) + const calls = await collectCalls(provider, dbPath) + + const credited = calls.find(c => c.inputTokens === 42000) + expect(credited).toBeDefined() + }) + + it('skips the meter when any bubble carries real tokenCounts', async () => { + const composerId = 'ef001111-2222-3333-4444-555566667777' + const dbPath = buildDb((db) => { + insertComposerData(db, { composerId, totalUsedTokens: 80000 }) + insertBubble(db, { composerId, bubbleUuid: 'b1', type: 1, text: 'prompt', inputTokens: 6000 }) + insertBubble(db, { composerId, bubbleUuid: 'b2', type: 2, text: 'reply', model: 'gpt-5', outputTokens: 900 }) + }) + + const provider = createCursorProvider(dbPath) + const calls = await collectCalls(provider, dbPath) + + // Real per-bubble counts are authoritative; the snapshot must not stack. + expect(calls.find(c => c.inputTokens === 80000)).toBeUndefined() + const inputTotal = calls.reduce((s, c) => s + c.inputTokens, 0) + expect(inputTotal).toBe(6000) + }) + + it('attributes aggregated agentKv tools once, with canonical Bash names', async () => { + const composerId = 'eeee1111-2222-3333-4444-555566667777' + const requestId = 'req-001' + const dbPath = buildDb((db) => { + insertComposerData(db, { composerId, totalUsedTokens: 10000 }) + insertBubble(db, { composerId, bubbleUuid: 'b1', type: 1, text: 'do stuff', requestId }) + insertBubble(db, { composerId, bubbleUuid: 'b2', type: 2, text: 'doing stuff', model: 'gpt-5' }) + insertBubble(db, { composerId, bubbleUuid: 'b3', type: 1, text: 'do more stuff', requestId: 'req-002' }) + insertBubble(db, { composerId, bubbleUuid: 'b4', type: 2, text: 'doing more stuff', model: 'gpt-5' }) + insertAgentKv(db, { + blobId: 'akv-1', role: 'user', + content: [{ type: 'text', text: 'do stuff' }], + requestId, + }) + insertAgentKv(db, { + blobId: 'akv-2', role: 'assistant', + content: [ + { type: 'tool-call', toolName: 'Read', args: {} }, + { type: 'tool-call', toolName: 'Shell', args: { command: 'npm test' } }, + ], + }) + }) + + const provider = createCursorProvider(dbPath) + const calls = await collectCalls(provider, dbPath) + + const callWithTools = calls.find(c => c.tools.length > 0) + expect(callWithTools).toBeDefined() + expect(callWithTools!.tools).toContain('Read') + expect(callWithTools!.tools).toContain('Bash') + expect(callWithTools!.bashCommands).toContain('npm') + + const allTools = calls.flatMap(c => c.tools) + const allBashCommands = calls.flatMap(c => c.bashCommands) + expect(allTools.filter(t => t === 'Read').length).toBe(1) + expect(allTools.filter(t => t === 'Bash').length).toBe(1) + expect(allBashCommands.filter(cmd => cmd === 'npm').length).toBe(1) + }) + + it('uses conversation model for pricing the conversation record', async () => { + const composerId = 'ffff1111-2222-3333-4444-555566667777' + const dbPath = buildDb((db) => { + insertComposerData(db, { composerId, totalUsedTokens: 100000 }) + insertBubble(db, { composerId, bubbleUuid: 'b1', type: 1, text: 'prompt' }) + insertBubble(db, { + composerId, bubbleUuid: 'b2', type: 2, text: 'reply', + model: 'claude-4.5-opus-high-thinking', + }) + }) + + const provider = createCursorProvider(dbPath) + const calls = await collectCalls(provider, dbPath) + + const creditedCall = calls.find(c => c.inputTokens === 100000) + expect(creditedCall).toBeDefined() + expect(creditedCall!.model).toBe('claude-4.5-opus-high-thinking') + }) + + it('estimates input from the agent stream when a non-Composer turn has empty bubble text', async () => { + const composerId = '99990000-1111-2222-3333-444455556666' + const requestId = 'req-gpt-1' + const prompt = '<user_info>OS: darwin</user_info> refactor the auth module and add tests' + const dbPath = buildDb((db) => { + insertBubble(db, { composerId, bubbleUuid: 'b1', type: 1, text: '', requestId }) + insertBubble(db, { composerId, bubbleUuid: 'b2', type: 2, text: 'done', model: 'gpt-5' }) + insertAgentKv(db, { blobId: 'akv-1', role: 'user', content: prompt, requestId }) + }) + + const provider = createCursorProvider(dbPath) + const calls = await collectCalls(provider, dbPath) + + const credited = calls.find(c => c.inputTokens > 0) + expect(credited).toBeDefined() + expect(credited!.inputTokens).toBe(Math.ceil(prompt.length / 4)) + }) + + it('counts tool and system stream rows as context for meterless sessions', async () => { + const composerId = '77770000-1111-2222-3333-444455556666' + const requestId = 'req-gpt-2' + const prompt = 'summarize the repo' + const toolResult = 'x'.repeat(4000) + const dbPath = buildDb((db) => { + insertBubble(db, { composerId, bubbleUuid: 'b1', type: 1, text: '', requestId }) + insertBubble(db, { composerId, bubbleUuid: 'b2', type: 2, text: 'done', model: 'gpt-5' }) + insertAgentKv(db, { blobId: 'akv-1', role: 'user', content: prompt, requestId }) + insertAgentKv(db, { blobId: 'akv-2', role: 'tool', content: [{ type: 'text', text: toolResult }] }) + }) + + const provider = createCursorProvider(dbPath) + const calls = await collectCalls(provider, dbPath) + + const credited = calls.find(c => c.inputTokens > 0) + expect(credited).toBeDefined() + expect(credited!.inputTokens).toBe(Math.ceil((prompt.length + toolResult.length) / 4)) + }) + + it('does not double count turns that also have bubble text in stream-estimated conversations', async () => { + const composerId = '66660000-1111-2222-3333-444455556666' + const requestId = 'req-gpt-3' + const streamPrompt = 'the full prompt with injected context' + const dbPath = buildDb((db) => { + // Turn 1 has visible bubble text; turn 2's lives only in the stream. + insertBubble(db, { composerId, bubbleUuid: 'b1', type: 1, text: 'visible text', requestId }) + insertBubble(db, { composerId, bubbleUuid: 'b2', type: 1, text: '' }) + insertAgentKv(db, { blobId: 'akv-1', role: 'user', content: streamPrompt, requestId }) + }) + + const provider = createCursorProvider(dbPath) + const calls = await collectCalls(provider, dbPath) + + const inputTotal = calls.reduce((s, c) => s + c.inputTokens, 0) + expect(inputTotal).toBe(Math.ceil(streamPrompt.length / 4)) + }) + + it('emits sessions recorded only in the agent stream', async () => { + const requestId = 'req-headless-1' + const prompt = 'run the nightly data export' + const reply = 'export completed with 3 warnings' + const dbPath = buildDb((db) => { + insertAgentKv(db, { blobId: 'akv-1', role: 'user', content: prompt, requestId }) + insertAgentKv(db, { blobId: 'akv-2', role: 'assistant', content: [{ type: 'text', text: reply }] }) + }) + + const provider = createCursorProvider(dbPath) + const calls = await collectCalls(provider, dbPath) + + const session = calls.find(c => c.deduplicationKey === `cursor:agentKv:${requestId}`) + expect(session).toBeDefined() + expect(session!.inputTokens).toBe(Math.ceil(prompt.length / 4)) + expect(session!.outputTokens).toBe(Math.ceil(reply.length / 4)) + }) + + it('pairs each assistant reply with its own turn\'s user question', async () => { + const composerId = '55550000-1111-2222-3333-444455556666' + const dbPath = buildDb((db) => { + insertBubble(db, { composerId, bubbleUuid: 'b1', type: 1, text: 'first question' }) + insertBubble(db, { composerId, bubbleUuid: 'b2', type: 2, text: 'first reply', model: 'gpt-5' }) + insertBubble(db, { composerId, bubbleUuid: 'b3', type: 1, text: 'second question' }) + insertBubble(db, { composerId, bubbleUuid: 'b4', type: 2, text: 'second reply', model: 'gpt-5' }) + }) + + const provider = createCursorProvider(dbPath) + const calls = await collectCalls(provider, dbPath) + + const firstReply = calls.find(c => c.userMessage.includes('first reply')) + const secondReply = calls.find(c => c.userMessage.includes('second reply')) + expect(firstReply).toBeDefined() + expect(secondReply).toBeDefined() + expect(firstReply!.userMessage).toContain('first question') + expect(secondReply!.userMessage).toContain('second question') + }) + + it('does not fabricate input when an empty-text turn has no agent stream', async () => { + const composerId = '88880000-1111-2222-3333-444455556666' + const dbPath = buildDb((db) => { + insertBubble(db, { composerId, bubbleUuid: 'b1', type: 1, text: '' }) + insertBubble(db, { composerId, bubbleUuid: 'b2', type: 2, text: 'done', model: 'gpt-5' }) + }) + + const provider = createCursorProvider(dbPath) + const calls = await collectCalls(provider, dbPath) + + expect(calls.find(c => c.inputTokens > 0)).toBeUndefined() + }) +}) diff --git a/tests/providers/cursor-workspace-breakdown.test.ts b/tests/providers/cursor-workspace-breakdown.test.ts new file mode 100644 index 0000000..8e666b4 --- /dev/null +++ b/tests/providers/cursor-workspace-breakdown.test.ts @@ -0,0 +1,330 @@ +import { mkdtemp, mkdir, rm, writeFile } from 'fs/promises' +import { mkdirSync } from 'fs' +import { join } from 'path' +import { tmpdir } from 'os' +import { createRequire } from 'node:module' + +import { describe, it, expect, beforeEach, afterEach } from 'vitest' + +import { + createCursorProvider, + clearCursorWorkspaceMapCache, +} from '../../src/providers/cursor.js' +import { isSqliteAvailable } from '../../src/sqlite.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +const requireForTest = createRequire(import.meta.url) + +let userDir: string + +beforeEach(async () => { + userDir = await mkdtemp(join(tmpdir(), 'cursor-ws-test-')) + // Layout matches Cursor's: <userDir>/{globalStorage,workspaceStorage}/. + await mkdir(join(userDir, 'globalStorage'), { recursive: true }) + await mkdir(join(userDir, 'workspaceStorage'), { recursive: true }) + clearCursorWorkspaceMapCache() +}) + +afterEach(async () => { + clearCursorWorkspaceMapCache() + await rm(userDir, { recursive: true, force: true }) +}) + +function globalDbPath(): string { + return join(userDir, 'globalStorage', 'state.vscdb') +} + +/// Builds a global state.vscdb with the cursorDiskKV table and a small set of +/// bubbles for the requested composer ids. Each bubble carries enough fields +/// to satisfy parseBubbles() — created_at, tokenCount, conversationId, type. +function createGlobalDb(composerIds: string[]): string { + const dbPath = globalDbPath() + const { DatabaseSync: Database } = requireForTest('node:sqlite') + const db = new Database(dbPath) + db.exec(`CREATE TABLE cursorDiskKV (key TEXT PRIMARY KEY, value BLOB)`) + // ItemTable is unused by the global parser but creating it mirrors the + // real schema so a stray query against it does not error. + db.exec(`CREATE TABLE ItemTable (key TEXT UNIQUE, value BLOB)`) + + const insert = db.prepare(`INSERT INTO cursorDiskKV (key, value) VALUES (?, ?)`) + const baseTime = Date.now() - 24 * 3600 * 1000 + + for (const composerId of composerIds) { + // Exactly one assistant bubble per composer so the test math is + // "one composer == one call". User bubbles also produce calls in the + // real parser (text-length token estimation), but they are not + // necessary to exercise the workspace routing logic. + const bubbleId = `bubbleId:${composerId}:bubble-${composerId.slice(0, 6)}` + const bubble = { + type: 2, // assistant + conversationId: composerId, + createdAt: new Date(baseTime).toISOString(), + tokenCount: { inputTokens: 100, outputTokens: 50 }, + modelInfo: { modelName: 'claude-4.6-sonnet' }, + text: 'assistant reply for ' + composerId, + codeBlocks: '[]', + } + insert.run(bubbleId, JSON.stringify(bubble)) + } + + db.close() + return dbPath +} + +/// Creates one workspaceStorage/<hash>/ subdir with workspace.json (folder URI) +/// and state.vscdb (composer.composerData listing the supplied composerIds). +function createWorkspaceDir(hash: string, folderUri: string, composerIds: string[]): void { + const dir = join(userDir, 'workspaceStorage', hash) + mkdirSync(dir, { recursive: true }) + + const wsJsonPath = join(dir, 'workspace.json') + // We cannot do a top-level await in a sync helper; the caller writes via + // mkdirSync above and the JSON via Node's sync writeFile shim through the + // require'd 'fs'. Using readFileSync-friendly imports to keep this test + // helper sync. + const fs = requireForTest('fs') as typeof import('fs') + fs.writeFileSync(wsJsonPath, JSON.stringify({ folder: folderUri })) + + const wsDbPath = join(dir, 'state.vscdb') + const { DatabaseSync: Database } = requireForTest('node:sqlite') + const db = new Database(wsDbPath) + db.exec(`CREATE TABLE ItemTable (key TEXT UNIQUE, value BLOB)`) + const composerData = { + allComposers: composerIds.map(id => ({ + composerId: id, + name: 'session-' + id.slice(0, 6), + unifiedMode: 'agent', + })), + } + db.prepare(`INSERT INTO ItemTable (key, value) VALUES (?, ?)`).run( + 'composer.composerData', + JSON.stringify(composerData), + ) + db.close() +} + +async function collect(parser: { parse(): AsyncGenerator<ParsedProviderCall> }): Promise<ParsedProviderCall[]> { + const out: ParsedProviderCall[] = [] + for await (const call of parser.parse()) out.push(call) + return out +} + +describe('cursor provider — per-project breakdown (#196)', () => { + it('emits one source per workspace plus an orphan source', async () => { + if (!isSqliteAvailable()) return + + const dbPath = createGlobalDb([ + 'composer-work-1', + 'composer-work-2', + 'composer-personal-1', + 'composer-orphan-1', + ]) + createWorkspaceDir('hash-work', 'file:///Users/me/work-app', ['composer-work-1', 'composer-work-2']) + createWorkspaceDir('hash-personal', 'file:///Users/me/personal-app', ['composer-personal-1']) + + const provider = createCursorProvider(dbPath) + const sources = await provider.discoverSessions() + + const projects = sources.map(s => s.project).sort() + expect(projects).toContain('-Users-me-work-app') + expect(projects).toContain('-Users-me-personal-app') + // Orphan source is labeled 'cursor' so a user with no workspaces + // sees the same project name as before the breakdown change. + expect(projects).toContain('cursor') + }) + + it('routes calls to the right workspace and excludes others', async () => { + if (!isSqliteAvailable()) return + + const dbPath = createGlobalDb([ + 'composer-work-1', + 'composer-work-2', + 'composer-personal-1', + ]) + createWorkspaceDir('hash-work', 'file:///Users/me/work-app', ['composer-work-1', 'composer-work-2']) + createWorkspaceDir('hash-personal', 'file:///Users/me/personal-app', ['composer-personal-1']) + + const provider = createCursorProvider(dbPath) + const sources = await provider.discoverSessions() + const workSource = sources.find(s => s.project === '-Users-me-work-app')! + const personalSource = sources.find(s => s.project === '-Users-me-personal-app')! + + const workCalls = await collect(provider.createSessionParser(workSource, new Set())) + const personalCalls = await collect(provider.createSessionParser(personalSource, new Set())) + + const workComposerIds = new Set(workCalls.map(c => c.sessionId)) + expect(workComposerIds).toEqual(new Set(['composer-work-1', 'composer-work-2'])) + const personalComposerIds = new Set(personalCalls.map(c => c.sessionId)) + expect(personalComposerIds).toEqual(new Set(['composer-personal-1'])) + }) + + it('orphan source captures composers not registered in any workspace', async () => { + if (!isSqliteAvailable()) return + + const dbPath = createGlobalDb([ + 'composer-mapped', + 'composer-orphan-a', + 'composer-orphan-b', + ]) + createWorkspaceDir('hash-only', 'file:///Users/me/only-app', ['composer-mapped']) + + const provider = createCursorProvider(dbPath) + const sources = await provider.discoverSessions() + const orphanSource = sources.find(s => s.project === 'cursor')! + + const orphanCalls = await collect(provider.createSessionParser(orphanSource, new Set())) + const ids = new Set(orphanCalls.map(c => c.sessionId)) + expect(ids).toEqual(new Set(['composer-orphan-a', 'composer-orphan-b'])) + }) + + it('totals across all sources equal totals from the legacy single-source behavior', async () => { + if (!isSqliteAvailable()) return + + const dbPath = createGlobalDb([ + 'composer-work-1', + 'composer-personal-1', + 'composer-orphan-1', + ]) + createWorkspaceDir('hash-work', 'file:///Users/me/work-app', ['composer-work-1']) + createWorkspaceDir('hash-personal', 'file:///Users/me/personal-app', ['composer-personal-1']) + + const provider = createCursorProvider(dbPath) + const sources = await provider.discoverSessions() + + const seen = new Set<string>() + let totalCalls = 0 + let totalCost = 0 + for (const source of sources) { + const calls = await collect(provider.createSessionParser(source, seen)) + totalCalls += calls.length + for (const call of calls) totalCost += call.costUSD + } + // Three composers, one assistant call each => three calls overall. + expect(totalCalls).toBe(3) + expect(totalCost).toBeGreaterThan(0) + }) + + it('emits a single `cursor` source (legacy-equivalent) when no workspace mapping exists', async () => { + if (!isSqliteAvailable()) return + + // No createWorkspaceDir calls -> workspaceStorage exists but is empty. + const dbPath = createGlobalDb(['composer-1', 'composer-2']) + + const provider = createCursorProvider(dbPath) + const sources = await provider.discoverSessions() + expect(sources).toHaveLength(1) + expect(sources[0]!.project).toBe('cursor') + + const calls = await collect(provider.createSessionParser(sources[0]!, new Set())) + // All composers fall through to the orphan/catch-all source, matching + // the pre-PR behavior where every Cursor session showed under one row. + const ids = new Set(calls.map(c => c.sessionId)) + expect(ids).toEqual(new Set(['composer-1', 'composer-2'])) + }) + + it('handles multi-root workspaces (workspace.json without folder) by skipping them', async () => { + if (!isSqliteAvailable()) return + + const dbPath = createGlobalDb(['composer-multi']) + // Multi-root workspace: workspace.json carries `configuration` not `folder`. + const dir = join(userDir, 'workspaceStorage', 'hash-multi') + mkdirSync(dir, { recursive: true }) + await writeFile( + join(dir, 'workspace.json'), + JSON.stringify({ configuration: 'file:///path/to/.code-workspace' }), + ) + // No state.vscdb either — multi-root composer never registers. + + const provider = createCursorProvider(dbPath) + const sources = await provider.discoverSessions() + // Multi-root produces no workspace mapping; only the orphan source + // (labeled 'cursor') remains, and it captures the multi-root composer. + const projects = sources.map(s => s.project) + expect(projects).toEqual(['cursor']) + const calls = await collect(provider.createSessionParser(sources[0]!, new Set())) + expect(calls.map(c => c.sessionId)).toEqual(['composer-multi']) + }) + + it('sanitizes vscode-remote URIs into a slug', async () => { + if (!isSqliteAvailable()) return + + const dbPath = createGlobalDb(['composer-remote']) + createWorkspaceDir( + 'hash-remote', + 'vscode-remote://wsl+Ubuntu/home/me/proj', + ['composer-remote'], + ) + + const provider = createCursorProvider(dbPath) + const sources = await provider.discoverSessions() + const project = sources.find(s => s.project !== 'cursor')!.project + // file:// would yield "-Users-me-proj"; remote URIs get the scheme rewritten. + expect(project).toMatch(/wsl-Ubuntu/) + expect(project).toContain('home') + expect(project).toContain('proj') + }) + + it('drops sub-composer rows whose composer id is not a UUID', async () => { + if (!isSqliteAvailable()) return + + const dbPath = globalDbPath() + const { DatabaseSync: Database } = requireForTest('node:sqlite') + const db = new Database(dbPath) + db.exec(`CREATE TABLE cursorDiskKV (key TEXT PRIMARY KEY, value BLOB)`) + db.exec(`CREATE TABLE ItemTable (key TEXT UNIQUE, value BLOB)`) + const insert = db.prepare(`INSERT INTO cursorDiskKV (key, value) VALUES (?, ?)`) + + // One real composer with one bubble. Real composer ids are UUIDs. + const realComposerId = 'cccc1111-2222-3333-4444-555566667777' + insert.run(`bubbleId:${realComposerId}:bubble-real`, JSON.stringify({ + type: 2, + conversationId: realComposerId, + createdAt: new Date().toISOString(), + tokenCount: { inputTokens: 100, outputTokens: 50 }, + modelInfo: { modelName: 'claude-4.6-sonnet' }, + text: 'real', + codeBlocks: '[]', + })) + // A sub-composer row mirroring the real Cursor shape: the composer + // segment has an embedded newline and is not UUID-shaped. Must be + // dropped, not surfaced as its own session. + insert.run(`bubbleId:task-call_xxx\nfc_yyy:bubble-sub`, JSON.stringify({ + type: 2, + conversationId: '', + createdAt: new Date().toISOString(), + tokenCount: { inputTokens: 10, outputTokens: 5 }, + modelInfo: { modelName: 'claude-4.6-sonnet' }, + text: 'sub', + codeBlocks: '[]', + })) + db.close() + + createWorkspaceDir('hash-only', 'file:///Users/me/only', [realComposerId]) + + const provider = createCursorProvider(dbPath) + const sources = await provider.discoverSessions() + const seen = new Set<string>() + let allCalls = 0 + for (const source of sources) { + const calls = await collect(provider.createSessionParser(source, seen)) + allCalls += calls.length + } + // One real composer -> one call. Sub-composer dropped. Total: 1. + expect(allCalls).toBe(1) + }) + + it('remains backwards-compatible when given a legacy bare DB path', async () => { + if (!isSqliteAvailable()) return + + const dbPath = createGlobalDb(['composer-legacy-1', 'composer-legacy-2']) + createWorkspaceDir('hash-legacy', 'file:///Users/me/legacy', ['composer-legacy-1']) + + const provider = createCursorProvider(dbPath) + // Hand-construct a legacy SessionSource (no workspace tag) and verify + // it still yields every call regardless of workspace mapping. + const legacySource = { path: dbPath, project: 'cursor', provider: 'cursor' } + const calls = await collect(provider.createSessionParser(legacySource, new Set())) + const ids = new Set(calls.map(c => c.sessionId)) + expect(ids).toEqual(new Set(['composer-legacy-1', 'composer-legacy-2'])) + }) +}) diff --git a/tests/providers/cursor.test.ts b/tests/providers/cursor.test.ts new file mode 100644 index 0000000..61151a6 --- /dev/null +++ b/tests/providers/cursor.test.ts @@ -0,0 +1,167 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises' +import { join } from 'node:path' +import { tmpdir } from 'node:os' +import { createRequire } from 'node:module' +import { getAllProviders } from '../../src/providers/index.js' +import { getCursorTimeFloor, createCursorProvider, clearCursorWorkspaceMapCache } from '../../src/providers/cursor.js' +import { isSqliteAvailable } from '../../src/sqlite.js' +import type { Provider } from '../../src/providers/types.js' + +describe('cursor provider', () => { + let cursorProvider: Provider + + beforeEach(async () => { + const all = await getAllProviders() + cursorProvider = all.find(p => p.name === 'cursor')! + }) + it('is registered', () => { + expect(cursorProvider).toBeDefined() + expect(cursorProvider.name).toBe('cursor') + expect(cursorProvider.displayName).toBe('Cursor') + }) + + describe('model display names', () => { + it('maps cursor-auto to Cursor (auto) label', () => { + expect(cursorProvider.modelDisplayName('cursor-auto')).toBe('Cursor (auto)') + }) + + it('maps known models to readable names', () => { + expect(cursorProvider.modelDisplayName('claude-4.5-opus-high-thinking')).toBe('Opus 4.5 (Thinking)') + expect(cursorProvider.modelDisplayName('claude-4-sonnet-thinking')).toBe('Sonnet 4 (Thinking)') + expect(cursorProvider.modelDisplayName('grok-code-fast-1')).toBe('Grok Code Fast') + expect(cursorProvider.modelDisplayName('gemini-3-pro')).toBe('Gemini 3 Pro') + expect(cursorProvider.modelDisplayName('gpt-5')).toBe('GPT-5') + expect(cursorProvider.modelDisplayName('composer-1')).toBe('Composer 1') + }) + + it('returns raw name for unknown models', () => { + expect(cursorProvider.modelDisplayName('some-future-model')).toBe('some-future-model') + }) + }) + + describe('tool display names', () => { + it('returns raw tool name as identity', () => { + expect(cursorProvider.toolDisplayName('some_tool')).toBe('some_tool') + }) + }) + + describe('time floor', () => { + it('uses dateRange.start when within the six-month cap', () => { + const start = new Date(2026, 3, 1) + expect(getCursorTimeFloor({ start, end: new Date(2026, 5, 2) })).toBe(start.toISOString()) + }) + }) + + describe('session discovery', () => { + it('returns empty when sqlite is not available', async () => { + const sessions = await cursorProvider.discoverSessions() + expect(Array.isArray(sessions)).toBe(true) + }) + + it('returns empty when db does not exist', async () => { + const sessions = await cursorProvider.discoverSessions() + expect(sessions.every(s => s.provider === 'cursor')).toBe(true) + }) + }) +}) + +describe('cursor sqlite adapter', () => { + it('reports availability', async () => { + const { isSqliteAvailable } = await import('../../src/sqlite.js') + const available = isSqliteAvailable() + expect(typeof available).toBe('boolean') + }) + + it('provides error message when not available', async () => { + const { getSqliteLoadError } = await import('../../src/sqlite.js') + const error = getSqliteLoadError() + expect(typeof error).toBe('string') + expect(error.length).toBeGreaterThan(0) + }) +}) + +describe('cursor cache', () => { + it('returns null when no cache exists', async () => { + const { readCachedResults } = await import('../../src/cursor-cache.js') + const result = await readCachedResults('/nonexistent/path.db', new Date(0).toISOString()) + expect(result).toBeNull() + }) +}) + +// Regression: Cursor renamed the per-workspace composer list key from +// 'composer.composerData' to 'composer.composerHeaders'. loadWorkspaceMap must +// read both, otherwise every composer orphans into the 'cursor' catch-all and +// per-project attribution is lost. +describe('cursor workspace mapping (composer.composerHeaders regression)', () => { + const requireForTest = createRequire(import.meta.url) + type TestDb = { + exec(sql: string): void + prepare(sql: string): { run(...params: unknown[]): void } + close(): void + } + let root: string + + function writeItemTableDb(dbPath: string, key: string, composerIds: string[]): void { + const { DatabaseSync } = requireForTest('node:sqlite') as { DatabaseSync: new (p: string) => TestDb } + const db = new DatabaseSync(dbPath) + db.exec('CREATE TABLE ItemTable (key TEXT PRIMARY KEY, value TEXT)') + if (key) { + const value = JSON.stringify({ allComposers: composerIds.map(composerId => ({ composerId })) }) + db.prepare('INSERT INTO ItemTable (key, value) VALUES (?, ?)').run(key, value) + } + db.close() + } + + async function makeWorkspace(hash: string, folderUri: string, key: string, composerIds: string[]): Promise<void> { + const wsDir = join(root, 'User', 'workspaceStorage', hash) + await mkdir(wsDir, { recursive: true }) + await writeFile(join(wsDir, 'workspace.json'), JSON.stringify({ folder: folderUri })) + writeItemTableDb(join(wsDir, 'state.vscdb'), key, composerIds) + } + + async function makeGlobalDb(): Promise<string> { + const gsDir = join(root, 'User', 'globalStorage') + await mkdir(gsDir, { recursive: true }) + const dbPath = join(gsDir, 'state.vscdb') + // discoverSessions only needs the global DB to exist; the workspace map is + // built from the sibling workspaceStorage dir. + writeItemTableDb(dbPath, '', []) + return dbPath + } + + beforeEach(async () => { + root = await mkdtemp(join(tmpdir(), 'cursor-ws-test-')) + clearCursorWorkspaceMapCache() + }) + + afterEach(async () => { + clearCursorWorkspaceMapCache() + await rm(root, { recursive: true, force: true }) + }) + + it.skipIf(!isSqliteAvailable())( + 'maps composers to their workspace via composer.composerHeaders (new Cursor key)', + async () => { + await makeWorkspace('ws-headers', 'file:///home/user/myapp', 'composer.composerHeaders', ['comp-1', 'comp-2']) + const dbPath = await makeGlobalDb() + + const sources = await createCursorProvider(dbPath).discoverSessions() + const projects = sources.map(s => s.project) + + // Before the fix these composers orphaned to the 'cursor' catch-all. + expect(projects).toContain('-home-user-myapp') + }, + ) + + it.skipIf(!isSqliteAvailable())( + 'still maps composers via the legacy composer.composerData key', + async () => { + await makeWorkspace('ws-legacy', 'file:///home/user/legacy', 'composer.composerData', ['old-1']) + const dbPath = await makeGlobalDb() + + const sources = await createCursorProvider(dbPath).discoverSessions() + expect(sources.map(s => s.project)).toContain('-home-user-legacy') + }, + ) +}) diff --git a/tests/providers/devin.test.ts b/tests/providers/devin.test.ts new file mode 100644 index 0000000..0ceec22 --- /dev/null +++ b/tests/providers/devin.test.ts @@ -0,0 +1,816 @@ +import { mkdir, mkdtemp, rm, writeFile } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' +import { afterEach, beforeEach, describe, expect, it } from 'vitest' + +import { isSqliteAvailable } from '../../src/sqlite.js' +import { createDevinProvider } from '../../src/providers/devin.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'devin-provider-')) + process.env['HOME'] = tmpDir +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +async function configureDevinRate(rate = 1): Promise<void> { + await mkdir(join(tmpDir, '.config', 'codeburn'), { recursive: true }) + await writeFile(join(tmpDir, '.config', 'codeburn', 'config.json'), JSON.stringify({ + devin: { acuUsdRate: rate }, + })) +} + +async function writeTranscript(name: string, transcript: unknown): Promise<string> { + const transcriptsDir = join(tmpDir, 'transcripts') + await mkdir(transcriptsDir, { recursive: true }) + const filePath = join(transcriptsDir, name) + await writeFile(filePath, JSON.stringify(transcript)) + return filePath +} + +async function parseTranscript(filePath: string, project = 'devin'): Promise<ParsedProviderCall[]> { + const provider = createDevinProvider(tmpDir) + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser({ path: filePath, project, provider: 'devin' }, new Set()).parse()) { + calls.push(call) + } + return calls +} + +function createSessionsDb(): void { + const { DatabaseSync: Database } = require('node:sqlite') + const db = new Database(join(tmpDir, 'sessions.db')) + db.exec(` + CREATE TABLE sessions ( + id TEXT PRIMARY KEY, + working_directory TEXT, + backend_type TEXT, + model TEXT, + agent_mode TEXT, + created_at INTEGER, + last_activity_at INTEGER, + title TEXT, + hidden INTEGER NOT NULL DEFAULT 0 + ) + `) + db.prepare(` + INSERT INTO sessions (id, working_directory, model, created_at, last_activity_at, title, hidden) + VALUES (?, ?, ?, ?, ?, ?, ?) + `).run('db-session', '/Users/example/work/codeburn', 'claude-sonnet-4-6', 1_800_000_000, 1_800_000_010, 'CodeBurn', 0) + db.prepare(` + INSERT INTO sessions (id, working_directory, model, created_at, last_activity_at, title, hidden) + VALUES (?, ?, ?, ?, ?, ?, ?) + `).run('hidden-session', '/Users/example/work/hidden', 'claude-opus-4-6', 1_800_000_000, 1_800_000_010, 'Hidden', 1) + db.close() +} + +describe('devin provider', () => { + it('discovers Devin CLI transcript json files', async () => { + await configureDevinRate() + const filePath = await writeTranscript('glimmer-platinum.json', { steps: [] }) + await writeFile(join(tmpDir, 'transcripts', 'ignore.txt'), '{}') + + const provider = createDevinProvider(tmpDir) + const sources = await provider.discoverSessions() + + expect(sources).toEqual([ + { path: filePath, project: 'devin', provider: 'devin' }, + ]) + }) + + it('stays disabled until the Devin ACU rate is configured', async () => { + await writeTranscript('glimmer-platinum.json', { + session_id: 'session-123', + steps: [{ step_id: 's1', metadata: { committed_acu_cost: 0.5 } }], + }) + + const provider = createDevinProvider(tmpDir) + expect(await provider.discoverSessions()).toEqual([]) + expect(await parseTranscript(join(tmpDir, 'transcripts', 'glimmer-platinum.json'))).toEqual([]) + }) + + it('parses per-step ACUs, tokens, tools, and model resolution', async () => { + await configureDevinRate() + const filePath = await writeTranscript('glimmer-platinum.json', { + schema_version: '1', + session_id: 'session-123', + agent: { model_name: 'agent-model' }, + steps: [ + { + step_id: 1, + message: 'please inspect the repo', + metadata: { is_user_input: true, created_at: '2027-01-15T08:00:00.000Z' }, + }, + { + step_id: 2, + model_name: 'step-model', + metadata: { + created_at: '2027-01-15T08:00:01.000Z', + committed_acu_cost: 0.02076149918138981, + generation_model: 'claude-opus-4-6', + metrics: { + input_tokens: 100, + output_tokens: 20, + cache_creation_tokens: 10, + cache_read_tokens: 5, + }, + }, + tool_calls: [{ function_name: 'read_file' }], + }, + { + step_id: 3, + model_name: 'claude-sonnet-4-6', + metadata: { + created_at: '2027-01-15T08:00:02.000Z', + committed_acu_cost: 0.005421000067144632, + metrics: { input_tokens: 1 }, + }, + tool_calls: [{ function_name: 'str_replace' }], + }, + ], + }) + + const calls = await parseTranscript(filePath) + + expect(calls).toHaveLength(2) + expect(calls.reduce((sum, call) => sum + call.costUSD, 0)).toBeCloseTo(0.026182499248534442, 15) + expect(calls[0]).toMatchObject({ + provider: 'devin', + model: 'Opus 4.6', + inputTokens: 100, + outputTokens: 20, + cacheCreationInputTokens: 10, + cacheReadInputTokens: 5, + cachedInputTokens: 5, + costUSD: 0.02076149918138981, + tools: ['read_file'], + timestamp: '2027-01-15T08:00:01.000Z', + deduplicationKey: 'devin:session-123:2', + userMessage: 'please inspect the repo', + sessionId: 'session-123', + }) + expect(calls[1]).toMatchObject({ + model: 'Sonnet 4.6', + timestamp: '2027-01-15T08:00:02.000Z', + tools: ['str_replace'], + deduplicationKey: 'devin:session-123:3', + }) + }) + + it('renders Devin generation_model variants as friendly display names with effort tiers', async () => { + await configureDevinRate() + const cases = [ + { + schema: '1.4', + modelName: 'GPT-5.4', + location: 'metadata', + generationModel: 'gpt-5-3-codex-xhigh', + expected: 'GPT-5.3 Codex (xhigh)', + }, + { + schema: '1.4', + modelName: 'GPT-5.5', + location: 'metadata', + generationModel: 'gpt-5-4-low', + expected: 'GPT-5.4 (low)', + }, + { + schema: '1.4', + modelName: 'GPT-5.5', + location: 'metadata', + generationModel: 'gpt-5-5-medium', + expected: 'GPT-5.5 (medium)', + }, + { + schema: '1.4', + modelName: 'Gemini 3 Flash', + location: 'metadata', + generationModel: 'MODEL_PRIVATE_11', + expected: 'Gemini 3 Flash', + }, + { + schema: '1.4', + modelName: 'Gemini 3 Flash', + location: 'metadata', + generationModel: 'MODEL_GOOGLE_GEMINI_3_0_FLASH_MINIMAL', + expected: 'Gemini 3 Flash', + }, + { + schema: '1.7', + modelName: 'GPT-5.3-Codex', + location: 'extra', + generationModel: 'gpt-5-3-codex-xhigh', + expected: 'GPT-5.3 Codex (xhigh)', + }, + { + schema: '1.4', + modelName: 'GPT-5', + location: 'metadata', + generationModel: 'gpt-5', + expected: 'GPT-5', + }, + { + schema: '1.4', + modelName: 'GPT-5.6', + location: 'metadata', + generationModel: 'gpt-5-6-medium', + expected: 'GPT-5.6 (medium)', + }, + { + schema: '1.4', + modelName: 'GPT-5', + location: 'metadata', + generationModel: 'gpt-5-codex-xhigh', + expected: 'GPT-5 Codex (xhigh)', + }, + { + schema: '1.4', + modelName: 'GPT-5', + location: 'metadata', + generationModel: 'gpt-5-codex', + expected: 'GPT-5 Codex', + }, + { + schema: '1.4', + modelName: 'GPT-4', + location: 'metadata', + generationModel: 'gpt-4-1106-preview', + expected: 'gpt-4-1106-preview', + }, + ] as const + + for (let index = 0; index < cases.length; index++) { + const row = cases[index]! + const metadata: Record<string, unknown> = { + created_at: '2027-01-15T08:00:01.000Z', + committed_acu_cost: 0.1, + metrics: { input_tokens: 1 }, + } + const extra: Record<string, unknown> = {} + if (row.location === 'metadata') { + metadata['generation_model'] = row.generationModel + } else { + extra['generation_model'] = row.generationModel + } + + const step: Record<string, unknown> = { + step_id: index + 1, + source: 'assistant', + message: 'working', + metadata, + } + if (row.location === 'extra') step['extra'] = extra + + const filePath = await writeTranscript(`model-variant-${index}.json`, { + schema_version: row.schema, + session_id: `model-variant-${index}`, + agent: { model_name: row.modelName }, + steps: [step], + }) + + const calls = await parseTranscript(filePath) + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe(row.expected) + } + }) + + it('leaves already-friendly Devin model display names unchanged', () => { + const provider = createDevinProvider(tmpDir) + + expect(provider.modelDisplayName('GPT-5.3 Codex (xhigh)')).toBe('GPT-5.3 Codex (xhigh)') + }) + + it('includes token-only steps and skips user-input or empty steps', async () => { + await configureDevinRate() + const filePath = await writeTranscript('token-only.json', { + session_id: 'token-session', + agent: { model_name: 'agent-model' }, + steps: [ + { + step_id: 'user-cost', + metadata: { + is_user_input: true, + committed_acu_cost: 99, + metrics: { input_tokens: 99 }, + }, + }, + { step_id: 'empty', metadata: { created_at: '2026-06-05T10:00:00.000Z' } }, + { + step_id: 'tokens', + metadata: { + created_at: '2026-06-05T10:00:01.000Z', + metrics: { output_tokens: 42 }, + }, + }, + ], + }) + + const calls = await parseTranscript(filePath) + + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe('agent-model') + expect(calls[0]!.outputTokens).toBe(42) + expect(calls[0]!.costUSD).toBe(0) + }) + + it('converts ACUs to costUSD using the configured Devin rate', async () => { + await configureDevinRate(2.5) + const filePath = await writeTranscript('configured-rate.json', { + session_id: 'configured-rate', + agent: { model_name: 'agent-model' }, + steps: [ + { step_id: 's1', metadata: { committed_acu_cost: 0.4 } }, + ], + }) + + const calls = await parseTranscript(filePath) + + expect(calls).toHaveLength(1) + expect(calls[0]!.costUSD).toBeCloseTo(1, 12) + }) + + it('falls back to filename session id and deduplicates by step id', async () => { + await configureDevinRate() + const filePath = await writeTranscript('fallback-session.json', { + steps: [ + { + step_id: 1, + metadata: { + request_id: 'req-1', + committed_acu_cost: 0.1, + }, + }, + { + step_id: 2, + metadata: { + created_at: '2026-06-05T10:00:00.000Z', + committed_acu_cost: 0.2, + }, + }, + ], + }) + + const calls = await parseTranscript(filePath) + + expect(calls.map(c => c.sessionId)).toEqual(['fallback-session', 'fallback-session']) + expect(calls.map(c => c.model)).toEqual(['devin', 'devin']) + expect(calls.map(c => c.deduplicationKey)).toEqual([ + 'devin:fallback-session:1', + 'devin:fallback-session:2', + ]) + }) + + it('extracts user message from ContentPart[] messages (ATIF v1.7 multimodal)', async () => { + await configureDevinRate() + const filePath = await writeTranscript('content-parts.json', { + session_id: 'cp-session', + agent: { model_name: 'agent-model' }, + steps: [ + { + step_id: 1, + message: [ + { type: 'text', text: 'look at this screenshot' }, + { type: 'image', source: { media_type: 'image/png', path: '/tmp/screenshot.png' } }, + ], + metadata: { is_user_input: true, created_at: '2027-01-15T08:00:00.000Z' }, + }, + { + step_id: 2, + metadata: { + created_at: '2027-01-15T08:00:01.000Z', + committed_acu_cost: 0.1, + metrics: { input_tokens: 50 }, + }, + }, + ], + }) + + const calls = await parseTranscript(filePath) + + expect(calls).toHaveLength(1) + expect(calls[0]!.userMessage).toBe('look at this screenshot /tmp/screenshot.png') + }) + + it('parses ATIF v1.7 transcripts with agent.extra, final_metrics, and observations', async () => { + await configureDevinRate() + const filePath = await writeTranscript('atif-v17.json', { + schema_version: '1.7', + session_id: 'v17-session', + agent: { + name: 'devin', + version: '2.0', + model_name: 'claude-sonnet-4-6', + extra: { backend: 'cloud', permission_mode: 'auto' }, + }, + final_metrics: { + total_prompt_tokens: 500, + total_completion_tokens: 200, + total_cached_tokens: 50, + total_steps: 2, + }, + steps: [ + { + step_id: 1, + message: 'fix the bug', + metadata: { is_user_input: true, created_at: '2027-01-15T08:00:00.000Z' }, + }, + { + step_id: 2, + source: 'assistant', + model_name: 'claude-sonnet-4-6', + message: 'I will read the file first', + tool_calls: [{ tool_call_id: 'tc1', function_name: 'read_file', arguments: { path: 'src/main.ts' } }], + observation: { + results: [{ source_call_id: 'tc1', content: 'file contents here' }], + }, + extra: { + committed_acu_cost: 0.15, + generation_model: 'claude-sonnet-4-6', + telemetry: { source: 'devin-cli', operation: 'generate' }, + }, + metadata: { + created_at: '2027-01-15T08:00:01.000Z', + committed_acu_cost: 0.15, + metrics: { input_tokens: 200, output_tokens: 50, cache_creation_tokens: 20, cache_read_tokens: 10 }, + }, + }, + ], + }) + + const calls = await parseTranscript(filePath) + + expect(calls).toHaveLength(1) + expect(calls[0]).toMatchObject({ + provider: 'devin', + model: 'Sonnet 4.6', + inputTokens: 200, + outputTokens: 50, + cacheCreationInputTokens: 20, + cacheReadInputTokens: 10, + costUSD: 0.15, + tools: ['read_file'], + userMessage: 'fix the bug', + sessionId: 'v17-session', + }) + }) + + it('handles plain string user messages alongside ContentPart[] messages', async () => { + await configureDevinRate() + const filePath = await writeTranscript('mixed-messages.json', { + session_id: 'mixed-msg-session', + agent: { model_name: 'agent-model' }, + steps: [ + { + step_id: 1, + message: 'plain text user message', + metadata: { is_user_input: true, created_at: '2027-01-15T08:00:00.000Z' }, + }, + { + step_id: 2, + metadata: { + created_at: '2027-01-15T08:00:01.000Z', + committed_acu_cost: 0.1, + metrics: { input_tokens: 50 }, + }, + }, + { + step_id: 3, + message: [{ type: 'text', text: 'multimodal user message' }], + metadata: { is_user_input: true, created_at: '2027-01-15T08:00:02.000Z' }, + }, + { + step_id: 4, + metadata: { + created_at: '2027-01-15T08:00:03.000Z', + committed_acu_cost: 0.2, + metrics: { input_tokens: 100 }, + }, + }, + ], + }) + + const calls = await parseTranscript(filePath) + + expect(calls).toHaveLength(2) + expect(calls[0]!.userMessage).toBe('plain text user message') + expect(calls[1]!.userMessage).toBe('multimodal user message') + }) + + it('reads ACU cost from step.extra when metadata.committed_acu_cost is absent', async () => { + await configureDevinRate() + const filePath = await writeTranscript('extra-acu.json', { + session_id: 'extra-acu-session', + agent: { model_name: 'agent-model' }, + steps: [ + { + step_id: 1, + extra: { committed_acu_cost: 0.3 }, + metadata: { + created_at: '2027-01-15T08:00:00.000Z', + metrics: { input_tokens: 10 }, + }, + }, + ], + }) + + const calls = await parseTranscript(filePath) + + expect(calls).toHaveLength(1) + expect(calls[0]!.costUSD).toBeCloseTo(0.3, 12) + }) + + it('prefers metadata.committed_acu_cost over extra.committed_acu_cost', async () => { + await configureDevinRate() + const filePath = await writeTranscript('acu-priority.json', { + session_id: 'acu-priority-session', + agent: { model_name: 'agent-model' }, + steps: [ + { + step_id: 1, + extra: { committed_acu_cost: 0.99 }, + metadata: { + created_at: '2027-01-15T08:00:00.000Z', + committed_acu_cost: 0.11, + metrics: { input_tokens: 10 }, + }, + }, + ], + }) + + const calls = await parseTranscript(filePath) + + expect(calls).toHaveLength(1) + expect(calls[0]!.costUSD).toBeCloseTo(0.11, 12) + }) + + it('reads tokens from step.metrics when metadata.metrics is absent', async () => { + await configureDevinRate() + const filePath = await writeTranscript('step-metrics.json', { + session_id: 'step-metrics-session', + agent: { model_name: 'agent-model' }, + steps: [ + { + step_id: 1, + metrics: { + prompt_tokens: 300, + completion_tokens: 75, + cached_tokens: 15, + extra: { cache_creation_input_tokens: 25 }, + }, + extra: { committed_acu_cost: 0.2 }, + metadata: { created_at: '2027-01-15T08:00:00.000Z' }, + }, + ], + }) + + const calls = await parseTranscript(filePath) + + expect(calls).toHaveLength(1) + expect(calls[0]).toMatchObject({ + inputTokens: 300, + outputTokens: 75, + cacheCreationInputTokens: 25, + cacheReadInputTokens: 15, + cachedInputTokens: 15, + costUSD: 0.2, + }) + }) + + it('prefers step.metrics over metadata.metrics when both are present', async () => { + await configureDevinRate() + const filePath = await writeTranscript('metrics-priority.json', { + session_id: 'metrics-priority-session', + agent: { model_name: 'agent-model' }, + steps: [ + { + step_id: 1, + metrics: { + prompt_tokens: 500, + completion_tokens: 100, + cached_tokens: 20, + extra: { cache_creation_input_tokens: 30 }, + }, + metadata: { + created_at: '2027-01-15T08:00:00.000Z', + committed_acu_cost: 0.1, + metrics: { + input_tokens: 1, + output_tokens: 1, + cache_creation_tokens: 1, + cache_read_tokens: 1, + }, + }, + }, + ], + }) + + const calls = await parseTranscript(filePath) + + expect(calls).toHaveLength(1) + expect(calls[0]).toMatchObject({ + inputTokens: 500, + outputTokens: 100, + cacheCreationInputTokens: 30, + cacheReadInputTokens: 20, + cachedInputTokens: 20, + }) + }) + + it('handles observation results with ContentPart[] content', async () => { + await configureDevinRate() + const filePath = await writeTranscript('observation-content-parts.json', { + session_id: 'obs-cp-session', + agent: { model_name: 'agent-model' }, + steps: [ + { + step_id: 1, + message: 'check the image', + metadata: { is_user_input: true, created_at: '2027-01-15T08:00:00.000Z' }, + }, + { + step_id: 2, + source: 'assistant', + message: 'reading file', + tool_calls: [{ tool_call_id: 'tc1', function_name: 'read_file', arguments: {} }], + observation: { + results: [{ + source_call_id: 'tc1', + content: [ + { type: 'text', text: 'file output here' }, + { type: 'image', source: { media_type: 'image/png', path: '/tmp/output.png' } }, + ], + }], + }, + metadata: { + created_at: '2027-01-15T08:00:01.000Z', + committed_acu_cost: 0.1, + metrics: { input_tokens: 100, output_tokens: 30 }, + }, + }, + ], + }) + + const calls = await parseTranscript(filePath) + + expect(calls).toHaveLength(1) + expect(calls[0]).toMatchObject({ + tools: ['read_file'], + costUSD: 0.1, + inputTokens: 100, + outputTokens: 30, + }) + }) + + it('falls back to metadata.metrics when step.metrics is present but empty', async () => { + await configureDevinRate() + const filePath = await writeTranscript('empty-step-metrics.json', { + session_id: 'empty-metrics-session', + agent: { model_name: 'agent-model' }, + steps: [ + { + step_id: 1, + metrics: {}, + metadata: { + created_at: '2027-01-15T08:00:00.000Z', + committed_acu_cost: 0.1, + metrics: { input_tokens: 80, output_tokens: 20, cache_read_tokens: 5 }, + }, + }, + ], + }) + + const calls = await parseTranscript(filePath) + + expect(calls).toHaveLength(1) + expect(calls[0]).toMatchObject({ + inputTokens: 80, + outputTokens: 20, + cacheReadInputTokens: 5, + costUSD: 0.1, + }) + }) + + it('normalizes an image-only ContentPart[] user message to its path', async () => { + await configureDevinRate() + const filePath = await writeTranscript('image-only.json', { + session_id: 'image-only-session', + agent: { model_name: 'agent-model' }, + steps: [ + { + step_id: 1, + message: [ + { type: 'image', source: { media_type: 'image/png', path: '/tmp/only.png' } }, + ], + metadata: { is_user_input: true, created_at: '2027-01-15T08:00:00.000Z' }, + }, + { + step_id: 2, + metadata: { + created_at: '2027-01-15T08:00:01.000Z', + committed_acu_cost: 0.1, + metrics: { input_tokens: 40 }, + }, + }, + ], + }) + + const calls = await parseTranscript(filePath) + + expect(calls).toHaveLength(1) + expect(calls[0]!.userMessage).toBe('/tmp/only.png') + }) + + it('ignores array-root and malformed transcripts', async () => { + await configureDevinRate() + const arrayPath = await writeTranscript('array.json', []) + const malformedPath = join(tmpDir, 'transcripts', 'bad.json') + await writeFile(malformedPath, '{') + + expect(await parseTranscript(arrayPath)).toEqual([]) + expect(await parseTranscript(malformedPath)).toEqual([]) + }) + + it('deduplicates calls with a shared seen key set', async () => { + await configureDevinRate() + const filePath = await writeTranscript('dupe.json', { + session_id: 'dupe-session', + steps: [{ step_id: 's1', metadata: { committed_acu_cost: 0.5 } }], + }) + const provider = createDevinProvider(tmpDir) + const seenKeys = new Set<string>() + const source = { path: filePath, project: 'devin', provider: 'devin' } + + const first: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, seenKeys).parse()) first.push(call) + const second: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, seenKeys).parse()) second.push(call) + + expect(first).toHaveLength(1) + expect(second).toHaveLength(0) + }) +}) + +const skipUnlessSqlite = isSqliteAvailable() ? describe : describe.skip + +skipUnlessSqlite('devin provider sessions.db enrichment', () => { + it('uses sessions.db to enrich project, projectPath, model, and timestamp fallbacks', async () => { + await configureDevinRate() + createSessionsDb() + const filePath = await writeTranscript('db-session.json', { + session_id: 'db-session', + steps: [ + { + step_id: 's1', + metadata: { + committed_acu_cost: 0.25, + metrics: { input_tokens: 10 }, + }, + }, + ], + }) + + const calls = await parseTranscript(filePath, 'fallback-project') + + expect(calls).toHaveLength(1) + expect(calls[0]).toMatchObject({ + model: 'Sonnet 4.6', + project: 'codeburn', + projectPath: '/Users/example/work/codeburn', + timestamp: '2027-01-15T08:00:10.000Z', + costUSD: 0.25, + }) + }) + + it('uses sessions.db project labels during discovery when transcript filename matches the session id', async () => { + await configureDevinRate() + createSessionsDb() + const filePath = await writeTranscript('db-session.json', { session_id: 'db-session', steps: [] }) + + const provider = createDevinProvider(tmpDir) + const sources = await provider.discoverSessions() + + expect(sources).toEqual([ + { path: filePath, project: 'codeburn', provider: 'devin' }, + ]) + }) + + it('skips sessions hidden in sessions.db', async () => { + await configureDevinRate() + createSessionsDb() + await writeTranscript('hidden-session.json', { + session_id: 'hidden-session', + steps: [{ step_id: 's1', metadata: { committed_acu_cost: 0.25 } }], + }) + + const provider = createDevinProvider(tmpDir) + expect(await provider.discoverSessions()).toEqual([]) + + const calls = await parseTranscript(join(tmpDir, 'transcripts', 'hidden-session.json')) + expect(calls).toEqual([]) + }) +}) diff --git a/tests/providers/droid.test.ts b/tests/providers/droid.test.ts new file mode 100644 index 0000000..c312b45 --- /dev/null +++ b/tests/providers/droid.test.ts @@ -0,0 +1,148 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { createDroidProvider } from '../../src/providers/droid.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let factoryDir: string + +async function writeSession(opts: { + projectDir?: string + sessionId?: string + lines?: unknown[] + settings?: unknown + subdir?: string +}): Promise<string> { + const sessionId = opts.sessionId ?? 'session-1' + const projectDir = opts.projectDir ?? '/tmp/my-project' + const subdir = opts.subdir ?? '-tmp-my-project' + const dir = join(factoryDir, 'sessions', subdir) + await mkdir(dir, { recursive: true }) + const jsonlPath = join(dir, `${sessionId}.jsonl`) + const lines = opts.lines ?? [ + { type: 'session_start', id: sessionId, cwd: projectDir, title: 'Test session' }, + { type: 'message', id: 'u1', timestamp: '2026-04-20T10:00:00.000Z', message: { role: 'user', content: [{ type: 'text', text: 'build this' }] } }, + { type: 'message', id: 'a1', timestamp: '2026-04-20T10:00:01.000Z', message: { role: 'assistant', content: [{ type: 'text', text: 'done' }] } }, + ] + await writeFile(jsonlPath, lines.map(line => JSON.stringify(line)).join('\n')) + + if (opts.settings !== undefined) { + await writeFile(join(dir, `${sessionId}.settings.json`), JSON.stringify(opts.settings)) + } + + return jsonlPath +} + +async function parseAll(filePath: string, seen = new Set<string>()): Promise<ParsedProviderCall[]> { + const provider = createDroidProvider(factoryDir) + const parser = provider.createSessionParser({ path: filePath, project: 'proj', provider: 'droid' }, seen) + const calls: ParsedProviderCall[] = [] + for await (const call of parser.parse()) calls.push(call) + return calls +} + +describe('droid provider', () => { + beforeEach(async () => { + factoryDir = await mkdtemp(join(tmpdir(), 'codeburn-droid-test-')) + }) + + afterEach(async () => { + await rm(factoryDir, { recursive: true, force: true }) + }) + + it('discovers Droid JSONL sessions', async () => { + await writeSession({ settings: { model: 'gpt-5', tokenUsage: { inputTokens: 10, outputTokens: 5, cacheCreationTokens: 0, cacheReadTokens: 0, thinkingTokens: 0 } } }) + + const provider = createDroidProvider(factoryDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.provider).toBe('droid') + expect(sessions[0]!.path.endsWith('session-1.jsonl')).toBe(true) + }) + + it('parses calls and distributes session-level token usage', async () => { + const path = await writeSession({ + lines: [ + { type: 'session_start', id: 'session-1', cwd: '/tmp/my-project' }, + { type: 'message', id: 'u1', timestamp: '2026-04-20T10:00:00.000Z', message: { role: 'user', content: [{ type: 'text', text: '<system-reminder>x</system-reminder>' }, { type: 'text', text: 'build this' }] } }, + { type: 'message', id: 'a1', timestamp: '2026-04-20T10:00:01.000Z', message: { role: 'assistant', content: [{ type: 'text', text: 'first' }] } }, + { type: 'message', id: 'a2', timestamp: '2026-04-20T10:00:02.000Z', message: { role: 'assistant', content: [{ type: 'text', text: 'second' }] } }, + ], + settings: { model: 'custom:gpt-5-[Proxy]-0', tokenUsage: { inputTokens: 101, outputTokens: 51, cacheCreationTokens: 7, cacheReadTokens: 11, thinkingTokens: 5 } }, + }) + + const calls = await parseAll(path) + + expect(calls).toHaveLength(2) + expect(calls[0]!.provider).toBe('droid') + expect(calls[0]!.model).toBe('gpt-5') + expect(calls[0]!.inputTokens).toBe(50) + expect(calls[1]!.inputTokens).toBe(51) + expect(calls[0]!.outputTokens).toBe(25) + expect(calls[1]!.outputTokens).toBe(26) + expect(calls[0]!.cacheReadInputTokens).toBe(5) + expect(calls[1]!.cacheReadInputTokens).toBe(6) + expect(calls[0]!.userMessage).toBe('build this') + expect(calls[0]!.sessionId).toBe('session-1') + }) + + it('extracts tools and meaningful bash command names', async () => { + const path = await writeSession({ + lines: [ + { type: 'session_start', id: 'session-1', cwd: '/tmp/my-project' }, + { type: 'message', id: 'a1', timestamp: '2026-04-20T10:00:01.000Z', message: { role: 'assistant', content: [ + { type: 'tool_use', name: 'Execute', input: { command: "python3 - <<'PY'\nimport os\n}\nPY" } }, + { type: 'tool_use', name: 'Read', input: { file_path: '/tmp/a' } }, + { type: 'tool_use', name: 'Task', input: { prompt: 'do work' } }, + ] } }, + ], + settings: { model: 'gpt-5', tokenUsage: { inputTokens: 10, outputTokens: 5, cacheCreationTokens: 0, cacheReadTokens: 0, thinkingTokens: 0 } }, + }) + + const calls = await parseAll(path) + + expect(calls).toHaveLength(1) + expect(calls[0]!.tools).toEqual(['Bash', 'Read', 'Agent']) + expect(calls[0]!.bashCommands).toContain('python3') + expect(calls[0]!.bashCommands).not.toContain('import') + expect(calls[0]!.bashCommands).not.toContain('}') + }) + + it('deduplicates calls by session and message id', async () => { + const path = await writeSession({ settings: { model: 'gpt-5', tokenUsage: { inputTokens: 10, outputTokens: 5, cacheCreationTokens: 0, cacheReadTokens: 0, thinkingTokens: 0 } } }) + const seen = new Set<string>() + + expect(await parseAll(path, seen)).toHaveLength(1) + expect(await parseAll(path, seen)).toHaveLength(0) + }) + + it('strips Droid model wrappers for display', () => { + const provider = createDroidProvider(factoryDir) + expect(provider.modelDisplayName('custom:GLM-5.1-[Proxy]-0')).toBe('GLM-5.1') + expect(provider.modelDisplayName('custom:claude-sonnet-4-6-1')).toBe('Sonnet 4.6') + }) + + it('returns no calls when settings are missing', async () => { + const path = await writeSession({}) + expect(await parseAll(path)).toHaveLength(0) + }) + + it('skips internal .factory sessions during discovery', async () => { + await writeSession({ projectDir: factoryDir, subdir: '-internal', settings: { model: 'gpt-5', tokenUsage: { inputTokens: 10, outputTokens: 5, cacheCreationTokens: 0, cacheReadTokens: 0, thinkingTokens: 0 } } }) + + const provider = createDroidProvider(factoryDir) + expect(await provider.discoverSessions()).toHaveLength(0) + }) + + it('returns no calls for empty sessions', async () => { + const path = await writeSession({ + lines: [{ type: 'session_start', id: 'empty', cwd: '/tmp/my-project' }], + settings: { model: 'gpt-5', tokenUsage: { inputTokens: 10, outputTokens: 5, cacheCreationTokens: 0, cacheReadTokens: 0, thinkingTokens: 0 } }, + }) + + expect(await parseAll(path)).toHaveLength(0) + }) +}) diff --git a/tests/providers/forge.test.ts b/tests/providers/forge.test.ts new file mode 100644 index 0000000..cd2b66b --- /dev/null +++ b/tests/providers/forge.test.ts @@ -0,0 +1,275 @@ +import { mkdtemp, readFile, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' +import { createRequire } from 'node:module' + +import { afterEach, beforeEach, describe, expect, it } from 'vitest' +import { isSqliteAvailable } from '../../src/sqlite.js' +import { createForgeProvider } from '../../src/providers/forge.js' +import { getProvider } from '../../src/providers/index.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +const requireForTest = createRequire(import.meta.url) + +type TestDb = { + exec(sql: string): void + prepare(sql: string): { run(...params: unknown[]): void } + close(): void +} + +let tmpRoot: string + +beforeEach(async () => { + tmpRoot = await mkdtemp(join(tmpdir(), 'forge-test-')) +}) + +afterEach(async () => { + await rm(tmpRoot, { recursive: true, force: true }) +}) + +function createForgeDb(): string { + const dbPath = join(tmpRoot, 'forge.db') + const { DatabaseSync: Database } = requireForTest('node:sqlite') + const db = new Database(dbPath) + db.exec(` + CREATE TABLE conversations( + conversation_id TEXT PRIMARY KEY NOT NULL, + title TEXT, + workspace_id BIGINT NOT NULL, + context TEXT, + created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP, + metrics TEXT + ) + `) + db.close() + return dbPath +} + +function withTestDb(dbPath: string, fn: (db: TestDb) => void): void { + const { DatabaseSync: Database } = requireForTest('node:sqlite') + const db = new Database(dbPath) + try { + fn(db) + } finally { + db.close() + } +} + +function insertConversationRow(db: TestDb, overrides: { + conversationId?: string + title?: string | null + workspaceId?: number | string + context?: string | null + createdAt?: string + updatedAt?: string | null +} = {}): void { + db.prepare(` + INSERT INTO conversations (conversation_id, title, workspace_id, context, created_at, updated_at, metrics) + VALUES (?, ?, ?, ?, ?, ?, ?) + `).run( + overrides.conversationId ?? 'conv-1', + 'title' in overrides ? overrides.title : 'Forge Project', + overrides.workspaceId ?? 123, + overrides.context ?? null, + overrides.createdAt ?? '2026-05-06 15:00:00', + 'updatedAt' in overrides ? overrides.updatedAt : '2026-05-06 15:20:41.379094', + null, + ) +} + +function insertConversation(db: TestDb): void { + const context = { + conversation_id: 'conv-1', + messages: [ + { message: { text: { role: 'User', content: 'implement forge' } } }, + { + message: { + text: { + role: 'Assistant', + content: '', + model: 'claude-opus-4-6', + tool_calls: [ + { name: 'shell', call_id: 'call-1', arguments: { command: 'git status && npm test' } }, + { name: 'Read', call_id: 'call-2', arguments: { file_path: '/tmp/a' } }, + ], + }, + }, + usage: { + prompt_tokens: { actual: 1200 }, + completion_tokens: { actual: 300 }, + total_tokens: { actual: 1500 }, + cached_tokens: { actual: 200 }, + }, + }, + ], + } + + insertConversationRow(db, { context: JSON.stringify(context) }) +} + +async function collect(parser: { parse(): AsyncGenerator<ParsedProviderCall> }): Promise<ParsedProviderCall[]> { + const out: ParsedProviderCall[] = [] + for await (const call of parser.parse()) out.push(call) + return out +} + +describe('forge provider', () => { + it('discovers conversations with context and parses assistant usage/tool calls', async () => { + if (!isSqliteAvailable()) return + + const dbPath = createForgeDb() + withTestDb(dbPath, insertConversation) + + const provider = createForgeProvider(dbPath) + const sources = await provider.discoverSessions() + + expect(sources).toEqual([ + { + path: `${dbPath}:conv-1`, + project: 'Forge Project', + provider: 'forge', + }, + ]) + + const seenKeys = new Set<string>() + const calls = await collect(provider.createSessionParser(sources[0]!, seenKeys)) + + expect(calls).toHaveLength(1) + expect(calls[0]).toMatchObject({ + provider: 'forge', + model: 'claude-opus-4-6', + inputTokens: 1000, + outputTokens: 300, + cacheReadInputTokens: 200, + cachedInputTokens: 200, + cacheCreationInputTokens: 0, + tools: ['Bash', 'Read'], + bashCommands: ['git', 'npm'], + userMessage: 'implement forge', + sessionId: 'conv-1', + timestamp: '2026-05-06T15:20:41.379Z', + deduplicationKey: 'forge:conv-1:call-1', + }) + + const duplicates = await collect(provider.createSessionParser(sources[0]!, seenKeys)) + expect(duplicates).toEqual([]) + }) + + it('does not select conversation context while discovering sessions', async () => { + const source = await readFile(new URL('../../src/providers/forge.ts', import.meta.url), 'utf8') + const discoverySql = source.match(/async function discoverFromDb[\s\S]*?db\.query<[^>]+>\(\s*`([\s\S]*?)`/)?.[1] + const selectedColumns = discoverySql?.split('FROM conversations')[0] ?? '' + + expect(discoverySql).toContain('WHERE context IS NOT NULL') + expect(selectedColumns).not.toMatch(/\bcontext\b/) + expect(selectedColumns).not.toMatch(/\bcreated_at\b|\bupdated_at\b/) + }) + + it('returns no sessions when the database is missing', async () => { + const provider = createForgeProvider(join(tmpRoot, 'missing.db')) + + await expect(provider.discoverSessions()).resolves.toEqual([]) + }) + + it('skips zero-token assistant usage', async () => { + if (!isSqliteAvailable()) return + + const dbPath = createForgeDb() + const context = { + messages: [ + { message: { text: { role: 'User', content: 'zero tokens' } } }, + { + message: { text: { role: 'Assistant', model: 'claude-opus-4-6' } }, + usage: { + prompt_tokens: { actual: 0 }, + completion_tokens: { actual: 0 }, + cached_tokens: { actual: 0 }, + }, + }, + ], + } + withTestDb(dbPath, db => insertConversationRow(db, { context: JSON.stringify(context) })) + + const provider = createForgeProvider(dbPath) + const sources = await provider.discoverSessions() + const calls = await collect(provider.createSessionParser(sources[0]!, new Set())) + + expect(calls).toEqual([]) + }) + + it('parses multiple assistant messages with the nearest previous user prompt', async () => { + if (!isSqliteAvailable()) return + + const dbPath = createForgeDb() + const context = { + messages: [ + { message: { text: { role: 'User', content: 'first request' } } }, + { + message: { text: { role: 'Assistant', model: 'claude-opus-4-6', tool_calls: [{ name: 'shell', call_id: 'call-1', arguments: { command: 'npm test' } }] } }, + usage: { prompt_tokens: { actual: 100 }, completion_tokens: { actual: 20 } }, + }, + { message: { text: { role: 'User', content: 'second request' } } }, + { + message: { text: { role: 'Assistant', model: 'claude-sonnet-4-6', tool_calls: [{ name: 'Read', call_id: 'call-2', arguments: { file_path: '/tmp/a' } }] } }, + usage: { prompt_tokens: { actual: 200 }, completion_tokens: { actual: 30 } }, + }, + ], + } + withTestDb(dbPath, db => insertConversationRow(db, { context: JSON.stringify(context) })) + + const provider = createForgeProvider(dbPath) + const sources = await provider.discoverSessions() + const calls = await collect(provider.createSessionParser(sources[0]!, new Set())) + + expect(calls).toHaveLength(2) + expect(calls.map(call => call.userMessage)).toEqual(['first request', 'second request']) + expect(calls.map(call => call.deduplicationKey)).toEqual(['forge:conv-1:call-1', 'forge:conv-1:call-2']) + }) + + it('uses workspace_id as project when title is null', async () => { + if (!isSqliteAvailable()) return + + const dbPath = createForgeDb() + withTestDb(dbPath, db => insertConversationRow(db, { title: null, workspaceId: 'workspace-1', context: '{}' })) + + const provider = createForgeProvider(dbPath) + const sources = await provider.discoverSessions() + + expect(sources[0]?.project).toBe('workspace-1') + }) + + it('uses large integer workspace_id values as strings when title is null', async () => { + if (!isSqliteAvailable()) return + + const dbPath = createForgeDb() + withTestDb(dbPath, db => { + db.exec(` + INSERT INTO conversations (conversation_id, title, workspace_id, context, created_at, updated_at, metrics) + VALUES ('conv-1', NULL, 8549909960051246556, '{}', '2026-05-06 15:00:00', '2026-05-06 15:20:41.379094', NULL) + `) + }) + + const provider = createForgeProvider(dbPath) + const sources = await provider.discoverSessions() + + expect(sources[0]?.project).toBe('8549909960051246556') + }) + + it('does not throw and yields no calls for invalid JSON context', async () => { + if (!isSqliteAvailable()) return + + const dbPath = createForgeDb() + withTestDb(dbPath, db => insertConversationRow(db, { context: '{invalid' })) + + const provider = createForgeProvider(dbPath) + const sources = await provider.discoverSessions() + + await expect(collect(provider.createSessionParser(sources[0]!, new Set()))).resolves.toEqual([]) + }) + + it('is available through the provider registry', async () => { + const provider = await getProvider('forge') + expect(provider?.name).toBe('forge') + }) +}) diff --git a/tests/providers/gemini.test.ts b/tests/providers/gemini.test.ts new file mode 100644 index 0000000..5dee848 --- /dev/null +++ b/tests/providers/gemini.test.ts @@ -0,0 +1,193 @@ +import { mkdtemp, rm, writeFile } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' +import { afterEach, beforeEach, describe, expect, it } from 'vitest' + +import { createGeminiProvider } from '../../src/providers/gemini.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'gemini-provider-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +async function parseFixture(messages: unknown[]): Promise<ParsedProviderCall[]> { + const filePath = join(tmpDir, 'session-gemini.json') + await writeFile(filePath, JSON.stringify({ + sessionId: 'gemini-session-1', + startTime: '2026-05-16T10:00:00.000Z', + messages, + })) + + const provider = createGeminiProvider() + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser({ path: filePath, project: 'gemini-project', provider: 'gemini' }, new Set()).parse()) { + calls.push(call) + } + return calls +} + +describe('gemini provider', () => { + it('emits one provider call per Gemini message with token usage', async () => { + const calls = await parseFixture([ + { + id: 'u1', + timestamp: '2026-05-16T10:00:00.000Z', + type: 'user', + content: 'inspect the repo', + }, + { + id: 'g1', + timestamp: '2026-05-16T10:00:05.000Z', + type: 'gemini', + content: 'reading files', + model: 'gemini-3.1-pro-preview', + tokens: { input: 120, cached: 20, output: 30, thoughts: 5 }, + toolCalls: [{ id: 't1', name: 'read_file', args: { path: 'src/index.ts' } }], + }, + { + id: 'u2', + timestamp: '2026-05-16T10:01:00.000Z', + type: 'user', + content: [{ text: 'run tests' }], + }, + { + id: 'g2', + timestamp: '2026-05-16T10:01:10.000Z', + type: 'gemini', + content: 'running tests', + model: 'gemini-3.1-pro-preview', + tokens: { input: 80, cached: 10, output: 25 }, + toolCalls: [{ id: 't2', name: 'run_command', args: { command: 'npm test' } }], + }, + ]) + + expect(calls).toHaveLength(2) + expect(calls.map(c => c.deduplicationKey)).toEqual([ + 'gemini:gemini-session-1:g1', + 'gemini:gemini-session-1:g2', + ]) + expect(calls.map(c => c.timestamp)).toEqual([ + '2026-05-16T10:00:05.000Z', + '2026-05-16T10:01:10.000Z', + ]) + expect(calls.map(c => c.userMessage)).toEqual(['inspect the repo', 'run tests']) + expect(calls[0]!.inputTokens).toBe(100) + expect(calls[0]!.cacheReadInputTokens).toBe(20) + expect(calls[0]!.reasoningTokens).toBe(5) + expect(calls[0]!.tools).toEqual(['Read']) + expect(calls[1]!.inputTokens).toBe(70) + expect(calls[1]!.cacheReadInputTokens).toBe(10) + expect(calls[1]!.tools).toEqual(['Bash']) + expect(calls[1]!.bashCommands).toEqual(['npm']) + }) + + it('keeps aggregate token totals when splitting a Gemini session into calls', async () => { + const calls = await parseFixture([ + { id: 'u1', timestamp: '2026-05-16T10:00:00.000Z', type: 'user', content: 'work' }, + { + id: 'g1', + timestamp: '2026-05-16T10:00:05.000Z', + type: 'gemini', + content: 'first', + model: 'gemini-3.1-pro-preview', + tokens: { input: 120, cached: 20, output: 30, thoughts: 5 }, + }, + { + id: 'g2', + timestamp: '2026-05-16T10:00:10.000Z', + type: 'gemini', + content: 'second', + model: 'gemini-3.1-pro-preview', + tokens: { input: 80, cached: 10, output: 25, thoughts: 0 }, + }, + ]) + + expect(calls).toHaveLength(2) + expect(calls.reduce((sum, call) => sum + call.inputTokens, 0)).toBe(170) + expect(calls.reduce((sum, call) => sum + call.cacheReadInputTokens, 0)).toBe(30) + expect(calls.reduce((sum, call) => sum + call.outputTokens, 0)).toBe(55) + expect(calls.reduce((sum, call) => sum + call.reasoningTokens, 0)).toBe(5) + }) + + it('skips Gemini messages without token usage', async () => { + const calls = await parseFixture([ + { id: 'u1', timestamp: '2026-05-16T10:00:00.000Z', type: 'user', content: 'work' }, + { + id: 'info', + timestamp: '2026-05-16T10:00:05.000Z', + type: 'gemini', + content: 'tool-only notice', + model: 'gemini-3.1-pro-preview', + }, + ]) + + expect(calls).toEqual([]) + }) + + it('uses a deterministic ordinal key when Gemini message ids are missing', async () => { + const messages = [ + { id: 'u1', timestamp: '2026-05-16T10:00:00.000Z', type: 'user', content: 'work' }, + { + timestamp: '2026-05-16T10:00:05.000Z', + type: 'gemini', + content: 'first', + model: 'gemini-3.1-pro-preview', + tokens: { input: 10, output: 5 }, + }, + { + timestamp: '2026-05-16T10:00:10.000Z', + type: 'gemini', + content: 'second', + model: 'gemini-3.1-pro-preview', + tokens: { input: 12, output: 6 }, + }, + ] + + const first = await parseFixture(messages) + const second = await parseFixture(messages) + + expect(first.map(c => c.deduplicationKey)).toEqual([ + 'gemini:gemini-session-1:idx-0', + 'gemini:gemini-session-1:idx-1', + ]) + expect(second.map(c => c.deduplicationKey)).toEqual(first.map(c => c.deduplicationKey)) + }) + + it('does not poison seenKeys when a Gemini message timestamp is invalid', async () => { + const filePath = join(tmpDir, 'session-gemini.json') + await writeFile(filePath, JSON.stringify({ + sessionId: 'gemini-session-1', + startTime: '2026-05-16T10:00:00.000Z', + messages: [ + { id: 'u1', timestamp: '2026-05-16T10:00:00.000Z', type: 'user', content: 'work' }, + { + id: 'g1', + timestamp: 'not-a-date', + type: 'gemini', + content: 'first', + model: 'gemini-3.1-pro-preview', + tokens: { input: 10, output: 5 }, + }, + ], + })) + + const provider = createGeminiProvider() + const seenKeys = new Set<string>() + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser( + { path: filePath, project: 'gemini-project', provider: 'gemini' }, + seenKeys, + ).parse()) { + calls.push(call) + } + + expect(calls).toEqual([]) + expect(seenKeys.has('gemini:gemini-session-1:g1')).toBe(false) + }) +}) diff --git a/tests/providers/grok.test.ts b/tests/providers/grok.test.ts new file mode 100644 index 0000000..4fcac7a --- /dev/null +++ b/tests/providers/grok.test.ts @@ -0,0 +1,187 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { createGrokProvider } from '../../src/providers/grok.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'grok-test-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +// Mirrors the real on-disk layout: +// <sessionsDir>/<url-encoded-cwd>/<uuid>/{summary.json, signals.json, updates.jsonl} +async function writeSession(opts: { + cwdEncoded?: string + uuid?: string + cwd?: string + model?: string + turns?: Array<{ promptId: string; totals: number[] }> + toolCalls?: Array<{ title: string; rawInput: Record<string, unknown> }> + toolsUsed?: string[] +} = {}) { + const cwdEncoded = opts.cwdEncoded ?? '%2FUsers%2Ftest' + const uuid = opts.uuid ?? '019edf9c-0000-7000-8000-000000000001' + const cwd = opts.cwd ?? '/Users/test/myproject' + const model = opts.model ?? 'grok-build' + const dir = join(tmpDir, cwdEncoded, uuid) + await mkdir(dir, { recursive: true }) + + await writeFile(join(dir, 'summary.json'), JSON.stringify({ + info: { id: uuid, cwd }, + created_at: '2026-06-19T11:20:40.686261Z', + updated_at: '2026-06-19T11:31:12.282793Z', + last_active_at: '2026-06-19T11:31:12.222328Z', + num_messages: 42, + current_model_id: model, + session_summary: 'User asks about the repo', + generated_title: 'User asks about the repo', + })) + + await writeFile(join(dir, 'signals.json'), JSON.stringify({ + primaryModelId: model, + modelsUsed: [model], + toolsUsed: opts.toolsUsed ?? ['read_file', 'run_terminal_command', 'grep'], + contextTokensUsed: 40000, + contextWindowTokens: 512000, + })) + + const turns = opts.turns ?? [ + { promptId: 'p1', totals: [20000, 25000] }, + { promptId: 'p2', totals: [30000, 35000] }, + { promptId: 'p3', totals: [40000, 45000] }, + ] + const lines: string[] = [] + for (const turn of turns) { + for (const total of turn.totals) { + lines.push(JSON.stringify({ + timestamp: '2026-06-19T11:30:00.000Z', + method: 'session/update', + params: { + sessionId: uuid, + update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'hi' } }, + _meta: { totalTokens: total, promptId: turn.promptId, updateType: 'AgentMessageChunk', modelId: model }, + }, + })) + } + } + for (const tc of opts.toolCalls ?? [ + { title: 'read_file', rawInput: { target_directory: '.' } }, + { title: 'grep', rawInput: { pattern: 'x' } }, + { title: 'run_terminal_command', rawInput: { command: 'git status' } }, + { title: 'spawn_subagent', rawInput: { subagent_type: 'general-purpose', prompt: 'x' } }, + ]) { + lines.push(JSON.stringify({ + timestamp: '2026-06-19T11:30:05.000Z', + method: 'session/update', + params: { sessionId: uuid, update: { sessionUpdate: 'tool_call', toolCallId: 'c1', title: tc.title, rawInput: tc.rawInput } }, + })) + } + await writeFile(join(dir, 'updates.jsonl'), lines.join('\n') + '\n') + + return { dir, uuid } +} + +describe('grok provider - discovery', () => { + it('discovers each session dir and derives project from cwd', async () => { + await writeSession({ cwd: '/Users/test/myproject' }) + const sessions = await createGrokProvider(tmpDir).discoverSessions() + expect(sessions).toHaveLength(1) + expect(sessions[0]!.provider).toBe('grok') + expect(sessions[0]!.project).toBe('myproject') + expect(sessions[0]!.path).toMatch(/updates\.jsonl$/) + }) + + it('returns empty for a non-existent sessions dir', async () => { + const sessions = await createGrokProvider('/nope/does/not/exist').discoverSessions() + expect(sessions).toEqual([]) + }) + + it('skips directories without a summary.json', async () => { + await mkdir(join(tmpDir, '%2Ftmp', 'not-a-session'), { recursive: true }) + const sessions = await createGrokProvider(tmpDir).discoverSessions() + expect(sessions).toEqual([]) + }) +}) + +describe('grok provider - parsing', () => { + async function parse(seen = new Set<string>()) { + const provider = createGrokProvider(tmpDir) + const [source] = await provider.discoverSessions() + const calls: ParsedProviderCall[] = [] + if (!source) return calls + for await (const call of provider.createSessionParser(source, seen).parse()) { + calls.push(call) + } + return calls + } + + it('emits one estimated call per session from the totalTokens curve', async () => { + await writeSession() + const calls = await parse() + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.model).toBe('grok-build') + // input = peak context (max totalTokens across the session) + expect(call.inputTokens).toBe(45000) + // cache reads = re-sent context (sum of per-turn starts 90000 minus peak 45000) + expect(call.cacheReadInputTokens).toBe(45000) + // output = sum of per-turn growth (3 turns x 5000) + expect(call.outputTokens).toBe(15000) + expect(call.costIsEstimated).toBe(true) + expect(call.costUSD).toBeGreaterThan(0) + expect(call.tools).toEqual(['Read', 'Grep', 'Bash', 'Agent']) + expect(call.bashCommands).toContain('git') + expect(call.subagentTypes).toEqual(['general-purpose']) + expect(call.project).toBe('myproject') + expect(call.deduplicationKey).toContain('grok:') + }) + + it('skips a session with no token growth', async () => { + await writeSession({ turns: [{ promptId: 'p1', totals: [0, 0] }] }) + expect(await parse()).toHaveLength(0) + }) + + it('deduplicates across repeated parses', async () => { + await writeSession() + const seen = new Set<string>() + expect(await parse(seen)).toHaveLength(1) + expect(await parse(seen)).toHaveLength(0) + }) + + it('sums fresh input across a compaction instead of only the last peak', async () => { + await writeSession({ turns: [ + { promptId: 'p1', totals: [100000, 400000] }, + { promptId: 'p2', totals: [20000, 50000] }, + ] }) + const calls = await parse() + expect(calls).toHaveLength(1) + // 400k (segment 1 peak) + 50k (post-compaction segment), not just the 400k global peak + expect(calls[0]!.inputTokens).toBe(450000) + }) +}) + +describe('grok provider - display names', () => { + const provider = createGrokProvider('/tmp') + + it('has the right name and displayName', () => { + expect(provider.name).toBe('grok') + expect(provider.displayName).toBe('Grok Build') + }) + + it('labels grok-build', () => { + expect(provider.modelDisplayName('grok-build')).toBe('Grok Build') + }) + + it('normalizes tool names', () => { + expect(provider.toolDisplayName('run_terminal_command')).toBe('Bash') + expect(provider.toolDisplayName('mystery_tool')).toBe('mystery_tool') + }) +}) diff --git a/tests/providers/hermes.test.ts b/tests/providers/hermes.test.ts new file mode 100644 index 0000000..e475bf0 --- /dev/null +++ b/tests/providers/hermes.test.ts @@ -0,0 +1,546 @@ +import { mkdir, mkdtemp, rm } from 'fs/promises' +import { basename, dirname, join } from 'path' +import { tmpdir } from 'os' +import { createRequire } from 'node:module' + +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import { calculateCost } from '../../src/models.js' +import { createHermesProvider } from '../../src/providers/hermes.js' +import { isSqliteAvailable } from '../../src/sqlite.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' +import type { DateRange } from '../../src/types.js' + +const requireForTest = createRequire(import.meta.url) + +type TestDb = { + exec(sql: string): void + prepare(sql: string): { run(...params: unknown[]): void } + close(): void +} + +let tmpDir: string +let cacheDir: string +let originalHermesHome: string | undefined +let originalCodeburnCacheDir: string | undefined + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'hermes-provider-test-')) + cacheDir = await mkdtemp(join(tmpdir(), 'hermes-provider-cache-')) + originalHermesHome = process.env['HERMES_HOME'] + originalCodeburnCacheDir = process.env['CODEBURN_CACHE_DIR'] +}) + +afterEach(async () => { + if (originalHermesHome === undefined) delete process.env['HERMES_HOME'] + else process.env['HERMES_HOME'] = originalHermesHome + if (originalCodeburnCacheDir === undefined) delete process.env['CODEBURN_CACHE_DIR'] + else process.env['CODEBURN_CACHE_DIR'] = originalCodeburnCacheDir + await rm(tmpDir, { recursive: true, force: true }) + await rm(cacheDir, { recursive: true, force: true }) +}) + +function createHermesDb(homeDir: string): string { + const { DatabaseSync: Database } = requireForTest('node:sqlite') + const dbPath = join(homeDir, 'state.db') + const db = new Database(dbPath) + db.exec(` + CREATE TABLE sessions ( + id TEXT PRIMARY KEY, + source TEXT, + model TEXT, + cwd TEXT, + billing_provider TEXT, + billing_base_url TEXT, + billing_mode TEXT, + input_tokens INTEGER DEFAULT 0, + output_tokens INTEGER DEFAULT 0, + cache_read_tokens INTEGER DEFAULT 0, + cache_write_tokens INTEGER DEFAULT 0, + reasoning_tokens INTEGER DEFAULT 0, + estimated_cost_usd REAL, + actual_cost_usd REAL, + cost_status TEXT, + api_call_count INTEGER DEFAULT 0, + message_count INTEGER DEFAULT 0, + tool_call_count INTEGER DEFAULT 0, + started_at REAL, + ended_at REAL, + title TEXT + ) + `) + db.exec(` + CREATE TABLE messages ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + session_id TEXT NOT NULL, + role TEXT NOT NULL, + content TEXT, + tool_call_id TEXT, + tool_calls TEXT, + tool_name TEXT, + timestamp REAL NOT NULL + ) + `) + db.close() + return dbPath +} + +function createLegacyHermesDb(homeDir: string): string { + const { DatabaseSync: Database } = requireForTest('node:sqlite') + const dbPath = join(homeDir, 'state.db') + const db = new Database(dbPath) + db.exec(` + CREATE TABLE sessions ( + id TEXT PRIMARY KEY, + model TEXT, + input_tokens INTEGER DEFAULT 0, + output_tokens INTEGER DEFAULT 0, + started_at REAL + ) + `) + db.exec(` + CREATE TABLE messages ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + session_id TEXT NOT NULL, + role TEXT NOT NULL, + content TEXT, + tool_calls TEXT, + timestamp REAL NOT NULL + ) + `) + db.close() + return dbPath +} + +async function createProfileHermesDb(hermesHome: string, profile: string): Promise<string> { + const profileDir = join(hermesHome, 'profiles', profile) + await mkdir(profileDir, { recursive: true }) + return createHermesDb(profileDir) +} + +function insertSession(db: TestDb, values: { + id: string + source?: string + model?: string + cwd?: string | null + billingProvider?: string + inputTokens: number + outputTokens: number + cacheReadTokens: number + cacheWriteTokens: number + reasoningTokens: number + estimatedCost?: number | null + actualCost?: number | null + apiCalls?: number + toolCalls?: number + startedAt: number + title?: string +}): void { + db.prepare( + `INSERT INTO sessions ( + id, source, model, cwd, billing_provider, input_tokens, output_tokens, + cache_read_tokens, cache_write_tokens, reasoning_tokens, estimated_cost_usd, + actual_cost_usd, api_call_count, tool_call_count, started_at, title + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, + ).run( + values.id, + values.source ?? 'cli', + values.model ?? 'gpt-5.5', + values.cwd ?? null, + values.billingProvider ?? 'openai-codex', + values.inputTokens, + values.outputTokens, + values.cacheReadTokens, + values.cacheWriteTokens, + values.reasoningTokens, + values.estimatedCost ?? null, + values.actualCost ?? null, + values.apiCalls ?? 1, + values.toolCalls ?? 0, + values.startedAt, + values.title ?? values.id, + ) +} + +function withTestDb(dbPath: string, fn: (db: TestDb) => void): void { + const { DatabaseSync: Database } = requireForTest('node:sqlite') + const db = new Database(dbPath) + try { + fn(db) + } finally { + db.close() + } +} + +function dayRange(): DateRange { + return { + start: new Date('2026-05-23T00:00:00.000Z'), + end: new Date('2026-05-23T23:59:59.999Z'), + } +} + +async function loadParserWithHermesHome(hermesHome: string, codeburnCacheDir: string) { + process.env['HERMES_HOME'] = hermesHome + process.env['CODEBURN_CACHE_DIR'] = codeburnCacheDir + vi.resetModules() + const parser = await import('../../src/parser.js') + return parser +} + +async function collectCalls(hermesHome: string, sourcePath: string): Promise<ParsedProviderCall[]> { + const provider = createHermesProvider(hermesHome) + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser({ path: sourcePath, project: 'hermes', provider: 'hermes' }, new Set()).parse()) { + calls.push(call) + } + return calls +} + +const skipUnlessSqlite = isSqliteAvailable() ? describe : describe.skip + +skipUnlessSqlite('hermes provider', () => { + it('discovers state.db sessions with token usage', async () => { + const dbPath = createHermesDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, { + id: 'session-1', + inputTokens: 100, + outputTokens: 20, + cacheReadTokens: 50, + cacheWriteTokens: 0, + reasoningTokens: 5, + startedAt: 1779549200, + title: 'Test Project', + }) + db.prepare( + `INSERT INTO sessions (id, source, model, input_tokens, output_tokens, started_at, title) + VALUES (?, ?, ?, ?, ?, ?, ?)`, + ).run('empty', 'cli', 'gpt-5.5', 0, 0, 1779549300, 'Empty') + }) + + const provider = createHermesProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(1) + expect(sessions[0]!.provider).toBe('hermes') + expect(sessions[0]!.path).toBe(`${dbPath}#hermes-session=session-1`) + expect(sessions[0]!.project).toBe('default') + }) + + it('parses session-level token usage and tool calls from messages', async () => { + const dbPath = createHermesDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, { + id: 'session-1', + source: 'tui', + inputTokens: 1000, + outputTokens: 200, + cacheReadTokens: 300, + cacheWriteTokens: 40, + reasoningTokens: 25, + estimatedCost: 0.12, + apiCalls: 3, + toolCalls: 2, + startedAt: 1779549200, + title: 'Provider Work', + }) + db.prepare('INSERT INTO messages (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)') + .run('session-1', 'user', 'Add Hermes support', 1779549201) + db.prepare('INSERT INTO messages (session_id, role, content, tool_calls, timestamp) VALUES (?, ?, ?, ?, ?)') + .run( + 'session-1', + 'assistant', + '', + JSON.stringify([ + { function: { name: 'read_file', arguments: JSON.stringify({ path: '/tmp/file.ts' }) } }, + { function: { name: 'terminal', arguments: JSON.stringify({ command: 'npm test' }) } }, + ]), + 1779549202, + ) + }) + + const calls = await collectCalls(tmpDir, `${dbPath}#hermes-session=session-1`) + expect(calls).toHaveLength(1) + expect(calls[0]!).toMatchObject({ + provider: 'hermes', + model: 'gpt-5.5', + inputTokens: 1000, + outputTokens: 200, + cacheReadInputTokens: 300, + cacheCreationInputTokens: 40, + cachedInputTokens: 300, + reasoningTokens: 25, + costUSD: 0.12, + userMessage: 'Add Hermes support', + sessionId: 'session-1', + deduplicationKey: 'hermes:default:session-1', + }) + expect(calls[0]!.tools).toEqual(['Read', 'Bash']) + expect(calls[0]!.bashCommands).toEqual(['npm test']) + expect(calls[0]!.toolSequence).toEqual([ + [{ tool: 'Read', file: '/tmp/file.ts' }, { tool: 'Bash', command: 'npm test' }], + ]) + }) + + + it('maps composio MCP tools before generic MCP prefixes', () => { + const provider = createHermesProvider(tmpDir) + expect(provider.toolDisplayName('mcp_composio_GMAIL_SEND_EMAIL')).toBe('MCP') + expect(provider.toolDisplayName('mcp__github__create_issue')).toBe('mcp__github__create_issue') + }) + + it('falls back to calculateCost when no actual or estimated cost is recorded', async () => { + const dbPath = createHermesDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, { + id: 'no-cost-session', + model: 'claude-sonnet-4-20250514', + inputTokens: 1000, + outputTokens: 200, + cacheReadTokens: 0, + cacheWriteTokens: 0, + reasoningTokens: 50, + estimatedCost: null, + actualCost: null, + startedAt: 1779549200, + }) + db.prepare('INSERT INTO messages (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)') + .run('no-cost-session', 'user', 'Test calculateCost fallback', 1779549201) + }) + + const calls = await collectCalls(tmpDir, `${dbPath}#hermes-session=no-cost-session`) + expect(calls).toHaveLength(1) + expect(calls[0]!.costUSD).toBe(calculateCost('claude-sonnet-4-20250514', 1000, 250, 0, 0, 0)) + expect(calls[0]!.reasoningTokens).toBe(50) + }) + + it('does not split multibyte characters when truncating the first user message', async () => { + const dbPath = createHermesDb(tmpDir) + const message = `${'a'.repeat(499)}😀truncated tail` + withTestDb(dbPath, (db) => { + insertSession(db, { + id: 'emoji-session', + inputTokens: 10, + outputTokens: 5, + cacheReadTokens: 0, + cacheWriteTokens: 0, + reasoningTokens: 0, + estimatedCost: 0.01, + startedAt: 1779549200, + }) + db.prepare('INSERT INTO messages (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)') + .run('emoji-session', 'user', message, 1779549201) + }) + + const calls = await collectCalls(tmpDir, `${dbPath}#hermes-session=emoji-session`) + expect(calls).toHaveLength(1) + expect(calls[0]!.userMessage).toBe(`${'a'.repeat(499)}😀`) + }) + + it('parses legacy databases that predate optional accounting columns', async () => { + const dbPath = createLegacyHermesDb(tmpDir) + withTestDb(dbPath, (db) => { + db.prepare( + `INSERT INTO sessions (id, model, input_tokens, output_tokens, started_at) + VALUES (?, ?, ?, ?, ?)`, + ).run('legacy-session', 'gpt-5.5', 12, 34, 1779549200) + db.prepare('INSERT INTO messages (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)') + .run('legacy-session', 'user', 'Legacy Hermes DB', 1779549201) + }) + + const provider = createHermesProvider(tmpDir) + const discovered = await provider.discoverSessions() + expect(discovered.map(s => s.path)).toEqual([`${dbPath}#hermes-session=legacy-session`]) + + const calls = await collectCalls(tmpDir, `${dbPath}#hermes-session=legacy-session`) + expect(calls).toHaveLength(1) + expect(calls[0]).toMatchObject({ + inputTokens: 12, + outputTokens: 34, + cacheReadInputTokens: 0, + cacheCreationInputTokens: 0, + reasoningTokens: 0, + userMessage: 'Legacy Hermes DB', + }) + }) + + it('discovers root and profile databases and preserves Hermes DB accounting through parser aggregation', async () => { + const rootDbPath = createHermesDb(tmpDir) + const profileDbPath = await createProfileHermesDb(tmpDir, 'coder') + + withTestDb(rootDbPath, (db) => { + insertSession(db, { + id: 'root-session', + model: 'gpt-5.5', + inputTokens: 100, + outputTokens: 20, + cacheReadTokens: 30, + cacheWriteTokens: 40, + reasoningTokens: 5, + estimatedCost: 0.25, + actualCost: 0.30, + startedAt: 1779494400, + title: 'Root session', + }) + db.prepare('INSERT INTO messages (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)') + .run('root-session', 'user', 'Current working directory: /tmp/root-project\nImplement root support', 1779494401) + }) + withTestDb(profileDbPath, (db) => { + insertSession(db, { + id: 'profile-session', + model: 'gpt-5.5', + inputTokens: 200, + outputTokens: 70, + cacheReadTokens: 11, + cacheWriteTokens: 13, + reasoningTokens: 17, + estimatedCost: 0.42, + actualCost: null, + startedAt: 1779501600, + title: 'Profile session', + }) + db.prepare('INSERT INTO messages (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)') + .run('profile-session', 'user', 'Current working directory: /tmp/profile-project\nImplement profile support', 1779501601) + }) + + const provider = createHermesProvider(tmpDir) + const discovered = await provider.discoverSessions() + expect(discovered.map(s => s.path).sort()).toEqual([ + `${profileDbPath}#hermes-session=profile-session`, + `${rootDbPath}#hermes-session=root-session`, + ].sort()) + expect(discovered.map(s => s.project).sort()).toEqual(['coder', 'default']) + + const rootCalls = await collectCalls(tmpDir, `${rootDbPath}#hermes-session=root-session`) + const profileCalls = await collectCalls(tmpDir, `${profileDbPath}#hermes-session=profile-session`) + expect(rootCalls[0]).toMatchObject({ inputTokens: 100, outputTokens: 20, cacheReadInputTokens: 30, cacheCreationInputTokens: 40, reasoningTokens: 5, costUSD: 0.30 }) + expect(profileCalls[0]).toMatchObject({ inputTokens: 200, outputTokens: 70, cacheReadInputTokens: 11, cacheCreationInputTokens: 13, reasoningTokens: 17, costUSD: 0.42 }) + + const { clearSessionCache, parseAllSessions } = await loadParserWithHermesHome(tmpDir, cacheDir) + clearSessionCache() + const projects = await parseAllSessions(dayRange(), 'hermes') + const sessions = projects.flatMap(project => project.sessions) + expect(sessions).toHaveLength(2) + expect(sessions.reduce((sum, session) => sum + session.totalInputTokens, 0)).toBe(300) + expect(sessions.reduce((sum, session) => sum + session.totalOutputTokens, 0)).toBe(90) + expect(sessions.reduce((sum, session) => sum + session.totalReasoningTokens, 0)).toBe(22) + expect(sessions.reduce((sum, session) => sum + session.totalCacheReadTokens, 0)).toBe(41) + expect(sessions.reduce((sum, session) => sum + session.totalCacheWriteTokens, 0)).toBe(53) + expect(sessions.reduce((sum, session) => sum + session.totalCostUSD, 0)).toBeCloseTo(0.72) + expect(projects.map(project => project.project).sort()).toEqual(['tmp-profile-project', 'tmp-root-project']) + + const modelTokens = sessions.flatMap(session => Object.values(session.modelBreakdown).map(model => model.tokens)) + expect(modelTokens.reduce((sum, tokens) => sum + tokens.outputTokens, 0)).toBe(90) + expect(modelTokens.reduce((sum, tokens) => sum + tokens.reasoningTokens, 0)).toBe(22) + }) + + it('treats sibling profile-like directories as default sessions', async () => { + const profileLikeDir = join(dirname(tmpDir), `${basename(tmpDir)}-profiles_backup`, 'coder') + await mkdir(profileLikeDir, { recursive: true }) + const dbPath = createHermesDb(profileLikeDir) + + withTestDb(dbPath, (db) => { + insertSession(db, { + id: 'sibling-session', + inputTokens: 10, + outputTokens: 5, + cacheReadTokens: 0, + cacheWriteTokens: 0, + reasoningTokens: 0, + startedAt: 1779549200, + }) + db.prepare('INSERT INTO messages (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)') + .run('sibling-session', 'user', 'Sibling profile-like directory', 1779549201) + }) + + const calls = await collectCalls(tmpDir, `${dbPath}#hermes-session=sibling-session`) + expect(calls[0]).toMatchObject({ + deduplicationKey: 'hermes:default:sibling-session', + project: 'default', + }) + }) + + it('infers projects from Windows current working directory messages', async () => { + const dbPath = createHermesDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, { + id: 'windows-cwd-session', + inputTokens: 10, + outputTokens: 5, + cacheReadTokens: 0, + cacheWriteTokens: 0, + reasoningTokens: 0, + startedAt: 1779549200, + }) + db.prepare('INSERT INTO messages (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)') + .run('windows-cwd-session', 'user', 'Current working directory: C:\\AI_LAB\\OPENCLAW\nAdd Windows path support', 1779549201) + }) + + const calls = await collectCalls(tmpDir, `${dbPath}#hermes-session=windows-cwd-session`) + expect(calls[0]).toMatchObject({ + project: 'C--AI_LAB-OPENCLAW', + projectPath: 'C:\\AI_LAB\\OPENCLAW', + }) + }) + + it('groups by the sessions.cwd column when present, ahead of message scraping', async () => { + const dbPath = createHermesDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, { + id: 'cwd-session', + cwd: '/Users/me/projects/codeburn', + inputTokens: 30, + outputTokens: 10, + cacheReadTokens: 0, + cacheWriteTokens: 0, + reasoningTokens: 0, + startedAt: 1779549200, + }) + db.prepare('INSERT INTO messages (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)') + .run('cwd-session', 'user', 'Current working directory: /tmp/decoy\nbuild it', 1779549201) + }) + + const calls = await collectCalls(tmpDir, `${dbPath}#hermes-session=cwd-session`) + expect(calls[0]).toMatchObject({ + project: 'Users-me-projects-codeburn', + projectPath: '/Users/me/projects/codeburn', + }) + }) + + it('flags estimated cost only when Hermes recorded none', async () => { + const dbPath = createHermesDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, { + id: 'no-cost', + inputTokens: 100, outputTokens: 20, cacheReadTokens: 0, cacheWriteTokens: 0, reasoningTokens: 0, + startedAt: 1779549200, + }) + insertSession(db, { + id: 'recorded-cost', + actualCost: 1.23, + inputTokens: 100, outputTokens: 20, cacheReadTokens: 0, cacheWriteTokens: 0, reasoningTokens: 0, + startedAt: 1779549300, + }) + }) + + const noCost = await collectCalls(tmpDir, `${dbPath}#hermes-session=no-cost`) + expect(noCost[0]!.costIsEstimated).toBe(true) + + const recorded = await collectCalls(tmpDir, `${dbPath}#hermes-session=recorded-cost`) + expect(recorded[0]).toMatchObject({ costUSD: 1.23, costIsEstimated: false }) + }) + + it('counts tool-result messages by their tool_name', async () => { + const dbPath = createHermesDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, { + id: 'tool-result-session', + inputTokens: 10, outputTokens: 5, cacheReadTokens: 0, cacheWriteTokens: 0, reasoningTokens: 0, + startedAt: 1779549200, + }) + db.prepare('INSERT INTO messages (session_id, role, content, tool_name, timestamp) VALUES (?, ?, ?, ?, ?)') + .run('tool-result-session', 'tool', null, 'read_file', 1779549201) + }) + + const calls = await collectCalls(tmpDir, `${dbPath}#hermes-session=tool-result-session`) + expect(calls[0]!.tools).toContain('Read') + }) +}) diff --git a/tests/providers/ibm-bob.test.ts b/tests/providers/ibm-bob.test.ts new file mode 100644 index 0000000..d61f92e --- /dev/null +++ b/tests/providers/ibm-bob.test.ts @@ -0,0 +1,164 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { ibmBob, createIBMBobProvider } from '../../src/providers/ibm-bob.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +function makeUiMessages(opts: { + tokensIn?: number + tokensOut?: number + cacheReads?: number + cacheWrites?: number + cost?: number + userMessage?: string + ts?: number +}): string { + const messages: unknown[] = [] + + if (opts.userMessage) { + messages.push({ type: 'say', say: 'user_feedback', text: opts.userMessage, ts: 1_700_000_000_000 }) + } + + const apiData: Record<string, unknown> = { + tokensIn: opts.tokensIn ?? 100, + tokensOut: opts.tokensOut ?? 50, + cacheReads: opts.cacheReads ?? 0, + cacheWrites: opts.cacheWrites ?? 0, + } + if (opts.cost !== undefined) apiData.cost = opts.cost + + messages.push({ + type: 'say', + say: 'api_req_started', + text: JSON.stringify(apiData), + ts: opts.ts ?? 1_700_000_001_000, + }) + + return JSON.stringify(messages) +} + +function makeApiHistory(model?: string): string { + const modelTag = model ? `<model>${model}</model>` : '' + return JSON.stringify([ + { role: 'user', content: [{ type: 'text', text: `hello\n<environment_details>\n${modelTag}\n</environment_details>` }] }, + { role: 'assistant', content: [{ type: 'text', text: 'response' }] }, + ]) +} + +describe('ibm-bob provider - discovery and parsing', () => { + beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'ibm-bob-test-')) + }) + + afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) + }) + + it('discovers IBM Bob task directories with ui_messages.json', async () => { + const task1 = join(tmpDir, 'tasks', 'task-a') + const task2 = join(tmpDir, 'tasks', 'task-b') + await mkdir(task1, { recursive: true }) + await mkdir(task2, { recursive: true }) + await writeFile(join(task1, 'ui_messages.json'), '[]') + await writeFile(join(task2, 'ui_messages.json'), '[]') + + const provider = createIBMBobProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(2) + expect(sessions.every(s => s.provider === 'ibm-bob')).toBe(true) + expect(sessions.every(s => s.project === 'IBM Bob')).toBe(true) + }) + + it('skips tasks without ui_messages.json', async () => { + const task = join(tmpDir, 'tasks', 'task-no-ui') + await mkdir(task, { recursive: true }) + await writeFile(join(task, 'api_conversation_history.json'), '[]') + + const provider = createIBMBobProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(0) + }) + + it('parses token usage and provider cost from Bob ui messages', async () => { + const taskDir = join(tmpDir, 'tasks', 'task-001') + await mkdir(taskDir, { recursive: true }) + await writeFile(join(taskDir, 'ui_messages.json'), makeUiMessages({ + tokensIn: 250, + tokensOut: 125, + cacheReads: 60, + cacheWrites: 30, + cost: 0.08, + userMessage: 'modernize this class', + })) + await writeFile(join(taskDir, 'api_conversation_history.json'), makeApiHistory('anthropic/claude-sonnet-4-6')) + + const source = { path: taskDir, project: 'IBM Bob', provider: 'ibm-bob' } + const calls: ParsedProviderCall[] = [] + for await (const call of ibmBob.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!).toMatchObject({ + provider: 'ibm-bob', + model: 'claude-sonnet-4-6', + inputTokens: 250, + outputTokens: 125, + cacheReadInputTokens: 60, + cacheCreationInputTokens: 30, + costUSD: 0.08, + userMessage: 'modernize this class', + sessionId: 'task-001', + }) + expect(calls[0]!.deduplicationKey).toBe('ibm-bob:task-001:0') + }) + + it('falls back to IBM Bob auto model when history has no model tag', async () => { + const taskDir = join(tmpDir, 'tasks', 'task-002') + await mkdir(taskDir, { recursive: true }) + await writeFile(join(taskDir, 'ui_messages.json'), makeUiMessages({ tokensIn: 100, tokensOut: 50 })) + await writeFile(join(taskDir, 'api_conversation_history.json'), makeApiHistory()) + + const source = { path: taskDir, project: 'IBM Bob', provider: 'ibm-bob' } + const calls: ParsedProviderCall[] = [] + for await (const call of ibmBob.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe('ibm-bob-auto') + expect(calls[0]!.costUSD).toBeGreaterThan(0) + }) + + it('deduplicates across parser runs', async () => { + const taskDir = join(tmpDir, 'tasks', 'task-003') + await mkdir(taskDir, { recursive: true }) + await writeFile(join(taskDir, 'ui_messages.json'), makeUiMessages({ tokensIn: 100, tokensOut: 50 })) + + const source = { path: taskDir, project: 'IBM Bob', provider: 'ibm-bob' } + const seenKeys = new Set<string>() + + const calls1: ParsedProviderCall[] = [] + for await (const call of ibmBob.createSessionParser(source, seenKeys).parse()) calls1.push(call) + + const calls2: ParsedProviderCall[] = [] + for await (const call of ibmBob.createSessionParser(source, seenKeys).parse()) calls2.push(call) + + expect(calls1).toHaveLength(1) + expect(calls2).toHaveLength(0) + }) +}) + +describe('ibm-bob provider - metadata', () => { + it('has correct name and displayName', () => { + expect(ibmBob.name).toBe('ibm-bob') + expect(ibmBob.displayName).toBe('IBM Bob') + }) + + it('uses shared short model display names', () => { + expect(ibmBob.modelDisplayName('ibm-bob-auto')).toBe('IBM Bob (auto)') + expect(ibmBob.modelDisplayName('claude-sonnet-4-6')).toBe('Sonnet 4.6') + }) +}) diff --git a/tests/providers/kilo-code.test.ts b/tests/providers/kilo-code.test.ts new file mode 100644 index 0000000..136afc9 --- /dev/null +++ b/tests/providers/kilo-code.test.ts @@ -0,0 +1,62 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { kiloCode, createKiloCodeProvider } from '../../src/providers/kilo-code.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +describe('kilo-code provider - discovery path differentiation', () => { + beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'kilo-code-test-')) + }) + + afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) + }) + + it('discovers tasks using kilo-code extension path', async () => { + const task = join(tmpDir, 'tasks', 'task-kilo-1') + await mkdir(task, { recursive: true }) + await writeFile(join(task, 'ui_messages.json'), JSON.stringify([ + { type: 'say', say: 'api_req_started', text: JSON.stringify({ tokensIn: 100, tokensOut: 50 }), ts: 1700000000000 }, + ])) + + const provider = createKiloCodeProvider(tmpDir) + const sessions = await provider.discoverSessions() + const fromOverride = sessions.filter(s => s.path.startsWith(tmpDir)) + + expect(fromOverride).toHaveLength(1) + expect(fromOverride[0]!.provider).toBe('kilo-code') + }) + + it('parses with kilo-code provider name in dedup key', async () => { + const task = join(tmpDir, 'tasks', 'task-kilo-2') + await mkdir(task, { recursive: true }) + await writeFile(join(task, 'ui_messages.json'), JSON.stringify([ + { type: 'say', say: 'api_req_started', text: JSON.stringify({ tokensIn: 200, tokensOut: 100 }), ts: 1700000000000 }, + ])) + + const source = { path: task, project: 'task-kilo-2', provider: 'kilo-code' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiloCode.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.provider).toBe('kilo-code') + expect(calls[0]!.deduplicationKey).toMatch(/^kilo-code:/) + }) +}) + +describe('kilo-code provider - metadata', () => { + it('has correct name and displayName', () => { + expect(kiloCode.name).toBe('kilo-code') + expect(kiloCode.displayName).toBe('KiloCode') + }) + + it('uses different extension ID than roo-code', () => { + expect(kiloCode.name).toBe('kilo-code') + expect(kiloCode.name).not.toBe('roo-code') + }) +}) diff --git a/tests/providers/kimi.test.ts b/tests/providers/kimi.test.ts new file mode 100644 index 0000000..486a03e --- /dev/null +++ b/tests/providers/kimi.test.ts @@ -0,0 +1,192 @@ +import { createHash } from 'crypto' +import { afterEach, beforeEach, describe, expect, it } from 'vitest' +import { mkdir, mkdtemp, rm, writeFile } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { createKimiProvider } from '../../src/providers/kimi.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'kimi-test-')) +}) + +afterEach(async () => { + delete process.env.KIMI_MODEL_NAME + await rm(tmpDir, { recursive: true, force: true }) +}) + +function md5(value: string): string { + return createHash('md5').update(value, 'utf-8').digest('hex') +} + +function record(timestamp: number, type: string, payload: Record<string, unknown>): string { + return JSON.stringify({ + timestamp, + message: { type, payload }, + }) +} + +async function writeSession(workDir: string, sessionId: string, lines: string[]): Promise<string> { + const hash = md5(workDir) + const sessionDir = join(tmpDir, 'sessions', hash, sessionId) + await mkdir(sessionDir, { recursive: true }) + const wirePath = join(sessionDir, 'wire.jsonl') + await writeFile(wirePath, [ + JSON.stringify({ type: 'metadata', protocol_version: '2' }), + ...lines, + ].join('\n') + '\n') + return wirePath +} + +async function collect(provider: ReturnType<typeof createKimiProvider>, path: string, seen = new Set<string>()): Promise<ParsedProviderCall[]> { + const parser = provider.createSessionParser({ path, project: 'app', provider: 'kimi' }, seen) + const calls: ParsedProviderCall[] = [] + for await (const call of parser.parse()) calls.push(call) + return calls +} + +describe('Kimi provider', () => { + it('discovers session and subagent wire logs under KIMI_SHARE_DIR layout', async () => { + const workDir = '/Users/test/work/app' + const hash = md5(workDir) + await writeFile(join(tmpDir, 'kimi.json'), JSON.stringify({ + work_dirs: [{ path: workDir, kaos: 'local', last_session_id: 'sess-1' }], + })) + + const sessionDir = join(tmpDir, 'sessions', hash, 'sess-1') + const subagentDir = join(sessionDir, 'subagents', 'agent-1') + await mkdir(subagentDir, { recursive: true }) + await writeFile(join(sessionDir, 'wire.jsonl'), '\n') + await writeFile(join(subagentDir, 'wire.jsonl'), '\n') + + const sources = await createKimiProvider(tmpDir).discoverSessions() + + expect(sources).toHaveLength(2) + expect(sources.map(s => s.project)).toEqual(['app', 'app']) + expect(sources.map(s => s.provider)).toEqual(['kimi', 'kimi']) + expect(sources.map(s => s.path).sort()).toEqual([ + join(sessionDir, 'subagents', 'agent-1', 'wire.jsonl'), + join(sessionDir, 'wire.jsonl'), + ].sort()) + }) + + it('parses Kimi wire StatusUpdate usage, tools, bash commands, and configured model', async () => { + await writeFile(join(tmpDir, 'config.toml'), [ + 'default_model = "kimi-code/k2"', + '', + '[models."kimi-code/k2"]', + 'model = "kimi-k2-thinking-turbo"', + ].join('\n')) + + const wirePath = await writeSession('/Users/test/work/app', 'sess-1', [ + record(1776162400, 'TurnBegin', { user_input: 'add status endpoint' }), + record(1776162401, 'ToolCall', { + type: 'function', + id: 'call-shell', + function: { name: 'Shell', arguments: JSON.stringify({ command: 'git status && npm test' }) }, + }), + record(1776162402, 'ToolCall', { + type: 'function', + id: 'call-read', + function: { name: 'ReadFile', arguments: JSON.stringify({ path: 'src/index.ts' }) }, + }), + record(1776162403, 'StatusUpdate', { + message_id: 'msg-1', + token_usage: { + input_other: 100, + input_cache_read: 25, + input_cache_creation: 10, + output: 40, + }, + }), + ]) + + const calls = await collect(createKimiProvider(tmpDir), wirePath) + + expect(calls).toHaveLength(1) + expect(calls[0]).toMatchObject({ + provider: 'kimi', + model: 'kimi-k2-thinking-turbo', + inputTokens: 100, + outputTokens: 40, + cacheReadInputTokens: 25, + cacheCreationInputTokens: 10, + cachedInputTokens: 25, + tools: ['Bash', 'Read'], + bashCommands: ['git', 'npm'], + timestamp: '2026-04-14T10:26:43.000Z', + deduplicationKey: 'kimi:sess-1:msg-1', + userMessage: 'add status endpoint', + sessionId: 'sess-1', + }) + expect(calls[0]!.costUSD).toBeGreaterThan(0) + }) + + it('uses content parts, model payload overrides, and message-id deduplication', async () => { + process.env.KIMI_MODEL_NAME = 'kimi-k2-thinking' + const wirePath = await writeSession('/Users/test/work/app', 'sess-2', [ + record(1776023300, 'TurnBegin', { + user_input: [ + { type: 'text', text: 'refactor parser' }, + { type: 'image_url', image_url: { url: 'file://diagram.png' } }, + { type: 'text', text: 'carefully' }, + ], + }), + record(1776023301, 'ToolCallRequest', { + id: 'call-write', + name: 'WriteFile', + arguments: JSON.stringify({ path: 'src/parser.ts', content: 'x' }), + }), + record(1776023302, 'StatusUpdate', { + message_id: 'msg-2', + model_name: 'kimi-k2.6', + token_usage: { input_other: 5, output: 7 }, + }), + record(1776023303, 'StatusUpdate', { + message_id: 'msg-2', + model_name: 'kimi-k2.6', + token_usage: { input_other: 5, output: 7 }, + }), + ]) + + const calls = await collect(createKimiProvider(tmpDir), wirePath) + + expect(calls).toHaveLength(1) + expect(calls[0]).toMatchObject({ + model: 'kimi-k2.6', + userMessage: 'refactor parser carefully', + tools: ['Write'], + deduplicationKey: 'kimi:sess-2:msg-2', + }) + }) + + it('skips non-usage updates and supports legacy input total fields defensively', async () => { + const wirePath = await writeSession('/Users/test/work/app', 'sess-3', [ + record(1776023400, 'TurnBegin', { user_input: 'summarize' }), + record(1776023401, 'StatusUpdate', { context_usage: 0.5 }), + record(1776023402, 'StatusUpdate', { + message_id: 'msg-3', + token_usage: { + input: 120, + input_cache_read: 30, + input_cache_creation: 10, + output_tokens: 20, + }, + }), + ]) + + const calls = await collect(createKimiProvider(tmpDir), wirePath) + + expect(calls).toHaveLength(1) + expect(calls[0]).toMatchObject({ + inputTokens: 80, + cacheReadInputTokens: 30, + cacheCreationInputTokens: 10, + outputTokens: 20, + model: 'kimi-auto', + }) + }) +}) diff --git a/tests/providers/kiro.test.ts b/tests/providers/kiro.test.ts new file mode 100644 index 0000000..5928670 --- /dev/null +++ b/tests/providers/kiro.test.ts @@ -0,0 +1,948 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { kiro, createKiroProvider } from '../../src/providers/kiro.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +function makeChatFile(opts: { + executionId?: string + modelId?: string + workflowId?: string + startTime?: number + endTime?: number + userPrompt?: string + botResponses?: string[] +}) { + const chat = [ + { role: 'human', content: '<identity>\nYou are Kiro.\n</identity>' }, + { role: 'bot', content: '' }, + { role: 'tool', content: 'workspace tree...' }, + { role: 'bot', content: 'I will follow these instructions.' }, + ] + + if (opts.userPrompt) { + chat.push({ role: 'human', content: opts.userPrompt }) + } + + for (const resp of opts.botResponses ?? ['Done.']) { + chat.push({ role: 'bot', content: resp }) + } + + return JSON.stringify({ + executionId: opts.executionId ?? 'exec-001', + actionId: 'act', + context: [], + validations: {}, + chat, + metadata: { + modelId: opts.modelId ?? 'claude-haiku-4-5', + modelProvider: 'qdev', + workflow: 'act', + workflowId: opts.workflowId ?? 'wf-001', + startTime: opts.startTime ?? 1777333000000, + endTime: opts.endTime ?? 1777333010000, + }, + }) +} + +function makeModernExecutionFile(opts: { + executionId?: string + sessionId?: string + modelId?: string + startTime?: number | string + userPrompt?: string + assistantResponse?: string +}) { + const startTime = opts.startTime ?? 1777333000000 + return JSON.stringify({ + executionId: opts.executionId ?? 'exec-modern-001', + sessionId: opts.sessionId ?? 'session-modern-001', + workflowType: 'chat-agent', + status: 'succeed', + startTime, + endTime: typeof startTime === 'number' ? startTime + 10000 : 1777333010000, + modelId: opts.modelId ?? 'claude-sonnet-4.5', + messages: [ + { role: 'user', content: opts.userPrompt ?? 'explain the new kiro storage layout' }, + { + role: 'assistant', + content: opts.assistantResponse ?? 'Done. <tool_use><name>runCommand</name></tool_use>', + toolCalls: [{ name: 'readFile' }], + }, + ], + }) +} + +describe('kiro provider - chat file parsing', () => { + beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'kiro-test-')) + }) + + afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) + }) + + it('parses a basic chat file', async () => { + const wsHash = 'a'.repeat(32) + const wsDir = join(tmpDir, wsHash) + await mkdir(wsDir, { recursive: true }) + const chatPath = join(wsDir, 'abc123.chat') + await writeFile(chatPath, makeChatFile({ + modelId: 'claude-haiku-4-5', + userPrompt: 'explain the code', + botResponses: ['Here is an explanation of the code structure.'], + })) + + const source = { path: chatPath, project: 'myproject', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.provider).toBe('kiro') + expect(call.model).toBe('claude-haiku-4-5') + expect(call.outputTokens).toBeGreaterThan(0) + expect(call.userMessage).toBe('explain the code') + expect(call.bashCommands).toEqual([]) + expect(call.costUSD).toBeGreaterThan(0) + }) + + it('stores kiro-auto when model is auto', async () => { + const wsHash = 'b'.repeat(32) + const wsDir = join(tmpDir, wsHash) + await mkdir(wsDir, { recursive: true }) + const chatPath = join(wsDir, 'abc.chat') + await writeFile(chatPath, makeChatFile({ + modelId: 'auto', + botResponses: ['some output'], + })) + + const source = { path: chatPath, project: 'test', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe('kiro-auto') + expect(calls[0]!.costUSD).toBeGreaterThan(0) + }) + + it('skips chat files with no bot output', async () => { + const wsHash = 'c'.repeat(32) + const wsDir = join(tmpDir, wsHash) + await mkdir(wsDir, { recursive: true }) + const chatPath = join(wsDir, 'empty.chat') + await writeFile(chatPath, JSON.stringify({ + executionId: 'exec-empty', + actionId: 'act', + context: [], + validations: {}, + chat: [ + { role: 'human', content: '<identity>\nYou are Kiro.\n</identity>' }, + { role: 'bot', content: '' }, + { role: 'human', content: 'do something' }, + { role: 'bot', content: '' }, + ], + metadata: { + modelId: 'claude-haiku-4-5', + modelProvider: 'qdev', + workflow: 'act', + workflowId: 'wf-empty', + startTime: 1777333000000, + endTime: 1777333010000, + }, + })) + + const source = { path: chatPath, project: 'test', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(0) + }) + + it('deduplicates across parser runs', async () => { + const wsHash = 'd'.repeat(32) + const wsDir = join(tmpDir, wsHash) + await mkdir(wsDir, { recursive: true }) + const chatPath = join(wsDir, 'dup.chat') + await writeFile(chatPath, makeChatFile({ botResponses: ['hello'] })) + + const source = { path: chatPath, project: 'test', provider: 'kiro' } + const seenKeys = new Set<string>() + + const calls1: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, seenKeys).parse()) calls1.push(call) + + const calls2: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, seenKeys).parse()) calls2.push(call) + + expect(calls1).toHaveLength(1) + expect(calls2).toHaveLength(0) + }) + + it('returns empty for missing file', async () => { + const source = { path: '/nonexistent/test.chat', project: 'test', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + expect(calls).toHaveLength(0) + }) + + it('returns empty for invalid JSON', async () => { + const wsHash = 'e'.repeat(32) + const wsDir = join(tmpDir, wsHash) + await mkdir(wsDir, { recursive: true }) + const chatPath = join(wsDir, 'bad.chat') + await writeFile(chatPath, 'not json at all') + + const source = { path: chatPath, project: 'test', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + expect(calls).toHaveLength(0) + }) + + it('estimates tokens from text length', async () => { + const wsHash = 'f'.repeat(32) + const wsDir = join(tmpDir, wsHash) + await mkdir(wsDir, { recursive: true }) + const chatPath = join(wsDir, 'tokens.chat') + const longResponse = 'x'.repeat(400) + await writeFile(chatPath, makeChatFile({ botResponses: [longResponse] })) + + const source = { path: chatPath, project: 'test', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.outputTokens).toBe(109) + }) + + it('normalizes dot-versioned model IDs to dashes', async () => { + const wsHash = 'h'.repeat(32) + const wsDir = join(tmpDir, wsHash) + await mkdir(wsDir, { recursive: true }) + const chatPath = join(wsDir, 'dot.chat') + await writeFile(chatPath, makeChatFile({ + modelId: 'claude-haiku-4.5', + botResponses: ['response text here'], + })) + + const source = { path: chatPath, project: 'test', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe('claude-haiku-4-5') + expect(calls[0]!.costUSD).toBeGreaterThan(0) + }) + + it('uses workflowId as sessionId', async () => { + const wsHash = 'g'.repeat(32) + const wsDir = join(tmpDir, wsHash) + await mkdir(wsDir, { recursive: true }) + const chatPath = join(wsDir, 'sess.chat') + await writeFile(chatPath, makeChatFile({ + workflowId: 'my-workflow-id', + botResponses: ['ok'], + })) + + const source = { path: chatPath, project: 'test', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.sessionId).toBe('my-workflow-id') + }) + + it('parses a post-February extensionless execution file', async () => { + const wsHash = 'i'.repeat(32) + const sessionHash = 'session-modern' + const wsDir = join(tmpDir, wsHash, sessionHash) + await mkdir(wsDir, { recursive: true }) + const executionPath = join(wsDir, 'execution-modern') + await writeFile(executionPath, makeModernExecutionFile({ + executionId: 'exec-modern', + sessionId: 'session-modern', + modelId: 'claude-sonnet-4.5', + userPrompt: 'summarize this workspace', + assistantResponse: 'I reviewed it. <tool_use><name>runCommand</name></tool_use>', + })) + + const source = { path: executionPath, project: 'test', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.provider).toBe('kiro') + expect(call.model).toBe('claude-sonnet-4-5') + expect(call.sessionId).toBe('session-modern') + expect(call.userMessage).toBe('summarize this workspace') + expect(call.inputTokens).toBeGreaterThan(0) + expect(call.outputTokens).toBeGreaterThan(0) + expect(call.tools).toEqual(['Bash', 'Read']) + expect(call.costUSD).toBeGreaterThan(0) + }) + + it('skips session index files without conversation content', async () => { + const wsHash = 'j'.repeat(32) + const wsDir = join(tmpDir, wsHash) + await mkdir(wsDir, { recursive: true }) + const indexPath = join(wsDir, 'session-index') + await writeFile(indexPath, JSON.stringify({ + executions: [{ + executionId: 'exec-indexed', + type: 'chat-agent', + status: 'succeed', + startTime: 1777333000000, + endTime: 1777333010000, + }], + })) + + const source = { path: indexPath, project: 'test', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(0) + }) + + it('parses direct prompt and response fields from modern execution files', async () => { + const wsHash = 'k'.repeat(32) + const wsDir = join(tmpDir, wsHash) + await mkdir(wsDir, { recursive: true }) + const executionPath = join(wsDir, 'execution-direct') + await writeFile(executionPath, JSON.stringify({ + executionId: 'exec-direct', + workflowType: 'chat-agent', + status: 'succeed', + startTime: 1777333000000, + model: { id: 'auto' }, + prompt: 'make a small change', + response: 'Changed it. <tool_use><name>writeFile</name></tool_use>', + })) + + const source = { path: executionPath, project: 'test', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe('kiro-auto') + expect(calls[0]!.userMessage).toBe('make a small change') + expect(calls[0]!.tools).toEqual(['Edit']) + }) + + it('accepts second-based modern timestamps', async () => { + const wsHash = 'n'.repeat(32) + const wsDir = join(tmpDir, wsHash) + await mkdir(wsDir, { recursive: true }) + const executionPath = join(wsDir, 'execution-seconds') + await writeFile(executionPath, makeModernExecutionFile({ + executionId: 'exec-seconds', + startTime: 1777333000, + })) + + const source = { path: executionPath, project: 'test', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.timestamp).toBe('2026-04-27T23:36:40.000Z') + }) + + it('accepts numeric-string modern timestamps', async () => { + const wsHash = 'o'.repeat(32) + const wsDir = join(tmpDir, wsHash) + await mkdir(wsDir, { recursive: true }) + const executionPath = join(wsDir, 'execution-string-time') + await writeFile(executionPath, makeModernExecutionFile({ + executionId: 'exec-string-time', + startTime: '1777333000000', + })) + + const source = { path: executionPath, project: 'test', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.timestamp).toBe('2026-04-27T23:36:40.000Z') + }) + + it('does not poison dedup keys when a modern execution has an invalid timestamp', async () => { + const wsHash = 'p'.repeat(32) + const wsDir = join(tmpDir, wsHash) + await mkdir(wsDir, { recursive: true }) + const invalidPath = join(wsDir, 'execution-invalid-time') + const validPath = join(wsDir, 'execution-valid-time') + const shared = { + executionId: 'exec-recovered', + sessionId: 'session-recovered', + } + await writeFile(invalidPath, makeModernExecutionFile({ + ...shared, + startTime: 'not-a-timestamp', + })) + await writeFile(validPath, makeModernExecutionFile({ + ...shared, + startTime: 1777333000000, + })) + + const seenKeys = new Set<string>() + const invalidCalls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser({ path: invalidPath, project: 'test', provider: 'kiro' }, seenKeys).parse()) { + invalidCalls.push(call) + } + const validCalls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser({ path: validPath, project: 'test', provider: 'kiro' }, seenKeys).parse()) { + validCalls.push(call) + } + + expect(invalidCalls).toHaveLength(0) + expect(validCalls).toHaveLength(1) + }) + + it.each(['conversation', 'chat', 'transcript', 'entries', 'events'])('parses modern execution conversation arrays from %s', async (key) => { + const wsHash = 'q'.repeat(32) + const wsDir = join(tmpDir, wsHash) + await mkdir(wsDir, { recursive: true }) + const executionPath = join(wsDir, `execution-${key}`) + await writeFile(executionPath, JSON.stringify({ + executionId: `exec-${key}`, + workflowType: 'chat-agent', + status: 'succeed', + startTime: 1777333000000, + modelId: 'claude-sonnet-4.5', + [key]: [ + { role: 'user', content: `request from ${key}` }, + { role: 'assistant', content: `response from ${key}`, toolCalls: [{ name: 'readFile' }] }, + ], + })) + + const source = { path: executionPath, project: 'test', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.userMessage).toBe(`request from ${key}`) + expect(calls[0]!.tools).toEqual(['Read']) + }) + + it('keeps modern executions with structured assistant tool calls and no assistant text', async () => { + const wsHash = 'l'.repeat(32) + const wsDir = join(tmpDir, wsHash, 'session-tools') + await mkdir(wsDir, { recursive: true }) + const executionPath = join(wsDir, 'execution-tools') + await writeFile(executionPath, JSON.stringify({ + executionId: 'exec-tools', + sessionId: 'session-tools', + workflowType: 'chat-agent', + status: 'succeed', + startTime: 1777333000000, + modelId: 'claude-sonnet-4.5', + messages: [ + { role: 'user', content: 'run the test suite' }, + { role: 'assistant', toolCalls: [{ name: 'runCommand' }] }, + ], + })) + + const source = { path: executionPath, project: 'test', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.tools).toEqual(['Bash']) + expect(calls[0]!.inputTokens).toBeGreaterThan(0) + expect(calls[0]!.outputTokens).toBe(0) + }) + + it('keeps direct modern executions with root tool calls and no response text', async () => { + const wsHash = 'm'.repeat(32) + const wsDir = join(tmpDir, wsHash) + await mkdir(wsDir, { recursive: true }) + const executionPath = join(wsDir, 'execution-root-tools') + await writeFile(executionPath, JSON.stringify({ + executionId: 'exec-root-tools', + workflowType: 'chat-agent', + status: 'succeed', + startTime: 1777333000000, + model: { id: 'auto' }, + name: 'workflow-name', + prompt: 'edit a file', + toolCalls: [{ name: 'writeFile' }], + })) + + const source = { path: executionPath, project: 'test', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.tools).toEqual(['Edit']) + expect(calls[0]!.tools).not.toContain('workflow-name') + expect(calls[0]!.outputTokens).toBe(0) + }) +}) + +describe('kiro provider - discoverSessions', () => { + beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'kiro-test-')) + }) + + afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) + }) + + it('discovers chat files from workspace hash directories', async () => { + const wsHash = 'a1b2c3d4e5f6'.padEnd(32, '0') + const wsDir = join(tmpDir, wsHash) + await mkdir(wsDir, { recursive: true }) + await writeFile(join(wsDir, 'session1.chat'), makeChatFile({})) + await writeFile(join(wsDir, 'session2.chat'), makeChatFile({})) + + const provider = createKiroProvider(tmpDir, '/nonexistent/ws') + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(2) + expect(sessions.every(s => s.provider === 'kiro')).toBe(true) + expect(sessions.every(s => s.path.endsWith('.chat'))).toBe(true) + }) + + it('discovers extensionless session index files and nested execution files', async () => { + const wsHash = 'd'.repeat(32) + const wsDir = join(tmpDir, wsHash) + const sessionDir = join(wsDir, 'session-dir') + await mkdir(sessionDir, { recursive: true }) + await writeFile(join(wsDir, 'session-index'), JSON.stringify({ executions: [] })) + await writeFile(join(wsDir, 'legacy.chat'), makeChatFile({})) + await writeFile(join(wsDir, 'ignored.json'), '{}') + await writeFile(join(wsDir, '.DS_Store'), 'ignored') + await writeFile(join(sessionDir, 'execution-1'), makeModernExecutionFile({})) + await writeFile(join(sessionDir, '.hidden'), 'ignored') + await writeFile(join(sessionDir, 'ignored.txt'), 'hello') + + const provider = createKiroProvider(tmpDir, '/nonexistent/ws') + const sessions = await provider.discoverSessions() + const paths = sessions.map(s => s.path).sort() + + expect(paths).toEqual([ + join(sessionDir, 'execution-1'), + join(wsDir, 'legacy.chat'), + join(wsDir, 'session-index'), + ].sort()) + }) + + it('reads project name from workspace.json', async () => { + const wsHash = 'b'.repeat(32) + const agentWsDir = join(tmpDir, wsHash) + await mkdir(agentWsDir, { recursive: true }) + await writeFile(join(agentWsDir, 'test.chat'), makeChatFile({})) + + const workspaceStorageDir = join(tmpDir, 'ws-storage') + const wsStorageEntry = join(workspaceStorageDir, wsHash) + await mkdir(wsStorageEntry, { recursive: true }) + await writeFile(join(wsStorageEntry, 'workspace.json'), JSON.stringify({ folder: 'file:///home/user/myapp' })) + + const provider = createKiroProvider(tmpDir, workspaceStorageDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.project).toBe('myapp') + }) + + it('returns empty when directory does not exist', async () => { + const provider = createKiroProvider('/nonexistent/agent', '/nonexistent/ws') + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(0) + }) + + it('skips non-32-char directories', async () => { + const shortDir = join(tmpDir, 'short') + await mkdir(shortDir, { recursive: true }) + await writeFile(join(shortDir, 'test.chat'), makeChatFile({})) + + const provider = createKiroProvider(tmpDir, '/nonexistent/ws') + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(0) + }) + + it('skips files with unsupported extensions', async () => { + const wsHash = 'c'.repeat(32) + const wsDir = join(tmpDir, wsHash) + await mkdir(wsDir, { recursive: true }) + await writeFile(join(wsDir, 'index.json'), '{}') + await writeFile(join(wsDir, 'notes.txt'), 'hello') + + const provider = createKiroProvider(tmpDir, '/nonexistent/ws') + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(0) + }) +}) + +describe('kiro provider - metadata', () => { + it('has correct name and displayName', () => { + expect(kiro.name).toBe('kiro') + expect(kiro.displayName).toBe('Kiro') + }) + + it('normalizes model display names', () => { + expect(kiro.modelDisplayName('claude-haiku-4-5')).toBe('Haiku 4.5') + expect(kiro.modelDisplayName('claude-sonnet-4-5')).toBe('Sonnet 4.5') + expect(kiro.modelDisplayName('claude-sonnet-4-6')).toBe('Sonnet 4.6') + expect(kiro.modelDisplayName('unknown-model')).toBe('unknown-model') + }) + + it('normalizes tool display names', () => { + expect(kiro.toolDisplayName('readFile')).toBe('Read') + expect(kiro.toolDisplayName('writeFile')).toBe('Edit') + expect(kiro.toolDisplayName('runCommand')).toBe('Bash') + expect(kiro.toolDisplayName('searchFiles')).toBe('Grep') + expect(kiro.toolDisplayName('unknown_tool')).toBe('unknown_tool') + }) + + it('normalizes CLI-specific tool names', () => { + expect(kiro.toolDisplayName('code')).toBe('Read') + expect(kiro.toolDisplayName('subagent')).toBe('Agent') + expect(kiro.toolDisplayName('web_fetch')).toBe('WebFetch') + }) + + it('passes through MCP tool names unchanged', () => { + expect(kiro.toolDisplayName('mcp__server__searchJira')).toBe('mcp__server__searchJira') + expect(kiro.toolDisplayName('mcp__atlassian__getIssue')).toBe('mcp__atlassian__getIssue') + }) + + it('longest-prefix match for versioned model IDs', () => { + expect(kiro.modelDisplayName('claude-sonnet-4-5-20260101')).toBe('Sonnet 4.5') + expect(kiro.modelDisplayName('claude-haiku-4-5-20260101')).toBe('Haiku 4.5') + }) +}) + +describe('kiro provider - CLI session discovery', () => { + let cliDir: string + + beforeEach(async () => { + cliDir = await mkdtemp(join(tmpdir(), 'kiro-cli-test-')) + }) + + afterEach(async () => { + await rm(cliDir, { recursive: true, force: true }) + }) + + it('discovers .jsonl files from CLI sessions directory', async () => { + const sessionId = '11111111-1111-1111-1111-111111111111' + await writeFile(join(cliDir, `${sessionId}.jsonl`), '') + await writeFile(join(cliDir, `${sessionId}.json`), JSON.stringify({ + session_id: sessionId, + cwd: '/home/user/my-project', + created_at: '2026-01-01T00:00:00Z', + updated_at: '2026-01-01T00:01:00Z', + })) + + const provider = createKiroProvider('/nonexistent', '/nonexistent', cliDir) + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(1) + expect(sessions[0]!.project).toBe('my-project') + expect(sessions[0]!.path).toContain('.jsonl') + expect(sessions[0]!.provider).toBe('kiro') + }) + + it('parses CLI session JSONL into calls', async () => { + const sessionId = '22222222-2222-2222-2222-222222222222' + const jsonl = [ + JSON.stringify({ version: '1', kind: 'Prompt', data: { message_id: 'm1', content: [{ kind: 'text', data: 'hello world' }], meta: { timestamp: 1700000000 } } }), + JSON.stringify({ version: '1', kind: 'AssistantMessage', data: { message_id: 'm2', content: [{ kind: 'text', data: 'Hello! How can I help you today?' }, { kind: 'toolUse', data: { toolUseId: 't1', name: 'read', input: {} } }] } }), + JSON.stringify({ version: '1', kind: 'ToolResults', data: { message_id: 'm3', content: [{ kind: 'text', data: 'file contents here' }], results: { t1: { output: 'ok' } } } }), + JSON.stringify({ version: '1', kind: 'AssistantMessage', data: { message_id: 'm4', content: [{ kind: 'text', data: 'I read the file for you.' }] } }), + ].join('\n') + + await writeFile(join(cliDir, `${sessionId}.jsonl`), jsonl) + await writeFile(join(cliDir, `${sessionId}.json`), JSON.stringify({ + session_id: sessionId, + cwd: '/tmp/test-project', + created_at: '2026-01-01T00:00:00Z', + updated_at: '2026-01-01T00:01:00Z', + session_state: { + rts_model_state: { model_info: { model_id: 'auto' } }, + conversation_metadata: { + user_turn_metadatas: [{ + end_timestamp: '2026-01-01T00:00:30Z', + metering_usage: [{ value: 0.05, unit: 'credit' }, { value: 0.08, unit: 'credit' }], + }], + }, + }, + })) + + const source = { path: join(cliDir, `${sessionId}.jsonl`), project: 'test-project', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.provider).toBe('kiro') + expect(call.model).toBe('kiro-auto') + expect(call.tools).toContain('Read') + expect(call.userMessage).toBe('hello world') + expect(call.costUSD).toBeCloseTo(0.13, 2) + expect(call.deduplicationKey).toBe(`kiro-cli:${sessionId}:0`) + expect(call.timestamp).toBe('2026-01-01T00:00:30.000Z') + expect(call.project).toBe('test-project') + }) + + it('parses multiple turns from a CLI session', async () => { + const sessionId = '33333333-3333-3333-3333-333333333333' + const jsonl = [ + JSON.stringify({ version: '1', kind: 'Prompt', data: { message_id: 'm1', content: [{ kind: 'text', data: 'first question' }], meta: { timestamp: 1700000000 } } }), + JSON.stringify({ version: '1', kind: 'AssistantMessage', data: { message_id: 'm2', content: [{ kind: 'text', data: 'first answer' }] } }), + JSON.stringify({ version: '1', kind: 'Prompt', data: { message_id: 'm3', content: [{ kind: 'text', data: 'second question' }], meta: { timestamp: 1700000060 } } }), + JSON.stringify({ version: '1', kind: 'AssistantMessage', data: { message_id: 'm4', content: [{ kind: 'text', data: 'second answer' }] } }), + ].join('\n') + + await writeFile(join(cliDir, `${sessionId}.jsonl`), jsonl) + await writeFile(join(cliDir, `${sessionId}.json`), JSON.stringify({ + session_id: sessionId, + cwd: '/tmp/multi', + created_at: '2026-01-01T00:00:00Z', + updated_at: '2026-01-01T00:02:00Z', + session_state: { + rts_model_state: { model_info: { model_id: 'claude-sonnet-4' } }, + conversation_metadata: { + user_turn_metadatas: [ + { end_timestamp: '2026-01-01T00:00:30Z', metering_usage: [{ value: 0.04, unit: 'credit' }] }, + { end_timestamp: '2026-01-01T00:01:30Z', metering_usage: [{ value: 0.06, unit: 'credit' }] }, + ], + }, + }, + })) + + const source = { path: join(cliDir, `${sessionId}.jsonl`), project: 'multi', provider: 'kiro' } + const calls: ParsedProviderCall[] = [] + for await (const call of kiro.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(2) + expect(calls[0]!.userMessage).toBe('first question') + expect(calls[0]!.model).toBe('claude-sonnet-4') + expect(calls[1]!.userMessage).toBe('second question') + expect(calls[1]!.costUSD).toBeCloseTo(0.06, 2) + }) + + it('skips non-jsonl files in CLI directory', async () => { + await writeFile(join(cliDir, 'something.json'), '{}') + await writeFile(join(cliDir, 'something.lock'), '') + + const provider = createKiroProvider('/nonexistent', '/nonexistent', cliDir) + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(0) + }) +}) + +describe('kiro provider - context.messages with entries', () => { + beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'kiro-ctx-')) + }) + + afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) + }) + + it('parses context.messages using entries field', async () => { + // Simulates the real Kiro IDE format where messages use "entries" not "content" + const file = JSON.stringify({ + executionId: 'exec-ctx-001', + workflowType: 'chat-agent', + status: 'succeed', + startTime: 1777333000000, + chatSessionId: 'session-ctx-001', + context: { + messages: [ + { role: 'human', entries: ['What is the meaning of life?'] }, + { role: 'bot', entries: ['The meaning of life is 42, according to Douglas Adams.'] }, + { role: 'human', entries: ['Tell me more'] }, + { role: 'bot', entries: ['The answer comes from The Hitchhiker\'s Guide to the Galaxy.'] }, + ], + }, + }) + + const wsHash = 'a'.repeat(32) + const subDir = 'b'.repeat(32) + await mkdir(join(tmpDir, wsHash, subDir), { recursive: true }) + await writeFile(join(tmpDir, wsHash, subDir, 'exec-ctx-001'), file) + + const provider = createKiroProvider(tmpDir, tmpDir, '/nonexistent') + const sessions = await provider.discoverSessions() + expect(sessions.length).toBeGreaterThan(0) + + const calls: ParsedProviderCall[] = [] + for (const source of sessions) { + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + } + + expect(calls.length).toBeGreaterThan(0) + const call = calls[0]! + expect(call.inputTokens).toBeGreaterThan(0) + expect(call.outputTokens).toBeGreaterThan(0) + expect(call.sessionId).toBe('session-ctx-001') + }) + + it('extracts tools from usageSummary', async () => { + const file = JSON.stringify({ + executionId: 'exec-tools-001', + workflowType: 'chat-agent', + status: 'succeed', + startTime: 1777333000000, + chatSessionId: 'session-tools-001', + context: { + messages: [ + { role: 'human', entries: ['Search for accounts'] }, + { role: 'bot', entries: ['Found 5 accounts.'] }, + ], + }, + usageSummary: [ + { usedTools: ['mcp_aws_sentral_mcp_search_accounts'], usage: 0.5, unit: 'credit' }, + { usedTools: ['executeBash', 'readFile'], usage: 1.0, unit: 'credit' }, + ], + }) + + const wsHash = 'c'.repeat(32) + const subDir = 'd'.repeat(32) + await mkdir(join(tmpDir, wsHash, subDir), { recursive: true }) + await writeFile(join(tmpDir, wsHash, subDir, 'exec-tools-001'), file) + + const provider = createKiroProvider(tmpDir, tmpDir, '/nonexistent') + const sessions = await provider.discoverSessions() + const calls: ParsedProviderCall[] = [] + for (const source of sessions) { + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + } + + expect(calls.length).toBeGreaterThan(0) + const call = calls[0]! + expect(call.tools).toContain('aws_sentral_mcp_search_accounts') + expect(call.tools).toContain('Bash') + expect(call.tools).toContain('Read') + }) + + it('skips execution index files with executions array', async () => { + // The session index file has {executions: [...], version: 2} + const indexFile = JSON.stringify({ + executions: [ + { executionId: 'exec-001', type: 'chat-agent', status: 'succeed', startTime: 1777333000000 }, + ], + version: 2, + }) + + const wsHash = 'e'.repeat(32) + await mkdir(join(tmpDir, wsHash), { recursive: true }) + await writeFile(join(tmpDir, wsHash, 'f'.repeat(32)), indexFile) + + const provider = createKiroProvider(tmpDir, tmpDir, '/nonexistent') + const sessions = await provider.discoverSessions() + const calls: ParsedProviderCall[] = [] + for (const source of sessions) { + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + } + + expect(calls).toHaveLength(0) + }) +}) + +describe('kiro provider - workspace-sessions format', () => { + beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'kiro-wss-')) + }) + + afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) + }) + + it('discovers and parses workspace-sessions files', async () => { + // Create workspace-sessions/<base64>/<sessionId>.json + const wsSessionsDir = join(tmpDir, 'workspace-sessions', 'L3RtcC90ZXN0') + await mkdir(wsSessionsDir, { recursive: true }) + + const sessionFile = JSON.stringify({ + sessionId: 'ws-session-001', + title: 'Test session', + selectedModel: 'claude-opus-4.8', + workspaceDirectory: '/tmp/test', + history: [ + { message: { role: 'user', content: [{ type: 'text', text: 'What is TypeScript?' }] } }, + { message: { role: 'assistant', content: 'TypeScript is a typed superset of JavaScript.' } }, + { message: { role: 'user', content: [{ type: 'text', text: 'How do I use generics?' }] } }, + { message: { role: 'assistant', content: 'Generics allow you to create reusable components.' } }, + ], + }) + + await writeFile(join(wsSessionsDir, 'ws-session-001.json'), sessionFile) + // Also need sessions.json (should be skipped) + await writeFile(join(wsSessionsDir, 'sessions.json'), '[]') + + const provider = createKiroProvider(tmpDir, tmpDir, '/nonexistent') + const sessions = await provider.discoverSessions() + + const wsSessions = sessions.filter(s => s.path.includes('workspace-sessions')) + expect(wsSessions).toHaveLength(1) + expect(wsSessions[0]!.path).toContain('ws-session-001.json') + + const calls: ParsedProviderCall[] = [] + for (const source of wsSessions) { + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + } + + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.model).toBe('claude-opus-4-8') + expect(call.sessionId).toBe('ws-session-001') + expect(call.inputTokens).toBeGreaterThan(0) + expect(call.outputTokens).toBeGreaterThan(0) + expect(call.deduplicationKey).toBe('kiro:ws-session:ws-session-001') + }) + + it('skips workspace-sessions with only stub assistant replies referencing execution files', async () => { + const wsSessionsDir = join(tmpDir, 'workspace-sessions', 'L3RtcC90ZXN0') + await mkdir(wsSessionsDir, { recursive: true }) + + // Session where assistant only says "On it." with executionId refs + // (real output is in execution files — skip to avoid double-counting) + const sessionFile = JSON.stringify({ + sessionId: 'ws-session-stub', + selectedModel: 'auto', + workspaceDirectory: '/tmp/test', + history: [ + { message: { role: 'user', content: [{ type: 'text', text: 'Deploy the stack' }] } }, + { message: { role: 'assistant', content: 'On it.' }, executionId: 'exec-ref-001' }, + ], + }) + + await writeFile(join(wsSessionsDir, 'ws-session-stub.json'), sessionFile) + + const provider = createKiroProvider(tmpDir, tmpDir, '/nonexistent') + const sessions = await provider.discoverSessions() + const calls: ParsedProviderCall[] = [] + for (const source of sessions) { + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + } + + // Should be skipped: has executionId refs but no real assistant content + expect(calls).toHaveLength(0) + }) + + it('skips sessions.json file in workspace-sessions', async () => { + const wsSessionsDir = join(tmpDir, 'workspace-sessions', 'L3RtcC90ZXN0') + await mkdir(wsSessionsDir, { recursive: true }) + await writeFile(join(wsSessionsDir, 'sessions.json'), '[]') + + const provider = createKiroProvider(tmpDir, tmpDir, '/nonexistent') + const sessions = await provider.discoverSessions() + const wsSessions = sessions.filter(s => s.path.includes('workspace-sessions')) + expect(wsSessions).toHaveLength(0) + }) +}) diff --git a/tests/providers/lingtai-tui.test.ts b/tests/providers/lingtai-tui.test.ts new file mode 100644 index 0000000..3feef28 --- /dev/null +++ b/tests/providers/lingtai-tui.test.ts @@ -0,0 +1,207 @@ +import { mkdir, mkdtemp, rm, writeFile } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { afterEach, beforeEach, describe, expect, it } from 'vitest' + +import { createLingTaiTuiProvider } from '../../src/providers/lingtai-tui.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'lingtai-tui-provider-test-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +async function writeAgent(name: string, opts: { + home?: string + manifest?: Record<string, unknown> + ledgerLines?: Array<Record<string, unknown> | string> +} = {}): Promise<string> { + const home = opts.home ?? tmpDir + const agentDir = join(home, name) + await mkdir(join(agentDir, 'logs'), { recursive: true }) + if (opts.manifest) { + await writeFile(join(agentDir, '.agent.json'), JSON.stringify(opts.manifest, null, 2)) + } + const ledgerPath = join(agentDir, 'logs', 'token_ledger.jsonl') + const lines = opts.ledgerLines ?? [] + await writeFile( + ledgerPath, + lines.map(line => typeof line === 'string' ? line : JSON.stringify(line)).join('\n') + (lines.length ? '\n' : ''), + ) + return ledgerPath +} + +async function collectCalls(provider: ReturnType<typeof createLingTaiTuiProvider>, sourcePath: string, project = 'agent'): Promise<ParsedProviderCall[]> { + const calls: ParsedProviderCall[] = [] + const parser = provider.createSessionParser({ path: sourcePath, project, provider: 'lingtai-tui' }, new Set()) + for await (const call of parser.parse()) calls.push(call) + return calls +} + +describe('lingtai-tui provider', () => { + it('discovers top-level LingTai token ledgers', async () => { + const ledgerPath = await writeAgent('agent-a', { + manifest: { + agent_id: 'agent-001', + agent_name: 'Operator Agent', + llm: { model: 'gpt-5.5', base_url: 'example-endpoint' }, + }, + ledgerLines: [ + { source: 'main', ts: '2026-06-04T01:25:09Z', input: 100, output: 20, thinking: 5, cached: 10, model: 'gpt-5.5' }, + ], + }) + await mkdir(join(tmpDir, 'agent-a', 'daemons', 'em-1', 'logs'), { recursive: true }) + await writeFile(join(tmpDir, 'agent-a', 'daemons', 'em-1', 'logs', 'token_ledger.jsonl'), '{}\n') + + const provider = createLingTaiTuiProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toEqual([{ path: ledgerPath, project: 'Operator Agent', provider: 'lingtai-tui' }]) + }) + + it('discovers project-local LingTai homes from the TUI registry', async () => { + const defaultHome = join(tmpDir, 'home', '.lingtai') + const globalDir = join(tmpDir, 'home', '.lingtai-tui') + const projectRoot = join(tmpDir, 'projects', 'sample-project') + const projectHome = join(projectRoot, '.lingtai') + + const defaultLedger = await writeAgent('personal', { + home: defaultHome, + manifest: { agent_name: 'Personal Agent' }, + ledgerLines: [{ ts: '2026-07-06T01:00:00Z', input: 1, output: 1, model: 'gpt-5.5' }], + }) + const projectLedger = await writeAgent('lingtai', { + home: projectHome, + manifest: { agent_name: 'Project Agent' }, + ledgerLines: [{ ts: '2026-07-06T02:00:00Z', input: 2, output: 2, model: 'gpt-5.5' }], + }) + await mkdir(globalDir, { recursive: true }) + await writeFile(join(globalDir, 'registry.jsonl'), JSON.stringify({ path: projectRoot }) + '\n') + + const provider = createLingTaiTuiProvider({ + defaultHomeOverride: defaultHome, + globalDirOverride: globalDir, + cwdOverride: join(tmpDir, 'elsewhere'), + }) + const sessions = await provider.discoverSessions() + + expect(sessions).toEqual([ + { path: defaultLedger, project: 'Personal Agent', provider: 'lingtai-tui' }, + { path: projectLedger, project: 'sample-project-Project Agent', provider: 'lingtai-tui' }, + ]) + }) + + it('parses ledger entries and separates cached input from fresh input', async () => { + const ledgerPath = await writeAgent('agent-b', { + manifest: { + agent_id: 'agent-002', + address: 'agent-b', + llm: { model: 'fallback-model', base_url: 'fallback-endpoint' }, + }, + ledgerLines: [ + { source: 'main', ts: '2026-06-04T01:25:09Z', input: 100, output: 20, thinking: 5, cached: 10, model: 'gpt-5.5', endpoint: 'example-endpoint' }, + { source: 'tc_wake', ts: '2026-06-04T01:28:24Z', input: 25, output: 5, thinking: 0, cached: 10 }, + { source: 'summarize_apriori', ts: '2026-06-04T01:29:24Z', input: 40, output: 10, thinking: 0, cached: 20 }, + { source: 'daemon', em_id: 'em-1', run_id: 'run-1', ts: '2026-06-04T01:30:24Z', input: 50, output: 10, thinking: 0, cached: 50 }, + ], + }) + + const calls = await collectCalls(createLingTaiTuiProvider(tmpDir), ledgerPath, 'agent-b') + + expect(calls).toHaveLength(4) + expect(calls[0]).toMatchObject({ + provider: 'lingtai-tui', + model: 'gpt-5.5', + inputTokens: 90, + outputTokens: 20, + reasoningTokens: 5, + cacheReadInputTokens: 10, + cachedInputTokens: 10, + timestamp: '2026-06-04T01:25:09.000Z', + userMessage: 'LingTai main conversation', + sessionId: 'agent-002:main', + project: 'agent-b', + }) + expect(calls[1]).toMatchObject({ + tools: ['Agent'], + subagentTypes: ['lingtai-task-coordinator'], + userMessage: 'LingTai task coordinator wake', + sessionId: 'agent-002:tc_wake', + }) + expect(calls[2]).toMatchObject({ + tools: ['EnterPlanMode'], + subagentTypes: [], + userMessage: 'LingTai planning summary', + sessionId: 'agent-002:summarize_apriori', + }) + expect(calls[1]).toMatchObject({ + model: 'fallback-model', + }) + expect(calls[3]).toMatchObject({ + model: 'fallback-model', + inputTokens: 0, + cacheReadInputTokens: 50, + tools: ['Agent'], + subagentTypes: ['lingtai-daemon'], + sessionId: 'run-1', + userMessage: 'LingTai daemon task', + }) + expect(calls[0]!.deduplicationKey).not.toBe(calls[3]!.deduplicationKey) + }) + + it('skips corrupt and zero-token lines', async () => { + const ledgerPath = await writeAgent('agent-c', { + ledgerLines: [ + 'not json', + { source: 'main', ts: '2026-06-04T01:25:09Z', input: 0, output: 0, thinking: 0, cached: 0, model: 'gpt-5.5' }, + { source: 'main', ts: '2026-06-04T01:26:09Z', input: 1, output: 2, thinking: 3, cached: 0, model: 'gpt-5.5' }, + ], + }) + + const calls = await collectCalls(createLingTaiTuiProvider(tmpDir), ledgerPath) + + expect(calls).toHaveLength(1) + expect(calls[0]!.inputTokens).toBe(1) + expect(calls[0]!.outputTokens).toBe(2) + expect(calls[0]!.reasoningTokens).toBe(3) + }) + + it('uses shared model display names', () => { + const provider = createLingTaiTuiProvider(tmpDir) + expect(provider.modelDisplayName('claude-sonnet-4-6')).toBe('Sonnet 4.6') + expect(provider.modelDisplayName('some-future-model')).toBe('some-future-model') + }) + + // A planted .agent.json can be valid JSON with wrong-typed fields. Before the + // manifest was normalized, an object-valued agent_name reached + // sanitizeProject().trim() and threw — and discoverAllSessions loops providers + // with no try/catch, so that one file broke usage discovery for EVERY + // provider. Discovery and parsing must both survive it. + it('does not crash on a valid-JSON manifest with wrong-typed fields', async () => { + const ledgerPath = await writeAgent('agent-hostile', { + manifest: { + agent_name: {}, + agent_id: [1, 2], + address: 42, + nickname: { x: 1 }, + llm: { model: {}, base_url: [] }, + }, + ledgerLines: [ + { source: 'main', ts: '2026-06-04T01:26:09Z', input: 10, output: 5, model: 'gpt-5.5' }, + ], + }) + + const provider = createLingTaiTuiProvider(tmpDir) + await expect(provider.discoverSessions()).resolves.toBeInstanceOf(Array) + const calls = await collectCalls(provider, ledgerPath) + expect(calls).toHaveLength(1) + // Wrong-typed manifest name falls back to the sanitized agent directory. + expect(typeof calls[0]!.model).toBe('string') + }) +}) diff --git a/tests/providers/mistral-vibe.test.ts b/tests/providers/mistral-vibe.test.ts new file mode 100644 index 0000000..1a393fc --- /dev/null +++ b/tests/providers/mistral-vibe.test.ts @@ -0,0 +1,314 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { createMistralVibeProvider } from '../../src/providers/mistral-vibe.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'mistral-vibe-test-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +function metadata(opts: { + sessionId?: string + cwd?: string + input?: number + output?: number + sessionCost?: number + inputPrice?: number + outputPrice?: number + activeModel?: string + modelName?: string + configInputPrice?: number + configOutputPrice?: number + endTime?: string | null + title?: string +} = {}) { + const activeModel = opts.activeModel ?? 'mistral-medium-3.5' + return { + session_id: opts.sessionId ?? 'session-abc123', + start_time: '2026-05-11T10:00:00+00:00', + end_time: Object.hasOwn(opts, 'endTime') ? opts.endTime : '2026-05-11T10:05:00+00:00', + environment: { + working_directory: opts.cwd ?? '/Users/test/mistral-project', + }, + stats: { + session_prompt_tokens: opts.input ?? 2000, + session_completion_tokens: opts.output ?? 3000, + session_cost: opts.sessionCost, + input_price_per_million: opts.inputPrice ?? 1.5, + output_price_per_million: opts.outputPrice ?? 7.5, + tokens_per_second: 42, + }, + config: { + active_model: activeModel, + models: [ + { + alias: activeModel, + name: opts.modelName ?? 'mistral-vibe-cli-latest', + provider: 'mistral', + input_price: opts.configInputPrice ?? 1.5, + output_price: opts.configOutputPrice ?? 7.5, + }, + ], + }, + title: opts.title ?? 'implement mistral support', + total_messages: 2, + } +} + +function userMessage(content: unknown = 'implement mistral support') { + return { + role: 'user', + content, + message_id: 'msg-user-1', + } +} + +function assistantMessage(toolCalls: Array<{ name: string; args?: Record<string, unknown> | string }> = []) { + return { + role: 'assistant', + content: 'Done', + message_id: 'msg-assistant-1', + tool_calls: toolCalls.map((call, idx) => ({ + id: `tool-${idx}`, + type: 'function', + function: { + name: call.name, + arguments: typeof call.args === 'string' ? call.args : JSON.stringify(call.args ?? {}), + }, + })), + } +} + +async function writeSession( + name: string, + meta: Record<string, unknown>, + messages = [userMessage(), assistantMessage()], + root = tmpDir, +) { + const sessionDir = join(root, name) + await mkdir(sessionDir, { recursive: true }) + await writeFile(join(sessionDir, 'meta.json'), JSON.stringify(meta, null, 2)) + await writeFile(join(sessionDir, 'messages.jsonl'), messages.map(m => JSON.stringify(m)).join('\n') + '\n') + return sessionDir +} + +async function collect(sourcePath: string, provider = createMistralVibeProvider(tmpDir)): Promise<ParsedProviderCall[]> { + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser({ + path: sourcePath, + project: 'mistral-project', + provider: 'mistral-vibe', + }, new Set()).parse()) { + calls.push(call) + } + return calls +} + +describe('mistral-vibe provider - session discovery', () => { + it('discovers Vibe session folders and derives project from metadata cwd', async () => { + const sessionDir = await writeSession('session_20260511_100000_sessiona', metadata({ + sessionId: 'session-a', + cwd: '/Users/test/project-a', + })) + await mkdir(join(tmpDir, 'not-a-session'), { recursive: true }) + + const provider = createMistralVibeProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]).toEqual({ + path: sessionDir, + project: 'project-a', + provider: 'mistral-vibe', + }) + }) + + it('discovers subagent session folders nested under agents', async () => { + const parentDir = await writeSession('session_20260511_100000_parent', metadata({ + sessionId: 'parent-session', + cwd: '/Users/test/parent-project', + })) + const childDir = await writeSession('session_20260511_100001_child', metadata({ + sessionId: 'child-session', + cwd: '/Users/test/child-project', + }), [userMessage('child task'), assistantMessage()], join(parentDir, 'agents')) + + const provider = createMistralVibeProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions.map(s => s.path).sort()).toEqual([childDir, parentDir].sort()) + expect(sessions.map(s => s.project).sort()).toEqual(['child-project', 'parent-project']) + }) + + it('returns empty for a missing Vibe sessions directory', async () => { + const provider = createMistralVibeProvider('/missing/vibe/logs/session') + await expect(provider.discoverSessions()).resolves.toEqual([]) + }) + + it('uses VIBE_HOME when no override directory is provided', async () => { + const vibeHome = join(tmpDir, 'vibe-home') + process.env['VIBE_HOME'] = vibeHome + const sessionsDir = join(vibeHome, 'logs', 'session') + await writeSession('session_20260511_100000_sessiona', metadata({ + sessionId: 'env-session', + cwd: '/Users/test/env-project', + }), [userMessage(), assistantMessage()], sessionsDir) + + const provider = createMistralVibeProvider() + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.project).toBe('env-project') + }) +}) + +describe('mistral-vibe provider - parsing', () => { + it('parses cumulative session usage, tools, bash commands, and first user message', async () => { + const sessionDir = await writeSession('session_20260511_100000_sessiona', metadata(), [ + userMessage([{ type: 'text', text: 'track Mistral Vibe usage' }]), + assistantMessage([ + { name: 'read_file', args: { path: 'src/index.ts' } }, + { name: 'search_replace', args: { file_path: 'src/index.ts', content: 'patch' } }, + { name: 'bash', args: { command: 'npm test && git status' } }, + ]), + ]) + + const calls = await collect(sessionDir, createMistralVibeProvider(tmpDir)) + + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.provider).toBe('mistral-vibe') + expect(call.model).toBe('mistral-medium-3.5') + expect(call.inputTokens).toBe(2000) + expect(call.outputTokens).toBe(3000) + expect(call.costUSD).toBeCloseTo(0.0255, 8) + expect(call.tools).toEqual(['Read', 'Edit', 'Bash']) + expect(call.bashCommands).toEqual(['npm', 'git']) + expect(call.timestamp).toBe('2026-05-11T10:05:00+00:00') + expect(call.userMessage).toBe('track Mistral Vibe usage') + expect(call.sessionId).toBe('session-abc123') + expect(call.deduplicationKey).toBe('mistral-vibe:session-abc123:msg-assistant-1') + }) + + it('prefers Vibe session_cost over price-derived estimates when present', async () => { + const sessionDir = await writeSession('session_20260511_100000_sessiona', metadata({ + input: 364147, + output: 1731, + sessionCost: 0.381681, + inputPrice: 100, + outputPrice: 100, + })) + + const calls = await collect(sessionDir, createMistralVibeProvider(tmpDir)) + + expect(calls).toHaveLength(1) + expect(calls[0]!.costUSD).toBe(0.381681) + }) + + it('uses configured model prices when stats omit prices', async () => { + const sessionDir = await writeSession('session_20260511_100000_sessiona', metadata({ + inputPrice: 0, + outputPrice: 0, + input: 1000, + output: 1000, + })) + + const calls = await collect(sessionDir, createMistralVibeProvider(tmpDir)) + + expect(calls).toHaveLength(1) + expect(calls[0]!.costUSD).toBeCloseTo(0.009, 8) + }) + + it('falls back to LiteLLM pricing when Vibe does not provide prices', async () => { + const sessionDir = await writeSession('session_20260511_100000_sessiona', metadata({ + activeModel: 'claude-sonnet-4-6', + modelName: 'claude-sonnet-4-6', + input: 1000, + output: 1000, + inputPrice: 0, + outputPrice: 0, + configInputPrice: 0, + configOutputPrice: 0, + })) + + const calls = await collect(sessionDir, createMistralVibeProvider(tmpDir)) + + expect(calls).toHaveLength(1) + expect(calls[0]!.costUSD).toBeCloseTo(0.018, 8) + }) + + it('falls back to start_time when end_time is missing', async () => { + const sessionDir = await writeSession('session_20260511_100000_sessiona', metadata({ + endTime: null, + })) + + const calls = await collect(sessionDir, createMistralVibeProvider(tmpDir)) + + expect(calls[0]!.timestamp).toBe('2026-05-11T10:00:00+00:00') + }) + + it('deduplicates by session id', async () => { + const sessionDir = await writeSession('session_20260511_100000_sessiona', metadata()) + const provider = createMistralVibeProvider(tmpDir) + const source = { path: sessionDir, project: 'mistral-project', provider: 'mistral-vibe' } + const seen = new Set<string>() + + const first: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, seen).parse()) first.push(call) + const second: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, seen).parse()) second.push(call) + + expect(first).toHaveLength(1) + expect(second).toHaveLength(0) + }) + + it('skips sessions without cumulative token usage', async () => { + const sessionDir = await writeSession('session_20260511_100000_empty', metadata({ + input: 0, + output: 0, + })) + + const calls = await collect(sessionDir, createMistralVibeProvider(tmpDir)) + + expect(calls).toEqual([]) + }) + + it('skips sessions with malformed meta.json', async () => { + const sessionDir = join(tmpDir, 'session_20260511_100000_bad') + await mkdir(sessionDir, { recursive: true }) + await writeFile(join(sessionDir, 'meta.json'), '{{not json') + await writeFile(join(sessionDir, 'messages.jsonl'), JSON.stringify(userMessage()) + '\n') + + const provider = createMistralVibeProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(0) + }) + + it('returns empty calls when messages.jsonl is malformed', async () => { + const sessionDir = await writeSession('session_20260511_100000_badjsonl', metadata()) + await writeFile(join(sessionDir, 'messages.jsonl'), '{{not json\n{{also bad\n') + + const calls = await collect(sessionDir, createMistralVibeProvider(tmpDir)) + expect(calls).toHaveLength(1) + expect(calls[0]!.tools).toEqual([]) + expect(calls[0]!.bashCommands).toEqual([]) + }) + + it('formats model and tool display names', () => { + const provider = createMistralVibeProvider(tmpDir) + + expect(provider.modelDisplayName('mistral-medium-3.5')).toBe('Mistral Medium 3.5') + expect(provider.modelDisplayName('devstral-small-latest')).toBe('Devstral Small') + expect(provider.toolDisplayName('search_replace')).toBe('Edit') + expect(provider.toolDisplayName('unknown_tool')).toBe('unknown_tool') + }) +}) diff --git a/tests/providers/mux.test.ts b/tests/providers/mux.test.ts new file mode 100644 index 0000000..1957be3 --- /dev/null +++ b/tests/providers/mux.test.ts @@ -0,0 +1,404 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { createMuxProvider } from '../../src/providers/mux.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'mux-test-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +// ~/.mux/config.json shape: { projects: Array<[projectPath, { workspaces: [{ id }] }]> } +async function writeConfig(root: string, entries: Array<[string, string[]]>) { + const data = { + projects: entries.map(([projectPath, ids]) => [ + projectPath, + { workspaces: ids.map(id => ({ id, name: 'main', path: `${projectPath}/wt-${id}` })) }, + ]), + } + await writeFile(join(root, 'config.json'), JSON.stringify(data)) +} + +async function writeWorkspace(root: string, workspaceId: string, lines: string[]) { + const dir = join(root, 'sessions', workspaceId) + await mkdir(dir, { recursive: true }) + const filePath = join(dir, 'chat.jsonl') + await writeFile(filePath, lines.join('\n') + '\n') + return filePath +} + +// Sub-agent transcripts live nested under the parent workspace, not as a +// top-level sessions/<id> dir. +async function writeSubagent(root: string, workspaceId: string, childTaskId: string, lines: string[]) { + const dir = join(root, 'sessions', workspaceId, 'subagent-transcripts', childTaskId) + await mkdir(dir, { recursive: true }) + const filePath = join(dir, 'chat.jsonl') + await writeFile(filePath, lines.join('\n') + '\n') + return filePath +} + +function userMessage(text: string, id = 'msg-user-1') { + return JSON.stringify({ + id, + role: 'user', + parts: [{ type: 'text', text }], + metadata: { historySequence: 0, timestamp: 1776023210000 }, + }) +} + +type AsstOpts = { + id?: string + timestamp?: number + model?: string + input?: number + output?: number + reasoning?: number + cacheRead?: number + cacheCreate?: number + tools?: Array<{ name: string; script?: string }> + text?: string +} + +function assistantMessage(opts: AsstOpts = {}) { + const parts: Array<Record<string, unknown>> = [{ type: 'text', text: opts.text ?? 'done' }] + for (const t of opts.tools ?? []) { + parts.push({ + type: 'dynamic-tool', + toolCallId: `call-${t.name}`, + toolName: t.name, + input: t.script !== undefined ? { script: t.script } : {}, + state: 'output-available', + output: {}, + }) + } + const metadata: Record<string, unknown> = { + historySequence: 1, + model: opts.model ?? 'anthropic:claude-opus-4-8', + timestamp: opts.timestamp ?? 1776023230000, + usage: { + inputTokens: opts.input ?? 1000, + outputTokens: opts.output ?? 200, + reasoningTokens: opts.reasoning ?? 0, + cachedInputTokens: opts.cacheRead ?? 0, + }, + ...(opts.cacheCreate + ? { providerMetadata: { anthropic: { cacheCreationInputTokens: opts.cacheCreate } } } + : {}), + } + return JSON.stringify({ id: opts.id ?? 'msg-asst-1', role: 'assistant', parts, metadata }) +} + +describe('mux provider - session discovery', () => { + it('discovers chat.jsonl per workspace and resolves project from config.json', async () => { + await writeWorkspace(tmpDir, 'ws-abc', [userMessage('hi'), assistantMessage({})]) + await writeConfig(tmpDir, [['/Users/test/myproject', ['ws-abc']]]) + + const provider = createMuxProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.provider).toBe('mux') + expect(sessions[0]!.project).toBe('myproject') + expect(sessions[0]!.path).toContain(join('sessions', 'ws-abc', 'chat.jsonl')) + }) + + it('falls back to the workspaceId when config.json has no mapping', async () => { + await writeWorkspace(tmpDir, 'ws-orphan', [assistantMessage({})]) + // no config.json written + + const provider = createMuxProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.project).toBe('ws-orphan') + }) + + it('discovers multiple workspaces across projects', async () => { + await writeWorkspace(tmpDir, 'ws-1', [assistantMessage({})]) + await writeWorkspace(tmpDir, 'ws-2', [assistantMessage({})]) + await writeConfig(tmpDir, [ + ['/Users/test/project-a', ['ws-1']], + ['/Users/test/project-b', ['ws-2']], + ]) + + const provider = createMuxProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions.map(s => s.project).sort()).toEqual(['project-a', 'project-b']) + }) + + it('returns empty for a non-existent root', async () => { + const provider = createMuxProvider('/nonexistent/path/that/does/not/exist') + expect(await provider.discoverSessions()).toEqual([]) + }) + + it('skips workspace directories without a chat.jsonl', async () => { + await mkdir(join(tmpDir, 'sessions', 'ws-empty'), { recursive: true }) + const provider = createMuxProvider(tmpDir) + expect(await provider.discoverSessions()).toEqual([]) + }) + + it('discovers sub-agent transcripts and attributes them to the parent project', async () => { + await writeWorkspace(tmpDir, 'ws-parent', [assistantMessage({ id: 'parent-1' })]) + await writeSubagent(tmpDir, 'ws-parent', 'child-a', [assistantMessage({ id: 'child-a-1' })]) + await writeSubagent(tmpDir, 'ws-parent', 'child-b', [assistantMessage({ id: 'child-b-1' })]) + await writeConfig(tmpDir, [['/Users/test/myproject', ['ws-parent']]]) + + const provider = createMuxProvider(tmpDir) + const sessions = await provider.discoverSessions() + + // parent chat.jsonl + two sub-agent transcripts, all under one project. + expect(sessions).toHaveLength(3) + expect(sessions.every(s => s.project === 'myproject')).toBe(true) + const subagentPaths = sessions + .map(s => s.path) + .filter(p => p.includes('subagent-transcripts')) + .sort() + expect(subagentPaths).toHaveLength(2) + expect(subagentPaths[0]).toContain(join('subagent-transcripts', 'child-a', 'chat.jsonl')) + }) + + it('discovers a sub-agent transcript even when the workspace has no top-level chat.jsonl', async () => { + // mkdir the workspace dir without a chat.jsonl, but with a sub-agent transcript. + await writeSubagent(tmpDir, 'ws-parent', 'child-only', [assistantMessage({ id: 'child-only-1' })]) + + const provider = createMuxProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.path).toContain(join('subagent-transcripts', 'child-only', 'chat.jsonl')) + }) + + it('counts sub-agent calls once, with a workspace-distinct dedup key', async () => { + const seenKeys = new Set<string>() + await writeWorkspace(tmpDir, 'ws-parent', [assistantMessage({ id: 'shared-id', input: 100 })]) + // Same message id inside the sub-agent must NOT collide with the parent's. + await writeSubagent(tmpDir, 'ws-parent', 'child-a', [assistantMessage({ id: 'shared-id', input: 200 })]) + + const provider = createMuxProvider(tmpDir) + const sessions = await provider.discoverSessions() + const calls: ParsedProviderCall[] = [] + for (const source of sessions) { + for await (const call of provider.createSessionParser(source, seenKeys).parse()) calls.push(call) + } + + expect(calls).toHaveLength(2) + expect(new Set(calls.map(c => c.deduplicationKey))).toEqual( + new Set(['mux:ws-parent:shared-id', 'mux:child-a:shared-id']), + ) + expect(calls.map(c => c.sessionId).sort()).toEqual(['child-a', 'ws-parent']) + }) +}) + +describe('mux provider - chat.jsonl parsing', () => { + it('decomposes inclusive input/output usage into codeburn token fields', async () => { + // input is inclusive of cache; output is inclusive of reasoning. + const filePath = await writeWorkspace(tmpDir, 'ws-abc', [ + userMessage('implement the feature'), + assistantMessage({ + id: 'msg-1', + input: 1000, + output: 230, + reasoning: 30, + cacheRead: 200, + cacheCreate: 50, + }), + ]) + + const provider = createMuxProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'mux' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.provider).toBe('mux') + expect(call.model).toBe('claude-opus-4-8') // provider prefix stripped so codeburn prices/displays it + expect(call.inputTokens).toBe(750) // 1000 - 200 cacheRead - 50 cacheCreate + expect(call.outputTokens).toBe(200) // 230 - 30 reasoning + expect(call.reasoningTokens).toBe(30) + expect(call.cacheReadInputTokens).toBe(200) + expect(call.cachedInputTokens).toBe(200) + expect(call.cacheCreationInputTokens).toBe(50) + expect(call.webSearchRequests).toBe(0) + expect(call.sessionId).toBe('ws-abc') + expect(call.userMessage).toBe('implement the feature') + expect(call.timestamp).toBe(new Date(1776023230000).toISOString()) + expect(call.costUSD).toBeGreaterThan(0) + expect(call.deduplicationKey).toBe('mux:ws-abc:msg-1') + }) + + it('maps tool names and extracts bash command programs', async () => { + const filePath = await writeWorkspace(tmpDir, 'ws-abc', [ + assistantMessage({ + tools: [ + { name: 'file_read' }, + { name: 'file_edit_replace_string' }, + { name: 'bash', script: 'git status && bun test' }, + ], + }), + ]) + + const provider = createMuxProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'mux' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls[0]!.tools).toEqual(['Read', 'Edit', 'Bash']) + expect(calls[0]!.bashCommands).toEqual(['git', 'bun']) + }) + + it('skips assistant messages without a usage blob', async () => { + const filePath = await writeWorkspace(tmpDir, 'ws-abc', [ + JSON.stringify({ + id: 'no-usage', + role: 'assistant', + parts: [{ type: 'text', text: 'thinking...' }], + metadata: { model: 'anthropic:claude-opus-4-8', timestamp: 1 }, + }), + ]) + + const provider = createMuxProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'mux' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + expect(calls).toHaveLength(0) + }) + + it('skips assistant messages with all-zero tokens', async () => { + const filePath = await writeWorkspace(tmpDir, 'ws-abc', [ + assistantMessage({ input: 0, output: 0 }), + ]) + + const provider = createMuxProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'mux' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + expect(calls).toHaveLength(0) + }) + + it('deduplicates calls seen across multiple parses', async () => { + const filePath = await writeWorkspace(tmpDir, 'ws-abc', [assistantMessage({ id: 'dup' })]) + + const provider = createMuxProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'mux' } + const seenKeys = new Set<string>() + + const first: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, seenKeys).parse()) first.push(call) + const second: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, seenKeys).parse()) second.push(call) + + expect(first).toHaveLength(1) + expect(second).toHaveLength(0) + }) + + it('yields one call per assistant message and pairs the preceding user prompt', async () => { + const filePath = await writeWorkspace(tmpDir, 'ws-multi', [ + userMessage('first question', 'u1'), + assistantMessage({ id: 'a1', input: 500, output: 100 }), + userMessage('second question', 'u2'), + assistantMessage({ id: 'a2', input: 600, output: 120 }), + ]) + + const provider = createMuxProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'mux' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(2) + expect(calls[0]!.userMessage).toBe('first question') + expect(calls[0]!.inputTokens).toBe(500) + expect(calls[1]!.userMessage).toBe('second question') + expect(calls[1]!.inputTokens).toBe(600) + }) + + it('handles a missing session file gracefully', async () => { + const provider = createMuxProvider(tmpDir) + const source = { path: join(tmpDir, 'sessions', 'nope', 'chat.jsonl'), project: 'x', provider: 'mux' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) calls.push(call) + expect(calls).toHaveLength(0) + }) + + it('keeps distinct id-less assistant messages via the line-index fallback', async () => { + const asst = (text: string, input: number) => + JSON.stringify({ + role: 'assistant', + parts: [{ type: 'text', text }], + // No `id`, identical historySequence — the fallback must stay unique. + metadata: { model: 'anthropic:claude-opus-4-8', timestamp: 1, historySequence: 5, usage: { inputTokens: input, outputTokens: 5 } }, + }) + const filePath = await writeWorkspace(tmpDir, 'ws-noid', [asst('a', 10), asst('b', 11)]) + + const provider = createMuxProvider(tmpDir) + const source = { path: filePath, project: 'p', provider: 'mux' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(2) + expect(new Set(calls.map(c => c.deduplicationKey)).size).toBe(2) + }) + + it('tolerates malformed lines without dropping later valid turns', async () => { + const filePath = await writeWorkspace(tmpDir, 'ws-abc', [ + // parts is an object, not an array (corrupt) — must not throw the loop + JSON.stringify({ id: 'bad-parts', role: 'assistant', parts: { type: 'text', text: 'x' }, metadata: { model: 'anthropic:claude-opus-4-8', timestamp: 1, usage: { inputTokens: 10, outputTokens: 5 } } }), + // out-of-range timestamp — must not throw; timestamp falls back to '' + JSON.stringify({ id: 'bad-ts', role: 'assistant', parts: [{ type: 'text', text: 'x' }], metadata: { model: 'anthropic:claude-opus-4-8', timestamp: 1.7e18, usage: { inputTokens: 10, outputTokens: 5 } } }), + assistantMessage({ id: 'good', input: 100, output: 20 }), + ]) + + const provider = createMuxProvider(tmpDir) + const source = { path: filePath, project: 'p', provider: 'mux' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(3) // none of the malformed lines aborted the parse + expect(calls.find(c => c.deduplicationKey === 'mux:ws-abc:good')?.inputTokens).toBe(100) + expect(calls.find(c => c.deduplicationKey === 'mux:ws-abc:bad-ts')?.timestamp).toBe('') + }) +}) + +describe('mux provider - display names', () => { + const provider = createMuxProvider('/tmp') + + it('has correct name and displayName', () => { + expect(provider.name).toBe('mux') + expect(provider.displayName).toBe('Mux') + }) + + it('strips the provider prefix and humanizes the model', () => { + expect(provider.modelDisplayName('anthropic:claude-opus-4-8')).toBe('Opus 4.8') + expect(provider.modelDisplayName('anthropic:claude-sonnet-4-6')).toBe('Sonnet 4.6') + }) + + it('returns the bare id for unknown / prefixless models', () => { + expect(provider.modelDisplayName('ollama:some-random-model')).toBe('some-random-model') + expect(provider.modelDisplayName('some-random-model')).toBe('some-random-model') + }) + + it('normalizes tool names to the canonical set', () => { + expect(provider.toolDisplayName('bash')).toBe('Bash') + expect(provider.toolDisplayName('file_read')).toBe('Read') + expect(provider.toolDisplayName('file_edit_insert')).toBe('Edit') + expect(provider.toolDisplayName('task')).toBe('Agent') + expect(provider.toolDisplayName('unknown_tool')).toBe('unknown_tool') + }) +}) diff --git a/tests/providers/omp.test.ts b/tests/providers/omp.test.ts new file mode 100644 index 0000000..6a25c27 --- /dev/null +++ b/tests/providers/omp.test.ts @@ -0,0 +1,225 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { createOmpProvider } from '../../src/providers/pi.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'omp-test-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +function sessionMeta(opts: { id?: string; cwd?: string } = {}) { + return JSON.stringify({ + type: 'session', + version: 3, + id: opts.id ?? 'sess-001', + timestamp: '2026-04-14T10:00:00.000Z', + cwd: opts.cwd ?? '/Users/test/myproject', + }) +} + +function userMessage(text: string) { + return JSON.stringify({ + type: 'message', + id: 'msg-user-1', + timestamp: '2026-04-14T10:00:10.000Z', + message: { + role: 'user', + content: [{ type: 'text', text }], + timestamp: 1776023210000, + }, + }) +} + +function assistantMessage(opts: { + id?: string + responseId?: string + timestamp?: string + model?: string + input?: number + output?: number + cacheRead?: number + cacheWrite?: number + tools?: Array<{ name: string; command?: string }> +}) { + const content = (opts.tools ?? []).map(t => ({ + type: 'toolCall', + id: `call-${t.name}`, + name: t.name, + arguments: t.command !== undefined ? { command: t.command } : {}, + })) + + return JSON.stringify({ + type: 'message', + id: opts.id ?? 'msg-asst-1', + timestamp: opts.timestamp ?? '2026-04-14T10:00:30.000Z', + message: { + role: 'assistant', + content, + provider: 'anthropic', + model: opts.model ?? 'claude-sonnet-4-5', + responseId: opts.responseId ?? 'resp-001', + usage: { + input: opts.input ?? 1000, + output: opts.output ?? 200, + cacheRead: opts.cacheRead ?? 0, + cacheWrite: opts.cacheWrite ?? 0, + cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }, + }, + timestamp: 1776023230000, + }, + }) +} + +async function writeSession(projectDir: string, filename: string, lines: string[]) { + await mkdir(projectDir, { recursive: true }) + const filePath = join(projectDir, filename) + await writeFile(filePath, lines.join('\n') + '\n') + return filePath +} + +describe('omp provider - identity', () => { + it('has correct name and displayName', () => { + const provider = createOmpProvider(tmpDir) + expect(provider.name).toBe('omp') + expect(provider.displayName).toBe('OMP') + }) +}) + +describe('omp provider - session discovery', () => { + it('discovers sessions from the omp sessions directory', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + await writeSession(projectDir, '2026-04-14T10-00-00-000Z_sess-001.jsonl', [ + sessionMeta({ cwd: '/Users/test/myproject' }), + assistantMessage({}), + ]) + + const provider = createOmpProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.provider).toBe('omp') + expect(sessions[0]!.project).toBe('myproject') + }) + + it('returns empty for non-existent directory', async () => { + const provider = createOmpProvider('/nonexistent/omp/path') + const sessions = await provider.discoverSessions() + expect(sessions).toEqual([]) + }) + + it('skips files whose first line is not a session entry', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + await writeSession(projectDir, 'bad.jsonl', [ + JSON.stringify({ type: 'message', id: 'x' }), + ]) + + const provider = createOmpProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toEqual([]) + }) +}) + +describe('omp provider - JSONL parsing', () => { + it('extracts token usage from an omp-format assistant message', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + const filePath = await writeSession(projectDir, 'session.jsonl', [ + sessionMeta({ id: 'sess-omp-1', cwd: '/Users/test/myproject' }), + userMessage('write a test'), + assistantMessage({ + responseId: 'resp-omp-1', + timestamp: '2026-04-14T10:00:30.000Z', + model: 'claude-sonnet-4-5', + input: 1500, + output: 300, + cacheRead: 2000, + cacheWrite: 50, + }), + ]) + + const provider = createOmpProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'omp' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.provider).toBe('omp') + expect(call.model).toBe('claude-sonnet-4-5') + expect(call.inputTokens).toBe(1500) + expect(call.outputTokens).toBe(300) + expect(call.cacheReadInputTokens).toBe(2000) + expect(call.cachedInputTokens).toBe(2000) + expect(call.cacheCreationInputTokens).toBe(50) + expect(call.sessionId).toBe('sess-omp-1') + expect(call.userMessage).toBe('write a test') + expect(call.timestamp).toBe('2026-04-14T10:00:30.000Z') + expect(call.deduplicationKey).toContain('omp:') + expect(call.deduplicationKey).toContain('resp-omp-1') + }) + + it('ignores the embedded usage.cost and recalculates cost', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + const filePath = await writeSession(projectDir, 'session.jsonl', [ + sessionMeta(), + assistantMessage({ input: 1000, output: 200, cacheRead: 0, cacheWrite: 0 }), + ]) + + const provider = createOmpProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'omp' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + // cost must be calculated by codeburn, not taken from usage.cost (which is zeroed in fixture) + expect(calls[0]!.costUSD).toBeGreaterThanOrEqual(0) + }) + + it('collects tool names from toolCall content items', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + const filePath = await writeSession(projectDir, 'session.jsonl', [ + sessionMeta(), + assistantMessage({ + tools: [{ name: 'read' }, { name: 'edit' }, { name: 'bash', command: 'bun test' }], + }), + ]) + + const provider = createOmpProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'omp' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls[0]!.tools).toEqual(['Read', 'Edit', 'Bash']) + expect(calls[0]!.bashCommands).toEqual(['bun']) + }) + + it('skips assistant messages with zero tokens', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + const filePath = await writeSession(projectDir, 'session.jsonl', [ + sessionMeta(), + assistantMessage({ input: 0, output: 0 }), + ]) + + const provider = createOmpProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'omp' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(0) + }) +}) diff --git a/tests/providers/open-design.test.ts b/tests/providers/open-design.test.ts new file mode 100644 index 0000000..1595c5f --- /dev/null +++ b/tests/providers/open-design.test.ts @@ -0,0 +1,155 @@ +import { mkdtemp, rm } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' +import { describe, it, expect, beforeEach, afterEach } from 'vitest' + +import { calculateCost } from '../../src/models.js' +import { clearSessionCache, filterProjectsByDateRange, parseAllSessions } from '../../src/parser.js' +import { allProviderNames } from '../../src/providers/index.js' +import { createOpenDesignProvider } from '../../src/providers/open-design.js' +import type { ParsedProviderCall, SessionSource } from '../../src/providers/types.js' + +const fixtureRoot = join(import.meta.dirname, '../fixtures/open-design') +const dataDir = join(fixtureRoot, 'namespaces', 'release-stable', 'data') + +let previousOverride: string | undefined +let previousCacheDir: string | undefined +let cacheDir: string | undefined + +async function collect(source: SessionSource, seenKeys = new Set<string>()): Promise<ParsedProviderCall[]> { + const provider = createOpenDesignProvider() + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, seenKeys).parse()) calls.push(call) + return calls +} + +async function fixtureSource(runId: string): Promise<SessionSource> { + const provider = createOpenDesignProvider() + const sources = await provider.discoverSessions() + const source = sources.find(s => s.path.includes(`${runId}/events.jsonl`)) + expect(source).toBeDefined() + return source! +} + +describe('open-design provider', () => { + beforeEach(async () => { + previousOverride = process.env['CODEBURN_OPEN_DESIGN_DIR'] + previousCacheDir = process.env['CODEBURN_CACHE_DIR'] + cacheDir = await mkdtemp(join(tmpdir(), 'codeburn-open-design-cache-')) + process.env['CODEBURN_OPEN_DESIGN_DIR'] = dataDir + process.env['CODEBURN_CACHE_DIR'] = cacheDir + clearSessionCache() + }) + + afterEach(async () => { + clearSessionCache() + if (previousOverride === undefined) { + delete process.env['CODEBURN_OPEN_DESIGN_DIR'] + } else { + process.env['CODEBURN_OPEN_DESIGN_DIR'] = previousOverride + } + if (previousCacheDir === undefined) { + delete process.env['CODEBURN_CACHE_DIR'] + } else { + process.env['CODEBURN_CACHE_DIR'] = previousCacheDir + } + if (cacheDir) await rm(cacheDir, { recursive: true, force: true }) + cacheDir = undefined + }) + + it('discovers per-run events.jsonl files from the env override data dir', async () => { + const provider = createOpenDesignProvider() + const sources = await provider.discoverSessions() + + expect(sources.map(s => s.provider).every(p => p === 'open-design')).toBe(true) + expect(sources.map(s => s.project)).toEqual(['release-stable', 'release-stable', 'release-stable']) + expect(sources.map(s => s.path).sort()).toEqual([ + join(dataDir, 'runs', 'run-mixed', 'events.jsonl'), + join(dataDir, 'runs', 'run-no-usage', 'events.jsonl'), + join(dataDir, 'runs', 'run-start-seeded', 'events.jsonl'), + ].sort()) + }) + + it('parses a mixed-model run into separate per-model usage calls', async () => { + const calls = await collect(await fixtureSource('run-mixed')) + + expect(calls).toHaveLength(2) + expect(calls.map(c => c.model)).toEqual(['openai-codex:gpt-5.5', 'glm-5.2']) + + const codex = calls[0]! + expect(codex.provider).toBe('open-design') + expect(codex.sessionId).toBe('run-mixed') + expect(codex.inputTokens).toBe(950) + expect(codex.outputTokens).toBe(200) + expect(codex.cacheCreationInputTokens).toBe(0) + expect(codex.cacheReadInputTokens).toBe(50) + expect(codex.cachedInputTokens).toBe(50) + expect(codex.reasoningTokens).toBe(25) + expect(codex.timestamp).toBe('2026-06-22T10:00:05.000Z') + expect(new Date(codex.timestamp).toISOString()).toBe(codex.timestamp) + expect(codex.costUSD).toBeCloseTo( + calculateCost(codex.model, 950, 225, 0, 50, 0), + 12, + ) + + const glm = calls[1]! + expect(glm.inputTokens).toBe(2900) + expect(glm.outputTokens).toBe(400) + expect(glm.cacheCreationInputTokens).toBe(0) + expect(glm.cacheReadInputTokens).toBe(100) + expect(glm.cachedInputTokens).toBe(100) + expect(glm.reasoningTokens).toBe(60) + expect(glm.timestamp).toBe('2026-06-22T10:00:15.000Z') + expect(glm.costUSD).toBeGreaterThan(0) + }) + + it('does not emit calls for a run with no usage events', async () => { + const calls = await collect(await fixtureSource('run-no-usage')) + expect(calls).toHaveLength(0) + }) + + it('uses the start-seeded model before any status transition', async () => { + const calls = await collect(await fixtureSource('run-start-seeded')) + + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe('glm-5.2') + expect(calls[0]!.inputTokens).toBe(770) + expect(calls[0]!.outputTokens).toBe(33) + expect(calls[0]!.cacheReadInputTokens).toBe(7) + expect(calls[0]!.reasoningTokens).toBe(3) + expect(calls[0]!.costUSD).toBeGreaterThan(0) + }) + + it('keeps numeric epoch timestamp usage in date-scoped aggregation', async () => { + const projects = await parseAllSessions(undefined, 'open-design') + const filtered = filterProjectsByDateRange(projects, { + start: new Date('2026-06-22T00:00:00.000Z'), + end: new Date('2026-06-22T23:59:59.999Z'), + }) + const calls = filtered.flatMap(project => + project.sessions.flatMap(session => + session.turns.flatMap(turn => turn.assistantCalls), + ), + ) + const numericTimestampCall = calls.find(call => + call.deduplicationKey === 'open-design:run-mixed:evt-codex-usage', + ) + + expect(numericTimestampCall?.timestamp).toBe('2026-06-22T10:00:05.000Z') + }) + + it('deduplicates usage events per run and event id across parser runs', async () => { + const source = await fixtureSource('run-mixed') + const seenKeys = new Set<string>() + + const first = await collect(source, seenKeys) + const second = await collect(source, seenKeys) + + expect(first).toHaveLength(2) + expect(second).toHaveLength(0) + }) + + it('registers open-design as a core provider', () => { + expect(allProviderNames()).toContain('open-design') + }) +}) diff --git a/tests/providers/openclaw.test.ts b/tests/providers/openclaw.test.ts new file mode 100644 index 0000000..d988aac --- /dev/null +++ b/tests/providers/openclaw.test.ts @@ -0,0 +1,192 @@ +import { describe, it, expect, afterAll } from 'vitest' +import { createOpenClawProvider } from '../../src/providers/openclaw.js' +import { writeFile, mkdir, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +const SESSION_LINES = [ + JSON.stringify({ type: 'session', version: 3, id: 'test-sess-1', timestamp: '2026-04-20T10:00:00.000Z', cwd: '/tmp' }), + JSON.stringify({ type: 'model_change', id: 'mc1', timestamp: '2026-04-20T10:00:01.000Z', provider: 'anthropic', modelId: 'claude-sonnet-4-6' }), + JSON.stringify({ + type: 'message', id: 'u1', timestamp: '2026-04-20T10:00:02.000Z', + message: { role: 'user', content: [{ type: 'text', text: 'hello world' }] }, + }), + JSON.stringify({ + type: 'message', id: 'a1', timestamp: '2026-04-20T10:00:03.000Z', + message: { + role: 'assistant', model: 'claude-sonnet-4-6', + content: [{ type: 'text', text: 'Hi!' }], + usage: { input: 500, output: 100, cacheRead: 200, cacheWrite: 50, totalTokens: 850 }, + }, + }), + JSON.stringify({ + type: 'message', id: 'a2', timestamp: '2026-04-20T10:00:05.000Z', + message: { + role: 'assistant', model: 'claude-sonnet-4-6', + content: [ + { type: 'text', text: 'Running command' }, + { type: 'toolCall', name: 'exec', arguments: { command: 'ls -la' } }, + { type: 'toolCall', name: 'read', arguments: { path: '/tmp/x' } }, + { type: 'tool_use', name: 'write', arguments: { path: '/tmp/y' } }, + ], + usage: { input: 600, output: 200, cacheRead: 100, cacheWrite: 0, totalTokens: 900, cost: { total: 0.05 } }, + }, + }), +] + +async function setupFixture(dir: string, agentName: string, sessionId: string, lines: string[]): Promise<string> { + const sessionsDir = join(dir, agentName, 'sessions') + await mkdir(sessionsDir, { recursive: true }) + const filePath = join(sessionsDir, `${sessionId}.jsonl`) + await writeFile(filePath, lines.join('\n')) + return filePath +} + +describe('openclaw provider', () => { + const baseDir = join(tmpdir(), `codeburn-openclaw-test-${Date.now()}`) + + it('discovers sessions in agent directories', async () => { + const dir = join(baseDir, 'discover') + await setupFixture(dir, 'myproject', 'sess-1', SESSION_LINES) + const provider = createOpenClawProvider(dir) + const sources = await provider.discoverSessions() + expect(sources.length).toBe(1) + expect(sources[0].provider).toBe('openclaw') + expect(sources[0].project).toBe('myproject') + }) + + it('parses assistant messages with usage', async () => { + const dir = join(baseDir, 'parse') + await setupFixture(dir, 'proj', 'test-sess-1', SESSION_LINES) + const provider = createOpenClawProvider(dir) + const sources = await provider.discoverSessions() + const parser = provider.createSessionParser(sources[0], new Set()) + const calls: any[] = [] + for await (const call of parser.parse()) { + calls.push(call) + } + expect(calls.length).toBe(2) + expect(calls[0].provider).toBe('openclaw') + expect(calls[0].model).toBe('claude-sonnet-4-6') + expect(calls[0].inputTokens).toBe(500) + expect(calls[0].outputTokens).toBe(100) + expect(calls[0].cacheReadInputTokens).toBe(200) + expect(calls[0].userMessage).toBe('hello world') + expect(calls[0].sessionId).toBe('test-sess-1') + }) + + it('uses cost.total from provider when available', async () => { + const dir = join(baseDir, 'cost') + await setupFixture(dir, 'proj', 'test-sess-1', SESSION_LINES) + const provider = createOpenClawProvider(dir) + const sources = await provider.discoverSessions() + const parser = provider.createSessionParser(sources[0], new Set()) + const calls: any[] = [] + for await (const call of parser.parse()) calls.push(call) + expect(calls[1].costUSD).toBe(0.05) + }) + + it('extracts tools and bash commands', async () => { + const dir = join(baseDir, 'tools') + await setupFixture(dir, 'proj', 'test-sess-1', SESSION_LINES) + const provider = createOpenClawProvider(dir) + const sources = await provider.discoverSessions() + const parser = provider.createSessionParser(sources[0], new Set()) + const calls: any[] = [] + for await (const call of parser.parse()) calls.push(call) + expect(calls[1].tools).toContain('Bash') + expect(calls[1].tools).toContain('Read') + expect(calls[1].tools).toContain('Write') + expect(calls[1].bashCommands).toContain('ls') + }) + + it('deduplicates on re-parse', async () => { + const dir = join(baseDir, 'dedup') + await setupFixture(dir, 'proj', 'test-sess-1', SESSION_LINES) + const provider = createOpenClawProvider(dir) + const sources = await provider.discoverSessions() + const seen = new Set<string>() + const parser1 = provider.createSessionParser(sources[0], seen) + const calls1: any[] = [] + for await (const c of parser1.parse()) calls1.push(c) + expect(calls1.length).toBe(2) + const parser2 = provider.createSessionParser(sources[0], seen) + const calls2: any[] = [] + for await (const c of parser2.parse()) calls2.push(c) + expect(calls2.length).toBe(0) + }) + + it('reads model from model_change event', async () => { + const lines = [ + JSON.stringify({ type: 'session', id: 'mc-test', timestamp: '2026-04-20T10:00:00.000Z' }), + JSON.stringify({ type: 'model_change', id: 'mc1', modelId: 'gpt-5.5', provider: 'openai' }), + JSON.stringify({ + type: 'message', id: 'a1', timestamp: '2026-04-20T10:00:01.000Z', + message: { role: 'assistant', usage: { input: 100, output: 50, cacheRead: 0, cacheWrite: 0 } }, + }), + ] + const dir = join(baseDir, 'model-change') + await setupFixture(dir, 'proj', 'mc-test', lines) + const provider = createOpenClawProvider(dir) + const sources = await provider.discoverSessions() + const parser = provider.createSessionParser(sources[0], new Set()) + const calls: any[] = [] + for await (const c of parser.parse()) calls.push(c) + expect(calls[0].model).toBe('gpt-5.5') + }) + + it('reads model from custom model-snapshot event', async () => { + const lines = [ + JSON.stringify({ type: 'session', id: 'snap-test', timestamp: '2026-04-20T10:00:00.000Z' }), + JSON.stringify({ type: 'custom', customType: 'model-snapshot', data: { modelId: 'glm-5.1:cloud', provider: 'ollama' }, id: 's1' }), + JSON.stringify({ + type: 'message', id: 'a1', timestamp: '2026-04-20T10:00:01.000Z', + message: { role: 'assistant', usage: { input: 200, output: 80, cacheRead: 0, cacheWrite: 0 } }, + }), + ] + const dir = join(baseDir, 'snapshot') + await setupFixture(dir, 'proj', 'snap-test', lines) + const provider = createOpenClawProvider(dir) + const sources = await provider.discoverSessions() + const parser = provider.createSessionParser(sources[0], new Set()) + const calls: any[] = [] + for await (const c of parser.parse()) calls.push(c) + expect(calls[0].model).toBe('glm-5.1:cloud') + }) + + it('skips entries with invalid timestamps', async () => { + const lines = [ + JSON.stringify({ type: 'session', id: 'bad-ts', timestamp: 'not-a-date' }), + JSON.stringify({ + type: 'message', id: 'a1', timestamp: 'also-bad', + message: { role: 'assistant', model: 'test', usage: { input: 100, output: 50, cacheRead: 0, cacheWrite: 0 } }, + }), + ] + const dir = join(baseDir, 'bad-ts') + await setupFixture(dir, 'proj', 'bad-ts', lines) + const provider = createOpenClawProvider(dir) + const sources = await provider.discoverSessions() + const parser = provider.createSessionParser(sources[0], new Set()) + const calls: any[] = [] + for await (const c of parser.parse()) calls.push(c) + expect(calls.length).toBe(0) + }) + + it('tool and model display names work', () => { + const provider = createOpenClawProvider() + expect(provider.toolDisplayName('bash')).toBe('Bash') + expect(provider.toolDisplayName('dispatch_agent')).toBe('Agent') + expect(provider.toolDisplayName('unknown')).toBe('unknown') + expect(provider.modelDisplayName('claude-sonnet-4-6')).toBe('claude-sonnet-4-6') + }) + + it('returns empty for nonexistent directory', async () => { + const provider = createOpenClawProvider('/tmp/nonexistent-openclaw-test') + const sources = await provider.discoverSessions() + expect(sources.length).toBe(0) + }) + + afterAll(async () => { + await rm(baseDir, { recursive: true, force: true }) + }) +}) diff --git a/tests/providers/opencode-file.test.ts b/tests/providers/opencode-file.test.ts new file mode 100644 index 0000000..ed3718e --- /dev/null +++ b/tests/providers/opencode-file.test.ts @@ -0,0 +1,243 @@ +import { mkdtemp, rm, mkdir, writeFile } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { describe, it, expect, beforeEach, afterEach } from 'vitest' + +import { createOpenCodeProvider } from '../../src/providers/opencode.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'opencode-file-test-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +type Msg = { id: string; data: Record<string, unknown>; parts?: Array<Record<string, unknown>> } + +// Mirrors the OpenCode 1.1+ on-disk layout under <dataDir>/storage/. +async function writeSession(opts: { + sessionId?: string + projectId?: string + directory?: string + title?: string + messages: Msg[] +}) { + const storage = join(tmpDir, 'opencode', 'storage') + const sessionId = opts.sessionId ?? 'ses_test1' + const projectId = opts.projectId ?? 'global' + + const sessionDir = join(storage, 'session', projectId) + await mkdir(sessionDir, { recursive: true }) + await writeFile(join(sessionDir, `${sessionId}.json`), JSON.stringify({ + id: sessionId, + slug: 'cosmic-engine', + version: '1.1.65', + projectID: projectId, + directory: opts.directory ?? '/Users/test/myproject', + title: opts.title ?? 'Test session', + time: { created: 1781886356809, updated: 1781886683506 }, + })) + + const messageDir = join(storage, 'message', sessionId) + await mkdir(messageDir, { recursive: true }) + for (const m of opts.messages) { + await writeFile(join(messageDir, `${m.id}.json`), JSON.stringify({ id: m.id, sessionID: sessionId, ...m.data })) + if (m.parts?.length) { + const partDir = join(storage, 'part', m.id) + await mkdir(partDir, { recursive: true }) + let i = 0 + for (const p of m.parts) { + await writeFile(join(partDir, `prt_${m.id}_${String(i++).padStart(3, '0')}.json`), JSON.stringify(p)) + } + } + } + return { sessionId } +} + +async function parseAll(seen = new Set<string>()): Promise<ParsedProviderCall[]> { + const provider = createOpenCodeProvider(tmpDir) + const sources = await provider.discoverSessions() + const calls: ParsedProviderCall[] = [] + for (const source of sources) { + for await (const call of provider.createSessionParser(source, seen).parse()) calls.push(call) + } + return calls +} + +describe('opencode file-based provider - discovery', () => { + it('discovers a file-based session and derives the project from directory', async () => { + await writeSession({ + directory: '/Users/test/myproject', + messages: [{ + id: 'msg_a', + data: { + role: 'assistant', modelID: 'gpt-5.3-codex-spark', cost: 0, + tokens: { input: 1000, output: 200, reasoning: 50, cache: { read: 5000, write: 0 } }, + time: { created: 1781886356900 }, + }, + parts: [{ type: 'text', text: 'hello' }], + }], + }) + const provider = createOpenCodeProvider(tmpDir) + const sources = await provider.discoverSessions() + expect(sources).toHaveLength(1) + expect(sources[0]!.provider).toBe('opencode') + expect(sources[0]!.project).toBe('Users-test-myproject') + expect(sources[0]!.path.endsWith('.json')).toBe(true) + }) + + it('returns nothing when neither file storage nor a DB exists', async () => { + const provider = createOpenCodeProvider(tmpDir) + expect(await provider.discoverSessions()).toEqual([]) + }) +}) + +describe('opencode file-based provider - parsing', () => { + it('extracts tokens, tools, bash commands, and the preceding user message', async () => { + await writeSession({ + messages: [ + { + id: 'msg_user', + data: { role: 'user', time: { created: 1 } }, + parts: [{ type: 'text', text: 'find the git repos' }], + }, + { + id: 'msg_a', + data: { + role: 'assistant', modelID: 'gpt-5.3-codex-spark', cost: 0, + tokens: { input: 1200, output: 300, reasoning: 100, cache: { read: 8000, write: 0 } }, + time: { created: 2 }, + }, + parts: [ + { type: 'reasoning' }, + { type: 'tool', tool: 'bash', state: { status: 'completed', input: { command: 'git status' } } }, + { type: 'tool', tool: 'read', state: { input: { filePath: '/x' } } }, + { type: 'text', text: 'done' }, + ], + }, + ], + }) + const calls = await parseAll() + expect(calls).toHaveLength(1) + const c = calls[0]! + expect(c.provider).toBe('opencode') + expect(c.model).toBe('gpt-5.3-codex-spark') + expect(c.inputTokens).toBe(1200) + expect(c.outputTokens).toBe(300) + expect(c.reasoningTokens).toBe(100) + expect(c.cacheReadInputTokens).toBe(8000) + expect(c.cachedInputTokens).toBe(8000) + expect(c.tools).toEqual(['Bash', 'Read']) + expect(c.bashCommands).toContain('git') + expect(c.userMessage).toBe('find the git repos') + expect(c.deduplicationKey).toBe('opencode:ses_test1:msg_a') + }) + + it('extracts skill names and subagent types from skill/task tool parts', async () => { + await writeSession({ + messages: [{ + id: 'msg_a', + data: { + role: 'assistant', modelID: 'gpt-5.3-codex-spark', cost: 0, + tokens: { input: 100, output: 20, reasoning: 0, cache: { read: 0, write: 0 } }, + time: { created: 1 }, + }, + parts: [ + { type: 'tool', tool: 'skill', state: { input: { name: 'commit' } } }, + { type: 'tool', tool: 'task', state: { input: { description: 'find files', subagent_type: 'explore' } } }, + { type: 'text', text: 'done' }, + ], + }], + }) + const calls = await parseAll() + expect(calls).toHaveLength(1) + const c = calls[0]! + expect(c.tools).toEqual(['Skill', 'Agent']) + expect(c.skills).toEqual(['commit']) + expect(c.subagentTypes).toEqual(['explore']) + }) + + it('leaves skills and subagentTypes empty when no skill/task parts are present', async () => { + await writeSession({ + messages: [{ + id: 'msg_a', + data: { + role: 'assistant', modelID: 'gpt-5.3-codex-spark', cost: 0, + tokens: { input: 100, output: 20, reasoning: 0, cache: { read: 0, write: 0 } }, + time: { created: 1 }, + }, + parts: [{ type: 'tool', tool: 'bash', state: { input: { command: 'ls' } } }], + }], + }) + const calls = await parseAll() + expect(calls[0]!.skills).toEqual([]) + expect(calls[0]!.subagentTypes).toEqual([]) + }) + + it('skips an errored or empty assistant turn (all-zero tokens, no parts)', async () => { + await writeSession({ + messages: [{ + id: 'msg_err', + data: { + role: 'assistant', modelID: 'gpt-5.3-codex', cost: 0, + tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, + time: { created: 1 }, + }, + }], + }) + expect(await parseAll()).toHaveLength(0) + }) + + it('falls back to message.cost when the model has no price table', async () => { + await writeSession({ + messages: [{ + id: 'msg_a', + data: { + role: 'assistant', modelID: 'totally-unknown-model-xyz', cost: 0.42, + tokens: { input: 100, output: 20, reasoning: 0, cache: { read: 0, write: 0 } }, + time: { created: 1 }, + }, + parts: [{ type: 'text', text: 'x' }], + }], + }) + const calls = await parseAll() + expect(calls).toHaveLength(1) + expect(calls[0]!.costUSD).toBeCloseTo(0.42) + }) + + it('deduplicates across repeated parses', async () => { + await writeSession({ + messages: [{ + id: 'msg_a', + data: { + role: 'assistant', modelID: 'gpt-5.3-codex-spark', + tokens: { input: 100, output: 20, reasoning: 0, cache: { read: 0, write: 0 } }, + time: { created: 1 }, + }, + parts: [{ type: 'text', text: 'x' }], + }], + }) + const seen = new Set<string>() + expect(await parseAll(seen)).toHaveLength(1) + expect(await parseAll(seen)).toHaveLength(0) + }) + + it('reads sessions across multiple project folders', async () => { + await writeSession({ + sessionId: 'ses_one', projectId: 'global', directory: '/Users/test/a', + messages: [{ id: 'm1', data: { role: 'assistant', modelID: 'gpt-5.3-codex-spark', tokens: { input: 10, output: 2 }, time: { created: 1 } }, parts: [{ type: 'text', text: 'x' }] }], + }) + await writeSession({ + sessionId: 'ses_two', projectId: 'proj_hash', directory: '/Users/test/b', + messages: [{ id: 'm2', data: { role: 'assistant', modelID: 'gpt-5.3-codex-spark', tokens: { input: 20, output: 4 }, time: { created: 1 } }, parts: [{ type: 'text', text: 'y' }] }], + }) + const calls = await parseAll() + expect(calls).toHaveLength(2) + expect(calls.map((c) => c.sessionId).sort()).toEqual(['ses_one', 'ses_two']) + }) +}) diff --git a/tests/providers/opencode.test.ts b/tests/providers/opencode.test.ts new file mode 100644 index 0000000..5dc9070 --- /dev/null +++ b/tests/providers/opencode.test.ts @@ -0,0 +1,901 @@ +import { mkdtemp, rm, mkdir, writeFile } from 'fs/promises' +import { mkdirSync } from 'fs' +import { join } from 'path' +import { tmpdir } from 'os' + +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { isSqliteAvailable } from '../../src/sqlite.js' +import { createOpenCodeProvider } from '../../src/providers/opencode.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +type TestDb = { + exec(sql: string): void + prepare(sql: string): { run(...params: unknown[]): void } + close(): void +} + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'opencode-test-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +function createTestDb(dir: string): string { + const ocDir = join(dir, 'opencode') + mkdirSync(ocDir, { recursive: true }) + const dbPath = join(ocDir, 'opencode.db') + + const { DatabaseSync: Database } = require('node:sqlite') + const db = new Database(dbPath) + db.exec(` + CREATE TABLE session ( + id TEXT PRIMARY KEY, project_id TEXT NOT NULL, parent_id TEXT, + slug TEXT NOT NULL, directory TEXT NOT NULL, title TEXT NOT NULL, + version TEXT NOT NULL, time_created INTEGER, time_updated INTEGER, + time_archived INTEGER + ) + `) + db.exec(` + CREATE TABLE message ( + id TEXT PRIMARY KEY, session_id TEXT NOT NULL, + time_created INTEGER, time_updated INTEGER, data TEXT NOT NULL + ) + `) + db.exec(` + CREATE TABLE part ( + id TEXT PRIMARY KEY, message_id TEXT NOT NULL, + session_id TEXT NOT NULL, time_created INTEGER, + time_updated INTEGER, data TEXT NOT NULL + ) + `) + db.close() + return dbPath +} + +function withTestDb(dbPath: string, fn: (db: TestDb) => void): void { + const { DatabaseSync: Database } = require('node:sqlite') + const db = new Database(dbPath) + fn(db) + db.close() +} + +function insertSession( + db: TestDb, + id: string, + opts: { directory?: string; title?: string; parentId?: string | null; archived?: number | null } = {}, +): void { + db.prepare(` + INSERT INTO session (id, project_id, slug, directory, title, version, time_created, time_archived, parent_id) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) + `).run(id, 'proj-1', 'slug-1', opts.directory ?? '/home/user/myproject', opts.title ?? 'My Project', '1.0', 1700000000000, opts.archived ?? null, opts.parentId ?? null) +} + +type MessageFixture = { + role: string + modelID?: string + cost?: number + tokens?: { + input: number + output: number + reasoning: number + cache: { read: number; write: number } + } +} + +type PartFixture = { + type: string + text?: string + tool?: string + state?: { status: string; input: { command?: string } } +} + +function insertMessage(db: TestDb, id: string, sessionId: string, timeCreated: number, data: MessageFixture): void { + db.prepare(`INSERT INTO message (id, session_id, time_created, data) VALUES (?, ?, ?, ?)`) + .run(id, sessionId, timeCreated, JSON.stringify(data)) +} + +function insertPart(db: TestDb, id: string, messageId: string, sessionId: string, data: PartFixture): void { + db.prepare(`INSERT INTO part (id, message_id, session_id, data) VALUES (?, ?, ?, ?)`) + .run(id, messageId, sessionId, JSON.stringify(data)) +} + +async function collectCalls(provider: ReturnType<typeof createOpenCodeProvider>, dbPath: string, sessionId: string, seenKeys?: Set<string>): Promise<ParsedProviderCall[]> { + const source = { path: `${dbPath}:${sessionId}`, project: 'myproject', provider: 'opencode' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, seenKeys ?? new Set()).parse()) { + calls.push(call) + } + return calls +} + +const skipUnlessSqlite = isSqliteAvailable() ? describe : describe.skip + +skipUnlessSqlite('opencode provider - model display names', () => { + it('strips provider prefix and delegates to shared lookup', () => { + const provider = createOpenCodeProvider() + expect(provider.modelDisplayName('claude-opus-4-6-20260205')).toBe('Opus 4.6') + }) + + it('strips google provider prefix', () => { + const provider = createOpenCodeProvider() + expect(provider.modelDisplayName('google/gemini-2.5-pro')).toBe('Gemini 2.5 Pro') + }) + + it('strips openai provider prefix', () => { + const provider = createOpenCodeProvider() + expect(provider.modelDisplayName('openai/gpt-4o')).toBe('GPT-4o') + }) + + it('passes through models without prefix unchanged', () => { + const provider = createOpenCodeProvider() + expect(provider.modelDisplayName('gpt-4o')).toBe('GPT-4o') + expect(provider.modelDisplayName('gpt-4o-mini')).toBe('GPT-4o Mini') + }) + + it('returns unknown models as-is', () => { + const provider = createOpenCodeProvider() + expect(provider.modelDisplayName('big-pickle')).toBe('big-pickle') + }) + + it('has correct displayName', () => { + const provider = createOpenCodeProvider() + expect(provider.displayName).toBe('OpenCode') + expect(provider.name).toBe('opencode') + }) +}) + +skipUnlessSqlite('opencode provider - tool display names', () => { + it('maps opencode builtins', () => { + const provider = createOpenCodeProvider() + expect(provider.toolDisplayName('bash')).toBe('Bash') + expect(provider.toolDisplayName('edit')).toBe('Edit') + expect(provider.toolDisplayName('task')).toBe('Agent') + expect(provider.toolDisplayName('fetch')).toBe('WebFetch') + expect(provider.toolDisplayName('grep')).toBe('Grep') + expect(provider.toolDisplayName('write')).toBe('Write') + expect(provider.toolDisplayName('skill')).toBe('Skill') + }) + + it('returns unknown tools as-is', () => { + const provider = createOpenCodeProvider() + expect(provider.toolDisplayName('github_search_code')).toBe('github_search_code') + }) +}) + +skipUnlessSqlite('opencode provider - session discovery', () => { + it('discovers sessions with correct path format', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + }) + + const provider = createOpenCodeProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.provider).toBe('opencode') + expect(sessions[0]!.project).toBe('home-user-myproject') + expect(sessions[0]!.path).toBe(`${dbPath}:sess-1`) + }) + + it('excludes archived sessions', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-archived', { archived: 1700000001000 }) + }) + + const provider = createOpenCodeProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(0) + }) + + it('excludes child sessions', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-child', { parentId: 'parent-id' }) + }) + + const provider = createOpenCodeProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(0) + }) + + it('returns empty for non-existent path', async () => { + const provider = createOpenCodeProvider('/nonexistent/path') + const sessions = await provider.discoverSessions() + expect(sessions).toEqual([]) + }) + + it('returns empty for empty database', async () => { + createTestDb(tmpDir) + const provider = createOpenCodeProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toEqual([]) + }) + + it('discovers sessions across multiple channel databases', async () => { + const ocDir = join(tmpDir, 'opencode') + await mkdir(ocDir, { recursive: true }) + + const { DatabaseSync: Database } = require('node:sqlite') + for (const file of ['opencode.db', 'opencode-dev.db']) { + const dbPath = join(ocDir, file) + const db = new Database(dbPath) + db.exec(` + CREATE TABLE session (id TEXT PRIMARY KEY, project_id TEXT NOT NULL, parent_id TEXT, + slug TEXT NOT NULL, directory TEXT NOT NULL, title TEXT NOT NULL, + version TEXT NOT NULL, time_created INTEGER, time_updated INTEGER, time_archived INTEGER) + `) + db.exec(`CREATE TABLE message (id TEXT PRIMARY KEY, session_id TEXT NOT NULL, + time_created INTEGER, time_updated INTEGER, data TEXT NOT NULL)`) + db.exec(`CREATE TABLE part (id TEXT PRIMARY KEY, message_id TEXT NOT NULL, + session_id TEXT NOT NULL, time_created INTEGER, time_updated INTEGER, data TEXT NOT NULL)`) + db.prepare(`INSERT INTO session (id, project_id, slug, directory, title, version, time_created) + VALUES (?, ?, ?, ?, ?, ?, ?)`).run(`sess-${file}`, 'proj-1', 'slug-1', '/home/user/myproject', 'My Project', '1.0', 1700000000000) + db.close() + } + + const provider = createOpenCodeProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(2) + expect(sessions.map(s => s.path)).toEqual( + expect.arrayContaining([ + expect.stringContaining('opencode.db:sess-opencode.db'), + expect.stringContaining('opencode-dev.db:sess-opencode-dev.db'), + ]), + ) + expect(sessions.every(s => s.provider === 'opencode')).toBe(true) + }) + + it('ignores non-opencode db files in the directory', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + }) + await writeFile(join(tmpDir, 'opencode', 'other.db'), '') + await writeFile(join(tmpDir, 'opencode', 'opencode.txt'), '') + + const provider = createOpenCodeProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(1) + }) + + it('sanitizes title when directory is empty', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1', { directory: '', title: 'My Session Title' }) + }) + + const provider = createOpenCodeProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions[0]!.project).toBe('My Session Title') + }) + + it('discovers multiple sessions in one database', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1', { directory: '/home/user/project-a', title: 'A' }) + insertSession(db, 'sess-2', { directory: '/home/user/project-b', title: 'B' }) + }) + + const provider = createOpenCodeProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(2) + }) +}) + +skipUnlessSqlite('opencode provider - session parsing', () => { + it('parses assistant messages with all fields', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + + insertMessage(db, 'msg-1', 'sess-1', 1700000000000, { role: 'user' }) + insertPart(db, 'part-1', 'msg-1', 'sess-1', { type: 'text', text: 'fix the login bug' }) + + insertMessage(db, 'msg-2', 'sess-1', 1700000001000, { + role: 'assistant', + modelID: 'claude-opus-4-6', + cost: 0.05, + tokens: { input: 100, output: 200, reasoning: 50, cache: { read: 500, write: 300 } }, + }) + insertPart(db, 'part-2', 'msg-2', 'sess-1', { + type: 'tool', tool: 'bash', + state: { status: 'completed', input: { command: 'npm test && git push' } }, + }) + insertPart(db, 'part-3', 'msg-2', 'sess-1', { + type: 'tool', tool: 'edit', state: { status: 'completed', input: {} }, + }) + }) + + const provider = createOpenCodeProvider(tmpDir) + const calls = await collectCalls(provider, dbPath, 'sess-1') + + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.provider).toBe('opencode') + expect(call.model).toBe('claude-opus-4-6') + expect(call.inputTokens).toBe(100) + expect(call.outputTokens).toBe(200) + expect(call.reasoningTokens).toBe(50) + expect(call.cacheReadInputTokens).toBe(500) + expect(call.cacheCreationInputTokens).toBe(300) + expect(call.cachedInputTokens).toBe(500) + expect(call.webSearchRequests).toBe(0) + expect(call.speed).toBe('standard') + expect(call.costUSD).toBeGreaterThan(0) + expect(call.tools).toEqual(['Bash', 'Edit']) + expect(call.bashCommands).toEqual(['npm', 'git']) + expect(call.userMessage).toBe('fix the login bug') + expect(call.sessionId).toBe('sess-1') + expect(call.timestamp).toBe(new Date(1700000001000).toISOString()) + expect(call.deduplicationKey).toBe('opencode:sess-1:msg-2') + }) + + it('normalizes opencode MCP tool names for shared MCP reporting', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + + insertMessage(db, 'msg-1', 'sess-1', 1700000000000, { role: 'user' }) + insertPart(db, 'part-1', 'msg-1', 'sess-1', { type: 'text', text: 'look up the ClickUp task' }) + + insertMessage(db, 'msg-2', 'sess-1', 1700000001000, { + role: 'assistant', + modelID: 'claude-opus-4-6', + cost: 0.05, + tokens: { input: 100, output: 200, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + insertPart(db, 'part-2', 'msg-2', 'sess-1', { + type: 'tool', + tool: 'clickup_clickup_get_task', + state: { status: 'completed', input: {} }, + }) + insertPart(db, 'part-3', 'msg-2', 'sess-1', { + type: 'tool', + tool: 'figma_get_file', + state: { status: 'completed', input: {} }, + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + + expect(calls).toHaveLength(1) + expect(calls[0]!.tools).toEqual([ + 'mcp__clickup__clickup_get_task', + 'mcp__figma__get_file', + ]) + }) + + it('preserves already-normalized MCP tool names', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + insertMessage(db, 'msg-1', 'sess-1', 1700000001000, { + role: 'assistant', + modelID: 'claude-opus-4-6', + cost: 0.05, + tokens: { input: 100, output: 200, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + insertPart(db, 'part-1', 'msg-1', 'sess-1', { + type: 'tool', + tool: 'mcp__github__search_code', + state: { status: 'completed', input: {} }, + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + + expect(calls).toHaveLength(1) + expect(calls[0]!.tools).toEqual(['mcp__github__search_code']) + }) + + it('keeps extension tool names without a server prefix as regular tools', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + insertMessage(db, 'msg-1', 'sess-1', 1700000001000, { + role: 'assistant', + modelID: 'claude-opus-4-6', + cost: 0.05, + tokens: { input: 100, output: 200, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + insertPart(db, 'part-1', 'msg-1', 'sess-1', { + type: 'tool', + tool: 'customtool', + state: { status: 'completed', input: {} }, + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + + expect(calls).toHaveLength(1) + expect(calls[0]!.tools).toEqual(['customtool']) + }) + + it('keeps malformed server-prefixed tool names as regular tools', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + insertMessage(db, 'msg-1', 'sess-1', 1700000001000, { + role: 'assistant', + modelID: 'claude-opus-4-6', + cost: 0.05, + tokens: { input: 100, output: 200, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + insertPart(db, 'part-1', 'msg-1', 'sess-1', { + type: 'tool', + tool: '_missing_server', + state: { status: 'completed', input: {} }, + }) + insertPart(db, 'part-2', 'msg-1', 'sess-1', { + type: 'tool', + tool: 'missing_', + state: { status: 'completed', input: {} }, + }) + insertPart(db, 'part-3', 'msg-1', 'sess-1', { + type: 'tool', + tool: '_', + state: { status: 'completed', input: {} }, + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + + expect(calls).toHaveLength(1) + expect(calls[0]!.tools).toEqual([ + '_missing_server', + 'missing_', + '_', + ]) + }) + + it('skips zero-token messages with zero cost', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + insertMessage(db, 'msg-1', 'sess-1', 1700000001000, { + role: 'assistant', modelID: 'claude-opus-4-6', cost: 0, + tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + expect(calls).toHaveLength(0) + }) + + it('keeps zero-usage assistant messages when router responses contain text', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + insertMessage(db, 'msg-u1', 'sess-1', 1700000000000, { role: 'user' }) + insertPart(db, 'part-u1', 'msg-u1', 'sess-1', { type: 'text', text: 'use the configured router' }) + insertMessage(db, 'msg-a1', 'sess-1', 1700000001000, { + role: 'assistant', modelID: 'edenai/router-model', cost: 0, + tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + insertPart(db, 'part-a1', 'msg-a1', 'sess-1', { type: 'text', text: 'router response text' }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe('edenai/router-model') + expect(calls[0]!.inputTokens).toBe(0) + expect(calls[0]!.outputTokens).toBe(0) + expect(calls[0]!.costUSD).toBe(0) + expect(calls[0]!.userMessage).toBe('use the configured router') + }) + + it('keeps zero-usage assistant messages when router responses contain tool calls', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + insertMessage(db, 'msg-a1', 'sess-1', 1700000001000, { + role: 'assistant', modelID: 'edenai/router-model', cost: 0, + tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + insertPart(db, 'part-a1', 'msg-a1', 'sess-1', { + type: 'tool', tool: 'bash', + state: { status: 'completed', input: { command: 'npm test' } }, + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + expect(calls).toHaveLength(1) + expect(calls[0]!.tools).toEqual(['Bash']) + expect(calls[0]!.bashCommands).toEqual(['npm']) + expect(calls[0]!.costUSD).toBe(0) + }) + + it('deduplicates messages across parses', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + insertMessage(db, 'msg-1', 'sess-1', 1700000001000, { + role: 'assistant', modelID: 'claude-opus-4-6', cost: 0.05, + tokens: { input: 100, output: 200, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + }) + + const provider = createOpenCodeProvider(tmpDir) + const seenKeys = new Set<string>() + const calls1 = await collectCalls(provider, dbPath, 'sess-1', seenKeys) + const calls2 = await collectCalls(provider, dbPath, 'sess-1', seenKeys) + + expect(calls1).toHaveLength(1) + expect(calls2).toHaveLength(0) + expect(seenKeys.has('opencode:sess-1:msg-1')).toBe(true) + }) + + it('falls back to pre-calculated cost for unknown models', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + insertMessage(db, 'msg-1', 'sess-1', 1700000001000, { + role: 'assistant', modelID: 'totally-unknown-model-xyz', cost: 0.42, + tokens: { input: 100, output: 200, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + expect(calls).toHaveLength(1) + expect(calls[0]!.costUSD).toBe(0.42) + }) + + it('uses calculated cost over pre-calculated for known models', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + insertMessage(db, 'msg-1', 'sess-1', 1700000001000, { + role: 'assistant', modelID: 'claude-opus-4-6', cost: 999.99, + tokens: { input: 100, output: 200, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + expect(calls).toHaveLength(1) + expect(calls[0]!.costUSD).toBeGreaterThan(0) + expect(calls[0]!.costUSD).not.toBe(999.99) + }) + + it('handles missing tokens field gracefully', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + insertMessage(db, 'msg-1', 'sess-1', 1700000001000, { + role: 'assistant', modelID: 'claude-opus-4-6', cost: 0.10, + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + expect(calls).toHaveLength(1) + expect(calls[0]!.inputTokens).toBe(0) + expect(calls[0]!.outputTokens).toBe(0) + expect(calls[0]!.costUSD).toBe(0.10) + }) + + it('uses "unknown" for missing modelID', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + insertMessage(db, 'msg-1', 'sess-1', 1700000001000, { + role: 'assistant', cost: 0.05, + tokens: { input: 100, output: 200, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe('unknown') + }) + + it('handles corrupt JSON in message and part data', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + + db.prepare(`INSERT INTO message (id, session_id, time_created, data) VALUES (?, ?, ?, ?)`) + .run('msg-corrupt', 'sess-1', 1700000000500, 'not valid json {]') + + insertMessage(db, 'msg-valid', 'sess-1', 1700000001000, { + role: 'assistant', modelID: 'claude-opus-4-6', cost: 0.05, + tokens: { input: 100, output: 200, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + + db.prepare(`INSERT INTO part (id, message_id, session_id, data) VALUES (?, ?, ?, ?)`) + .run('part-corrupt', 'msg-valid', 'sess-1', 'corrupt {[}') + + insertPart(db, 'part-valid', 'msg-valid', 'sess-1', { + type: 'tool', tool: 'bash', state: { status: 'completed', input: {} }, + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe('claude-opus-4-6') + expect(calls[0]!.tools).toEqual(['Bash']) + }) + + it('converts seconds-epoch timestamps to milliseconds', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + insertMessage(db, 'msg-1', 'sess-1', 1700000001, { + role: 'assistant', modelID: 'claude-opus-4-6', cost: 0.05, + tokens: { input: 100, output: 200, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + expect(calls).toHaveLength(1) + expect(calls[0]!.timestamp).toBe(new Date(1700000001 * 1000).toISOString()) + }) + + it('skips non-user non-assistant roles', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + insertMessage(db, 'msg-1', 'sess-1', 1700000001000, { + role: 'system', modelID: 'claude-opus-4-6', + tokens: { input: 100, output: 200, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + expect(calls).toHaveLength(0) + }) + + it('returns empty for invalid db path', async () => { + const provider = createOpenCodeProvider(tmpDir) + const source = { path: '/nonexistent/db.db:sess-1', project: 'test', provider: 'opencode' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) calls.push(call) + expect(calls).toHaveLength(0) + }) + + it('tracks user messages per assistant response', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + + insertMessage(db, 'msg-u1', 'sess-1', 1700000000000, { role: 'user' }) + insertPart(db, 'part-u1', 'msg-u1', 'sess-1', { type: 'text', text: 'first question' }) + + insertMessage(db, 'msg-a1', 'sess-1', 1700000001000, { + role: 'assistant', modelID: 'claude-opus-4-6', cost: 0.01, + tokens: { input: 50, output: 50, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + + insertMessage(db, 'msg-u2', 'sess-1', 1700000002000, { role: 'user' }) + insertPart(db, 'part-u2', 'msg-u2', 'sess-1', { type: 'text', text: 'second question' }) + + insertMessage(db, 'msg-a2', 'sess-1', 1700000003000, { + role: 'assistant', modelID: 'claude-opus-4-6', cost: 0.02, + tokens: { input: 80, output: 80, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + expect(calls).toHaveLength(2) + expect(calls[0]!.userMessage).toBe('first question') + expect(calls[1]!.userMessage).toBe('second question') + }) + + it('attributes child and grandchild session calls back to the root session', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'root') + insertSession(db, 'child', { parentId: 'root' }) + insertSession(db, 'grandchild', { parentId: 'child' }) + + insertMessage(db, 'msg-root-user', 'root', 1700000000000, { role: 'user' }) + insertPart(db, 'part-root-user', 'msg-root-user', 'root', { type: 'text', text: 'root prompt' }) + insertMessage(db, 'msg-root-assistant', 'root', 1700000001000, { + role: 'assistant', + modelID: 'claude-opus-4-6', + cost: 0.01, + tokens: { input: 10, output: 20, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + insertPart(db, 'part-root-tool', 'msg-root-assistant', 'root', { + type: 'tool', + tool: 'read', + state: { status: 'completed', input: {} }, + }) + + insertMessage(db, 'msg-child-user', 'child', 1700000002000, { role: 'user' }) + insertPart(db, 'part-child-user', 'msg-child-user', 'child', { type: 'text', text: 'child prompt' }) + insertMessage(db, 'msg-child-assistant', 'child', 1700000003000, { + role: 'assistant', + modelID: 'claude-opus-4-6', + cost: 0.02, + tokens: { input: 30, output: 40, reasoning: 5, cache: { read: 0, write: 0 } }, + }) + insertPart(db, 'part-child-tool', 'msg-child-assistant', 'child', { + type: 'tool', + tool: 'task', + state: { status: 'completed', input: {} }, + }) + + insertMessage(db, 'msg-grand-user', 'grandchild', 1700000004000, { role: 'user' }) + insertPart(db, 'part-grand-user', 'msg-grand-user', 'grandchild', { type: 'text', text: 'grandchild prompt' }) + insertMessage(db, 'msg-grand-assistant', 'grandchild', 1700000005000, { + role: 'assistant', + modelID: 'claude-opus-4-6', + cost: 0.03, + tokens: { input: 50, output: 60, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + insertPart(db, 'part-grand-tool', 'msg-grand-assistant', 'grandchild', { + type: 'tool', + tool: 'bash', + state: { status: 'completed', input: { command: 'npm test' } }, + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'root') + + expect(calls).toHaveLength(3) + expect(calls.map(call => call.sessionId)).toEqual(['root', 'root', 'root']) + expect(calls.map(call => call.deduplicationKey)).toEqual([ + 'opencode:root:msg-root-assistant', + 'opencode:child:msg-child-assistant', + 'opencode:grandchild:msg-grand-assistant', + ]) + expect(calls.map(call => call.userMessage)).toEqual([ + 'root prompt', + 'child prompt', + 'grandchild prompt', + ]) + expect(calls[0]!.tools).toEqual(['Read']) + expect(calls[1]!.tools).toEqual(['Agent']) + expect(calls[2]!.tools).toEqual(['Bash']) + expect(calls[2]!.bashCommands).toEqual(['npm']) + }) + + it('does not include archived child sessions in the root subtree', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'root') + insertSession(db, 'archived-child', { parentId: 'root', archived: 1700000002500 }) + + insertMessage(db, 'msg-root-assistant', 'root', 1700000001000, { + role: 'assistant', + modelID: 'claude-opus-4-6', + cost: 0.01, + tokens: { input: 10, output: 20, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + + insertMessage(db, 'msg-child-assistant', 'archived-child', 1700000003000, { + role: 'assistant', + modelID: 'claude-opus-4-6', + cost: 0.02, + tokens: { input: 30, output: 40, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'root') + + expect(calls).toHaveLength(1) + expect(calls[0]!.deduplicationKey).toBe('opencode:root:msg-root-assistant') + }) + + it('joins multiple text parts in user messages', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + + insertMessage(db, 'msg-u1', 'sess-1', 1700000000000, { role: 'user' }) + insertPart(db, 'part-a', 'msg-u1', 'sess-1', { type: 'text', text: 'hello' }) + insertPart(db, 'part-b', 'msg-u1', 'sess-1', { type: 'text', text: 'world' }) + + insertMessage(db, 'msg-a1', 'sess-1', 1700000001000, { + role: 'assistant', modelID: 'claude-opus-4-6', cost: 0.01, + tokens: { input: 50, output: 50, reasoning: 0, cache: { read: 0, write: 0 } }, + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + expect(calls[0]!.userMessage).toBe('hello world') + }) + + it('yields nothing for session with only user messages', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + insertMessage(db, 'msg-u1', 'sess-1', 1700000000000, { role: 'user' }) + insertPart(db, 'part-u1', 'msg-u1', 'sess-1', { type: 'text', text: 'hello?' }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + expect(calls).toHaveLength(0) + }) + + it('falls back to session-level tokens when per-message data yields nothing', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + db.exec(`ALTER TABLE session ADD COLUMN cost REAL`) + db.exec(`ALTER TABLE session ADD COLUMN tokens_input INTEGER`) + db.exec(`ALTER TABLE session ADD COLUMN tokens_output INTEGER`) + db.exec(`ALTER TABLE session ADD COLUMN tokens_reasoning INTEGER`) + db.exec(`ALTER TABLE session ADD COLUMN tokens_cache_read INTEGER`) + db.exec(`ALTER TABLE session ADD COLUMN tokens_cache_write INTEGER`) + db.exec(`ALTER TABLE session ADD COLUMN model_id TEXT`) + + insertSession(db, 'sess-1') + db.prepare(`UPDATE session SET cost = 0.15, tokens_input = 5000, tokens_output = 2000, tokens_reasoning = 0, tokens_cache_read = 3000, tokens_cache_write = 1000, model_id = 'claude-sonnet-4-20250514' WHERE id = 'sess-1'`).run() + + insertMessage(db, 'msg-1', 'sess-1', 1700000001000, { + role: 'assistant', modelID: 'claude-sonnet-4-20250514', + }) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + expect(calls).toHaveLength(1) + expect(calls[0]!.inputTokens).toBe(5000) + expect(calls[0]!.outputTokens).toBe(2000) + expect(calls[0]!.cacheReadInputTokens).toBe(3000) + expect(calls[0]!.cacheCreationInputTokens).toBe(1000) + expect(calls[0]!.costUSD).toBeGreaterThan(0) + expect(calls[0]!.model).toBe('claude-sonnet-4-20250514') + expect(calls[0]!.deduplicationKey).toBe('opencode:sess-1:session-level') + }) + + it('accepts role "model" as equivalent to "assistant"', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + insertMessage(db, 'msg-1', 'sess-1', 1700000001000, { + role: 'model', modelID: 'gemini-2.5-pro', cost: 0.03, + tokens: { input: 100, output: 200, reasoning: 0, cache: { read: 0, write: 0 } }, + } as any) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe('gemini-2.5-pro') + }) + + it('recognizes tool-call and tool_call part types', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + insertMessage(db, 'msg-1', 'sess-1', 1700000001000, { + role: 'assistant', modelID: 'claude-opus-4-6', + }) + insertPart(db, 'part-1', 'msg-1', 'sess-1', { + type: 'tool-call', tool: 'bash', + state: { status: 'completed', input: { command: 'ls' } }, + } as any) + insertPart(db, 'part-2', 'msg-1', 'sess-1', { + type: 'tool_call', tool: 'edit', + state: { status: 'completed', input: {} }, + } as any) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + expect(calls).toHaveLength(1) + expect(calls[0]!.tools).toEqual(['Bash', 'Edit']) + }) + + it('counts reasoning/file parts as activity even without text or tool parts', async () => { + const dbPath = createTestDb(tmpDir) + withTestDb(dbPath, (db) => { + insertSession(db, 'sess-1') + insertMessage(db, 'msg-1', 'sess-1', 1700000001000, { + role: 'assistant', modelID: 'claude-opus-4-6', + }) + insertPart(db, 'part-1', 'msg-1', 'sess-1', { + type: 'reasoning', + } as any) + }) + + const calls = await collectCalls(createOpenCodeProvider(tmpDir), dbPath, 'sess-1') + expect(calls).toHaveLength(1) + expect(calls[0]!.costUSD).toBe(0) + expect(calls[0]!.tools).toEqual([]) + }) +}) diff --git a/tests/providers/pi.test.ts b/tests/providers/pi.test.ts new file mode 100644 index 0000000..398d509 --- /dev/null +++ b/tests/providers/pi.test.ts @@ -0,0 +1,514 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { createPiProvider } from '../../src/providers/pi.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' +import { classifyTurn } from '../../src/classifier.js' +import type { ParsedApiCall, ParsedTurn } from '../../src/types.js' + +// Mirrors src/parser.ts providerCallToTurn so we can assert that a Pi call's +// skills survive the classifier into `subCategory`, which is the sole input the +// session summary reads to build the "Skills & Agents" breakdown (#588). +function turnFromPiCall(call: ParsedProviderCall, userMessage = ''): ParsedTurn { + const apiCall: ParsedApiCall = { + provider: call.provider, + model: call.model, + usage: { + inputTokens: call.inputTokens, + outputTokens: call.outputTokens, + cacheCreationInputTokens: call.cacheCreationInputTokens, + cacheReadInputTokens: call.cacheReadInputTokens, + cachedInputTokens: call.cachedInputTokens, + reasoningTokens: call.reasoningTokens, + webSearchRequests: call.webSearchRequests, + }, + costUSD: call.costUSD, + tools: call.tools, + mcpTools: call.tools.filter(t => t.startsWith('mcp__')), + skills: call.skills ?? [], + subagentTypes: call.subagentTypes ?? [], + hasAgentSpawn: call.tools.includes('Agent'), + hasPlanMode: call.tools.includes('EnterPlanMode'), + speed: call.speed, + timestamp: call.timestamp, + bashCommands: call.bashCommands, + deduplicationKey: call.deduplicationKey, + } + return { userMessage, assistantCalls: [apiCall], timestamp: call.timestamp, sessionId: call.sessionId } +} + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'pi-test-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +function sessionMeta(opts: { id?: string; cwd?: string } = {}) { + return JSON.stringify({ + type: 'session', + version: 3, + id: opts.id ?? 'sess-001', + timestamp: '2026-04-14T10:00:00.000Z', + cwd: opts.cwd ?? '/Users/test/myproject', + }) +} + +function userMessage(text: string, timestamp?: string) { + return JSON.stringify({ + type: 'message', + id: 'msg-user-1', + timestamp: timestamp ?? '2026-04-14T10:00:10.000Z', + message: { + role: 'user', + content: [{ type: 'text', text }], + timestamp: 1776023210000, + }, + }) +} + +function assistantMessage(opts: { + id?: string + responseId?: string + timestamp?: string + model?: string + input?: number + output?: number + cacheRead?: number + cacheWrite?: number + tools?: Array<{ name: string; command?: string; path?: string; filePath?: string }> +}) { + const content = (opts.tools ?? []).map(t => { + const args: Record<string, unknown> = {} + if (t.command !== undefined) args['command'] = t.command + if (t.path !== undefined) args['path'] = t.path + if (t.filePath !== undefined) args['file_path'] = t.filePath + return { + type: 'toolCall', + id: `call-${t.name}`, + name: t.name, + arguments: args, + } + }) + + return JSON.stringify({ + type: 'message', + id: opts.id ?? 'msg-asst-1', + timestamp: opts.timestamp ?? '2026-04-14T10:00:30.000Z', + message: { + role: 'assistant', + content, + api: 'openai-codex-responses', + provider: 'openai-codex', + model: opts.model ?? 'gpt-5.4', + responseId: opts.responseId ?? 'resp-001', + usage: { + input: opts.input ?? 1000, + output: opts.output ?? 200, + cacheRead: opts.cacheRead ?? 0, + cacheWrite: opts.cacheWrite ?? 0, + totalTokens: (opts.input ?? 1000) + (opts.output ?? 200) + (opts.cacheRead ?? 0), + cost: { input: 0.0025, output: 0.003, cacheRead: 0, cacheWrite: 0, total: 0.0055 }, + }, + stopReason: 'stop', + timestamp: 1776023230000, + }, + }) +} + +async function writeSession(projectDir: string, filename: string, lines: string[]) { + await mkdir(projectDir, { recursive: true }) + const filePath = join(projectDir, filename) + await writeFile(filePath, lines.join('\n') + '\n') + return filePath +} + +describe('pi provider - session discovery', () => { + it('discovers sessions grouped by project directory', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + await writeSession(projectDir, '2026-04-14T10-00-00-000Z_sess-001.jsonl', [ + sessionMeta({ cwd: '/Users/test/myproject' }), + assistantMessage({}), + ]) + + const provider = createPiProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]!.provider).toBe('pi') + expect(sessions[0]!.project).toBe('myproject') + expect(sessions[0]!.path).toContain('sess-001.jsonl') + }) + + it('discovers sessions across multiple project directories', async () => { + const dir1 = join(tmpDir, '--Users-test-project-a--') + const dir2 = join(tmpDir, '--Users-test-project-b--') + await writeSession(dir1, 'session1.jsonl', [sessionMeta({ cwd: '/Users/test/project-a' }), assistantMessage({})]) + await writeSession(dir2, 'session2.jsonl', [sessionMeta({ cwd: '/Users/test/project-b' }), assistantMessage({})]) + + const provider = createPiProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(2) + const projects = sessions.map(s => s.project).sort() + expect(projects).toEqual(['project-a', 'project-b']) + }) + + it('returns empty for non-existent directory', async () => { + const provider = createPiProvider('/nonexistent/path/that/does/not/exist') + const sessions = await provider.discoverSessions() + expect(sessions).toEqual([]) + }) + + it('skips files whose first line is not a session entry', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + await writeSession(projectDir, 'bad.jsonl', [ + JSON.stringify({ type: 'message', id: 'x' }), + ]) + + const provider = createPiProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toEqual([]) + }) + + it('skips non-jsonl files', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + await mkdir(projectDir, { recursive: true }) + await writeFile(join(projectDir, 'notes.txt'), 'not a session') + + const provider = createPiProvider(tmpDir) + const sessions = await provider.discoverSessions() + expect(sessions).toEqual([]) + }) +}) + +describe('pi provider - JSONL parsing', () => { + it('extracts token usage and metadata from an assistant message', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + const filePath = await writeSession(projectDir, 'session.jsonl', [ + sessionMeta({ id: 'sess-abc', cwd: '/Users/test/myproject' }), + userMessage('implement the feature'), + assistantMessage({ + responseId: 'resp-abc', + timestamp: '2026-04-14T10:00:30.000Z', + model: 'gpt-5.4', + input: 2000, + output: 400, + cacheRead: 5000, + cacheWrite: 100, + }), + ]) + + const provider = createPiProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'pi' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.provider).toBe('pi') + expect(call.model).toBe('gpt-5.4') + expect(call.inputTokens).toBe(2000) + expect(call.outputTokens).toBe(400) + expect(call.cacheReadInputTokens).toBe(5000) + expect(call.cachedInputTokens).toBe(5000) + expect(call.cacheCreationInputTokens).toBe(100) + expect(call.sessionId).toBe('sess-abc') + expect(call.userMessage).toBe('implement the feature') + expect(call.timestamp).toBe('2026-04-14T10:00:30.000Z') + expect(call.costUSD).toBeGreaterThan(0) + expect(call.deduplicationKey).toContain('pi:') + expect(call.deduplicationKey).toContain('resp-abc') + }) + + it('does not crash when a user message content is a string instead of an array (issue #441)', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + // Pi legitimately writes string `content` for some (e.g. injected) user turns. + // Before the fix this threw `content.filter is not a function`, which aborted + // the whole backfill and silently emptied the trend/history. + const stringContentUser = JSON.stringify({ + type: 'message', + id: 'msg-user-str', + timestamp: '2026-04-14T10:00:10.000Z', + message: { role: 'user', content: 'test message from file watcher', timestamp: 1776023210000 }, + }) + const filePath = await writeSession(projectDir, 'session.jsonl', [ + sessionMeta({ id: 'sess-str', cwd: '/Users/test/myproject' }), + stringContentUser, + assistantMessage({ responseId: 'resp-str', input: 500, output: 80 }), + ]) + + const provider = createPiProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'pi' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + // The assistant turn is still parsed, and the string user content is paired. + expect(calls).toHaveLength(1) + expect(calls[0]!.inputTokens).toBe(500) + expect(calls[0]!.userMessage).toBe('test message from file watcher') + }) + + it('collects tool names from toolCall content items', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + const filePath = await writeSession(projectDir, 'session.jsonl', [ + sessionMeta(), + assistantMessage({ + tools: [ + { name: 'read' }, + { name: 'edit' }, + { name: 'bash', command: 'git status' }, + ], + }), + ]) + + const provider = createPiProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'pi' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls[0]!.tools).toEqual(['Read', 'Edit', 'Bash']) + }) + + it('extracts bash commands from bash tool arguments', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + const filePath = await writeSession(projectDir, 'session.jsonl', [ + sessionMeta(), + assistantMessage({ + tools: [ + { name: 'bash', command: 'git status && bun test' }, + ], + }), + ]) + + const provider = createPiProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'pi' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls[0]!.bashCommands).toEqual(['git', 'bun']) + }) + + it('classifies a SKILL.md read as a skill load, not a Read (#588)', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + const filePath = await writeSession(projectDir, 'session.jsonl', [ + sessionMeta(), + assistantMessage({ + tools: [ + { name: 'read', path: '/Volumes/T7/repos/cuneiform/.pi/skills/bmad-create-story/SKILL.md' }, + { name: 'read', path: '/Volumes/T7/repos/cuneiform/workflow.md' }, + { name: 'edit', path: '/Volumes/T7/repos/cuneiform/workflow.md' }, + ], + }), + ]) + + const provider = createPiProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'pi' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + // The SKILL.md read is surfaced as the Skill tool (not Read); the plain + // read stays a Read. + expect(calls[0]!.skills).toEqual(['bmad-create-story']) + expect(calls[0]!.tools).toEqual(['Skill', 'Read', 'Edit']) + }) + + it('classifies a skill:// read as a skill load (OMP-style URI)', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + const filePath = await writeSession(projectDir, 'session.jsonl', [ + sessionMeta(), + assistantMessage({ + tools: [{ name: 'read', path: 'skill://commit-workflow' }], + }), + ]) + + const provider = createPiProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'pi' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls[0]!.skills).toEqual(['commit-workflow']) + expect(calls[0]!.tools).toEqual(['Skill']) + }) + + it('reads the file_path key as a fallback for skill loads', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + const filePath = await writeSession(projectDir, 'session.jsonl', [ + sessionMeta(), + assistantMessage({ + tools: [{ name: 'read', filePath: '/home/u/.agents/skills/deep-research/SKILL.md' }], + }), + ]) + + const provider = createPiProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'pi' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls[0]!.skills).toEqual(['deep-research']) + expect(calls[0]!.tools).toEqual(['Skill']) + }) + + it('leaves a normal read (no SKILL.md) as a Read with no skills', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + const filePath = await writeSession(projectDir, 'session.jsonl', [ + sessionMeta(), + assistantMessage({ + tools: [{ name: 'read', path: '/home/u/project/src/skill-loader.ts' }], + }), + ]) + + const provider = createPiProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'pi' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls[0]!.skills).toEqual([]) + expect(calls[0]!.tools).toEqual(['Read']) + }) + + it('a pure skill-load turn classifies as general with the skill as subCategory (feeds the Skills breakdown, #588)', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + const filePath = await writeSession(projectDir, 'session.jsonl', [ + sessionMeta(), + assistantMessage({ + tools: [{ name: 'read', path: '/home/u/.pi/agent/skills/systematic-debugging/SKILL.md' }], + }), + ]) + + const provider = createPiProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'pi' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + // End to end: the parsed skill load must reach `subCategory`, or the + // Skills & Agents breakdown stays empty (the second half of #588). + const classified = classifyTurn(turnFromPiCall(calls[0]!)) + expect(classified.category).toBe('general') + expect(classified.subCategory).toBe('systematic-debugging') + }) + + it('skips assistant messages with zero tokens', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + const filePath = await writeSession(projectDir, 'session.jsonl', [ + sessionMeta(), + assistantMessage({ input: 0, output: 0 }), + ]) + + const provider = createPiProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'pi' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(0) + }) + + it('deduplicates calls seen across multiple parses', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + const filePath = await writeSession(projectDir, 'session.jsonl', [ + sessionMeta(), + assistantMessage({ responseId: 'resp-dup' }), + ]) + + const provider = createPiProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'pi' } + const seenKeys = new Set<string>() + + const firstRun: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, seenKeys).parse()) { + firstRun.push(call) + } + + const secondRun: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, seenKeys).parse()) { + secondRun.push(call) + } + + expect(firstRun).toHaveLength(1) + expect(secondRun).toHaveLength(0) + }) + + it('yields one call per assistant message in a multi-turn session', async () => { + const projectDir = join(tmpDir, '--Users-test-myproject--') + const filePath = await writeSession(projectDir, 'session.jsonl', [ + sessionMeta({ id: 'sess-multi' }), + userMessage('first question'), + assistantMessage({ responseId: 'resp-1', timestamp: '2026-04-14T10:00:30.000Z', input: 500, output: 100 }), + userMessage('second question'), + assistantMessage({ responseId: 'resp-2', timestamp: '2026-04-14T10:01:00.000Z', input: 600, output: 120 }), + ]) + + const provider = createPiProvider(tmpDir) + const source = { path: filePath, project: 'myproject', provider: 'pi' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + + expect(calls).toHaveLength(2) + expect(calls[0]!.userMessage).toBe('first question') + expect(calls[0]!.inputTokens).toBe(500) + expect(calls[1]!.userMessage).toBe('second question') + expect(calls[1]!.inputTokens).toBe(600) + }) + + it('handles missing session file gracefully', async () => { + const provider = createPiProvider(tmpDir) + const source = { path: '/nonexistent/session.jsonl', project: 'test', provider: 'pi' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, new Set()).parse()) { + calls.push(call) + } + expect(calls).toHaveLength(0) + }) +}) + +describe('pi provider - display names', () => { + const provider = createPiProvider('/tmp') + + it('has correct name and displayName', () => { + expect(provider.name).toBe('pi') + expect(provider.displayName).toBe('Pi') + }) + + it('maps known models to readable names', () => { + expect(provider.modelDisplayName('gpt-5.4')).toBe('GPT-5.4') + expect(provider.modelDisplayName('gpt-5.4-mini')).toBe('GPT-5.4 Mini') + expect(provider.modelDisplayName('gpt-5')).toBe('GPT-5') + }) + + it('returns raw name for unknown models', () => { + expect(provider.modelDisplayName('some-future-model')).toBe('some-future-model') + }) + + it('normalizes tool names to capitalized form', () => { + expect(provider.toolDisplayName('bash')).toBe('Bash') + expect(provider.toolDisplayName('read')).toBe('Read') + expect(provider.toolDisplayName('unknown_tool')).toBe('unknown_tool') + }) +}) diff --git a/tests/providers/roo-code.test.ts b/tests/providers/roo-code.test.ts new file mode 100644 index 0000000..35efee5 --- /dev/null +++ b/tests/providers/roo-code.test.ts @@ -0,0 +1,247 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { rooCode, createRooCodeProvider } from '../../src/providers/roo-code.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +function makeUiMessages(opts: { + tokensIn?: number + tokensOut?: number + cacheReads?: number + cacheWrites?: number + cost?: number + userMessage?: string + ts?: number +}): string { + const messages: unknown[] = [] + + if (opts.userMessage) { + messages.push({ type: 'say', say: 'user_feedback', text: opts.userMessage, ts: 1700000000000 }) + } + + const apiData: Record<string, unknown> = { + tokensIn: opts.tokensIn ?? 100, + tokensOut: opts.tokensOut ?? 50, + cacheReads: opts.cacheReads ?? 0, + cacheWrites: opts.cacheWrites ?? 0, + } + if (opts.cost !== undefined) apiData.cost = opts.cost + + messages.push({ + type: 'say', + say: 'api_req_started', + text: JSON.stringify(apiData), + ts: opts.ts ?? 1700000001000, + }) + + return JSON.stringify(messages) +} + +function makeApiHistory(opts?: { model?: string }): string { + const modelTag = opts?.model ? `<model>${opts.model}</model>` : '' + const messages = [ + { role: 'user', content: [{ type: 'text', text: `hello\n<environment_details>\n${modelTag}\n</environment_details>` }] }, + { role: 'assistant', content: [{ type: 'text', text: 'response' }] }, + ] + return JSON.stringify(messages) +} + +describe('roo-code provider - parsing', () => { + beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'roo-code-test-')) + }) + + afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) + }) + + it('parses tokens and cost from ui_messages.json', async () => { + const taskDir = join(tmpDir, 'tasks', 'task-001') + await mkdir(taskDir, { recursive: true }) + await writeFile(join(taskDir, 'ui_messages.json'), makeUiMessages({ + tokensIn: 200, + tokensOut: 100, + cacheReads: 50, + cacheWrites: 30, + cost: 0.05, + userMessage: 'fix the bug', + })) + await writeFile(join(taskDir, 'api_conversation_history.json'), makeApiHistory()) + + const source = { path: taskDir, project: 'task-001', provider: 'roo-code' } + const calls: ParsedProviderCall[] = [] + for await (const call of rooCode.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.provider).toBe('roo-code') + expect(call.inputTokens).toBe(200) + expect(call.outputTokens).toBe(100) + expect(call.cacheReadInputTokens).toBe(50) + expect(call.cacheCreationInputTokens).toBe(30) + expect(call.costUSD).toBe(0.05) + expect(call.userMessage).toBe('fix the bug') + expect(call.sessionId).toBe('task-001') + }) + + it('extracts model from api_conversation_history.json', async () => { + const taskDir = join(tmpDir, 'tasks', 'task-002') + await mkdir(taskDir, { recursive: true }) + await writeFile(join(taskDir, 'ui_messages.json'), makeUiMessages({ tokensIn: 100, tokensOut: 50 })) + await writeFile(join(taskDir, 'api_conversation_history.json'), makeApiHistory({ model: 'claude-sonnet-4-5' })) + + const source = { path: taskDir, project: 'task-002', provider: 'roo-code' } + const calls: ParsedProviderCall[] = [] + for await (const call of rooCode.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe('claude-sonnet-4-5') + }) + + it('falls back to cline-auto when no model indicators', async () => { + const taskDir = join(tmpDir, 'tasks', 'task-003') + await mkdir(taskDir, { recursive: true }) + await writeFile(join(taskDir, 'ui_messages.json'), makeUiMessages({ tokensIn: 100, tokensOut: 50 })) + await writeFile(join(taskDir, 'api_conversation_history.json'), JSON.stringify([ + { role: 'user', content: [{ type: 'text', text: 'hello' }] }, + { role: 'assistant', content: [{ type: 'text', text: 'hi' }] }, + ])) + + const source = { path: taskDir, project: 'task-003', provider: 'roo-code' } + const calls: ParsedProviderCall[] = [] + for await (const call of rooCode.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.model).toBe('cline-auto') + }) + + it('deduplicates across parser runs', async () => { + const taskDir = join(tmpDir, 'tasks', 'task-004') + await mkdir(taskDir, { recursive: true }) + await writeFile(join(taskDir, 'ui_messages.json'), makeUiMessages({ tokensIn: 100, tokensOut: 50 })) + + const source = { path: taskDir, project: 'task-004', provider: 'roo-code' } + const seenKeys = new Set<string>() + + const calls1: ParsedProviderCall[] = [] + for await (const call of rooCode.createSessionParser(source, seenKeys).parse()) calls1.push(call) + + const calls2: ParsedProviderCall[] = [] + for await (const call of rooCode.createSessionParser(source, seenKeys).parse()) calls2.push(call) + + expect(calls1).toHaveLength(1) + expect(calls2).toHaveLength(0) + }) + + it('handles missing ui_messages.json gracefully', async () => { + const taskDir = join(tmpDir, 'tasks', 'task-005') + await mkdir(taskDir, { recursive: true }) + + const source = { path: taskDir, project: 'task-005', provider: 'roo-code' } + const calls: ParsedProviderCall[] = [] + for await (const call of rooCode.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(0) + }) + + it('handles invalid JSON gracefully', async () => { + const taskDir = join(tmpDir, 'tasks', 'task-006') + await mkdir(taskDir, { recursive: true }) + await writeFile(join(taskDir, 'ui_messages.json'), 'not valid json') + + const source = { path: taskDir, project: 'task-006', provider: 'roo-code' } + const calls: ParsedProviderCall[] = [] + for await (const call of rooCode.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(0) + }) + + it('skips entries with zero tokens', async () => { + const taskDir = join(tmpDir, 'tasks', 'task-007') + await mkdir(taskDir, { recursive: true }) + await writeFile(join(taskDir, 'ui_messages.json'), JSON.stringify([ + { type: 'say', say: 'api_req_started', text: JSON.stringify({ tokensIn: 0, tokensOut: 0 }), ts: 1700000000000 }, + ])) + + const source = { path: taskDir, project: 'task-007', provider: 'roo-code' } + const calls: ParsedProviderCall[] = [] + for await (const call of rooCode.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(0) + }) + + it('calculates cost from model when cost field missing', async () => { + const taskDir = join(tmpDir, 'tasks', 'task-008') + await mkdir(taskDir, { recursive: true }) + await writeFile(join(taskDir, 'ui_messages.json'), makeUiMessages({ tokensIn: 1000, tokensOut: 500 })) + await writeFile(join(taskDir, 'api_conversation_history.json'), makeApiHistory()) + + const source = { path: taskDir, project: 'task-008', provider: 'roo-code' } + const calls: ParsedProviderCall[] = [] + for await (const call of rooCode.createSessionParser(source, new Set()).parse()) calls.push(call) + + expect(calls).toHaveLength(1) + expect(calls[0]!.costUSD).toBeGreaterThan(0) + }) +}) + +describe('roo-code provider - discovery', () => { + beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'roo-code-test-')) + }) + + afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) + }) + + it('discovers task directories with ui_messages.json', async () => { + const task1 = join(tmpDir, 'tasks', 'task-a') + const task2 = join(tmpDir, 'tasks', 'task-b') + await mkdir(task1, { recursive: true }) + await mkdir(task2, { recursive: true }) + await writeFile(join(task1, 'ui_messages.json'), '[]') + await writeFile(join(task2, 'ui_messages.json'), '[]') + + const provider = createRooCodeProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(2) + expect(sessions.every(s => s.provider === 'roo-code')).toBe(true) + }) + + it('skips tasks without ui_messages.json', async () => { + const task = join(tmpDir, 'tasks', 'task-no-ui') + await mkdir(task, { recursive: true }) + await writeFile(join(task, 'api_conversation_history.json'), '[]') + + const provider = createRooCodeProvider(tmpDir) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(0) + }) + + it('returns empty for nonexistent directory', async () => { + const provider = createRooCodeProvider('/nonexistent/path') + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(0) + }) +}) + +describe('roo-code provider - metadata', () => { + it('has correct name and displayName', () => { + expect(rooCode.name).toBe('roo-code') + expect(rooCode.displayName).toBe('Roo Code') + }) + + it('passes through model display names', () => { + expect(rooCode.modelDisplayName('claude-sonnet-4-5')).toBe('claude-sonnet-4-5') + }) + + it('passes through tool display names', () => { + expect(rooCode.toolDisplayName('read_file')).toBe('read_file') + }) +}) diff --git a/tests/providers/vercel-gateway.test.ts b/tests/providers/vercel-gateway.test.ts new file mode 100644 index 0000000..856c675 --- /dev/null +++ b/tests/providers/vercel-gateway.test.ts @@ -0,0 +1,117 @@ +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest' +import { mkdtemp, rm } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' +import { fetchVercelGatewayReport, vercelGateway } from '../../src/providers/vercel-gateway.js' +import { parseAllSessions, clearSessionCache } from '../../src/parser.js' + +describe('vercel-gateway provider', () => { + const originalFetch = globalThis.fetch + const originalKey = process.env.AI_GATEWAY_API_KEY + + beforeEach(() => { + process.env.AI_GATEWAY_API_KEY = 'test-key' + }) + + afterEach(() => { + globalThis.fetch = originalFetch + if (originalKey === undefined) delete process.env.AI_GATEWAY_API_KEY + else process.env.AI_GATEWAY_API_KEY = originalKey + vi.restoreAllMocks() + }) + + it('discovers a session when API key is set', async () => { + const sessions = await vercelGateway.discoverSessions() + expect(sessions).toHaveLength(1) + expect(sessions[0]?.provider).toBe('vercel-gateway') + }) + + it('returns empty discovery without API key', async () => { + delete process.env.AI_GATEWAY_API_KEY + delete process.env.VERCEL_OIDC_TOKEN + const sessions = await vercelGateway.discoverSessions() + expect(sessions).toEqual([]) + }) + + it('maps report rows to parsed calls', async () => { + globalThis.fetch = vi.fn(async () => ({ + ok: true, + json: async () => ({ + results: [{ + day: '2026-06-01', + model: 'anthropic/claude-sonnet-4.6', + total_cost: 1.25, + input_tokens: 1000, + output_tokens: 200, + request_count: 3, + }], + }), + })) as typeof fetch + + const range = { + start: new Date('2026-06-01T00:00:00.000Z'), + end: new Date('2026-06-02T23:59:59.999Z'), + } + const rows = await fetchVercelGatewayReport(range) + expect(rows).toHaveLength(1) + + const source = { path: 'vercel-ai-gateway:report', project: 'Vercel AI Gateway', provider: 'vercel-gateway' } + const seen = new Set<string>() + const calls = [] + for await (const call of vercelGateway.createSessionParser(source, seen, range).parse()) { + calls.push(call) + } + expect(calls).toHaveLength(1) + expect(calls[0]?.costUSD).toBe(1.25) + expect(calls[0]?.model).toBe('anthropic/claude-sonnet-4.6') + }) +}) + +describe('vercel-gateway end-to-end (parseAllSessions network path)', () => { + const originalFetch = globalThis.fetch + const originalKey = process.env.AI_GATEWAY_API_KEY + const originalCacheDir = process.env.CODEBURN_CACHE_DIR + let cacheDir: string + + beforeEach(async () => { + cacheDir = await mkdtemp(join(tmpdir(), 'cb-vercel-cache-')) + process.env.CODEBURN_CACHE_DIR = cacheDir + process.env.AI_GATEWAY_API_KEY = 'test-key' + clearSessionCache() + }) + + afterEach(async () => { + globalThis.fetch = originalFetch + if (originalKey === undefined) delete process.env.AI_GATEWAY_API_KEY + else process.env.AI_GATEWAY_API_KEY = originalKey + if (originalCacheDir === undefined) delete process.env.CODEBURN_CACHE_DIR + else process.env.CODEBURN_CACHE_DIR = originalCacheDir + clearSessionCache() + vi.restoreAllMocks() + await rm(cacheDir, { recursive: true, force: true }) + }) + + // Regression: the synthetic source path `vercel-ai-gateway:report` has no file + // on disk, so it was dropped by the fingerprintFile gate in parseProviderSources + // and the provider always reported $0. Network providers must survive that gate + // and contribute their fetched cost through the real aggregation pipeline. + it('network source survives the fingerprint gate and contributes cost', async () => { + globalThis.fetch = vi.fn(async () => ({ + ok: true, + json: async () => ({ + results: [ + { day: '2026-06-01', model: 'openai/gpt-4o', total_cost: 12.34, input_tokens: 1000, output_tokens: 500, request_count: 3 }, + ], + }), + })) as typeof fetch + + const range = { + start: new Date('2026-05-01T00:00:00.000Z'), + end: new Date('2026-06-09T23:59:59.999Z'), + } + const projects = await parseAllSessions(range, 'vercel-gateway') + const total = projects.reduce((sum, p) => sum + p.totalCostUSD, 0) + + expect(total).toBeCloseTo(12.34, 2) + }) +}) diff --git a/tests/providers/vscode-cline-parser.test.ts b/tests/providers/vscode-cline-parser.test.ts new file mode 100644 index 0000000..b250b0c --- /dev/null +++ b/tests/providers/vscode-cline-parser.test.ts @@ -0,0 +1,58 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm } from 'fs/promises' +import { join, posix, win32 } from 'path' +import { tmpdir } from 'os' + +import { discoverClineTasks, getVSCodeGlobalStoragePaths } from '../../src/providers/vscode-cline-parser.js' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'vscode-cline-parser-test-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +async function writeTask(baseDir: string, taskId: string): Promise<void> { + const taskDir = join(baseDir, 'tasks', taskId) + await mkdir(taskDir, { recursive: true }) + await writeFile(join(taskDir, 'ui_messages.json'), '[]') +} + +describe('VS Code Cline-family storage discovery', () => { + it('includes VSCodium globalStorage paths on all supported platforms', () => { + const extensionId = 'example.extension' + + expect(getVSCodeGlobalStoragePaths(extensionId, '/Users/test', 'darwin')).toContain( + posix.join('/Users/test', 'Library', 'Application Support', 'VSCodium', 'User', 'globalStorage', extensionId), + ) + expect(getVSCodeGlobalStoragePaths(extensionId, 'C:\\Users\\test', 'win32')).toContain( + win32.join('C:\\Users\\test', 'AppData', 'Roaming', 'VSCodium', 'User', 'globalStorage', extensionId), + ) + expect(getVSCodeGlobalStoragePaths(extensionId, '/home/test', 'linux')).toContain( + posix.join('/home/test', '.config', 'VSCodium', 'User', 'globalStorage', extensionId), + ) + }) + + it('discovers tasks across multiple VS Code-compatible storage roots', async () => { + const codeRoot = join(tmpDir, 'Code', 'User', 'globalStorage', 'example.extension') + const codiumRoot = join(tmpDir, 'VSCodium', 'User', 'globalStorage', 'example.extension') + await writeTask(codeRoot, 'task-code') + await writeTask(codiumRoot, 'task-codium') + + const sessions = await discoverClineTasks( + 'example.extension', + 'example-provider', + 'Example Provider', + [codeRoot, codiumRoot], + ) + + expect(sessions).toHaveLength(2) + expect(sessions.map(s => s.path).sort()).toEqual([ + join(codeRoot, 'tasks', 'task-code'), + join(codiumRoot, 'tasks', 'task-codium'), + ].sort()) + }) +}) diff --git a/tests/providers/warp.test.ts b/tests/providers/warp.test.ts new file mode 100644 index 0000000..433a4f0 --- /dev/null +++ b/tests/providers/warp.test.ts @@ -0,0 +1,358 @@ +import { mkdtemp, rm } from 'fs/promises' +import { mkdirSync } from 'fs' +import { join } from 'path' +import { tmpdir } from 'os' +import { createRequire } from 'node:module' + +import { afterEach, beforeEach, describe, expect, it } from 'vitest' +import { createWarpProvider } from '../../src/providers/warp.js' +import { isSqliteAvailable } from '../../src/sqlite.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +const requireForTest = createRequire(import.meta.url) + +type TestDb = { + exec(sql: string): void + prepare(sql: string): { run(...params: unknown[]): void } + close(): void +} + +type QueryFixture = { + exchangeId: string + conversationId: string + startTs: string + input: string + outputStatus?: string + modelId?: string + workingDirectory?: string | null +} + +type BlockFixture = { + blockId: string + conversationId: string + startTs: string + completedTs: string + exitCode: number + command: string +} + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'warp-provider-test-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +function createWarpDb(dir: string): string { + mkdirSync(dir, { recursive: true }) + const dbPath = join(dir, 'warp.sqlite') + const { DatabaseSync: Database } = requireForTest('node:sqlite') + const db = new Database(dbPath) + db.exec(` + CREATE TABLE IF NOT EXISTS agent_conversations ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + conversation_id TEXT NOT NULL, + conversation_data TEXT NOT NULL, + last_modified_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP + ) + `) + db.exec(` + CREATE TABLE IF NOT EXISTS ai_queries ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + exchange_id TEXT NOT NULL, + conversation_id TEXT NOT NULL, + start_ts DATETIME NOT NULL, + input TEXT NOT NULL, + working_directory TEXT, + output_status TEXT NOT NULL, + model_id TEXT NOT NULL DEFAULT '', + planning_model_id TEXT NOT NULL DEFAULT '', + coding_model_id TEXT NOT NULL DEFAULT '' + ) + `) + db.exec(` + CREATE TABLE IF NOT EXISTS blocks ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + pane_leaf_uuid BLOB NOT NULL, + stylized_command BLOB NOT NULL, + stylized_output BLOB NOT NULL, + pwd TEXT, + git_branch TEXT, + virtual_env TEXT, + conda_env TEXT, + exit_code INTEGER NOT NULL, + did_execute BOOLEAN NOT NULL, + completed_ts DATETIME, + start_ts DATETIME, + ps1 TEXT, + honor_ps1 BOOLEAN NOT NULL DEFAULT 0, + shell TEXT, + user TEXT, + host TEXT, + is_background BOOLEAN NOT NULL DEFAULT 0, + rprompt TEXT, + prompt_snapshot TEXT, + block_id TEXT NOT NULL DEFAULT '', + ai_metadata TEXT, + is_local BOOLEAN, + agent_view_visibility TEXT, + git_branch_name TEXT + ) + `) + db.close() + return dbPath +} + +function withTestDb(dbPath: string, fn: (db: TestDb) => void): void { + const { DatabaseSync: Database } = requireForTest('node:sqlite') + const db = new Database(dbPath) + try { + fn(db) + } finally { + db.close() + } +} + +function insertConversation( + db: TestDb, + conversationId: string, + conversationData: unknown, + lastModifiedAt = '2026-05-18 10:10:00', +): void { + db.prepare( + 'INSERT INTO agent_conversations (conversation_id, conversation_data, last_modified_at) VALUES (?, ?, ?)', + ).run(conversationId, JSON.stringify(conversationData), lastModifiedAt) +} + +function insertQuery(db: TestDb, q: QueryFixture): void { + db.prepare( + `INSERT INTO ai_queries ( + exchange_id, conversation_id, start_ts, input, working_directory, output_status, model_id, planning_model_id, coding_model_id + ) VALUES (?, ?, ?, ?, ?, ?, ?, '', '')`, + ).run( + q.exchangeId, + q.conversationId, + q.startTs, + q.input, + q.workingDirectory ?? null, + q.outputStatus ?? '"Completed"', + q.modelId ?? 'auto-efficient', + ) +} + +function insertBlock(db: TestDb, b: BlockFixture): void { + db.prepare( + `INSERT INTO blocks ( + pane_leaf_uuid, stylized_command, stylized_output, exit_code, did_execute, + completed_ts, start_ts, block_id, ai_metadata + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, + ).run( + Buffer.from([0]), + b.command, + '', + b.exitCode, + 1, + b.completedTs, + b.startTs, + b.blockId, + JSON.stringify({ + requested_command_action_id: `call-${b.blockId}`, + conversation_id: b.conversationId, + }), + ) +} + +async function collectCalls( + dbPath: string, + conversationId: string, + seenKeys = new Set<string>(), +): Promise<ParsedProviderCall[]> { + const provider = createWarpProvider(dbPath) + const source = { + path: `${dbPath}:${conversationId}`, + project: 'warp', + provider: 'warp', + } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, seenKeys).parse()) { + calls.push(call) + } + return calls +} + +const skipUnlessSqlite = isSqliteAvailable() ? describe : describe.skip + +skipUnlessSqlite('warp provider', () => { + it('discovers sessions and sanitizes project names from working_directory', async () => { + const dbPath = createWarpDb(tmpDir) + withTestDb(dbPath, (db) => { + insertConversation(db, 'conv-1', { conversation_usage_metadata: { token_usage: [] } }) + insertQuery(db, { + exchangeId: 'ex-1', + conversationId: 'conv-1', + startTs: '2026-05-18 10:00:00.000000', + input: '[]', + workingDirectory: '/Users/test/project-a', + }) + }) + + const provider = createWarpProvider(dbPath) + const sessions = await provider.discoverSessions() + expect(sessions).toHaveLength(1) + expect(sessions[0]!.provider).toBe('warp') + expect(sessions[0]!.path).toBe(`${dbPath}:conv-1`) + expect(sessions[0]!.project).toBe('Users-test-project-a') + }) + + it('parses one call per completed exchange and estimates tokens from primary-agent totals', async () => { + const dbPath = createWarpDb(tmpDir) + withTestDb(dbPath, (db) => { + insertConversation(db, 'conv-1', { + conversation_usage_metadata: { + token_usage: [ + { + model_id: 'GPT-5.3 Codex (medium reasoning)', + warp_tokens: 300, + byok_tokens: 0, + warp_token_usage_by_category: { primary_agent: 300 }, + byok_token_usage_by_category: {}, + }, + { + model_id: 'Claude Haiku 4.5', + warp_tokens: 90, + byok_tokens: 0, + warp_token_usage_by_category: { full_terminal_use: 90 }, + byok_token_usage_by_category: {}, + }, + ], + }, + }) + insertQuery(db, { + exchangeId: 'ex-1', + conversationId: 'conv-1', + startTs: '2026-05-18 10:00:00.000000', + input: JSON.stringify([{ Query: { text: 'short prompt' } }]), + modelId: 'auto-efficient', + workingDirectory: '/Users/test/project-a', + }) + insertQuery(db, { + exchangeId: 'ex-2', + conversationId: 'conv-1', + startTs: '2026-05-18 10:03:00.000000', + input: JSON.stringify([{ Query: { text: 'longer prompt with substantially more detail for weighting' } }]), + modelId: 'auto-efficient', + workingDirectory: '/Users/test/project-a', + }) + }) + + const calls = await collectCalls(dbPath, 'conv-1') + expect(calls).toHaveLength(2) + expect(calls.map(call => call.deduplicationKey)).toEqual([ + 'warp:conv-1:ex-1', + 'warp:conv-1:ex-2', + ]) + expect(calls.map(call => call.userMessage)).toEqual([ + 'short prompt', + 'longer prompt with substantially more detail for weighting', + ]) + expect(calls.every(call => call.model === 'gpt-5.3-codex')).toBe(true) + expect(calls.every(call => call.costIsEstimated === true)).toBe(true) + expect(calls.reduce((sum, call) => sum + call.inputTokens, 0)).toBe(300) + expect(calls[1]!.inputTokens).toBeGreaterThan(calls[0]!.inputTokens) + expect(calls[0]!.projectPath).toBe('/Users/test/project-a') + expect(calls[0]!.project).toBe('Users-test-project-a') + }) + + it('attributes command blocks to the nearest preceding exchange and extracts Bash commands', async () => { + const dbPath = createWarpDb(tmpDir) + withTestDb(dbPath, (db) => { + insertConversation(db, 'conv-2', { + conversation_usage_metadata: { + token_usage: [ + { + model_id: 'GPT-5.3 Codex (medium reasoning)', + warp_tokens: 120, + byok_tokens: 0, + warp_token_usage_by_category: { primary_agent: 120 }, + byok_token_usage_by_category: {}, + }, + ], + }, + }) + insertQuery(db, { + exchangeId: 'ex-a', + conversationId: 'conv-2', + startTs: '2026-05-18 11:00:00.000000', + input: JSON.stringify([{ Query: { text: 'run tests' } }]), + }) + insertQuery(db, { + exchangeId: 'ex-b', + conversationId: 'conv-2', + startTs: '2026-05-18 11:05:00.000000', + input: JSON.stringify([{ Query: { text: 'summarize results' } }]), + }) + insertBlock(db, { + blockId: 'block-1', + conversationId: 'conv-2', + startTs: '2026-05-18 11:01:00.000000', + completedTs: '2026-05-18 11:01:04.000000', + exitCode: 0, + command: 'npm test && git status', + }) + }) + + const calls = await collectCalls(dbPath, 'conv-2') + expect(calls).toHaveLength(2) + expect(calls[0]!.tools).toEqual(['Bash']) + expect(calls[0]!.bashCommands).toEqual(['npm', 'git']) + expect(calls[1]!.tools).toEqual([]) + expect(calls[1]!.bashCommands).toEqual([]) + }) + + it('skips pending or invalid exchanges and does not poison seenKeys for skipped rows', async () => { + const dbPath = createWarpDb(tmpDir) + withTestDb(dbPath, (db) => { + insertConversation(db, 'conv-3', { + conversation_usage_metadata: { + token_usage: [ + { + model_id: 'GPT-5.3 Codex (medium reasoning)', + warp_tokens: 42, + byok_tokens: 0, + warp_token_usage_by_category: { primary_agent: 42 }, + byok_token_usage_by_category: {}, + }, + ], + }, + }) + insertQuery(db, { + exchangeId: 'ex-skip-seen', + conversationId: 'conv-3', + startTs: '2026-05-18 12:00:00.000000', + input: JSON.stringify([{ Query: { text: 'already seen' } }]), + }) + insertQuery(db, { + exchangeId: 'ex-pending', + conversationId: 'conv-3', + startTs: '2026-05-18 12:01:00.000000', + input: JSON.stringify([{ Query: { text: 'still running' } }]), + outputStatus: '"Pending"', + }) + insertQuery(db, { + exchangeId: 'ex-invalid-ts', + conversationId: 'conv-3', + startTs: 'not-a-timestamp', + input: JSON.stringify([{ Query: { text: 'bad timestamp' } }]), + }) + }) + + const seen = new Set<string>(['warp:conv-3:ex-skip-seen']) + const calls = await collectCalls(dbPath, 'conv-3', seen) + expect(calls).toEqual([]) + expect(seen.has('warp:conv-3:ex-invalid-ts')).toBe(false) + expect(seen.has('warp:conv-3:ex-pending')).toBe(false) + }) +}) diff --git a/tests/providers/zcode.test.ts b/tests/providers/zcode.test.ts new file mode 100644 index 0000000..f205737 --- /dev/null +++ b/tests/providers/zcode.test.ts @@ -0,0 +1,141 @@ +import { mkdtemp, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' +import { createRequire } from 'node:module' + +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { isSqliteAvailable } from '../../src/sqlite.js' +import { createZcodeProvider } from '../../src/providers/zcode.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +const requireForTest = createRequire(import.meta.url) + +let tmpRoot: string + +beforeEach(async () => { + tmpRoot = await mkdtemp(join(tmpdir(), 'zcode-test-')) +}) + +afterEach(async () => { + await rm(tmpRoot, { recursive: true, force: true }) +}) + +// Minimal subset of the real ZCode schema (db v0.14.8) covering only the +// columns the provider reads. +function createZcodeDb(dir: string): string { + const dbPath = join(dir, 'db.sqlite') + const { DatabaseSync: Database } = requireForTest('node:sqlite') + const db = new Database(dbPath) + db.exec(` + CREATE TABLE session ( + id TEXT PRIMARY KEY, + directory TEXT NOT NULL + ) + `) + db.exec(` + CREATE TABLE model_usage ( + id TEXT PRIMARY KEY, + session_id TEXT NOT NULL, + turn_id TEXT, + model_id TEXT NOT NULL, + input_tokens INTEGER NOT NULL DEFAULT 0, + output_tokens INTEGER NOT NULL DEFAULT 0, + reasoning_tokens INTEGER NOT NULL DEFAULT 0, + cache_creation_input_tokens INTEGER NOT NULL DEFAULT 0, + cache_read_input_tokens INTEGER NOT NULL DEFAULT 0, + started_at INTEGER NOT NULL, + completed_at INTEGER + ) + `) + db.exec(` + CREATE TABLE tool_usage ( + id TEXT PRIMARY KEY, + session_id TEXT NOT NULL, + turn_id TEXT, + tool_name TEXT NOT NULL, + started_at INTEGER NOT NULL + ) + `) + db.close() + return dbPath +} + +// Seeds one session with a single GLM-5.2 request whose 9125 input tokens +// include 8064 cached, plus two tool calls in the same turn. +function seed(dbPath: string): void { + const { DatabaseSync: Database } = requireForTest('node:sqlite') + const db = new Database(dbPath) + try { + db.prepare('INSERT INTO session (id, directory) VALUES (?, ?)').run('sess-1', '/Users/me/proj') + db.prepare( + `INSERT INTO model_usage + (id, session_id, turn_id, model_id, input_tokens, output_tokens, reasoning_tokens, + cache_creation_input_tokens, cache_read_input_tokens, started_at, completed_at) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, + ).run('mu-1', 'sess-1', 'turn-1', 'GLM-5.2', 9125, 27, 0, 0, 8064, 1781981181862, 1781981202412) + db.prepare( + 'INSERT INTO tool_usage (id, session_id, turn_id, tool_name, started_at) VALUES (?, ?, ?, ?, ?)', + ).run('tu-1', 'sess-1', 'turn-1', 'Bash', 1781981299176) + db.prepare( + 'INSERT INTO tool_usage (id, session_id, turn_id, tool_name, started_at) VALUES (?, ?, ?, ?, ?)', + ).run('tu-2', 'sess-1', 'turn-1', 'Read', 1781981315829) + } finally { + db.close() + } +} + +async function collect(parser: { parse(): AsyncGenerator<ParsedProviderCall> }): Promise<ParsedProviderCall[]> { + const out: ParsedProviderCall[] = [] + for await (const call of parser.parse()) out.push(call) + return out +} + +describe('zcode provider', () => { + it('discovers sessions that have usage', async () => { + if (!isSqliteAvailable()) return + const dbPath = createZcodeDb(tmpRoot) + seed(dbPath) + + const provider = createZcodeProvider(dbPath) + const sessions = await provider.discoverSessions() + + expect(sessions).toHaveLength(1) + expect(sessions[0]?.provider).toBe('zcode') + expect(sessions[0]?.project).toBe('Users-me-proj') + }) + + it('splits cached tokens out of input and prices via the GLM-5.2 alias', async () => { + if (!isSqliteAvailable()) return + const dbPath = createZcodeDb(tmpRoot) + seed(dbPath) + + const provider = createZcodeProvider(dbPath) + const [source] = await provider.discoverSessions() + const calls = await collect(provider.createSessionParser(source!, new Set<string>())) + + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.model).toBe('GLM-5.2') + expect(call.inputTokens).toBe(1061) // 9125 - 8064 cached + expect(call.cacheReadInputTokens).toBe(8064) + expect(call.outputTokens).toBe(27) + expect(call.tools).toEqual(['Bash', 'Read']) + expect(call.costUSD).toBeGreaterThan(0) + }) + + it('does not re-emit rows already in the seen set', async () => { + if (!isSqliteAvailable()) return + const dbPath = createZcodeDb(tmpRoot) + seed(dbPath) + + const provider = createZcodeProvider(dbPath) + const [source] = await provider.discoverSessions() + const seen = new Set<string>() + + const first = await collect(provider.createSessionParser(source!, seen)) + const second = await collect(provider.createSessionParser(source!, seen)) + + expect(first).toHaveLength(1) + expect(second).toHaveLength(0) + }) +}) diff --git a/tests/providers/zed.test.ts b/tests/providers/zed.test.ts new file mode 100644 index 0000000..4762cd7 --- /dev/null +++ b/tests/providers/zed.test.ts @@ -0,0 +1,236 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, rm } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' +import { createRequire } from 'node:module' +import zlib from 'zlib' + +import { createZedProvider } from '../../src/providers/zed.js' +import { isSqliteAvailable } from '../../src/sqlite.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +const requireForTest = createRequire(import.meta.url) + +const zstd = (zlib as { zstdCompressSync?: (buf: Buffer) => Buffer }).zstdCompressSync + +const skipReason = !isSqliteAvailable() + ? 'node:sqlite not available — needs Node 22+; skipping' + : !zstd + ? 'zlib zstd not available — needs Node 22.15+; skipping' + : null + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'zed-test-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +function buildDb(fn: (db: { + exec(sql: string): void + prepare(sql: string): { run(...params: unknown[]): void } + close(): void +}) => void): string { + const dbPath = join(tmpDir, 'threads.db') + const { DatabaseSync: Database } = requireForTest('node:sqlite') + const db = new Database(dbPath) + db.exec(`CREATE TABLE threads ( + id TEXT PRIMARY KEY, + summary TEXT NOT NULL, + updated_at TEXT NOT NULL, + data_type TEXT NOT NULL, + data BLOB NOT NULL, + parent_id TEXT, folder_paths TEXT, folder_paths_order TEXT, created_at TEXT + )`) + fn(db) + db.close() + return dbPath +} + +function insertThread(db: { + prepare(sql: string): { run(...params: unknown[]): void } +}, opts: { + id: string + summary?: string + updatedAt?: string + dataType?: string + thread?: unknown + rawData?: Buffer +}): void { + const data = opts.rawData ?? zstd!(Buffer.from(JSON.stringify(opts.thread ?? {}))) + db.prepare('INSERT INTO threads (id, summary, updated_at, data_type, data) VALUES (?, ?, ?, ?, ?)').run( + opts.id, + opts.summary ?? 'a thread', + opts.updatedAt ?? '2026-06-20T10:00:00Z', + opts.dataType ?? 'zstd', + data, + ) +} + +async function collectCalls(dbPath: string, seenKeys = new Set<string>()): Promise<ParsedProviderCall[]> { + const provider = createZedProvider(dbPath) + const sources = await provider.discoverSessions() + const calls: ParsedProviderCall[] = [] + for (const source of sources) { + for await (const call of provider.createSessionParser(source, seenKeys).parse()) { + calls.push(call) + } + } + return calls +} + +describe.skipIf(skipReason !== null)('zed provider (#480)', () => { + it('emits one call per request with exact Anthropic-shaped token fields', async () => { + const dbPath = buildDb((db) => { + insertThread(db, { + id: 'thread-1', + summary: 'refactor the parser', + updatedAt: '2026-06-21T09:30:00Z', + thread: { + model: { provider: 'anthropic', model: 'claude-opus-4-8' }, + request_token_usage: { + 'req-1': { input_tokens: 1200, output_tokens: 300, cache_creation_input_tokens: 5000, cache_read_input_tokens: 90000 }, + 'req-2': { input_tokens: 800, output_tokens: 150, cache_creation_input_tokens: 0, cache_read_input_tokens: 95000 }, + }, + cumulative_token_usage: { input_tokens: 2000, output_tokens: 450 }, + }, + }) + }) + + const calls = await collectCalls(dbPath) + expect(calls.length).toBe(2) + const first = calls.find(c => c.deduplicationKey === 'zed:thread-1:req-1') + expect(first).toBeDefined() + expect(first!.inputTokens).toBe(1200) + expect(first!.outputTokens).toBe(300) + expect(first!.cacheCreationInputTokens).toBe(5000) + expect(first!.cacheReadInputTokens).toBe(90000) + expect(first!.model).toBe('claude-opus-4-8') + expect(first!.costUSD).toBeGreaterThan(0) + expect(first!.sessionId).toBe('thread-1') + expect(first!.userMessage).toBe('refactor the parser') + expect(first!.timestamp).toBe('2026-06-21T09:30:00.000Z') + // Cumulative must not be counted on top of per-request entries. + expect(calls.reduce((s, c) => s + c.inputTokens, 0)).toBe(2000) + }) + + it('falls back to cumulative_token_usage when the per-request map is empty', async () => { + const dbPath = buildDb((db) => { + insertThread(db, { + id: 'thread-2', + thread: { + model: { provider: 'anthropic', model: 'claude-sonnet-4-6' }, + request_token_usage: {}, + cumulative_token_usage: { input_tokens: 5400, output_tokens: 900, cache_read_input_tokens: 20000 }, + }, + }) + }) + + const calls = await collectCalls(dbPath) + expect(calls.length).toBe(1) + expect(calls[0]!.deduplicationKey).toBe('zed:thread-2:cumulative-remainder') + expect(calls[0]!.inputTokens).toBe(5400) + expect(calls[0]!.cacheReadInputTokens).toBe(20000) + }) + + it('tops threads up to the cumulative counter when the per-request map undercounts', async () => { + // Mirrors a real thread: the map (keyed by user message) covered only some + // requests while cumulative carried ~3x the tokens. + const dbPath = buildDb((db) => { + insertThread(db, { + id: 'thread-real', + thread: { + model: { provider: 'zed.dev', model: 'gpt-5.4' }, + request_token_usage: { + 'msg-1': { input_tokens: 9514, output_tokens: 19 }, + 'msg-2': { input_tokens: 2757, output_tokens: 310, cache_read_input_tokens: 33408 }, + }, + cumulative_token_usage: { input_tokens: 35464, output_tokens: 1868, cache_read_input_tokens: 140288 }, + }, + }) + }) + + const calls = await collectCalls(dbPath) + expect(calls.length).toBe(3) + const remainder = calls.find(c => c.deduplicationKey === 'zed:thread-real:cumulative-remainder') + expect(remainder).toBeDefined() + expect(calls.reduce((s, c) => s + c.inputTokens, 0)).toBe(35464) + expect(calls.reduce((s, c) => s + c.outputTokens, 0)).toBe(1868) + expect(calls.reduce((s, c) => s + c.cacheReadInputTokens, 0)).toBe(140288) + }) + + it('skips non-zstd rows and malformed blobs without dropping healthy threads', async () => { + const dbPath = buildDb((db) => { + insertThread(db, { id: 'bad-type', dataType: 'protobuf', rawData: Buffer.from('{}') }) + insertThread(db, { id: 'bad-blob', rawData: Buffer.from('not zstd at all') }) + insertThread(db, { + id: 'good', + thread: { + model: { model: 'claude-opus-4-8' }, + request_token_usage: { 'req-1': { input_tokens: 10, output_tokens: 5 } }, + }, + }) + }) + + const calls = await collectCalls(dbPath) + expect(calls.length).toBe(1) + expect(calls[0]!.sessionId).toBe('good') + }) + + it('reads legacy uncompressed json rows alongside zstd rows', async () => { + const dbPath = buildDb((db) => { + insertThread(db, { + id: 'legacy', + dataType: 'json', + rawData: Buffer.from(JSON.stringify({ + model: { model: 'claude-sonnet-4-6' }, + request_token_usage: { 'req-1': { input_tokens: 40, output_tokens: 8 } }, + })), + }) + }) + + const calls = await collectCalls(dbPath) + expect(calls.length).toBe(1) + expect(calls[0]!.inputTokens).toBe(40) + expect(calls[0]!.model).toBe('claude-sonnet-4-6') + }) + + it('dedupes across repeat parses via the shared seenKeys set', async () => { + const dbPath = buildDb((db) => { + insertThread(db, { + id: 'thread-3', + thread: { + model: { model: 'claude-opus-4-8' }, + request_token_usage: { 'req-1': { input_tokens: 100, output_tokens: 50 } }, + }, + }) + }) + + const seen = new Set<string>() + expect((await collectCalls(dbPath, seen)).length).toBe(1) + expect((await collectCalls(dbPath, seen)).length).toBe(0) + }) + + it('skips threads whose usage is entirely zero instead of emitting empty calls', async () => { + const dbPath = buildDb((db) => { + insertThread(db, { + id: 'thread-4', + thread: { + model: { model: 'claude-opus-4-8' }, + request_token_usage: { 'req-1': { input_tokens: 0, output_tokens: 0 } }, + cumulative_token_usage: { input_tokens: 0, output_tokens: 0 }, + }, + }) + }) + + expect((await collectCalls(dbPath)).length).toBe(0) + }) + + it('discovers nothing when the database does not exist', async () => { + const provider = createZedProvider(join(tmpDir, 'missing.db')) + expect(await provider.discoverSessions()).toEqual([]) + }) +}) diff --git a/tests/providers/zerostack.test.ts b/tests/providers/zerostack.test.ts new file mode 100644 index 0000000..0b5111e --- /dev/null +++ b/tests/providers/zerostack.test.ts @@ -0,0 +1,142 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest' +import { mkdtemp, writeFile, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { createZerostackProvider } from '../../src/providers/zerostack.js' +import type { ParsedProviderCall } from '../../src/providers/types.js' + +let tmpDir: string + +beforeEach(async () => { + tmpDir = await mkdtemp(join(tmpdir(), 'zerostack-test-')) +}) + +afterEach(async () => { + await rm(tmpDir, { recursive: true, force: true }) +}) + +// Mirrors the real on-disk format: one JSON file per session with cumulative +// token totals (see src/session/mod.rs in zerostack). +function session(opts: { + id?: string + model?: string + provider?: string + workingDir?: string + input?: number + output?: number + updatedAt?: string +} = {}) { + return JSON.stringify({ + id: opts.id ?? 'sess-001', + name: '', + messages: [ + { role: 'user', content: 'hello, what is this repo about?', estimated_tokens: 7 }, + { role: 'assistant', content: 'It is a minimal coding agent in Rust.', estimated_tokens: 92 }, + ], + compactions: [], + created_at: '2026-06-19T11:33:34.022836+00:00', + updated_at: opts.updatedAt ?? '2026-06-19T11:34:14.140631+00:00', + total_input_tokens: opts.input ?? 34119, + total_output_tokens: opts.output ?? 961, + total_cost: 0.015677835, + total_estimated_tokens: 446, + model: opts.model ?? 'deepseek/deepseek-v4-pro', + provider: opts.provider ?? 'openrouter', + working_dir: opts.workingDir ?? '/Users/test/myproject', + permission_allowlist: [], + }) +} + +async function write(filename: string, content: string) { + const path = join(tmpDir, filename) + await writeFile(path, content) + return path +} + +describe('zerostack provider - discovery', () => { + it('discovers each session json and derives project from working_dir', async () => { + await write('sess-001.json', session({ workingDir: '/Users/test/myproject' })) + const sessions = await createZerostackProvider(tmpDir).discoverSessions() + expect(sessions).toHaveLength(1) + expect(sessions[0]!.provider).toBe('zerostack') + expect(sessions[0]!.project).toBe('myproject') + }) + + it('skips non-json files and unparseable files', async () => { + await write('notes.txt', 'not a session') + await write('broken.json', '{ not valid json') + const sessions = await createZerostackProvider(tmpDir).discoverSessions() + expect(sessions).toEqual([]) + }) + + it('returns empty for a non-existent directory', async () => { + const sessions = await createZerostackProvider('/nope/does/not/exist').discoverSessions() + expect(sessions).toEqual([]) + }) +}) + +describe('zerostack provider - parsing', () => { + async function parse(path: string, seen = new Set<string>()) { + const provider = createZerostackProvider(tmpDir) + const source = { path, project: 'myproject', provider: 'zerostack' } + const calls: ParsedProviderCall[] = [] + for await (const call of provider.createSessionParser(source, seen).parse()) { + calls.push(call) + } + return calls + } + + it('emits one cumulative call per session with a resolved cost', async () => { + const path = await write('sess-abc.json', session({ id: 'sess-abc' })) + const calls = await parse(path) + + expect(calls).toHaveLength(1) + const call = calls[0]! + expect(call.model).toBe('deepseek/deepseek-v4-pro') + expect(call.inputTokens).toBe(34119) + expect(call.outputTokens).toBe(961) + expect(call.sessionId).toBe('sess-abc') + expect(call.userMessage).toBe('hello, what is this repo about?') + expect(call.timestamp).toBe('2026-06-19T11:34:14.140631+00:00') + expect(call.costUSD).toBeGreaterThan(0) + expect(call.deduplicationKey).toContain('zerostack:') + }) + + it('skips sessions with zero tokens', async () => { + const path = await write('empty.json', session({ input: 0, output: 0 })) + expect(await parse(path)).toHaveLength(0) + }) + + it('deduplicates across repeated parses', async () => { + const path = await write('dup.json', session()) + const seen = new Set<string>() + expect(await parse(path, seen)).toHaveLength(1) + expect(await parse(path, seen)).toHaveLength(0) + }) + + it('prices unknown local models at zero without throwing', async () => { + const path = await write('local.json', session({ model: 'my-local-model', provider: 'ollama' })) + const calls = await parse(path) + expect(calls).toHaveLength(1) + expect(calls[0]!.costUSD).toBe(0) + }) +}) + +describe('zerostack provider - display names', () => { + const provider = createZerostackProvider('/tmp') + + it('has correct name and displayName', () => { + expect(provider.name).toBe('zerostack') + expect(provider.displayName).toBe('Zerostack') + }) + + it('strips the openrouter route prefix from model ids', () => { + expect(provider.modelDisplayName('deepseek/deepseek-v4-pro')).toBe('DeepSeek v4 Pro') + }) + + it('normalizes tool names', () => { + expect(provider.toolDisplayName('bash')).toBe('Bash') + expect(provider.toolDisplayName('unknown_tool')).toBe('unknown_tool') + }) +}) diff --git a/tests/scan-progress.test.ts b/tests/scan-progress.test.ts new file mode 100644 index 0000000..0ffc7d2 --- /dev/null +++ b/tests/scan-progress.test.ts @@ -0,0 +1,66 @@ +import { describe, it, expect, vi, afterEach } from 'vitest' +import { createScanProgress, setInteractiveScanUI } from '../src/parser.js' + +// The scan-progress line must be silent while an interactive Ink UI (dashboard, +// compare) is live, because it renders to the same terminal. The end-to-end +// proof (cold dashboard WITH a plan stays silent; cold overview shows progress) +// is documented in the PR and was run under a PTY. +describe('createScanProgress gate', () => { + const origTTY = process.stderr.isTTY + + afterEach(() => { + setInteractiveScanUI(false) + Object.defineProperty(process.stderr, 'isTTY', { value: origTTY, configurable: true }) + vi.restoreAllMocks() + }) + + function forceTTY(v: boolean) { + Object.defineProperty(process.stderr, 'isTTY', { value: v, configurable: true }) + } + + it('writes progress for a plain CLI command in a TTY over the threshold', async () => { + forceTTY(true) + const w = vi.spyOn(process.stderr, 'write').mockReturnValue(true) + const p = createScanProgress('scanning', 100) + await p.tick(100) // final tick bypasses the 100ms throttle + expect(w).toHaveBeenCalled() + expect(String(w.mock.calls[0]![0])).toContain('scanning 100/100') + }) + + it('goes silent once an interactive Ink UI is active, even in a TTY', async () => { + forceTTY(true) + setInteractiveScanUI() // dashboard/compare call this right before render() + const w = vi.spyOn(process.stderr, 'write').mockReturnValue(true) + const p = createScanProgress('scanning', 100) + for (let i = 1; i <= 100; i++) await p.tick(i) + p.finish() + expect(w).not.toHaveBeenCalled() + }) + + it('finish() clears the line when progress was shown', async () => { + forceTTY(true) + const w = vi.spyOn(process.stderr, 'write').mockReturnValue(true) + const p = createScanProgress('scanning', 100) + await p.tick(100) + w.mockClear() + p.finish() + expect(String(w.mock.calls[0]![0])).toBe('\r\x1b[K') + }) + + it('writes nothing when stderr is not a TTY (piped/captured output)', async () => { + forceTTY(false) + const w = vi.spyOn(process.stderr, 'write').mockReturnValue(true) + const p = createScanProgress('scanning', 100) + await p.tick(100) + p.finish() + expect(w).not.toHaveBeenCalled() + }) + + it('stays silent below the small-tree threshold', async () => { + forceTTY(true) + const w = vi.spyOn(process.stderr, 'write').mockReturnValue(true) + const p = createScanProgress('scanning', 5) + await p.tick(5) + expect(w).not.toHaveBeenCalled() + }) +}) diff --git a/tests/security/prototype-pollution.test.ts b/tests/security/prototype-pollution.test.ts new file mode 100644 index 0000000..8a57ac2 --- /dev/null +++ b/tests/security/prototype-pollution.test.ts @@ -0,0 +1,67 @@ +import { describe, it, expect, afterEach } from 'vitest' +import { mkdtemp, mkdir, cp, rm } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' + +import { parseAllSessions } from '../../src/parser.js' +import type { DateRange } from '../../src/types.js' + +// Fixtures carry timestamp 2026-04-16T00:00:00Z. The range below must stay +// wide enough to include that date; if the fixtures move, move FIXTURE_DAY too. +const FIXTURE_DAY = Date.UTC(2026, 3, 16) // month index 3 = April (Date.UTC is 0-indexed) +const RANGE_BEFORE_MS = FIXTURE_DAY - 24 * 60 * 60 * 1000 +const RANGE_AFTER_MS = FIXTURE_DAY + 24 * 60 * 60 * 1000 +const PROJECT_NAME = 'codeburn-poc-testing' + +function makeRange(offsetMs: number): DateRange { + return { + start: new Date(RANGE_BEFORE_MS + offsetMs), + end: new Date(RANGE_AFTER_MS + offsetMs), + } +} + +// Hermeticity note: the Claude provider also scans a fixed Desktop sessions +// dir independent of CLAUDE_CONFIG_DIR. The narrow dateRange above excludes +// any real sessions in practice, but these tests are not strictly isolated +// on a machine with April 2026 Claude Desktop activity. A stricter fix +// belongs in a follow-up to discoverSessions itself. + +describe('HIGH-1 prototype pollution via unchecked bracket-assign', () => { + const tmpDirs: string[] = [] + + afterEach(async () => { + delete (Object.prototype as Record<string, unknown>).calls + while (tmpDirs.length > 0) { + const d = tmpDirs.pop() + if (d) await rm(d, { recursive: true, force: true }) + } + }) + + async function setupPoc(fixture: string): Promise<string> { + const base = await mkdtemp(join(tmpdir(), 'codeburn-sec-')) + tmpDirs.push(base) + const projectDir = join(base, 'projects', PROJECT_NAME) + await mkdir(projectDir, { recursive: true }) + await cp(join(__dirname, '..', 'fixtures', 'security', fixture), join(projectDir, 'pwn.jsonl')) + process.env['CLAUDE_CONFIG_DIR'] = base + return base + } + + it('does not pollute Object.prototype when session contains tool_use name "__proto__"', async () => { + await setupPoc('proto-tool.jsonl') + await expect(parseAllSessions(makeRange(0), 'claude')).resolves.not.toThrow() + expect(({} as Record<string, unknown>).calls).toBeUndefined() + }) + + it('does not pollute Object.prototype when bash command basename is "__proto__"', async () => { + await setupPoc('proto-bash.jsonl') + await expect(parseAllSessions(makeRange(1), 'claude')).resolves.not.toThrow() + expect(({} as Record<string, unknown>).calls).toBeUndefined() + }) + + it('does not pollute Object.prototype when model name is "__proto__"', async () => { + await setupPoc('proto-model.jsonl') + await expect(parseAllSessions(makeRange(2), 'claude')).resolves.not.toThrow() + expect(({} as Record<string, unknown>).calls).toBeUndefined() + }) +}) diff --git a/tests/session-cache.test.ts b/tests/session-cache.test.ts new file mode 100644 index 0000000..b14ab06 --- /dev/null +++ b/tests/session-cache.test.ts @@ -0,0 +1,585 @@ +import { afterEach, beforeEach, describe, expect, it } from 'vitest' +import { readFile, rm, writeFile, mkdir } from 'fs/promises' +import { existsSync } from 'fs' +import { tmpdir } from 'os' +import { join } from 'path' + +import { + CACHE_VERSION, + type CachedCall, + type CachedFile, + type CachedTurn, + type FileFingerprint, + type SessionCache, + cleanupOrphanedTempFiles, + computeEnvFingerprint, + emptyCache, + fingerprintFile, + loadCache, + mergeCallByDedupKey, + reconcileFile, + saveCache, +} from '../src/session-cache.js' + +const TMP_DIR = join(tmpdir(), `codeburn-scache-test-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`) + +beforeEach(() => { + process.env['CODEBURN_CACHE_DIR'] = TMP_DIR +}) + +afterEach(async () => { + if (existsSync(TMP_DIR)) await rm(TMP_DIR, { recursive: true }) +}) + +function makeCall(overrides: Partial<CachedCall> = {}): CachedCall { + return { + provider: 'claude', + model: 'claude-sonnet-4-20250514', + usage: { + inputTokens: 1000, + outputTokens: 500, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + cachedInputTokens: 0, + reasoningTokens: 0, + webSearchRequests: 0, + cacheCreationOneHourTokens: 0, + }, + speed: 'standard', + timestamp: '2026-05-15T10:00:00Z', + tools: ['Read', 'Edit'], + bashCommands: [], + skills: [], + deduplicationKey: 'msg-abc123', + ...overrides, + } +} + +function makeTurn(overrides: Partial<CachedTurn> = {}): CachedTurn { + return { + timestamp: '2026-05-15T10:00:00Z', + sessionId: 'sess-1', + userMessage: 'fix the bug', + calls: [makeCall()], + ...overrides, + } +} + +function makeCachedFile(overrides: Partial<CachedFile> = {}): CachedFile { + return { + fingerprint: { dev: 1, ino: 100, mtimeMs: 1000, sizeBytes: 5000 }, + mcpInventory: [], + turns: [makeTurn()], + ...overrides, + } +} + +// ── emptyCache ───────────────────────────────────────────────────────── + +describe('emptyCache', () => { + it('returns a valid empty cache', () => { + const cache = emptyCache() + expect(cache.version).toBe(CACHE_VERSION) + expect(cache.providers).toEqual({}) + }) +}) + +// ── loadCache / saveCache ────────────────────────────────────────────── + +describe('loadCache / saveCache', () => { + it('returns empty cache when no file exists', async () => { + const cache = await loadCache() + expect(cache.version).toBe(CACHE_VERSION) + expect(cache.providers).toEqual({}) + }) + + it('round-trips a cache through save and load', async () => { + const cache: SessionCache = { + version: CACHE_VERSION, + providers: { + claude: { + envFingerprint: 'abc123', + files: { + '/path/to/session.jsonl': makeCachedFile(), + }, + }, + }, + } + + await saveCache(cache) + const loaded = await loadCache() + expect(loaded).toEqual(cache) + }) + + it('persists a failed-parse marker across save/load (negative-result cache)', async () => { + const cache: SessionCache = { + version: CACHE_VERSION, + providers: { + pi: { + envFingerprint: 'abc123', + files: { + '/path/to/bad.jsonl': makeCachedFile({ turns: [], failed: true }), + }, + }, + }, + } + + await saveCache(cache) + const loaded = await loadCache() + // The `failed` flag and empty turns survive validation + load, so the file + // stays skipped on the next run instead of being re-read and re-thrown. + expect(loaded.providers['pi']?.files['/path/to/bad.jsonl']?.failed).toBe(true) + expect(loaded.providers['pi']?.files['/path/to/bad.jsonl']?.turns).toEqual([]) + }) + + it('returns empty cache on version mismatch', async () => { + const bad: SessionCache = { version: 999, providers: { claude: { envFingerprint: 'x', files: {} } } } + await mkdir(TMP_DIR, { recursive: true }) + await writeFile(join(TMP_DIR, 'session-cache.json'), JSON.stringify(bad)) + + const loaded = await loadCache() + expect(loaded.version).toBe(CACHE_VERSION) + expect(loaded.providers).toEqual({}) + }) + + it('returns empty cache on corrupt JSON', async () => { + await mkdir(TMP_DIR, { recursive: true }) + await writeFile(join(TMP_DIR, 'session-cache.json'), '{broken') + + const loaded = await loadCache() + expect(loaded.version).toBe(CACHE_VERSION) + expect(loaded.providers).toEqual({}) + }) + + it('atomic write does not leave partial file on error', async () => { + await saveCache(emptyCache()) + const raw = await readFile(join(TMP_DIR, 'session-cache.json'), 'utf-8') + expect(JSON.parse(raw)).toEqual(emptyCache()) + }) +}) + +// ── computeEnvFingerprint ────────────────────────────────────────────── + +describe('computeEnvFingerprint', () => { + it('returns stable hash for same env', () => { + const a = computeEnvFingerprint('claude') + const b = computeEnvFingerprint('claude') + expect(a).toBe(b) + expect(a).toHaveLength(16) + }) + + it('changes when env var changes', () => { + const before = computeEnvFingerprint('claude') + process.env['CLAUDE_CONFIG_DIR'] = '/tmp/different' + const after = computeEnvFingerprint('claude') + expect(before).not.toBe(after) + }) + + it('returns stable hash for unknown provider (no env vars)', () => { + const a = computeEnvFingerprint('unknown-provider') + const b = computeEnvFingerprint('unknown-provider') + expect(a).toBe(b) + }) + + it('includes parser versions in provider fingerprints', () => { + expect(computeEnvFingerprint('claude')).not.toBe(computeEnvFingerprint('unknown-provider')) + expect(computeEnvFingerprint('copilot')).not.toBe(computeEnvFingerprint('unknown-provider')) + expect(computeEnvFingerprint('kiro')).not.toBe(computeEnvFingerprint('unknown-provider')) + expect(computeEnvFingerprint('warp')).not.toBe(computeEnvFingerprint('unknown-provider')) + }) +}) + +// ── fingerprintFile ──────────────────────────────────────────────────── + +describe('fingerprintFile', () => { + it('returns fingerprint for existing file', async () => { + await mkdir(TMP_DIR, { recursive: true }) + const filePath = join(TMP_DIR, 'test.jsonl') + await writeFile(filePath, 'line1\nline2\n') + + const fp = await fingerprintFile(filePath) + expect(fp).not.toBeNull() + expect(fp!.sizeBytes).toBe(12) + expect(fp!.dev).toBeGreaterThan(0) + expect(fp!.ino).toBeGreaterThan(0) + expect(fp!.mtimeMs).toBeGreaterThan(0) + }) + + it('returns null for non-existent file', async () => { + const fp = await fingerprintFile('/no/such/file') + expect(fp).toBeNull() + }) + + it('resolves compound path with # separator (Cursor workspace)', async () => { + await mkdir(TMP_DIR, { recursive: true }) + const filePath = join(TMP_DIR, 'state.vscdb') + await writeFile(filePath, 'cursor-data') + + const fp = await fingerprintFile(`${filePath}#cursor-ws=__orphan__`) + expect(fp).not.toBeNull() + expect(fp!.sizeBytes).toBe(11) + }) + + it('resolves compound path with : separator (OpenCode session)', async () => { + await mkdir(TMP_DIR, { recursive: true }) + const filePath = join(TMP_DIR, 'opencode.db') + await writeFile(filePath, 'opencode-data') + + const fp = await fingerprintFile(`${filePath}:ses_abc123`) + expect(fp).not.toBeNull() + expect(fp!.sizeBytes).toBe(13) + }) + + it('returns null when base file does not exist for compound path', async () => { + const fp = await fingerprintFile('/no/such/file.db#cursor-ws=workspace') + expect(fp).toBeNull() + }) + + it('prefers # separator over : when both present', async () => { + await mkdir(TMP_DIR, { recursive: true }) + const filePath = join(TMP_DIR, 'state.vscdb') + await writeFile(filePath, 'both-seps') + + // Path has both # and : — should strip at # first and find the base file + const fp = await fingerprintFile(`${filePath}#cursor-ws=ws:extra-colon`) + expect(fp).not.toBeNull() + expect(fp!.sizeBytes).toBe(9) + }) +}) + +// ── reconcileFile ────────────────────────────────────────────────────── + +describe('reconcileFile', () => { + it('returns "new" when no cached entry', () => { + const fp: FileFingerprint = { dev: 1, ino: 100, mtimeMs: 1000, sizeBytes: 5000 } + expect(reconcileFile(fp, undefined)).toEqual({ action: 'new' }) + }) + + it('returns "unchanged" when all fields match', () => { + const fp: FileFingerprint = { dev: 1, ino: 100, mtimeMs: 1000, sizeBytes: 5000 } + const cached = makeCachedFile({ fingerprint: { ...fp } }) + expect(reconcileFile(fp, cached)).toEqual({ action: 'unchanged' }) + }) + + it('returns "appended" when ino same, size grew, and has lastCompleteLineOffset', () => { + const cached = makeCachedFile({ + fingerprint: { dev: 1, ino: 100, mtimeMs: 1000, sizeBytes: 5000 }, + lastCompleteLineOffset: 4500, + }) + const current: FileFingerprint = { dev: 1, ino: 100, mtimeMs: 2000, sizeBytes: 8000 } + const result = reconcileFile(current, cached) + expect(result).toEqual({ action: 'appended', readFromOffset: 4500 }) + }) + + it('returns "modified" when ino changed', () => { + const cached = makeCachedFile({ + fingerprint: { dev: 1, ino: 100, mtimeMs: 1000, sizeBytes: 5000 }, + }) + const current: FileFingerprint = { dev: 1, ino: 200, mtimeMs: 2000, sizeBytes: 5000 } + expect(reconcileFile(current, cached)).toEqual({ action: 'modified' }) + }) + + it('a failed marker at the same fingerprint stays "unchanged" (not re-parsed)', () => { + const fp: FileFingerprint = { dev: 1, ino: 100, mtimeMs: 1000, sizeBytes: 5000 } + const marker = makeCachedFile({ fingerprint: { ...fp }, turns: [], failed: true }) + expect(reconcileFile(fp, marker)).toEqual({ action: 'unchanged' }) + }) + + it('a failed marker is re-parsed once the file changes', () => { + const marker = makeCachedFile({ + fingerprint: { dev: 1, ino: 100, mtimeMs: 1000, sizeBytes: 5000 }, + turns: [], + failed: true, + }) + const changed: FileFingerprint = { dev: 1, ino: 100, mtimeMs: 2000, sizeBytes: 6000 } + expect(reconcileFile(changed, marker)).toEqual({ action: 'modified' }) + }) + + it('returns "modified" when size shrank', () => { + const cached = makeCachedFile({ + fingerprint: { dev: 1, ino: 100, mtimeMs: 1000, sizeBytes: 5000 }, + lastCompleteLineOffset: 4500, + }) + const current: FileFingerprint = { dev: 1, ino: 100, mtimeMs: 2000, sizeBytes: 3000 } + expect(reconcileFile(current, cached)).toEqual({ action: 'modified' }) + }) + + it('returns "modified" when same size but different mtime', () => { + const cached = makeCachedFile({ + fingerprint: { dev: 1, ino: 100, mtimeMs: 1000, sizeBytes: 5000 }, + }) + const current: FileFingerprint = { dev: 1, ino: 100, mtimeMs: 2000, sizeBytes: 5000 } + expect(reconcileFile(current, cached)).toEqual({ action: 'modified' }) + }) + + it('returns "modified" for DB provider (no lastCompleteLineOffset) on any fingerprint change', () => { + const cached = makeCachedFile({ + fingerprint: { dev: 1, ino: 100, mtimeMs: 1000, sizeBytes: 5000 }, + }) + const current: FileFingerprint = { dev: 1, ino: 100, mtimeMs: 2000, sizeBytes: 8000 } + expect(reconcileFile(current, cached)).toEqual({ action: 'modified' }) + }) + + it('returns "modified" when dev changed even if ino same and size grew', () => { + const cached = makeCachedFile({ + fingerprint: { dev: 1, ino: 100, mtimeMs: 1000, sizeBytes: 5000 }, + lastCompleteLineOffset: 4500, + }) + const current: FileFingerprint = { dev: 2, ino: 100, mtimeMs: 2000, sizeBytes: 8000 } + expect(reconcileFile(current, cached)).toEqual({ action: 'modified' }) + }) +}) + +// ── mergeCallByDedupKey ──────────────────────────────────────────────── + +describe('mergeCallByDedupKey', () => { + it('keeps earlier timestamp', () => { + const existing = makeCall({ timestamp: '2026-05-15T10:00:00Z' }) + const incoming = makeCall({ timestamp: '2026-05-15T10:01:00Z' }) + const merged = mergeCallByDedupKey(existing, incoming) + expect(merged.timestamp).toBe('2026-05-15T10:00:00Z') + }) + + it('takes incoming usage (latest wins)', () => { + const existing = makeCall({ usage: { ...makeCall().usage, outputTokens: 100 } }) + const incoming = makeCall({ usage: { ...makeCall().usage, outputTokens: 999 } }) + const merged = mergeCallByDedupKey(existing, incoming) + expect(merged.usage.outputTokens).toBe(999) + }) + + it('takes incoming tools (latest wins)', () => { + const existing = makeCall({ tools: ['Read'] }) + const incoming = makeCall({ tools: ['Read', 'Edit', 'Bash'] }) + const merged = mergeCallByDedupKey(existing, incoming) + expect(merged.tools).toEqual(['Read', 'Edit', 'Bash']) + }) +}) + +// ── deep validation (loadCache) ──────────────────────────────────────── + +describe('loadCache validation', () => { + async function writeRawCache(data: unknown): Promise<void> { + await mkdir(TMP_DIR, { recursive: true }) + await writeFile(join(TMP_DIR, 'session-cache.json'), JSON.stringify(data)) + } + + it('rejects providers as array', async () => { + await writeRawCache({ version: CACHE_VERSION, providers: [] }) + expect((await loadCache()).providers).toEqual({}) + }) + + it('rejects provider section missing envFingerprint', async () => { + await writeRawCache({ version: CACHE_VERSION, providers: { claude: { files: {} } } }) + expect((await loadCache()).providers).toEqual({}) + }) + + it('rejects provider section with files as array', async () => { + await writeRawCache({ version: CACHE_VERSION, providers: { claude: { envFingerprint: 'x', files: [] } } }) + expect((await loadCache()).providers).toEqual({}) + }) + + it('rejects file with invalid fingerprint (missing ino)', async () => { + await writeRawCache({ + version: CACHE_VERSION, + providers: { claude: { envFingerprint: 'x', files: { + '/f': { fingerprint: { dev: 1, mtimeMs: 1, sizeBytes: 1 }, mcpInventory: [], turns: [] }, + } } }, + }) + expect((await loadCache()).providers).toEqual({}) + }) + + it('rejects file with non-numeric fingerprint field', async () => { + await writeRawCache({ + version: CACHE_VERSION, + providers: { claude: { envFingerprint: 'x', files: { + '/f': { fingerprint: { dev: 1, ino: 'bad', mtimeMs: 1, sizeBytes: 1 }, mcpInventory: [], turns: [] }, + } } }, + }) + expect((await loadCache()).providers).toEqual({}) + }) + + it('rejects turn with missing sessionId', async () => { + const badTurn = { timestamp: 'x', userMessage: 'y', calls: [] } + await writeRawCache({ + version: CACHE_VERSION, + providers: { claude: { envFingerprint: 'x', files: { + '/f': { fingerprint: { dev: 1, ino: 2, mtimeMs: 3, sizeBytes: 4 }, mcpInventory: [], turns: [badTurn] }, + } } }, + }) + expect((await loadCache()).providers).toEqual({}) + }) + + it('rejects call with missing usage object', async () => { + const badCall = { provider: 'claude', model: 'm', deduplicationKey: 'k', timestamp: 't', tools: [], bashCommands: [], skills: [] } + const turn = { timestamp: 'x', sessionId: 's', userMessage: 'y', calls: [badCall] } + await writeRawCache({ + version: CACHE_VERSION, + providers: { claude: { envFingerprint: 'x', files: { + '/f': { fingerprint: { dev: 1, ino: 2, mtimeMs: 3, sizeBytes: 4 }, mcpInventory: [], turns: [turn] }, + } } }, + }) + expect((await loadCache()).providers).toEqual({}) + }) + + it('rejects call with NaN in usage', async () => { + const badUsage = { inputTokens: NaN, outputTokens: 0, cacheCreationInputTokens: 0, cacheReadInputTokens: 0, cachedInputTokens: 0, reasoningTokens: 0, webSearchRequests: 0, cacheCreationOneHourTokens: 0 } + const call = { provider: 'claude', model: 'm', usage: badUsage, deduplicationKey: 'k', timestamp: 't', tools: [], bashCommands: [], skills: [], speed: 'standard' } + const turn = { timestamp: 'x', sessionId: 's', userMessage: 'y', calls: [call] } + await writeRawCache({ + version: CACHE_VERSION, + providers: { claude: { envFingerprint: 'x', files: { + '/f': { fingerprint: { dev: 1, ino: 2, mtimeMs: 3, sizeBytes: 4 }, mcpInventory: [], turns: [turn] }, + } } }, + }) + expect((await loadCache()).providers).toEqual({}) + }) + + function validCallJson() { + return { + provider: 'claude', model: 'm', deduplicationKey: 'k', timestamp: 't', speed: 'standard', + tools: ['Read'], bashCommands: ['ls'], skills: [], + usage: { inputTokens: 1, outputTokens: 1, cacheCreationInputTokens: 0, cacheReadInputTokens: 0, cachedInputTokens: 0, reasoningTokens: 0, webSearchRequests: 0, cacheCreationOneHourTokens: 0 }, + } + } + + function wrapCall(callOverride: Record<string, unknown>) { + return { + version: CACHE_VERSION, + providers: { claude: { envFingerprint: 'x', files: { + '/f': { fingerprint: { dev: 1, ino: 2, mtimeMs: 3, sizeBytes: 4 }, mcpInventory: [], turns: [ + { timestamp: 'x', sessionId: 's', userMessage: 'y', calls: [{ ...validCallJson(), ...callOverride }] }, + ] }, + } } }, + } + } + + function wrapFile(fileOverride: Record<string, unknown>) { + return { + version: CACHE_VERSION, + providers: { claude: { envFingerprint: 'x', files: { + '/f': { fingerprint: { dev: 1, ino: 2, mtimeMs: 3, sizeBytes: 4 }, mcpInventory: [], turns: [], ...fileOverride }, + } } }, + } + } + + it('rejects tools containing non-string element', async () => { + await writeRawCache(wrapCall({ tools: ['Read', 42] })) + expect((await loadCache()).providers).toEqual({}) + }) + + it('rejects bashCommands containing object element', async () => { + await writeRawCache(wrapCall({ bashCommands: [{}] })) + expect((await loadCache()).providers).toEqual({}) + }) + + it('rejects skills containing null element', async () => { + await writeRawCache(wrapCall({ skills: [null] })) + expect((await loadCache()).providers).toEqual({}) + }) + + it('rejects invalid speed value', async () => { + await writeRawCache(wrapCall({ speed: 'turbo' })) + expect((await loadCache()).providers).toEqual({}) + }) + + it('rejects non-string project', async () => { + await writeRawCache(wrapCall({ project: 123 })) + expect((await loadCache()).providers).toEqual({}) + }) + + it('rejects non-string projectPath', async () => { + await writeRawCache(wrapCall({ projectPath: true })) + expect((await loadCache()).providers).toEqual({}) + }) + + it('rejects mcpInventory containing non-string element', async () => { + await writeRawCache(wrapFile({ mcpInventory: ['valid', 99] })) + expect((await loadCache()).providers).toEqual({}) + }) + + it('rejects non-numeric lastCompleteLineOffset', async () => { + await writeRawCache(wrapFile({ lastCompleteLineOffset: 'bad' })) + expect((await loadCache()).providers).toEqual({}) + }) + + it('rejects NaN lastCompleteLineOffset', async () => { + await writeRawCache(wrapFile({ lastCompleteLineOffset: null })) + expect((await loadCache()).providers).toEqual({}) + }) + + it('rejects non-string canonicalCwd', async () => { + await writeRawCache(wrapFile({ canonicalCwd: 42 })) + expect((await loadCache()).providers).toEqual({}) + }) + + it('accepts optional fields when absent', async () => { + const cache: SessionCache = { + version: CACHE_VERSION, + providers: { claude: { envFingerprint: 'x', files: { + '/f': { fingerprint: { dev: 1, ino: 2, mtimeMs: 3, sizeBytes: 4 }, mcpInventory: [], turns: [] }, + } } }, + } + await writeRawCache(cache) + expect((await loadCache())).toEqual(cache) + }) + + it('accepts a fully valid cache with all fields populated', async () => { + const cache: SessionCache = { + version: CACHE_VERSION, + providers: { + claude: { + envFingerprint: 'abc', + files: { '/f': makeCachedFile() }, + }, + }, + } + await writeRawCache(cache) + const loaded = await loadCache() + expect(loaded).toEqual(cache) + }) +}) + +// ── cleanupOrphanedTempFiles ─────────────────────────────────────────── + +describe('cleanupOrphanedTempFiles', () => { + it('removes .tmp files older than 5 minutes', async () => { + await mkdir(TMP_DIR, { recursive: true }) + + const oldTmp = join(TMP_DIR, 'session-cache.json.abc123.tmp') + await writeFile(oldTmp, 'stale') + const { utimes } = await import('fs/promises') + const oldTime = new Date(Date.now() - 10 * 60 * 1000) + await utimes(oldTmp, oldTime, oldTime) + + await cleanupOrphanedTempFiles() + expect(existsSync(oldTmp)).toBe(false) + }) + + it('preserves recent .tmp files', async () => { + await mkdir(TMP_DIR, { recursive: true }) + + const recentTmp = join(TMP_DIR, 'session-cache.json.def456.tmp') + await writeFile(recentTmp, 'recent') + + await cleanupOrphanedTempFiles() + expect(existsSync(recentTmp)).toBe(true) + }) + + it('ignores .tmp files from other caches', async () => { + await mkdir(TMP_DIR, { recursive: true }) + + const otherTmp = join(TMP_DIR, 'codex-results.json.abc123.tmp') + await writeFile(otherTmp, 'other cache temp') + const { utimes } = await import('fs/promises') + const oldTime = new Date(Date.now() - 10 * 60 * 1000) + await utimes(otherTmp, oldTime, oldTime) + + await cleanupOrphanedTempFiles() + expect(existsSync(otherTmp)).toBe(true) + }) + + it('does not fail when cache dir does not exist', async () => { + process.env['CODEBURN_CACHE_DIR'] = '/no/such/dir' + await cleanupOrphanedTempFiles() + }) +}) diff --git a/tests/setup/env-isolation.ts b/tests/setup/env-isolation.ts new file mode 100644 index 0000000..7d638a4 --- /dev/null +++ b/tests/setup/env-isolation.ts @@ -0,0 +1,111 @@ +// Vitest setup file: isolates every test from the developer's shell environment. +// +// codeburn discovers sessions through a long list of provider-specific env +// vars (CLAUDE_CONFIG_DIR, CODEX_HOME, CRUSH_GLOBAL_DATA, …) and via HOME / +// XDG_* / APPDATA / LOCALAPPDATA. Without this file, any value set in the +// developer's shell (e.g. CLAUDE_CONFIG_DIRS=/Users/me/.claude:…) bleeds into +// fixture-based tests: the parser reads the developer's REAL sessions instead +// of the temp-dir fixture, producing nonsense totals and false failures that +// pass on a clean CI runner. +// +// What this file does: +// 1. Mints an empty sandbox temp dir once per worker. +// 2. REDIRECTED vars (HOME / XDG_* / APPDATA / LOCALAPPDATA) point at the +// sandbox so any fallback to homedir() / platform defaults lands in an +// empty filesystem. +// 3. CLEARED vars (every provider's explicit override) are deleted so a test +// that does NOT set one gets "unconfigured" rather than the dev's value. +// 4. PRESERVED vars (PATH, COLUMNS, …) are snapshotted from the dev's shell +// and restored every test. We can't wipe them - Node uses PATH for spawn +// and module resolution, terminal code uses COLUMNS - but a test that +// mutates them shouldn't leak the change into the next test. +// 5. Re-asserts the above before EVERY test (global beforeEach), so a test +// that mutates an env var doesn't leak its value into the next test. +// Tests can freely set process.env['HOME'] = customDir without saving the +// previous value - the next test gets a fresh sandbox baseline. +// +// CAVEAT: env vars set in a test file's beforeAll() get overwritten by this +// file's beforeEach before each test runs. Use beforeEach (not beforeAll) when +// the test body depends on a specific env var value. + +import { mkdtempSync } from 'fs' +import { tmpdir } from 'os' +import { join } from 'path' +import { beforeEach } from 'vitest' + +const sandbox = mkdtempSync(join(tmpdir(), 'codeburn-test-env-')) + +const REDIRECTED = [ + 'HOME', + 'XDG_CONFIG_HOME', + 'XDG_DATA_HOME', + 'XDG_CACHE_HOME', + 'XDG_STATE_HOME', + 'APPDATA', + 'LOCALAPPDATA', +] as const + +const CLEARED = [ + // Provider session-discovery dirs + 'CLAUDE_CONFIG_DIR', + 'CLAUDE_CONFIG_DIRS', + 'CODEX_HOME', + 'CRUSH_GLOBAL_DATA', + 'CODEBUFF_DATA_DIR', + 'FACTORY_DIR', + 'GOOSE_PATH_ROOT', + 'GROK_HOME', + 'KIRO_HOME', + 'KIMI_SHARE_DIR', + 'MUX_ROOT', + 'QWEN_DATA_DIR', + 'VIBE_HOME', + 'WARP_DB_PATH', + 'ZS_DATA_DIR', + // codeburn override dirs / paths + 'CODEBURN_CACHE_DIR', + 'CODEBURN_COPILOT_JETBRAINS_DIR', + 'CODEBURN_COPILOT_OTEL_DB', + 'CODEBURN_COPILOT_SESSION_STATE_DIR', + 'CODEBURN_COPILOT_WS_STORAGE_DIR', + 'CODEBURN_DESKTOP_SESSIONS_DIR', + 'CODEBURN_MUX_DIR', + 'CODEBURN_ANTIGRAVITY_SETTINGS_PATH', + // codeburn behavior toggles (set by the dev to tweak local runs) + 'CODEBURN_COPILOT_DISABLE_OTEL', + 'CODEBURN_TZ', + 'CODEBURN_VERBOSE', + 'CODEBURN_CURSOR_MAX_BUBBLES', + 'CODEBURN_FORCE_MACOS_MAJOR', + // Provider model/credential overrides + 'KIMI_MODEL_NAME', + 'AI_GATEWAY_API_KEY', + 'VERCEL_OIDC_TOKEN', + // Read by detectBashBloat - a dev's real shell limit must not bleed in + 'BASH_MAX_OUTPUT_LENGTH', +] as const + +// Snapshotted from the dev's shell and restored every test. These can't be +// wiped (Node needs PATH for spawn / module resolution, dashboard/table layout +// reads COLUMNS) but a test that mutates them shouldn't leak. +const PRESERVED = ['PATH', 'COLUMNS'] as const +const preservedSnapshot = new Map<string, string | undefined>() +for (const key of PRESERVED) preservedSnapshot.set(key, process.env[key]) + +function applyIsolation(): void { + for (const key of REDIRECTED) process.env[key] = sandbox + for (const key of CLEARED) delete process.env[key] + for (const key of PRESERVED) { + const original = preservedSnapshot.get(key) + if (original === undefined) delete process.env[key] + else process.env[key] = original + } + // Pin the timezone so date grouping is deterministic regardless of the dev's + // shell TZ. Clearing it is not enough (Node falls back to the OS zone); a + // non-UTC TZ would otherwise shift day buckets versus a clean CI runner. A + // test that needs a specific zone can still set process.env.TZ in beforeEach. + process.env.TZ = 'UTC' +} + +applyIsolation() +beforeEach(applyIsolation) diff --git a/tests/sharing/approve.test.ts b/tests/sharing/approve.test.ts new file mode 100644 index 0000000..b8872ec --- /dev/null +++ b/tests/sharing/approve.test.ts @@ -0,0 +1,62 @@ +import { describe, it, expect, beforeAll, afterAll } from 'vitest' + +import { generateIdentity, type Identity } from '../../src/sharing/identity.js' +import { PeerStore, pairingCode } from '../../src/sharing/pairing.js' +import { ShareServer } from '../../src/sharing/share-server.js' +import { pairRequest, fetchUsage } from '../../src/sharing/client.js' + +describe('pairingCode', () => { + it('is order-independent, deterministic, and 3 digits', () => { + expect(pairingCode('aaa', 'bbb')).toBe(pairingCode('bbb', 'aaa')) + expect(pairingCode('aaa', 'bbb')).toMatch(/^\d{3}$/) + expect(pairingCode('aaa', 'bbb')).toBe(pairingCode('aaa', 'bbb')) + }) +}) + +describe('approve-style pairing (no PIN)', () => { + let server: ShareServer + let serverId: Identity + let clientId: Identity + let port: number + let seenCode = '' + + beforeAll(async () => { + serverId = await generateIdentity('MacBook') + clientId = await generateIdentity('Mac Studio') + server = new ShareServer({ + identity: serverId, + peers: new PeerStore(), + getUsage: async () => ({ current: { cost: 7 } }), + approve: async (req) => { + seenCode = req.code + return req.name !== 'Intruder' + }, + }) + port = await server.listen(0, '127.0.0.1') + }) + + afterAll(async () => { + await server.close() + }) + + const ep = () => ({ identity: clientId, host: '127.0.0.1', port, expectedFingerprint: serverId.fingerprint }) + + it('accepts an approved device, with the same code on both sides, and the token works', async () => { + const r = await pairRequest(ep(), 'Mac Studio') + expect(r.status).toBe(200) + const body = r.json as { token: string; code: string } + expect(body.token).toBeTruthy() + // Both ends derive the same confirmation code from the two fingerprints. + expect(body.code).toBe(pairingCode(serverId.fingerprint, clientId.fingerprint)) + expect(seenCode).toBe(body.code) + + const usage = await fetchUsage(ep(), body.token) + expect(usage.status).toBe(200) + expect((usage.json as { current: { cost: number } }).current.cost).toBe(7) + }) + + it('rejects a declined device', async () => { + const r = await pairRequest(ep(), 'Intruder') + expect(r.status).toBe(403) + }) +}) diff --git a/tests/sharing/connect-timeout.test.ts b/tests/sharing/connect-timeout.test.ts new file mode 100644 index 0000000..3a7f658 --- /dev/null +++ b/tests/sharing/connect-timeout.test.ts @@ -0,0 +1,15 @@ +import { describe, it, expect } from 'vitest' + +import { generateIdentity } from '../../src/sharing/identity.js' +import { hello } from '../../src/sharing/client.js' + +describe('peer connect timeout', () => { + it('fails fast when a peer is unreachable instead of riding the OS connect timeout', async () => { + const id = await generateIdentity('Test') + // RFC5737 TEST-NET-1 is reserved and black-holed: the SYN gets no answer, + // so without the connect-phase cap this would hang ~75s on macOS. + const start = Date.now() + await expect(hello({ identity: id, host: '192.0.2.1', port: 7777 })).rejects.toThrow() + expect(Date.now() - start).toBeLessThan(6000) + }, 15000) +}) diff --git a/tests/sharing/host.test.ts b/tests/sharing/host.test.ts new file mode 100644 index 0000000..39db688 --- /dev/null +++ b/tests/sharing/host.test.ts @@ -0,0 +1,258 @@ +import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest' +import { mkdtemp, rm } from 'fs/promises' +import { join } from 'path' +import { tmpdir } from 'os' + +import { addRemote, pullDevices, renderDevices, summarizeDeviceUsage, type DeviceUsage } from '../../src/sharing/host.js' + +const clientMock = vi.hoisted(() => ({ + hello: vi.fn(), + pair: vi.fn(), + pairRequest: vi.fn(), + fetchUsage: vi.fn(), +})) + +vi.mock('../../src/sharing/client.js', () => clientMock) + +describe('host device flow', () => { + let dir: string + + beforeEach(async () => { + vi.clearAllMocks() + dir = await mkdtemp(join(tmpdir(), 'cb-host-')) + }) + + afterEach(async () => { + await rm(dir, { recursive: true, force: true }) + }) + + it('pairs, persists, pulls both devices, and combines', async () => { + const remoteUsage = { current: { cost: 100, calls: 10, sessions: 2, inputTokens: 1000, outputTokens: 200 } } + clientMock.hello.mockResolvedValue({ status: 200, json: { fingerprint: 'remote-fp', name: 'MacBook' } }) + clientMock.pair.mockResolvedValue({ status: 200, json: { token: 'remote-token' } }) + clientMock.fetchUsage.mockResolvedValue({ status: 200, json: remoteUsage }) + + const device = await addRemote('127.0.0.1:7777', '123456', { defaultPort: 7777, dir }) + expect(device.name).toBe('MacBook') + expect(device.token).toBeTruthy() + + const localUsage = { current: { cost: 50, calls: 5, sessions: 1, inputTokens: 500, outputTokens: 100 } } + const results = await pullDevices(async () => localUsage, { period: 'month' }, 'Mac Studio', { dir }) + + expect(results).toHaveLength(2) + expect(results[0]!.local).toBe(true) + expect(results[0]!.payload!.current!.cost).toBe(50) + const remote = results.find((r) => !r.local)! + expect(remote.name).toBe('MacBook') + expect(remote.payload!.current!.cost).toBe(100) + expect(clientMock.fetchUsage).toHaveBeenCalledWith( + expect.objectContaining({ host: '127.0.0.1', port: 7777, expectedFingerprint: 'remote-fp' }), + 'remote-token', + { period: 'month' }, + ) + + const text = renderDevices(results) + expect(text).toContain('Mac Studio (this Mac)') + expect(text).toContain('MacBook') + expect(text).toContain('Combined') + expect(text).toContain('150') // combined cost 50 + 100 + }) + + it('renders an unreachable device as an error without dropping the combined row', () => { + const results: DeviceUsage[] = [ + { id: 'local', name: 'Mac Studio', local: true, payload: { current: { cost: 10, calls: 1, sessions: 1, inputTokens: 1, outputTokens: 1 } } }, + { id: 'remote-1', name: 'MacBook', local: false, error: 'connection refused' }, + ] + const text = renderDevices(results) + expect(text).toContain('connection refused') + expect(text).toContain('Combined') + }) + + it('summarizes reachable devices and excludes error rows from combined totals', () => { + const results: DeviceUsage[] = [ + { + id: 'local', + name: 'Mac Studio', + local: true, + payload: { + current: { cost: 10, calls: 2, sessions: 1, inputTokens: 100, outputTokens: 40 }, + history: { + daily: [ + { cacheWriteTokens: 5, cacheReadTokens: 10 }, + { cacheWriteTokens: 7, cacheReadTokens: 3 }, + ], + }, + }, + }, + { + id: 'remote-1', + name: 'MacBook', + local: false, + payload: { + current: { cost: 3, calls: 4, sessions: 2, inputTokens: 20, outputTokens: 30 }, + history: { daily: [{ cacheWriteTokens: 2, cacheReadTokens: 8 }] }, + }, + }, + { id: 'remote-err', name: 'Offline', local: false, error: 'timeout' }, + ] + + const summary = summarizeDeviceUsage(results) + + expect(summary.perDevice).toEqual([ + { + id: 'local', + name: 'Mac Studio', + local: true, + cost: 10, + calls: 2, + sessions: 1, + inputTokens: 100, + outputTokens: 40, + cacheCreateTokens: 12, + cacheReadTokens: 13, + totalTokens: 165, + }, + { + id: 'remote-1', + name: 'MacBook', + local: false, + cost: 3, + calls: 4, + sessions: 2, + inputTokens: 20, + outputTokens: 30, + cacheCreateTokens: 2, + cacheReadTokens: 8, + totalTokens: 60, + }, + { + id: 'remote-err', + name: 'Offline', + local: false, + error: 'timeout', + cost: 0, + calls: 0, + sessions: 0, + inputTokens: 0, + outputTokens: 0, + cacheCreateTokens: 0, + cacheReadTokens: 0, + totalTokens: 0, + }, + ]) + expect(summary.combined).toEqual({ + cost: 13, + calls: 6, + sessions: 3, + inputTokens: 120, + outputTokens: 70, + cacheCreateTokens: 14, + cacheReadTokens: 21, + totalTokens: 225, + deviceCount: 3, + reachableCount: 2, + }) + }) + + it('scopes cache-token summaries to the optional window without changing no-window totals', () => { + const results: DeviceUsage[] = [ + { + id: 'local', + name: 'Mac Studio', + local: true, + payload: { + current: { cost: 1, calls: 1, sessions: 1, inputTokens: 100, outputTokens: 50 }, + history: { + daily: [ + { date: '2026-04-09', cacheWriteTokens: 100, cacheReadTokens: 1000 }, + { date: '2026-04-10', cacheWriteTokens: 5, cacheReadTokens: 10 }, + { date: '2026-04-11', cacheWriteTokens: 7, cacheReadTokens: 3 }, + ], + }, + }, + }, + { + id: 'remote-1', + name: 'MacBook', + local: false, + payload: { + current: { cost: 2, calls: 2, sessions: 1, inputTokens: 20, outputTokens: 30 }, + history: { + daily: [ + { date: '2026-04-08', cacheWriteTokens: 11, cacheReadTokens: 13 }, + { date: '2026-04-10', cacheWriteTokens: 2, cacheReadTokens: 8 }, + ], + }, + }, + }, + ] + + const all = summarizeDeviceUsage(results) + expect(all.perDevice[0]).toMatchObject({ + cacheCreateTokens: 112, + cacheReadTokens: 1013, + totalTokens: 1275, + }) + expect(all.perDevice[1]).toMatchObject({ + cacheCreateTokens: 13, + cacheReadTokens: 21, + totalTokens: 84, + }) + expect(all.combined).toMatchObject({ + inputTokens: 120, + outputTokens: 80, + cacheCreateTokens: 125, + cacheReadTokens: 1034, + totalTokens: 1359, + }) + + const scoped = summarizeDeviceUsage(results, { start: '2026-04-10', end: '2026-04-10' }) + expect(scoped.perDevice[0]).toMatchObject({ + cacheCreateTokens: 5, + cacheReadTokens: 10, + totalTokens: 165, + }) + expect(scoped.perDevice[1]).toMatchObject({ + cacheCreateTokens: 2, + cacheReadTokens: 8, + totalTokens: 60, + }) + expect(scoped.combined).toMatchObject({ + cost: 3, + calls: 3, + sessions: 2, + inputTokens: 120, + outputTokens: 80, + cacheCreateTokens: 7, + cacheReadTokens: 18, + totalTokens: 225, + deviceCount: 2, + reachableCount: 2, + }) + }) + + it('prefers period-scoped current cache tokens over the 365-day daily history (#583)', () => { + const results: DeviceUsage[] = [ + { + id: 'local', + name: 'Mac', + local: true, + payload: { + current: { cost: 1, calls: 1, sessions: 1, inputTokens: 100, outputTokens: 50, cacheReadTokens: 42, cacheWriteTokens: 7 }, + history: { + daily: [ + // A full 365-day backfill whose cache dwarfs the selected period. + { date: '2025-08-01', cacheWriteTokens: 900, cacheReadTokens: 5000 }, + { date: '2026-04-10', cacheWriteTokens: 3, cacheReadTokens: 8 }, + ], + }, + }, + }, + ] + + const summary = summarizeDeviceUsage(results) + // Reads current (7 / 42), not the inflated daily-history sum (903 / 5008). + expect(summary.perDevice[0]).toMatchObject({ cacheCreateTokens: 7, cacheReadTokens: 42 }) + expect(summary.combined).toMatchObject({ cacheCreateTokens: 7, cacheReadTokens: 42 }) + }) +}) diff --git a/tests/sharing/pairing.test.ts b/tests/sharing/pairing.test.ts new file mode 100644 index 0000000..cd950c1 --- /dev/null +++ b/tests/sharing/pairing.test.ts @@ -0,0 +1,112 @@ +import { describe, it, expect } from 'vitest' + +import { + certFingerprint, + generatePin, + constantTimeEqual, + mintToken, + PairingWindow, + PeerStore, +} from '../../src/sharing/pairing.js' + +describe('certFingerprint', () => { + it('is a deterministic 64-char hex digest', () => { + const fp = certFingerprint('cert-bytes') + expect(fp).toMatch(/^[0-9a-f]{64}$/) + expect(certFingerprint('cert-bytes')).toBe(fp) + }) + it('differs for different certs', () => { + expect(certFingerprint('a')).not.toBe(certFingerprint('b')) + }) +}) + +describe('generatePin', () => { + it('is always 6 digits', () => { + for (let i = 0; i < 200; i++) expect(generatePin()).toMatch(/^\d{6}$/) + }) + it('varies', () => { + const pins = new Set(Array.from({ length: 50 }, () => generatePin())) + expect(pins.size).toBeGreaterThan(1) + }) +}) + +describe('constantTimeEqual', () => { + it('matches equal strings and rejects different ones', () => { + expect(constantTimeEqual('abc', 'abc')).toBe(true) + expect(constantTimeEqual('abc', 'abd')).toBe(false) + expect(constantTimeEqual('abc', 'abcd')).toBe(false) + }) +}) + +describe('mintToken', () => { + it('is url-safe and unique', () => { + const a = mintToken() + const b = mintToken() + expect(a).toMatch(/^[A-Za-z0-9_-]+$/) + expect(a).not.toBe(b) + }) +}) + +describe('PairingWindow', () => { + it('accepts the correct PIN within the window', () => { + const w = new PairingWindow(1000, 1000, '123456') + expect(w.verify('123456', 1500)).toBe(true) + }) + it('rejects a wrong PIN', () => { + const w = new PairingWindow(1000, 1000, '123456') + expect(w.verify('000000', 1200)).toBe(false) + }) + it('rejects after the window expires', () => { + const w = new PairingWindow(1000, 1000, '123456') + expect(w.isOpen(3000)).toBe(false) + expect(w.verify('123456', 3000)).toBe(false) + }) + it('is one-time: a consumed PIN cannot be reused', () => { + const w = new PairingWindow(10_000, 1000, '123456') + expect(w.verify('123456', 1100)).toBe(true) + expect(w.verify('123456', 1200)).toBe(false) + }) + it('closes after too many wrong guesses (no brute force within the window)', () => { + const w = new PairingWindow(10_000, 1000, '123456', 5) + for (let i = 0; i < 5; i++) expect(w.verify('000000', 1000 + i)).toBe(false) + // window is now locked even though the TTL has not expired + expect(w.isOpen(1100)).toBe(false) + // and the correct PIN no longer works + expect(w.verify('123456', 1100)).toBe(false) + }) +}) + +describe('PeerStore', () => { + it('authorizes only when token AND fingerprint both match the same peer', () => { + const store = new PeerStore() + const a = store.pair('fp-aaa', 'MacBook') + const b = store.pair('fp-bbb', 'Mac Studio') + + // correct pairing + expect(store.authorize(a.token, 'fp-aaa')).toBe(true) + // right token, wrong device fingerprint -> denied (stolen-token defense) + expect(store.authorize(a.token, 'fp-bbb')).toBe(false) + // wrong token on the right device -> denied + expect(store.authorize('not-the-token', 'fp-aaa')).toBe(false) + // unknown device -> denied + expect(store.authorize(a.token, 'fp-ccc')).toBe(false) + expect(store.authorize(b.token, 'fp-bbb')).toBe(true) + }) + + it('revokes a peer on unpair', () => { + const store = new PeerStore() + const p = store.pair('fp-x', 'Laptop') + expect(store.authorize(p.token, 'fp-x')).toBe(true) + expect(store.unpair('fp-x')).toBe(true) + expect(store.authorize(p.token, 'fp-x')).toBe(false) + expect(store.list()).toHaveLength(0) + }) + + it('round-trips through serializable peer records', () => { + const store = new PeerStore() + store.pair('fp-1', 'A') + const restored = new PeerStore(store.list()) + const peer = restored.list()[0]! + expect(restored.authorize(peer.token, 'fp-1')).toBe(true) + }) +}) diff --git a/tests/sharing/sanitize.test.ts b/tests/sharing/sanitize.test.ts new file mode 100644 index 0000000..6ad7458 --- /dev/null +++ b/tests/sharing/sanitize.test.ts @@ -0,0 +1,46 @@ +import { describe, it, expect } from 'vitest' + +import { sanitizeForSharing } from '../../src/sharing/sanitize.js' +import type { MenubarPayload } from '../../src/menubar-json.js' + +function fixture(): MenubarPayload { + return { + generated: 'now', + current: { + label: 'June', + cost: 100, + calls: 5, + sessions: 2, + oneShotRate: 1, + inputTokens: 10, + outputTokens: 20, + cacheHitPercent: 90, + codexCredits: 0, + topActivities: [{ name: 'Coding', cost: 50, savingsUSD: 0, turns: 3, oneShotRate: 1 }], + topModels: [{ name: 'Opus', cost: 80, savingsUSD: 0, savingsBaselineModel: '', calls: 4 }], + providers: { claude: 100 }, + topProjects: [ + { name: 'secret-project', cost: 100, savingsUSD: 0, sessions: 2, avgCostPerSession: 50, sessionDetails: [] }, + ], + tools: [{ name: 'Bash', calls: 9 }], + topSessions: [{ project: 'secret-project', cost: 100, savingsUSD: 0, calls: 5, date: '2026-06-01' }], + }, + history: { daily: [] }, + } as unknown as MenubarPayload +} + +describe('sanitizeForSharing', () => { + it('strips project names and session detail but keeps aggregates', () => { + const clean = sanitizeForSharing(fixture()) + expect(clean.current.topProjects).toEqual([]) + expect(clean.current.topSessions).toEqual([]) + expect(clean.current.cost).toBe(100) + expect(clean.current.topModels[0]!.name).toBe('Opus') + expect(clean.current.providers).toEqual({ claude: 100 }) + }) + + it('leaks no project name anywhere in the shared payload', () => { + const clean = sanitizeForSharing(fixture()) + expect(JSON.stringify(clean)).not.toContain('secret-project') + }) +}) diff --git a/tests/sharing/transport.test.ts b/tests/sharing/transport.test.ts new file mode 100644 index 0000000..473ab50 --- /dev/null +++ b/tests/sharing/transport.test.ts @@ -0,0 +1,148 @@ +import { describe, it, expect, beforeAll, afterAll } from 'vitest' + +import { generateIdentity, type Identity } from '../../src/sharing/identity.js' +import { PeerStore } from '../../src/sharing/pairing.js' +import { ShareServer } from '../../src/sharing/share-server.js' +import { getDateRange, parsePeriodOrThrow } from '../../src/cli-date.js' +import { hello, pair, fetchUsage } from '../../src/sharing/client.js' + +describe('device sharing transport (loopback mutual TLS)', () => { + let server: ShareServer + let serverId: Identity + let clientId: Identity + let peers: PeerStore + let port: number + + beforeAll(async () => { + serverId = await generateIdentity('MacBook') + clientId = await generateIdentity('Mac Studio') + peers = new PeerStore() + server = new ShareServer({ identity: serverId, peers, getUsage: async () => ({ current: { cost: 42 } }) }) + port = await server.listen(0, '127.0.0.1') + }) + + afterAll(async () => { + await server.close() + }) + + const ep = () => ({ identity: clientId, host: '127.0.0.1', port }) + + it('hello exposes name + fingerprint, and the client sees the right cert', async () => { + const r = await hello(ep()) + expect(r.status).toBe(200) + const body = r.json as { name: string; fingerprint: string } + expect(body.name).toBe('MacBook') + expect(body.fingerprint).toBe(serverId.fingerprint) + expect(r.serverFingerprint).toBe(serverId.fingerprint) + }) + + it('denies usage before pairing', async () => { + const r = await fetchUsage(ep(), 'no-token') + expect(r.status).toBe(401) + }) + + it('pairs with a valid PIN, then authorizes a pinned usage pull', async () => { + const pin = server.openPairing() + const pr = await pair(ep(), pin, 'Mac Studio') + expect(pr.status).toBe(200) + const token = (pr.json as { token: string }).token + expect(token).toBeTruthy() + + const ur = await fetchUsage({ ...ep(), expectedFingerprint: serverId.fingerprint }, token) + expect(ur.status).toBe(200) + expect((ur.json as { current: { cost: number } }).current.cost).toBe(42) + }) + + it('returns bad request when getUsage rejects an invalid period', async () => { + const badServer = new ShareServer({ + identity: serverId, + peers, + getUsage: async (q) => { + getDateRange(parsePeriodOrThrow(q.period ?? 'month')) + return { current: { cost: 0 } } + }, + }) + const badPort = await badServer.listen(0, '127.0.0.1') + try { + const pin = badServer.openPairing() + const pr = await pair({ ...ep(), port: badPort }, pin, 'Mac Studio') + const token = (pr.json as { token: string }).token + const ur = await fetchUsage( + { ...ep(), port: badPort, expectedFingerprint: serverId.fingerprint }, + token, + { period: 'garbage' }, + ) + expect(ur.status).toBe(400) + expect((ur.json as { error: string }).error).toMatch(/Unknown period "garbage"/) + } finally { + await badServer.close() + } + }) + + it('keeps unexpected getUsage failures as internal errors', async () => { + const badServer = new ShareServer({ + identity: serverId, + peers, + getUsage: async () => { + throw new Error('database temporarily unavailable') + }, + }) + const badPort = await badServer.listen(0, '127.0.0.1') + try { + const pin = badServer.openPairing() + const pr = await pair({ ...ep(), port: badPort }, pin, 'Mac Studio') + const token = (pr.json as { token: string }).token + const ur = await fetchUsage( + { ...ep(), port: badPort, expectedFingerprint: serverId.fingerprint }, + token, + ) + expect(ur.status).toBe(500) + expect((ur.json as { error: string }).error).toMatch(/database temporarily unavailable/) + } finally { + await badServer.close() + } + }) + + it('does not classify plain string-matched errors as usage validation errors', async () => { + const badServer = new ShareServer({ + identity: serverId, + peers, + getUsage: async () => { + throw new Error('Unknown period "garbage". Valid values: today, week, 30days, month, all.') + }, + }) + const badPort = await badServer.listen(0, '127.0.0.1') + try { + const pin = badServer.openPairing() + const pr = await pair({ ...ep(), port: badPort }, pin, 'Mac Studio') + const token = (pr.json as { token: string }).token + const ur = await fetchUsage( + { ...ep(), port: badPort, expectedFingerprint: serverId.fingerprint }, + token, + ) + expect(ur.status).toBe(500) + expect((ur.json as { error: string }).error).toMatch(/Unknown period "garbage"/) + } finally { + await badServer.close() + } + }) + + it('rejects a wrong PIN', async () => { + server.openPairing() + const pr = await pair(ep(), '000000', 'x') + expect(pr.status).toBe(401) + }) + + it('rejects a token replayed from a different device fingerprint', async () => { + const pin = server.openPairing() + const pr = await pair(ep(), pin, 'Mac Studio') + const token = (pr.json as { token: string }).token + const attacker = await generateIdentity('Evil') + const r = await fetchUsage({ identity: attacker, host: '127.0.0.1', port }, token) + expect(r.status).toBe(401) + }) + + it('aborts when the peer fingerprint does not match the pin', async () => { + await expect(hello({ ...ep(), expectedFingerprint: 'deadbeef' })).rejects.toThrow(/fingerprint mismatch/) + }) +}) diff --git a/tests/usage-aggregator.test.ts b/tests/usage-aggregator.test.ts new file mode 100644 index 0000000..3a47c7f --- /dev/null +++ b/tests/usage-aggregator.test.ts @@ -0,0 +1,25 @@ +import { describe, expect, it, beforeAll } from 'vitest' +import { buildMenubarPayloadForRange } from '../src/usage-aggregator.js' +import { getDateRange } from '../src/cli-date.js' +import { loadPricing } from '../src/models.js' + +describe('buildMenubarPayloadForRange', () => { + beforeAll(async () => { + await loadPricing() + }) + + it('returns a valid payload and skips optimize findings when optimize:false', async () => { + const payload = await buildMenubarPayloadForRange(getDateRange('today'), { provider: 'all', optimize: false }) + expect(typeof payload.current.label).toBe('string') + expect(payload.current.cost).toBeGreaterThanOrEqual(0) + expect(Array.isArray(payload.current.topProjects)).toBe(true) + expect(Array.isArray(payload.current.topModels)).toBe(true) + expect(Array.isArray(payload.history.daily)).toBe(true) + expect(payload.current.retryTax.totalUSD).toBeGreaterThanOrEqual(0) + // Codex credits are always present in the payload (display gates them); 0 with no data. + expect(typeof payload.current.codexCredits).toBe('number') + expect(payload.current.codexCredits).toBeGreaterThanOrEqual(0) + // optimize:false => scanAndDetect skipped => empty optimize block regardless of data + expect(payload.optimize).toEqual({ findingCount: 0, savingsUSD: 0, topFindings: [] }) + }) +}) diff --git a/tests/web-dashboard.test.ts b/tests/web-dashboard.test.ts new file mode 100644 index 0000000..f8858ca --- /dev/null +++ b/tests/web-dashboard.test.ts @@ -0,0 +1,59 @@ +import { mkdtemp, rm } from 'fs/promises' +import { tmpdir } from 'os' +import { join } from 'path' +import type { AddressInfo } from 'net' +import type { Server } from 'http' + +import { afterAll, beforeAll, describe, expect, it } from 'vitest' + +import { runWebDashboard } from '../src/web-dashboard.js' + +// Regression guard for the original bug: a bad `period` query used to hit +// process.exit(1) and kill the long-running dashboard server. The handlers must +// now answer 400 and keep serving. +describe('web dashboard server: invalid query returns 400 without exiting', () => { + let server: Server + let base: string + let homeDir: string + let cacheDir: string + const prevHome = process.env['HOME'] + const prevCache = process.env['CODEBURN_CACHE_DIR'] + + beforeAll(async () => { + homeDir = await mkdtemp(join(tmpdir(), 'codeburn-web-home-')) + cacheDir = await mkdtemp(join(tmpdir(), 'codeburn-web-cache-')) + process.env['HOME'] = homeDir + process.env['CODEBURN_CACHE_DIR'] = cacheDir + server = await runWebDashboard({ + period: 'today', provider: 'all', project: [], exclude: [], port: 0, open: false, + }) + base = `http://127.0.0.1:${(server.address() as AddressInfo).port}` + }) + + afterAll(async () => { + await new Promise<void>((resolve) => server.close(() => resolve())) + if (prevHome === undefined) delete process.env['HOME'] + else process.env['HOME'] = prevHome + if (prevCache === undefined) delete process.env['CODEBURN_CACHE_DIR'] + else process.env['CODEBURN_CACHE_DIR'] = prevCache + await rm(homeDir, { recursive: true, force: true }) + await rm(cacheDir, { recursive: true, force: true }) + }) + + it('answers 400 for an invalid /api/usage period and keeps serving', async () => { + const bad = await fetch(`${base}/api/usage?period=garbage`) + expect(bad.status).toBe(400) + expect((await bad.json() as { error: string }).error).toMatch(/Unknown period "garbage"/) + + // The bug was process.exit; if it regressed, this test process would die. + // A successful follow-up request proves the server survived the bad one. + const ok = await fetch(`${base}/api/usage?period=today`) + expect(ok.status).toBe(200) + }) + + it('answers 400 for an invalid /api/devices period', async () => { + const bad = await fetch(`${base}/api/devices?period=garbage`) + expect(bad.status).toBe(400) + expect((await bad.json() as { error: string }).error).toMatch(/Unknown period "garbage"/) + }) +}) diff --git a/tests/yield.test.ts b/tests/yield.test.ts new file mode 100644 index 0000000..8a6f31d --- /dev/null +++ b/tests/yield.test.ts @@ -0,0 +1,58 @@ +import { describe, expect, it } from 'vitest' + +import { buildYieldJsonReport, type YieldSummary } from '../src/yield.js' + +describe('buildYieldJsonReport', () => { + it('serializes yield buckets, ratios, and session details', () => { + const summary: YieldSummary = { + productive: { cost: 8, sessions: 2 }, + reverted: { cost: 2, sessions: 1 }, + abandoned: { cost: 10, sessions: 1 }, + total: { cost: 20, sessions: 4 }, + details: [ + { sessionId: 's1', project: 'app', cost: 8, category: 'productive', commitCount: 2 }, + { sessionId: 's2', project: 'app', cost: 2, category: 'reverted', commitCount: 1 }, + ], + } + const report = buildYieldJsonReport(summary, '30 Days', { + start: new Date('2026-05-01T00:00:00.000Z'), + end: new Date('2026-05-31T23:59:59.999Z'), + }) + + expect(report.period).toEqual({ + label: '30 Days', + start: '2026-05-01T00:00:00.000Z', + end: '2026-05-31T23:59:59.999Z', + }) + expect(report.summary.productive).toEqual({ + costUSD: 8, + sessions: 2, + costPercent: 40, + sessionPercent: 50, + }) + expect(report.summary.reverted.costPercent).toBe(10) + expect(report.summary.abandoned.sessionPercent).toBe(25) + expect(report.summary.total).toEqual({ costUSD: 20, sessions: 4 }) + expect(report.summary.productiveToRevertedCostRatio).toBe(4) + expect(report.details).toHaveLength(2) + expect(report.details[0]).toMatchObject({ sessionId: 's1', costUSD: 8, category: 'productive' }) + expect(report.details[0]).not.toHaveProperty('cost') + }) + + it('uses null ratio when no spend was reverted', () => { + const summary: YieldSummary = { + productive: { cost: 1, sessions: 1 }, + reverted: { cost: 0, sessions: 0 }, + abandoned: { cost: 0, sessions: 0 }, + total: { cost: 1, sessions: 1 }, + details: [], + } + + const report = buildYieldJsonReport(summary, 'Today', { + start: new Date('2026-06-14T00:00:00.000Z'), + end: new Date('2026-06-14T23:59:59.999Z'), + }) + + expect(report.summary.productiveToRevertedCostRatio).toBeNull() + }) +}) diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 0000000..e153610 --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,18 @@ +{ + "compilerOptions": { + "target": "ES2022", + "module": "ESNext", + "moduleResolution": "bundler", + "jsx": "react-jsx", + "strict": true, + "esModuleInterop": true, + "skipLibCheck": true, + "outDir": "dist", + "rootDir": "src", + "declaration": true, + "sourceMap": true, + "resolveJsonModule": true + }, + "include": ["src/**/*"], + "exclude": ["node_modules", "dist", "tests"] +} diff --git a/tsup.config.ts b/tsup.config.ts new file mode 100644 index 0000000..c20e55c --- /dev/null +++ b/tsup.config.ts @@ -0,0 +1,13 @@ +import { defineConfig } from 'tsup' + +export default defineConfig({ + entry: ['src/main.ts'], + format: ['esm'], + target: 'node20', + outDir: 'dist', + clean: true, + splitting: false, + sourcemap: true, + dts: false, + external: ['@modelcontextprotocol/sdk', 'zod'], +}) diff --git a/vitest.config.ts b/vitest.config.ts new file mode 100644 index 0000000..b56c015 --- /dev/null +++ b/vitest.config.ts @@ -0,0 +1,10 @@ +import { defineConfig } from 'vitest/config' + +export default defineConfig({ + test: { + // Runs once per worker before any test. Scrubs the developer's shell so + // session-discovery env vars (CLAUDE_CONFIG_DIRS, HOME, XDG_*, every + // provider-specific *_HOME) don't bleed real local data into fixtures. + setupFiles: ['./tests/setup/env-isolation.ts'], + }, +})

{title}

{page === 'context' ? 'Context' : viewTitle}

Incoming pairing request

Search local devices