wehub-resource-sync
949 lines
36 KiB
TypeScript
949 lines
36 KiB
TypeScript
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)
|
|
})
|
|
})
|