atoo-studio 0.0.1 → 0.0.2

package/dist/src/events/types.d.ts

@@ -0,0 +1,214 @@
+/**
+ * SessionEvent — canonical superset type for all agent message formats.
+ *
+ * Discriminated union on `type`. Every raw JSONL event from any agent
+ * (Claude Code, future Codex/Gemini) maps 1:1 to a SessionEvent variant.
+ *
+ * See docs/session-event-schema.md for how this type was derived.
+ */
+export interface TextBlock {
+    type: 'text';
+    text: string;
+}
+export interface ThinkingBlock {
+    type: 'thinking';
+    thinking: string;
+    signature?: string;
+}
+export interface ToolUseBlock {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, any>;
+    caller?: string;
+}
+export interface ToolResultBlock {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string | ToolResultContentBlock[];
+    is_error?: boolean;
+}
+export type ToolResultContentBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    source: ImageSource;
+};
+export interface ImageBlock {
+    type: 'image';
+    source: ImageSource;
+}
+export interface DocumentBlock {
+    type: 'document';
+    source: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    };
+}
+export interface ImageSource {
+    type: 'base64';
+    media_type: string;
+    data: string;
+}
+export type AssistantContentBlock = TextBlock | ThinkingBlock | ToolUseBlock;
+export type UserContentBlock = TextBlock | ToolResultBlock | ImageBlock | DocumentBlock;
+export type ContentBlock = AssistantContentBlock | UserContentBlock;
+export interface SessionEventEnvelope {
+    uuid: string;
+    sessionId?: string;
+    session_id?: string;
+    parentUuid?: string | null;
+    timestamp?: string;
+    cwd?: string;
+    gitBranch?: string;
+    version?: string;
+    slug?: string;
+    userType?: string;
+    isSidechain?: boolean;
+    isSynthetic?: boolean;
+    agentId?: string;
+    parent_tool_use_id?: string | null;
+}
+export interface UserEvent extends SessionEventEnvelope {
+    type: 'user';
+    message: {
+        role: 'user';
+        content: string | UserContentBlock[];
+    };
+    toolUseResult?: ToolUseResult;
+}
+export interface ToolUseResult {
+    type?: string;
+    content?: string;
+    filePath?: string;
+    file?: {
+        content: string;
+        filePath: string;
+        numLines?: number;
+        startLine?: number;
+        totalLines?: number;
+    };
+    originalFile?: string;
+    structuredPatch?: any;
+    prompt?: string;
+    status?: string;
+    totalDurationMs?: number;
+    totalTokens?: number;
+    totalToolUseCount?: number;
+    usage?: Record<string, any>;
+}
+export interface AssistantEvent extends SessionEventEnvelope {
+    type: 'assistant';
+    message: {
+        role: 'assistant';
+        content: string | AssistantContentBlock[];
+        model?: string;
+        stop_reason?: string | null;
+        usage?: {
+            input_tokens?: number;
+            output_tokens?: number;
+            cache_creation_input_tokens?: number;
+            cache_read_input_tokens?: number;
+        };
+    };
+}
+export interface SystemEvent extends SessionEventEnvelope {
+    type: 'system';
+    subtype?: string;
+    model?: string;
+    permissionMode?: string;
+    durationMs?: number;
+    content?: string;
+    hookCount?: number;
+    hookInfos?: any[];
+    hookErrors?: any[];
+    hasOutput?: boolean;
+    preventedContinuation?: boolean;
+    url?: string;
+    compactMetadata?: {
+        preTokens?: number;
+        trigger?: string;
+    };
+    message?: {
+        role: string;
+        content: any;
+    };
+}
+export interface ProgressEvent extends SessionEventEnvelope {
+    type: 'progress';
+    data?: {
+        agentId?: string;
+        content?: string;
+        type?: string;
+        [key: string]: any;
+    };
+    message?: {
+        role: string;
+        content: any;
+    };
+}
+export interface ControlRequestEvent extends SessionEventEnvelope {
+    type: 'control_request';
+    request_id?: string;
+    request?: {
+        subtype?: string;
+        tool_use?: {
+            name: string;
+            input: Record<string, any>;
+        };
+        tool_name?: string;
+        input?: Record<string, any>;
+        model?: string;
+        [key: string]: any;
+    };
+}
+export interface ControlResponseEvent extends SessionEventEnvelope {
+    type: 'control_response';
+    response?: {
+        subtype?: string;
+        request_id?: string;
+        response?: {
+            behavior?: string;
+            message?: string;
+            updatedInput?: any;
+            updatedPermissions?: any[];
+        };
+    };
+}
+export interface ResultEvent extends SessionEventEnvelope {
+    type: 'result';
+    subtype?: string;
+    result?: string;
+    message?: {
+        role: string;
+        content: any;
+    };
+}
+export interface FileHistorySnapshotEvent extends SessionEventEnvelope {
+    type: 'file-history-snapshot';
+    filePath?: string;
+    content?: string;
+    [key: string]: any;
+}
+export interface LastPromptEvent extends SessionEventEnvelope {
+    type: 'last-prompt';
+    prompt?: string;
+    [key: string]: any;
+}
+export interface QueueOperationEvent extends SessionEventEnvelope {
+    type: 'queue-operation';
+    operation?: string;
+    [key: string]: any;
+}
+export type SessionEvent = UserEvent | AssistantEvent | SystemEvent | ProgressEvent | ControlRequestEvent | ControlResponseEvent | ResultEvent | FileHistorySnapshotEvent | LastPromptEvent | QueueOperationEvent;
+export declare function isUserEvent(e: SessionEvent): e is UserEvent;
+export declare function isAssistantEvent(e: SessionEvent): e is AssistantEvent;
+export declare function isSystemEvent(e: SessionEvent): e is SystemEvent;
+export declare function isProgressEvent(e: SessionEvent): e is ProgressEvent;
+export declare function isControlRequestEvent(e: SessionEvent): e is ControlRequestEvent;
+export declare function isControlResponseEvent(e: SessionEvent): e is ControlResponseEvent;
+export declare function isResultEvent(e: SessionEvent): e is ResultEvent;
+/** Get the session ID from either camelCase or snake_case field. */
+export declare function getSessionId(e: SessionEvent): string;

package/dist/src/events/types.js

@@ -0,0 +1,22 @@
+/**
+ * SessionEvent — canonical superset type for all agent message formats.
+ *
+ * Discriminated union on `type`. Every raw JSONL event from any agent
+ * (Claude Code, future Codex/Gemini) maps 1:1 to a SessionEvent variant.
+ *
+ * See docs/session-event-schema.md for how this type was derived.
+ */
+// ═══════════════════════════════════════════════════════
+// Type guards
+// ═══════════════════════════════════════════════════════
+export function isUserEvent(e) { return e.type === 'user'; }
+export function isAssistantEvent(e) { return e.type === 'assistant'; }
+export function isSystemEvent(e) { return e.type === 'system'; }
+export function isProgressEvent(e) { return e.type === 'progress'; }
+export function isControlRequestEvent(e) { return e.type === 'control_request'; }
+export function isControlResponseEvent(e) { return e.type === 'control_response'; }
+export function isResultEvent(e) { return e.type === 'result'; }
+/** Get the session ID from either camelCase or snake_case field. */
+export function getSessionId(e) {
+    return e.sessionId || e.session_id || '';
+}

package/dist/src/events/wire.d.ts

@@ -0,0 +1,114 @@
+import type { SessionEvent } from './types.js';
+export interface WireBase {
+    id: string;
+    sessionId: string;
+    timestamp: number;
+    rawEventUuid?: string;
+    _sidechain?: boolean;
+    _parentToolUseId?: string;
+    _agentId?: string;
+}
+export interface WireUserMessage extends WireBase {
+    type: 'user_message';
+    text: string;
+    attachments?: WireAttachment[];
+}
+export interface WireAssistantMessage extends WireBase {
+    type: 'assistant_message';
+    text: string;
+    isPartial?: boolean;
+}
+export interface WireThinking extends WireBase {
+    type: 'thinking';
+    text: string;
+}
+export interface WireToolUse extends WireBase {
+    type: 'tool_result';
+    requestId: string;
+    toolName: string;
+    input?: any;
+    output: string;
+    isError: boolean;
+    isPending?: boolean;
+}
+export interface WireToolRequest extends WireBase {
+    type: 'tool_request';
+    requestId: string;
+    toolName: string;
+    input: any;
+    description?: string;
+    responded: boolean;
+    response?: 'approved' | 'denied';
+}
+export interface WireQuestion extends WireBase {
+    type: 'question';
+    requestId: string;
+    questions: WireQuestionItem[];
+    responded: boolean;
+}
+export interface WireQuestionItem {
+    question: string;
+    header?: string;
+    options: {
+        label: string;
+        description?: string;
+    }[];
+    allowFreeInput?: boolean;
+    multiSelect?: boolean;
+}
+export interface WirePlanApproval extends WireBase {
+    type: 'plan_approval';
+    requestId: string;
+    plan: string;
+    responded: boolean;
+    response?: 'approved' | 'denied';
+}
+export interface WireStatusUpdate extends WireBase {
+    type: 'status_update';
+    status: 'initializing' | 'idle' | 'active' | 'waiting' | 'error' | 'exited';
+    mode?: string;
+    model?: string;
+}
+export interface WireContextUsage extends WireBase {
+    type: 'context_usage';
+    model: string;
+    usedTokens: number;
+    totalTokens: number;
+    percent: number;
+    freePercent: number;
+}
+export interface WireSystemMessage extends WireBase {
+    type: 'system_message';
+    text: string;
+    subtype?: string;
+}
+export interface WireResult extends WireBase {
+    type: 'result';
+    subtype?: string;
+    summary?: string;
+}
+export interface WireAttachment {
+    media_type: string;
+    data: string;
+    name?: string;
+    text?: string;
+}
+export type WireMessage = WireUserMessage | WireAssistantMessage | WireThinking | WireToolUse | WireToolRequest | WireQuestion | WirePlanApproval | WireStatusUpdate | WireContextUsage | WireSystemMessage | WireResult;
+/**
+ * Convert a SessionEvent to zero or more WireMessages for frontend display.
+ * This replaces mapIngressEvent() from claude-message-mapper.ts.
+ *
+ * @param uiSessionId - The UI-facing session ID (agent session ID)
+ * @param event - Raw SessionEvent
+ * @param pendingToolUses - Map tracking tool_use blocks for correlation
+ * @returns Array of WireMessages (may be empty for filtered events)
+ */
+export declare function toWireMessages(uiSessionId: string, event: SessionEvent, pendingToolUses: Map<string, {
+    name: string;
+    input: any;
+}>): WireMessage[];
+/**
+ * Try to parse /context output for token usage info.
+ * Returns a WireContextUsage message if found, null otherwise.
+ */
+export declare function tryParseContextUsageWire(sessionId: string, event: SessionEvent): WireContextUsage | null;

package/dist/src/events/wire.js

@@ -0,0 +1,296 @@
+/**
+ * WireMessage — slim projection of SessionEvent for frontend display.
+ * Replaces the AbstractMessage hierarchy and mapIngressEvent().
+ */
+import { v4 as uuidv4 } from 'uuid';
+// ═══════════════════════════════════════════════════════
+// Helpers
+// ═══════════════════════════════════════════════════════
+function hasAnsi(text) {
+    return /\x1b\[/.test(text);
+}
+function getEventText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content.map((b) => b.text || b.content || '').join('');
+    }
+    return '';
+}
+// ═══════════════════════════════════════════════════════
+// toWireMessages — SessionEvent → WireMessage[]
+// ═══════════════════════════════════════════════════════
+/**
+ * Convert a SessionEvent to zero or more WireMessages for frontend display.
+ * This replaces mapIngressEvent() from claude-message-mapper.ts.
+ *
+ * @param uiSessionId - The UI-facing session ID (agent session ID)
+ * @param event - Raw SessionEvent
+ * @param pendingToolUses - Map tracking tool_use blocks for correlation
+ * @returns Array of WireMessages (may be empty for filtered events)
+ */
+export function toWireMessages(uiSessionId, event, pendingToolUses) {
+    const messages = [];
+    const now = Date.now();
+    if (event.type === 'assistant') {
+        const msg = event.message;
+        // Skip synthetic messages
+        if (msg.model === '<synthetic>')
+            return messages;
+        if (Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+                if (block.type === 'thinking' && 'thinking' in block) {
+                    messages.push({
+                        id: uuidv4(),
+                        sessionId: uiSessionId,
+                        timestamp: now,
+                        type: 'thinking',
+                        text: block.thinking,
+                    });
+                }
+                else if (block.type === 'text') {
+                    if (hasAnsi(block.text))
+                        continue;
+                    messages.push({
+                        id: uuidv4(),
+                        sessionId: uiSessionId,
+                        timestamp: now,
+                        type: 'assistant_message',
+                        text: block.text,
+                    });
+                }
+                else if (block.type === 'tool_use' && 'id' in block && 'name' in block) {
+                    pendingToolUses.set(block.id, {
+                        name: block.name,
+                        input: block.input || {},
+                    });
+                    messages.push({
+                        id: block.id,
+                        sessionId: uiSessionId,
+                        timestamp: now,
+                        type: 'tool_result',
+                        requestId: block.id,
+                        toolName: block.name,
+                        input: block.input || {},
+                        output: '',
+                        isError: false,
+                        isPending: true,
+                    });
+                }
+            }
+        }
+        else if (typeof msg.content === 'string') {
+            if (!hasAnsi(msg.content)) {
+                messages.push({
+                    id: uuidv4(),
+                    sessionId: uiSessionId,
+                    timestamp: now,
+                    type: 'assistant_message',
+                    text: msg.content,
+                });
+            }
+        }
+    }
+    else if (event.type === 'control_request') {
+        const cr = event;
+        if (cr.request?.subtype === 'initialize')
+            return messages;
+        const toolUse = cr.request?.tool_use;
+        const toolName = toolUse?.name || cr.request?.tool_name || '';
+        const toolInput = toolUse?.input || cr.request?.input || {};
+        const controlRequestId = cr.request_id || cr.uuid || uuidv4();
+        if (toolName === 'AskUserQuestion') {
+            const rawQuestions = toolInput.questions || [];
+            const typedQuestions = rawQuestions.map((q) => ({
+                question: q.question || '',
+                header: q.header,
+                options: Array.isArray(q.options)
+                    ? q.options.map((o) => ({ label: o.label || '', description: o.description }))
+                    : [],
+                allowFreeInput: true,
+                multiSelect: !!q.multiSelect,
+            }));
+            messages.push({
+                id: cr.uuid || controlRequestId,
+                sessionId: uiSessionId,
+                timestamp: now,
+                type: 'question',
+                requestId: controlRequestId,
+                questions: typedQuestions,
+                responded: false,
+            });
+        }
+        else if (toolName === 'ExitPlanMode') {
+            messages.push({
+                id: cr.uuid || controlRequestId,
+                sessionId: uiSessionId,
+                timestamp: now,
+                type: 'plan_approval',
+                requestId: controlRequestId,
+                plan: toolInput.plan || '',
+                responded: false,
+            });
+        }
+        else {
+            const name = toolName || cr.request?.subtype || 'unknown';
+            const input = Object.keys(toolInput).length > 0 ? toolInput : (cr.request || {});
+            let description;
+            if (name === 'Bash' && input.command) {
+                description = input.command.substring(0, 200);
+            }
+            else if ((name === 'Edit' || name === 'Write') && input.file_path) {
+                description = input.file_path;
+            }
+            else if (name === 'Read' && input.file_path) {
+                description = input.file_path;
+            }
+            messages.push({
+                id: controlRequestId,
+                sessionId: uiSessionId,
+                timestamp: now,
+                type: 'tool_request',
+                requestId: controlRequestId,
+                toolName: name,
+                input,
+                description,
+                responded: false,
+            });
+        }
+    }
+    else if (event.type === 'user') {
+        const ue = event;
+        if (ue.isSynthetic)
+            return messages;
+        const content = ue.message.content;
+        // Handle tool_result blocks
+        if (Array.isArray(content)) {
+            const allToolResults = content.every((b) => b.type === 'tool_result');
+            if (allToolResults) {
+                for (const block of content) {
+                    if (block.type === 'tool_result' && 'tool_use_id' in block) {
+                        const toolUse = pendingToolUses.get(block.tool_use_id);
+                        const toolName = toolUse?.name || 'unknown';
+                        const output = typeof block.content === 'string'
+                            ? block.content
+                            : Array.isArray(block.content)
+                                ? block.content.map((b) => b.text || '').join('')
+                                : JSON.stringify(block.content || '');
+                        messages.push({
+                            id: uuidv4(),
+                            sessionId: uiSessionId,
+                            timestamp: now,
+                            type: 'tool_result',
+                            requestId: block.tool_use_id,
+                            toolName,
+                            input: toolUse?.input,
+                            output: output.substring(0, 5000),
+                            isError: !!block.is_error,
+                        });
+                        pendingToolUses.delete(block.tool_use_id);
+                    }
+                }
+                return messages;
+            }
+        }
+        // Regular user message
+        const text = getEventText(content);
+        if (text.startsWith('/') || hasAnsi(text))
+            return messages;
+        if (/<command-name>|<local-command-caveat>|<command-message>/.test(text))
+            return messages;
+        const displayContent = typeof content === 'string' ? content : text;
+        if (displayContent) {
+            messages.push({
+                id: event.uuid || uuidv4(),
+                sessionId: uiSessionId,
+                timestamp: now,
+                type: 'user_message',
+                text: displayContent,
+            });
+        }
+    }
+    else if (event.type === 'result') {
+        const re = event;
+        messages.push({
+            id: re.uuid || uuidv4(),
+            sessionId: uiSessionId,
+            timestamp: now,
+            type: 'result',
+            subtype: re.subtype,
+            summary: re.result,
+        });
+    }
+    else if (event.type === 'system' && event.subtype === 'init') {
+        const se = event;
+        messages.push({
+            id: se.uuid || uuidv4(),
+            sessionId: uiSessionId,
+            timestamp: now,
+            type: 'status_update',
+            status: 'idle',
+            model: se.model,
+            mode: se.permissionMode,
+        });
+    }
+    else if (event.type === 'system' && event.subtype === 'status') {
+        const se = event;
+        if (se.permissionMode) {
+            messages.push({
+                id: se.uuid || uuidv4(),
+                sessionId: uiSessionId,
+                timestamp: now,
+                type: 'status_update',
+                status: 'idle',
+                mode: se.permissionMode,
+            });
+        }
+    }
+    // Skip: progress, file-history-snapshot, last-prompt, queue-operation, control_response
+    // Tag all produced messages with the source event UUID
+    const eventUuid = event.uuid;
+    if (eventUuid) {
+        for (const msg of messages) {
+            msg.rawEventUuid = eventUuid;
+        }
+    }
+    return messages;
+}
+/**
+ * Try to parse /context output for token usage info.
+ * Returns a WireContextUsage message if found, null otherwise.
+ */
+export function tryParseContextUsageWire(sessionId, event) {
+    if (event.type !== 'user' && event.type !== 'system')
+        return null;
+    let text = '';
+    const content = event.message?.content;
+    if (typeof content === 'string') {
+        text = content;
+    }
+    else if (Array.isArray(content)) {
+        text = content.map((b) => b.text || (typeof b.content === 'string' ? b.content : '') || '').join('');
+    }
+    if (!text || !hasAnsi(text))
+        return null;
+    const clean = text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+    const tokenMatch = clean.match(/([\w.-]+)\s*[·•]\s*([\d.]+)k?\/([\d.]+)k?\s*tokens?\s*\((\d+)%\)/);
+    if (!tokenMatch)
+        return null;
+    const model = tokenMatch[1];
+    const usedTokens = Math.round(parseFloat(tokenMatch[2]) * 1000);
+    const totalTokens = Math.round(parseFloat(tokenMatch[3]) * 1000);
+    const usedPercent = parseInt(tokenMatch[4], 10);
+    const freeMatch = clean.match(/Free\s+space:\s*([\d.]+)k?\s*\(([\d.]+)%\)/);
+    const freePercent = freeMatch ? parseFloat(freeMatch[2]) : (100 - usedPercent);
+    return {
+        id: uuidv4(),
+        sessionId,
+        timestamp: Date.now(),
+        type: 'context_usage',
+        model,
+        usedTokens,
+        totalTokens,
+        percent: usedPercent,
+        freePercent,
+    };
+}

package/dist/src/fs-monitor-types.d.ts

@@ -0,0 +1,24 @@
+export type ChangeOperation = 'create' | 'modify' | 'delete' | 'rename';
+export interface FileChange {
+    changeId: string;
+    sessionId: string;
+    timestamp: number;
+    pid: number;
+    operation: ChangeOperation;
+    path: string;
+    oldPath?: string;
+    beforeHash: string | null;
+    afterHash: string | null;
+    fileSize: number;
+    isBinary: boolean;
+}
+/** JSON line event from the LD_PRELOAD shared library */
+export interface PreloadEvent {
+    session_id: string;
+    op: 'write' | 'rename' | 'delete' | 'truncate';
+    path: string;
+    old_path?: string;
+    snapshot?: string;
+    file_existed: boolean;
+    ts: number;
+}

package/dist/src/fs-monitor-types.js

@@ -0,0 +1 @@
+export {};