retell-cli 1.0.0 → 1.0.1

package/dist/index.js

@@ -25,8 +25,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // src/index.ts
 var import_commander = require("commander");
-var import_fs4 = require("fs");
-var import_path4 = require("path");
+var import_fs5 = require("fs");
+var import_path6 = require("path");
 
 // src/commands/login.ts
 var readline = __toESM(require("readline/promises"));
@@ -133,6 +133,84 @@ function configFileExists() {
 
 // src/services/output-formatter.ts
 var import_retell_sdk = __toESM(require("retell-sdk"));
+var DANGEROUS_KEYS = ["__proto__", "constructor", "prototype"];
+var ARRAY_INDEX_PATTERN = /^\d+$/;
+function validateSafeKey(key) {
+  if (DANGEROUS_KEYS.includes(key)) {
+    throw new Error(`Dangerous key detected in path: ${key}`);
+  }
+}
+function hasNestedPath(obj, path) {
+  if (obj === null || obj === void 0 || typeof obj !== "object") {
+    return false;
+  }
+  const keys = path.split(".");
+  for (const key of keys) {
+    validateSafeKey(key);
+  }
+  let current = obj;
+  for (const key of keys) {
+    if (current === null || current === void 0) {
+      return false;
+    }
+    if (Array.isArray(current)) {
+      const index = parseInt(key, 10);
+      if (isNaN(index) || index < 0 || index >= current.length) {
+        return false;
+      }
+      current = current[index];
+    } else if (typeof current === "object") {
+      if (!(key in current)) {
+        return false;
+      }
+      current = current[key];
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+function getNestedValue(obj, path) {
+  if (!obj || typeof obj !== "object") {
+    return void 0;
+  }
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    if (Array.isArray(current)) {
+      const index = parseInt(key, 10);
+      if (isNaN(index) || index < 0 || index >= current.length) {
+        return void 0;
+      }
+      current = current[index];
+    } else if (typeof current === "object") {
+      current = current[key];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function setNestedValue(obj, path, value) {
+  const keys = path.split(".");
+  const lastKey = keys.pop();
+  validateSafeKey(lastKey);
+  let current = obj;
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    validateSafeKey(key);
+    if (!(key in current) || typeof current[key] !== "object" || current[key] === null) {
+      const nextKey = keys[i + 1];
+      const isNextKeyArrayIndex = nextKey && ARRAY_INDEX_PATTERN.test(nextKey);
+      current[key] = isNextKeyArrayIndex ? [] : {};
+    }
+    current = current[key];
+  }
+  current[lastKey] = value;
+}
 function outputJson(data) {
   console.log(JSON.stringify(data, null, 2));
 }
@@ -178,10 +256,48 @@ function handleSdkError(error) {
     outputError(message, "API_ERROR");
   }
   if (error instanceof Error) {
+    if (error.name === "ValidationError") {
+      outputError(error.message, "VALIDATION_ERROR");
+    }
     outputError(error.message, "UNKNOWN_ERROR");
   }
   outputError("An unexpected error occurred", "UNKNOWN_ERROR");
 }
+function filterFields(data, fields, options = {}) {
+  if (data === null || data === void 0) {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.map((item) => filterFields(item, fields, options));
+  }
+  if (typeof data !== "object") {
+    return data;
+  }
+  const result = {};
+  const warnings = [];
+  for (const field of fields) {
+    if (!hasNestedPath(data, field)) {
+      const availableFields = Object.keys(data);
+      const fieldList = availableFields.length > 0 ? `Available fields: ${availableFields.join(", ")}` : "No fields available";
+      const warning = `Field '${field}' not found in data. ${fieldList}`;
+      warnings.push(warning);
+      if (options.strict) {
+        throw new Error(warning);
+      }
+      continue;
+    }
+    const value = getNestedValue(data, field);
+    setNestedValue(result, field, value);
+  }
+  if (warnings.length > 0 && !options.strict) {
+    if (process.env.DEBUG) {
+      console.warn(JSON.stringify({ warnings }, null, 2));
+    } else {
+      warnings.forEach((warning) => console.warn(`Warning: ${warning}`));
+    }
+  }
+  return result;
+}
 
 // src/commands/login.ts
 async function loginCommand() {
@@ -259,24 +375,33 @@ async function listTranscriptsCommand(options) {
     const calls = await client.call.list({
       limit: options.limit || 50
     });
-    outputJson(calls);
+    const output = options.fields ? filterFields(calls, options.fields.split(",").map((f) => f.trim())) : calls;
+    outputJson(output);
   } catch (error) {
     handleSdkError(error);
   }
 }
 
 // src/commands/transcripts/get.ts
-async function getTranscriptCommand(callId) {
+async function getTranscriptCommand(callId, options = {}) {
   try {
     const client = getRetellClient();
     const call = await client.call.retrieve(callId);
-    outputJson(call);
+    const output = options.fields ? filterFields(call, options.fields.split(",").map((f) => f.trim())) : call;
+    outputJson(output);
   } catch (error) {
     handleSdkError(error);
   }
 }
 
 // src/commands/transcripts/analyze.ts
+var DEFAULT_LATENCY_THRESHOLD = 2e3;
+var DEFAULT_SILENCE_THRESHOLD = 5e3;
+function validateThreshold(threshold, name) {
+  if (!Number.isInteger(threshold) || threshold <= 0) {
+    throw new Error(`${name} must be a positive integer (got: ${threshold})`);
+  }
+}
 function extractTranscriptTurns(transcriptObject) {
   if (!transcriptObject || !Array.isArray(transcriptObject)) {
     return [];
@@ -287,10 +412,122 @@ function extractTranscriptTurns(transcriptObject) {
     word_count: turn.content ? turn.content.split(/\s+/).length : 0
   }));
 }
-async function analyzeTranscriptCommand(callId) {
+function formatTimestamp(seconds) {
+  if (!seconds || seconds < 0)
+    return "N/A";
+  const totalSeconds = Math.floor(seconds);
+  const mins = Math.floor(totalSeconds / 60);
+  const secs = totalSeconds % 60;
+  const hrs = Math.floor(mins / 60);
+  const displayMins = mins % 60;
+  if (hrs > 0) {
+    return `${hrs.toString().padStart(2, "0")}:${displayMins.toString().padStart(2, "0")}:${secs.toString().padStart(2, "0")}`;
+  }
+  return `${displayMins.toString().padStart(2, "0")}:${secs.toString().padStart(2, "0")}`;
+}
+function detectLatencySpikes(call, config) {
+  const hotspots = [];
+  if (call.latency?.e2e?.p90 && call.latency.e2e.p90 > config.latencyThreshold) {
+    hotspots.push({
+      turn_index: -1,
+      timestamp: "N/A",
+      issue_type: "latency_spike",
+      metrics: {
+        latency_p90_e2e: call.latency.e2e.p90,
+        latency_p90_llm: call.latency?.llm?.p90 || 0,
+        latency_p90_tts: call.latency?.tts?.p90 || 0
+      }
+    });
+  }
+  return hotspots;
+}
+function detectLongSilences(call, config) {
+  const hotspots = [];
+  const transcript = call.transcript_object || [];
+  for (let i = 1; i < transcript.length; i++) {
+    const prevTurn = transcript[i - 1];
+    const currTurn = transcript[i];
+    const prevWords = prevTurn.words || [];
+    const currWords = currTurn.words || [];
+    if (prevWords.length === 0 || currWords.length === 0)
+      continue;
+    const prevEnd = prevWords[prevWords.length - 1]?.end;
+    const currStart = currWords[0]?.start;
+    if (prevEnd === void 0 || currStart === void 0)
+      continue;
+    const gapMs = (currStart - prevEnd) * 1e3;
+    if (gapMs > config.silenceThreshold) {
+      hotspots.push({
+        turn_index: i,
+        timestamp: formatTimestamp(currStart),
+        issue_type: "long_silence",
+        user_utterance: prevTurn.role === "user" ? prevTurn.content : currTurn.content,
+        agent_utterance: currTurn.role === "agent" ? currTurn.content : prevTurn.content,
+        metrics: {
+          silence_duration_ms: Math.round(gapMs)
+        }
+      });
+    }
+  }
+  return hotspots;
+}
+function detectSentimentIssues(call) {
+  const hotspots = [];
+  if (call.call_analysis?.user_sentiment === "Negative") {
+    hotspots.push({
+      turn_index: -1,
+      timestamp: "N/A",
+      issue_type: "sentiment",
+      metrics: {
+        sentiment: call.call_analysis.user_sentiment
+      }
+    });
+  }
+  return hotspots;
+}
+function detectAllHotspots(call, config) {
+  const hotspots = [
+    ...detectLatencySpikes(call, config),
+    ...detectLongSilences(call, config),
+    ...detectSentimentIssues(call)
+  ];
+  return hotspots.sort((a, b) => {
+    if (a.turn_index === -1)
+      return -1;
+    if (b.turn_index === -1)
+      return 1;
+    return a.turn_index - b.turn_index;
+  });
+}
+async function analyzeTranscriptCommand(callId, options = {}) {
   try {
+    if (options.hotspotsOnly) {
+      const latencyThreshold = options.latencyThreshold ?? DEFAULT_LATENCY_THRESHOLD;
+      const silenceThreshold = options.silenceThreshold ?? DEFAULT_SILENCE_THRESHOLD;
+      validateThreshold(latencyThreshold, "Latency threshold");
+      validateThreshold(silenceThreshold, "Silence threshold");
+    }
     const client = getRetellClient();
     const call = await client.call.retrieve(callId);
+    if (options.raw) {
+      const output2 = options.fields ? filterFields(call, options.fields.split(",").map((f) => f.trim())) : call;
+      outputJson(output2);
+      return;
+    }
+    if (options.hotspotsOnly) {
+      const config = {
+        latencyThreshold: options.latencyThreshold ?? DEFAULT_LATENCY_THRESHOLD,
+        silenceThreshold: options.silenceThreshold ?? DEFAULT_SILENCE_THRESHOLD
+      };
+      const hotspots = detectAllHotspots(call, config);
+      const result = {
+        call_id: callId,
+        hotspots
+      };
+      const output2 = options.fields ? filterFields(result, options.fields.split(",").map((f) => f.trim())) : result;
+      outputJson(output2);
+      return;
+    }
     const analysis = {
       call_id: callId,
       metadata: {
@@ -324,12 +561,154 @@ async function analyzeTranscriptCommand(callId) {
         breakdown: call.call_cost?.product_costs || []
       }
     };
-    outputJson(analysis);
+    const output = options.fields ? filterFields(analysis, options.fields.split(",").map((f) => f.trim())) : analysis;
+    outputJson(output);
   } catch (error) {
     handleSdkError(error);
   }
 }
 
+// src/commands/transcripts/search.ts
+var import_zod2 = require("zod");
+var MAX_LIMIT = 1e3;
+var DEFAULT_LIMIT = 50;
+var CallSchema = import_zod2.z.object({
+  call_id: import_zod2.z.string(),
+  call_status: import_zod2.z.string().optional(),
+  agent_id: import_zod2.z.string().optional(),
+  start_timestamp: import_zod2.z.number().optional(),
+  end_timestamp: import_zod2.z.number().optional()
+  // Allow additional fields (the API may return more fields than we validate)
+}).passthrough();
+var CallListSchema = import_zod2.z.array(CallSchema);
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+function parseDate(dateStr) {
+  if (!dateStr) {
+    throw new ValidationError("Date string cannot be empty");
+  }
+  const dateOnlyPattern = /^\d{4}-\d{2}-\d{2}$/;
+  const iso8601Pattern = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
+  if (!iso8601Pattern.test(dateStr)) {
+    throw new ValidationError(`Invalid date format: "${dateStr}". Use YYYY-MM-DD or ISO 8601 format.`);
+  }
+  const date = new Date(dateStr);
+  if (isNaN(date.getTime())) {
+    throw new ValidationError(`Invalid date format: "${dateStr}". Use YYYY-MM-DD or ISO 8601 format.`);
+  }
+  return { date, isDateOnly: dateOnlyPattern.test(dateStr) };
+}
+function validateSearchOptions(options) {
+  const validStatuses = ["error", "ended", "ongoing"];
+  if (options.status && !validStatuses.includes(options.status)) {
+    throw new ValidationError(
+      `Invalid status: "${options.status}". Valid options: ${validStatuses.join(", ")}`
+    );
+  }
+  const parsedDates = {};
+  if (options.since !== void 0) {
+    parsedDates.sinceDate = parseDate(options.since);
+  }
+  if (options.until !== void 0) {
+    parsedDates.untilDate = parseDate(options.until);
+    if (parsedDates.untilDate.isDateOnly) {
+      const date = new Date(parsedDates.untilDate.date.getTime());
+      date.setUTCHours(23, 59, 59, 999);
+      parsedDates.untilDate.date = date;
+    }
+  }
+  if (parsedDates.sinceDate && parsedDates.untilDate) {
+    if (parsedDates.sinceDate.date > parsedDates.untilDate.date) {
+      throw new ValidationError(
+        `Invalid date range: --since ("${options.since}") is after --until ("${options.until}")`
+      );
+    }
+  }
+  if (options.limit !== void 0 && (options.limit < 1 || !Number.isInteger(options.limit))) {
+    throw new ValidationError(`Limit must be a positive integer (got: "${options.limit}")`);
+  }
+  if (options.limit !== void 0 && options.limit > MAX_LIMIT) {
+    throw new ValidationError(`Limit cannot exceed ${MAX_LIMIT} (got: "${options.limit}")`);
+  }
+  return parsedDates;
+}
+async function searchTranscripts(options, parsedDates) {
+  const client = getRetellClient();
+  const apiParams = {
+    limit: options.limit || DEFAULT_LIMIT,
+    sort_order: "descending"
+    // Most recent first
+  };
+  const filterCriteria = {};
+  if (options.status) {
+    filterCriteria.call_status = [options.status];
+  }
+  if (options.agentId) {
+    filterCriteria.agent_id = [options.agentId];
+  }
+  if (parsedDates.sinceDate || parsedDates.untilDate) {
+    filterCriteria.start_timestamp = {};
+    if (parsedDates.sinceDate) {
+      filterCriteria.start_timestamp.lower_threshold = parsedDates.sinceDate.date.getTime();
+    }
+    if (parsedDates.untilDate) {
+      filterCriteria.start_timestamp.upper_threshold = parsedDates.untilDate.date.getTime();
+    }
+  }
+  if (Object.keys(filterCriteria).length > 0) {
+    apiParams.filter_criteria = filterCriteria;
+  }
+  const response = await client.call.list(apiParams);
+  const validation = CallListSchema.safeParse(response);
+  if (!validation.success) {
+    console.warn("Warning: API response validation failed:", validation.error.message);
+    throw new Error(`Invalid API response format: ${validation.error.message}`);
+  }
+  const results = validation.data;
+  const requestedLimit = options.limit || DEFAULT_LIMIT;
+  const result = {
+    results,
+    total_count: results.length,
+    filters_applied: {
+      ...options.status && { status: options.status },
+      ...options.agentId && { agent_id: options.agentId },
+      ...options.since && { since: options.since },
+      ...options.until && { until: options.until },
+      limit: requestedLimit
+    }
+  };
+  if (results.length === requestedLimit && results.length > 0) {
+    console.warn(
+      `Warning: Results limited to ${results.length}. There may be additional results available. Use --limit to increase (max: ${MAX_LIMIT}).`
+    );
+  }
+  return result;
+}
+async function searchTranscriptsCommand(options = {}) {
+  try {
+    const parsedDates = validateSearchOptions(options);
+    const searchResult = await searchTranscripts(options, parsedDates);
+    const output = options.fields ? {
+      results: searchResult.results.map(
+        (r) => filterFields(r, options.fields.split(",").map((f) => f.trim()))
+      ),
+      total_count: searchResult.total_count,
+      filters_applied: searchResult.filters_applied
+    } : searchResult;
+    outputJson(output);
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      handleSdkError(error);
+    } else {
+      handleSdkError(error);
+    }
+  }
+}
+
 // src/commands/agents/list.ts
 async function listAgentsCommand(options = {}) {
   try {
@@ -361,18 +740,20 @@ async function listAgentsCommand(options = {}) {
         response_engine_id
       };
     });
-    outputJson(formatted);
+    const output = options.fields ? filterFields(formatted, options.fields.split(",").map((f) => f.trim())) : formatted;
+    outputJson(output);
   } catch (error) {
     handleSdkError(error);
   }
 }
 
 // src/commands/agents/info.ts
-async function agentInfoCommand(agentId) {
+async function agentInfoCommand(agentId, options = {}) {
   try {
     const client = getRetellClient();
     const agent = await client.agent.retrieve(agentId);
-    outputJson(agent);
+    const output = options.fields ? filterFields(agent, options.fields.split(",").map((f) => f.trim())) : agent;
+    outputJson(output);
   } catch (error) {
     handleSdkError(error);
   }
@@ -396,8 +777,8 @@ async function resolvePromptSource(agentId) {
         llm_id: llm.llm_id,
         version: llm.version,
         general_prompt: llm.general_prompt,
-        begin_message: llm.begin_message,
-        states: llm.states
+        begin_message: llm.begin_message ?? void 0,
+        states: llm.states ?? void 0
       }
     };
   }
@@ -413,7 +794,7 @@ async function resolvePromptSource(agentId) {
         conversation_flow_id: flow.conversation_flow_id,
         version: flow.version,
         global_prompt: flow.global_prompt,
-        nodes: flow.nodes
+        nodes: flow.nodes ?? []
       }
     };
   }
@@ -536,76 +917,45 @@ function getFilesCreated(type, promptSource) {
 }
 
 // src/commands/prompts/update.ts
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+
+// src/services/prompt-loader.ts
 var import_fs3 = require("fs");
 var import_path3 = require("path");
-function validateAgentId2(agentId) {
-  if (agentId.includes("..") || agentId.includes("/") || agentId.includes("\\")) {
-    throw new Error("Invalid agent ID: cannot contain path separators or traversal sequences");
+function loadLocalPrompts(agentId, agentDir) {
+  if (!(0, import_fs3.existsSync)(agentDir)) {
+    throw new Error(`Prompts directory not found: ${agentDir}. Run 'retell prompts pull ${agentId}' first.`);
   }
-}
-async function updatePromptsCommand(agentId, options) {
+  const metadataPath = (0, import_path3.join)(agentDir, "metadata.json");
+  if (!(0, import_fs3.existsSync)(metadataPath)) {
+    throw new Error(`metadata.json not found in ${agentDir}. Directory may be corrupted.`);
+  }
+  let metadata;
   try {
-    validateAgentId2(agentId);
-    const baseDir = options.source || ".retell-prompts";
-    const agentDir = (0, import_path3.join)(baseDir, agentId);
-    if (!(0, import_fs3.existsSync)(agentDir)) {
-      outputError(
-        `Prompts directory not found: ${agentDir}. Run 'retell prompts pull ${agentId}' first.`,
-        "DIRECTORY_NOT_FOUND"
-      );
-      return;
-    }
-    const metadataPath = (0, import_path3.join)(agentDir, "metadata.json");
-    if (!(0, import_fs3.existsSync)(metadataPath)) {
-      outputError(
-        `metadata.json not found in ${agentDir}. Directory may be corrupted.`,
-        "METADATA_NOT_FOUND"
-      );
-      return;
-    }
-    const metadata = JSON.parse((0, import_fs3.readFileSync)(metadataPath, "utf-8"));
-    const promptSource = await resolvePromptSource(agentId);
-    if (promptSource.type === "custom-llm") {
-      outputError(promptSource.error, "CUSTOM_LLM_NOT_SUPPORTED");
-      return;
-    }
-    if (metadata.type !== promptSource.type) {
-      outputError(
-        `Type mismatch: local files are ${metadata.type}, but agent uses ${promptSource.type}. Pull prompts again to sync.`,
-        "TYPE_MISMATCH"
-      );
-      return;
-    }
-    const client = getRetellClient();
-    if (promptSource.type === "retell-llm") {
-      const prompts2 = loadRetellLlmPrompts(agentDir);
-      await client.llm.update(promptSource.llmId, prompts2);
-      outputJson({
-        message: "Prompts updated successfully (draft version)",
-        agent_id: agentId,
-        agent_name: promptSource.agentName,
-        type: "retell-llm",
-        llm_id: promptSource.llmId,
-        note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
-      });
-    } else if (promptSource.type === "conversation-flow") {
-      const prompts2 = loadConversationFlowPrompts(agentDir);
-      await client.conversationFlow.update(promptSource.flowId, prompts2);
-      outputJson({
-        message: "Prompts updated successfully (draft version)",
-        agent_id: agentId,
-        agent_name: promptSource.agentName,
-        type: "conversation-flow",
-        conversation_flow_id: promptSource.flowId,
-        note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
-      });
-    }
+    metadata = JSON.parse((0, import_fs3.readFileSync)(metadataPath, "utf-8"));
   } catch (error) {
     if (error instanceof SyntaxError) {
-      outputError(`Invalid JSON in file: ${error.message}`, "INVALID_JSON");
-      return;
+      throw new Error(`Invalid JSON in metadata.json: ${error.message}`);
     }
-    handleSdkError(error);
+    throw new Error(`Failed to read metadata.json: ${error.message}`);
+  }
+  if (metadata.type === "retell-llm") {
+    const prompts2 = loadRetellLlmPrompts(agentDir);
+    return {
+      type: "retell-llm",
+      metadata,
+      prompts: prompts2
+    };
+  } else if (metadata.type === "conversation-flow") {
+    const prompts2 = loadConversationFlowPrompts(agentDir);
+    return {
+      type: "conversation-flow",
+      metadata,
+      prompts: prompts2
+    };
+  } else {
+    throw new Error(`Unknown agent type in metadata: ${metadata.type}`);
   }
 }
 function loadRetellLlmPrompts(agentDir) {
@@ -694,6 +1044,311 @@ function loadConversationFlowPrompts(agentDir) {
   return prompts2;
 }
 
+// src/services/prompt-diff.ts
+function deepEqual(obj1, obj2, maxDepth = 100) {
+  if (obj1 === obj2)
+    return true;
+  if (obj1 === null || obj2 === null)
+    return false;
+  if (typeof obj1 !== "object" || typeof obj2 !== "object")
+    return false;
+  let currentDepth = 0;
+  const sortedStringify = (obj) => {
+    if (++currentDepth > maxDepth) {
+      throw new Error(
+        `Maximum depth (${maxDepth}) exceeded during comparison. This may indicate a circular reference or extremely deep nesting.`
+      );
+    }
+    if (obj === null)
+      return "null";
+    if (typeof obj !== "object")
+      return JSON.stringify(obj);
+    if (Array.isArray(obj)) {
+      return "[" + obj.map(sortedStringify).join(",") + "]";
+    }
+    const keys = Object.keys(obj).sort();
+    const pairs = keys.map((k) => JSON.stringify(k) + ":" + sortedStringify(obj[k]));
+    return "{" + pairs.join(",") + "}";
+  };
+  try {
+    return sortedStringify(obj1) === sortedStringify(obj2);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Maximum depth")) {
+      console.warn("Warning:", error.message, "Falling back to reference equality.");
+      return obj1 === obj2;
+    }
+    throw error;
+  }
+}
+function generateDiff(agentId, localPrompts, remotePrompts) {
+  if (remotePrompts.type === "custom-llm") {
+    throw new Error("Cannot diff custom LLM agents");
+  }
+  if (localPrompts.type !== remotePrompts.type) {
+    throw new Error(
+      `Type mismatch: local files are ${localPrompts.type}, but agent uses ${remotePrompts.type}`
+    );
+  }
+  if (localPrompts.type === "retell-llm" && remotePrompts.type === "retell-llm") {
+    return generateRetellLlmDiff(agentId, localPrompts, remotePrompts);
+  } else if (localPrompts.type === "conversation-flow" && remotePrompts.type === "conversation-flow") {
+    return generateConversationFlowDiff(agentId, localPrompts, remotePrompts);
+  }
+  throw new Error(`Unsupported agent type: ${localPrompts.type}`);
+}
+function generateRetellLlmDiff(agentId, localPrompts, remotePrompts) {
+  const changes = {};
+  if (localPrompts.prompts.general_prompt !== remotePrompts.prompts.general_prompt) {
+    changes.general_prompt = {
+      old: remotePrompts.prompts.general_prompt,
+      new: localPrompts.prompts.general_prompt,
+      change_type: "modified"
+    };
+  }
+  const localBeginMessage = localPrompts.prompts.begin_message || null;
+  const remoteBeginMessage = remotePrompts.prompts.begin_message || null;
+  if (localBeginMessage !== remoteBeginMessage) {
+    if (localBeginMessage && !remoteBeginMessage) {
+      changes.begin_message = {
+        old: null,
+        new: localBeginMessage,
+        change_type: "added"
+      };
+    } else if (!localBeginMessage && remoteBeginMessage) {
+      changes.begin_message = {
+        old: remoteBeginMessage,
+        new: null,
+        change_type: "removed"
+      };
+    } else {
+      changes.begin_message = {
+        old: remoteBeginMessage,
+        new: localBeginMessage,
+        change_type: "modified"
+      };
+    }
+  }
+  const localStates = localPrompts.prompts.states || [];
+  const remoteStates = remotePrompts.prompts.states || [];
+  const localStatesMap = new Map(localStates.map((s) => [s.name, s.state_prompt]));
+  const remoteStatesMap = new Map(remoteStates.map((s) => [s.name, s.state_prompt]));
+  for (const [stateName, localPrompt] of localStatesMap) {
+    const remotePrompt = remoteStatesMap.get(stateName);
+    const fieldKey = `states.${stateName}`;
+    if (remotePrompt === void 0) {
+      changes[fieldKey] = {
+        old: null,
+        new: localPrompt,
+        change_type: "added"
+      };
+    } else if (localPrompt !== remotePrompt) {
+      changes[fieldKey] = {
+        old: remotePrompt,
+        new: localPrompt,
+        change_type: "modified"
+      };
+    }
+  }
+  for (const [stateName, remotePrompt] of remoteStatesMap) {
+    if (!localStatesMap.has(stateName)) {
+      const fieldKey = `states.${stateName}`;
+      changes[fieldKey] = {
+        old: remotePrompt,
+        new: null,
+        change_type: "removed"
+      };
+    }
+  }
+  return {
+    agent_id: agentId,
+    agent_type: "retell-llm",
+    has_changes: Object.keys(changes).length > 0,
+    changes
+  };
+}
+function generateConversationFlowDiff(agentId, localPrompts, remotePrompts) {
+  const changes = {};
+  if (localPrompts.prompts.global_prompt !== remotePrompts.prompts.global_prompt) {
+    changes.global_prompt = {
+      old: remotePrompts.prompts.global_prompt,
+      new: localPrompts.prompts.global_prompt,
+      change_type: "modified"
+    };
+  }
+  const localNodes = localPrompts.prompts.nodes || [];
+  const remoteNodes = remotePrompts.prompts.nodes || [];
+  const localNodesMap = new Map(localNodes.map((n) => [n.id, n]));
+  const remoteNodesMap = new Map(remoteNodes.map((n) => [n.id, n]));
+  for (const [nodeId, localNode] of localNodesMap) {
+    const remoteNode = remoteNodesMap.get(nodeId);
+    const fieldKey = `nodes.${nodeId}`;
+    if (remoteNode === void 0) {
+      changes[fieldKey] = {
+        old: null,
+        new: localNode,
+        change_type: "added"
+      };
+    } else {
+      if (!deepEqual(localNode, remoteNode)) {
+        changes[fieldKey] = {
+          old: remoteNode,
+          new: localNode,
+          change_type: "modified"
+        };
+      }
+    }
+  }
+  for (const [nodeId, remoteNode] of remoteNodesMap) {
+    if (!localNodesMap.has(nodeId)) {
+      const fieldKey = `nodes.${nodeId}`;
+      changes[fieldKey] = {
+        old: remoteNode,
+        new: null,
+        change_type: "removed"
+      };
+    }
+  }
+  return {
+    agent_id: agentId,
+    agent_type: "conversation-flow",
+    has_changes: Object.keys(changes).length > 0,
+    changes
+  };
+}
+
+// src/commands/prompts/update.ts
+function validateAgentId2(agentId) {
+  if (agentId.includes("..") || agentId.includes("/") || agentId.includes("\\")) {
+    throw new Error("Invalid agent ID: cannot contain path separators or traversal sequences");
+  }
+}
+async function updatePromptsCommand(agentId, options) {
+  try {
+    validateAgentId2(agentId);
+    const baseDir = options.source || ".retell-prompts";
+    const agentDir = (0, import_path4.join)(baseDir, agentId);
+    if (!(0, import_fs4.existsSync)(agentDir)) {
+      outputError(
+        `Prompts directory not found: ${agentDir}. Run 'retell prompts pull ${agentId}' first.`,
+        "DIRECTORY_NOT_FOUND"
+      );
+      return;
+    }
+    const metadataPath = (0, import_path4.join)(agentDir, "metadata.json");
+    if (!(0, import_fs4.existsSync)(metadataPath)) {
+      outputError(
+        `metadata.json not found in ${agentDir}. Directory may be corrupted.`,
+        "METADATA_NOT_FOUND"
+      );
+      return;
+    }
+    const metadata = JSON.parse((0, import_fs4.readFileSync)(metadataPath, "utf-8"));
+    const promptSource = await resolvePromptSource(agentId);
+    if (promptSource.type === "custom-llm") {
+      outputError(promptSource.error, "CUSTOM_LLM_NOT_SUPPORTED");
+      return;
+    }
+    if (metadata.type !== promptSource.type) {
+      outputError(
+        `Type mismatch: local files are ${metadata.type}, but agent uses ${promptSource.type}. Pull prompts again to sync.`,
+        "TYPE_MISMATCH"
+      );
+      return;
+    }
+    if (options.dryRun) {
+      let localPrompts2;
+      try {
+        localPrompts2 = loadLocalPrompts(agentId, agentDir);
+      } catch (error) {
+        outputError(error.message, "LOCAL_PROMPTS_ERROR");
+        return;
+      }
+      let diff;
+      try {
+        diff = generateDiff(agentId, localPrompts2, promptSource);
+      } catch (error) {
+        outputError(error.message, "DIFF_GENERATION_ERROR");
+        return;
+      }
+      outputJson({
+        message: "Dry run - no changes applied",
+        ...diff
+      });
+      return;
+    }
+    let localPrompts;
+    try {
+      localPrompts = loadLocalPrompts(agentId, agentDir);
+    } catch (error) {
+      outputError(error.message, "LOCAL_PROMPTS_ERROR");
+      return;
+    }
+    const client = getRetellClient();
+    if (promptSource.type === "retell-llm" && localPrompts.type === "retell-llm") {
+      await client.llm.update(promptSource.llmId, localPrompts.prompts);
+      outputJson({
+        message: "Prompts updated successfully (draft version)",
+        agent_id: agentId,
+        agent_name: promptSource.agentName,
+        type: "retell-llm",
+        llm_id: promptSource.llmId,
+        note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
+      });
+    } else if (promptSource.type === "conversation-flow" && localPrompts.type === "conversation-flow") {
+      await client.conversationFlow.update(promptSource.flowId, localPrompts.prompts);
+      outputJson({
+        message: "Prompts updated successfully (draft version)",
+        agent_id: agentId,
+        agent_name: promptSource.agentName,
+        type: "conversation-flow",
+        conversation_flow_id: promptSource.flowId,
+        note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
+      });
+    }
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      outputError(`Invalid JSON in file: ${error.message}`, "INVALID_JSON");
+      return;
+    }
+    handleSdkError(error);
+  }
+}
+
+// src/commands/prompts/diff.ts
+var import_path5 = require("path");
+function validateAgentId3(agentId) {
+  if (agentId.includes("..") || agentId.includes("/") || agentId.includes("\\")) {
+    throw new Error("Invalid agent ID: cannot contain path separators or traversal sequences");
+  }
+}
+async function diffPromptsCommand(agentId, options) {
+  try {
+    validateAgentId3(agentId);
+    const baseDir = options.source || ".retell-prompts";
+    const agentDir = (0, import_path5.join)(baseDir, agentId);
+    const localPrompts = loadLocalPrompts(agentId, agentDir);
+    const remotePrompts = await resolvePromptSource(agentId);
+    if (remotePrompts.type === "custom-llm") {
+      outputError(remotePrompts.error, "CUSTOM_LLM_NOT_SUPPORTED");
+    }
+    if (localPrompts.type !== remotePrompts.type) {
+      outputError(
+        `Type mismatch: local files are ${localPrompts.type}, but agent uses ${remotePrompts.type}. Pull prompts again to sync.`,
+        "TYPE_MISMATCH"
+      );
+    }
+    const diff = generateDiff(agentId, localPrompts, remotePrompts);
+    let output = diff;
+    if (options.fields) {
+      const fieldList = options.fields.split(",").map((f) => f.trim());
+      output = filterFields(diff, fieldList);
+    }
+    outputJson(output);
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
 // src/commands/agent/publish.ts
 async function publishAgentCommand(agentId) {
   try {
@@ -701,10 +1356,10 @@ async function publishAgentCommand(agentId) {
     const result = await client.agent.publish(agentId);
     outputJson({
       message: "Agent published successfully",
-      agent_id: result.agent_id,
-      agent_name: result.agent_name,
-      version: result.version,
-      is_published: result.is_published,
+      agent_id: result?.agent_id || agentId,
+      agent_name: result?.agent_name || "Unknown",
+      version: result?.version || "Unknown",
+      is_published: result?.is_published ?? true,
       note: "Draft version incremented and ready for new changes"
     });
   } catch (error) {
@@ -714,7 +1369,7 @@ async function publishAgentCommand(agentId) {
 
 // src/index.ts
 var packageJson = JSON.parse(
-  (0, import_fs4.readFileSync)((0, import_path4.join)(__dirname, "../package.json"), "utf-8")
+  (0, import_fs5.readFileSync)((0, import_path6.join)(__dirname, "../package.json"), "utf-8")
 );
 var program = new import_commander.Command();
 program.name("retell").description("Retell AI CLI - Manage transcripts and agent prompts").version(packageJson.version, "-v, --version", "Display version number").helpOption("-h, --help", "Display help for command").option("--json", "Output as JSON (default)", true);
@@ -727,10 +1382,11 @@ Examples:
   await loginCommand();
 });
 var transcripts = program.command("transcripts").description("Manage call transcripts");
-transcripts.command("list").description("List all call transcripts").option("-l, --limit <number>", "Maximum number of calls to return (default: 50)", "50").addHelpText("after", `
+transcripts.command("list").description("List all call transcripts").option("-l, --limit <number>", "Maximum number of calls to return (default: 50)", "50").option("--fields <fields>", "Comma-separated list of fields to return (e.g., call_id,call_status,metadata.duration)").addHelpText("after", `
 Examples:
   $ retell transcripts list
   $ retell transcripts list --limit 100
+  $ retell transcripts list --fields call_id,call_status
   $ retell transcripts list | jq '.[] | select(.call_status == "error")'
   `).action(async (options) => {
   const limit = parseInt(options.limit, 10);
@@ -739,28 +1395,62 @@ Examples:
     process.exit(1);
   }
   await listTranscriptsCommand({
-    limit
+    limit,
+    fields: options.fields
   });
 });
-transcripts.command("get <call_id>").description("Get a specific call transcript").addHelpText("after", `
+transcripts.command("get <call_id>").description("Get a specific call transcript").option("--fields <fields>", "Comma-separated list of fields to return (e.g., call_id,metadata.duration,analysis)").addHelpText("after", `
 Examples:
   $ retell transcripts get call_abc123
+  $ retell transcripts get call_abc123 --fields call_id,metadata.duration
   $ retell transcripts get call_abc123 | jq '.transcript_object'
-  `).action(async (callId) => {
-  await getTranscriptCommand(callId);
+  `).action(async (callId, options) => {
+  await getTranscriptCommand(callId, {
+    fields: options.fields
+  });
 });
-transcripts.command("analyze <call_id>").description("Analyze a call transcript with performance metrics and insights").addHelpText("after", `
+transcripts.command("analyze <call_id>").description("Analyze a call transcript with performance metrics and insights").option("--fields <fields>", "Comma-separated list of fields to return (e.g., call_id,performance,analysis.summary)").option("--raw", "Return unmodified API response instead of enriched analysis").option("--hotspots-only", "Return only conversation hotspots/issues for troubleshooting").option("--latency-threshold <ms>", `Latency threshold in ms for hotspot detection (default: ${DEFAULT_LATENCY_THRESHOLD})`, String(DEFAULT_LATENCY_THRESHOLD)).option("--silence-threshold <ms>", `Silence threshold in ms for hotspot detection (default: ${DEFAULT_SILENCE_THRESHOLD})`, String(DEFAULT_SILENCE_THRESHOLD)).addHelpText("after", `
 Examples:
   $ retell transcripts analyze call_abc123
+  $ retell transcripts analyze call_abc123 --fields call_id,performance
+  $ retell transcripts analyze call_abc123 --raw
+  $ retell transcripts analyze call_abc123 --raw --fields call_id,transcript_object
+  $ retell transcripts analyze call_abc123 --hotspots-only
+  $ retell transcripts analyze call_abc123 --hotspots-only --latency-threshold 1500
+  $ retell transcripts analyze call_abc123 --hotspots-only --fields hotspots
   $ retell transcripts analyze call_abc123 | jq '.performance.latency_p50_ms'
-  `).action(async (callId) => {
-  await analyzeTranscriptCommand(callId);
+  `).action(async (callId, options) => {
+  await analyzeTranscriptCommand(callId, {
+    fields: options.fields,
+    raw: options.raw,
+    hotspotsOnly: options.hotspotsOnly,
+    latencyThreshold: options.latencyThreshold ? parseInt(options.latencyThreshold) : void 0,
+    silenceThreshold: options.silenceThreshold ? parseInt(options.silenceThreshold) : void 0
+  });
+});
+transcripts.command("search").description("Search transcripts with advanced filtering").option("--status <status>", "Filter by call status (error, ended, ongoing)").option("--agent-id <id>", "Filter by agent ID").option("--since <date>", "Filter calls after this date (YYYY-MM-DD or ISO format)").option("--until <date>", "Filter calls before this date (YYYY-MM-DD or ISO format)").option("--limit <number>", "Maximum number of results (default: 50)", "50").option("--fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
+Examples:
+  $ retell transcripts search --status error
+  $ retell transcripts search --agent-id agent_123 --since 2025-11-01
+  $ retell transcripts search --status error --limit 10
+  $ retell transcripts search --status error --fields call_id,agent_id,call_status
+  $ retell transcripts search --since 2025-11-01 --until 2025-11-15
+  `).action(async (options) => {
+  await searchTranscriptsCommand({
+    status: options.status,
+    agentId: options.agentId,
+    since: options.since,
+    until: options.until,
+    limit: options.limit ? Number(options.limit) : void 0,
+    fields: options.fields
+  });
 });
 var agents = program.command("agents").description("Manage agents");
-agents.command("list").description("List all agents").option("-l, --limit <number>", "Maximum number of agents to return (default: 100)", "100").addHelpText("after", `
+agents.command("list").description("List all agents").option("-l, --limit <number>", "Maximum number of agents to return (default: 100)", "100").option("--fields <fields>", "Comma-separated list of fields to return (e.g., agent_id,agent_name,response_engine_type)").addHelpText("after", `
 Examples:
   $ retell agents list
   $ retell agents list --limit 10
+  $ retell agents list --fields agent_id,agent_name
   $ retell agents list | jq '.[] | select(.response_engine.type == "retell-llm")'
   `).action(async (options) => {
   const limit = parseInt(options.limit, 10);
@@ -769,15 +1459,19 @@ Examples:
     process.exit(1);
   }
   await listAgentsCommand({
-    limit
+    limit,
+    fields: options.fields
   });
 });
-agents.command("info <agent_id>").description("Get detailed agent information").addHelpText("after", `
+agents.command("info <agent_id>").description("Get detailed agent information").option("--fields <fields>", "Comma-separated list of fields to return (e.g., agent_name,response_engine.type,voice_config)").addHelpText("after", `
 Examples:
   $ retell agents info agent_123abc
+  $ retell agents info agent_123abc --fields agent_name,response_engine.type
   $ retell agents info agent_123abc | jq '.response_engine.type'
-  `).action(async (agentId) => {
-  await agentInfoCommand(agentId);
+  `).action(async (agentId, options) => {
+  await agentInfoCommand(agentId, {
+    fields: options.fields
+  });
 });
 var prompts = program.command("prompts").description("Manage agent prompts");
 prompts.command("pull <agent_id>").description("Download agent prompts to a local file").option("-o, --output <path>", "Output file path (default: .retell-prompts/<agent_id>.json)", ".retell-prompts").addHelpText("after", `
@@ -787,6 +1481,14 @@ Examples:
   `).action(async (agentId, options) => {
   await pullPromptsCommand(agentId, options);
 });
+prompts.command("diff <agent_id>").description("Show differences between local and remote prompts").option("-s, --source <path>", "Source directory path (default: .retell-prompts)", ".retell-prompts").option("-f, --fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
+Examples:
+  $ retell prompts diff agent_123abc
+  $ retell prompts diff agent_123abc --source ./custom-prompts
+  $ retell prompts diff agent_123abc --fields has_changes,changes.general_prompt
+  `).action(async (agentId, options) => {
+  await diffPromptsCommand(agentId, options);
+});
 prompts.command("update <agent_id>").description("Update agent prompts from a local file").option("-s, --source <path>", "Source file path (default: .retell-prompts/<agent_id>.json)", ".retell-prompts").option("--dry-run", "Preview changes without applying them", false).addHelpText("after", `
 Examples:
   $ retell prompts update agent_123abc --source my-prompts.json --dry-run