@aiconnect/agentjobs-mcp 1.0.9 → 1.2.0

package/build/utils/debugger.js

@@ -0,0 +1,74 @@
+export class MCPDebugger {
+    isDebugEnabled;
+    constructor(enabled = process.env.MCP_DEBUG === 'true') {
+        this.isDebugEnabled = enabled;
+    }
+    formatLog(level, message, data) {
+        if (!this.isDebugEnabled)
+            return;
+        const timestamp = new Date().toISOString();
+        const prefix = `[MCP-DEBUG ${timestamp}] [${level.toUpperCase()}]`;
+        console.error(`${prefix} ${message}`);
+        if (data !== undefined) {
+            console.error(`${prefix} Data:`, JSON.stringify(data, null, 2));
+        }
+    }
+    info(message, data) {
+        this.formatLog('info', message, data);
+    }
+    warn(message, data) {
+        this.formatLog('warn', message, data);
+    }
+    error(message, data) {
+        this.formatLog('error', message, data);
+    }
+    debug(message, data) {
+        this.formatLog('debug', message, data);
+    }
+    // Helper para debugar chamadas de tools
+    toolCall(toolName, args) {
+        this.info(`Tool called: ${toolName}`, { args });
+    }
+    toolResponse(toolName, response, duration) {
+        this.info(`Tool response: ${toolName}`, {
+            response: typeof response === 'object' ? response : { value: response },
+            duration: duration ? `${duration}ms` : undefined
+        });
+    }
+    toolError(toolName, error) {
+        this.error(`Tool error: ${toolName}`, {
+            error: error.message || error,
+            stack: error.stack
+        });
+    }
+    // Helper para debugar requisições HTTP
+    httpRequest(method, url, data) {
+        this.debug(`HTTP ${method.toUpperCase()} ${url}`, data);
+    }
+    httpResponse(method, url, status, data) {
+        this.debug(`HTTP Response ${method.toUpperCase()} ${url} [${status}]`, data);
+    }
+    httpError(method, url, error) {
+        this.error(`HTTP Error ${method.toUpperCase()} ${url}`, error);
+    }
+}
+// Instância global do debugger
+export const mcpDebugger = new MCPDebugger();
+// Helper function para medir tempo de execução
+export function withTiming(fn, name) {
+    return new Promise(async (resolve, reject) => {
+        const start = Date.now();
+        mcpDebugger.debug(`Starting ${name}`);
+        try {
+            const result = await fn();
+            const duration = Date.now() - start;
+            mcpDebugger.debug(`Completed ${name} in ${duration}ms`);
+            resolve(result);
+        }
+        catch (error) {
+            const duration = Date.now() - start;
+            mcpDebugger.error(`Failed ${name} after ${duration}ms`, error);
+            reject(error);
+        }
+    });
+}

package/build/utils/formatters.js

@@ -1,4 +1,185 @@
 import { z } from "zod";
+// Aceita string ISO ou number (timestamp) e converte para string ISO amigável
+const isoOrMs = z.union([z.string(), z.number()]).optional();
+const toIso = (v) => {
+    if (v === null || v === undefined)
+        return undefined;
+    try {
+        if (typeof v === 'string') {
+            const d = new Date(v);
+            return isNaN(d.getTime()) ? v : d.toISOString();
+        }
+        if (typeof v === 'number') {
+            const d = new Date(v);
+            return isNaN(d.getTime()) ? String(v) : d.toISOString();
+        }
+        return String(v);
+    }
+    catch {
+        return String(v);
+    }
+};
+const taskSchema = z.object({
+    task_id: z.string(),
+    created_at: isoOrMs,
+}).passthrough();
+const flagsSchema = z.object({
+    is_new_channel: z.boolean().optional(),
+    has_human_reply: z.boolean().optional(),
+    first_reply_at: isoOrMs.nullable().optional(),
+    ignore_cooldown: z.boolean().optional(),
+}).passthrough();
+const channelDataSchema = z.object({
+    org_id: z.string().optional(),
+    channel_code: z.string().optional(),
+    channel_id: z.string().optional(),
+    platform: z.string().optional(),
+    name: z.string().optional(),
+    profile_id: z.string().optional(),
+    thread_id: z.string().optional(),
+}).passthrough();
+const jobConfigSchema = z.object({
+    profile_id: z.string().optional(),
+    max_follow_ups: z.number().optional(),
+    max_task_retries: z.number().optional(),
+    task_retry_interval: z.number().optional(), // minutos
+    max_time_to_complete: z.number().optional(), // minutos
+    failure_cooldown_minutes: z.number().optional(),
+    start_prompt: z.string().optional(),
+}).passthrough();
+const jobDetailsSchema = z.object({
+    job_id: z.string(),
+    job_type_id: z.string(),
+    org_id: z.string(),
+    channel_code: z.string(),
+    chat_id: z.string().optional(),
+    job_status: z.string(),
+    result: z.string().nullable().optional(),
+    created_at: isoOrMs,
+    updated_at: isoOrMs,
+    scheduled_at: isoOrMs.optional(),
+    last_task_created_at: isoOrMs.nullable().optional(),
+    tags: z.string().optional(),
+    execution_log: z.array(z.string()).optional(),
+    tasks: z.array(taskSchema).optional().default([]),
+    flags: flagsSchema.optional().default({}),
+    channel_data: channelDataSchema.optional().default({}),
+    job_config: jobConfigSchema.optional().default({}),
+    params: z.record(z.any()).optional().default({}),
+}).passthrough();
+const bool = (v) => (v === true ? 'yes' : v === false ? 'no' : 'n/a');
+const safe = (v, fallback = 'n/a') => v === undefined || v === null || v === '' ? fallback : String(v);
+const truncate = (s, max = 300) => {
+    if (typeof s !== 'string')
+        return s;
+    return s.length > max ? `${s.slice(0, max)}…` : s;
+};
+const fmtList = (arr) => (arr && arr.length ? arr.join(', ') : 'n/a');
+export function formatJobDetails(job) {
+    try {
+        const j = jobDetailsSchema.parse(job);
+        // Derivados
+        const tasks = j.tasks || [];
+        const retriesUsed = Math.max((tasks.length || 0) - 1, 0);
+        const maxRetries = j.job_config?.max_task_retries ?? undefined;
+        const retriesRemaining = maxRetries !== undefined ? Math.max(maxRetries - retriesUsed, 0) : undefined;
+        const createdIso = toIso(j.created_at);
+        const updatedIso = toIso(j.updated_at);
+        const scheduledIso = toIso(j.scheduled_at);
+        const lastTaskIso = toIso(j.last_task_created_at);
+        const firstReplyIso = toIso(j.flags?.first_reply_at);
+        // Duração aproximada
+        let durationLine = 'n/a';
+        try {
+            const start = scheduledIso ? new Date(scheduledIso).getTime() : createdIso ? new Date(createdIso).getTime() : NaN;
+            const end = updatedIso ? new Date(updatedIso).getTime() : Date.now();
+            if (!isNaN(start) && !isNaN(end) && end >= start) {
+                const ms = end - start;
+                const mins = Math.floor(ms / 60000);
+                const secs = Math.floor((ms % 60000) / 1000);
+                durationLine = `${mins}m ${secs}s`;
+            }
+        }
+        catch {
+            // ignore errors
+        }
+        // Tags em lista
+        const tagsList = j.tags ? j.tags.split(',').map(s => s.trim()).filter(Boolean) : [];
+        // Tarefas formatadas (mostra as últimas 5)
+        const lastTasks = tasks.slice(-5).map((t, i) => `  - [${i + Math.max(tasks.length - 5 + 1, 1)}] ${t.task_id} @ ${safe(toIso(t.created_at))}`);
+        // Exec log (últimas 5 linhas)
+        const lastLogs = (j.execution_log || []).slice(-5).map((l) => `  - ${l}`);
+        // Params (pretty JSON, truncado para visualização)
+        const paramsPretty = (() => {
+            try {
+                const text = JSON.stringify(j.params ?? {}, null, 2);
+                return truncate(text, 1500);
+            }
+            catch {
+                return String(j.params);
+            }
+        })();
+        const startPrompt = j.job_config?.start_prompt ? truncate(j.job_config.start_prompt, 500) : undefined;
+        return (`Job Details
+===========
+
+Identification:
+- Job ID: ${j.job_id}
+- Status: ${j.job_status}
+- Org ID: ${j.org_id}
+- Channel Code: ${j.channel_code}
+- Chat ID: ${safe(j.chat_id)}
+- Job Type: ${j.job_type_id}
+
+Channel:
+- Platform: ${safe(j.channel_data?.platform)}
+- Channel ID: ${safe(j.channel_data?.channel_id)}
+- Name: ${safe(j.channel_data?.name)}
+- Profile ID: ${safe(j.channel_data?.profile_id)}
+- Thread ID: ${safe(j.channel_data?.thread_id)}
+
+Type Config:
+- Profile ID: ${safe(j.job_config?.profile_id)}
+- Max Follow-ups: ${safe(j.job_config?.max_follow_ups)}
+- Max Task Retries: ${safe(j.job_config?.max_task_retries)}
+- Task Retry Interval: ${safe(j.job_config?.task_retry_interval)} min
+- Max Time to Complete: ${safe(j.job_config?.max_time_to_complete)} min
+- Failure Cooldown: ${safe(j.job_config?.failure_cooldown_minutes)} min
+- Start Prompt: ${safe(startPrompt)}
+
+Flags:
+- is_new_channel: ${bool(j.flags?.is_new_channel)}
+- has_human_reply: ${bool(j.flags?.has_human_reply)}
+- first_reply_at: ${safe(firstReplyIso)}
+- ignore_cooldown: ${bool(j.flags?.ignore_cooldown)}
+
+Params:
+${paramsPretty}
+
+Tasks:
+- Total Tasks: ${tasks.length}
+- Retries Used: ${retriesUsed}${maxRetries !== undefined ? ` / ${maxRetries} (remaining: ${retriesRemaining})` : ''}
+${lastTasks.length ? lastTasks.join('\n') : '  - n/a'}
+
+Dates:
+- Created At: ${safe(createdIso)}
+- Updated At: ${safe(updatedIso)}
+- Scheduled At: ${safe(scheduledIso)}
+- Last Task At: ${safe(lastTaskIso)}
+- Duration: ${durationLine}
+
+Result / Tags / Log:
+- Result: ${safe(j.result)}
+- Tags: ${fmtList(tagsList)}
+- Execution Log (last 5):
+${lastLogs.length ? lastLogs.join('\n') : '  - n/a'}
+`).trim();
+    }
+    catch (e) {
+        // Se a validação flexível ainda assim falhar, retorna JSON completo
+        return `Job Details (raw):\n\n${JSON.stringify(job, null, 2)}`;
+    }
+}
 // Schema para um job individual, baseado no exemplo fornecido.
 const jobSchema = z.object({
     job_id: z.string(),
@@ -10,15 +191,6 @@ const jobSchema = z.object({
     result: z.string().nullable(),
     job_type_id: z.string(),
 }).passthrough(); // .passthrough() permite outros campos não definidos no schema.
-/**
- * Formata a resposta completa de um job, ideal para o get_job.
- * @param job - O objeto do job.
- * @returns Uma string formatada com os detalhes completos do job.
- */
-export function formatJobDetails(job) {
-    const fullJobDetails = JSON.stringify(job, null, 2);
-    return `Job Details:\n\n${fullJobDetails}`;
-}
 /**
  * Formata um resumo de um job, com os campos principais.
  * @param job - O objeto do job.
@@ -37,65 +209,365 @@ export function formatJobSummary(job) {
 - Result: ${parsedJob.result || 'N/A'}
     `.trim();
     }
-    catch (error) {
+    catch {
         // Se a validação falhar, retorna o objeto como string.
         return JSON.stringify(job, null, 2);
     }
 }
 /**
  * Formata a resposta para a lista de jobs.
+ *
+ * `meta` é obrigatório e os três campos (`count`, `limit`, `total`) precisam
+ * ser numéricos — confirmado empiricamente que o backend sempre os retorna em
+ * `/services/agent-jobs`. Falha explícita aqui é preferível a inventar um
+ * footer com valores inferidos, pois isso recriaria a ambiguidade
+ * "page count vs total" que esta tool deveria eliminar.
+ *
  * @param jobs - Um array de jobs.
- * @param pagination - O objeto de paginação.
+ * @param meta - O objeto `meta` retornado pelo backend.
+ * @param offset - O `offset` que a tool enviou na requisição (default 0).
  * @returns Uma string formatada com a lista de resumos de jobs.
  */
-export function formatJobList(jobs, pagination) {
-    if (!jobs || jobs.length === 0) {
-        return "No jobs found for the given criteria.";
+export function formatJobList(jobs, meta, offset = 0) {
+    if (!meta || typeof meta.count !== 'number' || typeof meta.limit !== 'number' || typeof meta.total !== 'number') {
+        throw new Error('formatJobList: meta is required with numeric `count`, `limit`, and `total`. ' +
+            `Received: ${JSON.stringify(meta)}`);
     }
-    const jobSummaries = jobs.map(job => formatJobSummary(job)).join('\n\n');
-    const paginationSummary = `Page: ${Math.floor((pagination.offset || 0) / (pagination.limit || 20)) + 1} | Total Jobs: ${pagination.total}`;
-    return `Found ${jobs.length} jobs.\n\n${jobSummaries}\n\n${paginationSummary}`;
+    const safeJobs = jobs || [];
+    const { count, limit, total } = meta;
+    const hasMore = (offset + count) < total;
+    const nextOffset = hasMore ? offset + limit : null;
+    const footer = `Returned: ${count} | Total matching: ${total} | Has more: ${hasMore} | Next offset: ${nextOffset === null ? 'null' : nextOffset}`;
+    if (safeJobs.length === 0) {
+        return `Found 0 jobs.\n\n${footer}`;
+    }
+    const jobSummaries = safeJobs.map(job => formatJobSummary(job)).join('\n\n');
+    return `Found ${safeJobs.length} jobs.\n\n${jobSummaries}\n\n${footer}`;
 }
 // Schema for job type details
 const jobTypeSchema = z.object({
     id: z.string(),
     org_id: z.string(),
     name: z.string(),
-    description: z.string(),
+    description: z.string().optional(),
     default_config: z.object({
-        profile_id: z.string(),
-        max_follow_ups: z.number(),
-        max_task_retries: z.number(),
-        task_retry_interval: z.number().describe("The interval in minutes to wait before retrying a task."),
-        max_time_to_complete: z.number().describe("The maximum time in minutes to complete a task."),
-        start_prompt: z.string(),
-    }),
+        profile_id: z.string().optional(),
+        max_follow_ups: z.number().optional(),
+        max_task_retries: z.number().optional(),
+        task_retry_interval: z.number().optional(),
+        max_time_to_complete: z.number().optional(),
+        failure_cooldown_minutes: z.number().optional(),
+        start_prompt: z.string().optional(),
+    }).optional(),
+    params_schema: z.any().optional(),
+    version: z.union([z.string(), z.number()]).optional(),
+    visibility: z.string().optional(),
+    active: z.boolean().optional(),
+    tags: z.union([z.string(), z.array(z.string())]).optional(),
+    created_at: isoOrMs,
+    updated_at: isoOrMs,
 }).passthrough();
+// Helper to summarize JSON Schema
+function summarizeSchema(schema, _depth = 1, limit = 12) {
+    if (!schema || typeof schema !== 'object') {
+        return {
+            type: 'unknown',
+            requiredCount: 0,
+            propsCount: 0,
+            properties: []
+        };
+    }
+    const type = schema.type || 'unknown';
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    const props = schema.properties || {};
+    const propNames = Object.keys(props);
+    const properties = propNames.slice(0, limit).map(name => ({
+        name,
+        type: props[name]?.type || 'any',
+        required: required.includes(name),
+        description: props[name]?.description,
+        default: props[name]?.default
+    }));
+    return {
+        type,
+        requiredCount: required.length,
+        propsCount: propNames.length,
+        properties
+    };
+}
 /**
  * Formats the response for job type details.
  * @param jobType - The job type object.
+ * @param options - Formatter options.
  * @returns A formatted string with the job type details.
  */
-export function formatJobTypeDetails(jobType) {
+export function formatJobTypeDetails(jobType, options = {}) {
+    const { includeSchema = true, schemaDepth = 1, truncate: truncateLimits = {}, renderAsMarkdown = true, showEmptySections = false } = options;
+    const { startPrompt: startPromptLimit = 500, description: descriptionLimit = 400, schemaString: schemaStringLimit = 1500 } = truncateLimits;
     try {
-        const parsedJobType = jobTypeSchema.parse(jobType);
-        return `
-- ID: ${parsedJobType.id}
-- Name: ${parsedJobType.name}
-- Description: ${parsedJobType.description}
-- Organization ID: ${parsedJobType.org_id}
-
-Default Configuration:
-- Profile ID: ${parsedJobType.default_config.profile_id}
-- Max Follow-ups: ${parsedJobType.default_config.max_follow_ups}
-- Max Task Retries: ${parsedJobType.default_config.max_task_retries}
-- Task Retry Interval: ${parsedJobType.default_config.task_retry_interval} minutes
-- Max Time to Complete: ${parsedJobType.default_config.max_time_to_complete} minutes
-- Start Prompt: ${parsedJobType.default_config.start_prompt}
-    `.trim();
+        const j = jobTypeSchema.parse(jobType);
+        // Normalize dates
+        const createdIso = toIso(j.created_at);
+        const updatedIso = toIso(j.updated_at);
+        // Format tags
+        const tagsList = (() => {
+            if (!j.tags)
+                return [];
+            if (typeof j.tags === 'string') {
+                return j.tags.split(',').map(s => s.trim()).filter(Boolean);
+            }
+            return j.tags;
+        })();
+        // Truncate long texts
+        const descriptionText = j.description ? truncate(j.description, descriptionLimit) : undefined;
+        const startPromptText = j.default_config?.start_prompt
+            ? truncate(j.default_config.start_prompt, startPromptLimit)
+            : undefined;
+        // Calculate derived fields
+        const retryPolicy = j.default_config?.max_task_retries && j.default_config?.task_retry_interval
+            ? `${j.default_config.max_task_retries} every ${j.default_config.task_retry_interval} min`
+            : undefined;
+        const executionWindow = j.default_config?.max_time_to_complete
+            ? `${j.default_config.max_time_to_complete} min`
+            : undefined;
+        const cooldownInfo = j.default_config?.failure_cooldown_minutes
+            ? `${j.default_config.failure_cooldown_minutes} min`
+            : undefined;
+        // Summarize schema
+        const schemaSummary = j.params_schema ? summarizeSchema(j.params_schema, schemaDepth) : null;
+        const schemaPreview = j.params_schema && includeSchema ? (() => {
+            try {
+                const text = JSON.stringify(j.params_schema, null, 2);
+                return truncate(text, schemaStringLimit);
+            }
+            catch {
+                return 'Unable to serialize schema';
+            }
+        })() : null;
+        // Build policies line
+        const policies = [
+            retryPolicy ? `retries up to ${retryPolicy}` : null,
+            executionWindow ? `window ${executionWindow}` : null,
+            cooldownInfo ? `cooldown ${cooldownInfo}` : null
+        ].filter(Boolean).join(' | ');
+        // Format output
+        const title = renderAsMarkdown ? '## Job Type Details\n' : 'Job Type Details\n===========\n';
+        let output = title + '\n';
+        // Identification
+        output += 'Identification:\n';
+        output += `- ID: ${j.id}\n`;
+        output += `- Name: ${j.name}\n`;
+        output += `- Org ID: ${j.org_id}\n`;
+        if (j.version !== undefined)
+            output += `- Version: ${safe(j.version)}\n`;
+        if (j.visibility !== undefined)
+            output += `- Visibility: ${safe(j.visibility)}\n`;
+        if (j.active !== undefined)
+            output += `- Active: ${bool(j.active)}\n`;
+        output += '\n';
+        // Description
+        if (descriptionText || showEmptySections) {
+            output += 'Description:\n';
+            output += safe(descriptionText) + '\n\n';
+        }
+        // Default Config
+        if (j.default_config || showEmptySections) {
+            output += 'Default Config:\n';
+            if (j.default_config) {
+                const cfg = j.default_config;
+                if (cfg.profile_id)
+                    output += `- Profile ID: ${cfg.profile_id}\n`;
+                if (cfg.max_follow_ups !== undefined)
+                    output += `- Max Follow-ups: ${cfg.max_follow_ups}\n`;
+                if (cfg.max_task_retries !== undefined)
+                    output += `- Max Task Retries: ${cfg.max_task_retries}\n`;
+                if (cfg.task_retry_interval !== undefined)
+                    output += `- Task Retry Interval: ${cfg.task_retry_interval} min\n`;
+                if (cfg.max_time_to_complete !== undefined)
+                    output += `- Max Time to Complete: ${cfg.max_time_to_complete} min\n`;
+                if (cfg.failure_cooldown_minutes !== undefined)
+                    output += `- Failure Cooldown: ${cfg.failure_cooldown_minutes} min\n`;
+                if (startPromptText)
+                    output += `- Start Prompt: ${startPromptText}\n`;
+                if (policies)
+                    output += `- Policies: ${policies}\n`;
+            }
+            else {
+                output += 'n/a\n';
+            }
+            output += '\n';
+        }
+        // Params Schema
+        if ((schemaSummary && includeSchema) || showEmptySections) {
+            output += 'Params Schema:\n';
+            if (schemaSummary) {
+                output += `- Type: ${schemaSummary.type} | Required: ${schemaSummary.requiredCount} | Properties: ${schemaSummary.propsCount}\n`;
+                if (schemaSummary.properties.length > 0) {
+                    output += '- Properties:\n';
+                    schemaSummary.properties.forEach(prop => {
+                        const req = prop.required ? ' (required)' : '';
+                        const desc = prop.description ? ` — ${truncate(prop.description, 100)}` : '';
+                        const def = prop.default !== undefined ? ` — Defaults to ${JSON.stringify(prop.default)}` : '';
+                        output += `  - ${prop.name}: ${prop.type}${req}${desc}${def}\n`;
+                    });
+                    if (schemaSummary.propsCount > schemaSummary.properties.length) {
+                        output += `  - +${schemaSummary.propsCount - schemaSummary.properties.length} more…\n`;
+                    }
+                }
+                if (schemaPreview) {
+                    output += '- Schema preview:\n';
+                    output += '```json\n' + schemaPreview + '\n```\n';
+                }
+            }
+            else {
+                output += 'n/a\n';
+            }
+            output += '\n';
+        }
+        // Metadata
+        output += 'Metadata:\n';
+        output += `- Created At: ${safe(createdIso)}\n`;
+        output += `- Updated At: ${safe(updatedIso)}\n`;
+        output += `- Tags: ${fmtList(tagsList)}\n`;
+        return output.trim();
     }
-    catch (error) {
-        // If validation fails, return the object as a string.
-        return `Invalid job type details format: ${JSON.stringify(jobType, null, 2)}`;
+    catch (e) {
+        // If validation fails, return raw JSON
+        return `Job Type Details (raw):\n\n${JSON.stringify(jobType, null, 2)}`;
     }
 }
+/**
+ * Formats a summary of a job type.
+ * @param jobType - The job type object.
+ * @returns A formatted string with the job type summary.
+ */
+export function formatJobTypeSummary(jobType) {
+    try {
+        const j = jobTypeSchema.parse(jobType);
+        const retries = j.default_config?.max_task_retries && j.default_config?.task_retry_interval
+            ? `${j.default_config.max_task_retries} every ${j.default_config.task_retry_interval} min`
+            : 'n/a';
+        const maxTime = j.default_config?.max_time_to_complete
+            ? `${j.default_config.max_time_to_complete} min`
+            : 'n/a';
+        const cooldown = j.default_config?.failure_cooldown_minutes
+            ? `${j.default_config.failure_cooldown_minutes} min`
+            : 'n/a';
+        const schemaSummary = j.params_schema ? summarizeSchema(j.params_schema) : null;
+        const schemaInfo = schemaSummary
+            ? `required=${schemaSummary.requiredCount}, props=${schemaSummary.propsCount}`
+            : 'n/a';
+        return [
+            `- ID: ${j.id}`,
+            `- Name: ${j.name}`,
+            `- Active: ${bool(j.active)}`,
+            `- Retries: ${retries} | Max Time: ${maxTime} | Cooldown: ${cooldown}`,
+            `- Params: ${schemaInfo}`
+        ].join('\n');
+    }
+    catch {
+        // If validation fails, return basic info
+        return JSON.stringify(jobType, null, 2);
+    }
+}
+const DATE_FILTER_KEYS = [
+    'scheduled_at_gte',
+    'scheduled_at_lte',
+    'created_at_gte',
+    'created_at_lte',
+];
+const renderDateRange = (label, gte, lte) => {
+    if (gte === undefined && lte === undefined)
+        return null;
+    const left = gte !== undefined ? String(gte) : '(open)';
+    const right = lte !== undefined ? String(lte) : '(open)';
+    return `${label}: ${left} → ${right}`;
+};
+const CONTEXT_LABEL_WIDTH = 16; // "Server version: " == 16 chars
+const JOB_TYPE_ID_WIDTH = 22;
+const JOB_TYPE_EMOJI_WIDTH = 4;
+function padLabel(label) {
+    return (label + ':').padEnd(CONTEXT_LABEL_WIDTH, ' ');
+}
+function formatJobTypeLine(jt) {
+    const id = jt.id.padEnd(JOB_TYPE_ID_WIDTH, ' ');
+    const emoji = (jt.emoji ?? '').padEnd(JOB_TYPE_EMOJI_WIDTH, ' ');
+    const description = jt.description ? ` — ${jt.description}` : '';
+    return `  - ${id} ${emoji} ${jt.name}${description}`;
+}
+export function formatContext(input) {
+    const { localConfig, jobTypes, total, jobTypesError } = input;
+    const contextSection = [
+        'Context:',
+        `  ${padLabel('Org ID')} ${localConfig.org_id}`,
+        `  ${padLabel('Timezone')} ${localConfig.timezone}`,
+        `  ${padLabel('API URL')} ${localConfig.api_url}`,
+        `  ${padLabel('Server version')} ${localConfig.server_version}`
+    ].join('\n');
+    let jobsSection;
+    if (jobTypesError !== undefined) {
+        jobsSection = `Job types: unavailable (error: ${jobTypesError})`;
+    }
+    else if (jobTypes === undefined) {
+        jobsSection = 'Job types: unavailable (error: unknown)';
+    }
+    else {
+        const totalCount = typeof total === 'number' ? total : jobTypes.length;
+        if (totalCount === 0) {
+            jobsSection = 'Job types available (0):\n  (no job types registered for this org)';
+        }
+        else {
+            const lines = jobTypes.map(formatJobTypeLine);
+            let trailing = '';
+            if (totalCount > jobTypes.length) {
+                const missing = totalCount - jobTypes.length;
+                trailing = `\n  … and ${missing} more job types not shown`;
+            }
+            jobsSection = `Job types available (${totalCount}):\n${lines.join('\n')}${trailing}`;
+        }
+    }
+    return `${contextSection}\n\n${jobsSection}`;
+}
+export function formatJobStats(stats, appliedFilters = {}) {
+    const { waiting = 0, running = 0, completed = 0, failed = 0, canceled = 0, scheduled = 0, } = stats.status;
+    const totalJobs = waiting + running + completed + failed + canceled + scheduled;
+    const successRate = totalJobs > 0 ? ((completed / (totalJobs - waiting - scheduled - running)) * 100).toFixed(1) : "0.0";
+    const completionRate = (completed + failed) > 0 ? (completed / (completed + failed) * 100).toFixed(1) : "0.0";
+    const activeJobs = running + waiting + scheduled;
+    const filters = appliedFilters || {};
+    const scheduledLine = renderDateRange('Scheduled', filters.scheduled_at_gte, filters.scheduled_at_lte);
+    const createdLine = renderDateRange('Created', filters.created_at_gte, filters.created_at_lte);
+    const hasAnyDateFilter = DATE_FILTER_KEYS.some((k) => filters[k] !== undefined);
+    const periodFallback = hasAnyDateFilter ? null : 'Period: All time';
+    const dateLines = [scheduledLine, createdLine, periodFallback].filter((l) => l !== null);
+    const dateFilterSet = new Set(DATE_FILTER_KEYS);
+    const otherFilterEntries = Object.entries(filters).filter(([k, v]) => !dateFilterSet.has(k) && v !== undefined && v !== null && v !== '');
+    const filtersSection = otherFilterEntries.length
+        ? `Filters:\n${otherFilterEntries.map(([k, v]) => `- ${k}: ${v}`).join('\n')}\n\n`
+        : '';
+    const percentage = (value) => {
+        if (totalJobs === 0)
+            return "0.0";
+        return ((value / totalJobs) * 100).toFixed(1);
+    };
+    return `
+Job Statistics Report
+====================
+
+${dateLines.join('\n')}
+
+${filtersSection}Status Breakdown:
+✓ Completed:  ${completed} jobs (${percentage(completed)}%)
+⏳ Running:     ${running} jobs (${percentage(running)}%)
+⏰ Scheduled:  ${scheduled} jobs (${percentage(scheduled)}%)
+⏸ Waiting:     ${waiting} jobs (${percentage(waiting)}%)
+✗ Failed:      ${failed} jobs (${percentage(failed)}%)
+⊘ Canceled:    ${canceled} jobs (${percentage(canceled)}%)
+
+Summary:
+- Total Jobs: ${totalJobs}
+- Success Rate: ${successRate}%
+- Active Jobs: ${activeJobs} (running + waiting + scheduled)
+- Completion Rate: ${completionRate}% (completed / (completed + failed))
+  `.trim();
+}