@arka-labs/nemesis 1.2.0

package/lib/ui/dashboard.js

@@ -0,0 +1,580 @@
+/**
+ * Orchestration dashboard + daemon — poll-based TUI that monitors AND orchestrates dispatches.
+ * Actively dispatches READY_TO_DISPATCH OdMs and routes results via routing.chain.
+ * All data from filesystem, zero network.
+ */
+
+import { readdirSync, readFileSync, existsSync, statSync, unlinkSync, appendFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { emitKeypressEvents } from 'node:readline';
+import { style } from './colors.js';
+import { titledBox } from './box.js';
+import { readRegistry, getLanes } from '../../lib/core/registry.js';
+import { launchHeadless, buildDispatchPrompt } from '../kairos/agent-runner.js';
+import { createDispatchTransaction } from '../kairos/dispatcher-router.js';
+import { debug } from '../core/logger.js';
+import { listOdm, inspectOdm, setOdmStatus, assignOdm } from '../core/odm.js';
+import { pushEvent, EVENT_TYPES } from '../kairos/event-bus.js';
+
+// ---------------------------------------------------------------------------
+// States
+// ---------------------------------------------------------------------------
+
+export const STATES = {
+  IDLE: 'IDLE',
+  DISPATCH_ACTIVE: 'DISPATCH_ACTIVE',
+  MULTI_DISPATCH: 'MULTI_DISPATCH',
+  ESCALATION: 'ESCALATION',
+  DELIVERY: 'DELIVERY',
+};
+
+// ---------------------------------------------------------------------------
+// Data loaders (filesystem)
+// ---------------------------------------------------------------------------
+
+function readJsonDir(dir) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter(f => f.endsWith('.json'))
+    .map(f => {
+      try {
+        const data = JSON.parse(readFileSync(join(dir, f), 'utf-8'));
+        return { file: f, ...data };
+      } catch (e) { debug(`readJsonDir ${f}: ${e.message}`); return null; }
+    })
+    .filter(Boolean);
+}
+
+function readLogTail(logPath, lines = 5) {
+  if (!existsSync(logPath)) return [];
+  try {
+    const content = readFileSync(logPath, 'utf-8');
+    return content.split('\n').filter(Boolean).slice(-lines);
+  } catch (e) { debug(`readLogTail: ${e.message}`); return []; }
+}
+
+// ---------------------------------------------------------------------------
+// detectState — determine current orchestration state
+// ---------------------------------------------------------------------------
+
+export function detectState(root) {
+  const kairosDir = join(root, '.nemesis', 'kairos');
+  const pending = readJsonDir(join(kairosDir, 'pending-dispatch'));
+  const results = readJsonDir(join(kairosDir, 'dispatch-results'));
+  const escalations = readJsonDir(join(kairosDir, 'escalations'));
+  const events = readJsonDir(join(kairosDir, 'events'));
+
+  if (escalations.length > 0) {
+    return { state: STATES.ESCALATION, pending, results, escalations, events };
+  }
+  if (pending.length > 1) {
+    return { state: STATES.MULTI_DISPATCH, pending, results, escalations, events };
+  }
+  if (pending.length === 1) {
+    return { state: STATES.DISPATCH_ACTIVE, pending, results, escalations, events };
+  }
+  if (results.length > 0) {
+    return { state: STATES.DELIVERY, pending, results, escalations, events };
+  }
+  return { state: STATES.IDLE, pending, results, escalations, events };
+}
+
+// ---------------------------------------------------------------------------
+// checkAgentActivity — probe PID + log for liveness
+// ---------------------------------------------------------------------------
+
+export function checkAgentActivity(dispatchEntry, root) {
+  const pid = dispatchEntry.pid;
+  let alive = false;
+  if (pid) {
+    try { process.kill(pid, 0); alive = true; } catch { alive = false; }
+  }
+
+  const logFile = dispatchEntry.file?.replace('.json', '.log');
+  const logPath = logFile
+    ? join(root, '.nemesis', 'kairos', 'pending-dispatch', logFile)
+    : null;
+  const logLines = logPath ? readLogTail(logPath) : [];
+
+  let status = 'dead';
+  if (alive) {
+    status = 'active';
+  } else if (logLines.length > 0) {
+    // Check if log was written recently (within 60s)
+    if (logPath && existsSync(logPath)) {
+      const stat = statSync(logPath);
+      const ageMs = Date.now() - stat.mtimeMs;
+      status = ageMs < 60_000 ? 'active' : 'silent';
+    }
+  }
+
+  return { alive, status, logLines, pid };
+}
+
+// ---------------------------------------------------------------------------
+// Relative time
+// ---------------------------------------------------------------------------
+
+export function relativeTime(isoString) {
+  if (!isoString) return '';
+  const diff = Date.now() - new Date(isoString).getTime();
+  if (diff < 0) return 'maintenant';
+  const secs = Math.floor(diff / 1000);
+  if (secs < 60) return `il y a ${secs}s`;
+  const mins = Math.floor(secs / 60);
+  if (mins < 60) return `il y a ${mins}m`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `il y a ${hours}h`;
+  const days = Math.floor(hours / 24);
+  return `il y a ${days}j`;
+}
+
+// ---------------------------------------------------------------------------
+// Render functions (one per state)
+// ---------------------------------------------------------------------------
+
+function renderIdle(data, registry) {
+  const lanes = registry ? getLanes(registry) : [];
+  const lines = [
+    `${style.dim('Aucun dispatch en cours.')}`,
+    '',
+    `Agents enregistres : ${lanes.length}`,
+  ];
+  if (data.results.length > 0) {
+    lines.push(`Resultats disponibles : ${data.results.length}`);
+  }
+  lines.push('');
+  lines.push(style.dim('Les OdMs READY_TO_DISPATCH sont dispatches automatiquement.'));
+  return titledBox('Orchestration \u2014 IDLE', lines, { border: style.dim });
+}
+
+function renderDispatchActive(data, registry, root) {
+  const d = data.pending[0];
+  const activity = checkAgentActivity(d, root);
+
+  const statusIcon = activity.status === 'active'
+    ? style.green('\u25CF')
+    : activity.status === 'silent'
+      ? style.yellow('\u25CF')
+      : style.red('\u25CF');
+
+  const agentLabel = d.to || d.agent || d.agentName || '?';
+  const txnLabel = d.txnId || d.txn_id || d.file?.replace('.json', '') || '';
+  const timeLabel = d.created_at || d.dispatched_at || d.launchedAt;
+
+  const lines = [
+    `Agent    : ${style.bold(agentLabel)}  ${statusIcon} ${activity.status}`,
+    `OdM      : ${d.odmId || d.odm_id || 'N/A'}`,
+    `TXN      : ${style.dim(txnLabel)}`,
+    `PID      : ${activity.pid || 'N/A'}`,
+    `Demarre  : ${relativeTime(timeLabel)}`,
+    '',
+  ];
+
+  // OdM steps if available
+  if (d.steps && Array.isArray(d.steps)) {
+    lines.push(style.bold('Etapes :'));
+    for (const step of d.steps) {
+      const icon = step.status === 'done' ? style.green('\u2713') : '\u25CB';
+      lines.push(`  ${icon} ${step.label || step.name || '?'}`);
+    }
+    lines.push('');
+  }
+
+  // Last log lines
+  if (activity.logLines.length > 0) {
+    lines.push(style.bold('Derniere activite :'));
+    for (const line of activity.logLines.slice(-3)) {
+      lines.push(`  ${style.dim(line)}`);
+    }
+  }
+
+  return titledBox('Orchestration \u2014 DISPATCH ACTIF', lines, { border: style.nemesisAccent });
+}
+
+function renderMultiDispatch(data, registry, root) {
+  const lines = [`${data.pending.length} dispatches en cours`, ''];
+
+  for (const d of data.pending) {
+    const activity = checkAgentActivity(d, root);
+    const statusIcon = activity.status === 'active'
+      ? style.green('\u25CF')
+      : activity.status === 'silent'
+        ? style.yellow('\u25CF')
+        : style.red('\u25CF');
+
+    lines.push(`${statusIcon} ${style.bold(d.to || d.agent || d.agentName || '?')}  \u2014  OdM ${d.odmId || d.odm_id || 'N/A'}  ${relativeTime(d.created_at || d.dispatched_at || d.launchedAt)}`);
+  }
+
+  return titledBox('Orchestration \u2014 MULTI-DISPATCH', lines, { border: style.nemesisAccent });
+}
+
+function renderEscalation(data) {
+  const esc = data.escalations[0];
+  const lines = [
+    `${style.red('\u26A0')} ${style.bold('ESCALADE')}`,
+    '',
+    `Agent    : ${style.bold(esc.from || esc.agent || '?')}`,
+    `Type     : ${esc.type || esc.escalation_type || 'unknown'}`,
+    `Message  : ${esc.message || esc.reason || '(pas de message)'}`,
+    `Date     : ${relativeTime(esc.created_at || esc.timestamp)}`,
+  ];
+
+  if (data.escalations.length > 1) {
+    lines.push('');
+    lines.push(style.dim(`+ ${data.escalations.length - 1} autre(s) escalade(s)`));
+  }
+
+  return titledBox('Orchestration \u2014 ESCALADE', lines, { border: style.red });
+}
+
+function renderDelivery(data) {
+  const lines = [`${data.results.length} resultat(s) disponible(s)`, ''];
+
+  for (const r of data.results.slice(0, 5)) {
+    // Consider result successful if: explicit success flag, or response exists (agent delivered something)
+    const isSuccess = r.status === 'success' || r.success || (r.response && r.exitCode !== 1);
+    const icon = isSuccess ? style.green('\u2713') : style.red('\u2717');
+    const agentLabel = r.from || r.agent || r.agentName || '?';
+    lines.push(`${icon} ${style.bold(agentLabel)}  \u2014  OdM ${r.odmId || r.odm_id || 'N/A'}  ${relativeTime(r.completed_at || r.finishedAt || r.created_at)}`);
+  }
+
+  if (data.results.length > 5) {
+    lines.push(style.dim(`  + ${data.results.length - 5} de plus`));
+  }
+
+  return titledBox('Orchestration \u2014 LIVRAISON', lines, { border: style.green });
+}
+
+// ---------------------------------------------------------------------------
+// renderDashboard — single frame
+// ---------------------------------------------------------------------------
+
+export function renderDashboard(root, _opts = {}) {
+  const hcmDir = join(root, '.nemesis', 'HCM');
+  let registry = null;
+  if (existsSync(join(hcmDir, 'project'))) {
+    registry = readRegistry(hcmDir);
+  }
+
+  const data = detectState(root);
+  let output;
+
+  switch (data.state) {
+    case STATES.ESCALATION: output = renderEscalation(data); break;
+    case STATES.MULTI_DISPATCH: output = renderMultiDispatch(data, registry, root); break;
+    case STATES.DISPATCH_ACTIVE: output = renderDispatchActive(data, registry, root); break;
+    case STATES.DELIVERY: output = renderDelivery(data); break;
+    default: output = renderIdle(data, registry); break;
+  }
+
+  return output;
+}
+
+// ---------------------------------------------------------------------------
+// Orchestrator daemon — dispatch + routing + Leader notifications
+// ---------------------------------------------------------------------------
+
+function orchLog(msg) {
+  try { appendFileSync('/tmp/nemesis-orch.log', `[${new Date().toISOString()}] ${msg}\n`); } catch {}
+}
+
+function notifyLeader(root, leader, payload) {
+  try {
+    pushEvent(root, {
+      target_agent_id: leader.id || leader.name,
+      event_type: EVENT_TYPES.DISPATCH_RESULT,
+      source_agent_id: 'orchestrator',
+      priority: 'HIGH',
+      payload,
+    });
+  } catch (e) { debug(`notifyLeader: ${e.message}`); }
+}
+
+/**
+ * One orchestration cycle: dispatch READY_TO_DISPATCH OdMs + route results via chain.
+ * Returns an array of action strings for display.
+ * @param {string} root — project root
+ * @returns {Promise<string[]>}
+ */
+export async function orchestrate(root) {
+  const hcmDir = join(root, '.nemesis', 'HCM');
+  if (!existsSync(join(hcmDir, 'project'))) return [];
+
+  const registry = readRegistry(hcmDir);
+  if (!registry) return [];
+
+  const lanes = getLanes(registry);
+  const leader = lanes.find(l => l.leader);
+  const actions = [];
+
+  // --- S3: Auto-dispatch OdMs with READY_TO_DISPATCH ---
+  const odms = listOdm(hcmDir);
+  const readyOdms = odms.filter(o => o.status === 'READY_TO_DISPATCH');
+
+  for (const odmSummary of readyOdms) {
+    const assignee = odmSummary.assignee;
+    const agent = lanes.find(l =>
+      (l.name === assignee || l.id === assignee) && l.session_id
+    );
+    if (!agent) {
+      orchLog(`Skip ${odmSummary.id}: agent ${assignee} not found or no session`);
+      continue;
+    }
+
+    try {
+      setOdmStatus(odmSummary.id, 'DISPATCHING', hcmDir);
+
+      const { odm } = inspectOdm(odmSummary.id, hcmDir);
+      const prompt = buildDispatchPrompt(odm);
+      const missionId = odm.odm_meta?.mission_id || odm.odm_meta?.contract_id || '';
+      const projectId = odm.odm_meta?.project_id || '';
+
+      const txnResult = createDispatchTransaction({
+        from: 'orchestrator',
+        to: agent.name,
+        odmId: odmSummary.id,
+        missionId,
+        projectId,
+        root,
+      });
+
+      await launchHeadless(agent, prompt, {
+        txnId: txnResult.txnId,
+        odmId: odmSummary.id,
+        missionId,
+        projectId,
+        root,
+      });
+
+      setOdmStatus(odmSummary.id, 'ASSIGNED', hcmDir);
+
+      const action = `Dispatch ${odmSummary.id} → ${agent.name}`;
+      actions.push(action);
+      orchLog(action);
+
+      // S5: Notify Leader
+      if (leader) {
+        notifyLeader(root, leader, {
+          summary: action,
+          odmId: odmSummary.id,
+          agent_from: 'orchestrator',
+          agent_to: agent.name,
+        });
+      }
+    } catch (err) {
+      // Revert on error: DISPATCHING → READY_TO_DISPATCH
+      try { setOdmStatus(odmSummary.id, 'READY_TO_DISPATCH', hcmDir); } catch (e) { orchLog(`revert status ${odmSummary.id}: ${e.message}`); }
+      const action = `ERREUR ${odmSummary.id}: ${err.message}`;
+      actions.push(action);
+      orchLog(action);
+    }
+  }
+
+  // --- S4: Route dispatch results via routing.chain ---
+  // Read results WITHOUT consuming — only delete after successful routing
+  const resultsDir = join(root, '.nemesis', 'kairos', 'dispatch-results');
+  const resultFiles = existsSync(resultsDir)
+    ? readdirSync(resultsDir).filter(f => f.endsWith('.json'))
+    : [];
+
+  for (const file of resultFiles) {
+    const filepath = join(resultsDir, file);
+    let result;
+    try {
+      result = JSON.parse(readFileSync(filepath, 'utf-8'));
+    } catch (e) { debug(`orchestrate result parse ${file}: ${e.message}`); continue; }
+
+    const _txnId = file.replace('.json', '');
+    const odmId = result.odmId;
+    if (!odmId) { try { unlinkSync(filepath); } catch {} continue; }
+
+    try {
+      const { odm } = inspectOdm(odmId, hcmDir);
+      const chain = odm.odm_payload?.cadrage?.routing?.chain;
+      const currentAssignee = odm.odm_meta?.assigned_to?.actor_id;
+
+      if (!chain || chain.length === 0) {
+        // No chain → mark completed
+        try { setOdmStatus(odmId, 'COMPLETED', hcmDir); } catch (e) { orchLog(`setOdmStatus ${odmId}: ${e.message}`); }
+        const action = `Completed ${odmId} (no chain)`;
+        actions.push(action);
+        orchLog(action);
+
+        if (leader) {
+          notifyLeader(root, leader, {
+            summary: action,
+            odmId,
+            agent_from: currentAssignee || result.agentName,
+            agent_to: 'COMPLETED',
+          });
+        }
+      } else {
+        // Find current position in chain
+        const currentIdx = chain.indexOf(currentAssignee);
+        const nextIdx = currentIdx + 1;
+
+        if (nextIdx < chain.length) {
+          // Route to next agent in chain
+          const nextAgent = chain[nextIdx];
+          assignOdm(odmId, nextAgent, hcmDir);
+          setOdmStatus(odmId, 'READY_TO_DISPATCH', hcmDir);
+
+          const action = `Route ${odmId}: ${currentAssignee} → ${nextAgent}`;
+          actions.push(action);
+          orchLog(action);
+
+          if (leader) {
+            notifyLeader(root, leader, {
+              summary: action,
+              odmId,
+              agent_from: currentAssignee,
+              agent_to: nextAgent,
+            });
+          }
+        } else {
+          // End of chain → completed
+          try { setOdmStatus(odmId, 'COMPLETED', hcmDir); } catch (e) { orchLog(`setOdmStatus ${odmId}: ${e.message}`); }
+          const action = `Completed ${odmId} (chain done)`;
+          actions.push(action);
+          orchLog(action);
+
+          if (leader) {
+            notifyLeader(root, leader, {
+              summary: action,
+              odmId,
+              agent_from: currentAssignee,
+              agent_to: 'COMPLETED',
+            });
+          }
+        }
+      }
+
+      // Only consume AFTER successful routing
+      try { unlinkSync(filepath); } catch (e) { debug(`unlinkSync result ${file}: ${e.message}`); }
+    } catch (err) {
+      // DO NOT delete — result preserved for retry
+      orchLog(`Route error ${odmId}: ${err.message}`);
+    }
+  }
+
+  return actions;
+}
+
+// ---------------------------------------------------------------------------
+// startDashboard — poll loop with keypress handler + orchestrator daemon
+// ---------------------------------------------------------------------------
+
+export function startDashboard(root, opts = {}) {
+  const { pollInterval = 2000 } = opts;
+  const { stdin, stdout } = process;
+
+  let lastOutput = '';
+  let running = true;
+  let orchestrating = false;
+  const recentActions = [];
+
+  function render() {
+    const output = renderDashboard(root);
+    // Build full output including orchestrator actions
+    const actionLines = recentActions.slice(-5).map(a => `  ${style.dim('• ' + a)}`).join('\n');
+    const fullOutput = output + (actionLines ? '\n' + actionLines : '');
+
+    if (fullOutput === lastOutput) return;
+
+    // Clear screen and move cursor to top
+    stdout.write('\x1b[2J\x1b[H');
+    stdout.write(output);
+    stdout.write('\n');
+
+    // Display recent orchestrator actions
+    if (recentActions.length > 0) {
+      stdout.write(`\n  ${style.bold('Orchestrateur :')}\n`);
+      for (const action of recentActions.slice(-5)) {
+        stdout.write(`    ${style.dim('• ' + action)}\n`);
+      }
+    }
+
+    const data = detectState(root);
+    // Action bar
+    const actions = [];
+    if (data.state === STATES.DISPATCH_ACTIVE || data.state === STATES.MULTI_DISPATCH) {
+      actions.push('r actualiser');
+    }
+    actions.push('q quitter');
+    stdout.write(`\n  ${style.dim(actions.join('  |  '))}\n`);
+
+    lastOutput = fullOutput;
+  }
+
+  // Initial render
+  render();
+
+  // Poll interval with orchestrator
+  const timer = setInterval(async () => {
+    if (!running) return;
+    // Orchestrate: dispatch + route (with guard against overlapping)
+    if (!orchestrating) {
+      orchestrating = true;
+      try {
+        const actions = await orchestrate(root);
+        if (actions.length > 0) {
+          recentActions.push(...actions);
+          // Keep only last 20 actions
+          if (recentActions.length > 20) recentActions.splice(0, recentActions.length - 20);
+        }
+      } catch (err) {
+        orchLog(`orchestrate error: ${err.message}`);
+      }
+      orchestrating = false;
+    }
+    render();
+  }, pollInterval);
+
+  // Setup keypress
+  if (stdin.isTTY) {
+    emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+  }
+
+  function cleanup() {
+    running = false;
+    clearInterval(timer);
+    if (stdin.isTTY) {
+      stdin.removeListener('keypress', onKey);
+      stdin.setRawMode(false);
+      stdin.pause();
+    }
+    // Restore cursor
+    stdout.write('\x1b[?25h');
+  }
+
+  function onKey(ch, key) {
+    if (!key) return;
+    if (key.ctrl && key.name === 'c') {
+      cleanup();
+      process.exit(0);
+    }
+    if (ch === 'q') {
+      cleanup();
+      return;
+    }
+    if (ch === 'r') {
+      lastOutput = '';
+      render();
+    }
+  }
+
+  if (stdin.isTTY) {
+    stdin.on('keypress', onKey);
+  }
+
+  // Cleanup on signals
+  const onSignal = () => { cleanup(); process.exit(0); };
+  process.on('SIGINT', onSignal);
+  process.on('SIGTERM', onSignal);
+
+  return { stop: cleanup };
+}

package/lib/ui/error-hints.js

@@ -0,0 +1,49 @@
+/**
+ * Error hints — structured error messages with actionable guidance.
+ */
+
+import { style } from './colors.js';
+
+export const COMMON_HINTS = {
+  REGISTRY_NOT_FOUND: {
+    hint: 'Le registre projet est introuvable.',
+    command: 'nemesis init',
+  },
+  AGENT_NOT_FOUND: {
+    hint: 'Cet agent n\'existe pas dans le registre.',
+    command: 'nemesis team list',
+  },
+  ODM_NOT_FOUND: {
+    hint: 'Aucun OdM correspondant.',
+    command: 'nemesis odm init',
+  },
+  HCM_UNREACHABLE: {
+    hint: 'Le HCM est injoignable.',
+    command: 'nemesis auth login',
+  },
+  NO_AGENTS: {
+    hint: 'Aucun agent enregistre dans le projet.',
+    command: 'nemesis team add',
+  },
+  AGENT_NO_SESSION: {
+    hint: 'Cet agent n\'a pas de session active.',
+    command: 'nemesis team panneau <agent>',
+  },
+};
+
+/**
+ * Format an error with optional hint and suggested command.
+ * @param {string} message — main error message
+ * @param {{ hint?: string, command?: string }} opts
+ * @returns {string} formatted multi-line error string
+ */
+export function formatError(message, opts = {}) {
+  const lines = [`  ${style.red('\u2717')} ${message}`];
+  if (opts.hint) {
+    lines.push(`  ${style.dim('\u2192')} ${opts.hint}`);
+  }
+  if (opts.command) {
+    lines.push(`  ${style.dim('\u2192 Essayez :')} ${style.bold(opts.command)}`);
+  }
+  return lines.join('\n');
+}

package/lib/ui/format.js

@@ -0,0 +1,61 @@
+/**
+ * Output formatter — JSON / text / yaml based on --format flag.
+ */
+
+export function formatOutput(data, format = 'text') {
+  switch (format) {
+    case 'json':
+      return JSON.stringify(data, null, 2);
+    case 'yaml':
+      return toYaml(data);
+    case 'text':
+    default:
+      if (typeof data === 'string') return data;
+      return JSON.stringify(data, null, 2);
+  }
+}
+
+function toYaml(obj, indent = 0) {
+  const prefix = '  '.repeat(indent);
+  const lines = [];
+
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      if (typeof item === 'object' && item !== null) {
+        lines.push(`${prefix}-`);
+        lines.push(toYaml(item, indent + 1));
+      } else {
+        lines.push(`${prefix}- ${formatScalar(item)}`);
+      }
+    }
+  } else if (typeof obj === 'object' && obj !== null) {
+    for (const [key, val] of Object.entries(obj)) {
+      if (val === null || val === undefined) {
+        lines.push(`${prefix}${key}: null`);
+      } else if (typeof val === 'object') {
+        lines.push(`${prefix}${key}:`);
+        lines.push(toYaml(val, indent + 1));
+      } else {
+        lines.push(`${prefix}${key}: ${formatScalar(val)}`);
+      }
+    }
+  } else {
+    lines.push(`${prefix}${formatScalar(obj)}`);
+  }
+
+  return lines.join('\n');
+}
+
+function formatScalar(val) {
+  if (typeof val === 'string') {
+    if (val.includes('\n') || val.includes(':') || val.includes('#')) {
+      return `"${val.replace(/"/g, '\\"')}"`;
+    }
+    return val;
+  }
+  return String(val);
+}
+
+export function print(data, format = 'text') {
+  console.log(formatOutput(data, format));
+}