@supaku/agentfactory 0.1.0

package/dist/src/logger.js

@@ -0,0 +1,430 @@
+/**
+ * Logger utility for worker and orchestrator output
+ *
+ * Provides colorized, structured logging with worker/agent context.
+ * Uses ANSI escape codes directly to avoid external dependencies.
+ */
+// ANSI color codes
+const colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    // Foreground colors
+    black: '\x1b[30m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    // Bright foreground colors
+    brightBlack: '\x1b[90m',
+    brightRed: '\x1b[91m',
+    brightGreen: '\x1b[92m',
+    brightYellow: '\x1b[93m',
+    brightBlue: '\x1b[94m',
+    brightMagenta: '\x1b[95m',
+    brightCyan: '\x1b[96m',
+    brightWhite: '\x1b[97m',
+    // Background colors
+    bgBlack: '\x1b[40m',
+    bgRed: '\x1b[41m',
+    bgGreen: '\x1b[42m',
+    bgYellow: '\x1b[43m',
+    bgBlue: '\x1b[44m',
+    bgMagenta: '\x1b[45m',
+    bgCyan: '\x1b[46m',
+    bgWhite: '\x1b[47m',
+};
+// Color palette for worker/agent identification (easy to distinguish)
+const WORKER_COLORS = ['cyan', 'magenta', 'yellow', 'green', 'blue', 'brightCyan', 'brightMagenta', 'brightYellow'];
+// Activity type colors
+const ACTIVITY_COLORS = {
+    thought: 'brightBlack',
+    action: 'blue',
+    response: 'green',
+    tool_use: 'cyan',
+    tool_result: 'brightBlack',
+};
+// Log level styling
+const LEVEL_STYLES = {
+    debug: { color: 'brightBlack', label: 'DBG' },
+    info: { color: 'brightBlue', label: 'INF' },
+    success: { color: 'green', label: 'OK ' },
+    warn: { color: 'yellow', label: 'WRN' },
+    error: { color: 'red', label: 'ERR' },
+};
+const LOG_LEVEL_PRIORITY = {
+    debug: 0,
+    info: 1,
+    success: 2,
+    warn: 3,
+    error: 4,
+};
+// Map to track assigned colors for worker/agent IDs
+const colorAssignments = new Map();
+let colorIndex = 0;
+function getColorForId(id) {
+    if (!colorAssignments.has(id)) {
+        colorAssignments.set(id, WORKER_COLORS[colorIndex % WORKER_COLORS.length]);
+        colorIndex++;
+    }
+    return colorAssignments.get(id);
+}
+function colorize(text, ...colorNames) {
+    const colorCodes = colorNames.map((c) => colors[c]).join('');
+    return `${colorCodes}${text}${colors.reset}`;
+}
+function formatTimestamp() {
+    const now = new Date();
+    const hours = now.getHours().toString().padStart(2, '0');
+    const minutes = now.getMinutes().toString().padStart(2, '0');
+    const seconds = now.getSeconds().toString().padStart(2, '0');
+    return `${hours}:${minutes}:${seconds}`;
+}
+function truncate(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    return text.substring(0, maxLength - 3) + '...';
+}
+export class Logger {
+    context;
+    options;
+    constructor(context = {}, options = {}) {
+        this.context = context;
+        this.options = {
+            showTimestamp: options.showTimestamp ?? true,
+            showLevel: options.showLevel ?? true,
+            colorEnabled: options.colorEnabled ?? process.stdout.isTTY !== false,
+            minLevel: options.minLevel ?? 'info',
+        };
+    }
+    /**
+     * Create a child logger with additional context
+     */
+    child(additionalContext) {
+        return new Logger({ ...this.context, ...additionalContext }, this.options);
+    }
+    /**
+     * Format the context prefix (worker ID, issue identifier)
+     */
+    formatPrefix() {
+        const parts = [];
+        // Worker ID with color
+        if (this.context.workerShortId || this.context.workerId) {
+            const id = this.context.workerShortId || this.context.workerId.substring(0, 8);
+            const color = getColorForId(this.context.workerId || id);
+            if (this.options.colorEnabled) {
+                parts.push(colorize(`[${id}]`, color, 'bold'));
+            }
+            else {
+                parts.push(`[${id}]`);
+            }
+        }
+        // Issue identifier with rotating color for visual distinction
+        if (this.context.issueIdentifier) {
+            if (this.options.colorEnabled) {
+                const color = getColorForId(this.context.issueIdentifier);
+                parts.push(colorize(`[${this.context.issueIdentifier}]`, color, 'bold'));
+            }
+            else {
+                parts.push(`[${this.context.issueIdentifier}]`);
+            }
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Format a log line
+     */
+    formatLine(level, message, data) {
+        const parts = [];
+        // Timestamp
+        if (this.options.showTimestamp) {
+            const ts = formatTimestamp();
+            if (this.options.colorEnabled) {
+                parts.push(colorize(ts, 'dim'));
+            }
+            else {
+                parts.push(ts);
+            }
+        }
+        // Level indicator
+        if (this.options.showLevel) {
+            const style = LEVEL_STYLES[level];
+            if (this.options.colorEnabled) {
+                parts.push(colorize(style.label, style.color));
+            }
+            else {
+                parts.push(style.label);
+            }
+        }
+        // Context prefix (worker/issue)
+        const prefix = this.formatPrefix();
+        if (prefix) {
+            parts.push(prefix);
+        }
+        // Message
+        parts.push(message);
+        // Data (if any)
+        if (data && Object.keys(data).length > 0) {
+            const dataStr = this.formatData(data);
+            if (this.options.colorEnabled) {
+                parts.push(colorize(dataStr, 'dim'));
+            }
+            else {
+                parts.push(dataStr);
+            }
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Format data object for display
+     */
+    formatData(data) {
+        const pairs = [];
+        for (const [key, value] of Object.entries(data)) {
+            if (value === undefined)
+                continue;
+            let valueStr;
+            if (typeof value === 'string') {
+                valueStr = truncate(value, 50);
+            }
+            else if (typeof value === 'number' || typeof value === 'boolean') {
+                valueStr = String(value);
+            }
+            else {
+                valueStr = truncate(JSON.stringify(value), 50);
+            }
+            pairs.push(`${key}=${valueStr}`);
+        }
+        return pairs.length > 0 ? `{ ${pairs.join(', ')} }` : '';
+    }
+    /**
+     * Check if a log level should be output
+     */
+    shouldLog(level) {
+        return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.options.minLevel];
+    }
+    /**
+     * Core log method
+     */
+    log(level, message, data) {
+        if (!this.shouldLog(level))
+            return;
+        const line = this.formatLine(level, message, data);
+        if (level === 'error') {
+            console.error(line);
+        }
+        else if (level === 'warn') {
+            console.warn(line);
+        }
+        else {
+            console.log(line);
+        }
+    }
+    // Convenience methods
+    debug(message, data) {
+        this.log('debug', message, data);
+    }
+    info(message, data) {
+        this.log('info', message, data);
+    }
+    success(message, data) {
+        this.log('success', message, data);
+    }
+    warn(message, data) {
+        this.log('warn', message, data);
+    }
+    error(message, data) {
+        this.log('error', message, data);
+    }
+    /**
+     * Log an activity (thought, action, response) with appropriate styling
+     */
+    activity(type, content, maxLength = 80) {
+        if (!this.shouldLog('info'))
+            return;
+        const parts = [];
+        // Timestamp
+        if (this.options.showTimestamp) {
+            const ts = formatTimestamp();
+            if (this.options.colorEnabled) {
+                parts.push(colorize(ts, 'dim'));
+            }
+            else {
+                parts.push(ts);
+            }
+        }
+        // Activity type indicator
+        const activityColor = ACTIVITY_COLORS[type] || 'white';
+        const typeLabel = type.substring(0, 3).toUpperCase();
+        if (this.options.colorEnabled) {
+            parts.push(colorize(typeLabel, activityColor));
+        }
+        else {
+            parts.push(typeLabel);
+        }
+        // Context prefix
+        const prefix = this.formatPrefix();
+        if (prefix) {
+            parts.push(prefix);
+        }
+        // Content (truncated)
+        const truncatedContent = truncate(content.replace(/\n/g, ' '), maxLength);
+        parts.push(truncatedContent);
+        console.log(parts.join(' '));
+    }
+    /**
+     * Log a section header/divider
+     */
+    section(title) {
+        const divider = '─'.repeat(60);
+        if (this.options.colorEnabled) {
+            console.log(colorize(`\n${divider}`, 'dim'));
+            console.log(colorize(`  ${title}`, 'bold', 'brightWhite'));
+            console.log(colorize(`${divider}`, 'dim'));
+        }
+        else {
+            console.log(`\n${divider}`);
+            console.log(`  ${title}`);
+            console.log(divider);
+        }
+    }
+    /**
+     * Log a status change with visual indicator
+     */
+    status(status, details) {
+        const statusColors = {
+            starting: 'yellow',
+            running: 'blue',
+            completed: 'green',
+            stopped: 'yellow',
+            failed: 'red',
+            claimed: 'cyan',
+            registered: 'green',
+        };
+        const color = statusColors[status.toLowerCase()] || 'white';
+        const parts = [];
+        // Timestamp
+        if (this.options.showTimestamp) {
+            const ts = formatTimestamp();
+            if (this.options.colorEnabled) {
+                parts.push(colorize(ts, 'dim'));
+            }
+            else {
+                parts.push(ts);
+            }
+        }
+        // Status indicator
+        if (this.options.colorEnabled) {
+            parts.push(colorize('●', color));
+        }
+        else {
+            parts.push('*');
+        }
+        // Context prefix
+        const prefix = this.formatPrefix();
+        if (prefix) {
+            parts.push(prefix);
+        }
+        // Status text
+        if (this.options.colorEnabled) {
+            parts.push(colorize(status.toUpperCase(), color, 'bold'));
+        }
+        else {
+            parts.push(status.toUpperCase());
+        }
+        // Details
+        if (details) {
+            parts.push(details);
+        }
+        console.log(parts.join(' '));
+    }
+    /**
+     * Log a tool call with formatted input
+     */
+    toolCall(toolName, input) {
+        if (!this.shouldLog('info'))
+            return;
+        const parts = [];
+        // Timestamp
+        if (this.options.showTimestamp) {
+            const ts = formatTimestamp();
+            if (this.options.colorEnabled) {
+                parts.push(colorize(ts, 'dim'));
+            }
+            else {
+                parts.push(ts);
+            }
+        }
+        // Tool indicator
+        if (this.options.colorEnabled) {
+            parts.push(colorize('→', 'cyan'));
+        }
+        else {
+            parts.push('→');
+        }
+        // Context prefix
+        const prefix = this.formatPrefix();
+        if (prefix) {
+            parts.push(prefix);
+        }
+        // Tool name
+        if (this.options.colorEnabled) {
+            parts.push(colorize(toolName, 'cyan', 'bold'));
+        }
+        else {
+            parts.push(toolName);
+        }
+        // Formatted input (key parameters)
+        if (input) {
+            const summary = this.formatToolInput(toolName, input);
+            if (summary) {
+                if (this.options.colorEnabled) {
+                    parts.push(colorize(summary, 'dim'));
+                }
+                else {
+                    parts.push(summary);
+                }
+            }
+        }
+        console.log(parts.join(' '));
+    }
+    /**
+     * Format tool input for display (show relevant params based on tool type)
+     */
+    formatToolInput(toolName, input) {
+        // Show most relevant parameter based on tool type
+        const toolParams = {
+            Read: ['file_path'],
+            Write: ['file_path'],
+            Edit: ['file_path', 'old_string'],
+            Grep: ['pattern', 'path'],
+            Glob: ['pattern'],
+            Bash: ['command'],
+            Task: ['subagent_type', 'description'],
+            WebFetch: ['url'],
+            WebSearch: ['query'],
+        };
+        const relevantParams = toolParams[toolName] || Object.keys(input).slice(0, 2);
+        const values = [];
+        for (const param of relevantParams) {
+            if (input[param] !== undefined) {
+                const value = String(input[param]);
+                values.push(truncate(value, 40));
+            }
+        }
+        return values.length > 0 ? values.join(' ') : '';
+    }
+}
+/**
+ * Create a logger instance
+ */
+export function createLogger(context, options) {
+    return new Logger(context, options);
+}
+/**
+ * Default logger for quick use
+ */
+export const logger = createLogger();

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

@@ -0,0 +1,128 @@
+/**
+ * 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 type { AgentSession } from '@supaku/agentfactory-linear';
+import type { ClaudeStreamHandlers } from './stream-parser';
+/** Configuration for the activity emitter */
+export interface ActivityEmitterConfig {
+    /** AgentSession to emit activities to */
+    session: AgentSession;
+    /** 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;
+}
+/**
+ * Activity Emitter
+ *
+ * Handles rate-limited emission of Claude events to Linear activities.
+ */
+export declare class ActivityEmitter {
+    private readonly session;
+    private readonly minInterval;
+    private readonly maxOutputLength;
+    private readonly includeTimestamps;
+    private readonly onActivityEmitted?;
+    private readonly onActivityThrottled?;
+    private lastEmitTime;
+    private queue;
+    private flushTimer;
+    private isProcessing;
+    private readonly reportedToolErrors;
+    constructor(config: ActivityEmitterConfig);
+    /**
+     * 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>;
+    /**
+     * 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
+     */
+    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
+     */
+    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
+     */
+    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 activity emitter instance
+ */
+export declare function createActivityEmitter(config: ActivityEmitterConfig): ActivityEmitter;
+//# sourceMappingURL=activity-emitter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"activity-emitter.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/activity-emitter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAC/D,OAAO,KAAK,EAOV,oBAAoB,EACrB,MAAM,iBAAiB,CAAA;AAIxB,6CAA6C;AAC7C,MAAM,WAAW,qBAAqB;IACpC,yCAAyC;IACzC,OAAO,EAAE,YAAY,CAAA;IACrB,iEAAiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,wEAAwE;IACxE,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,mEAAmE;IACnE,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,oDAAoD;IACpD,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3D,sDAAsD;IACtD,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAC9D;AAgCD;;;;GAIG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;IACpC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAQ;IACxC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAC3C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAyC;IAC5E,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAyC;IAE9E,OAAO,CAAC,YAAY,CAAI;IACxB,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,UAAU,CAA6C;IAC/D,OAAO,CAAC,YAAY,CAAQ;IAE5B,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAyB;gBAEhD,MAAM,EAAE,qBAAqB;IASzC;;OAEG;IACG,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAQpE;;OAEG;IACG,WAAW,CACf,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,UAAO,GACf,OAAO,CAAC,IAAI,CAAC;IAWhB;;OAEG;IACG,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQlD;;OAEG;IACG,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASrD;;;;;;;;OAQG;IACG,eAAe,CACnB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE;QACR,eAAe,CAAC,EAAE,MAAM,CAAA;QACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAC5C,GACA,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IA2BlE;;OAEG;IACH,iBAAiB,IAAI,oBAAoB;IA0EzC;;OAEG;YACW,aAAa;IAe3B;;OAEG;YACW,YAAY;IA+B1B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAiD7B;;OAEG;YACW,YAAY;IA6C1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAoC1B;;OAEG;IACH,OAAO,CAAC,cAAc;IAQtB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAe3B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B;;OAEG;IACH,OAAO,CAAC,KAAK;CAGd;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,qBAAqB,GAC5B,eAAe,CAEjB"}