770 lines
25 KiB
TypeScript
770 lines
25 KiB
TypeScript
/**
|
|
* Tests for session log incremental writes and pointer management
|
|
*/
|
|
|
|
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
|
|
import { existsSync, readFileSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
|
|
import { join } from 'node:path';
|
|
import { tmpdir } from 'node:os';
|
|
import {
|
|
createSessionLog,
|
|
updateLatestPointer,
|
|
initNdjsonLog,
|
|
appendNdjsonLine,
|
|
loadNdjsonLog,
|
|
loadSessionLog,
|
|
extractFailureInfo,
|
|
type LatestLogPointer,
|
|
type SessionLog,
|
|
type NdjsonRecord,
|
|
type NdjsonStepComplete,
|
|
type NdjsonPieceComplete,
|
|
type NdjsonPieceAbort,
|
|
type NdjsonPhaseStart,
|
|
type NdjsonPhaseComplete,
|
|
type NdjsonInteractiveStart,
|
|
type NdjsonInteractiveEnd,
|
|
} from '../infra/fs/session.js';
|
|
|
|
/** Create a temp project directory with .takt/logs structure */
|
|
function createTempProject(): string {
|
|
const dir = join(tmpdir(), `takt-test-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
|
|
mkdirSync(dir, { recursive: true });
|
|
return dir;
|
|
}
|
|
|
|
describe('updateLatestPointer', () => {
|
|
let projectDir: string;
|
|
|
|
beforeEach(() => {
|
|
projectDir = createTempProject();
|
|
});
|
|
|
|
afterEach(() => {
|
|
rmSync(projectDir, { recursive: true, force: true });
|
|
});
|
|
|
|
it('should create latest.json with pointer data', () => {
|
|
const log = createSessionLog('my task', projectDir, 'default');
|
|
const sessionId = 'abc-123';
|
|
|
|
updateLatestPointer(log, sessionId, projectDir);
|
|
|
|
const latestPath = join(projectDir, '.takt', 'logs', 'latest.json');
|
|
expect(existsSync(latestPath)).toBe(true);
|
|
|
|
const pointer = JSON.parse(readFileSync(latestPath, 'utf-8')) as LatestLogPointer;
|
|
expect(pointer.sessionId).toBe('abc-123');
|
|
expect(pointer.logFile).toBe('abc-123.jsonl');
|
|
expect(pointer.task).toBe('my task');
|
|
expect(pointer.pieceName).toBe('default');
|
|
expect(pointer.status).toBe('running');
|
|
expect(pointer.iterations).toBe(0);
|
|
expect(pointer.startTime).toBeDefined();
|
|
expect(pointer.updatedAt).toBeDefined();
|
|
});
|
|
|
|
it('should not create previous.json when copyToPrevious is false', () => {
|
|
const log = createSessionLog('task', projectDir, 'wf');
|
|
updateLatestPointer(log, 'sid-1', projectDir);
|
|
|
|
const previousPath = join(projectDir, '.takt', 'logs', 'previous.json');
|
|
expect(existsSync(previousPath)).toBe(false);
|
|
});
|
|
|
|
it('should not create previous.json when copyToPrevious is true but latest.json does not exist', () => {
|
|
const log = createSessionLog('task', projectDir, 'wf');
|
|
updateLatestPointer(log, 'sid-1', projectDir, { copyToPrevious: true });
|
|
|
|
const previousPath = join(projectDir, '.takt', 'logs', 'previous.json');
|
|
// latest.json didn't exist before this call, so previous.json should not be created
|
|
expect(existsSync(previousPath)).toBe(false);
|
|
});
|
|
|
|
it('should copy latest.json to previous.json when copyToPrevious is true and latest exists', () => {
|
|
const log1 = createSessionLog('first task', projectDir, 'wf1');
|
|
updateLatestPointer(log1, 'sid-first', projectDir);
|
|
|
|
// Simulate a second piece starting
|
|
const log2 = createSessionLog('second task', projectDir, 'wf2');
|
|
updateLatestPointer(log2, 'sid-second', projectDir, { copyToPrevious: true });
|
|
|
|
const logsDir = join(projectDir, '.takt', 'logs');
|
|
const latest = JSON.parse(readFileSync(join(logsDir, 'latest.json'), 'utf-8')) as LatestLogPointer;
|
|
const previous = JSON.parse(readFileSync(join(logsDir, 'previous.json'), 'utf-8')) as LatestLogPointer;
|
|
|
|
// latest should point to second session
|
|
expect(latest.sessionId).toBe('sid-second');
|
|
expect(latest.task).toBe('second task');
|
|
|
|
// previous should point to first session
|
|
expect(previous.sessionId).toBe('sid-first');
|
|
expect(previous.task).toBe('first task');
|
|
});
|
|
|
|
it('should not update previous.json on step-complete calls (no copyToPrevious)', () => {
|
|
// Piece 1 creates latest
|
|
const log1 = createSessionLog('first', projectDir, 'wf');
|
|
updateLatestPointer(log1, 'sid-1', projectDir);
|
|
|
|
// Piece 2 starts → copies latest to previous
|
|
const log2 = createSessionLog('second', projectDir, 'wf');
|
|
updateLatestPointer(log2, 'sid-2', projectDir, { copyToPrevious: true });
|
|
|
|
// Step completes → updates only latest (no copyToPrevious)
|
|
log2.iterations = 1;
|
|
updateLatestPointer(log2, 'sid-2', projectDir);
|
|
|
|
const logsDir = join(projectDir, '.takt', 'logs');
|
|
const previous = JSON.parse(readFileSync(join(logsDir, 'previous.json'), 'utf-8')) as LatestLogPointer;
|
|
|
|
// previous should still point to first session
|
|
expect(previous.sessionId).toBe('sid-1');
|
|
});
|
|
|
|
it('should update iterations and status in latest.json on subsequent calls', () => {
|
|
const log = createSessionLog('task', projectDir, 'wf');
|
|
updateLatestPointer(log, 'sid-1', projectDir, { copyToPrevious: true });
|
|
|
|
// Simulate step completion
|
|
log.iterations = 2;
|
|
updateLatestPointer(log, 'sid-1', projectDir);
|
|
|
|
// Simulate piece completion
|
|
log.status = 'completed';
|
|
log.iterations = 3;
|
|
updateLatestPointer(log, 'sid-1', projectDir);
|
|
|
|
const latestPath = join(projectDir, '.takt', 'logs', 'latest.json');
|
|
const pointer = JSON.parse(readFileSync(latestPath, 'utf-8')) as LatestLogPointer;
|
|
expect(pointer.status).toBe('completed');
|
|
expect(pointer.iterations).toBe(3);
|
|
});
|
|
});
|
|
|
|
describe('NDJSON log', () => {
|
|
let projectDir: string;
|
|
|
|
beforeEach(() => {
|
|
projectDir = createTempProject();
|
|
});
|
|
|
|
afterEach(() => {
|
|
rmSync(projectDir, { recursive: true, force: true });
|
|
});
|
|
|
|
describe('initNdjsonLog', () => {
|
|
it('should create a .jsonl file with piece_start record', () => {
|
|
const filepath = initNdjsonLog('sess-001', 'my task', 'default', projectDir);
|
|
|
|
expect(filepath).toContain('sess-001.jsonl');
|
|
expect(existsSync(filepath)).toBe(true);
|
|
|
|
const content = readFileSync(filepath, 'utf-8');
|
|
const lines = content.trim().split('\n');
|
|
expect(lines).toHaveLength(1);
|
|
|
|
const record = JSON.parse(lines[0]!) as NdjsonRecord;
|
|
expect(record.type).toBe('piece_start');
|
|
if (record.type === 'piece_start') {
|
|
expect(record.task).toBe('my task');
|
|
expect(record.pieceName).toBe('default');
|
|
expect(record.startTime).toBeDefined();
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('appendNdjsonLine', () => {
|
|
it('should append records as individual lines', () => {
|
|
const filepath = initNdjsonLog('sess-002', 'task', 'wf', projectDir);
|
|
|
|
const stepStart: NdjsonRecord = {
|
|
type: 'step_start',
|
|
step: 'plan',
|
|
agent: 'planner',
|
|
iteration: 1,
|
|
timestamp: new Date().toISOString(),
|
|
};
|
|
appendNdjsonLine(filepath, stepStart);
|
|
|
|
const stepComplete: NdjsonStepComplete = {
|
|
type: 'step_complete',
|
|
step: 'plan',
|
|
agent: 'planner',
|
|
status: 'done',
|
|
content: 'Plan completed',
|
|
instruction: 'Create a plan',
|
|
timestamp: new Date().toISOString(),
|
|
};
|
|
appendNdjsonLine(filepath, stepComplete);
|
|
|
|
const content = readFileSync(filepath, 'utf-8');
|
|
const lines = content.trim().split('\n');
|
|
expect(lines).toHaveLength(3); // piece_start + step_start + step_complete
|
|
|
|
const parsed0 = JSON.parse(lines[0]!) as NdjsonRecord;
|
|
expect(parsed0.type).toBe('piece_start');
|
|
|
|
const parsed1 = JSON.parse(lines[1]!) as NdjsonRecord;
|
|
expect(parsed1.type).toBe('step_start');
|
|
if (parsed1.type === 'step_start') {
|
|
expect(parsed1.step).toBe('plan');
|
|
expect(parsed1.agent).toBe('planner');
|
|
expect(parsed1.iteration).toBe(1);
|
|
}
|
|
|
|
const parsed2 = JSON.parse(lines[2]!) as NdjsonRecord;
|
|
expect(parsed2.type).toBe('step_complete');
|
|
if (parsed2.type === 'step_complete') {
|
|
expect(parsed2.step).toBe('plan');
|
|
expect(parsed2.content).toBe('Plan completed');
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('loadNdjsonLog', () => {
|
|
it('should reconstruct SessionLog from NDJSON file', () => {
|
|
const filepath = initNdjsonLog('sess-003', 'build app', 'default', projectDir);
|
|
|
|
// Add step_start + step_complete
|
|
appendNdjsonLine(filepath, {
|
|
type: 'step_start',
|
|
step: 'plan',
|
|
agent: 'planner',
|
|
iteration: 1,
|
|
timestamp: '2025-01-01T00:00:01.000Z',
|
|
});
|
|
|
|
const stepComplete: NdjsonStepComplete = {
|
|
type: 'step_complete',
|
|
step: 'plan',
|
|
agent: 'planner',
|
|
status: 'done',
|
|
content: 'Plan completed',
|
|
instruction: 'Create a plan',
|
|
matchedRuleIndex: 0,
|
|
matchedRuleMethod: 'phase3_tag',
|
|
timestamp: '2025-01-01T00:00:02.000Z',
|
|
};
|
|
appendNdjsonLine(filepath, stepComplete);
|
|
|
|
const complete: NdjsonPieceComplete = {
|
|
type: 'piece_complete',
|
|
iterations: 1,
|
|
endTime: '2025-01-01T00:00:03.000Z',
|
|
};
|
|
appendNdjsonLine(filepath, complete);
|
|
|
|
const log = loadNdjsonLog(filepath);
|
|
expect(log).not.toBeNull();
|
|
expect(log!.task).toBe('build app');
|
|
expect(log!.pieceName).toBe('default');
|
|
expect(log!.status).toBe('completed');
|
|
expect(log!.iterations).toBe(1);
|
|
expect(log!.endTime).toBe('2025-01-01T00:00:03.000Z');
|
|
expect(log!.history).toHaveLength(1);
|
|
expect(log!.history[0]!.step).toBe('plan');
|
|
expect(log!.history[0]!.content).toBe('Plan completed');
|
|
expect(log!.history[0]!.matchedRuleIndex).toBe(0);
|
|
expect(log!.history[0]!.matchedRuleMethod).toBe('phase3_tag');
|
|
});
|
|
|
|
it('should handle aborted piece', () => {
|
|
const filepath = initNdjsonLog('sess-004', 'failing task', 'wf', projectDir);
|
|
|
|
appendNdjsonLine(filepath, {
|
|
type: 'step_start',
|
|
step: 'impl',
|
|
agent: 'coder',
|
|
iteration: 1,
|
|
timestamp: '2025-01-01T00:00:01.000Z',
|
|
});
|
|
|
|
appendNdjsonLine(filepath, {
|
|
type: 'step_complete',
|
|
step: 'impl',
|
|
agent: 'coder',
|
|
status: 'error',
|
|
content: 'Failed',
|
|
instruction: 'Do the thing',
|
|
error: 'compile error',
|
|
timestamp: '2025-01-01T00:00:02.000Z',
|
|
} satisfies NdjsonStepComplete);
|
|
|
|
const abort: NdjsonPieceAbort = {
|
|
type: 'piece_abort',
|
|
iterations: 1,
|
|
reason: 'Max iterations reached',
|
|
endTime: '2025-01-01T00:00:03.000Z',
|
|
};
|
|
appendNdjsonLine(filepath, abort);
|
|
|
|
const log = loadNdjsonLog(filepath);
|
|
expect(log).not.toBeNull();
|
|
expect(log!.status).toBe('aborted');
|
|
expect(log!.history[0]!.error).toBe('compile error');
|
|
});
|
|
|
|
it('should return null for non-existent file', () => {
|
|
const result = loadNdjsonLog('/nonexistent/path.jsonl');
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
it('should return null for empty file', () => {
|
|
const logsDir = join(projectDir, '.takt', 'logs');
|
|
mkdirSync(logsDir, { recursive: true });
|
|
const filepath = join(logsDir, 'empty.jsonl');
|
|
writeFileSync(filepath, '', 'utf-8');
|
|
|
|
const result = loadNdjsonLog(filepath);
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
it('should skip step_start records when reconstructing SessionLog', () => {
|
|
const filepath = initNdjsonLog('sess-005', 'task', 'wf', projectDir);
|
|
|
|
// Add various records
|
|
appendNdjsonLine(filepath, {
|
|
type: 'step_start',
|
|
step: 'plan',
|
|
agent: 'planner',
|
|
iteration: 1,
|
|
timestamp: '2025-01-01T00:00:01.000Z',
|
|
});
|
|
|
|
appendNdjsonLine(filepath, {
|
|
type: 'step_complete',
|
|
step: 'plan',
|
|
agent: 'planner',
|
|
status: 'done',
|
|
content: 'Done',
|
|
instruction: 'Plan it',
|
|
timestamp: '2025-01-01T00:00:02.000Z',
|
|
} satisfies NdjsonStepComplete);
|
|
|
|
appendNdjsonLine(filepath, {
|
|
type: 'piece_complete',
|
|
iterations: 1,
|
|
endTime: '2025-01-01T00:00:03.000Z',
|
|
});
|
|
|
|
const log = loadNdjsonLog(filepath);
|
|
expect(log).not.toBeNull();
|
|
// Only step_complete adds to history
|
|
expect(log!.history).toHaveLength(1);
|
|
expect(log!.iterations).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe('loadSessionLog with .jsonl extension', () => {
|
|
it('should delegate to loadNdjsonLog for .jsonl files', () => {
|
|
const filepath = initNdjsonLog('sess-006', 'jsonl task', 'wf', projectDir);
|
|
|
|
appendNdjsonLine(filepath, {
|
|
type: 'step_complete',
|
|
step: 'plan',
|
|
agent: 'planner',
|
|
status: 'done',
|
|
content: 'Plan done',
|
|
instruction: 'Plan',
|
|
timestamp: '2025-01-01T00:00:02.000Z',
|
|
} satisfies NdjsonStepComplete);
|
|
|
|
appendNdjsonLine(filepath, {
|
|
type: 'piece_complete',
|
|
iterations: 1,
|
|
endTime: '2025-01-01T00:00:03.000Z',
|
|
});
|
|
|
|
// loadSessionLog should handle .jsonl
|
|
const log = loadSessionLog(filepath);
|
|
expect(log).not.toBeNull();
|
|
expect(log!.task).toBe('jsonl task');
|
|
expect(log!.status).toBe('completed');
|
|
});
|
|
|
|
it('should still load legacy .json files', () => {
|
|
const logsDir = join(projectDir, '.takt', 'logs');
|
|
mkdirSync(logsDir, { recursive: true });
|
|
const legacyPath = join(logsDir, 'legacy-001.json');
|
|
const legacyLog: SessionLog = {
|
|
task: 'legacy task',
|
|
projectDir,
|
|
pieceName: 'wf',
|
|
iterations: 0,
|
|
startTime: new Date().toISOString(),
|
|
status: 'running',
|
|
history: [],
|
|
};
|
|
writeFileSync(legacyPath, JSON.stringify(legacyLog, null, 2), 'utf-8');
|
|
|
|
const log = loadSessionLog(legacyPath);
|
|
expect(log).not.toBeNull();
|
|
expect(log!.task).toBe('legacy task');
|
|
});
|
|
});
|
|
|
|
describe('appendNdjsonLine real-time characteristics', () => {
|
|
it('should append without overwriting previous content', () => {
|
|
const filepath = initNdjsonLog('sess-007', 'task', 'wf', projectDir);
|
|
|
|
// Read after init
|
|
const after1 = readFileSync(filepath, 'utf-8').trim().split('\n');
|
|
expect(after1).toHaveLength(1);
|
|
|
|
// Append more records
|
|
appendNdjsonLine(filepath, {
|
|
type: 'step_start',
|
|
step: 'plan',
|
|
agent: 'planner',
|
|
iteration: 1,
|
|
timestamp: '2025-01-01T00:00:01.000Z',
|
|
});
|
|
|
|
const after2 = readFileSync(filepath, 'utf-8').trim().split('\n');
|
|
expect(after2).toHaveLength(2);
|
|
// First line should still be piece_start
|
|
expect(JSON.parse(after2[0]!).type).toBe('piece_start');
|
|
});
|
|
|
|
it('should produce valid JSON on each line', () => {
|
|
const filepath = initNdjsonLog('sess-008', 'task', 'wf', projectDir);
|
|
|
|
for (let i = 0; i < 5; i++) {
|
|
appendNdjsonLine(filepath, {
|
|
type: 'step_start',
|
|
step: `step-${i}`,
|
|
agent: 'planner',
|
|
iteration: i + 1,
|
|
timestamp: new Date().toISOString(),
|
|
});
|
|
}
|
|
|
|
const content = readFileSync(filepath, 'utf-8');
|
|
const lines = content.trim().split('\n');
|
|
expect(lines).toHaveLength(6); // 1 init + 5 step_start
|
|
|
|
// Every line should be valid JSON
|
|
for (const line of lines) {
|
|
expect(() => JSON.parse(line)).not.toThrow();
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('phase NDJSON records', () => {
|
|
it('should serialize and append phase_start records', () => {
|
|
const filepath = initNdjsonLog('sess-phase-001', 'task', 'wf', projectDir);
|
|
|
|
const record: NdjsonPhaseStart = {
|
|
type: 'phase_start',
|
|
step: 'plan',
|
|
phase: 1,
|
|
phaseName: 'execute',
|
|
timestamp: '2025-01-01T00:00:01.000Z',
|
|
instruction: 'Do the planning',
|
|
};
|
|
appendNdjsonLine(filepath, record);
|
|
|
|
const content = readFileSync(filepath, 'utf-8');
|
|
const lines = content.trim().split('\n');
|
|
expect(lines).toHaveLength(2); // piece_start + phase_start
|
|
|
|
const parsed = JSON.parse(lines[1]!) as NdjsonRecord;
|
|
expect(parsed.type).toBe('phase_start');
|
|
if (parsed.type === 'phase_start') {
|
|
expect(parsed.step).toBe('plan');
|
|
expect(parsed.phase).toBe(1);
|
|
expect(parsed.phaseName).toBe('execute');
|
|
expect(parsed.instruction).toBe('Do the planning');
|
|
}
|
|
});
|
|
|
|
it('should serialize and append phase_complete records', () => {
|
|
const filepath = initNdjsonLog('sess-phase-002', 'task', 'wf', projectDir);
|
|
|
|
const record: NdjsonPhaseComplete = {
|
|
type: 'phase_complete',
|
|
step: 'plan',
|
|
phase: 2,
|
|
phaseName: 'report',
|
|
status: 'done',
|
|
content: 'Report output',
|
|
timestamp: '2025-01-01T00:00:02.000Z',
|
|
};
|
|
appendNdjsonLine(filepath, record);
|
|
|
|
const content = readFileSync(filepath, 'utf-8');
|
|
const lines = content.trim().split('\n');
|
|
expect(lines).toHaveLength(2);
|
|
|
|
const parsed = JSON.parse(lines[1]!) as NdjsonRecord;
|
|
expect(parsed.type).toBe('phase_complete');
|
|
if (parsed.type === 'phase_complete') {
|
|
expect(parsed.step).toBe('plan');
|
|
expect(parsed.phase).toBe(2);
|
|
expect(parsed.phaseName).toBe('report');
|
|
expect(parsed.status).toBe('done');
|
|
expect(parsed.content).toBe('Report output');
|
|
}
|
|
});
|
|
|
|
it('should serialize phase_complete with error', () => {
|
|
const filepath = initNdjsonLog('sess-phase-003', 'task', 'wf', projectDir);
|
|
|
|
const record: NdjsonPhaseComplete = {
|
|
type: 'phase_complete',
|
|
step: 'impl',
|
|
phase: 3,
|
|
phaseName: 'judge',
|
|
status: 'error',
|
|
timestamp: '2025-01-01T00:00:03.000Z',
|
|
error: 'Status judgment phase failed',
|
|
};
|
|
appendNdjsonLine(filepath, record);
|
|
|
|
const content = readFileSync(filepath, 'utf-8');
|
|
const lines = content.trim().split('\n');
|
|
const parsed = JSON.parse(lines[1]!) as NdjsonRecord;
|
|
expect(parsed.type).toBe('phase_complete');
|
|
if (parsed.type === 'phase_complete') {
|
|
expect(parsed.error).toBe('Status judgment phase failed');
|
|
expect(parsed.phase).toBe(3);
|
|
expect(parsed.phaseName).toBe('judge');
|
|
}
|
|
});
|
|
|
|
it('should be skipped by loadNdjsonLog (default case)', () => {
|
|
const filepath = initNdjsonLog('sess-phase-004', 'task', 'wf', projectDir);
|
|
|
|
// Add phase records
|
|
appendNdjsonLine(filepath, {
|
|
type: 'phase_start',
|
|
step: 'plan',
|
|
phase: 1,
|
|
phaseName: 'execute',
|
|
timestamp: '2025-01-01T00:00:01.000Z',
|
|
instruction: 'Plan it',
|
|
} satisfies NdjsonPhaseStart);
|
|
|
|
appendNdjsonLine(filepath, {
|
|
type: 'phase_complete',
|
|
step: 'plan',
|
|
phase: 1,
|
|
phaseName: 'execute',
|
|
status: 'done',
|
|
content: 'Planned',
|
|
timestamp: '2025-01-01T00:00:02.000Z',
|
|
} satisfies NdjsonPhaseComplete);
|
|
|
|
// Add a step_complete so we can verify history
|
|
appendNdjsonLine(filepath, {
|
|
type: 'step_complete',
|
|
step: 'plan',
|
|
agent: 'planner',
|
|
status: 'done',
|
|
content: 'Plan completed',
|
|
instruction: 'Plan it',
|
|
timestamp: '2025-01-01T00:00:03.000Z',
|
|
} satisfies NdjsonStepComplete);
|
|
|
|
const log = loadNdjsonLog(filepath);
|
|
expect(log).not.toBeNull();
|
|
// Only step_complete should contribute to history
|
|
expect(log!.history).toHaveLength(1);
|
|
expect(log!.iterations).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe('interactive NDJSON records', () => {
|
|
it('should serialize and append interactive_start records', () => {
|
|
const filepath = initNdjsonLog('sess-interactive-001', 'task', 'wf', projectDir);
|
|
|
|
const record: NdjsonInteractiveStart = {
|
|
type: 'interactive_start',
|
|
timestamp: '2025-01-01T00:00:01.000Z',
|
|
};
|
|
appendNdjsonLine(filepath, record);
|
|
|
|
const content = readFileSync(filepath, 'utf-8');
|
|
const lines = content.trim().split('\n');
|
|
expect(lines).toHaveLength(2);
|
|
|
|
const parsed = JSON.parse(lines[1]!) as NdjsonRecord;
|
|
expect(parsed.type).toBe('interactive_start');
|
|
if (parsed.type === 'interactive_start') {
|
|
expect(parsed.timestamp).toBe('2025-01-01T00:00:01.000Z');
|
|
}
|
|
});
|
|
|
|
it('should serialize and append interactive_end records', () => {
|
|
const filepath = initNdjsonLog('sess-interactive-002', 'task', 'wf', projectDir);
|
|
|
|
const record: NdjsonInteractiveEnd = {
|
|
type: 'interactive_end',
|
|
confirmed: true,
|
|
task: 'Build a feature',
|
|
timestamp: '2025-01-01T00:00:02.000Z',
|
|
};
|
|
appendNdjsonLine(filepath, record);
|
|
|
|
const content = readFileSync(filepath, 'utf-8');
|
|
const lines = content.trim().split('\n');
|
|
expect(lines).toHaveLength(2);
|
|
|
|
const parsed = JSON.parse(lines[1]!) as NdjsonRecord;
|
|
expect(parsed.type).toBe('interactive_end');
|
|
if (parsed.type === 'interactive_end') {
|
|
expect(parsed.confirmed).toBe(true);
|
|
expect(parsed.task).toBe('Build a feature');
|
|
}
|
|
});
|
|
|
|
it('should be skipped by loadNdjsonLog (default case)', () => {
|
|
const filepath = initNdjsonLog('sess-interactive-003', 'task', 'wf', projectDir);
|
|
|
|
appendNdjsonLine(filepath, {
|
|
type: 'interactive_start',
|
|
timestamp: '2025-01-01T00:00:01.000Z',
|
|
} satisfies NdjsonInteractiveStart);
|
|
|
|
appendNdjsonLine(filepath, {
|
|
type: 'interactive_end',
|
|
confirmed: true,
|
|
task: 'Some task',
|
|
timestamp: '2025-01-01T00:00:02.000Z',
|
|
} satisfies NdjsonInteractiveEnd);
|
|
|
|
const log = loadNdjsonLog(filepath);
|
|
expect(log).not.toBeNull();
|
|
expect(log!.history).toHaveLength(0);
|
|
});
|
|
});
|
|
|
|
describe('extractFailureInfo', () => {
|
|
it('should return null for non-existent file', () => {
|
|
const result = extractFailureInfo('/nonexistent/path.jsonl');
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
it('should extract failure info from aborted piece log', () => {
|
|
const filepath = initNdjsonLog('20260205-120000-abc123', 'failing task', 'wf', projectDir);
|
|
|
|
// Add step_start for plan
|
|
appendNdjsonLine(filepath, {
|
|
type: 'step_start',
|
|
step: 'plan',
|
|
agent: 'planner',
|
|
iteration: 1,
|
|
timestamp: '2025-01-01T00:00:01.000Z',
|
|
});
|
|
|
|
// Add step_complete for plan
|
|
appendNdjsonLine(filepath, {
|
|
type: 'step_complete',
|
|
step: 'plan',
|
|
agent: 'planner',
|
|
status: 'done',
|
|
content: 'Plan done',
|
|
instruction: 'Plan it',
|
|
timestamp: '2025-01-01T00:00:02.000Z',
|
|
} satisfies NdjsonStepComplete);
|
|
|
|
// Add step_start for implement (fails before completing)
|
|
appendNdjsonLine(filepath, {
|
|
type: 'step_start',
|
|
step: 'implement',
|
|
agent: 'coder',
|
|
iteration: 2,
|
|
timestamp: '2025-01-01T00:00:03.000Z',
|
|
});
|
|
|
|
// Add piece_abort
|
|
appendNdjsonLine(filepath, {
|
|
type: 'piece_abort',
|
|
iterations: 1,
|
|
reason: 'spawn node ENOENT',
|
|
endTime: '2025-01-01T00:00:04.000Z',
|
|
} satisfies NdjsonPieceAbort);
|
|
|
|
const result = extractFailureInfo(filepath);
|
|
expect(result).not.toBeNull();
|
|
expect(result!.lastCompletedMovement).toBe('plan');
|
|
expect(result!.failedMovement).toBe('implement');
|
|
expect(result!.iterations).toBe(1);
|
|
expect(result!.errorMessage).toBe('spawn node ENOENT');
|
|
expect(result!.sessionId).toBe('20260205-120000-abc123');
|
|
});
|
|
|
|
it('should handle log with only completed movements (no abort)', () => {
|
|
const filepath = initNdjsonLog('sess-success-001', 'task', 'wf', projectDir);
|
|
|
|
appendNdjsonLine(filepath, {
|
|
type: 'step_start',
|
|
step: 'plan',
|
|
agent: 'planner',
|
|
iteration: 1,
|
|
timestamp: '2025-01-01T00:00:01.000Z',
|
|
});
|
|
|
|
appendNdjsonLine(filepath, {
|
|
type: 'step_complete',
|
|
step: 'plan',
|
|
agent: 'planner',
|
|
status: 'done',
|
|
content: 'Plan done',
|
|
instruction: 'Plan it',
|
|
timestamp: '2025-01-01T00:00:02.000Z',
|
|
} satisfies NdjsonStepComplete);
|
|
|
|
appendNdjsonLine(filepath, {
|
|
type: 'piece_complete',
|
|
iterations: 1,
|
|
endTime: '2025-01-01T00:00:03.000Z',
|
|
});
|
|
|
|
const result = extractFailureInfo(filepath);
|
|
expect(result).not.toBeNull();
|
|
expect(result!.lastCompletedMovement).toBe('plan');
|
|
expect(result!.failedMovement).toBeNull();
|
|
expect(result!.iterations).toBe(1);
|
|
expect(result!.errorMessage).toBeNull();
|
|
});
|
|
|
|
it('should handle log with no step_complete records', () => {
|
|
const filepath = initNdjsonLog('sess-fail-early-001', 'task', 'wf', projectDir);
|
|
|
|
appendNdjsonLine(filepath, {
|
|
type: 'step_start',
|
|
step: 'plan',
|
|
agent: 'planner',
|
|
iteration: 1,
|
|
timestamp: '2025-01-01T00:00:01.000Z',
|
|
});
|
|
|
|
appendNdjsonLine(filepath, {
|
|
type: 'piece_abort',
|
|
iterations: 0,
|
|
reason: 'API error',
|
|
endTime: '2025-01-01T00:00:02.000Z',
|
|
} satisfies NdjsonPieceAbort);
|
|
|
|
const result = extractFailureInfo(filepath);
|
|
expect(result).not.toBeNull();
|
|
expect(result!.lastCompletedMovement).toBeNull();
|
|
expect(result!.failedMovement).toBe('plan');
|
|
expect(result!.iterations).toBe(0);
|
|
expect(result!.errorMessage).toBe('API error');
|
|
});
|
|
|
|
it('should return null for empty file', () => {
|
|
const logsDir = join(projectDir, '.takt', 'logs');
|
|
mkdirSync(logsDir, { recursive: true });
|
|
const filepath = join(logsDir, 'empty.jsonl');
|
|
writeFileSync(filepath, '', 'utf-8');
|
|
|
|
const result = extractFailureInfo(filepath);
|
|
expect(result).toBeNull();
|
|
});
|
|
});
|
|
});
|