fix(call): clear wrapped partial transcripts cleanly in npm run call (#11)

## Describe your changes

Fixes a long-standing display bug in `npm run call` where partial assistant transcripts visibly duplicate themselves in the terminal, leaving stacks of `🤖 Assistant: ...` lines on screen instead of overwriting cleanly.

- **Root cause:** `handleControlMessage` in `src/call.ts` was repainting partials with `\r` + N spaces + `\r`. `\r` only returns the cursor to column 0 of the *current* terminal row, so when a partial wraps to multiple rows (very common for assistant utterances on an 80-col terminal — the example that surfaced this was 110 cells wide), only the bottom row gets cleared. Every wrapped row above stays on screen, and the next partial paints another wrapping block on top.
- **Fix:** Compute the previous partial's row count from `process.stdout.columns` and an estimated display width that treats emoji and CJK glyphs as 2 cells, then walk the cursor up with `readline.moveCursor` / `readline.cursorTo` / `readline.clearLine` to erase every row, not just the bottom one.
- **Apply the same clear** before printing speech-update events, the call-ended message, the WebSocket `onclose` log, and the SIGINT/SIGTERM cleanup banner so they don't print on top of an in-flight partial either.
- **Non-TTY mode:** When `process.stdout.isTTY` is false (piping to `tee`, CI logs, redirecting to a file), `\r` was producing literal carriage returns and concatenated lines. We now skip live partial overwrites entirely in non-TTY contexts and only emit finals — one transcript per line, clean logs.

No new dependencies. Pure refactor of an existing function plus two small helpers (`getDisplayWidth`, `clearWrittenLine`) below `connectWebSocket`.

## Relevant Context (linear ticket, slack link, etc)

Surfaced during a manual simulated call (`npm run call -- <org> -s <squad>`) — every assistant turn was producing 5–10 stacked copies of the same `🤖 Assistant: ... Seller C` partial in the terminal, with long stretches of trailing whitespace between them. The duplication signature (identical content, growing whitespace gaps) traced back to `\r` only clearing one wrapped row instead of all of them.

## API Changes

- **Is this changing the public API?**

  - [ ] Yes
  - [x] No

- **If yes, is it backward‐compatible?**
  - [ ] Yes
  - [ ] No

N/A. This repo is an internal gitops CLI; the only user-visible change is that `npm run call` now renders partial transcripts cleanly in TTY and emits one line per final transcript in non-TTY contexts. No flags, no commands, no on-disk schema, no platform requests change.

Non backward-compatible changes might break customers' agents. Please proceed with care and notify the team.

## How did you test this?

**Automated:**
- `npx tsc --noEmit` — clean.
- `npm test` — 33/33 passing (no new tests added; existing suite covers the credential walker, path matching, cleanup safety, CLI arg parsing, and clean-resource regression set).

**Width math sanity check:**
- The exact partial that was duplicating in the reported call (`🤖 Assistant: Understood. Let's pick up right where we left off. The last instruction was: first open Seller C`) has a display width of **110 cells** under the new `getDisplayWidth`, which correctly resolves to **2 rows on an 80-col terminal**, **2 rows at 100 cols**, and **1 row at 120+ cols**. Short partials and `🎤 You: ...` lines correctly resolve to 1 row at all standard widths.

**Manual smoke test flagged for reviewer** (requires real terminal + a configured org with an assistant or squad):
- `npm run call -- <org> -a <name>` (or `-s <squad>`) and have a multi-sentence exchange. Confirm that long assistant partials overwrite in place — no stack of duplicate `🤖 Assistant: ...` lines, no leftover wrapped rows.
- Resize the terminal mid-call to a narrow width (e.g. 50 cols) and continue the conversation; partials should still overwrite cleanly when they wrap to 3+ rows.
- Pipe the output to a file: `npm run call -- <org> -a <name> | tee /tmp/call.log`. Confirm the log contains only finals (one per line), no `\r` artifacts, no duplicated partials.
- Press Ctrl+C while a partial is on screen; confirm `👋 Ending call...` prints cleanly without the partial visible above it.

Author: dhruva-vapi

src/call.ts

@@ -435,7 +435,9 @@ async function connectWebSocket(
 
     // Graceful shutdown
     const cleanup = () => {
-      console.log("\n👋 Ending call...");
+      clearWrittenLine(process.stdout, lastTranscript);
+      lastTranscript = "";
+      console.log("👋 Ending call...");
       if (micStream) {
         micStream.stop();
       }
@@ -508,12 +510,69 @@ async function connectWebSocket(
     };
 
     ws.onclose = (event) => {
-      console.log(`\n📴 Call ended (code: ${event.code})`);
+      clearWrittenLine(process.stdout, lastTranscript);
+      lastTranscript = "";
+      console.log(`📴 Call ended (code: ${event.code})`);
       cleanup();
     };
   });
 }
 
+// Approximate terminal display width of a string. Most terminals render
+// emojis and CJK glyphs as 2 cells and ASCII as 1; we use a coarse range
+// check rather than pulling in a full Unicode width table. Iteration is by
+// code point so surrogate pairs (emoji) count once.
+function getDisplayWidth(text: string): number {
+  let width = 0;
+  for (const char of text) {
+    const code = char.codePointAt(0) ?? 0;
+    if (code === 0xfe0f || (code >= 0x200b && code <= 0x200f)) {
+      // Variation selectors / zero-width joiners: no display width
+      continue;
+    }
+    if (
+      (code >= 0x1100 && code <= 0x115f) || // Hangul Jamo
+      (code >= 0x2e80 && code <= 0x303e) || // CJK radicals / punctuation
+      (code >= 0x3041 && code <= 0x33ff) || // Hiragana, Katakana, etc.
+      (code >= 0x3400 && code <= 0x4dbf) || // CJK Extension A
+      (code >= 0x4e00 && code <= 0x9fff) || // CJK Unified Ideographs
+      (code >= 0xa000 && code <= 0xa4cf) || // Yi Syllables
+      (code >= 0xac00 && code <= 0xd7a3) || // Hangul Syllables
+      (code >= 0xf900 && code <= 0xfaff) || // CJK Compatibility Ideographs
+      (code >= 0xfe30 && code <= 0xfe4f) || // CJK Compatibility Forms
+      (code >= 0xff00 && code <= 0xff60) || // Fullwidth forms
+      (code >= 0xffe0 && code <= 0xffe6) || // Fullwidth signs
+      (code >= 0x1f300 && code <= 0x1f64f) || // Emoji: misc symbols / pictographs / emoticons
+      (code >= 0x1f680 && code <= 0x1f6ff) || // Emoji: transport / map
+      (code >= 0x1f900 && code <= 0x1f9ff) || // Supplemental symbols / pictographs
+      (code >= 0x1fa70 && code <= 0x1faff) || // Symbols & pictographs extended-A
+      (code >= 0x2600 && code <= 0x27bf) // Misc symbols, dingbats
+    ) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+
+// Erase the previously-written partial transcript, accounting for terminal
+// wrap. \r alone only returns to column 0 of the *current* row, so wrapped
+// content above the cursor would otherwise stay on screen and pile up as
+// the partial is rewritten over and over.
+function clearWrittenLine(stream: NodeJS.WriteStream, text: string): void {
+  if (!text || !stream.isTTY) return;
+  const cols = stream.columns || 80;
+  const rows = Math.max(1, Math.ceil(getDisplayWidth(text) / cols));
+
+  readline.cursorTo(stream, 0);
+  readline.clearLine(stream, 0);
+  for (let i = 1; i < rows; i++) {
+    readline.moveCursor(stream, 0, -1);
+    readline.clearLine(stream, 0);
+  }
+}
+
 function handleControlMessage(
   message: ControlMessage,
   lastTranscript: string,
@@ -523,20 +582,18 @@ function handleControlMessage(
     case "transcript": {
       const tm = message as TranscriptMessage;
       const prefix = tm.role === "user" ? "🎤 You" : "🤖 Assistant";
+      const line = `${prefix}: ${tm.transcript}`;
 
       if (tm.transcriptType === "final") {
-        // Clear partial and show final
-        process.stdout.write(
-          "\r" + " ".repeat(lastTranscript.length + 20) + "\r",
-        );
-        console.log(`${prefix}: ${tm.transcript}`);
+        clearWrittenLine(process.stdout, lastTranscript);
+        console.log(line);
         setLastTranscript("");
-      } else {
-        // Show partial (overwrite previous partial)
-        const line = `${prefix}: ${tm.transcript}`;
-        process.stdout.write(
-          "\r" + " ".repeat(lastTranscript.length + 20) + "\r",
-        );
+      } else if (process.stdout.isTTY) {
+        // Live partial overwrite only makes sense in a TTY. In non-TTY
+        // output (piped to a file, CI logs, etc.) every partial would
+        // print as its own line and produce huge spam — skip them and
+        // wait for the final.
+        clearWrittenLine(process.stdout, lastTranscript);
         process.stdout.write(line);
         setLastTranscript(line);
       }
@@ -546,7 +603,9 @@ function handleControlMessage(
       const sm = message as SpeechUpdateMessage;
       if (sm.status === "started") {
         const who = sm.role === "user" ? "You" : "Assistant";
-        console.log(`\n💬 ${who} started speaking...`);
+        clearWrittenLine(process.stdout, lastTranscript);
+        if (lastTranscript) setLastTranscript("");
+        console.log(`💬 ${who} started speaking...`);
       }
       break;
     }
@@ -565,7 +624,9 @@ function handleControlMessage(
         "assistant-not-found": "Assistant not found",
       };
       const label = cm.reason ? (reasonLabels[cm.reason] ?? cm.reason) : "unknown reason";
-      console.log(`\n📞 Call ended: ${label}`);
+      clearWrittenLine(process.stdout, lastTranscript);
+      if (lastTranscript) setLastTranscript("");
+      console.log(`📞 Call ended: ${label}`);
       break;
     }
     default: