@mikado-ai/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,597 @@
+#!/usr/bin/env node
+import {
+  MikadoClient,
+  pollJob
+} from "./chunk-L27HHHAB.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/auth.ts
+import { createInterface } from "readline";
+import chalk2 from "chalk";
+
+// src/core/auth.ts
+import { homedir } from "os";
+import { join } from "path";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+function getConfigPath() {
+  return join(homedir(), ".mikado", "config.json");
+}
+function loadConfig() {
+  const envApiKey = process.env.MIKADO_API_KEY;
+  const envUrl = process.env.MIKADO_URL;
+  if (envApiKey && envUrl) {
+    return {
+      api_key: envApiKey,
+      base_url: envUrl
+    };
+  }
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    if (envApiKey && existsSync(configPath)) {
+      try {
+        const fileConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+        return {
+          api_key: envApiKey,
+          base_url: fileConfig.base_url || envUrl || "https://mikadoai.app"
+        };
+      } catch {
+      }
+    }
+    return null;
+  }
+  try {
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    return {
+      api_key: envApiKey || config.api_key,
+      base_url: envUrl || config.base_url
+    };
+  } catch (error) {
+    throw new Error(`Failed to read config file at ${configPath}: ${error}`);
+  }
+}
+function saveConfig(config) {
+  const configPath = getConfigPath();
+  const configDir = join(homedir(), ".mikado");
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true, mode: 448 });
+  }
+  writeFileSync(configPath, JSON.stringify(config, null, 2), { mode: 384 });
+}
+
+// src/output/human.ts
+import chalk from "chalk";
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = Math.floor(ms % 6e4 / 1e3);
+  return `${minutes}m ${seconds}s`;
+}
+function renderWhoami(response) {
+  console.log(chalk.green(`
+\u2713 Authenticated as "${response.organization_name}" (${response.key_prefix}...)`));
+  console.log(`  Key name: ${response.key_name}`);
+  console.log();
+}
+function renderJobStatus(job) {
+  const statusColors = {
+    PENDING: chalk.gray,
+    IN_PROGRESS: chalk.yellow,
+    SUCCESS: chalk.green,
+    FAILED: chalk.red,
+    RETRY: chalk.yellow,
+    CANCELLED: chalk.gray
+  };
+  const colorFn = statusColors[job.status] || chalk.white;
+  const statusIcon = job.status === "SUCCESS" ? "\u2713" : job.status === "FAILED" ? "\u2717" : "\u25D0";
+  console.log(`
+  Job:      ${job.job_id}`);
+  console.log(`  Status:   ${statusIcon} ${colorFn(job.status)}`);
+  if (job.elapsed_ms) {
+    console.log(`  Duration: ${formatDuration(job.elapsed_ms)}`);
+  }
+  if (job.entity_id) {
+    console.log(`  Conversation: ${job.entity_id}`);
+  }
+  if (job.error_message) {
+    console.log(`  Error:    ${chalk.red(job.error_message)}`);
+  }
+  if (job.conversation_summary) {
+    const s = job.conversation_summary;
+    console.log(`  Insights: ${s.insight_count} generated`);
+    if (s.sentiment) {
+      console.log(`  Sentiment: ${s.sentiment.toLowerCase()} (${s.sentiment_score?.toFixed(2) ?? "N/A"})`);
+    }
+    if (s.outcome) {
+      console.log(`  Outcome:  ${s.outcome}`);
+    }
+  }
+  console.log();
+}
+function renderSubmitResult(conversation) {
+  console.log(chalk.bold.green("\n\u2713 Processing Complete\n"));
+  const meta = [];
+  if (conversation.provider) meta.push(`Provider: ${conversation.provider.toLowerCase()}`);
+  if (conversation.analytics.duration_ms) meta.push(`Duration: ${formatDuration(conversation.analytics.duration_ms)}`);
+  if (conversation.analytics.turn_count) meta.push(`Turns: ${conversation.analytics.turn_count}`);
+  if (meta.length > 0) {
+    console.log(`  ${meta.join(" | ")}`);
+  }
+  if (conversation.analytics.sentiment) {
+    const score = conversation.analytics.sentiment_score?.toFixed(2) ?? "";
+    console.log(`  Sentiment: ${conversation.analytics.sentiment.toLowerCase()} (${score})`);
+  }
+  if (conversation.analytics.outcome_result) {
+    console.log(`  Outcome: ${conversation.analytics.outcome_result}`);
+  }
+  if (conversation.participants.length > 0) {
+    console.log(chalk.bold("\n  Participants:"));
+    conversation.participants.forEach((p) => {
+      const name = p.name || p.id;
+      const role = p.role ? ` (${p.role})` : "";
+      console.log(`    - ${name}${role} [${p.type}]`);
+    });
+  }
+  if (conversation.insights.length > 0) {
+    console.log(chalk.bold("\n  Insights:"));
+    conversation.insights.forEach((insight) => {
+      const name = insight.template_name || "Unnamed";
+      const scoreStr = insight.total_score != null ? ` \u2014 Score: ${insight.total_score}` : "";
+      const labels = insight.labels?.map((l) => l.value).join(", ");
+      const labelStr = labels ? ` (${labels})` : "";
+      console.log(`    ${chalk.cyan(name)}${scoreStr}${labelStr}`);
+      if (insight.summary) {
+        console.log(`      ${insight.summary}`);
+      }
+    });
+  }
+  if (conversation.processing.processing_time_ms) {
+    console.log(`
+  Processed in ${formatDuration(conversation.processing.processing_time_ms)}`);
+  }
+  console.log(`
+  Conversation: ${conversation.id}`);
+  console.log();
+}
+function renderCampaigns(response) {
+  if (response.campaigns.length === 0) {
+    console.log(chalk.gray("\n  No active campaigns found.\n"));
+    return;
+  }
+  console.log();
+  const idWidth = 10;
+  const nameWidth = Math.max(...response.campaigns.map((c) => c.name.length), 4) + 2;
+  const statusWidth = 10;
+  const templatesWidth = 10;
+  const convsWidth = 14;
+  console.log(
+    chalk.bold("  " + "ID".padEnd(idWidth)) + chalk.bold("Name".padEnd(nameWidth)) + chalk.bold("Status".padEnd(statusWidth)) + chalk.bold("Templates".padEnd(templatesWidth)) + chalk.bold("Conversations")
+  );
+  response.campaigns.forEach((c) => {
+    const statusColor = c.status === "ACTIVE" ? chalk.green : chalk.gray;
+    console.log(
+      `  ${c.short_id.padEnd(idWidth)}${chalk.cyan(c.name.padEnd(nameWidth))}${statusColor(c.status.padEnd(statusWidth))}${String(c.template_count).padEnd(templatesWidth)}${c.conversation_count}`
+    );
+  });
+  console.log();
+}
+
+// src/output/json.ts
+function outputJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function errorJson(message, code) {
+  const error = {
+    error: message,
+    ...code && { code }
+  };
+  console.error(JSON.stringify(error, null, 2));
+}
+
+// src/commands/auth.ts
+async function prompt(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function promptSecret(question) {
+  return new Promise((resolve) => {
+    process.stdout.write(question);
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.setEncoding("utf-8");
+    let input = "";
+    const onData = (chunk) => {
+      for (const char of chunk) {
+        if (char === "\n" || char === "\r" || char === "") {
+          stdin.removeListener("data", onData);
+          if (stdin.isTTY) {
+            stdin.setRawMode(wasRaw ?? false);
+          }
+          stdin.pause();
+          process.stdout.write("\n");
+          resolve(input);
+          return;
+        } else if (char === "") {
+          process.exit(1);
+        } else if (char === "\x7F" || char === "\b") {
+          if (input.length > 0) {
+            input = input.slice(0, -1);
+            process.stdout.write("\b \b");
+          }
+        } else {
+          input += char;
+          process.stdout.write("*");
+        }
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function authCommand(options) {
+  let apiKey = options.key;
+  let baseUrl = options.url;
+  if (!apiKey || !baseUrl) {
+    console.log(chalk2.bold("\nMikado AI CLI Authentication Setup\n"));
+    if (!apiKey) {
+      apiKey = await promptSecret("API Key: ");
+    }
+    if (!baseUrl) {
+      const defaultUrl = "https://mikadoai.app";
+      const urlInput = await prompt(`Base URL [${defaultUrl}]: `);
+      baseUrl = urlInput || defaultUrl;
+    }
+  }
+  if (!apiKey) {
+    if (options.json) {
+      errorJson("API key is required", "MISSING_API_KEY");
+    } else {
+      console.error(chalk2.red("Error: API key is required"));
+    }
+    process.exit(2);
+  }
+  if (!baseUrl) {
+    baseUrl = "https://mikadoai.app";
+  }
+  try {
+    const client = new MikadoClient({ apiKey, baseUrl });
+    const whoami = await client.whoami();
+    saveConfig({
+      api_key: apiKey,
+      base_url: baseUrl
+    });
+    if (options.json) {
+      outputJson({
+        success: true,
+        ...whoami
+      });
+    } else {
+      console.log(chalk2.green("\n\u2713 Authentication successful!"));
+      renderWhoami(whoami);
+      console.log(chalk2.gray(`Config saved to ~/.mikado/config.json`));
+    }
+  } catch (error) {
+    if (options.json) {
+      errorJson(error instanceof Error ? error.message : "Authentication failed", "AUTH_FAILED");
+    } else {
+      console.error(chalk2.red("\n\u2717 Authentication failed:"));
+      console.error(chalk2.red(`  ${error instanceof Error ? error.message : "Unknown error"}`));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/submit.ts
+import { readFileSync as readFileSync2 } from "fs";
+import chalk3 from "chalk";
+import ora from "ora";
+async function readInput(filePath) {
+  if (filePath === "-") {
+    return new Promise((resolve, reject) => {
+      let data = "";
+      process.stdin.setEncoding("utf-8");
+      process.stdin.on("data", (chunk) => {
+        data += chunk;
+      });
+      process.stdin.on("end", () => resolve(data));
+      process.stdin.on("error", reject);
+    });
+  } else {
+    return readFileSync2(filePath, "utf-8");
+  }
+}
+async function submitCommand(filePath, options) {
+  const config = loadConfig();
+  if (!config) {
+    if (options.json) {
+      errorJson("Not authenticated. Run: mikado auth", "NOT_AUTHENTICATED");
+    } else {
+      console.error(chalk3.red("Error: Not authenticated"));
+      console.error(chalk3.yellow("Run: mikado auth"));
+    }
+    process.exit(1);
+  }
+  const client = new MikadoClient({
+    apiKey: config.api_key,
+    baseUrl: config.base_url
+  });
+  let content;
+  try {
+    content = await readInput(filePath);
+  } catch (error) {
+    if (options.json) {
+      errorJson(
+        `Failed to read file: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "FILE_READ_ERROR"
+      );
+    } else {
+      console.error(chalk3.red("Error: Failed to read file"));
+      console.error(chalk3.red(`  ${error instanceof Error ? error.message : "Unknown error"}`));
+    }
+    process.exit(2);
+  }
+  if (!content || content.trim().length === 0) {
+    if (options.json) {
+      errorJson("File is empty", "EMPTY_FILE");
+    } else {
+      console.error(chalk3.red("Error: File is empty"));
+    }
+    process.exit(2);
+  }
+  let submitResult;
+  try {
+    submitResult = await client.submit(content, {
+      campaign: options.campaign,
+      filename: filePath !== "-" ? filePath : void 0
+    });
+  } catch (error) {
+    if (options.json) {
+      errorJson(
+        `Failed to submit: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "SUBMIT_FAILED"
+      );
+    } else {
+      console.error(chalk3.red("Error: Failed to submit transcript"));
+      console.error(chalk3.red(`  ${error instanceof Error ? error.message : "Unknown error"}`));
+    }
+    process.exit(1);
+  }
+  if (!options.wait) {
+    if (options.json) {
+      outputJson(submitResult);
+    } else {
+      console.log(chalk3.green("\u2713 Submitted successfully"));
+      console.log(`  Job ID:         ${submitResult.job_id}`);
+      console.log(`  Conversation:   ${submitResult.conversation_id}`);
+      console.log(`  Status:         ${submitResult.status}`);
+      console.log();
+      console.log(chalk3.gray("Check status with: mikado status " + submitResult.job_id));
+    }
+    return;
+  }
+  const spinner = options.json ? null : ora("Processing transcript...").start();
+  const timeoutMs = options.timeout ? options.timeout * 1e3 : 3e5;
+  try {
+    const finalStatus = await pollJob(client, submitResult.job_id, {
+      timeout: timeoutMs,
+      onUpdate: (status) => {
+        if (spinner) {
+          const statusText = status.status.toLowerCase();
+          spinner.text = `Processing transcript... (${statusText})`;
+        }
+      }
+    });
+    if (spinner) {
+      spinner.stop();
+    }
+    if (finalStatus.status === "FAILED") {
+      if (options.json) {
+        errorJson(
+          finalStatus.error_message || "Processing failed",
+          "PROCESSING_FAILED"
+        );
+      } else {
+        console.error(chalk3.red("\n\u2717 Processing failed:"));
+        console.error(chalk3.red(`  ${finalStatus.error_message || "Unknown error"}`));
+      }
+      process.exit(3);
+    }
+    const conversation = await client.getConversation(submitResult.conversation_id);
+    if (options.json) {
+      outputJson(conversation);
+    } else {
+      renderSubmitResult(conversation);
+    }
+  } catch (error) {
+    if (spinner) {
+      spinner.fail("Processing failed");
+    }
+    if (error instanceof Error && error.message.includes("timed out")) {
+      if (options.json) {
+        errorJson("Processing timed out", "TIMEOUT");
+      } else {
+        console.error(chalk3.red("\n\u2717 Processing timed out"));
+        console.error(chalk3.yellow(`  Check status later with: mikado status ${submitResult.job_id}`));
+      }
+      process.exit(4);
+    } else {
+      if (options.json) {
+        errorJson(
+          error instanceof Error ? error.message : "Unknown error",
+          "POLLING_FAILED"
+        );
+      } else {
+        console.error(chalk3.red("\n\u2717 Error:"));
+        console.error(chalk3.red(`  ${error instanceof Error ? error.message : "Unknown error"}`));
+      }
+      process.exit(1);
+    }
+  }
+}
+
+// src/commands/status.ts
+import chalk4 from "chalk";
+async function statusCommand(jobId, options) {
+  const config = loadConfig();
+  if (!config) {
+    if (options.json) {
+      errorJson("Not authenticated. Run: mikado auth", "NOT_AUTHENTICATED");
+    } else {
+      console.error(chalk4.red("Error: Not authenticated"));
+      console.error(chalk4.yellow("Run: mikado auth"));
+    }
+    process.exit(1);
+  }
+  const client = new MikadoClient({
+    apiKey: config.api_key,
+    baseUrl: config.base_url
+  });
+  try {
+    const status = await client.getJobStatus(jobId);
+    if (options.json) {
+      outputJson(status);
+    } else {
+      renderJobStatus(status);
+    }
+  } catch (error) {
+    if (options.json) {
+      errorJson(
+        error instanceof Error ? error.message : "Failed to fetch job status",
+        "STATUS_FAILED"
+      );
+    } else {
+      console.error(chalk4.red("Error: Failed to fetch job status"));
+      console.error(chalk4.red(`  ${error instanceof Error ? error.message : "Unknown error"}`));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/result.ts
+import chalk5 from "chalk";
+async function resultCommand(conversationId, options) {
+  const config = loadConfig();
+  if (!config) {
+    if (options.json) {
+      errorJson("Not authenticated. Run: mikado auth", "NOT_AUTHENTICATED");
+    } else {
+      console.error(chalk5.red("Error: Not authenticated"));
+      console.error(chalk5.yellow("Run: mikado auth"));
+    }
+    process.exit(1);
+  }
+  const client = new MikadoClient({
+    apiKey: config.api_key,
+    baseUrl: config.base_url
+  });
+  try {
+    const conversation = await client.getConversation(conversationId);
+    if (options.json) {
+      outputJson(conversation);
+    } else {
+      renderSubmitResult(conversation);
+    }
+  } catch (error) {
+    if (options.json) {
+      errorJson(
+        error instanceof Error ? error.message : "Failed to fetch conversation",
+        "RESULT_FAILED"
+      );
+    } else {
+      console.error(chalk5.red("Error: Failed to fetch conversation"));
+      console.error(chalk5.red(`  ${error instanceof Error ? error.message : "Unknown error"}`));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/campaigns.ts
+import chalk6 from "chalk";
+async function campaignsCommand(options) {
+  const config = loadConfig();
+  if (!config) {
+    if (options.json) {
+      errorJson("Not authenticated. Run: mikado auth", "NOT_AUTHENTICATED");
+    } else {
+      console.error(chalk6.red("Error: Not authenticated"));
+      console.error(chalk6.yellow("Run: mikado auth"));
+    }
+    process.exit(1);
+  }
+  const client = new MikadoClient({
+    apiKey: config.api_key,
+    baseUrl: config.base_url
+  });
+  try {
+    const campaigns = await client.listCampaigns();
+    if (options.json) {
+      outputJson(campaigns);
+    } else {
+      renderCampaigns(campaigns);
+    }
+  } catch (error) {
+    if (options.json) {
+      errorJson(
+        error instanceof Error ? error.message : "Failed to fetch campaigns",
+        "CAMPAIGNS_FAILED"
+      );
+    } else {
+      console.error(chalk6.red("Error: Failed to fetch campaigns"));
+      console.error(chalk6.red(`  ${error instanceof Error ? error.message : "Unknown error"}`));
+    }
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("mikado").description("Mikado CLI - conversation data extraction").version("0.1.0");
+program.option("--json", "Output results in JSON format");
+program.command("auth").description("Authenticate with Mikado API").option("--key <api-key>", "API key (or use MIKADO_API_KEY env var)").option("--url <base-url>", "Base URL (default: https://mikadoai.app)").action(async (options) => {
+  await authCommand({
+    key: options.key,
+    url: options.url,
+    json: program.opts().json
+  });
+});
+program.command("submit <file>").description('Submit a transcript file for processing (use "-" to read from stdin)').option("-c, --campaign <id>", "Target campaign (short_id, UUID, or name)").option("--no-wait", "Do not wait for processing to complete").option("--timeout <seconds>", "Polling timeout in seconds (default: 300)", parseInt).action(async (file, options) => {
+  await submitCommand(file, {
+    campaign: options.campaign,
+    wait: options.wait,
+    timeout: options.timeout,
+    json: program.opts().json
+  });
+});
+program.command("status <job-id>").description("Check the status of a processing job").action(async (jobId) => {
+  await statusCommand(jobId, {
+    json: program.opts().json
+  });
+});
+program.command("result <conversation-id>").description("Get full results for a completed conversation").action(async (conversationId) => {
+  await resultCommand(conversationId, {
+    json: program.opts().json
+  });
+});
+program.command("campaigns").description("List available campaigns").action(async () => {
+  await campaignsCommand({
+    json: program.opts().json
+  });
+});
+program.command("mcp").description("Start MCP stdio server (requires MIKADO_API_KEY env var)").action(async () => {
+  const { startMcpServer } = await import("./mcp.js");
+  await startMcpServer();
+});
+program.parse();

package/dist/mcp.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+declare function startMcpServer(): Promise<void>;
+
+export { startMcpServer };