@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/tokens-OLECWDFK.js

@@ -0,0 +1,92 @@
+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 {
+  FigmaClientError,
+  createFigmaClient,
+  parseFigmaRef,
+  tokensToVariables,
+  upsertBindings,
+  withFigmaErrors
+} from "./chunk-ZW6DURPF.js";
+import "./chunk-P5ZBLXJ6.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import "./chunk-VORQIH64.js";
+import "./chunk-JVBRJMOP.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/figma/tokens.ts
+import { writeFileSync } from "fs";
+import { join } from "path";
+async function runTokensImport(refInput, deps) {
+  const { fileKey } = parseFigmaRef(refInput);
+  const { version } = await deps.client.fileVersion(fileKey);
+  const sidecarPath = join(deps.projectDir, "figma-tokens.json");
+  let vars = null;
+  try {
+    vars = await deps.client.variables(fileKey);
+  } catch (err) {
+    if (!(err instanceof FigmaClientError) || err.code !== "REQUIRES_ENTERPRISE") throw err;
+  }
+  if (vars !== null) {
+    const out = tokensToVariables(vars, { fileKey, version });
+    upsertBindings(deps.projectDir, out.bindings);
+    writeFileSync(sidecarPath, JSON.stringify(out.sidecar, null, 2) + "\n");
+    return { mode: "variables", entries: out.entries, sidecarPath };
+  }
+  const styles = await deps.client.styles(fileKey);
+  const sidecar = {
+    source: { fileKey, version },
+    tokens: styles.map((s) => ({
+      name: s.name,
+      type: `style:${s.style_type}`,
+      figmaId: s.node_id ?? s.key,
+      key: s.key,
+      value: null
+    }))
+  };
+  writeFileSync(sidecarPath, JSON.stringify(sidecar, null, 2) + "\n");
+  return { mode: "styles", entries: [], sidecarPath, styleCount: styles.length };
+}
+var tokens_default = defineCommand({
+  meta: { name: "tokens", description: "Import figma variables/styles as brand tokens" },
+  args: {
+    ref: { type: "positional", description: "figma fileKey or URL", required: true },
+    dir: { type: "string", description: "project directory", default: "." }
+  },
+  async run({ args }) {
+    await withFigmaErrors("figma:tokens", async () => {
+      const t0 = Date.now();
+      const client = createFigmaClient({ token: process.env.FIGMA_TOKEN ?? "" });
+      const result = await runTokensImport(args.ref, { projectDir: args.dir, client });
+      if (result.mode === "styles") {
+        console.log(
+          (result.styleCount ?? 0) > 0 ? `variables are Enterprise-gated on this plan \u2014 recorded ${result.styleCount} published style(s) instead (style values resolve at component-import time)` : "variables are Enterprise-gated on this plan, and this file has no published library styles to fall back to \u2014 nothing recorded. Publish the file's styles to a team library, or read variables via the Figma MCP connector's get_variable_defs instead (works on any plan, rate-limited)."
+        );
+      }
+      console.log(`wrote ${result.sidecarPath} (${result.mode})`);
+      if (result.entries.length > 0) {
+        console.log("add to data-composition-variables:");
+        console.log(JSON.stringify(result.entries, null, 2));
+      }
+      const { trackFigmaImport } = await import("./telemetry-UN55N6U6.js");
+      trackFigmaImport({
+        phase: "tokens",
+        tokensMode: result.mode,
+        entryCount: result.entries.length,
+        durationMs: Date.now() - t0
+      });
+    });
+  }
+});
+export {
+  tokens_default as default,
+  runTokensImport
+};

package/vendor/framey/dist/transcribe-O7HQKMIV.js

@@ -0,0 +1,331 @@
+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 {
+  MIN_TIMEOUT_MS,
+  TranscribeError,
+  runTranscribe
+} from "./chunk-VHNLZAE2.js";
+import "./chunk-IG7NDKXO.js";
+import "./chunk-R6YBK4XX.js";
+import "./chunk-VMC4WSH5.js";
+import "./chunk-6BEFEWFB.js";
+import {
+  createProgressWriter
+} from "./chunk-HTUHQKDB.js";
+import "./chunk-HFQ4CWHA.js";
+import {
+  DEFAULT_MODEL
+} from "./chunk-HPDTCOKE.js";
+import "./chunk-WQ6ZXHFQ.js";
+import "./chunk-CFUCHO4T.js";
+import "./chunk-UMD3V7CU.js";
+import {
+  ft
+} from "./chunk-WMQNIQDJ.js";
+import "./chunk-EOVYQ3IG.js";
+import {
+  trackTranscribeUnavailable
+} from "./chunk-GNEFDLFB.js";
+import "./chunk-2UZQHDM7.js";
+import "./chunk-NYEXNSHM.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import "./chunk-54HJ63Q2.js";
+import "./chunk-ISN5GRYI.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  failCommand,
+  setCommandExitCode
+} from "./chunk-JVBRJMOP.js";
+import "./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-AHX34EFP.js";
+import "./chunk-LTGTN2TH.js";
+import "./chunk-BL4U6U52.js";
+import "./chunk-T2EUWCJE.js";
+import "./chunk-T6AGUTZJ.js";
+import "./chunk-XT6MXC7A.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-II3J3WXK.js";
+import "./chunk-UOFAE5RF.js";
+import "./chunk-IR35BCLK.js";
+import "./chunk-HU2SPFNG.js";
+import "./chunk-KGPLIH7B.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/transcribe.ts
+var examples = [
+  ["Transcribe an audio file", "framey transcribe audio.mp3"],
+  ["Transcribe a video file", "framey transcribe video.mp4"],
+  ["Use a larger model for better accuracy", "framey transcribe audio.mp3 --model medium.en"],
+  ["Set language to filter non-target speech", "framey transcribe audio.mp3 --language en"],
+  ["Import an existing SRT file", "framey transcribe subtitles.srt"],
+  ["Import an OpenAI Whisper JSON response", "framey transcribe response.json"],
+  ["Export captions to SRT", "framey transcribe transcript.json --to srt"],
+  ["Transcribe a video straight to VTT captions", "framey transcribe video.mp4 --to vtt"],
+  [
+    "Export single-word/CJK captions without re-grouping",
+    "framey transcribe transcript.json --to vtt --preserve-cues"
+  ]
+];
+var transcribe_default = defineCommand({
+  meta: {
+    name: "transcribe",
+    description: "Transcribe audio/video to word-level timestamps, or import an existing transcript"
+  },
+  args: {
+    input: {
+      type: "positional",
+      description: "Audio/video file to transcribe, or transcript file to import (.json, .srt, .vtt)",
+      required: true
+    },
+    dir: {
+      type: "string",
+      description: "Project directory (default: current directory)",
+      alias: "d"
+    },
+    engine: {
+      type: "string",
+      description: "ASR engine: auto (Parakeet if installed and it covers --language, else whisper), parakeet, or whisper. Default: auto. Parakeet is more accurate and faster; install it with `framey models install parakeet`.",
+      alias: "e"
+    },
+    model: {
+      type: "string",
+      description: `Whisper model (default: ${DEFAULT_MODEL}). Options: tiny.en, base.en, small.en, medium.en, small, medium, large-v3`,
+      alias: "m"
+    },
+    language: {
+      type: "string",
+      description: "Language code (e.g. en, es, ja). Whisper transcribes as this language; Parakeet, used when it covers it, detects the language itself.",
+      alias: "l"
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON; progress JSON lines go to stderr",
+      default: false
+    },
+    to: {
+      type: "string",
+      description: "Write an srt or vtt caption sidecar: exported from a transcript file, or written after transcribing audio/video"
+    },
+    output: {
+      type: "string",
+      alias: "o",
+      description: "Output path for exported SRT/VTT sidecar"
+    },
+    "preserve-cues": {
+      type: "boolean",
+      description: "Keep each transcript entry as its own caption cue (skip word-level grouping). Use when exporting an already-cued transcript whose entries have no internal spaces, e.g. single-word or CJK captions.",
+      default: false
+    },
+    "runtime-install": {
+      type: "boolean",
+      default: true,
+      description: "Allow installing the Whisper runtime. Use --no-runtime-install to require an existing runtime; model downloads remain allowed."
+    },
+    optional: {
+      type: "boolean",
+      description: "Treat captions as optional: if whisper-cpp is unavailable, skip and exit 0 instead of failing. For pipelines that continue without captions.",
+      default: false
+    },
+    timeout: {
+      type: "string",
+      description: "Whisper spawn timeout in ms. Overrides the duration+model auto-scaled default. Increase on slow CPUs (e.g. emulated arm64/x64, low-power laptops) where whisper.cpp takes many seconds per audio second on medium/large models. Applies to the whisper engine only; Parakeet has a separate fixed timeout. Minimum 5000 (5 s). Env: HYPERFRAMES_TRANSCRIBE_TIMEOUT_MS."
+    }
+  },
+  async run({ args }) {
+    const { json } = args;
+    const ui = { spin: null };
+    let result;
+    try {
+      result = await runTranscribe({
+        input: args.input,
+        dir: args.dir,
+        engine: args.engine,
+        model: args.model,
+        language: args.language,
+        installRuntime: args["runtime-install"],
+        timeoutMs: readTimeout(args.timeout)?.ms,
+        captions: { format: args.to, outputPath: args.output, preserveCues: args["preserve-cues"] },
+        stopOnProcessSignals: true,
+        onStatus: json ? void 0 : (message) => ui.spin?.message(message),
+        onProgress: json ? createProgressWriter(process.stderr) : void 0,
+        onEngine: (event) => {
+          if (event.notice && !json) console.error(c.dim(`  Note: ${event.notice}`));
+          ui.spin = showEngine(event, ui.spin, { json, model: args.model });
+        }
+      });
+    } catch (err) {
+      if (!(err instanceof TranscribeError)) throw err;
+      if (isRunFailure(err)) {
+        reportRunFailure(err, ui.spin, { json, optional: args.optional === true });
+      } else {
+        reportSetupFailure(err, json, args.timeout);
+      }
+      return;
+    }
+    reportResult(result, json, ui.spin);
+  }
+});
+function readTimeout(raw) {
+  const source = raw ?? process.env["HYPERFRAMES_TRANSCRIBE_TIMEOUT_MS"];
+  if (source == null || source === "") return void 0;
+  const origin = raw != null ? "--timeout" : "HYPERFRAMES_TRANSCRIBE_TIMEOUT_MS";
+  return { ms: Number.parseInt(source, 10), source, origin };
+}
+function showEngine(event, spin, opts) {
+  const label = c.accent(event.runner === "whisper" ? opts.model ?? DEFAULT_MODEL : "Parakeet");
+  if (event.fallbackReason !== void 0) {
+    spin?.clear();
+    console.error(c.warn(`${event.fallbackReason}. Using ${event.runner} for this run.`));
+    spin?.start(`Transcribing with ${label}...`);
+    return spin;
+  }
+  if (event.runner !== "whisper" && opts.model && !opts.json) {
+    console.error(
+      c.dim(`  Note: --model applies to the whisper engine only; ignored under Parakeet.`)
+    );
+  }
+  const started = opts.json ? null : ft();
+  started?.start(`Transcribing with ${label}...`);
+  return started;
+}
+function failWith(message, json) {
+  if (json) {
+    console.log(JSON.stringify({ ok: false, error: message }));
+  } else {
+    console.error(c.error(message));
+  }
+  failCommand(1, message);
+}
+function isRunFailure(err) {
+  if (err.code === "caption_write_failed") return err.transcriptPath !== void 0;
+  return err.code === "cancelled" || err.code === "whisper_unavailable" || err.code === "failed";
+}
+function reportSetupFailure(err, json, timeoutFlag) {
+  if (err.code === "input_not_found") {
+    console.error(c.error(err.message));
+    failCommand(1, err.message);
+  }
+  if (err.code === "invalid_transcript") throw err.cause;
+  const timeout = err.code === "invalid_timeout" ? readTimeout(timeoutFlag) : void 0;
+  if (timeout) {
+    failWith(
+      `Invalid ${timeout.origin}: "${timeout.source}". Must be an integer >= ${MIN_TIMEOUT_MS} (ms).`,
+      json
+    );
+  }
+  failWith(err.message, json);
+}
+function reportRunFailure(err, spin, opts) {
+  if (err.code === "whisper_unavailable") return reportWhisperUnavailable(err, spin, opts);
+  if (err.code === "cancelled" || err.code === "caption_write_failed") {
+    if (opts.json) console.log(JSON.stringify({ ok: false, error: err.message }));
+    else spin?.stop(err.code === "cancelled" ? c.warn(err.message) : c.error(err.message));
+    setCommandExitCode(err.code === "cancelled" ? 130 : 1);
+    return;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({ ok: false, error: err.message }));
+  } else {
+    spin?.stop(c.error(`Transcription failed: ${err.message}`));
+  }
+  failCommand(1, err.cause);
+}
+function reportWhisperUnavailable(err, spin, opts) {
+  trackTranscribeUnavailable({ optional: opts.optional });
+  const { install } = err;
+  if (opts.json) {
+    console.log(
+      JSON.stringify({ ok: false, skipped: true, reason: "whisper_unavailable", install })
+    );
+  } else {
+    const orParakeet = install ? `
+Or transcribe with Parakeet after: ${install}` : "";
+    spin?.stop(c.warn(`Captions skipped \u2014 ${err.message}${orParakeet}`));
+  }
+  setCommandExitCode(opts.optional ? 0 : 1);
+}
+function reportSidecar(to, wordCount, outPath) {
+  console.log(
+    `${c.success("\u25C7")}  Exported ${c.accent(String(wordCount))} words to ${c.accent(to.toUpperCase())} \u2192 ${c.accent(outPath)}`
+  );
+}
+function reportResult(result, json, spin) {
+  if (result.kind === "imported") {
+    const { format, wordCount, transcriptPath } = result;
+    if (json) {
+      console.log(JSON.stringify({ ok: true, format, wordCount, transcriptPath }));
+    } else {
+      console.log(
+        `${c.success("\u25C7")}  Imported ${c.accent(String(wordCount))} words from ${c.accent(format)} format \u2192 ${c.accent("transcript.json")}`
+      );
+    }
+    return;
+  }
+  if (result.kind === "exported") {
+    const { format, wordCount, outputPath } = result;
+    if (json) console.log(JSON.stringify({ ok: true, format, wordCount, outputPath }));
+    else reportSidecar(format, wordCount, outputPath);
+    return;
+  }
+  const { captions } = result;
+  if (json) {
+    console.log(
+      JSON.stringify({
+        ok: true,
+        engine: result.engine,
+        model: result.model,
+        detectedLanguage: result.detectedLanguage,
+        wordCount: result.wordCount,
+        durationSeconds: result.durationSeconds,
+        speechOnsetSeconds: result.speechOnsetSeconds,
+        transcriptPath: result.transcriptPath,
+        ...captions
+      })
+    );
+    return;
+  }
+  const onsetNote = result.speechOnsetSeconds != null ? ` \u2014 speech detected at ${result.speechOnsetSeconds.toFixed(1)}s` : "";
+  spin?.stop(
+    c.success(
+      `Transcribed ${c.accent(String(result.wordCount))} words (${result.durationSeconds.toFixed(1)}s${onsetNote})`
+    )
+  );
+  if (captions) reportSidecar(captions.format, result.wordCount, captions.outputPath);
+}
+export {
+  transcribe_default as default,
+  examples
+};

package/vendor/framey/dist/transcribe-UJESPBT5.js

@@ -0,0 +1,76 @@
+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 {
+  detectSpeechOnset,
+  getMediaDurationSeconds,
+  getPreparedWavDurationSeconds,
+  initialModelForLanguage,
+  isPcm16kMono,
+  isWhisperTimeoutError,
+  prepareWav,
+  resolveAudioPreparationTimeoutMs,
+  resolveWhisperTimeoutMs,
+  transcribe,
+  whisperModelSlowdownFactor,
+  withoutPaths,
+  wrapWhisperTimeoutError
+} from "./chunk-HTUHQKDB.js";
+import "./chunk-HFQ4CWHA.js";
+import "./chunk-HPDTCOKE.js";
+import "./chunk-WQ6ZXHFQ.js";
+import "./chunk-UMD3V7CU.js";
+import "./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-LTGTN2TH.js";
+import "./chunk-BL4U6U52.js";
+import "./chunk-T2EUWCJE.js";
+import "./chunk-XT6MXC7A.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-UOFAE5RF.js";
+import "./chunk-IR35BCLK.js";
+import "./chunk-HU2SPFNG.js";
+import "./chunk-KGPLIH7B.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  detectSpeechOnset,
+  getMediaDurationSeconds,
+  getPreparedWavDurationSeconds,
+  initialModelForLanguage,
+  isPcm16kMono,
+  isWhisperTimeoutError,
+  prepareWav,
+  resolveAudioPreparationTimeoutMs,
+  resolveWhisperTimeoutMs,
+  transcribe,
+  whisperModelSlowdownFactor,
+  withoutPaths,
+  wrapWhisperTimeoutError
+};