@supaku/agentfactory 0.1.0

package/dist/src/orchestrator/activity-emitter.js

@@ -0,0 +1,406 @@
+/**
+ * Linear Activity Emitter
+ *
+ * Emits Claude stream events to Linear as agent activities.
+ * Handles rate limiting by batching rapid activities and
+ * truncating long outputs.
+ *
+ * Mapping:
+ * - assistant message → response (persisted, user-directed communication)
+ * - tool_use → action (ephemeral)
+ * - tool_result → action (ephemeral)
+ * - result → response (persisted)
+ * - error → error (persisted)
+ */
+import { ENVIRONMENT_ISSUE_TYPES } from '@supaku/agentfactory-linear';
+const DEFAULT_MIN_INTERVAL = 500;
+const DEFAULT_MAX_OUTPUT_LENGTH = 2000;
+/**
+ * Map Claude todo status to Linear plan item state
+ */
+function mapTodoStatusToLinearState(status) {
+    switch (status) {
+        case 'pending':
+            return 'pending';
+        case 'in_progress':
+            return 'inProgress';
+        case 'completed':
+            return 'completed';
+        default:
+            return 'pending';
+    }
+}
+/**
+ * Activity Emitter
+ *
+ * Handles rate-limited emission of Claude events to Linear activities.
+ */
+export class ActivityEmitter {
+    session;
+    minInterval;
+    maxOutputLength;
+    includeTimestamps;
+    onActivityEmitted;
+    onActivityThrottled;
+    lastEmitTime = 0;
+    queue = [];
+    flushTimer = null;
+    isProcessing = false;
+    // Track reported tool error signatures for deduplication
+    reportedToolErrors = new Set();
+    constructor(config) {
+        this.session = config.session;
+        this.minInterval = config.minInterval ?? DEFAULT_MIN_INTERVAL;
+        this.maxOutputLength = config.maxOutputLength ?? DEFAULT_MAX_OUTPUT_LENGTH;
+        this.includeTimestamps = config.includeTimestamps ?? false;
+        this.onActivityEmitted = config.onActivityEmitted;
+        this.onActivityThrottled = config.onActivityThrottled;
+    }
+    /**
+     * Emit a thought activity (persistent by default for visibility in Linear)
+     */
+    async emitThought(content, ephemeral = false) {
+        await this.queueActivity({
+            type: 'thought',
+            content,
+            ephemeral,
+        });
+    }
+    /**
+     * Emit a tool use activity (ephemeral by default)
+     */
+    async emitToolUse(tool, input, ephemeral = true) {
+        const inputSummary = this.summarizeToolInput(tool, input);
+        await this.queueActivity({
+            type: 'action',
+            content: `${tool}: ${inputSummary}`,
+            ephemeral,
+            toolName: tool,
+            toolInput: input,
+        });
+    }
+    /**
+     * Emit a response activity (persisted)
+     */
+    async emitResponse(content) {
+        await this.queueActivity({
+            type: 'response',
+            content,
+            ephemeral: false,
+        });
+    }
+    /**
+     * Emit an error activity (persisted)
+     */
+    async emitError(error) {
+        const message = error instanceof Error ? error.message : error;
+        await this.queueActivity({
+            type: 'error',
+            content: message,
+            ephemeral: false,
+        });
+    }
+    /**
+     * Report a tool error as a Linear issue for tracking and improvement.
+     * Creates a bug in the Agent project backlog.
+     *
+     * @param toolName - Name of the tool that errored
+     * @param errorMessage - The error message
+     * @param context - Additional context about the error
+     * @returns The created issue, or null if creation failed or was deduplicated
+     */
+    async reportToolError(toolName, errorMessage, context) {
+        // Deduplicate using tool name + first 100 chars of error
+        const signature = `${toolName}:${errorMessage.substring(0, 100)}`;
+        if (this.reportedToolErrors.has(signature)) {
+            return null;
+        }
+        this.reportedToolErrors.add(signature);
+        try {
+            return await this.session.reportEnvironmentIssue(`Tool error: ${toolName}`, `The agent encountered an error while using the **${toolName}** tool.\n\n**Error:**\n\`\`\`\n${errorMessage}\n\`\`\``, {
+                issueType: ENVIRONMENT_ISSUE_TYPES.TOOL,
+                sourceIssueId: context?.issueIdentifier,
+                additionalContext: {
+                    toolName,
+                    ...context?.additionalContext,
+                },
+            });
+        }
+        catch (error) {
+            console.error('[ActivityEmitter] Failed to report tool error:', error);
+            return null;
+        }
+    }
+    /**
+     * Get Claude stream handlers that emit to Linear
+     */
+    getStreamHandlers() {
+        return {
+            onAssistant: async (event) => {
+                // Skip partial messages (streaming updates)
+                if (event.partial)
+                    return;
+                // Assistant messages are user-directed communication, emit as response (persisted)
+                await this.queueActivity({
+                    type: 'response',
+                    content: event.message,
+                    ephemeral: false,
+                });
+            },
+            onToolUse: async (event) => {
+                const inputSummary = this.summarizeToolInput(event.tool, event.input);
+                await this.queueActivity({
+                    type: 'action',
+                    content: `${event.tool}: ${inputSummary}`,
+                    ephemeral: true,
+                    toolName: event.tool,
+                    toolInput: event.input,
+                });
+            },
+            onToolResult: async (event) => {
+                const output = this.truncateOutput(event.output);
+                const prefix = event.is_error ? 'Error' : 'Result';
+                await this.queueActivity({
+                    type: 'action',
+                    content: `${event.tool} ${prefix}: ${output}`,
+                    ephemeral: true,
+                    toolName: event.tool,
+                    toolOutput: output,
+                });
+            },
+            onResult: async (event) => {
+                // Final result - persisted as response
+                const content = this.formatResultContent(event);
+                await this.queueActivity({
+                    type: 'response',
+                    content,
+                    ephemeral: false,
+                });
+            },
+            onError: async (event) => {
+                // Errors are persisted
+                await this.queueActivity({
+                    type: 'error',
+                    content: event.error.message,
+                    ephemeral: false,
+                });
+            },
+            onTodo: async (newTodos) => {
+                // Map Claude todos to Linear plan items
+                const planItems = newTodos.map((todo) => ({
+                    title: todo.content,
+                    state: mapTodoStatusToLinearState(todo.status),
+                    details: todo.activeForm,
+                }));
+                // Update the plan via session
+                try {
+                    await this.session.updatePlan(planItems);
+                }
+                catch (error) {
+                    console.error('Failed to update plan:', error);
+                }
+            },
+        };
+    }
+    /**
+     * Queue an activity for emission with rate limiting
+     */
+    async queueActivity(activity) {
+        this.queue.push(activity);
+        // Schedule flush if not already scheduled
+        if (!this.flushTimer && !this.isProcessing) {
+            const timeSinceLastEmit = Date.now() - this.lastEmitTime;
+            const delay = Math.max(0, this.minInterval - timeSinceLastEmit);
+            this.flushTimer = setTimeout(() => {
+                this.flushTimer = null;
+                this.processQueue();
+            }, delay);
+        }
+    }
+    /**
+     * Process queued activities
+     */
+    async processQueue() {
+        if (this.isProcessing || this.queue.length === 0)
+            return;
+        this.isProcessing = true;
+        try {
+            // Merge similar consecutive activities to reduce API calls
+            const merged = this.mergeQueuedActivities();
+            for (const activity of merged) {
+                await this.emitActivity(activity);
+                this.lastEmitTime = Date.now();
+                // Small delay between emissions to avoid rate limits
+                if (merged.length > 1) {
+                    await this.delay(100);
+                }
+            }
+        }
+        finally {
+            this.isProcessing = false;
+            // If more activities were queued during processing, schedule another flush
+            if (this.queue.length > 0 && !this.flushTimer) {
+                this.flushTimer = setTimeout(() => {
+                    this.flushTimer = null;
+                    this.processQueue();
+                }, this.minInterval);
+            }
+        }
+    }
+    /**
+     * Merge consecutive similar activities in the queue
+     */
+    mergeQueuedActivities() {
+        const activities = [...this.queue];
+        this.queue = [];
+        if (activities.length <= 1)
+            return activities;
+        const merged = [];
+        let current = activities[0];
+        for (let i = 1; i < activities.length; i++) {
+            const next = activities[i];
+            // Merge consecutive thoughts
+            if (current.type === 'thought' &&
+                next.type === 'thought' &&
+                current.ephemeral === next.ephemeral) {
+                current = {
+                    ...current,
+                    content: `${current.content}\n\n${next.content}`,
+                };
+                this.onActivityThrottled?.('thought', next.content);
+                continue;
+            }
+            // Merge consecutive tool results for same tool
+            if (current.type === 'action' &&
+                next.type === 'action' &&
+                current.toolName === next.toolName &&
+                current.ephemeral === next.ephemeral) {
+                current = {
+                    ...current,
+                    content: `${current.content}\n${next.content}`,
+                };
+                this.onActivityThrottled?.('action', next.content);
+                continue;
+            }
+            merged.push(current);
+            current = next;
+        }
+        merged.push(current);
+        return merged;
+    }
+    /**
+     * Emit a single activity to Linear
+     */
+    async emitActivity(activity) {
+        try {
+            const content = this.includeTimestamps
+                ? `[${new Date().toISOString()}] ${activity.content}`
+                : activity.content;
+            switch (activity.type) {
+                case 'thought':
+                    await this.session.emitThought(content, activity.ephemeral);
+                    break;
+                case 'action':
+                    if (activity.toolName && activity.toolInput) {
+                        await this.session.emitAction(activity.toolName, activity.toolInput, activity.ephemeral);
+                    }
+                    else if (activity.toolName && activity.toolOutput) {
+                        await this.session.emitToolResult(activity.toolName, activity.toolOutput, activity.ephemeral);
+                    }
+                    else {
+                        // Generic action - emit as thought
+                        await this.session.emitThought(content, activity.ephemeral);
+                    }
+                    break;
+                case 'response':
+                    await this.session.emitResponse(content);
+                    break;
+                case 'error':
+                    await this.session.emitError(new Error(content));
+                    break;
+            }
+            this.onActivityEmitted?.(activity.type, content);
+        }
+        catch (error) {
+            console.error(`Failed to emit ${activity.type} activity:`, error);
+        }
+    }
+    /**
+     * Summarize tool input for display
+     */
+    summarizeToolInput(tool, input) {
+        // Tool-specific summaries
+        switch (tool) {
+            case 'Read':
+                return String(input.file_path || input.path || 'file');
+            case 'Write':
+                return String(input.file_path || input.path || 'file');
+            case 'Edit':
+                return String(input.file_path || input.path || 'file');
+            case 'Grep':
+                return `"${input.pattern}" in ${input.path || '.'}`;
+            case 'Glob':
+                return String(input.pattern || '*');
+            case 'Bash':
+                const cmd = String(input.command || '');
+                return cmd.length > 50 ? cmd.substring(0, 47) + '...' : cmd;
+            case 'Task':
+                return String(input.description || input.prompt || 'task');
+            default:
+                // Generic: show first string value or truncated JSON
+                const firstStringValue = Object.values(input).find((v) => typeof v === 'string');
+                if (firstStringValue) {
+                    return firstStringValue.length > 50
+                        ? firstStringValue.substring(0, 47) + '...'
+                        : firstStringValue;
+                }
+                const json = JSON.stringify(input);
+                return json.length > 50 ? json.substring(0, 47) + '...' : json;
+        }
+    }
+    /**
+     * Truncate long output strings
+     */
+    truncateOutput(output) {
+        if (output.length <= this.maxOutputLength)
+            return output;
+        return (output.substring(0, this.maxOutputLength) +
+            `\n\n... (truncated ${output.length - this.maxOutputLength} chars)`);
+    }
+    /**
+     * Format the final result content
+     */
+    formatResultContent(event) {
+        let content = event.result;
+        if (event.cost) {
+            content += `\n\n---\n*Tokens: ${event.cost.input_tokens} in / ${event.cost.output_tokens} out*`;
+        }
+        if (event.duration_ms) {
+            const seconds = (event.duration_ms / 1000).toFixed(1);
+            content += event.cost ? ` | *Duration: ${seconds}s*` : `\n\n---\n*Duration: ${seconds}s*`;
+        }
+        return content;
+    }
+    /**
+     * Flush all pending activities immediately
+     */
+    async flush() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        await this.processQueue();
+    }
+    /**
+     * Helper delay function
+     */
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+/**
+ * Create an activity emitter instance
+ */
+export function createActivityEmitter(config) {
+    return new ActivityEmitter(config);
+}

package/dist/src/orchestrator/api-activity-emitter.d.ts

@@ -0,0 +1,167 @@
+/**
+ * API-based Activity Emitter
+ *
+ * Emits Claude stream events to Linear via the agent app's API endpoint.
+ * This is used when the orchestrator runs remotely (as a worker) and needs
+ * to proxy activities through the Vercel app which has OAuth tokens.
+ *
+ * The agent app API endpoint (/api/sessions/[id]/activity) retrieves the
+ * OAuth token from Redis using the session's organizationId and forwards
+ * the activity to Linear's Agent API.
+ *
+ * Mapping:
+ * - assistant message → response (persisted, user-directed communication)
+ * - tool_use → action (ephemeral)
+ * - tool_result → action (ephemeral)
+ * - result → response (persisted)
+ * - error → error (persisted)
+ */
+import type { ClaudeStreamHandlers } from './stream-parser';
+/** Configuration for the API activity emitter */
+export interface ApiActivityEmitterConfig {
+    /** Linear session ID */
+    sessionId: string;
+    /** Worker ID for authentication */
+    workerId: string;
+    /** API base URL (e.g., https://agent.supaku.dev) */
+    apiBaseUrl: string;
+    /** API authentication key */
+    apiKey: string;
+    /** Minimum interval between activities in ms (default: 500ms) */
+    minInterval?: number;
+    /** Maximum length for tool outputs before truncation (default: 2000) */
+    maxOutputLength?: number;
+    /** Whether to include timestamps in activities (default: false) */
+    includeTimestamps?: boolean;
+    /** Optional callback when an activity is emitted */
+    onActivityEmitted?: (type: string, content: string) => void;
+    /** Optional callback when an activity is throttled */
+    onActivityThrottled?: (type: string, content: string) => void;
+    /** Optional callback when API call fails */
+    onActivityError?: (type: string, error: Error) => void;
+    /** Optional callback when a progress update is posted */
+    onProgressPosted?: (milestone: string, message: string) => void;
+}
+/** Progress milestone types */
+export type ProgressMilestone = 'claimed' | 'worktree' | 'started' | 'running' | 'tests' | 'pr' | 'completed' | 'failed' | 'stopped' | 'resumed';
+/**
+ * API Activity Emitter
+ *
+ * Handles rate-limited emission of Claude events to Linear via API proxy.
+ */
+export declare class ApiActivityEmitter {
+    private readonly sessionId;
+    private workerId;
+    private readonly apiBaseUrl;
+    private readonly apiKey;
+    private readonly minInterval;
+    private readonly maxOutputLength;
+    private readonly includeTimestamps;
+    private readonly onActivityEmitted?;
+    private readonly onActivityThrottled?;
+    private readonly onActivityError?;
+    private readonly onProgressPosted?;
+    private lastEmitTime;
+    private queue;
+    private flushTimer;
+    private isProcessing;
+    private readonly reportedToolErrors;
+    constructor(config: ApiActivityEmitterConfig);
+    /**
+     * Update the worker ID used for API requests.
+     * Called after worker re-registration to ensure activities are attributed
+     * to the new worker ID and pass ownership checks.
+     */
+    updateWorkerId(newWorkerId: string): void;
+    /**
+     * Get the current worker ID
+     */
+    getWorkerId(): string;
+    /**
+     * Emit a thought activity (persistent by default for visibility in Linear)
+     */
+    emitThought(content: string, ephemeral?: boolean): Promise<void>;
+    /**
+     * Emit a tool use activity (ephemeral by default)
+     */
+    emitToolUse(tool: string, input: Record<string, unknown>, ephemeral?: boolean): Promise<void>;
+    /**
+     * Emit a response activity (persisted)
+     */
+    emitResponse(content: string): Promise<void>;
+    /**
+     * Emit an error activity (persisted)
+     */
+    emitError(error: Error | string): Promise<void>;
+    /**
+     * Post a progress update comment to the Linear issue thread.
+     * Unlike activities which are ephemeral, progress updates are
+     * persisted as comments and visible in the issue thread.
+     *
+     * @param milestone - The type of progress milestone (e.g., 'started', 'completed')
+     * @param message - The progress message to post
+     */
+    postProgress(milestone: ProgressMilestone, message: string): Promise<boolean>;
+    /**
+     * Report a tool error as a Linear issue for tracking and improvement.
+     * Creates a bug in the Agent project backlog via API.
+     *
+     * @param toolName - Name of the tool that errored
+     * @param errorMessage - The error message
+     * @param context - Additional context about the error
+     * @returns The created issue, or null if creation failed or was deduplicated
+     */
+    reportToolError(toolName: string, errorMessage: string, context?: {
+        issueIdentifier?: string;
+        additionalContext?: Record<string, unknown>;
+    }): Promise<{
+        id: string;
+        identifier: string;
+        url: string;
+    } | null>;
+    /**
+     * Get Claude stream handlers that emit to Linear via API
+     */
+    getStreamHandlers(): ClaudeStreamHandlers;
+    /**
+     * Queue an activity for emission with rate limiting
+     */
+    private queueActivity;
+    /**
+     * Process queued activities
+     */
+    private processQueue;
+    /**
+     * Merge consecutive similar activities in the queue
+     */
+    private mergeQueuedActivities;
+    /**
+     * Emit a single activity to Linear via API
+     */
+    private emitActivity;
+    /**
+     * Summarize tool input for display
+     */
+    private summarizeToolInput;
+    /**
+     * Truncate long output strings
+     */
+    private truncateOutput;
+    /**
+     * Format the final result content
+     */
+    private formatResultContent;
+    /**
+     * Flush all pending activities immediately
+     */
+    flush(): Promise<void>;
+    /**
+     * Helper delay function
+     */
+    private delay;
+}
+/**
+ * Create an API activity emitter instance
+ */
+export declare function createApiActivityEmitter(config: ApiActivityEmitterConfig): ApiActivityEmitter;
+//# sourceMappingURL=api-activity-emitter.d.ts.map

package/dist/src/orchestrator/api-activity-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-activity-emitter.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/api-activity-emitter.ts"],"names":[],"mappings":"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"}