@swarmify/agents-cli 1.12.0 → 1.13.0

package/dist/lib/teams/parsers.js

@@ -0,0 +1,837 @@
+/**
+ * Agent event stream parsers.
+ *
+ * Normalizes the heterogeneous JSON event formats emitted by each agent CLI
+ * (Claude, Codex, Gemini, Cursor, OpenCode) into a unified event schema
+ * with consistent types: init, message, tool_use, bash, file_read, file_write,
+ * file_create, file_delete, result, error, and others.
+ */
+import { extractFileOpsFromBash } from './file_ops.js';
+const claudeToolUseMap = new Map();
+/** Normalize a raw JSON event from any agent type into an array of unified event objects. */
+export function normalizeEvents(agentType, raw) {
+    if (agentType === 'codex') {
+        return normalizeCodex(raw);
+    }
+    else if (agentType === 'cursor') {
+        return normalizeCursor(raw);
+    }
+    else if (agentType === 'gemini') {
+        return normalizeGemini(raw);
+    }
+    else if (agentType === 'claude') {
+        return normalizeClaude(raw);
+    }
+    else if (agentType === 'opencode') {
+        return normalizeOpencode(raw);
+    }
+    const timestamp = new Date().toISOString();
+    return [{
+            type: raw.type || 'unknown',
+            agent: agentType,
+            raw: raw,
+            timestamp: timestamp,
+        }];
+}
+/** Normalize a raw JSON event, returning only the first unified event (convenience wrapper). */
+export function normalizeEvent(agentType, raw) {
+    const events = normalizeEvents(agentType, raw);
+    if (events.length > 0) {
+        return events[0];
+    }
+    return {
+        type: raw.type || 'unknown',
+        agent: agentType,
+        raw: raw,
+        timestamp: new Date().toISOString(),
+    };
+}
+function normalizeCodex(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return [{
+                type: 'unknown',
+                agent: 'codex',
+                raw: raw,
+                timestamp: new Date().toISOString(),
+            }];
+    }
+    const eventType = raw.type || 'unknown';
+    const timestamp = new Date().toISOString();
+    if (eventType === 'thread.started') {
+        return [{
+                type: 'init',
+                agent: 'codex',
+                session_id: raw.thread_id || null,
+                timestamp: timestamp,
+            }];
+    }
+    else if (eventType === 'turn.started') {
+        return [{
+                type: 'turn_start',
+                agent: 'codex',
+                timestamp: timestamp,
+            }];
+    }
+    else if (eventType === 'item.completed') {
+        const item = raw.item || {};
+        const itemType = item?.type;
+        if (itemType === 'agent_message') {
+            return [{
+                    type: 'message',
+                    agent: 'codex',
+                    content: item?.text || '',
+                    complete: true,
+                    timestamp: timestamp,
+                }];
+        }
+        else if (itemType === 'command_execution') {
+            const command = item?.command || '';
+            if (!command.trim()) {
+                return [];
+            }
+            const events = [{
+                    type: 'bash',
+                    agent: 'codex',
+                    tool: 'command_execution',
+                    command: command,
+                    timestamp: timestamp,
+                }];
+            const [filesRead, filesWritten, filesDeleted] = extractFileOpsFromBash(command);
+            for (const path of filesRead) {
+                events.push({
+                    type: 'file_read',
+                    agent: 'codex',
+                    tool: 'bash',
+                    path,
+                    command,
+                    timestamp,
+                });
+            }
+            for (const path of filesWritten) {
+                events.push({
+                    type: 'file_write',
+                    agent: 'codex',
+                    tool: 'bash',
+                    path,
+                    command,
+                    timestamp,
+                });
+            }
+            for (const path of filesDeleted) {
+                events.push({
+                    type: 'file_delete',
+                    agent: 'codex',
+                    tool: 'bash',
+                    path,
+                    command,
+                    timestamp,
+                });
+            }
+            return events;
+        }
+        else if (itemType === 'file_change') {
+            const changes = Array.isArray(item?.changes) ? item.changes : [];
+            const changeEvents = [];
+            for (const change of changes) {
+                const path = change?.path || change?.file_path || '';
+                if (!path) {
+                    continue;
+                }
+                const kind = String(change?.kind || change?.status || '').toLowerCase();
+                const baseEvent = {
+                    agent: 'codex',
+                    tool: 'file_change',
+                    path,
+                    timestamp,
+                };
+                if (['add', 'create', 'new'].includes(kind)) {
+                    changeEvents.push({ ...baseEvent, type: 'file_create' });
+                }
+                else if (['delete', 'remove'].includes(kind)) {
+                    changeEvents.push({ ...baseEvent, type: 'file_delete' });
+                }
+                else {
+                    changeEvents.push({ ...baseEvent, type: 'file_write' });
+                }
+            }
+            if (changeEvents.length > 0) {
+                return changeEvents;
+            }
+        }
+        else if (itemType === 'tool_call') {
+            const toolName = item?.name || 'unknown';
+            const toolArgs = item?.arguments || {};
+            if (toolName === 'create_file') {
+                const path = toolArgs?.path || toolArgs?.file_path || '';
+                if (!path) {
+                    return [];
+                }
+                return [{
+                        type: 'file_create',
+                        agent: 'codex',
+                        tool: toolName,
+                        path: path,
+                        timestamp: timestamp,
+                    }];
+            }
+            else if (toolName === 'write_file' || toolName === 'edit_file') {
+                const path = toolArgs?.path || toolArgs?.file_path || '';
+                if (!path) {
+                    return [];
+                }
+                return [{
+                        type: 'file_write',
+                        agent: 'codex',
+                        tool: toolName,
+                        path: path,
+                        timestamp: timestamp,
+                    }];
+            }
+            else if (toolName === 'read_file') {
+                const path = toolArgs?.path || toolArgs?.file_path || '';
+                if (!path) {
+                    return [];
+                }
+                return [{
+                        type: 'file_read',
+                        agent: 'codex',
+                        tool: toolName,
+                        path: path,
+                        timestamp: timestamp,
+                    }];
+            }
+            else if (toolName === 'delete_file' || toolName === 'remove_file') {
+                const path = toolArgs?.path || toolArgs?.file_path || '';
+                if (!path) {
+                    return [];
+                }
+                return [{
+                        type: 'file_delete',
+                        agent: 'codex',
+                        tool: toolName,
+                        path: path,
+                        timestamp: timestamp,
+                    }];
+            }
+            else if (toolName === 'shell' || toolName === 'bash' || toolName === 'execute') {
+                const command = toolArgs?.command || '';
+                if (!command.trim()) {
+                    return [];
+                }
+                return [{
+                        type: 'bash',
+                        agent: 'codex',
+                        tool: toolName,
+                        command: command,
+                        timestamp: timestamp,
+                    }];
+            }
+            else {
+                return [{
+                        type: 'tool_use',
+                        agent: 'codex',
+                        tool: toolName,
+                        args: toolArgs,
+                        timestamp: timestamp,
+                    }];
+            }
+        }
+    }
+    else if (eventType === 'turn.completed') {
+        const usage = raw.usage || {};
+        return [{
+                type: 'result',
+                agent: 'codex',
+                status: 'success',
+                usage: {
+                    input_tokens: usage?.input_tokens || 0,
+                    output_tokens: usage?.output_tokens || 0,
+                },
+                timestamp: timestamp,
+            }];
+    }
+    return [{
+            type: eventType,
+            agent: 'codex',
+            raw: raw,
+            timestamp: timestamp,
+        }];
+}
+function normalizeCursor(raw) {
+    const eventType = raw.type || 'unknown';
+    const subtype = raw.subtype;
+    const timestamp = new Date().toISOString();
+    if (eventType === 'system' && subtype === 'init') {
+        return [{
+                type: 'init',
+                agent: 'cursor',
+                model: raw.model,
+                session_id: raw.session_id,
+                timestamp: timestamp,
+            }];
+    }
+    else if (eventType === 'thinking') {
+        if (subtype === 'delta') {
+            const text = raw.text || '';
+            if (!text.trim()) {
+                return [];
+            }
+        }
+        return [{
+                type: 'thinking',
+                agent: 'cursor',
+                content: raw.text || '',
+                complete: subtype === 'completed',
+                timestamp: timestamp,
+            }];
+    }
+    else if (eventType === 'assistant') {
+        const message = raw.message || {};
+        const contentBlocks = message.content || [];
+        const events = [];
+        let textContent = '';
+        for (const block of contentBlocks) {
+            if (block.type === 'text') {
+                textContent += block.text || '';
+            }
+            else if (block.type === 'tool_use') {
+                events.push({
+                    type: 'tool_use',
+                    agent: 'cursor',
+                    tool: block.name || 'unknown',
+                    args: block.input || {},
+                    timestamp: timestamp,
+                });
+            }
+        }
+        if (textContent) {
+            events.push({
+                type: 'message',
+                agent: 'cursor',
+                content: textContent,
+                complete: true,
+                timestamp: timestamp,
+            });
+        }
+        if (events.length === 0) {
+            events.push({
+                type: 'message',
+                agent: 'cursor',
+                content: '',
+                complete: true,
+                timestamp: timestamp,
+            });
+        }
+        return events;
+    }
+    else if (eventType === 'result') {
+        return [{
+                type: 'result',
+                agent: 'cursor',
+                status: subtype || 'success',
+                duration_ms: raw.duration_ms,
+                timestamp: timestamp,
+            }];
+    }
+    else if (eventType === 'tool_result') {
+        return [{
+                type: 'tool_result',
+                agent: 'cursor',
+                tool: raw.tool_name || 'unknown',
+                success: raw.success !== false,
+                timestamp: timestamp,
+            }];
+    }
+    else if (eventType === 'tool_call' && subtype === 'completed') {
+        const toolCall = raw.tool_call;
+        if (toolCall?.shellToolCall) {
+            const command = toolCall.shellToolCall.args?.command || '';
+            return [{
+                    type: 'bash',
+                    agent: 'cursor',
+                    tool: 'shell',
+                    command: command,
+                    timestamp: timestamp,
+                }];
+        }
+        else if (toolCall?.editToolCall) {
+            const filePath = toolCall.editToolCall.args?.path || '';
+            return [{
+                    type: 'file_write',
+                    agent: 'cursor',
+                    tool: 'edit',
+                    path: filePath,
+                    timestamp: timestamp,
+                }];
+        }
+        else if (toolCall?.readToolCall) {
+            const filePath = toolCall.readToolCall.args?.path || '';
+            return [{
+                    type: 'file_read',
+                    agent: 'cursor',
+                    tool: 'read',
+                    path: filePath,
+                    timestamp: timestamp,
+                }];
+        }
+        else if (toolCall?.deleteToolCall) {
+            const filePath = toolCall.deleteToolCall.args?.path || '';
+            return [{
+                    type: 'file_delete',
+                    agent: 'cursor',
+                    tool: 'delete',
+                    path: filePath,
+                    timestamp: timestamp,
+                }];
+        }
+        else if (toolCall?.listToolCall) {
+            const dirPath = toolCall.listToolCall.args?.path || '';
+            return [{
+                    type: 'directory_list',
+                    agent: 'cursor',
+                    tool: 'list',
+                    path: dirPath,
+                    timestamp: timestamp,
+                }];
+        }
+        return [{
+                type: 'tool_use',
+                agent: 'cursor',
+                tool: Object.keys(toolCall || {})[0] || 'unknown',
+                timestamp: timestamp,
+            }];
+    }
+    return [{
+            type: eventType,
+            agent: 'cursor',
+            raw: raw,
+            timestamp: timestamp,
+        }];
+}
+function normalizeGemini(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return [{
+                type: 'unknown',
+                agent: 'gemini',
+                raw: raw,
+                timestamp: new Date().toISOString(),
+            }];
+    }
+    const eventType = raw?.type || 'unknown';
+    const timestamp = raw?.timestamp || new Date().toISOString();
+    if (eventType === 'init') {
+        return [{
+                type: 'init',
+                agent: 'gemini',
+                model: raw?.model,
+                session_id: raw?.session_id,
+                timestamp: timestamp,
+            }];
+    }
+    else if (eventType === 'message') {
+        const role = raw?.role || 'assistant';
+        if (role === 'assistant') {
+            return [{
+                    type: 'message',
+                    agent: 'gemini',
+                    content: raw?.content || '',
+                    complete: !raw?.delta,
+                    timestamp: timestamp,
+                }];
+        }
+        else {
+            return [{
+                    type: 'user_message',
+                    agent: 'gemini',
+                    content: raw?.content || '',
+                    timestamp: timestamp,
+                }];
+        }
+    }
+    else if (eventType === 'tool_call' || eventType === 'tool_use') {
+        const toolNameRaw = raw?.tool_name || raw?.name || 'unknown';
+        const toolName = String(toolNameRaw);
+        let toolArgsRaw = raw?.parameters;
+        if (toolArgsRaw === null || toolArgsRaw === undefined) {
+            toolArgsRaw = raw?.args;
+        }
+        const toolArgs = (typeof toolArgsRaw === 'object' && toolArgsRaw !== null) ? toolArgsRaw : {};
+        const toolNameLower = toolName.toLowerCase();
+        const filePath = toolArgs?.file_path || toolArgs?.path || '';
+        const command = toolArgs?.command || '';
+        // File write/edit tools - Gemini uses 'replace', 'edit', 'patch', 'write_file', etc.
+        const writeTools = ['replace', 'edit', 'patch', 'write_file', 'edit_file', 'update_file', 'modify_file'];
+        if (writeTools.includes(toolNameLower) || (toolNameLower.includes('write') && toolNameLower.includes('file'))) {
+            if (!filePath.trim()) {
+                return [];
+            }
+            return [{
+                    type: 'file_write',
+                    agent: 'gemini',
+                    tool: toolName,
+                    path: filePath,
+                    timestamp: timestamp,
+                }];
+        }
+        // File read tools
+        const readTools = ['read_file', 'view_file', 'cat_file', 'get_file'];
+        if (readTools.includes(toolNameLower) || (toolNameLower.includes('read') && toolNameLower.includes('file'))) {
+            if (!filePath.trim()) {
+                return [];
+            }
+            return [{
+                    type: 'file_read',
+                    agent: 'gemini',
+                    tool: toolName,
+                    path: filePath,
+                    timestamp: timestamp,
+                }];
+        }
+        // File delete tools
+        const deleteTools = ['delete_file', 'remove_file', 'rm_file'];
+        if (deleteTools.includes(toolNameLower) || (toolNameLower.includes('delete') && toolNameLower.includes('file'))) {
+            if (!filePath.trim()) {
+                return [];
+            }
+            return [{
+                    type: 'file_delete',
+                    agent: 'gemini',
+                    tool: toolName,
+                    path: filePath,
+                    timestamp: timestamp,
+                }];
+        }
+        // Shell/bash tools
+        if (['shell', 'bash', 'execute', 'run_command', 'run_shell_command'].includes(toolNameLower)) {
+            if (!command.trim()) {
+                return [];
+            }
+            return [{
+                    type: 'bash',
+                    agent: 'gemini',
+                    tool: toolName,
+                    command: command,
+                    timestamp: timestamp,
+                }];
+        }
+        return [{
+                type: 'tool_use',
+                agent: 'gemini',
+                tool: toolName,
+                args: toolArgs,
+                timestamp: timestamp,
+            }];
+    }
+    else if (eventType === 'result') {
+        const stats = raw?.stats || {};
+        return [{
+                type: 'result',
+                agent: 'gemini',
+                status: raw?.status || 'success',
+                duration_ms: stats?.duration_ms,
+                usage: {
+                    total_tokens: stats?.total_tokens || 0,
+                },
+                timestamp: timestamp,
+            }];
+    }
+    return [{
+            type: eventType,
+            agent: 'gemini',
+            raw: raw,
+            timestamp: timestamp,
+        }];
+}
+function normalizeClaude(raw) {
+    const eventType = raw.type || 'unknown';
+    const subtype = raw.subtype;
+    const timestamp = new Date().toISOString();
+    if (eventType === 'system' && subtype === 'init') {
+        return [{
+                type: 'init',
+                agent: 'claude',
+                model: raw.model,
+                session_id: raw.session_id,
+                timestamp: timestamp,
+            }];
+    }
+    else if (eventType === 'assistant') {
+        const message = raw.message || {};
+        const contentBlocks = message.content || [];
+        const events = [];
+        let textContent = '';
+        for (const block of contentBlocks) {
+            if (block.type === 'text') {
+                textContent += block.text || '';
+            }
+            else if (block.type === 'tool_use') {
+                const toolName = block.name || 'unknown';
+                const toolId = block.id;
+                const toolInput = block.input || {};
+                if (toolId) {
+                    if (toolName === 'Bash' && toolInput.command) {
+                        claudeToolUseMap.set(toolId, { tool: toolName, command: toolInput.command });
+                    }
+                    else if ((toolName === 'Edit' || toolName === 'Write') && toolInput.file_path) {
+                        claudeToolUseMap.set(toolId, { tool: toolName, path: toolInput.file_path });
+                    }
+                    else if (toolName === 'Read' && toolInput.file_path) {
+                        claudeToolUseMap.set(toolId, { tool: toolName, path: toolInput.file_path });
+                    }
+                }
+                events.push({
+                    type: 'tool_use',
+                    agent: 'claude',
+                    tool: toolName,
+                    args: toolInput,
+                    timestamp: timestamp,
+                });
+            }
+        }
+        if (textContent) {
+            events.push({
+                type: 'message',
+                agent: 'claude',
+                content: textContent,
+                complete: true,
+                timestamp: timestamp,
+            });
+        }
+        if (events.length === 0) {
+            events.push({
+                type: 'message',
+                agent: 'claude',
+                content: '',
+                complete: true,
+                timestamp: timestamp,
+            });
+        }
+        return events;
+    }
+    else if (eventType === 'user') {
+        const message = raw.message || {};
+        const contentBlocks = message.content || [];
+        const toolUseResult = raw.tool_use_result;
+        const events = [];
+        for (const block of contentBlocks) {
+            if (block.type === 'tool_result') {
+                const toolUseId = block.tool_use_id;
+                if (toolUseResult?.file) {
+                    events.push({
+                        type: 'file_read',
+                        agent: 'claude',
+                        path: toolUseResult.file.filePath,
+                        timestamp: timestamp,
+                    });
+                }
+                else if (toolUseResult?.stdout !== undefined) {
+                    const toolUseInfo = claudeToolUseMap.get(toolUseId);
+                    const command = toolUseInfo?.command || '';
+                    events.push({
+                        type: 'bash',
+                        agent: 'claude',
+                        command: command,
+                        timestamp: timestamp,
+                    });
+                    claudeToolUseMap.delete(toolUseId);
+                }
+                else if (!block.is_error && typeof toolUseResult !== 'string') {
+                    const toolUseInfo = claudeToolUseMap.get(toolUseId);
+                    if (toolUseInfo && (toolUseInfo.tool === 'Edit' || toolUseInfo.tool === 'Write') && toolUseInfo.path) {
+                        events.push({
+                            type: 'file_write',
+                            agent: 'claude',
+                            path: toolUseInfo.path,
+                            timestamp: timestamp,
+                        });
+                        claudeToolUseMap.delete(toolUseId);
+                    }
+                    else {
+                        events.push({
+                            type: 'tool_result',
+                            agent: 'claude',
+                            tool_use_id: toolUseId,
+                            success: true,
+                            timestamp: timestamp,
+                        });
+                        if (toolUseInfo) {
+                            claudeToolUseMap.delete(toolUseId);
+                        }
+                    }
+                }
+                else if (block.is_error || (typeof toolUseResult === 'string' && toolUseResult.startsWith('Error:'))) {
+                    events.push({
+                        type: 'error',
+                        agent: 'claude',
+                        message: block.content || (typeof toolUseResult === 'string' ? toolUseResult : ''),
+                        timestamp: timestamp,
+                    });
+                }
+                else {
+                    const toolUseInfo = claudeToolUseMap.get(toolUseId);
+                    events.push({
+                        type: 'tool_result',
+                        agent: 'claude',
+                        tool_use_id: toolUseId,
+                        success: !block.is_error,
+                        timestamp: timestamp,
+                    });
+                    if (toolUseInfo) {
+                        claudeToolUseMap.delete(toolUseId);
+                    }
+                }
+            }
+        }
+        return events.length > 0 ? events : [{
+                type: eventType,
+                agent: 'claude',
+                raw: raw,
+                timestamp: timestamp,
+            }];
+    }
+    else if (eventType === 'result') {
+        return [{
+                type: 'result',
+                agent: 'claude',
+                status: subtype || 'success',
+                duration_ms: raw.duration_ms,
+                timestamp: timestamp,
+            }];
+    }
+    return [{
+            type: eventType,
+            agent: 'claude',
+            raw: raw,
+            timestamp: timestamp,
+        }];
+}
+// --- OpenCode parsing ---
+// OpenCode outputs JSON events with step_start, tool_use, text, step_finish types
+function normalizeOpencode(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return [{
+                type: 'unknown',
+                agent: 'opencode',
+                raw: raw,
+                timestamp: new Date().toISOString(),
+            }];
+    }
+    const eventType = raw?.type || 'unknown';
+    const timestamp = raw?.timestamp ? new Date(raw.timestamp).toISOString() : new Date().toISOString();
+    const part = raw?.part || {};
+    if (eventType === 'step_start' || eventType === 'step-start') {
+        return [{
+                type: 'init',
+                agent: 'opencode',
+                session_id: part?.sessionID || null,
+                timestamp: timestamp,
+            }];
+    }
+    if (eventType === 'tool_use') {
+        const toolName = part?.tool || 'unknown';
+        const state = part?.state || {};
+        const input = state?.input || {};
+        const status = state?.status || 'unknown';
+        const events = [];
+        if (toolName === 'bash' && input?.command) {
+            events.push({
+                type: 'bash',
+                agent: 'opencode',
+                tool: toolName,
+                command: input.command,
+                timestamp: timestamp,
+            });
+            const [filesRead, filesWritten, filesDeleted] = extractFileOpsFromBash(input.command);
+            for (const path of filesRead) {
+                events.push({ type: 'file_read', agent: 'opencode', tool: 'bash', path, command: input.command, timestamp });
+            }
+            for (const path of filesWritten) {
+                events.push({ type: 'file_write', agent: 'opencode', tool: 'bash', path, command: input.command, timestamp });
+            }
+            for (const path of filesDeleted) {
+                events.push({ type: 'file_delete', agent: 'opencode', tool: 'bash', path, command: input.command, timestamp });
+            }
+            return events;
+        }
+        const filePath = input?.path || input?.file_path || '';
+        if (toolName === 'edit_file' || toolName === 'write_file' || toolName === 'create_file') {
+            if (filePath.trim()) {
+                return [{
+                        type: 'file_write',
+                        agent: 'opencode',
+                        tool: toolName,
+                        path: filePath,
+                        timestamp: timestamp,
+                    }];
+            }
+        }
+        if (toolName === 'read_file' || toolName === 'view_file') {
+            if (filePath.trim()) {
+                return [{
+                        type: 'file_read',
+                        agent: 'opencode',
+                        tool: toolName,
+                        path: filePath,
+                        timestamp: timestamp,
+                    }];
+            }
+        }
+        if (toolName === 'delete_file' || toolName === 'remove_file') {
+            if (filePath.trim()) {
+                return [{
+                        type: 'file_delete',
+                        agent: 'opencode',
+                        tool: toolName,
+                        path: filePath,
+                        timestamp: timestamp,
+                    }];
+            }
+        }
+        return [{
+                type: 'tool_use',
+                agent: 'opencode',
+                tool: toolName,
+                args: input,
+                timestamp: timestamp,
+            }];
+    }
+    if (eventType === 'text') {
+        const text = part?.text || '';
+        return [{
+                type: 'message',
+                agent: 'opencode',
+                content: text,
+                complete: true,
+                timestamp: timestamp,
+            }];
+    }
+    if (eventType === 'step_finish' || eventType === 'step-finish') {
+        const reason = part?.reason || 'unknown';
+        const status = reason === 'stop' ? 'success' : (reason === 'error' ? 'error' : 'success');
+        return [{
+                type: 'result',
+                agent: 'opencode',
+                status: status,
+                cost: part?.cost || 0,
+                tokens: part?.tokens || {},
+                timestamp: timestamp,
+            }];
+    }
+    return [{
+            type: eventType,
+            agent: 'opencode',
+            raw: raw,
+            timestamp: timestamp,
+        }];
+}
+/** Parse a single JSONL line into normalized events. Returns null if the line is not valid JSON. */
+export function parseEvent(agentType, line) {
+    try {
+        const raw = JSON.parse(line);
+        return normalizeEvents(agentType, raw);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=parsers.js.map