scalix 0.0.1 → 1.1.0

package/dist/agent-registry.js

@@ -0,0 +1,226 @@
+import { EventEmitter } from 'eventemitter3';
+import { randomUUID } from 'node:crypto';
+import { logger } from './logger.js';
+import { MULTI_AGENT_DEFAULTS } from './constants.js';
+export class AgentRegistry extends EventEmitter {
+    static instance = null;
+    agents = new Map();
+    agentRefs = new Map();
+    messages = [];
+    limits;
+    constructor(limits) {
+        super();
+        this.limits = {
+            maxDepth: limits?.maxDepth ?? MULTI_AGENT_DEFAULTS.maxDepth,
+            maxConcurrentAgents: limits?.maxConcurrentAgents ?? MULTI_AGENT_DEFAULTS.maxConcurrentAgents,
+            globalTokenBudget: limits?.globalTokenBudget ?? MULTI_AGENT_DEFAULTS.globalTokenBudget,
+        };
+    }
+    static getInstance(limits) {
+        if (!AgentRegistry.instance) {
+            AgentRegistry.instance = new AgentRegistry(limits);
+        }
+        return AgentRegistry.instance;
+    }
+    static resetInstance() {
+        if (AgentRegistry.instance) {
+            AgentRegistry.instance.removeAllListeners();
+            AgentRegistry.instance.agents.clear();
+            AgentRegistry.instance.agentRefs.clear();
+            AgentRegistry.instance.messages = [];
+        }
+        AgentRegistry.instance = null;
+    }
+    register(id, agentRef, parentId, metadata) {
+        const depth = parentId ? this.getDepth(parentId) + 1 : 0;
+        const entry = {
+            id,
+            parentId,
+            depth,
+            description: metadata.description,
+            model: metadata.model,
+            status: 'running',
+            tokenUsage: 0,
+            stepCount: 0,
+            spawnedAt: Date.now(),
+            completedAt: null,
+        };
+        this.agents.set(id, entry);
+        this.agentRefs.set(id, agentRef);
+        this.emit('agent:spawned', entry);
+        logger.info('Agent registered', { id, parentId, depth, description: metadata.description });
+    }
+    deregister(id, status) {
+        const entry = this.agents.get(id);
+        if (!entry)
+            return;
+        entry.status = status;
+        entry.completedAt = Date.now();
+        this.agentRefs.delete(id);
+        this.emit('agent:completed', entry);
+        logger.info('Agent deregistered', { id, status, tokens: entry.tokenUsage, steps: entry.stepCount });
+    }
+    getAgent(id) {
+        return this.agentRefs.get(id);
+    }
+    getMeta(id) {
+        return this.agents.get(id);
+    }
+    listActive() {
+        return [...this.agents.values()].filter(a => a.status === 'running');
+    }
+    listAll() {
+        return [...this.agents.values()];
+    }
+    getChildren(parentId) {
+        return [...this.agents.values()].filter(a => a.parentId === parentId);
+    }
+    getDepth(id) {
+        const entry = this.agents.get(id);
+        if (!entry)
+            return 0;
+        if (!entry.parentId)
+            return 0;
+        return 1 + this.getDepth(entry.parentId);
+    }
+    canSpawn(parentId) {
+        const activeCount = this.listActive().length;
+        if (activeCount >= this.limits.maxConcurrentAgents) {
+            return { allowed: false, reason: `Concurrent agent limit reached (${activeCount}/${this.limits.maxConcurrentAgents})` };
+        }
+        if (parentId) {
+            const depth = this.getDepth(parentId) + 1;
+            if (depth >= this.limits.maxDepth) {
+                return { allowed: false, reason: `Maximum agent depth reached (${depth}/${this.limits.maxDepth})` };
+            }
+        }
+        const totalTokens = this.getTotalTokens();
+        if (totalTokens >= this.limits.globalTokenBudget) {
+            return { allowed: false, reason: `Global token budget exhausted (${totalTokens.toLocaleString()}/${this.limits.globalTokenBudget.toLocaleString()})` };
+        }
+        return { allowed: true };
+    }
+    // --- Messaging ---
+    sendMessage(from, to, content) {
+        if (from === to) {
+            return { error: 'Cannot send a message to self' };
+        }
+        const recipient = this.agents.get(to);
+        if (!recipient) {
+            return { error: `Agent "${to}" not found` };
+        }
+        if (recipient.status !== 'running') {
+            return { error: `Agent "${to}" is not running (status: ${recipient.status})` };
+        }
+        const msg = {
+            id: randomUUID(),
+            from,
+            to,
+            content,
+            timestamp: Date.now(),
+            read: false,
+        };
+        this.messages.push(msg);
+        this.emit('agent:message', msg);
+        return msg;
+    }
+    broadcast(from, content) {
+        const sent = [];
+        for (const agent of this.listActive()) {
+            if (agent.id === from)
+                continue;
+            const result = this.sendMessage(from, agent.id, content);
+            if ('id' in result)
+                sent.push(result);
+        }
+        return sent;
+    }
+    getUnread(agentId) {
+        return this.messages.filter(m => m.to === agentId && !m.read);
+    }
+    markRead(agentId) {
+        for (const msg of this.messages) {
+            if (msg.to === agentId && !msg.read) {
+                msg.read = true;
+            }
+        }
+    }
+    // --- Resource Tracking ---
+    recordTokens(id, tokens) {
+        const entry = this.agents.get(id);
+        if (entry) {
+            entry.tokenUsage += tokens;
+        }
+        const totalTokens = this.getTotalTokens();
+        const budgetPct = totalTokens / this.limits.globalTokenBudget;
+        if (budgetPct >= 0.9) {
+            this.emit('budget:warning', {
+                totalTokens,
+                budget: this.limits.globalTokenBudget,
+                percentage: Math.round(budgetPct * 100),
+            });
+        }
+    }
+    recordStep(id) {
+        const entry = this.agents.get(id);
+        if (entry) {
+            entry.stepCount++;
+        }
+    }
+    getTotalTokens() {
+        let total = 0;
+        for (const entry of this.agents.values()) {
+            total += entry.tokenUsage;
+        }
+        return total;
+    }
+    getUsageSummary() {
+        const all = [...this.agents.values()];
+        return {
+            totalTokens: this.getTotalTokens(),
+            activeCount: all.filter(a => a.status === 'running').length,
+            completedCount: all.filter(a => a.status === 'completed').length,
+            failedCount: all.filter(a => a.status === 'failed' || a.status === 'aborted').length,
+            byAgent: all.map(a => ({
+                id: a.id,
+                description: a.description,
+                model: a.model,
+                tokens: a.tokenUsage,
+                steps: a.stepCount,
+                status: a.status,
+            })),
+        };
+    }
+    getAgentTree(rootId) {
+        const lines = [];
+        const roots = rootId
+            ? [this.agents.get(rootId)].filter(Boolean)
+            : [...this.agents.values()].filter(a => !a.parentId);
+        const render = (entry, indent) => {
+            const statusIcon = entry.status === 'running' ? '*' : entry.status === 'completed' ? '+' : 'x';
+            lines.push(`${indent}[${statusIcon}] ${entry.id.slice(0, 8)} ${entry.description} (${entry.model}, ${entry.tokenUsage.toLocaleString()} tok)`);
+            const children = this.getChildren(entry.id);
+            for (const child of children) {
+                render(child, indent + '  ');
+            }
+        };
+        for (const root of roots) {
+            render(root, '');
+        }
+        return lines.join('\n') || '(no agents)';
+    }
+    getLimits() {
+        return { ...this.limits };
+    }
+    setLimits(limits) {
+        if (limits.maxDepth !== undefined)
+            this.limits.maxDepth = limits.maxDepth;
+        if (limits.maxConcurrentAgents !== undefined)
+            this.limits.maxConcurrentAgents = limits.maxConcurrentAgents;
+        if (limits.globalTokenBudget !== undefined)
+            this.limits.globalTokenBudget = limits.globalTokenBudget;
+    }
+}
+export function generateAgentId() {
+    return randomUUID();
+}

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;
+}