@swarmify/agents-cli 1.12.0 → 1.13.1

package/dist/lib/teams/summarizer.js

@@ -0,0 +1,780 @@
+import { extractFileOpsFromBash } from './file_ops.js';
+function extractErrorFromRawEvents(events, maxChars = 500) {
+    const errorKeywords = ['error', 'Error', 'ERROR', 'failed', 'Failed', 'FAILED', 'exception', 'Exception'];
+    for (let i = events.length - 1; i >= Math.max(0, events.length - 20); i--) {
+        const event = events[i];
+        if (event.type === 'raw') {
+            const content = event.content || '';
+            if (typeof content === 'string') {
+                const contentLower = content.toLowerCase();
+                if (errorKeywords.some(keyword => contentLower.includes(keyword.toLowerCase()))) {
+                    let errorMsg = content.trim();
+                    if (errorMsg.length > maxChars) {
+                        errorMsg = errorMsg.substring(0, maxChars - 3) + '...';
+                    }
+                    return errorMsg;
+                }
+            }
+        }
+    }
+    return null;
+}
+/** Event type priority tiers for filtering. Higher tiers surface more important events. */
+export const PRIORITY = {
+    critical: [
+        'error',
+        'result',
+        'file_write',
+        'file_delete',
+        'file_create',
+    ],
+    important: [
+        'tool_use',
+        'bash',
+        'file_read',
+        'thinking',
+        'message',
+    ],
+    verbose: [
+        'thinking_delta',
+        'message_delta',
+        'init',
+        'turn_start',
+        'user_message',
+        'raw',
+    ],
+};
+/**
+ * Collapse sequential events of the same type into summary entries.
+ * Returns a cleaner list of events suitable for output.
+ */
+export function collapseEvents(events, maxEvents = 20) {
+    if (events.length === 0)
+        return [];
+    const collapsed = [];
+    let i = 0;
+    while (i < events.length) {
+        const event = events[i];
+        const eventType = event.type || 'unknown';
+        // For thinking events, collapse sequential ones
+        if (eventType === 'thinking') {
+            let count = 1;
+            let lastContent = event.content || '';
+            let j = i + 1;
+            while (j < events.length && events[j].type === 'thinking') {
+                count++;
+                if (events[j].content) {
+                    lastContent = events[j].content;
+                }
+                j++;
+            }
+            if (count > 1) {
+                collapsed.push({
+                    type: 'thinking_summary',
+                    count: count,
+                    last_content: lastContent.length > 200 ? lastContent.slice(-200) : lastContent,
+                    timestamp: event.timestamp,
+                });
+            }
+            else if (event.content) {
+                collapsed.push(event);
+            }
+            i = j;
+            continue;
+        }
+        // For message events, keep the last content
+        if (eventType === 'message') {
+            collapsed.push({
+                type: 'message',
+                content: event.content?.length > 500 ? event.content.slice(-500) : event.content,
+                complete: event.complete,
+                timestamp: event.timestamp,
+            });
+            i++;
+            continue;
+        }
+        // Keep tool events as-is but truncate large content
+        if (['bash', 'file_write', 'file_read', 'file_create', 'file_delete', 'tool_use'].includes(eventType)) {
+            const cleaned = { ...event };
+            if (cleaned.command && cleaned.command.length > 200) {
+                cleaned.command = cleaned.command.slice(0, 200) + '...';
+            }
+            collapsed.push(cleaned);
+            i++;
+            continue;
+        }
+        // Keep errors and results
+        if (['error', 'result'].includes(eventType)) {
+            collapsed.push(event);
+            i++;
+            continue;
+        }
+        // Skip other event types
+        i++;
+    }
+    // Return only the last N events
+    if (collapsed.length > maxEvents) {
+        return collapsed.slice(-maxEvents);
+    }
+    return collapsed;
+}
+/**
+ * Get a breakdown of tool calls by type.
+ */
+export function getToolBreakdown(events) {
+    const breakdown = {};
+    for (const event of events) {
+        const eventType = event.type || '';
+        if (eventType === 'bash') {
+            breakdown['bash'] = (breakdown['bash'] || 0) + 1;
+        }
+        else if (eventType === 'file_write') {
+            breakdown['file_write'] = (breakdown['file_write'] || 0) + 1;
+        }
+        else if (eventType === 'file_read') {
+            breakdown['file_read'] = (breakdown['file_read'] || 0) + 1;
+        }
+        else if (eventType === 'file_create') {
+            breakdown['file_create'] = (breakdown['file_create'] || 0) + 1;
+        }
+        else if (eventType === 'file_delete') {
+            breakdown['file_delete'] = (breakdown['file_delete'] || 0) + 1;
+        }
+        else if (eventType === 'tool_use') {
+            const tool = event.tool || 'unknown';
+            breakdown[tool] = (breakdown[tool] || 0) + 1;
+        }
+    }
+    return breakdown;
+}
+/** Group consecutive events of the same type into combined entries with counts and truncated content. */
+export function groupAndFlattenEvents(events) {
+    if (events.length === 0)
+        return [];
+    const grouped = [];
+    let i = 0;
+    while (i < events.length) {
+        const event = events[i];
+        const eventType = event.type || 'unknown';
+        if (eventType === 'message' || eventType === 'thinking') {
+            let count = 1;
+            let combinedContent = event.content || '';
+            let j = i + 1;
+            while (j < events.length && events[j].type === eventType) {
+                count++;
+                if (events[j].content) {
+                    combinedContent += (combinedContent ? '\n' : '') + events[j].content;
+                }
+                j++;
+            }
+            const flattened = {
+                type: eventType,
+                content: combinedContent.length > 1000 ? combinedContent.slice(-1000) : combinedContent,
+            };
+            if (count > 1) {
+                flattened.count = count;
+            }
+            grouped.push(flattened);
+            i = j;
+            continue;
+        }
+        if (['file_write', 'file_create', 'file_read', 'file_delete'].includes(eventType)) {
+            const path = event.path || '';
+            if (!path) {
+                i++;
+                continue;
+            }
+            const pathGroup = {
+                type: eventType,
+                path: path,
+                count: 1,
+            };
+            let j = i + 1;
+            while (j < events.length && events[j].type === eventType && events[j].path === path) {
+                pathGroup.count++;
+                j++;
+            }
+            grouped.push(pathGroup);
+            i = j;
+            continue;
+        }
+        if (eventType === 'bash') {
+            const command = event.command || '';
+            if (!command) {
+                i++;
+                continue;
+            }
+            const bashGroup = {
+                type: 'bash',
+                commands: [command],
+                count: 1,
+            };
+            let j = i + 1;
+            while (j < events.length && events[j].type === 'bash') {
+                bashGroup.commands.push(events[j].command || '');
+                bashGroup.count++;
+                j++;
+            }
+            if (bashGroup.commands.length > 5) {
+                bashGroup.commands = bashGroup.commands.slice(-5);
+                bashGroup.truncated = bashGroup.count - 5;
+            }
+            grouped.push(bashGroup);
+            i = j;
+            continue;
+        }
+        if (eventType === 'tool_use') {
+            const flattened = {
+                type: 'tool_use',
+                tool: event.tool || 'unknown',
+            };
+            if (event.name)
+                flattened.name = event.name;
+            if (event.input) {
+                const inputStr = typeof event.input === 'string' ? event.input : JSON.stringify(event.input);
+                flattened.input = inputStr.length > 200 ? inputStr.slice(0, 200) + '...' : inputStr;
+            }
+            grouped.push(flattened);
+            i++;
+            continue;
+        }
+        if (['error', 'result'].includes(eventType)) {
+            const flattened = {
+                type: eventType,
+            };
+            if (event.message)
+                flattened.message = event.message;
+            if (event.content)
+                flattened.content = event.content;
+            if (event.status)
+                flattened.status = event.status;
+            grouped.push(flattened);
+            i++;
+            continue;
+        }
+        i++;
+    }
+    return grouped;
+}
+/** Accumulated summary of an agent's activity: files touched, tools used, errors, and final message. */
+export class AgentSummary {
+    agentId;
+    agentType;
+    status;
+    duration = null;
+    filesModified = new Set();
+    filesCreated = new Set();
+    filesRead = new Set();
+    filesDeleted = new Set();
+    toolsUsed = new Set();
+    toolCallCount = 0;
+    bashCommands = [];
+    errors = [];
+    warnings = [];
+    finalMessage = null;
+    eventCount = 0;
+    lastActivity = null;
+    eventsCache = [];
+    constructor(agentId, agentType, status, duration = null, eventCount = 0) {
+        this.agentId = agentId;
+        this.agentType = agentType;
+        this.status = status;
+        this.duration = duration;
+        this.eventCount = eventCount;
+    }
+    toDict(detailLevel = 'standard') {
+        const base = {
+            agent_id: this.agentId,
+            agent_type: this.agentType,
+            status: this.status,
+        };
+        if (detailLevel === 'brief') {
+            return {
+                ...base,
+                duration: this.duration,
+                tool_call_count: this.toolCallCount,
+                last_activity: this.lastActivity,
+                files_modified: Array.from(this.filesModified).slice(0, 5),
+                files_created: Array.from(this.filesCreated).slice(0, 5),
+                has_errors: this.errors.length > 0,
+            };
+        }
+        else if (detailLevel === 'standard') {
+            return {
+                ...base,
+                duration: this.duration,
+                files_modified: Array.from(this.filesModified),
+                files_created: Array.from(this.filesCreated),
+                tools_used: Array.from(this.toolsUsed),
+                tool_call_count: this.toolCallCount,
+                errors: this.errors.slice(0, 3),
+                final_message: this.truncate(this.finalMessage, 2000),
+            };
+        }
+        else {
+            return {
+                ...base,
+                duration: this.duration,
+                files_modified: Array.from(this.filesModified),
+                files_created: Array.from(this.filesCreated),
+                files_read: Array.from(this.filesRead),
+                files_deleted: Array.from(this.filesDeleted),
+                tools_used: Array.from(this.toolsUsed),
+                tool_call_count: this.toolCallCount,
+                bash_commands: this.bashCommands.slice(-10),
+                errors: this.errors,
+                warnings: this.warnings,
+                final_message: this.finalMessage,
+                event_count: this.eventCount,
+                last_activity: this.lastActivity,
+            };
+        }
+    }
+    truncate(text, maxLen) {
+        if (!text)
+            return null;
+        if (text.length <= maxLen)
+            return text;
+        return text.substring(0, maxLen - 3) + '...';
+    }
+}
+/** Build an AgentSummary by walking all events and accumulating file ops, tool calls, errors, and messages. */
+export function summarizeEvents(agentId, agentType, status, events, duration = null) {
+    const summary = new AgentSummary(agentId, agentType, status, duration, events.length);
+    summary.eventsCache = events;
+    summary.agentId = agentId;
+    summary.agentType = agentType;
+    summary.status = status;
+    for (const event of events) {
+        const eventType = event.type || 'unknown';
+        summary.lastActivity = eventType;
+        if (eventType === 'file_write') {
+            const path = event.path || '';
+            if (path) {
+                summary.filesModified.add(path);
+                summary.toolCallCount++;
+            }
+        }
+        else if (eventType === 'file_create') {
+            const path = event.path || '';
+            if (path) {
+                summary.filesCreated.add(path);
+                summary.toolCallCount++;
+            }
+        }
+        else if (eventType === 'file_read') {
+            const path = event.path || '';
+            if (path) {
+                summary.filesRead.add(path);
+                summary.toolCallCount++;
+            }
+        }
+        else if (eventType === 'file_delete') {
+            const path = event.path || '';
+            if (path) {
+                summary.filesDeleted.add(path);
+                summary.toolCallCount++;
+            }
+        }
+        else if (eventType === 'directory_list') {
+            summary.toolCallCount++;
+        }
+        else if (eventType === 'tool_use') {
+            const tool = event.tool || 'unknown';
+            summary.toolsUsed.add(tool);
+            summary.toolCallCount++;
+        }
+        else if (eventType === 'bash') {
+            const command = event.command || '';
+            summary.toolsUsed.add('bash');
+            if (command) {
+                summary.bashCommands.push(command);
+                const [filesRead, filesWritten, filesDeleted] = extractFileOpsFromBash(command);
+                for (const path of filesRead) {
+                    summary.filesRead.add(path);
+                }
+                for (const path of filesWritten) {
+                    summary.filesModified.add(path);
+                }
+                for (const path of filesDeleted) {
+                    summary.filesDeleted.add(path);
+                }
+            }
+            summary.toolCallCount++;
+        }
+        else if (eventType === 'message') {
+            const content = event.content || '';
+            if (content) {
+                summary.finalMessage = content;
+            }
+        }
+        else if (eventType === 'error') {
+            let errorMsg = null;
+            for (const key of ['message', 'content', 'error', 'error_message', 'details']) {
+                if (event[key]) {
+                    errorMsg = String(event[key]);
+                    break;
+                }
+            }
+            if (!errorMsg) {
+                errorMsg = extractErrorFromRawEvents(summary.eventsCache);
+            }
+            if (errorMsg) {
+                if (errorMsg.length > 500) {
+                    errorMsg = errorMsg.substring(0, 497) + '...';
+                }
+                summary.errors.push(errorMsg);
+            }
+        }
+        else if (eventType === 'warning') {
+            const warningMsg = event.message || event.content || '';
+            if (warningMsg) {
+                summary.warnings.push(warningMsg);
+            }
+        }
+        else if (eventType === 'result') {
+            if (event.status === 'error') {
+                let errorMsg = null;
+                for (const key of ['message', 'error', 'error_message', 'error_details', 'details']) {
+                    if (event[key]) {
+                        errorMsg = String(event[key]);
+                        break;
+                    }
+                }
+                if (!errorMsg) {
+                    errorMsg = extractErrorFromRawEvents(summary.eventsCache);
+                }
+                if (errorMsg) {
+                    if (errorMsg.length > 500) {
+                        errorMsg = errorMsg.substring(0, 497) + '...';
+                    }
+                    summary.errors.push(errorMsg);
+                }
+            }
+            if (!summary.duration && event.duration_ms) {
+                const durationMs = event.duration_ms;
+                const seconds = durationMs / 1000;
+                if (seconds < 60) {
+                    if (seconds % 1 === 0) {
+                        summary.duration = `${Math.floor(seconds)} seconds`;
+                    }
+                    else {
+                        summary.duration = `${seconds.toFixed(1)} seconds`;
+                    }
+                }
+                else {
+                    const minutes = seconds / 60;
+                    summary.duration = `${minutes.toFixed(1)} minutes`;
+                }
+            }
+        }
+    }
+    return summary;
+}
+/**
+ * Compute the delta of new activity since a given point in time (ISO timestamp)
+ * or event index. Used for incremental status polling.
+ */
+export function getDelta(agentId, agentType, status, events, since // Optional: ISO timestamp (string) or event index (number)
+) {
+    // Filter events by timestamp (string) or index (number)
+    let newEvents;
+    let sinceEvent = 0;
+    if (since === undefined || since === null) {
+        // No filter - return all events
+        newEvents = events;
+    }
+    else if (typeof since === 'number') {
+        // Backward compatibility: event index
+        sinceEvent = since;
+        newEvents = events.slice(sinceEvent);
+    }
+    else if (typeof since === 'string') {
+        // New behavior: timestamp filtering
+        const sinceDate = new Date(since);
+        newEvents = events.filter((e) => {
+            if (!e.timestamp)
+                return false;
+            const eventDate = new Date(e.timestamp);
+            return eventDate > sinceDate;
+        });
+    }
+    else {
+        newEvents = events;
+    }
+    if (newEvents.length === 0) {
+        return {
+            agent_id: agentId,
+            status: status,
+            since_event: sinceEvent, // For backward compatibility
+            new_events_count: 0,
+            has_changes: false,
+            new_files_created: [],
+            new_files_modified: [],
+            new_files_read: [],
+            new_files_deleted: [],
+            new_bash_commands: [],
+            new_messages: [],
+            new_tool_count: 0,
+            new_errors: [],
+        };
+    }
+    const summary = summarizeEvents(agentId, agentType, status, newEvents);
+    return {
+        agent_id: agentId,
+        agent_type: agentType,
+        status: status,
+        since_event: sinceEvent, // For backward compatibility
+        new_events_count: newEvents.length,
+        current_event_count: sinceEvent + newEvents.length, // For backward compatibility
+        has_changes: true,
+        new_files_created: Array.from(summary.filesCreated),
+        new_files_modified: Array.from(summary.filesModified),
+        new_files_read: Array.from(summary.filesRead),
+        new_files_deleted: Array.from(summary.filesDeleted),
+        new_bash_commands: summary.bashCommands.slice(-15),
+        new_messages: getLastMessages(newEvents, 5),
+        new_tool_count: summary.toolCallCount,
+        new_tool_calls: newEvents // For backward compatibility
+            .filter((e) => ['tool_use', 'bash', 'file_write'].includes(e.type))
+            .slice(-5)
+            .map((e) => `${e.tool || 'unknown'}: ${e.command || e.path || ''}`),
+        latest_message: summary.finalMessage, // For backward compatibility
+        new_errors: summary.errors,
+    };
+}
+/** Filter events to only those in the specified priority tiers (defaults to critical + important). */
+export function filterEventsByPriority(events, includeLevels = null) {
+    if (!includeLevels) {
+        includeLevels = ['critical', 'important'];
+    }
+    const allowedTypes = new Set();
+    for (const level of includeLevels) {
+        const types = PRIORITY[level] || [];
+        for (const type of types) {
+            allowedTypes.add(type);
+        }
+    }
+    return events.filter(e => allowedTypes.has(e.type));
+}
+/** Return the event type of the last tool-related or significant event, or null. */
+export function getLastTool(events) {
+    if (events.length === 0)
+        return null;
+    const lastEvent = events[events.length - 1];
+    const eventType = lastEvent.type || '';
+    const validTypes = ['tool_use', 'bash', 'file_write', 'file_create', 'file_read', 'file_delete', 'message', 'error', 'result'];
+    if (validTypes.includes(eventType)) {
+        return eventType;
+    }
+    return null;
+}
+/** Extract all tool_use events as {tool, args} pairs. */
+export function getToolUses(events) {
+    const toolUses = [];
+    for (const event of events) {
+        if (event.type === 'tool_use') {
+            const tool = event.tool || 'unknown';
+            const args = event.args || {};
+            toolUses.push({ tool, args });
+        }
+    }
+    return toolUses;
+}
+/** Extract the last N complete messages from the event stream, joining streaming deltas. */
+export function getLastMessages(events, count = 3) {
+    const messages = [];
+    let currentBuffer = '';
+    let isCollecting = false;
+    for (const event of events) {
+        if (event.type === 'message') {
+            const content = event.content || '';
+            // For streaming events (delta=true), content fragments should be joined.
+            // We don't add newlines because these are likely parts of the same sentence/block.
+            currentBuffer += content;
+            isCollecting = true;
+            // If we hit an explicitly complete message, treat it as a boundary
+            if (event.complete) {
+                if (currentBuffer.trim()) {
+                    messages.push(currentBuffer);
+                }
+                currentBuffer = '';
+                isCollecting = false;
+            }
+        }
+        else {
+            // Any non-message event breaks the message stream
+            if (isCollecting) {
+                if (currentBuffer.trim()) {
+                    messages.push(currentBuffer);
+                }
+                currentBuffer = '';
+                isCollecting = false;
+            }
+        }
+    }
+    // Handle any remaining buffer at the end
+    if (isCollecting && currentBuffer.trim()) {
+        messages.push(currentBuffer);
+    }
+    return messages.slice(-count);
+}
+/** Build a lightweight QuickStatus snapshot from agent events. */
+export function getQuickStatus(agentId, agentType, status, events) {
+    const filesCreatedSet = new Set();
+    const filesModifiedSet = new Set();
+    const filesDeletedSet = new Set();
+    const filesReadSet = new Set();
+    let toolCount = 0;
+    let hasErrors = false;
+    const commands = [];
+    let lastMessage = null;
+    for (const event of events) {
+        const eventType = event.type || '';
+        if (eventType === 'message') {
+            const content = event.content || '';
+            if (content) {
+                lastMessage = content;
+            }
+        }
+        else if (eventType === 'file_create') {
+            const path = event.path || '';
+            if (path) {
+                filesCreatedSet.add(path);
+            }
+            toolCount++;
+        }
+        else if (eventType === 'file_write') {
+            const path = event.path || '';
+            if (path) {
+                filesModifiedSet.add(path);
+            }
+            toolCount++;
+        }
+        else if (eventType === 'file_delete') {
+            const path = event.path || '';
+            if (path) {
+                filesDeletedSet.add(path);
+            }
+            toolCount++;
+        }
+        else if (eventType === 'file_read') {
+            const path = event.path || '';
+            if (path) {
+                filesReadSet.add(path);
+            }
+            toolCount++;
+        }
+        else if (eventType === 'bash') {
+            toolCount++;
+            const cmd = event.command || '';
+            if (cmd) {
+                commands.push(cmd.length > 100 ? cmd.substring(0, 97) + '...' : cmd);
+                const [filesRead, filesWritten, filesDeleted] = extractFileOpsFromBash(cmd);
+                for (const path of filesRead) {
+                    filesReadSet.add(path);
+                }
+                for (const path of filesWritten) {
+                    filesModifiedSet.add(path);
+                }
+                for (const path of filesDeleted) {
+                    filesDeletedSet.add(path);
+                }
+            }
+        }
+        else if (eventType === 'directory_list') {
+            toolCount++;
+        }
+        else if (['tool_use'].includes(eventType)) {
+            toolCount++;
+        }
+        else if (eventType === 'error' || (eventType === 'result' && event.status === 'error')) {
+            hasErrors = true;
+        }
+    }
+    return {
+        agent_id: agentId,
+        agent_type: agentType,
+        status: status,
+        files_created: filesCreatedSet.size,
+        files_modified: filesModifiedSet.size,
+        files_deleted: filesDeletedSet.size,
+        files_read: filesReadSet.size,
+        tool_count: toolCount,
+        last_commands: commands.slice(-3),
+        has_errors: hasErrors,
+        last_message: lastMessage,
+    };
+}
+/** Produce a one-line human-readable status summary string (e.g. "Running, modified 3 files, used bash 5 times"). */
+export function getStatusSummary(agentId, agentType, status, events, duration = null) {
+    if (events.length === 0) {
+        if (status === 'running') {
+            return 'Just started, no activity yet';
+        }
+        return 'No activity';
+    }
+    let fileCount = 0;
+    let bashCount = 0;
+    let toolCount = 0;
+    let hasErrors = false;
+    for (const event of events) {
+        const eventType = event.type || '';
+        if (['file_write', 'file_create', 'file_delete'].includes(eventType)) {
+            fileCount++;
+        }
+        else if (eventType === 'bash') {
+            bashCount++;
+        }
+        else if (['tool_use', 'file_read'].includes(eventType)) {
+            toolCount++;
+        }
+        else if (['error', 'result'].includes(eventType)) {
+            if (event.status === 'error') {
+                hasErrors = true;
+            }
+        }
+    }
+    const totalTools = bashCount + toolCount;
+    const parts = [];
+    if (status === 'running') {
+        parts.push('Running');
+    }
+    else if (status === 'completed') {
+        if (hasErrors) {
+            parts.push('Completed with errors');
+        }
+        else {
+            parts.push('Completed successfully');
+        }
+    }
+    else if (status === 'failed') {
+        parts.push('Failed');
+    }
+    else if (status === 'stopped') {
+        parts.push('Stopped');
+    }
+    if (fileCount > 0) {
+        parts.push(`modified ${fileCount} file${fileCount !== 1 ? 's' : ''}`);
+    }
+    if (bashCount > 0) {
+        parts.push(`used bash ${bashCount} time${bashCount !== 1 ? 's' : ''}`);
+    }
+    if (toolCount > 0 && bashCount === 0) {
+        parts.push(`used ${toolCount} tool${toolCount !== 1 ? 's' : ''}`);
+    }
+    if (totalTools > 0 && bashCount > 0) {
+        parts.push(`used ${totalTools} tool${totalTools !== 1 ? 's' : ''}`);
+    }
+    if (hasErrors && status === 'running') {
+        parts.push('has errors');
+    }
+    if (parts.length === 0) {
+        if (status === 'running') {
+            return `Running, ${events.length} event${events.length !== 1 ? 's' : ''} so far`;
+        }
+        return status.charAt(0).toUpperCase() + status.slice(1);
+    }
+    return parts.join(', ');
+}
+//# sourceMappingURL=summarizer.js.map