@vibeframe/cli 0.27.0 → 0.30.0

package/src/utils/subtitle.test.ts

@@ -1,227 +0,0 @@
-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

@@ -1,169 +0,0 @@
-/**
- * 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

@@ -1,196 +0,0 @@
-/**
- * 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

@@ -1,20 +0,0 @@
-{
-  "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"]
-}