@vfrey/vfrey 0.0.1 → 1.0.0-beta.1

package/vendor/framey/dist/chunk-VFZ7W5W7.js

@@ -0,0 +1,226 @@
+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 {
+  replaceFileAtomically
+} from "./chunk-EOVYQ3IG.js";
+import {
+  realpath
+} from "./chunk-OFQWTKPW.js";
+
+// src/utils/appHistory.ts
+import { createHash } from "crypto";
+import { lstatSync as lstatSync2, mkdirSync as mkdirSync2, readdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, join as join2, relative, resolve, sep } from "path";
+
+// src/utils/projectRecords.ts
+import { closeSync, constants, fstatSync, lstatSync, mkdirSync, openSync, readSync } from "fs";
+import { join } from "path";
+var NO_FOLLOW = constants.O_NOFOLLOW ?? 0;
+var NON_BLOCK = constants.O_NONBLOCK ?? 0;
+function recordsDir(projectDir, create = false) {
+  const dir = join(projectDir, ".hyperframes");
+  try {
+    return lstatSync(dir).isDirectory() ? dir : null;
+  } catch {
+    if (!create) return null;
+    try {
+      mkdirSync(dir);
+      return dir;
+    } catch {
+      return null;
+    }
+  }
+}
+function readPlainFile(path, maxBytes) {
+  let fd;
+  try {
+    fd = openSync(path, constants.O_RDONLY | NO_FOLLOW | NON_BLOCK);
+  } catch {
+    return "";
+  }
+  try {
+    const stats = fstatSync(fd);
+    const named = lstatSync(path);
+    if (!stats.isFile() || !named.isFile() || named.ino !== stats.ino || named.dev !== stats.dev)
+      return "";
+    const length = Math.min(stats.size, maxBytes);
+    const buffer = Buffer.alloc(length);
+    readSync(fd, buffer, 0, length, stats.size - length);
+    return buffer.toString("utf8");
+  } catch {
+    return "";
+  } finally {
+    closeSync(fd);
+  }
+}
+function readRecord(projectDir, name, maxBytes) {
+  const dir = recordsDir(projectDir);
+  return dir ? readPlainFile(join(dir, name), maxBytes) : "";
+}
+function recordChangedAt(projectDir, name) {
+  const dir = recordsDir(projectDir);
+  try {
+    const stats = dir ? lstatSync(join(dir, name)) : null;
+    return stats?.isFile() ? stats.mtimeMs : 0;
+  } catch {
+    return 0;
+  }
+}
+function replaceFile(path, data, mode) {
+  try {
+    replaceFileAtomically(path, data, mode);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writeRecord(projectDir, name, data) {
+  const dir = recordsDir(projectDir, true);
+  return dir !== null && replaceFile(join(dir, name), data, 384);
+}
+
+// src/utils/appHistory.ts
+var APP_HISTORY = "app-history.jsonl";
+var MAX_READ_BYTES = 1024 * 1024;
+var MAX_FIELD_CHARS = 2e3;
+var MAX_WALKED_FILES = 5e3;
+var SKIPPED_DIRS = /* @__PURE__ */ new Set(["node_modules", "renders", "snapshots"]);
+var text = (value) => typeof value === "string" ? value.slice(0, MAX_FIELD_CHARS) : "";
+function toTurn(line) {
+  let raw;
+  try {
+    raw = Object(JSON.parse(line));
+  } catch {
+    return null;
+  }
+  const at = text(raw.at);
+  if (Number.isNaN(Date.parse(at))) return null;
+  const files = Array.isArray(raw.files) ? raw.files.map(text).filter(Boolean) : [];
+  return { at, engine: text(raw.engine), asked: text(raw.asked), did: text(raw.did), files };
+}
+function readAppTurns(dir) {
+  return readRecord(dir, APP_HISTORY, MAX_READ_BYTES).split("\n").flatMap((line) => toTurn(line) ?? []);
+}
+var stamp = (value) => typeof value === "string" ? Date.parse(value) || 0 : 0;
+function seenPath(dir) {
+  let real;
+  try {
+    real = realpath(dir);
+  } catch {
+    real = resolve(dir);
+  }
+  const key = createHash("sha256").update(real).digest("hex").slice(0, 32);
+  return join2(homedir(), ".hyperframes", "catch-up", `${key}.json`);
+}
+function readSeen(dir) {
+  try {
+    const seen = Object(JSON.parse(readPlainFile(seenPath(dir), 4096)));
+    const at = stamp(seen.at);
+    return { at, checked: stamp(seen.checked) || at };
+  } catch {
+    return { at: 0, checked: 0 };
+  }
+}
+function markSeen(dir, seen) {
+  const path = seenPath(dir);
+  const at = (time) => new Date(time).toISOString();
+  try {
+    mkdirSync2(dirname(path), { recursive: true, mode: 448 });
+  } catch {
+    return false;
+  }
+  return replaceFile(path, JSON.stringify({ at: at(seen.at), checked: at(seen.checked) }), 384);
+}
+function unseenTurns(dir, since, now = Date.now()) {
+  if (!since) return [];
+  return readAppTurns(dir).filter(
+    (turn) => Date.parse(turn.at) > since && Date.parse(turn.at) <= now
+  );
+}
+function isChangedFile(path, since) {
+  try {
+    const stats = lstatSync2(path);
+    return stats.isFile() && stats.mtimeMs > since;
+  } catch {
+    return false;
+  }
+}
+function filesChangedSince(dir, since) {
+  const changed = [];
+  let walked = 0;
+  const walk = (folder) => {
+    let entries;
+    try {
+      entries = readdirSync(folder, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (walked++ > MAX_WALKED_FILES) return;
+      if (entry.name.startsWith(".") || SKIPPED_DIRS.has(entry.name)) continue;
+      const path = join2(folder, entry.name);
+      if (entry.isDirectory()) walk(path);
+      else if (entry.isFile() && isChangedFile(path, since))
+        changed.push(relative(dir, path).split(sep).join("/"));
+    }
+  };
+  walk(dir);
+  return changed.sort();
+}
+function projectsNamed(cwd, args) {
+  const candidates = [cwd, ...args.filter((arg) => !arg.startsWith("-"))].flatMap((arg) => {
+    const path = resolve(cwd, arg);
+    return [path, dirname(path)];
+  });
+  return [...new Set(candidates)];
+}
+function appHistoryNotice(cwd, args) {
+  for (const dir of projectsNamed(cwd, args)) {
+    const { at } = readSeen(dir);
+    if (!at || recordChangedAt(dir, APP_HISTORY) <= at) continue;
+    const count = unseenTurns(dir, at).length;
+    if (count === 0) continue;
+    const where = relative(cwd, dir);
+    const turns = count === 1 ? "1 chat turn" : `${count} chat turns`;
+    return `The HyperFrames desktop app has ${turns} on this project you haven't seen. Run \`framey catch-up${where ? ` ${where}` : ""}\` before changing it.`;
+  }
+  return null;
+}
+var CATCH_UP_NOTE = "> **Back from the desktop app.** Once this project was opened in the HyperFrames desktop app, run `framey catch-up` before your next change here: it lists what the person asked Framey in the app and which files changed since.";
+var SCAFFOLD_TITLE = "# Framey Composition Project";
+var AFTER = "> alive through review, and stop it explicitly with `preview --stop` afterward.\n";
+function addCatchUpNote(dir) {
+  for (const name of ["CLAUDE.md", "AGENTS.md"]) {
+    const path = join2(dir, name);
+    try {
+      const text2 = readPlainFile(path, MAX_READ_BYTES);
+      if (!text2.startsWith(SCAFFOLD_TITLE) || text2.includes("framey catch-up")) continue;
+      const next = text2.includes(AFTER) ? text2.replace(AFTER, `${AFTER}
+${CATCH_UP_NOTE}
+`) : `${text2.trimEnd()}
+
+${CATCH_UP_NOTE}
+`;
+      replaceFile(path, next, lstatSync2(path).mode & 511);
+    } catch {
+    }
+  }
+}
+
+export {
+  writeRecord,
+  APP_HISTORY,
+  readAppTurns,
+  readSeen,
+  markSeen,
+  unseenTurns,
+  filesChangedSince,
+  appHistoryNotice,
+  CATCH_UP_NOTE,
+  addCatchUpNote
+};

package/vendor/framey/dist/chunk-VHNLZAE2.js

@@ -0,0 +1,348 @@
+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 {
+  parakeetRunner
+} from "./chunk-IG7NDKXO.js";
+import {
+  DecodeCancelled,
+  prepareSherpaWav,
+  sherpaUnsupportedReason,
+  transcribeWithSherpa
+} from "./chunk-R6YBK4XX.js";
+import {
+  initialModelForLanguage,
+  transcribe
+} from "./chunk-HTUHQKDB.js";
+import {
+  createRenderCancellationScope,
+  stoppedByCancelSignal
+} from "./chunk-HFQ4CWHA.js";
+import {
+  DEFAULT_MODEL,
+  findWhisper,
+  isWhisperUnavailable
+} from "./chunk-HPDTCOKE.js";
+import {
+  formatSrt,
+  formatVtt,
+  loadTranscript,
+  patchCaptionHtml
+} from "./chunk-CFUCHO4T.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-T2EUWCJE.js";
+import {
+  PARAKEET_INSTALL_COMMAND,
+  PARAKEET_LANGUAGES,
+  parakeetSpeaks,
+  transcribeWithParakeet
+} from "./chunk-II3J3WXK.js";
+import {
+  TRANSCRIPT_FILE
+} from "./chunk-IR35BCLK.js";
+
+// src/api/transcribe.ts
+import { existsSync, realpathSync, rmSync, statSync, writeFileSync } from "fs";
+import { basename, dirname, extname, join, resolve } from "path";
+var MIN_TIMEOUT_MS = 5e3;
+var TranscribeError = class extends Error {
+  code;
+  /** whisper_unavailable: the command that installs Parakeet, when Parakeet would cover this run. */
+  install;
+  /** caption_write_failed after transcribing: the transcript, which was saved. */
+  transcriptPath;
+  constructor(code, message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "TranscribeError";
+    this.code = code;
+    if (options.install !== void 0) this.install = options.install;
+    if (options.transcriptPath !== void 0) this.transcriptPath = options.transcriptPath;
+  }
+};
+async function runTranscribe(options) {
+  if (options.signal?.aborted) {
+    throw new TranscribeError("cancelled", "Transcription cancelled", {
+      cause: options.signal.reason
+    });
+  }
+  const inputPath = resolve(options.input);
+  if (!existsSync(inputPath)) {
+    throw new TranscribeError("input_not_found", `File not found: ${options.input}`);
+  }
+  const dir = resolve(options.dir ?? dirname(inputPath));
+  const ext = extname(inputPath).toLowerCase();
+  const isImport = ext === ".json" || ext === ".srt" || ext === ".vtt";
+  const sidecar = parseSidecar(options.captions, inputPath, dir);
+  if (sidecar && isImport) return exportTranscript(inputPath, sidecar);
+  if (isImport) return importTranscript(inputPath, dir);
+  const { timeoutMs } = options;
+  if (timeoutMs !== void 0 && !(Number.isInteger(timeoutMs) && timeoutMs >= MIN_TIMEOUT_MS)) {
+    throw new TranscribeError(
+      "invalid_timeout",
+      `Invalid timeoutMs: ${timeoutMs}. Must be an integer >= ${MIN_TIMEOUT_MS} (ms).`
+    );
+  }
+  return transcribeAudio(inputPath, dir, sidecar, options);
+}
+function parseExportFormat(value) {
+  if (!value) return void 0;
+  const normalized = value.toLowerCase();
+  if (normalized === "srt" || normalized === "vtt") return normalized;
+  throw new TranscribeError(
+    "invalid_option",
+    `Unsupported caption export format: ${value}. Use srt or vtt.`
+  );
+}
+function parseSidecar(captions, inputPath, dir) {
+  const to = parseExportFormat(captions?.format);
+  if (!to) return void 0;
+  const output = captions?.outputPath;
+  const outPath = resolve(output ?? join(dir, `transcript.${to}`));
+  const keep = [inputPath, join(dir, TRANSCRIPT_FILE)];
+  const problem = output !== void 0 && outputProblem(output, outPath, to) || overwriteProblem(outPath, keep);
+  if (problem) throw new TranscribeError("invalid_option", problem);
+  return { to, outPath, preserveCues: captions?.preserveCues === true, keep };
+}
+function outputProblem(output, outPath, to) {
+  if (!output) return "--output needs a file path";
+  const folder = dirname(outPath);
+  if (!existsSync(folder) || !statSync(folder).isDirectory()) {
+    return `Output folder not found: ${folder}`;
+  }
+  if (/[\\/]$/.test(output) || existsSync(outPath) && statSync(outPath).isDirectory()) {
+    return `--output is a folder; give a file path such as ${join(outPath, `transcript.${to}`)}`;
+  }
+  return void 0;
+}
+function overwriteProblem(outPath, keep) {
+  const hit = keep.find((file) => sameFile(outPath, file));
+  return hit && `The caption file would overwrite ${hit}; choose another file with --output`;
+}
+function sameFile(out, file) {
+  if (existsSync(out) && existsSync(file)) {
+    const [a, b] = [statSync(out, { bigint: true }), statSync(file, { bigint: true })];
+    if (a.ino !== 0n && b.ino !== 0n) return a.dev === b.dev && a.ino === b.ino;
+    return realpathSync.native(out) === realpathSync.native(file);
+  }
+  const realDir = (p) => existsSync(dirname(p)) ? realpathSync.native(dirname(p)) : dirname(p);
+  return realDir(out) === realDir(file) && basename(out).toLowerCase() === basename(file).toLowerCase();
+}
+function readTranscript(inputPath) {
+  let transcript;
+  try {
+    transcript = loadTranscript(inputPath);
+  } catch (err) {
+    throw new TranscribeError("invalid_transcript", normalizeErrorMessage(err), { cause: err });
+  }
+  if (transcript.words.length === 0) {
+    throw new TranscribeError("no_words", "No words found in transcript.");
+  }
+  return transcript;
+}
+function importTranscript(inputPath, dir) {
+  const { words, format } = readTranscript(inputPath);
+  const transcriptPath = join(dir, TRANSCRIPT_FILE);
+  writeFileSync(transcriptPath, JSON.stringify(words, null, 2));
+  patchCaptionHtml(dir, words);
+  return { kind: "imported", format, wordCount: words.length, transcriptPath };
+}
+function exportTranscript(inputPath, sidecar) {
+  const { words, format } = readTranscript(inputPath);
+  try {
+    writeCaptionSidecar(words, sidecar, format === "srt" || format === "vtt" || void 0);
+  } catch (err) {
+    throw new TranscribeError(
+      "caption_write_failed",
+      `The caption file ${sidecar.outPath} could not be written: ${normalizeErrorMessage(err)}`,
+      { cause: err }
+    );
+  }
+  return {
+    kind: "exported",
+    format: sidecar.to,
+    wordCount: words.length,
+    outputPath: sidecar.outPath
+  };
+}
+function writeCaptionSidecar(words, { to, outPath, preserveCues, keep }, phraseLevelSource) {
+  const hit = keep.find((file) => sameFile(outPath, file));
+  if (hit) throw new Error(`it is the same file as ${hit}`);
+  const preGrouped = preserveCues || phraseLevelSource;
+  const content = to === "srt" ? formatSrt(words, { preGrouped }) : formatVtt(words, { preGrouped });
+  writeFileSync(outPath, content);
+}
+function pickRunner(engine, parakeet, language, whisperForLanguage = false) {
+  if (engine === "whisper" || whisperForLanguage || !parakeetSpeaks(language)) return "whisper";
+  return parakeet() ?? "whisper";
+}
+function needsWhisperForLanguage(engine, language) {
+  const base = language?.trim().toLowerCase().split(/[-_]/, 1)[0];
+  if (engine === "whisper" || !base || base === "en" || !parakeetSpeaks(language)) return false;
+  return findWhisper() !== void 0;
+}
+var parakeetFallsBack = (engine) => engine === "auto";
+function withoutTrailingDots(text) {
+  let end = text.length;
+  while (end > 0 && text[end - 1] === ".") end--;
+  return text.slice(0, end);
+}
+var engineOf = (runner) => runner === "whisper" ? "whisper" : "parakeet";
+function failureMessage(err) {
+  const base = err instanceof Error ? err.message : String(err);
+  const stderr = err && typeof err === "object" && "stderr" in err && err.stderr ? String(err.stderr).trim().split("\n").slice(-3).filter((line) => !base.includes(line)).join("\n") : "";
+  return stderr ? `${base}
+${stderr}` : base;
+}
+async function transcribeAudio(inputPath, dir, sidecar, options) {
+  const engine = (options.engine ?? "auto").toLowerCase();
+  if (engine !== "auto" && engine !== "parakeet" && engine !== "whisper") {
+    throw new TranscribeError(
+      "invalid_option",
+      `Unknown --engine: ${options.engine}. Use auto, parakeet, or whisper.`
+    );
+  }
+  const unsupported = sherpaUnsupportedReason();
+  const whisperForLanguage = needsWhisperForLanguage(engine, options.language);
+  let runner = pickRunner(
+    engine,
+    () => parakeetRunner({ unsupported }),
+    options.language,
+    whisperForLanguage
+  );
+  if (engine === "parakeet" && runner === "whisper" && !whisperForLanguage) {
+    throw new TranscribeError(
+      "parakeet_unavailable",
+      !parakeetSpeaks(options.language) ? `Parakeet does not transcribe --language ${options.language}; it covers ${PARAKEET_LANGUAGES.split(" ").join(", ")}. Use --engine whisper.` : unsupported ?? `Parakeet is not installed. Install it with: ${PARAKEET_INSTALL_COMMAND} (or use --engine whisper)`
+    );
+  }
+  const model = options.model ?? DEFAULT_MODEL;
+  const whisperModel = initialModelForLanguage(model, options.language);
+  options.onEngine?.({
+    runner,
+    engine: engineOf(runner),
+    model: whisperModel,
+    ...whisperForLanguage && {
+      notice: `Parakeet chooses its own language, so whisper transcribes --language ${options.language}.`
+    }
+  });
+  const { onStatus, onProgress } = options;
+  const startScope = () => options.stopOnProcessSignals ? createRenderCancellationScope() : { signal: options.signal ?? new AbortController().signal, dispose: () => {
+  } };
+  let wavPath = inputPath;
+  let cancellation = runner === "sherpa" || !options.stopOnProcessSignals ? startScope() : null;
+  const librarySignal = options.stopOnProcessSignals ? void 0 : cancellation?.signal;
+  const run = (r) => {
+    switch (r) {
+      case "sherpa":
+        return transcribeWithSherpa(wavPath, dir, {
+          onProgress: onStatus,
+          onEvent: onProgress,
+          signal: cancellation.signal
+        });
+      case "parakeet-mlx":
+        return transcribeWithParakeet(wavPath, dir, {
+          onProgress: onStatus,
+          onEvent: onProgress,
+          signal: librarySignal
+        });
+      case "whisper":
+        return transcribe(wavPath, dir, {
+          model,
+          language: options.language,
+          onProgress: onStatus,
+          onEvent: onProgress,
+          timeoutMs: options.timeoutMs,
+          installRuntime: options.installRuntime,
+          signal: librarySignal,
+          startCancellation: () => (cancellation ??= startScope()).signal
+        });
+      default: {
+        const unreachable = r;
+        throw new Error(`Unknown transcription runner: ${unreachable}`);
+      }
+    }
+  };
+  try {
+    if (runner === "sherpa") {
+      wavPath = await prepareSherpaWav(inputPath, onStatus, librarySignal);
+    }
+    let result;
+    try {
+      result = await run(runner);
+    } catch (err) {
+      if (runner !== "sherpa" || err instanceof DecodeCancelled) throw err;
+      const reason = withoutTrailingDots(normalizeErrorMessage(err));
+      const parakeetError = `Parakeet failed: ${reason}. To repair it, run: ${PARAKEET_INSTALL_COMMAND}`;
+      if (!parakeetFallsBack(engine)) throw new Error(parakeetError);
+      runner = pickRunner(
+        engine,
+        () => parakeetRunner({ unsupported, skipSherpa: true }),
+        options.language
+      );
+      options.onEngine?.({
+        runner,
+        engine: engineOf(runner),
+        model: whisperModel,
+        fallbackReason: parakeetError
+      });
+      try {
+        result = await run(runner);
+      } catch (fallbackErr) {
+        if (stoppedByCancelSignal(fallbackErr)) {
+          throw new DecodeCancelled("Transcription cancelled");
+        }
+        const why = normalizeErrorMessage(fallbackErr);
+        throw new Error(`${parakeetError}. The ${runner} fallback failed too: ${why}`);
+      }
+    }
+    const { words } = loadTranscript(result.transcriptPath);
+    writeFileSync(result.transcriptPath, JSON.stringify(words, null, 2));
+    patchCaptionHtml(dir, words);
+    if (sidecar) {
+      try {
+        writeCaptionSidecar(words, sidecar, false);
+      } catch (err) {
+        throw new TranscribeError(
+          "caption_write_failed",
+          `Transcript saved to ${result.transcriptPath}, but the caption file ${sidecar.outPath} could not be written: ${normalizeErrorMessage(err)}`,
+          { cause: err, transcriptPath: result.transcriptPath }
+        );
+      }
+    }
+    return {
+      kind: "transcribed",
+      engine: engineOf(runner),
+      model: result.model,
+      detectedLanguage: result.detectedLanguage,
+      wordCount: words.length,
+      durationSeconds: result.durationSeconds,
+      speechOnsetSeconds: result.speechOnsetSeconds,
+      transcriptPath: result.transcriptPath,
+      ...sidecar && { captions: { format: sidecar.to, outputPath: sidecar.outPath } }
+    };
+  } catch (err) {
+    if (err instanceof TranscribeError) throw err;
+    if (err instanceof DecodeCancelled || cancellation?.signal.aborted) {
+      throw new TranscribeError("cancelled", "Transcription cancelled", { cause: err });
+    }
+    const message = failureMessage(err);
+    if (isWhisperUnavailable(err)) {
+      const install = engine === "auto" && parakeetSpeaks(options.language) && !unsupported ? PARAKEET_INSTALL_COMMAND : void 0;
+      throw new TranscribeError("whisper_unavailable", message, { cause: err, install });
+    }
+    throw new TranscribeError("failed", message, { cause: err });
+  } finally {
+    cancellation?.dispose();
+    if (wavPath !== inputPath) rmSync(wavPath, { force: true });
+  }
+}
+
+export {
+  MIN_TIMEOUT_MS,
+  TranscribeError,
+  runTranscribe
+};