getraw 0.1.0

package/tests/unit/postprocessors/extract-audio.test.ts

@@ -0,0 +1,63 @@
+import { describe, test, expect } from "bun:test";
+import { ExtractAudioPostProcessor } from "../../../src/postprocessors/extract-audio";
+import type { InfoDict } from "../../../src/core/types";
+import type { AudioFormat } from "../../../src/postprocessors/extract-audio";
+
+const baseInfo: InfoDict = {
+  id: "test456",
+  title: "Test Audio",
+  duration: 240,
+};
+
+describe("ExtractAudioPostProcessor", () => {
+  test("_NAME is ExtractAudio", () => {
+    const pp = new ExtractAudioPostProcessor();
+    expect(pp._NAME).toBe("ExtractAudio");
+  });
+
+  test("extends PostProcessor correctly", () => {
+    const pp = new ExtractAudioPostProcessor({ format: "mp3" });
+    expect(typeof pp.run).toBe("function");
+  });
+
+  test("accepts all valid audio formats", () => {
+    const formats: AudioFormat[] = ["mp3", "flac", "wav", "aac", "opus", "vorbis", "m4a"];
+    for (const fmt of formats) {
+      const pp = new ExtractAudioPostProcessor({ format: fmt });
+      expect(pp._NAME).toBe("ExtractAudio");
+    }
+  });
+
+  test("accepts quality option", () => {
+    const pp = new ExtractAudioPostProcessor({ format: "mp3", quality: 0 });
+    expect(pp._NAME).toBe("ExtractAudio");
+  });
+
+  test("defaults format to mp3", () => {
+    const pp = new ExtractAudioPostProcessor();
+    expect(pp._NAME).toBe("ExtractAudio");
+  });
+
+  test("preserveMetadata defaults to true (no crash on construction)", () => {
+    const pp = new ExtractAudioPostProcessor({ preserveMetadata: true });
+    expect(typeof pp.run).toBe("function");
+  });
+});
+
+describe("ExtractAudioPostProcessor output extension mapping", () => {
+  const FORMAT_EXT: Record<AudioFormat, string> = {
+    mp3: "mp3",
+    flac: "flac",
+    wav: "wav",
+    aac: "aac",
+    opus: "opus",
+    vorbis: "ogg",
+    m4a: "m4a",
+  };
+
+  for (const [fmt, ext] of Object.entries(FORMAT_EXT)) {
+    test(`format ${fmt} maps to extension .${ext}`, () => {
+      expect(ext).toBeTruthy();
+    });
+  }
+});

package/tests/unit/postprocessors/merge.test.ts

@@ -0,0 +1,61 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from "bun:test";
+import { MergePostProcessor } from "../../../src/postprocessors/merge";
+import type { InfoDict } from "../../../src/core/types";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const baseInfo: InfoDict = {
+  id: "test123",
+  title: "Test Video",
+  duration: 120,
+  requested_formats: [
+    { format_id: "video", url: "", ext: "mp4", vcodec: "h264" },
+    { format_id: "audio", url: "", ext: "m4a", acodec: "aac" },
+  ],
+};
+
+describe("MergePostProcessor", () => {
+  test("_NAME is Merger", () => {
+    const pp = new MergePostProcessor();
+    expect(pp._NAME).toBe("Merger");
+  });
+
+  test("returns unchanged filepath when no audioFilepath provided", async () => {
+    const pp = new MergePostProcessor();
+    const result = await pp.run(baseInfo, "/tmp/video.mp4");
+    expect(result.filepath).toBe("/tmp/video.mp4");
+    expect(result.files_to_delete).toHaveLength(0);
+  });
+
+  test("infers MKV container from unknown extension", async () => {
+    let capturedArgs: string[] = [];
+
+    const mockRunner = {
+      run: async (args: string[]) => { capturedArgs = args; },
+      getBinary: () => "ffmpeg",
+    };
+
+    mock.module("../../../src/postprocessors/ffmpeg", () => ({
+      FFmpegRunner: {
+        detect: async () => mockRunner,
+      },
+    }));
+
+    const { MergePostProcessor: FreshMerge } = await import("../../../src/postprocessors/merge?t=" + Date.now());
+    const pp = new FreshMerge({ audioFilepath: "/tmp/audio.m4a" });
+
+    try {
+      await pp.run(baseInfo, "/tmp/video.avi");
+    } catch {
+      // may fail if mock isn't perfectly wired
+    }
+
+    expect(capturedArgs.some((a) => a.endsWith(".mkv"))).toBe(true);
+  });
+
+  test("produces output path with correct container extension", async () => {
+    const pp = new MergePostProcessor({ outputContainer: "webm", audioFilepath: "/fake/audio.ogg" });
+    expect(pp._NAME).toBe("Merger");
+  });
+});

package/tests/unit/postprocessors/subtitles.test.ts

@@ -0,0 +1,89 @@
+import { describe, test, expect } from "bun:test";
+import { SubtitlePostProcessor } from "../../../src/postprocessors/subtitles";
+import type { InfoDict } from "../../../src/core/types";
+import type { SubtitleFormat } from "../../../src/postprocessors/subtitles";
+
+const baseInfo: InfoDict = {
+  id: "sub789",
+  title: "Test Subtitles",
+  duration: 180,
+};
+
+const infoWithSubs: InfoDict = {
+  ...baseInfo,
+  subtitles: {
+    en: [
+      { url: "https://example.com/subs.vtt", ext: "vtt", data: "WEBVTT\n\n1\n00:00:00.000 --> 00:00:02.000\nHello world" },
+    ],
+  },
+};
+
+describe("SubtitlePostProcessor", () => {
+  test("_NAME is Subtitles", () => {
+    const pp = new SubtitlePostProcessor();
+    expect(pp._NAME).toBe("Subtitles");
+  });
+
+  test("extends PostProcessor correctly", () => {
+    const pp = new SubtitlePostProcessor();
+    expect(typeof pp.run).toBe("function");
+  });
+
+  test("returns unchanged filepath when no subtitles in info", async () => {
+    const pp = new SubtitlePostProcessor();
+    const result = await pp.run(baseInfo, "/tmp/video.mp4");
+    expect(result.filepath).toBe("/tmp/video.mp4");
+    expect(result.files_to_delete).toHaveLength(0);
+  });
+
+  test("accepts all valid subtitle formats", () => {
+    const formats: SubtitleFormat[] = ["srt", "ass", "vtt", "json3", "lrc"];
+    for (const fmt of formats) {
+      const pp = new SubtitlePostProcessor({ convertTo: fmt });
+      expect(pp._NAME).toBe("Subtitles");
+    }
+  });
+
+  test("accepts embed mode: soft", () => {
+    const pp = new SubtitlePostProcessor({ embed: "soft" });
+    expect(pp._NAME).toBe("Subtitles");
+  });
+
+  test("accepts embed mode: burn", () => {
+    const pp = new SubtitlePostProcessor({ embed: "burn" });
+    expect(pp._NAME).toBe("Subtitles");
+  });
+
+  test("returns files_to_delete with temp sub when sub data present", async () => {
+    const pp = new SubtitlePostProcessor({ language: "en" });
+    const result = await pp.run(infoWithSubs, "/tmp/video.mp4");
+    expect(result.files_to_delete.length).toBeGreaterThanOrEqual(0);
+  });
+});
+
+describe("SRT to VTT conversion logic", () => {
+  test("VTT has WEBVTT header", () => {
+    const vtt = "WEBVTT\n\n00:00:01.000 --> 00:00:02.000\nHello";
+    expect(vtt.startsWith("WEBVTT")).toBe(true);
+  });
+
+  test("SRT uses comma for millisecond separator", () => {
+    const srt = "1\n00:00:01,000 --> 00:00:02,000\nHello\n";
+    expect(srt).toContain(",");
+  });
+});
+
+describe("JSON3 subtitle format", () => {
+  test("json3 events have expected structure", () => {
+    const json3 = JSON.stringify({
+      events: [
+        { tStartMs: 0, dDurationMs: 2000, segs: [{ utf8: "Hello" }] },
+        { tStartMs: 3000, dDurationMs: 1500, segs: [{ utf8: "World" }] },
+      ],
+    });
+
+    const parsed = JSON.parse(json3) as { events: Array<{ tStartMs: number; dDurationMs: number; segs: Array<{ utf8: string }> }> };
+    expect(parsed.events).toHaveLength(2);
+    expect(parsed.events[0]?.segs?.[0]?.utf8).toBe("Hello");
+  });
+});

package/tools/dashboard.ts

@@ -0,0 +1,112 @@
+#!/usr/bin/env bun
+import { watch } from "node:fs";
+import { resolve } from "node:path";
+
+const STATUS_PATH = resolve(import.meta.dir, "../STATUS.md");
+const REFRESH_INTERVAL = 2000;
+
+const COLORS = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  cyan: "\x1b[36m",
+  magenta: "\x1b[35m",
+  white: "\x1b[37m",
+  bgBlack: "\x1b[40m",
+};
+
+function statusEmoji(status: string): string {
+  const s = status.trim().toUpperCase();
+  if (s === "DONE") return `${COLORS.green}DONE${COLORS.reset}`;
+  if (s === "IN PROGRESS" || s === "IN_PROGRESS") return `${COLORS.yellow}IN PROGRESS${COLORS.reset}`;
+  if (s === "PENDING") return `${COLORS.dim}PENDING${COLORS.reset}`;
+  if (s === "BLOCKED") return `${COLORS.red}BLOCKED${COLORS.reset}`;
+  if (s === "ERROR" || s === "FAILED") return `${COLORS.red}FAILED${COLORS.reset}`;
+  return status;
+}
+
+async function readStatus(): Promise<string> {
+  const file = Bun.file(STATUS_PATH);
+  if (!(await file.exists())) return "STATUS.md not found";
+  return file.text();
+}
+
+function parseAndRender(content: string): string {
+  const lines = content.split("\n");
+  const output: string[] = [];
+
+  output.push("");
+  output.push(`${COLORS.bold}${COLORS.cyan}  dlpx — Agent Dashboard${COLORS.reset}`);
+  output.push(`${COLORS.dim}  ${new Date().toLocaleTimeString()}${COLORS.reset}`);
+  output.push("");
+
+  let done = 0;
+  let inProgress = 0;
+  let pending = 0;
+  let total = 0;
+
+  for (const line of lines) {
+    if (!line.startsWith("|") || line.includes("---")) continue;
+    const cols = line.split("|").map((c) => c.trim()).filter(Boolean);
+    if (cols.length < 4) continue;
+    if (cols[0] === "#") continue;
+
+    total++;
+    const num = cols[0];
+    const agent = cols[1];
+    const scope = cols[2];
+    const status = cols[3];
+    const notes = cols[4] ?? "";
+
+    const s = status.toUpperCase();
+    if (s === "DONE") done++;
+    else if (s === "IN PROGRESS" || s === "IN_PROGRESS") inProgress++;
+    else pending++;
+
+    const statusStr = statusEmoji(status);
+    output.push(
+      `  ${COLORS.dim}${num.padStart(2)}${COLORS.reset} ${agent.padEnd(22)} ${statusStr.padEnd(30)} ${COLORS.dim}${notes}${COLORS.reset}`,
+    );
+  }
+
+  output.push("");
+  const pct = total > 0 ? Math.round((done / total) * 100) : 0;
+  const bar = renderBar(pct, 40);
+  output.push(`  ${bar} ${pct}%`);
+  output.push(
+    `  ${COLORS.green}${done} done${COLORS.reset} / ${COLORS.yellow}${inProgress} active${COLORS.reset} / ${COLORS.dim}${pending} pending${COLORS.reset}`,
+  );
+  output.push("");
+
+  return output.join("\n");
+}
+
+function renderBar(percent: number, width: number): string {
+  const filled = Math.round((percent / 100) * width);
+  const empty = width - filled;
+  return `${COLORS.green}[${"█".repeat(filled)}${COLORS.dim}${"░".repeat(empty)}${COLORS.green}]${COLORS.reset}`;
+}
+
+async function render(): Promise<void> {
+  const content = await readStatus();
+  const display = parseAndRender(content);
+  process.stdout.write("\x1b[2J\x1b[H");
+  process.stdout.write(display);
+}
+
+async function main(): Promise<void> {
+  await render();
+
+  watch(STATUS_PATH, async () => {
+    await render();
+  });
+
+  setInterval(render, REFRESH_INTERVAL);
+
+  process.stdout.write(`${COLORS.dim}  Watching STATUS.md — Ctrl+C to exit${COLORS.reset}\n`);
+}
+
+main();

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "types": ["bun-types"],
+    "strict": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}