@chanl-ai/cli 2.0.1

package/dist/commands/calls.js

@@ -0,0 +1,719 @@
+import { Command } from "commander";
+import ora from "ora";
+import chalk from "chalk";
+import * as fs from "fs";
+import { createSdk } from "../utils/sdk-factory.js";
+import {
+  printError,
+  printInfo,
+  printBlank,
+  printSimpleTable,
+  printLabel,
+  isJsonOutput,
+  printJson,
+  formatDate,
+  printSuccess,
+  printWarning
+} from "../utils/output.js";
+function createCallsCommand() {
+  const calls = new Command("calls").description("Import, view, and analyze call recordings").addHelpText(
+    "after",
+    `
+What are Calls?
+  Calls are voice recordings from your AI agents (via VAPI, Twilio, etc.)
+  or imported transcripts/recordings. Each call can be analyzed with
+  scorecards to evaluate agent performance.
+
+Quick Start:
+  $ chanl calls import --transcript "..."      # Import a call
+  $ chanl calls list                           # List recent calls
+  $ chanl calls list --external-ref orderId=123  # Filter by external ref
+  $ chanl calls get <id>                       # View call details
+  $ chanl calls analyze <id>                   # Trigger scorecard analysis
+  $ chanl calls delete <id>                    # Delete a call
+
+Import Workflow:
+  1. Import a call with transcript, audio URL, or S3
+  2. Optionally specify analysis fields and scorecard
+  3. Webhook notifies when analysis is complete
+  4. View results with 'analysis <id>'
+
+Analysis Workflow:
+  1. List calls to find one to analyze
+  2. Trigger analysis with 'analyze <id>'
+  3. View results with 'analysis <id>'
+  4. Check transcript with 'transcript <id>'`
+  );
+  calls.command("list").description("List calls").option("-s, --status <status>", "Filter by status (pending, in_progress, completed, failed)").option("-a, --agent <agentId>", "Filter by agent ID").option("-d, --direction <direction>", "Filter by direction (inbound, outbound)").option("--customer <name>", "Filter by customer name").option("-e, --external-ref <key=value>", "Filter by external reference (repeatable)", collectExternalRefs, {}).option("-l, --limit <number>", "Number of items per page", "20").option("-p, --page <number>", "Page number", "1").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl calls list                           # List recent calls
+  $ chanl calls list --status completed        # Only completed calls
+  $ chanl calls list --agent abc123            # Filter by agent
+  $ chanl calls list --external-ref orderId=ORDER-123   # Filter by external ref
+  $ chanl calls list -e orderId=123 -e customerId=456   # Multiple external refs
+  $ chanl calls list --json                    # Output as JSON`
+  ).action(handleCallsList);
+  calls.command("get <id>").description("Get call details").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl calls get abc123                # Get call details
+  $ chanl calls get abc123 --json         # Output as JSON`
+  ).action(handleCallsGet);
+  calls.command("analyze <id>").description("Trigger scorecard analysis for a call").option("-s, --scorecard <scorecardId>", "Specific scorecard to use").option("-f, --force", "Force re-analysis even if already done").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl calls analyze abc123                    # Analyze with default scorecard
+  $ chanl calls analyze abc123 --scorecard xyz   # Use specific scorecard
+  $ chanl calls analyze abc123 --force            # Force re-analysis`
+  ).action(handleCallsAnalyze);
+  calls.command("analysis <id>").description("View scorecard analysis results for a call").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl calls analysis abc123           # View analysis results
+  $ chanl calls analysis abc123 --json    # Output as JSON`
+  ).action(handleCallsAnalysis);
+  calls.command("transcript <id>").description("View call transcript").option("--full", "Show full transcript text instead of segments").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl calls transcript abc123         # View transcript segments
+  $ chanl calls transcript abc123 --full  # Show full text
+  $ chanl calls transcript abc123 --json  # Output as JSON`
+  ).action(handleCallsTranscript);
+  calls.command("metrics <id>").description("View call metrics").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl calls metrics abc123            # View call metrics
+  $ chanl calls metrics abc123 --json     # Output as JSON`
+  ).action(handleCallsMetrics);
+  calls.command("import").description("Import a call from transcript, audio URL, or S3").option("-t, --transcript <text>", "Transcript text (plain text or JSON segments)").option("-f, --file <path>", "JSON file with import options").option("--audio-url <url>", "Audio file URL to transcribe").option("--audio-id <id>", "Pre-uploaded audio ID").option("--bucket <name>", "S3 bucket name").option("--key <key>", "S3 object key").option("--region <region>", "AWS region").option("--customer-name <name>", "Customer name").option("--agent-name <name>", "Agent name").option("--direction <dir>", "Call direction (inbound, outbound)").option("-e, --external-ref <key=value>", "External reference (repeatable)", collectExternalRefs, {}).option("--analysis-fields <fields>", "Comma-separated analysis fields").option("--scorecard <id>", "Scorecard ID to evaluate against").option("--webhook-url <url>", "Webhook URL for completion notification").addHelpText(
+    "after",
+    `
+Import Modes (at least one required):
+  --transcript    Import with existing transcript text
+  --audio-url     Import from audio URL (will be transcribed)
+  --audio-id      Import using pre-uploaded audio
+  --bucket/key    Import from S3 bucket
+  --file          Import from JSON file containing all options
+
+Analysis Fields:
+  sentiment, topics, keywords, quality, coaching, predictions,
+  speakers, upsell, metrics, extraction, followups
+
+Examples:
+  # Import with transcript
+  $ chanl calls import --transcript "Agent: Hello! Customer: Hi..."
+
+  # Import with customer metadata
+  $ chanl calls import --transcript "..." --customer-name "John" -e orderId=ORD-123
+
+  # Import from audio URL
+  $ chanl calls import --audio-url "https://example.com/call.mp3"
+
+  # Import from JSON file
+  $ chanl calls import -f import-data.json
+
+  # Import with analysis options
+  $ chanl calls import -t "..." --scorecard abc123 --analysis-fields sentiment,quality`
+  ).action(handleCallsImport);
+  calls.command("delete <id>").description("Delete a call").option("-y, --yes", "Skip confirmation prompt").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl calls delete abc123             # Delete with confirmation
+  $ chanl calls delete abc123 --yes       # Delete without confirmation`
+  ).action(handleCallsDelete);
+  calls.command("bulk-delete").description("Delete multiple calls").option("--ids <ids>", "Comma-separated call IDs to delete").option("-f, --file <path>", "File with call IDs (one per line)").option("-y, --yes", "Skip confirmation prompt").option("--keep-files", "Do not delete associated storage files").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl calls bulk-delete --ids id1,id2,id3     # Delete by IDs
+  $ chanl calls bulk-delete -f call-ids.txt       # Delete from file
+  $ chanl calls bulk-delete --ids id1,id2 --yes   # Skip confirmation`
+  ).action(handleCallsBulkDelete);
+  return calls;
+}
+function formatStatus(status) {
+  switch (status) {
+    case "completed":
+      return chalk.green("completed");
+    case "in_progress":
+      return chalk.cyan("in_progress");
+    case "pending":
+      return chalk.blue("pending");
+    case "failed":
+      return chalk.red("failed");
+    default:
+      return chalk.gray(status || "unknown");
+  }
+}
+function formatScore(score) {
+  if (score === void 0 || score === null) return "-";
+  if (score >= 80) return chalk.green(`${score}%`);
+  if (score >= 60) return chalk.yellow(`${score}%`);
+  return chalk.red(`${score}%`);
+}
+function formatDuration(seconds) {
+  if (!seconds) return "-";
+  if (seconds < 60) return `${Math.round(seconds)}s`;
+  const mins = Math.floor(seconds / 60);
+  const secs = Math.round(seconds % 60);
+  return `${mins}m ${secs}s`;
+}
+function collectExternalRefs(value, previous) {
+  const [key, ...rest] = value.split("=");
+  if (!key || rest.length === 0) {
+    printWarning(`Invalid external-ref format: '${value}'. Expected key=value`);
+    return previous;
+  }
+  return { ...previous, [key]: rest.join("=") };
+}
+async function handleCallsList(options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Fetching calls...").start();
+  try {
+    const response = await sdk.calls.list({
+      status: options.status,
+      agentId: options.agent,
+      direction: options.direction,
+      customerName: options.customer,
+      externalRefs: options.externalRef && Object.keys(options.externalRef).length > 0 ? options.externalRef : void 0,
+      limit: parseInt(options.limit, 10),
+      page: parseInt(options.page, 10)
+    });
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to fetch calls", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const rawData = response.data;
+    const calls = Array.isArray(rawData) ? rawData : rawData.calls || rawData.interactions || [];
+    if (isJsonOutput()) {
+      printJson(response.data);
+      return;
+    }
+    if (calls.length === 0) {
+      printInfo("No calls found");
+      return;
+    }
+    printBlank();
+    printSimpleTable(
+      ["ID", "Status", "Duration", "Score", "Agent", "Created"],
+      calls.map((c) => [
+        c.id.slice(-12),
+        formatStatus(c.status),
+        formatDuration(c.duration),
+        formatScore(c.score),
+        c.agentId?.slice(-8) || "-",
+        formatDate(c.createdAt)
+      ])
+    );
+    printBlank();
+    printInfo(`${calls.length} calls shown`);
+  } catch (error) {
+    spinner.fail("Failed to fetch calls");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleCallsGet(id) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Fetching call...").start();
+  try {
+    const response = await sdk.calls.get(id);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to fetch call", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    if (isJsonOutput()) {
+      printJson(response.data);
+      return;
+    }
+    const call = response.data.call || response.data;
+    printBlank();
+    console.log(chalk.bold("Call Details:"));
+    console.log(`  ID:         ${call.id}`);
+    console.log(`  Status:     ${formatStatus(call.status)}`);
+    console.log(`  Duration:   ${formatDuration(call.duration)}`);
+    console.log(`  Score:      ${formatScore(call.score)}`);
+    if (call.agentId) console.log(`  Agent:      ${call.agentId}`);
+    if (call.scenarioId) console.log(`  Scenario:   ${call.scenarioId}`);
+    console.log(`  Created:    ${formatDate(call.createdAt)}`);
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to fetch call");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleCallsAnalyze(id, options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Triggering analysis...").start();
+  try {
+    const response = await sdk.calls.analyze(id, {
+      scorecardId: options.scorecard,
+      forceReanalysis: options.force
+    });
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to trigger analysis", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    if (isJsonOutput()) {
+      printJson(response.data);
+      return;
+    }
+    const { status, resultId, message } = response.data;
+    printBlank();
+    if (status === "queued") {
+      console.log(chalk.green("\u2713 Analysis queued successfully"));
+      if (resultId) {
+        printLabel("Result ID", resultId);
+      }
+      printInfo(`Run 'chanl calls analysis ${id}' to view results when complete`);
+    } else if (status === "no_scorecard") {
+      console.log(chalk.yellow("\u26A0 No scorecard available"));
+      printInfo(message || "Configure a default scorecard for your workspace");
+    } else if (status === "no_transcript") {
+      console.log(chalk.yellow("\u26A0 No transcript available"));
+      printInfo(message || "Call needs a transcript before analysis");
+    }
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to trigger analysis");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleCallsAnalysis(id) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Fetching analysis...").start();
+  try {
+    const response = await sdk.calls.getAnalysis(id);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to fetch analysis", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    if (isJsonOutput()) {
+      printJson(response.data);
+      return;
+    }
+    const results = Array.isArray(response.data) ? response.data : response.data.results;
+    if (!results || results.length === 0) {
+      printInfo("No analysis results found for this call");
+      printInfo(`Run 'chanl calls analyze ${id}' to trigger analysis`);
+      return;
+    }
+    printBlank();
+    console.log(chalk.bold(`Analysis Results for Call ${id.slice(-12)}`));
+    console.log(chalk.dim("\u2500".repeat(60)));
+    for (const result of results) {
+      console.log(chalk.bold(`
+Scorecard: ${result.scorecardId?.slice(-8) || "Unknown"}`));
+      console.log(`  Overall Score: ${formatScore(result.overallScore)}`);
+      console.log(`  Status:        ${result.status || "completed"}`);
+      if (result.categoryScores && result.categoryScores.length > 0) {
+        console.log(chalk.bold("\n  Category Scores:"));
+        for (const cat of result.categoryScores) {
+          console.log(`    ${cat.categoryName}: ${formatScore(cat.score)}`);
+        }
+      }
+      if (result.feedback) {
+        console.log(chalk.bold("\n  Feedback:"));
+        console.log(`    ${result.feedback}`);
+      }
+    }
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to fetch analysis");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleCallsTranscript(id, options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Fetching transcript...").start();
+  try {
+    const response = await sdk.calls.getTranscript(id);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to fetch transcript", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    if (isJsonOutput()) {
+      printJson(response.data);
+      return;
+    }
+    const transcript = response.data.transcript || response.data;
+    if (!transcript) {
+      printInfo("No transcript available for this call");
+      return;
+    }
+    printBlank();
+    console.log(chalk.bold(`Transcript for Call ${id.slice(-12)}`));
+    console.log(chalk.dim("\u2500".repeat(60)));
+    if (transcript.wordCount) {
+      printLabel("Word Count", transcript.wordCount.toString());
+    }
+    if (transcript.speakerCount) {
+      printLabel("Speakers", transcript.speakerCount.toString());
+    }
+    if (transcript.language) {
+      printLabel("Language", transcript.language);
+    }
+    if (transcript.confidence) {
+      printLabel("Confidence", `${(transcript.confidence * 100).toFixed(1)}%`);
+    }
+    console.log(chalk.dim("\u2500".repeat(60)));
+    if (options.full || !transcript.segments || transcript.segments.length === 0) {
+      console.log("\n" + (transcript.text || "No text available"));
+    } else {
+      console.log("");
+      for (const segment of transcript.segments) {
+        const speaker = segment.speaker === "speaker_0" ? chalk.cyan("Agent") : chalk.yellow("Customer");
+        const time = `[${formatDuration(segment.start)} - ${formatDuration(segment.end)}]`;
+        console.log(`${speaker} ${chalk.dim(time)}`);
+        console.log(`  ${segment.text}`);
+        console.log("");
+      }
+    }
+    if (transcript.toolCalls && transcript.toolCalls.length > 0) {
+      console.log(chalk.dim("\u2500".repeat(60)));
+      console.log(chalk.bold(`Tool Calls (${transcript.toolCalls.length}):`));
+      console.log("");
+      printTranscriptToolCalls(transcript.toolCalls);
+    }
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to fetch transcript");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleCallsMetrics(id) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Fetching metrics...").start();
+  try {
+    const response = await sdk.calls.getMetrics(id);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to fetch metrics", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    if (isJsonOutput()) {
+      printJson(response.data);
+      return;
+    }
+    const metrics = response.data.metrics || response.data;
+    printBlank();
+    console.log(chalk.bold(`Metrics for Call ${id.slice(-12)}`));
+    console.log(chalk.dim("\u2500".repeat(50)));
+    if (metrics.duration) {
+      printLabel("Duration", formatDuration(metrics.duration));
+    }
+    if (metrics.talkTime) {
+      console.log(chalk.bold("\nTalk Time:"));
+      if (metrics.talkTime.total) console.log(`  Total:    ${formatDuration(metrics.talkTime.total)}`);
+      if (metrics.talkTime.agent) console.log(`  Agent:    ${formatDuration(metrics.talkTime.agent)}`);
+      if (metrics.talkTime.customer) console.log(`  Customer: ${formatDuration(metrics.talkTime.customer)}`);
+    }
+    if (metrics.responseTime) {
+      console.log(chalk.bold("\nResponse Time:"));
+      if (metrics.responseTime.average) console.log(`  Average:  ${metrics.responseTime.average.toFixed(0)}ms`);
+      if (metrics.responseTime.max) console.log(`  Max:      ${metrics.responseTime.max.toFixed(0)}ms`);
+    }
+    if (metrics.silence) {
+      console.log(chalk.bold("\nSilence:"));
+      if (metrics.silence.total) console.log(`  Total:    ${formatDuration(metrics.silence.total)}`);
+      if (metrics.silence.count) console.log(`  Count:    ${metrics.silence.count} pauses`);
+    }
+    if (metrics.interruptions) {
+      console.log(chalk.bold("\nInterruptions:"));
+      if (metrics.interruptions.total !== void 0) console.log(`  Total:    ${metrics.interruptions.total}`);
+      if (metrics.interruptions.byAgent !== void 0) console.log(`  By Agent: ${metrics.interruptions.byAgent}`);
+      if (metrics.interruptions.byCustomer !== void 0) console.log(`  By Customer: ${metrics.interruptions.byCustomer}`);
+    }
+    if (metrics.turnCount) {
+      printLabel("\nTurn Count", metrics.turnCount.toString());
+    }
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to fetch metrics");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleCallsImport(options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const hasTranscript = !!options.transcript;
+  const hasFile = !!options.file;
+  const hasAudioUrl = !!options.audioUrl;
+  const hasAudioId = !!options.audioId;
+  const hasS3 = !!(options.bucket && options.key);
+  if (!hasTranscript && !hasFile && !hasAudioUrl && !hasAudioId && !hasS3) {
+    printError(
+      "Missing import source",
+      "Provide one of: --transcript, --file, --audio-url, --audio-id, or --bucket/--key"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  let importOptions;
+  if (options.file) {
+    try {
+      const fileContent = fs.readFileSync(options.file, "utf-8");
+      importOptions = JSON.parse(fileContent);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      printError("Failed to read import file", message);
+      process.exitCode = 1;
+      return;
+    }
+  } else {
+    importOptions = {};
+    if (options.transcript) {
+      try {
+        const parsed = JSON.parse(options.transcript);
+        if (Array.isArray(parsed)) {
+          importOptions.transcript = parsed;
+        } else {
+          importOptions.transcript = options.transcript;
+        }
+      } catch {
+        importOptions.transcript = options.transcript;
+      }
+    }
+    if (options.audioUrl) {
+      importOptions.audioUrl = options.audioUrl;
+    }
+    if (options.audioId) {
+      importOptions.audioId = options.audioId;
+    }
+    if (options.bucket) {
+      importOptions.bucket = options.bucket;
+    }
+    if (options.key) {
+      importOptions.key = options.key;
+    }
+    if (options.region) {
+      importOptions.region = options.region;
+    }
+    if (options.customerName) {
+      importOptions.customerName = options.customerName;
+    }
+    if (options.agentName) {
+      importOptions.agentName = options.agentName;
+    }
+    if (options.direction) {
+      importOptions.callDirection = options.direction;
+    }
+    if (options.externalRef && Object.keys(options.externalRef).length > 0) {
+      importOptions.externalReferenceIds = options.externalRef;
+    }
+    if (options.analysisFields) {
+      importOptions.analysisFields = options.analysisFields.split(",").map((f) => f.trim());
+    }
+    if (options.scorecard) {
+      importOptions.scorecardId = options.scorecard;
+    }
+    if (options.webhookUrl) {
+      importOptions.webhookUrl = options.webhookUrl;
+    }
+  }
+  const spinner = ora("Importing call...").start();
+  try {
+    const response = await sdk.calls.import(importOptions);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to import call", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    if (isJsonOutput()) {
+      printJson(response.data);
+      return;
+    }
+    const { callId, processingStatus, importMode, externalReferenceIds } = response.data;
+    printBlank();
+    printSuccess("Call imported successfully");
+    printLabel("Call ID", callId);
+    printLabel("Status", processingStatus || "pending");
+    if (importMode) {
+      printLabel("Import Mode", importMode);
+    }
+    if (externalReferenceIds && Object.keys(externalReferenceIds).length > 0) {
+      printLabel("External Refs", Object.entries(externalReferenceIds).map(([k, v]) => `${k}=${v}`).join(", "));
+    }
+    printBlank();
+    printInfo(`Run 'chanl calls get ${callId}' to view call details`);
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to import call");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleCallsDelete(id, options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  if (!options.yes) {
+    printWarning(`This will permanently delete call ${id.slice(-12)}`);
+    printInfo("Use --yes to skip this confirmation");
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve) => {
+      rl.question(chalk.yellow("Are you sure? (y/N): "), (ans) => {
+        rl.close();
+        resolve(ans);
+      });
+    });
+    if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
+      printInfo("Cancelled");
+      return;
+    }
+  }
+  const spinner = ora("Deleting call...").start();
+  try {
+    const response = await sdk.calls.delete(id);
+    spinner.stop();
+    if (!response.success) {
+      printError("Failed to delete call", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    if (isJsonOutput()) {
+      printJson({ deleted: true, callId: id });
+      return;
+    }
+    printSuccess(`Call ${id.slice(-12)} deleted successfully`);
+  } catch (error) {
+    spinner.fail("Failed to delete call");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleCallsBulkDelete(options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  let callIds = [];
+  if (options.ids) {
+    callIds = options.ids.split(",").map((id) => id.trim()).filter(Boolean);
+  }
+  if (options.file) {
+    try {
+      const fileContent = fs.readFileSync(options.file, "utf-8");
+      const fileIds = fileContent.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+      callIds = [...callIds, ...fileIds];
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      printError("Failed to read IDs file", message);
+      process.exitCode = 1;
+      return;
+    }
+  }
+  callIds = [...new Set(callIds)];
+  if (callIds.length === 0) {
+    printError("No call IDs provided", "Use --ids or --file to specify calls to delete");
+    process.exitCode = 1;
+    return;
+  }
+  if (!options.yes) {
+    printWarning(`This will permanently delete ${callIds.length} call(s)`);
+    printInfo("Use --yes to skip this confirmation");
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve) => {
+      rl.question(chalk.yellow("Are you sure? (y/N): "), (ans) => {
+        rl.close();
+        resolve(ans);
+      });
+    });
+    if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
+      printInfo("Cancelled");
+      return;
+    }
+  }
+  const spinner = ora(`Deleting ${callIds.length} calls...`).start();
+  try {
+    const response = await sdk.calls.bulkDelete({
+      callIds,
+      deleteStorageFiles: !options.keepFiles
+    });
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to bulk delete calls", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    if (isJsonOutput()) {
+      printJson(response.data);
+      return;
+    }
+    const { deletedCount, failedIds, storageFilesDeleted } = response.data;
+    printBlank();
+    printSuccess(`Successfully deleted ${deletedCount} call(s)`);
+    if (storageFilesDeleted > 0) {
+      printInfo(`Deleted ${storageFilesDeleted} storage files`);
+    }
+    if (failedIds && failedIds.length > 0) {
+      printWarning(`Failed to delete ${failedIds.length} call(s): ${failedIds.slice(0, 5).join(", ")}${failedIds.length > 5 ? "..." : ""}`);
+    }
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to bulk delete calls");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+function printTranscriptToolCalls(toolCalls) {
+  for (const tc of toolCalls) {
+    const statusIcon = tc.status === "success" ? chalk.green("\u2713") : tc.status === "error" ? chalk.red("\u2717") : tc.status === "timeout" ? chalk.yellow("\u23F1") : chalk.dim("\u2026");
+    const duration = tc.durationMs ? chalk.dim(` (${tc.durationMs}ms)`) : "";
+    const time = tc.secondsFromStart !== void 0 ? chalk.dim(` @ ${tc.secondsFromStart.toFixed(1)}s`) : "";
+    const params = Object.keys(tc.parameters).length ? chalk.dim(` ${JSON.stringify(tc.parameters)}`) : "";
+    console.log(`  ${statusIcon} ${chalk.yellow(tc.name)}${params}${duration}${time}`);
+    if (tc.status === "error" && tc.error) {
+      console.log(`    ${chalk.red(tc.error.message)}`);
+    }
+  }
+}
+export {
+  createCallsCommand
+};
+//# sourceMappingURL=calls.js.map