scalix 0.0.1 → 1.0.0

package/dist/agent-replay.js

@@ -0,0 +1,166 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { USER_CONFIG_DIR } from './constants.js';
+const REPLAYS_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '.', USER_CONFIG_DIR, 'replays');
+export class AgentReplay {
+    session;
+    stepCounter = 0;
+    startTime;
+    recording = true;
+    constructor(sessionId, model) {
+        this.startTime = Date.now();
+        this.session = {
+            id: sessionId,
+            model,
+            startedAt: new Date().toISOString(),
+            steps: [],
+            totalTokens: 0,
+            totalCost: 0,
+            forkPoints: [],
+        };
+    }
+    record(kind, data = {}) {
+        if (!this.recording)
+            return { id: -1, kind, timestamp: 0, elapsed: 0, data };
+        const step = {
+            id: this.stepCounter++,
+            kind,
+            timestamp: Date.now(),
+            elapsed: Date.now() - this.startTime,
+            data,
+        };
+        this.session.steps.push(step);
+        if (kind === 'user_message') {
+            this.session.forkPoints.push(step.id);
+        }
+        return step;
+    }
+    recordUsage(tokens, cost) {
+        this.session.totalTokens += tokens;
+        this.session.totalCost += cost;
+    }
+    pause() {
+        this.recording = false;
+    }
+    resume() {
+        this.recording = true;
+    }
+    getSteps() {
+        return [...this.session.steps];
+    }
+    getStepsSince(stepId) {
+        const idx = this.session.steps.findIndex((s) => s.id === stepId);
+        if (idx === -1)
+            return [];
+        return this.session.steps.slice(idx);
+    }
+    getForkPoints() {
+        return this.session.forkPoints.map((id) => {
+            const step = this.session.steps.find((s) => s.id === id);
+            return {
+                stepId: id,
+                message: step?.data?.content || '(unknown)',
+            };
+        });
+    }
+    getTimeline() {
+        const lines = [];
+        let toolCallCount = 0;
+        for (const step of this.session.steps) {
+            const time = formatElapsed(step.elapsed);
+            switch (step.kind) {
+                case 'user_message':
+                    lines.push(`\n[${time}] YOU: ${truncate(step.data.content, 60)}`);
+                    toolCallCount = 0;
+                    break;
+                case 'thinking_start':
+                    lines.push(`[${time}] Thinking...`);
+                    break;
+                case 'thinking_end':
+                    lines.push(`[${time}] Done thinking`);
+                    break;
+                case 'stream_end':
+                    lines.push(`[${time}] AI: ${truncate(step.data.text, 80)}`);
+                    break;
+                case 'tool_call':
+                    toolCallCount++;
+                    lines.push(`[${time}] Tool #${toolCallCount}: ${step.data.name} → ${truncate(JSON.stringify(step.data.args), 50)}`);
+                    break;
+                case 'tool_result':
+                    lines.push(`[${time}]   Result: ${truncate(step.data.result, 60)}`);
+                    break;
+                case 'tool_blocked':
+                    lines.push(`[${time}]   BLOCKED: ${step.data.reason}`);
+                    break;
+                case 'error':
+                    lines.push(`[${time}] ERROR: ${step.data.message}`);
+                    break;
+                case 'context_compress':
+                    lines.push(`[${time}] Context compressed (${step.data.saved} tokens saved)`);
+                    break;
+                case 'model_switch':
+                    lines.push(`[${time}] Model: ${step.data.from} → ${step.data.to}`);
+                    break;
+            }
+        }
+        lines.push('');
+        lines.push(`Total: ${this.session.steps.length} steps, ${this.session.totalTokens.toLocaleString()} tokens`);
+        return lines.join('\n');
+    }
+    async save() {
+        await fs.mkdir(REPLAYS_DIR, { recursive: true });
+        const filePath = path.join(REPLAYS_DIR, `${this.session.id}.json`);
+        await fs.writeFile(filePath, JSON.stringify(this.session, null, 2), 'utf-8');
+        return filePath;
+    }
+    static async load(sessionId) {
+        const filePath = path.join(REPLAYS_DIR, `${sessionId}.json`);
+        const raw = await fs.readFile(filePath, 'utf-8');
+        const data = JSON.parse(raw);
+        const replay = new AgentReplay(data.id, data.model);
+        replay.session = data;
+        replay.stepCounter = data.steps.length;
+        replay.recording = false;
+        return replay;
+    }
+    static async listReplays() {
+        try {
+            await fs.mkdir(REPLAYS_DIR, { recursive: true });
+            const files = await fs.readdir(REPLAYS_DIR);
+            const replays = [];
+            for (const file of files) {
+                if (!file.endsWith('.json'))
+                    continue;
+                try {
+                    const raw = await fs.readFile(path.join(REPLAYS_DIR, file), 'utf-8');
+                    const data = JSON.parse(raw);
+                    replays.push({
+                        id: data.id,
+                        model: data.model,
+                        date: data.startedAt,
+                        steps: data.steps.length,
+                    });
+                }
+                catch {
+                    console.error(`Warning: corrupted replay file skipped: ${file}`);
+                }
+            }
+            return replays.sort((a, b) => b.date.localeCompare(a.date));
+        }
+        catch {
+            return [];
+        }
+    }
+}
+function formatElapsed(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const s = seconds % 60;
+    return minutes > 0 ? `${minutes}m${s.toString().padStart(2, '0')}s` : `${s}s`;
+}
+function truncate(s, max) {
+    if (!s)
+        return '';
+    const clean = s.replace(/\n/g, ' ').trim();
+    return clean.length > max ? clean.slice(0, max - 1) + '\u2026' : clean;
+}