tachibot-mcp 2.0.2

package/dist/src/utils/smart-api-client.js

@@ -0,0 +1,146 @@
+/**
+ * SmartAPIClient - Adaptive timeout and retry system for external API calls
+ *
+ * Features:
+ * - Fixed timeouts with priority-based adjustment (interactive vs batch)
+ * - Exponential backoff with full jitter
+ * - Proper resource cleanup with AbortController
+ * - NO metrics collection - privacy-first design
+ */
+export class SmartAPIClient {
+    constructor() {
+        // Default configuration
+        this.defaults = {
+            maxRetries: 3,
+            baseTimeoutMs: 30000, // 30 seconds
+            maxTimeoutMs: 120000, // 2 minutes
+            backoffBase: 2,
+            enableJitter: true
+        };
+        // Priority-specific timeout multipliers
+        this.priorityMultipliers = {
+            interactive: {
+                base: 0.5, // 50% of base timeout
+                max: 0.5 // 50% of max timeout
+            },
+            batch: {
+                base: 1.0, // 100% of base timeout
+                max: 1.0 // 100% of max timeout
+            }
+        };
+        // Singleton pattern
+    }
+    static getInstance() {
+        if (!SmartAPIClient.instance) {
+            SmartAPIClient.instance = new SmartAPIClient();
+        }
+        return SmartAPIClient.instance;
+    }
+    /**
+     * Call API with timeout and retry logic
+     */
+    async callWithRetries(apiCall, config) {
+        const fullConfig = { ...this.defaults, ...config };
+        const startTime = Date.now();
+        let lastError;
+        let attempt = 0;
+        while (attempt < fullConfig.maxRetries) {
+            const controller = new AbortController();
+            const timeoutMs = this.calculateTimeout(fullConfig.priority, fullConfig.baseTimeoutMs, fullConfig.maxTimeoutMs);
+            const timeoutId = setTimeout(() => {
+                controller.abort();
+            }, timeoutMs);
+            try {
+                const attemptStart = Date.now();
+                // Execute API call
+                const result = await Promise.race([
+                    apiCall(),
+                    this.createTimeoutPromise(timeoutMs, fullConfig.provider)
+                ]);
+                clearTimeout(timeoutId);
+                const latency = Date.now() - attemptStart;
+                console.log(`[SmartAPIClient] Success: ${fullConfig.provider} ` +
+                    `(attempt ${attempt + 1}, ${latency}ms, timeout=${timeoutMs}ms)`);
+                return result;
+            }
+            catch (error) {
+                clearTimeout(timeoutId);
+                lastError = error;
+                console.error(`[SmartAPIClient] Attempt ${attempt + 1} failed for ${fullConfig.provider}: ${error.message}`);
+                // Check if we should retry
+                if (!this.shouldRetry(error, attempt, fullConfig.maxRetries)) {
+                    break;
+                }
+                // Wait before retry with exponential backoff + jitter
+                await this.backoffWithJitter(attempt, fullConfig.backoffBase, fullConfig.enableJitter);
+                attempt++;
+            }
+            finally {
+                // Ensure cleanup
+                if (!controller.signal.aborted) {
+                    controller.abort();
+                }
+            }
+        }
+        const totalTime = Date.now() - startTime;
+        throw new Error(`[SmartAPIClient] All retries exhausted for ${fullConfig.provider} ` +
+            `(${attempt} attempts in ${totalTime}ms): ${lastError?.message || 'Unknown error'}`);
+    }
+    /**
+     * Calculate timeout based on priority
+     */
+    calculateTimeout(priority, baseTimeout, maxTimeout) {
+        const finalTimeout = Math.min(baseTimeout * this.priorityMultipliers[priority].base, maxTimeout * this.priorityMultipliers[priority].max);
+        return finalTimeout;
+    }
+    /**
+     * Exponential backoff with full jitter
+     */
+    async backoffWithJitter(attempt, base, enableJitter) {
+        const exponentialDelay = Math.pow(base, attempt) * 1000;
+        const cappedDelay = Math.min(exponentialDelay, 10000); // Cap at 10 seconds
+        const finalDelay = enableJitter
+            ? Math.random() * cappedDelay // Full jitter: random(0, cappedDelay)
+            : cappedDelay;
+        console.log(`[SmartAPIClient] Backing off for ${Math.round(finalDelay)}ms ` +
+            `(attempt ${attempt + 1}, ${enableJitter ? 'with' : 'without'} jitter)`);
+        await new Promise(resolve => setTimeout(resolve, finalDelay));
+    }
+    /**
+     * Determine if we should retry based on error type and attempt count
+     */
+    shouldRetry(error, attempt, maxRetries) {
+        if (attempt >= maxRetries - 1) {
+            return false;
+        }
+        // Retry on timeout, network errors, 5xx errors
+        const retryablePatterns = [
+            'timeout',
+            'ETIMEDOUT',
+            'ECONNRESET',
+            'ENOTFOUND',
+            'ECONNREFUSED',
+            '500',
+            '502',
+            '503',
+            '504'
+        ];
+        const errorMessage = error?.message?.toLowerCase() || '';
+        const isRetryable = retryablePatterns.some(pattern => errorMessage.includes(pattern.toLowerCase()));
+        console.log(`[SmartAPIClient] Error "${errorMessage.slice(0, 50)}..." is ` +
+            `${isRetryable ? 'retryable' : 'not retryable'}`);
+        return isRetryable;
+    }
+    /**
+     * Create a timeout promise for Promise.race
+     */
+    createTimeoutPromise(timeoutMs, provider) {
+        return new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error(`Timeout after ${timeoutMs}ms for ${provider}`));
+            }, timeoutMs);
+        });
+    }
+}
+// Export singleton instance
+export const smartAPIClient = SmartAPIClient.getInstance();

package/dist/src/utils/table-builder.js

@@ -0,0 +1,218 @@
+/**
+ * Beautiful Unicode box-drawing table builder using cli-table3
+ * Provides a fluent API for creating readable, professional tables
+ *
+ * @example
+ * ```typescript
+ * const table = new TableBuilder()
+ *   .withHeaders(['Status', 'Model', 'Conclusion'])
+ *   .withAlignments(['center', 'left', 'center'])
+ *   .addRow(['✅', 'grok-4', '✓ true'])
+ *   .build();
+ * ```
+ */
+import Table from 'cli-table3';
+/**
+ * Predefined table styles
+ */
+export const TableStyles = {
+    /**
+     * Beautiful Unicode box-drawing characters
+     * Uses double lines for outer border, single lines for inner
+     */
+    unicode: {
+        chars: {
+            'top': '═',
+            'top-mid': '╤',
+            'top-left': '╔',
+            'top-right': '╗',
+            'bottom': '═',
+            'bottom-mid': '╧',
+            'bottom-left': '╚',
+            'bottom-right': '╝',
+            'left': '║',
+            'left-mid': '╟',
+            'mid': '─',
+            'mid-mid': '┼',
+            'right': '║',
+            'right-mid': '╢',
+            'middle': '│'
+        },
+        style: {
+            head: [], // No color styling for headers
+            border: [] // No color styling for borders
+        }
+    },
+    /**
+     * Compact Unicode style with single lines
+     */
+    compact: {
+        chars: {
+            'top': '─',
+            'top-mid': '┬',
+            'top-left': '┌',
+            'top-right': '┐',
+            'bottom': '─',
+            'bottom-mid': '┴',
+            'bottom-left': '└',
+            'bottom-right': '┘',
+            'left': '│',
+            'left-mid': '├',
+            'mid': '─',
+            'mid-mid': '┼',
+            'right': '│',
+            'right-mid': '┤',
+            'middle': '│'
+        },
+        style: {
+            head: [],
+            border: []
+        }
+    },
+    /**
+     * ASCII-only style for maximum compatibility
+     */
+    ascii: {
+        chars: {
+            'top': '-',
+            'top-mid': '+',
+            'top-left': '+',
+            'top-right': '+',
+            'bottom': '-',
+            'bottom-mid': '+',
+            'bottom-left': '+',
+            'bottom-right': '+',
+            'left': '|',
+            'left-mid': '+',
+            'mid': '-',
+            'mid-mid': '+',
+            'right': '|',
+            'right-mid': '+',
+            'middle': '|'
+        },
+        style: {
+            head: [],
+            border: []
+        }
+    }
+};
+/**
+ * Fluent API table builder with beautiful Unicode box-drawing
+ */
+export class TableBuilder {
+    constructor() {
+        this.headers = [];
+        this.alignments = [];
+        this.rows = [];
+        this.style = TableStyles.unicode;
+    }
+    /**
+     * Set table headers
+     */
+    withHeaders(headers) {
+        this.headers = headers;
+        return this;
+    }
+    /**
+     * Set column alignments
+     * @param alignments - Array of 'left', 'center', or 'right'
+     */
+    withAlignments(alignments) {
+        this.alignments = alignments;
+        return this;
+    }
+    /**
+     * Set explicit column widths
+     * @param widths - Array of column widths in characters
+     */
+    withColumnWidths(widths) {
+        this.colWidths = widths;
+        return this;
+    }
+    /**
+     * Use a predefined style
+     * @param styleName - 'unicode', 'compact', or 'ascii'
+     */
+    withStyle(styleName) {
+        this.style = TableStyles[styleName];
+        return this;
+    }
+    /**
+     * Use custom box-drawing characters
+     * @param chars - Custom character set
+     */
+    withCustomChars(chars) {
+        this.style = {
+            ...this.style,
+            chars: { ...this.style.chars, ...chars }
+        };
+        return this;
+    }
+    /**
+     * Add a single row to the table
+     * @param row - Array of cell values
+     */
+    addRow(row) {
+        this.rows.push(row);
+        return this;
+    }
+    /**
+     * Add multiple rows at once
+     * @param rows - Array of row arrays
+     */
+    addRows(rows) {
+        this.rows.push(...rows);
+        return this;
+    }
+    /**
+     * Build and return the formatted table string
+     * @returns Formatted table with newline prefix for spacing
+     */
+    build() {
+        const options = {
+            head: this.headers.length > 0 ? this.headers : undefined,
+            colAligns: this.alignments.length > 0 ? this.alignments : undefined,
+            ...this.style
+        };
+        // Only add colWidths if explicitly set
+        if (this.colWidths && this.colWidths.length > 0) {
+            options.colWidths = this.colWidths;
+        }
+        const table = new Table(options);
+        if (this.rows.length > 0) {
+            table.push(...this.rows);
+        }
+        // Add newline prefix for better spacing in output
+        return '\n' + table.toString();
+    }
+    /**
+     * Build and return without the leading newline
+     * @returns Formatted table without prefix spacing
+     */
+    buildRaw() {
+        return this.build().trimStart();
+    }
+}
+/**
+ * Quick helper function for simple tables
+ * @param headers - Column headers
+ * @param rows - Table rows
+ * @param alignments - Optional column alignments
+ * @returns Formatted table string
+ *
+ * @example
+ * ```typescript
+ * const table = quickTable(
+ *   ['Name', 'Age'],
+ *   [['Alice', 30], ['Bob', 25]],
+ *   ['left', 'right']
+ * );
+ * ```
+ */
+export function quickTable(headers, rows, alignments) {
+    const builder = new TableBuilder().withHeaders(headers).addRows(rows);
+    if (alignments) {
+        builder.withAlignments(alignments);
+    }
+    return builder.build();
+}

package/dist/src/utils/timestamp-formatter.js

@@ -0,0 +1,134 @@
+/**
+ * Timestamp Formatter - Human-readable timestamps for workflow/session output
+ * Format: YYYY-MM-DD-DayName-HH-MM-shortid
+ * Example: 2025-11-23-Sunday-22-44-a1b2c3d4
+ */
+import { randomUUID } from 'crypto';
+/**
+ * Day names for human readability
+ */
+const DAY_NAMES = [
+    'Sunday',
+    'Monday',
+    'Tuesday',
+    'Wednesday',
+    'Thursday',
+    'Friday',
+    'Saturday'
+];
+/**
+ * Format a date as human-readable timestamp
+ * @param date - Date to format (defaults to now)
+ * @param includeShortId - Whether to include short UUID (default: true)
+ * @returns Formatted timestamp string
+ *
+ * @example
+ * formatTimestamp() // "2025-11-23-Sunday-22-44-a1b2c3d4"
+ * formatTimestamp(new Date(), false) // "2025-11-23-Sunday-22-44"
+ */
+export function formatTimestamp(date = new Date(), includeShortId = true) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const dayName = DAY_NAMES[date.getDay()];
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const parts = [year, month, day, dayName, hours, minutes];
+    if (includeShortId) {
+        const shortId = randomUUID().split('-')[0];
+        parts.push(shortId);
+    }
+    return parts.join('-');
+}
+/**
+ * Parse a human-readable timestamp back to Date
+ * @param timestamp - Formatted timestamp string
+ * @returns Date object or null if invalid
+ *
+ * @example
+ * parseTimestamp("2025-11-23-Sunday-22-44-a1b2c3d4") // Date object
+ */
+export function parseTimestamp(timestamp) {
+    try {
+        // Format: YYYY-MM-DD-DayName-HH-MM-shortid
+        const parts = timestamp.split('-');
+        if (parts.length < 6) {
+            return null;
+        }
+        const [year, month, day, _dayName, hours, minutes] = parts;
+        const date = new Date(parseInt(year), parseInt(month) - 1, // JS months are 0-indexed
+        parseInt(day), parseInt(hours), parseInt(minutes), 0, 0);
+        if (isNaN(date.getTime())) {
+            return null;
+        }
+        return date;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Generate a workflow ID with human-readable timestamp
+ * @param workflowName - Optional workflow name to include
+ * @returns Workflow ID string
+ *
+ * @example
+ * generateWorkflowId() // "2025-11-23-Sunday-22-44-a1b2c3d4"
+ * generateWorkflowId("pingpong") // "2025-11-23-Sunday-22-44-a1b2c3d4"
+ */
+export function generateWorkflowId(workflowName) {
+    // Don't include workflow name in the folder name - it's already in the parent path
+    // workflow-output/{workflowName}/{timestamp}/
+    return formatTimestamp();
+}
+/**
+ * Generate a session ID with human-readable timestamp
+ * @param mode - Session mode (e.g., "advanced-pingpong", "workflow-test")
+ * @returns Session ID string
+ *
+ * @example
+ * generateSessionId("advanced-pingpong") // "session-2025-11-23-Sunday-22-44-advanced-pingpong"
+ */
+export function generateSessionId(mode) {
+    const timestamp = formatTimestamp(new Date(), false); // No short ID in session names
+    return `session-${timestamp}-${mode}`;
+}
+/**
+ * Check if a timestamp is from today
+ */
+export function isToday(timestamp) {
+    const parsed = parseTimestamp(timestamp);
+    if (!parsed)
+        return false;
+    const today = new Date();
+    return (parsed.getFullYear() === today.getFullYear() &&
+        parsed.getMonth() === today.getMonth() &&
+        parsed.getDate() === today.getDate());
+}
+/**
+ * Get a human-readable relative time string
+ * @example "2 hours ago", "just now", "yesterday"
+ */
+export function getRelativeTime(timestamp) {
+    const parsed = parseTimestamp(timestamp);
+    if (!parsed)
+        return 'unknown';
+    const now = new Date();
+    const diffMs = now.getTime() - parsed.getTime();
+    const diffMins = Math.floor(diffMs / (1000 * 60));
+    const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    if (diffMins < 1)
+        return 'just now';
+    if (diffMins < 60)
+        return `${diffMins} minute${diffMins > 1 ? 's' : ''} ago`;
+    if (diffHours < 24)
+        return `${diffHours} hour${diffHours > 1 ? 's' : ''} ago`;
+    if (diffDays === 1)
+        return 'yesterday';
+    if (diffDays < 7)
+        return `${diffDays} days ago`;
+    if (diffDays < 30)
+        return `${Math.floor(diffDays / 7)} week${Math.floor(diffDays / 7) > 1 ? 's' : ''} ago`;
+    return parsed.toLocaleDateString();
+}