@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/tts-YCCQHZD4.js

@@ -0,0 +1,234 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  BUNDLED_VOICES,
+  DEFAULT_VOICE,
+  SUPPORTED_LANGS,
+  inferLangFromVoiceId,
+  isSupportedLang
+} from "./chunk-AHPGAESX.js";
+import "./chunk-WQ6ZXHFQ.js";
+import {
+  ft
+} from "./chunk-WMQNIQDJ.js";
+import {
+  isTextFile
+} from "./chunk-K4WKGXRC.js";
+import {
+  errorBox
+} from "./chunk-P5ZBLXJ6.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  failCommand,
+  failUsage
+} from "./chunk-JVBRJMOP.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/tts.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+var examples = [
+  ["Generate speech from text", 'framey tts "Welcome to Framey"'],
+  ["Choose a voice", 'framey tts "Hello world" --voice am_adam'],
+  ["Save to a specific file", 'framey tts "Intro" --voice bf_emma --output narration.wav'],
+  ["Adjust speech speed", 'framey tts "Slow and clear" --speed 0.8'],
+  [
+    "Generate Spanish speech",
+    'framey tts "La reuni\xF3n empieza a las nueve" --voice ef_dora --output es.wav'
+  ],
+  [
+    "Override phonemizer language",
+    'framey tts "Ciao a tutti" --voice af_heart --lang it --output accented.wav'
+  ],
+  ["Read text from a file", "framey tts script.txt"],
+  ["List available voices", "framey tts --list"]
+];
+var voiceList = BUNDLED_VOICES.map((v) => `${v.id} (${v.label})`).join(", ");
+var langList = SUPPORTED_LANGS.join(", ");
+var tts_default = defineCommand({
+  meta: {
+    name: "tts",
+    description: "Generate speech audio from text using a local AI model (Kokoro-82M)"
+  },
+  args: {
+    input: {
+      type: "positional",
+      description: "Text to speak, or path to a .txt file",
+      required: false
+    },
+    "text-file": {
+      type: "string",
+      description: "Read text from a .txt file (compatibility alias)"
+    },
+    output: {
+      type: "string",
+      description: "Output file path (default: speech.wav in current directory)",
+      alias: ["o", "out"]
+    },
+    voice: {
+      type: "string",
+      description: `Voice ID (default: ${DEFAULT_VOICE}). Options: ${voiceList}`,
+      alias: "v"
+    },
+    speed: {
+      type: "string",
+      description: "Speech speed multiplier (default: 1.0)",
+      alias: "s"
+    },
+    lang: {
+      type: "string",
+      description: `Phonemizer language (auto-detected from voice prefix when omitted). Options: ${langList}`,
+      alias: "l"
+    },
+    list: {
+      type: "boolean",
+      description: "List available voices and exit",
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON",
+      default: false
+    }
+  },
+  // fallow-ignore-next-line complexity
+  async run({ args }) {
+    if (args["text-file"] && args.input) {
+      console.error(c.error("Pass text to speak or --text-file, not both."));
+      failUsage();
+    }
+    if (args.list) {
+      return listVoices(args.json);
+    }
+    const input = args["text-file"] ?? args.input;
+    if (!input) {
+      console.error(c.error("Provide text to speak, or use --list to see available voices."));
+      failCommand();
+    }
+    let text;
+    if (args["text-file"] !== void 0 || isTextFile(input)) {
+      text = readFileSync(resolve(input), "utf-8").trim();
+      if (!text) {
+        console.error(c.error("File is empty."));
+        failCommand();
+      }
+    } else {
+      text = input;
+    }
+    if (!text.trim()) {
+      console.error(c.error("No text provided."));
+      failCommand();
+    }
+    const output = resolve(args.output ?? "speech.wav");
+    const voice = args.voice ?? DEFAULT_VOICE;
+    const speed = args.speed === void 0 ? 1 : Number(args.speed);
+    if (!Number.isFinite(speed) || speed < 0.1 || speed > 3) {
+      console.error(c.error("Speed must be a number between 0.1 and 3.0"));
+      failCommand();
+    }
+    const inferredLang = inferLangFromVoiceId(voice);
+    let lang = inferredLang;
+    if (args.lang != null) {
+      const requested = String(args.lang).toLowerCase();
+      if (!isSupportedLang(requested)) {
+        errorBox("Invalid --lang", `Got "${args.lang}". Must be one of: ${langList}.`);
+        failCommand();
+      }
+      lang = requested;
+    }
+    if (!args.json && args.lang != null && lang !== inferredLang) {
+      console.log(
+        c.dim(
+          `  Note: voice "${voice}" is ${inferredLang}, rendering with --lang ${lang} instead.`
+        )
+      );
+    }
+    const { synthesize } = await import("./synthesize-PKTB5ATG.js");
+    const spin = args.json ? null : ft();
+    spin?.start(`Generating speech with ${c.accent(voice)} (${lang})...`);
+    try {
+      const result = await synthesize(text, output, {
+        voice,
+        speed,
+        lang,
+        onProgress: spin ? (msg) => spin.message(msg) : void 0
+      });
+      if (args.json) {
+        console.log(
+          JSON.stringify({
+            ok: true,
+            voice,
+            speed,
+            lang,
+            langApplied: result.langApplied,
+            durationSeconds: result.durationSeconds,
+            outputPath: result.outputPath
+          })
+        );
+      } else {
+        spin?.stop(
+          c.success(
+            `Generated ${c.accent(result.durationSeconds.toFixed(1) + "s")} of speech \u2192 ${c.accent(result.outputPath)}`
+          )
+        );
+        if (args.lang != null && !result.langApplied) {
+          console.log(
+            c.dim(
+              "  Note: installed kokoro-onnx version does not support the --lang kwarg; phonemization used Kokoro's default."
+            )
+          );
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (args.json) {
+        console.log(JSON.stringify({ ok: false, error: message }));
+      } else {
+        spin?.stop(c.error(`Speech synthesis failed: ${message}`));
+      }
+      failCommand();
+    }
+  }
+});
+function listVoices(json) {
+  const rows = BUNDLED_VOICES.map((v) => ({ ...v, defaultLang: inferLangFromVoiceId(v.id) }));
+  if (json) {
+    console.log(JSON.stringify(rows));
+    return;
+  }
+  console.log(`
+${c.bold("Available voices")} (Kokoro-82M)
+`);
+  console.log(
+    `  ${c.dim("ID")}                ${c.dim("Name")}         ${c.dim("Language")}   ${c.dim("Lang code")}  ${c.dim("Gender")}`
+  );
+  console.log(`  ${c.dim("\u2500".repeat(72))}`);
+  for (const row of rows) {
+    const id = row.id.padEnd(18);
+    const label = row.label.padEnd(13);
+    const lang = row.language.padEnd(10);
+    const code = row.defaultLang.padEnd(10);
+    console.log(`  ${c.accent(id)} ${label} ${lang} ${code} ${row.gender}`);
+  }
+  console.log(
+    `
+  ${c.dim("Use any Kokoro voice ID \u2014 see https://github.com/thewh1teagle/kokoro-onnx for all 54 voices")}`
+  );
+  console.log(
+    `  ${c.dim("Override phonemizer with --lang <" + SUPPORTED_LANGS.join("|") + ">")}
+`
+  );
+}
+export {
+  tts_default as default,
+  examples
+};

package/vendor/framey/dist/urlDownloader-H2LXLG4U.js

@@ -0,0 +1,48 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import "./chunk-BZ56MTDX.js";
+import {
+  downloadToTemp,
+  fetchPublicHttpsText,
+  isHttpUrl,
+  safeDownloadUrlIdentity,
+  writeUrlDownloadTelemetry
+} from "./chunk-TIQB63MX.js";
+import "./chunk-IZCW2NKT.js";
+import "./chunk-RNV3DM4S.js";
+import "./chunk-DLA44CMS.js";
+import "./chunk-UJZREAV6.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-X7HBSTCZ.js";
+import "./chunk-B7RJV74O.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-K4MJX7SR.js";
+import "./chunk-4UMPIPCQ.js";
+import "./chunk-4P7NX5BM.js";
+import "./chunk-VAS6HQX3.js";
+import "./chunk-6BNTGNGD.js";
+import "./chunk-CZGHFATT.js";
+import "./chunk-PKZ7RK5N.js";
+import "./chunk-W2LGJSEN.js";
+import "./chunk-MMQ52NIZ.js";
+import "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-RXATE6FZ.js";
+import "./chunk-3422KMTD.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  downloadToTemp,
+  fetchPublicHttpsText,
+  isHttpUrl,
+  safeDownloadUrlIdentity,
+  writeUrlDownloadTelemetry
+};