@supaku/agentfactory 0.1.0

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

@@ -0,0 +1,469 @@
+/**
+ * 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)
+ */
+const DEFAULT_MIN_INTERVAL = 500;
+const DEFAULT_MAX_OUTPUT_LENGTH = 2000;
+/**
+ * API Activity Emitter
+ *
+ * Handles rate-limited emission of Claude events to Linear via API proxy.
+ */
+export class ApiActivityEmitter {
+    sessionId;
+    workerId; // Mutable to allow update after worker re-registration
+    apiBaseUrl;
+    apiKey;
+    minInterval;
+    maxOutputLength;
+    includeTimestamps;
+    onActivityEmitted;
+    onActivityThrottled;
+    onActivityError;
+    onProgressPosted;
+    lastEmitTime = 0;
+    queue = [];
+    flushTimer = null;
+    isProcessing = false;
+    // Track reported tool error signatures for deduplication
+    reportedToolErrors = new Set();
+    constructor(config) {
+        this.sessionId = config.sessionId;
+        this.workerId = config.workerId;
+        this.apiBaseUrl = config.apiBaseUrl.replace(/\/$/, ''); // Remove trailing slash
+        this.apiKey = config.apiKey;
+        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;
+        this.onActivityError = config.onActivityError;
+        this.onProgressPosted = config.onProgressPosted;
+    }
+    /**
+     * 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) {
+        this.workerId = newWorkerId;
+    }
+    /**
+     * Get the current worker ID
+     */
+    getWorkerId() {
+        return this.workerId;
+    }
+    /**
+     * 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,
+        });
+    }
+    /**
+     * 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
+     */
+    async postProgress(milestone, message) {
+        try {
+            const response = await fetch(`${this.apiBaseUrl}/api/sessions/${this.sessionId}/progress`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify({
+                    workerId: this.workerId,
+                    milestone,
+                    message,
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`API error ${response.status}: ${errorText}`);
+            }
+            const result = (await response.json());
+            if (result.posted) {
+                this.onProgressPosted?.(milestone, message);
+            }
+            else {
+                console.warn(`Progress not posted: ${result.reason ?? 'unknown'}`);
+            }
+            return result.posted;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            console.error(`Failed to post progress (${milestone}):`, err);
+            this.onActivityError?.('progress', err);
+            return false;
+        }
+    }
+    /**
+     * 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
+     */
+    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 {
+            const response = await fetch(`${this.apiBaseUrl}/api/sessions/${this.sessionId}/tool-error`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify({
+                    workerId: this.workerId,
+                    toolName,
+                    errorMessage,
+                    context,
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`API error ${response.status}: ${errorText}`);
+            }
+            const result = (await response.json());
+            if (result.created && result.issue) {
+                return result.issue;
+            }
+            return null;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            console.error('[ApiActivityEmitter] Failed to report tool error:', err);
+            this.onActivityError?.('tool-error', err);
+            return null;
+        }
+    }
+    /**
+     * Get Claude stream handlers that emit to Linear via API
+     */
+    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,
+                });
+            },
+            // Note: Todo/plan updates are not supported via API emitter
+            // Plans would need a separate API endpoint
+            onTodo: async (_newTodos) => {
+                // No-op - plan updates not supported via API yet
+            },
+        };
+    }
+    /**
+     * 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 via API
+     */
+    async emitActivity(activity) {
+        try {
+            const content = this.includeTimestamps
+                ? `[${new Date().toISOString()}] ${activity.content}`
+                : activity.content;
+            const response = await fetch(`${this.apiBaseUrl}/api/sessions/${this.sessionId}/activity`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify({
+                    workerId: this.workerId,
+                    activity: {
+                        type: activity.type,
+                        content,
+                        toolName: activity.toolName,
+                        toolInput: activity.toolInput,
+                    },
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`API error ${response.status}: ${errorText}`);
+            }
+            const result = (await response.json());
+            if (!result.forwarded) {
+                console.warn(`Activity not forwarded: ${result.reason ?? 'unknown'}`);
+            }
+            this.onActivityEmitted?.(activity.type, content);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            console.error(`Failed to emit ${activity.type} activity via API:`, err);
+            this.onActivityError?.(activity.type, err);
+        }
+    }
+    /**
+     * 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 API activity emitter instance
+ */
+export function createApiActivityEmitter(config) {
+    return new ApiActivityEmitter(config);
+}

package/dist/src/orchestrator/heartbeat-writer.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Heartbeat Writer
+ *
+ * Periodically writes heartbeat state to the .agent/ directory.
+ * Uses atomic writes (temp file + rename) to prevent corruption.
+ */
+import type { HeartbeatActivityType, HeartbeatWriterConfig } from './state-types';
+/**
+ * HeartbeatWriter periodically writes heartbeat state to enable crash detection
+ */
+export declare class HeartbeatWriter {
+    private readonly config;
+    private readonly heartbeatPath;
+    private intervalHandle;
+    private lastActivityType;
+    private lastActivityTimestamp;
+    private toolCallsCount;
+    private currentOperation;
+    private stopped;
+    constructor(config: HeartbeatWriterConfig);
+    /**
+     * Start the heartbeat writer
+     * Immediately writes the first heartbeat, then starts the interval
+     */
+    start(): void;
+    /**
+     * Stop the heartbeat writer
+     * Should be called when the agent exits
+     */
+    stop(): void;
+    /**
+     * Update the last activity type
+     * Call this when the agent does something
+     */
+    updateActivity(type: HeartbeatActivityType, operation?: string): void;
+    /**
+     * Record a tool call
+     */
+    recordToolCall(toolName: string): void;
+    /**
+     * Record thinking activity
+     */
+    recordThinking(): void;
+    /**
+     * Write the heartbeat file atomically
+     */
+    private writeHeartbeat;
+}
+/**
+ * Create a heartbeat writer for an agent
+ */
+export declare function createHeartbeatWriter(config: HeartbeatWriterConfig): HeartbeatWriter;
+/**
+ * Parse environment variable for heartbeat interval
+ */
+export declare function getHeartbeatIntervalFromEnv(): number;
+//# sourceMappingURL=heartbeat-writer.d.ts.map

package/dist/src/orchestrator/heartbeat-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeat-writer.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/heartbeat-writer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAEV,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,eAAe,CAAA;AAKtB;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;IACxD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAQ;IACtC,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,gBAAgB,CAAgC;IACxD,OAAO,CAAC,qBAAqB,CAAQ;IACrC,OAAO,CAAC,cAAc,CAAI;IAC1B,OAAO,CAAC,gBAAgB,CAAsB;IAC9C,OAAO,CAAC,OAAO,CAAQ;gBAEX,MAAM,EAAE,qBAAqB;IASzC;;;OAGG;IACH,KAAK,IAAI,IAAI;IA2Bb;;;OAGG;IACH,IAAI,IAAI,IAAI;IAQZ;;;OAGG;IACH,cAAc,CAAC,IAAI,EAAE,qBAAqB,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IASrE;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAItC;;OAEG;IACH,cAAc,IAAI,IAAI;IAItB;;OAEG;IACH,OAAO,CAAC,cAAc;CAyBvB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,GAAG,eAAe,CAEpF;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,CASpD"}

package/dist/src/orchestrator/heartbeat-writer.js

@@ -0,0 +1,137 @@
+/**
+ * Heartbeat Writer
+ *
+ * Periodically writes heartbeat state to the .agent/ directory.
+ * Uses atomic writes (temp file + rename) to prevent corruption.
+ */
+import { writeFileSync, renameSync, existsSync, mkdirSync } from 'fs';
+import { resolve, dirname } from 'path';
+// Default heartbeat interval: 10 seconds
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 10000;
+/**
+ * HeartbeatWriter periodically writes heartbeat state to enable crash detection
+ */
+export class HeartbeatWriter {
+    config;
+    heartbeatPath;
+    intervalHandle = null;
+    lastActivityType = 'idle';
+    lastActivityTimestamp;
+    toolCallsCount = 0;
+    currentOperation = null;
+    stopped = false;
+    constructor(config) {
+        this.config = {
+            ...config,
+            intervalMs: config.intervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS,
+        };
+        this.heartbeatPath = resolve(this.config.agentDir, 'heartbeat.json');
+        this.lastActivityTimestamp = Date.now();
+    }
+    /**
+     * Start the heartbeat writer
+     * Immediately writes the first heartbeat, then starts the interval
+     */
+    start() {
+        if (this.stopped) {
+            throw new Error('HeartbeatWriter has been stopped and cannot be restarted');
+        }
+        if (this.intervalHandle) {
+            return; // Already running
+        }
+        // Ensure the directory exists
+        const dir = dirname(this.heartbeatPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        // Write initial heartbeat
+        this.writeHeartbeat();
+        // Start interval
+        this.intervalHandle = setInterval(() => {
+            this.writeHeartbeat();
+        }, this.config.intervalMs);
+        // Don't prevent the process from exiting
+        this.intervalHandle.unref();
+    }
+    /**
+     * Stop the heartbeat writer
+     * Should be called when the agent exits
+     */
+    stop() {
+        this.stopped = true;
+        if (this.intervalHandle) {
+            clearInterval(this.intervalHandle);
+            this.intervalHandle = null;
+        }
+    }
+    /**
+     * Update the last activity type
+     * Call this when the agent does something
+     */
+    updateActivity(type, operation) {
+        this.lastActivityType = type;
+        this.lastActivityTimestamp = Date.now();
+        this.currentOperation = operation ?? null;
+        if (type === 'tool_use') {
+            this.toolCallsCount++;
+        }
+    }
+    /**
+     * Record a tool call
+     */
+    recordToolCall(toolName) {
+        this.updateActivity('tool_use', toolName);
+    }
+    /**
+     * Record thinking activity
+     */
+    recordThinking() {
+        this.updateActivity('thinking');
+    }
+    /**
+     * Write the heartbeat file atomically
+     */
+    writeHeartbeat() {
+        const memoryUsage = process.memoryUsage();
+        const now = Date.now();
+        const state = {
+            timestamp: now,
+            pid: this.config.pid,
+            memoryUsageMB: Math.round(memoryUsage.heapUsed / 1024 / 1024),
+            uptime: Math.floor((now - this.config.startTime) / 1000),
+            lastActivityType: this.lastActivityType,
+            lastActivityTimestamp: this.lastActivityTimestamp,
+            toolCallsCount: this.toolCallsCount,
+            currentOperation: this.currentOperation,
+        };
+        // Write atomically: temp file then rename
+        const tempPath = `${this.heartbeatPath}.tmp`;
+        try {
+            writeFileSync(tempPath, JSON.stringify(state, null, 2));
+            renameSync(tempPath, this.heartbeatPath);
+        }
+        catch (error) {
+            // Silently ignore write errors - heartbeat is best-effort
+            // The file might be locked or the directory might have been removed
+        }
+    }
+}
+/**
+ * Create a heartbeat writer for an agent
+ */
+export function createHeartbeatWriter(config) {
+    return new HeartbeatWriter(config);
+}
+/**
+ * Parse environment variable for heartbeat interval
+ */
+export function getHeartbeatIntervalFromEnv() {
+    const envValue = process.env.AGENT_HEARTBEAT_INTERVAL_MS;
+    if (envValue) {
+        const parsed = parseInt(envValue, 10);
+        if (!isNaN(parsed) && parsed > 0) {
+            return parsed;
+        }
+    }
+    return DEFAULT_HEARTBEAT_INTERVAL_MS;
+}

package/dist/src/orchestrator/index.d.ts

@@ -0,0 +1,20 @@
+export type { OrchestratorConfig, OrchestratorIssue, AgentProcess, OrchestratorEvents, SpawnAgentOptions, OrchestratorResult, OrchestratorStreamConfig, StopAgentResult, ForwardPromptResult, InjectMessageResult, SpawnAgentWithResumeOptions, WorkTypeTimeoutConfig, AgentWorkResult, } from './types';
+export type { ClaudeStreamEvent, ClaudeInitEvent, ClaudeSystemEvent, ClaudeAssistantEvent, ClaudeToolUseEvent, ClaudeToolResultEvent, ClaudeResultEvent, ClaudeErrorEvent, ClaudeTodoItem, ClaudeUserEvent, ClaudeEvent, ClaudeStreamHandlers, } from './stream-parser';
+export type { ActivityEmitterConfig } from './activity-emitter';
+export type { ApiActivityEmitterConfig, ProgressMilestone } from './api-activity-emitter';
+export type { WorktreeState, WorktreeStatus, HeartbeatState, HeartbeatActivityType, TodosState, TodoItem, TodoStatus, ProgressLogEntry, ProgressEventType, RecoveryCheckResult, HeartbeatWriterConfig, ProgressLoggerConfig, } from './state-types';
+export type { LogAnalysisConfig } from './log-config';
+export type { SessionEventType, SessionEvent, SessionMetadata, SessionLoggerConfig, } from './session-logger';
+export type { PatternType, PatternSeverity, AnalyzedPattern, AnalysisResult, SuggestedIssue, TrackedIssue, DeduplicationStore, } from './log-analyzer';
+export { AgentOrchestrator, createOrchestrator, getWorktreeIdentifier } from './orchestrator';
+export { ClaudeStreamParser, createStreamParser } from './stream-parser';
+export { ActivityEmitter, createActivityEmitter } from './activity-emitter';
+export { ApiActivityEmitter, createApiActivityEmitter } from './api-activity-emitter';
+export { HeartbeatWriter, createHeartbeatWriter, getHeartbeatIntervalFromEnv, } from './heartbeat-writer';
+export { ProgressLogger, createProgressLogger } from './progress-logger';
+export { getAgentDir, getStatePath, getHeartbeatPath, getTodosPath, isHeartbeatFresh, readWorktreeState, readHeartbeat, readTodos, checkRecovery, initializeAgentDir, writeState, updateState, writeTodos, createInitialState, buildRecoveryPrompt, getHeartbeatTimeoutFromEnv, getMaxRecoveryAttemptsFromEnv, getTaskListId, } from './state-recovery';
+export { getLogAnalysisConfig, isSessionLoggingEnabled, isAutoAnalyzeEnabled, } from './log-config';
+export { SessionLogger, createSessionLogger, readSessionMetadata, readSessionEvents, } from './session-logger';
+export { parseWorkResult } from './parse-work-result';
+export { LogAnalyzer, createLogAnalyzer } from './log-analyzer';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/orchestrator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,kBAAkB,EAClB,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,wBAAwB,EACxB,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,2BAA2B,EAC3B,qBAAqB,EACrB,eAAe,GAChB,MAAM,SAAS,CAAA;AAGhB,YAAY,EACV,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,kBAAkB,EAClB,qBAAqB,EACrB,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,WAAW,EACX,oBAAoB,GACrB,MAAM,iBAAiB,CAAA;AAGxB,YAAY,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAG/D,YAAY,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAGzF,YAAY,EACV,aAAa,EACb,cAAc,EACd,cAAc,EACd,qBAAqB,EACrB,UAAU,EACV,QAAQ,EACR,UAAU,EACV,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,eAAe,CAAA;AAGtB,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAGrD,YAAY,EACV,gBAAgB,EAChB,YAAY,EACZ,eAAe,EACf,mBAAmB,GACpB,MAAM,kBAAkB,CAAA;AAGzB,YAAY,EACV,WAAW,EACX,eAAe,EACf,eAAe,EACf,cAAc,EACd,cAAc,EACd,YAAY,EACZ,kBAAkB,GACnB,MAAM,gBAAgB,CAAA;AAGvB,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAG7F,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAGxE,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAG3E,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAA;AAGrF,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,2BAA2B,GAC5B,MAAM,oBAAoB,CAAA;AAG3B,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AAGxE,OAAO,EACL,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,SAAS,EACT,aAAa,EACb,kBAAkB,EAClB,UAAU,EACV,WAAW,EACX,UAAU,EACV,kBAAkB,EAClB,mBAAmB,EACnB,0BAA0B,EAC1B,6BAA6B,EAC7B,aAAa,GACd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,cAAc,CAAA;AAGrB,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAGrD,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA"}