@vibeframe/cli 0.27.0

package/src/utils/subtitle.test.ts

@@ -0,0 +1,227 @@
+import { describe, it, expect } from "vitest";
+import {
+  detectFormat,
+  formatTranscript,
+  formatSRT,
+  formatVTT,
+  formatSRTTime,
+  formatVTTTime,
+  parseSRT,
+} from "./subtitle.js";
+
+describe("subtitle utilities", () => {
+  describe("detectFormat", () => {
+    it("detects SRT from file extension", () => {
+      expect(detectFormat("output.srt")).toBe("srt");
+      expect(detectFormat("video.SRT")).toBe("srt");
+    });
+
+    it("detects VTT from file extension", () => {
+      expect(detectFormat("output.vtt")).toBe("vtt");
+      expect(detectFormat("video.VTT")).toBe("vtt");
+    });
+
+    it("defaults to JSON for unknown extensions", () => {
+      expect(detectFormat("output.json")).toBe("json");
+      expect(detectFormat("output.txt")).toBe("json");
+      expect(detectFormat("output")).toBe("json");
+    });
+
+    it("uses explicit format over extension", () => {
+      expect(detectFormat("output.json", "srt")).toBe("srt");
+      expect(detectFormat("output.srt", "vtt")).toBe("vtt");
+      expect(detectFormat("output.vtt", "json")).toBe("json");
+    });
+  });
+
+  describe("formatSRTTime", () => {
+    it("formats zero", () => {
+      expect(formatSRTTime(0)).toBe("00:00:00,000");
+    });
+
+    it("formats seconds", () => {
+      expect(formatSRTTime(5.5)).toBe("00:00:05,500");
+    });
+
+    it("formats minutes", () => {
+      expect(formatSRTTime(65.25)).toBe("00:01:05,250");
+    });
+
+    it("formats hours", () => {
+      expect(formatSRTTime(3661.123)).toBe("01:01:01,123");
+    });
+  });
+
+  describe("formatVTTTime", () => {
+    it("formats zero", () => {
+      expect(formatVTTTime(0)).toBe("00:00:00.000");
+    });
+
+    it("formats seconds with period separator", () => {
+      expect(formatVTTTime(5.5)).toBe("00:00:05.500");
+    });
+
+    it("formats hours", () => {
+      expect(formatVTTTime(3661.123)).toBe("01:01:01.123");
+    });
+  });
+
+  describe("formatSRT", () => {
+    it("formats empty segments", () => {
+      expect(formatSRT([])).toBe("");
+    });
+
+    it("formats single segment", () => {
+      const segments = [
+        { startTime: 0, endTime: 2.5, text: "Hello world" },
+      ];
+
+      const result = formatSRT(segments);
+
+      expect(result).toBe(
+        "1\n00:00:00,000 --> 00:00:02,500\nHello world\n"
+      );
+    });
+
+    it("formats multiple segments", () => {
+      const segments = [
+        { startTime: 0, endTime: 2.5, text: "First line" },
+        { startTime: 2.5, endTime: 5.0, text: "Second line" },
+      ];
+
+      const result = formatSRT(segments);
+
+      expect(result).toContain("1\n00:00:00,000 --> 00:00:02,500\nFirst line\n");
+      expect(result).toContain("2\n00:00:02,500 --> 00:00:05,000\nSecond line\n");
+    });
+  });
+
+  describe("formatVTT", () => {
+    it("includes WEBVTT header", () => {
+      const result = formatVTT([]);
+      expect(result).toBe("WEBVTT\n\n");
+    });
+
+    it("formats segments with period separator", () => {
+      const segments = [
+        { startTime: 0, endTime: 2.5, text: "Hello world" },
+      ];
+
+      const result = formatVTT(segments);
+
+      expect(result).toBe(
+        "WEBVTT\n\n1\n00:00:00.000 --> 00:00:02.500\nHello world\n"
+      );
+    });
+  });
+
+  describe("formatTranscript", () => {
+    const mockResult = {
+      id: "test-id",
+      status: "completed",
+      fullText: "Hello world. This is a test.",
+      segments: [
+        { startTime: 0, endTime: 2.5, text: "Hello world." },
+        { startTime: 2.5, endTime: 5.0, text: "This is a test." },
+      ],
+    };
+
+    it("formats as JSON", () => {
+      const result = formatTranscript(mockResult, "json");
+      const parsed = JSON.parse(result);
+
+      expect(parsed.id).toBe("test-id");
+      expect(parsed.segments).toHaveLength(2);
+    });
+
+    it("formats as SRT", () => {
+      const result = formatTranscript(mockResult, "srt");
+
+      expect(result).toContain("00:00:00,000 --> 00:00:02,500");
+      expect(result).toContain("Hello world.");
+      expect(result).not.toContain("WEBVTT");
+    });
+
+    it("formats as VTT", () => {
+      const result = formatTranscript(mockResult, "vtt");
+
+      expect(result).toContain("WEBVTT");
+      expect(result).toContain("00:00:00.000 --> 00:00:02.500");
+      expect(result).toContain("Hello world.");
+    });
+
+    it("handles empty segments", () => {
+      const emptyResult = { id: "test", status: "completed" };
+
+      expect(formatTranscript(emptyResult, "srt")).toBe("");
+      expect(formatTranscript(emptyResult, "vtt")).toBe("WEBVTT\n\n");
+    });
+  });
+
+  describe("parseSRT", () => {
+    it("parses valid SRT content", () => {
+      const srt = `1
+00:00:00,000 --> 00:00:02,500
+Hello world
+
+2
+00:00:02,500 --> 00:00:05,000
+This is a test
+`;
+      const segments = parseSRT(srt);
+
+      expect(segments).toHaveLength(2);
+      expect(segments[0].startTime).toBe(0);
+      expect(segments[0].endTime).toBe(2.5);
+      expect(segments[0].text).toBe("Hello world");
+      expect(segments[1].startTime).toBe(2.5);
+      expect(segments[1].endTime).toBe(5);
+      expect(segments[1].text).toBe("This is a test");
+    });
+
+    it("parses multi-line subtitle text", () => {
+      const srt = `1
+00:00:00,000 --> 00:00:03,000
+First line
+Second line
+`;
+      const segments = parseSRT(srt);
+
+      expect(segments).toHaveLength(1);
+      expect(segments[0].text).toBe("First line\nSecond line");
+    });
+
+    it("returns empty array for empty content", () => {
+      expect(parseSRT("")).toHaveLength(0);
+      expect(parseSRT("  \n  \n  ")).toHaveLength(0);
+    });
+
+    it("handles timestamps with hours", () => {
+      const srt = `1
+01:30:15,500 --> 02:00:00,000
+Long video subtitle
+`;
+      const segments = parseSRT(srt);
+
+      expect(segments).toHaveLength(1);
+      expect(segments[0].startTime).toBe(5415.5); // 1*3600 + 30*60 + 15 + 0.5
+      expect(segments[0].endTime).toBe(7200); // 2*3600
+    });
+
+    it("roundtrips with formatSRT", () => {
+      const original = [
+        { startTime: 0, endTime: 2.5, text: "Hello world" },
+        { startTime: 2.5, endTime: 5, text: "Second line" },
+      ];
+
+      const srtString = formatSRT(original);
+      const parsed = parseSRT(srtString);
+
+      expect(parsed).toHaveLength(2);
+      expect(parsed[0].text).toBe("Hello world");
+      expect(parsed[1].text).toBe("Second line");
+      expect(parsed[0].startTime).toBe(0);
+      expect(parsed[0].endTime).toBe(2.5);
+    });
+  });
+});

package/src/utils/subtitle.ts

@@ -0,0 +1,169 @@
+/**
+ * Subtitle format utilities for SRT/VTT generation
+ */
+
+export type SubtitleFormat = "json" | "srt" | "vtt";
+
+export interface SubtitleSegment {
+  startTime: number;
+  endTime: number;
+  text: string;
+}
+
+export interface TranscriptResult {
+  id: string;
+  status: string;
+  fullText?: string;
+  segments?: SubtitleSegment[];
+  detectedLanguage?: string;
+  error?: string;
+}
+
+/**
+ * Detect subtitle format from file extension or explicit format option
+ */
+export function detectFormat(outputPath: string, explicitFormat?: string): SubtitleFormat {
+  if (explicitFormat) {
+    const fmt = explicitFormat.toLowerCase();
+    if (fmt === "srt" || fmt === "vtt" || fmt === "json") {
+      return fmt;
+    }
+  }
+
+  const ext = outputPath.toLowerCase().split(".").pop();
+  if (ext === "srt") return "srt";
+  if (ext === "vtt") return "vtt";
+  return "json";
+}
+
+/**
+ * Format transcript result to the specified format
+ */
+export function formatTranscript(result: TranscriptResult, format: SubtitleFormat): string {
+  if (format === "json") {
+    return JSON.stringify(result, null, 2);
+  }
+
+  const segments = result.segments || [];
+
+  if (format === "srt") {
+    return formatSRT(segments);
+  }
+
+  return formatVTT(segments);
+}
+
+/**
+ * Format segments as SRT (SubRip Subtitle)
+ *
+ * SRT Format:
+ * 1
+ * 00:00:00,000 --> 00:00:02,500
+ * Hello world
+ */
+export function formatSRT(segments: SubtitleSegment[]): string {
+  return segments.map((seg, index) => {
+    const start = formatSRTTime(seg.startTime);
+    const end = formatSRTTime(seg.endTime);
+    return `${index + 1}\n${start} --> ${end}\n${seg.text}\n`;
+  }).join("\n");
+}
+
+/**
+ * Format segments as WebVTT (Web Video Text Tracks)
+ *
+ * VTT Format:
+ * WEBVTT
+ *
+ * 1
+ * 00:00:00.000 --> 00:00:02.500
+ * Hello world
+ */
+export function formatVTT(segments: SubtitleSegment[]): string {
+  const header = "WEBVTT\n\n";
+  const cues = segments.map((seg, index) => {
+    const start = formatVTTTime(seg.startTime);
+    const end = formatVTTTime(seg.endTime);
+    return `${index + 1}\n${start} --> ${end}\n${seg.text}\n`;
+  }).join("\n");
+  return header + cues;
+}
+
+/**
+ * Format time for SRT (uses comma for milliseconds)
+ * Format: HH:MM:SS,mmm
+ */
+export function formatSRTTime(seconds: number): string {
+  const hours = Math.floor(seconds / 3600);
+  const mins = Math.floor((seconds % 3600) / 60);
+  const secs = Math.floor(seconds % 60);
+  const ms = Math.round((seconds % 1) * 1000);
+
+  return `${pad(hours, 2)}:${pad(mins, 2)}:${pad(secs, 2)},${pad(ms, 3)}`;
+}
+
+/**
+ * Format time for VTT (uses period for milliseconds)
+ * Format: HH:MM:SS.mmm
+ */
+export function formatVTTTime(seconds: number): string {
+  const hours = Math.floor(seconds / 3600);
+  const mins = Math.floor((seconds % 3600) / 60);
+  const secs = Math.floor(seconds % 60);
+  const ms = Math.round((seconds % 1) * 1000);
+
+  return `${pad(hours, 2)}:${pad(mins, 2)}:${pad(secs, 2)}.${pad(ms, 3)}`;
+}
+
+/**
+ * Parse SRT content into SubtitleSegment array
+ *
+ * Handles standard SRT format:
+ * 1
+ * 00:00:00,000 --> 00:00:02,500
+ * Hello world
+ */
+export function parseSRT(content: string): SubtitleSegment[] {
+  const segments: SubtitleSegment[] = [];
+  const blocks = content.trim().split(/\n\s*\n/);
+
+  for (const block of blocks) {
+    const lines = block.trim().split("\n");
+    if (lines.length < 3) continue;
+
+    // Line 0: sequence number (skip)
+    // Line 1: timestamp line
+    const timeLine = lines[1].trim();
+    const timeMatch = timeLine.match(
+      /(\d{2}:\d{2}:\d{2}[,.]\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2}[,.]\d{3})/,
+    );
+    if (!timeMatch) continue;
+
+    const startTime = parseSRTTimestamp(timeMatch[1]);
+    const endTime = parseSRTTimestamp(timeMatch[2]);
+    // Lines 2+: subtitle text (may be multi-line)
+    const text = lines.slice(2).join("\n").trim();
+
+    if (text) {
+      segments.push({ startTime, endTime, text });
+    }
+  }
+
+  return segments;
+}
+
+function parseSRTTimestamp(timestamp: string): number {
+  // Accept both comma (SRT) and period (VTT) as ms separator
+  const normalized = timestamp.replace(",", ".");
+  const parts = normalized.split(":");
+  const hours = parseInt(parts[0], 10);
+  const mins = parseInt(parts[1], 10);
+  const secParts = parts[2].split(".");
+  const secs = parseInt(secParts[0], 10);
+  const ms = parseInt(secParts[1], 10);
+  return hours * 3600 + mins * 60 + secs + ms / 1000;
+}
+
+function pad(num: number, size: number): string {
+  return num.toString().padStart(size, "0");
+}

package/src/utils/tty.ts

@@ -0,0 +1,196 @@
+/**
+ * TTY Input Utilities
+ * Handles stdin fallback to /dev/tty for piped environments
+ */
+
+import { createInterface, Interface } from "node:readline";
+import { ReadStream } from "node:tty";
+
+let ttyStream: ReadStream | null = null;
+
+/**
+ * Get a TTY-capable input stream
+ * Falls back to /dev/tty when stdin is piped (e.g., from curl)
+ */
+export function getTTYInputStream(): typeof process.stdin | ReadStream {
+  if (process.stdin.isTTY) {
+    return process.stdin;
+  }
+
+  // stdin is not a TTY (piped), open /dev/tty directly
+  if (!ttyStream) {
+    try {
+      // Open /dev/tty as a TTY stream
+      const fd = require("fs").openSync("/dev/tty", "r");
+      ttyStream = new ReadStream(fd);
+    } catch {
+      // Fallback to stdin if /dev/tty is not available
+      console.warn("Warning: Cannot open /dev/tty, interactive input may not work");
+      return process.stdin;
+    }
+  }
+  return ttyStream;
+}
+
+/**
+ * Check if we have TTY input available
+ */
+export function hasTTY(): boolean {
+  if (process.stdin.isTTY) return true;
+
+  // Try to actually open /dev/tty to verify it's accessible
+  try {
+    const fs = require("fs");
+    const fd = fs.openSync("/dev/tty", "r");
+    fs.closeSync(fd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Close the TTY stream if we opened one
+ */
+export function closeTTYStream(): void {
+  if (ttyStream) {
+    ttyStream.destroy();
+    ttyStream = null;
+  }
+}
+
+/**
+ * Create a readline interface with TTY support
+ */
+export function createTTYInterface(options?: {
+  prompt?: string;
+  historySize?: number;
+}): Interface {
+  const input = getTTYInputStream();
+  return createInterface({
+    input,
+    output: process.stdout,
+    terminal: true,
+    historySize: options?.historySize ?? 100,
+    prompt: options?.prompt ?? "> ",
+  });
+}
+
+/**
+ * Prompt for input (single line)
+ * Throws in non-TTY environments to prevent hanging.
+ */
+export async function prompt(question: string): Promise<string> {
+  if (!hasTTY()) {
+    throw new Error(
+      "Interactive input required but no TTY available. " +
+        "Use command flags to provide values non-interactively."
+    );
+  }
+  const input = getTTYInputStream();
+  const rl = createInterface({
+    input,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+/**
+ * Prompt for hidden input (password/API key)
+ * Characters are not echoed to terminal
+ */
+export async function promptHidden(question: string): Promise<string> {
+  const input = getTTYInputStream() as ReadStream;
+
+  return new Promise((resolve) => {
+    process.stdout.write(question);
+
+    let value = "";
+
+    // Check if we can use raw mode
+    if (typeof input.setRawMode === "function") {
+      input.setRawMode(true);
+      input.resume();
+      input.setEncoding("utf8");
+
+      const onData = (char: string) => {
+        if (char === "\n" || char === "\r" || char === "\u0004") {
+          // Enter or EOF
+          input.setRawMode(false);
+          input.removeListener("data", onData);
+          process.stdout.write("\n");
+          resolve(value);
+        } else if (char === "\u0003") {
+          // Ctrl+C
+          input.setRawMode(false);
+          process.stdout.write("\n");
+          process.exit(1);
+        } else if (char === "\u007F" || char === "\b") {
+          // Backspace
+          if (value.length > 0) {
+            value = value.slice(0, -1);
+            // Clear character from display
+            process.stdout.write("\b \b");
+          }
+        } else if (char >= " ") {
+          // Printable character (may be multiple chars when pasting)
+          value += char;
+          process.stdout.write("*".repeat(char.length)); // Show asterisk for each char
+        }
+      };
+
+      input.on("data", onData);
+    } else {
+      // Fallback: no raw mode available, input will be visible
+      const rl = createInterface({ input, output: process.stdout });
+      rl.question("", (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    }
+  });
+}
+
+/**
+ * Prompt for selection from a list (1-based index)
+ */
+export async function promptSelect(
+  question: string,
+  options: string[],
+  defaultIndex = 0
+): Promise<number> {
+  // Display options
+  for (let i = 0; i < options.length; i++) {
+    const marker = i === defaultIndex ? "→" : " ";
+    console.log(`   ${marker} ${i + 1}. ${options[i]}`);
+  }
+  console.log();
+
+  const answer = await prompt(question);
+  const index = parseInt(answer, 10) - 1;
+
+  if (isNaN(index) || index < 0 || index >= options.length) {
+    return defaultIndex;
+  }
+  return index;
+}
+
+/**
+ * Prompt for yes/no confirmation
+ */
+export async function promptConfirm(
+  question: string,
+  defaultYes = true
+): Promise<boolean> {
+  const hint = defaultYes ? "(Y/n)" : "(y/N)";
+  const answer = await prompt(`${question} ${hint}: `);
+
+  if (answer === "") return defaultYes;
+  return answer.toLowerCase().startsWith("y");
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}