@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.19-dev.10.1

package/dist/node-runtime/v4-5MNC3H7G.js

@@ -0,0 +1,424 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  $brand,
+  $input,
+  $output,
+  NEVER,
+  TimePrecision,
+  ZodAny,
+  ZodArray,
+  ZodBase64,
+  ZodBase64URL,
+  ZodBigInt,
+  ZodBigIntFormat,
+  ZodBoolean,
+  ZodCIDRv4,
+  ZodCIDRv6,
+  ZodCUID,
+  ZodCUID2,
+  ZodCatch,
+  ZodCustom,
+  ZodCustomStringFormat,
+  ZodDate,
+  ZodDefault,
+  ZodDiscriminatedUnion,
+  ZodE164,
+  ZodEmail,
+  ZodEmoji,
+  ZodEnum,
+  ZodError,
+  ZodFile,
+  ZodGUID,
+  ZodIPv4,
+  ZodIPv6,
+  ZodISODate,
+  ZodISODateTime,
+  ZodISODuration,
+  ZodISOTime,
+  ZodIntersection,
+  ZodIssueCode,
+  ZodJWT,
+  ZodKSUID,
+  ZodLazy,
+  ZodLiteral,
+  ZodMap,
+  ZodNaN,
+  ZodNanoID,
+  ZodNever,
+  ZodNonOptional,
+  ZodNull,
+  ZodNullable,
+  ZodNumber,
+  ZodNumberFormat,
+  ZodObject,
+  ZodOptional,
+  ZodPipe,
+  ZodPrefault,
+  ZodPromise,
+  ZodReadonly,
+  ZodRealError,
+  ZodRecord,
+  ZodSet,
+  ZodString,
+  ZodStringFormat,
+  ZodSuccess,
+  ZodSymbol,
+  ZodTemplateLiteral,
+  ZodTransform,
+  ZodTuple,
+  ZodType,
+  ZodULID,
+  ZodURL,
+  ZodUUID,
+  ZodUndefined,
+  ZodUnion,
+  ZodUnknown,
+  ZodVoid,
+  ZodXID,
+  _ZodString,
+  _catch,
+  _default,
+  _endsWith,
+  _enum,
+  _function,
+  _gt,
+  _gte,
+  _includes,
+  _instanceof,
+  _length,
+  _lowercase,
+  _lt,
+  _lte,
+  _maxLength,
+  _maxSize,
+  _mime,
+  _minLength,
+  _minSize,
+  _multipleOf,
+  _negative,
+  _nonnegative,
+  _nonpositive,
+  _normalize,
+  _null,
+  _overwrite,
+  _positive,
+  _property,
+  _regex,
+  _size,
+  _startsWith,
+  _toLowerCase,
+  _toUpperCase,
+  _trim,
+  _undefined,
+  _uppercase,
+  _void,
+  any,
+  array,
+  base64,
+  base64url,
+  bigint,
+  boolean,
+  check,
+  cidrv4,
+  cidrv6,
+  clone,
+  coerce_exports,
+  config,
+  core_exports,
+  cuid,
+  cuid2,
+  custom,
+  date,
+  discriminatedUnion,
+  e164,
+  email,
+  emoji,
+  external_exports,
+  file,
+  flattenError,
+  float32,
+  float64,
+  formatError,
+  getErrorMap,
+  globalRegistry,
+  guid,
+  int,
+  int32,
+  int64,
+  intersection,
+  ipv4,
+  ipv6,
+  iso_exports,
+  json,
+  jwt,
+  keyof,
+  ksuid,
+  lazy,
+  literal,
+  locales_exports,
+  looseObject,
+  map,
+  nan,
+  nanoid,
+  nativeEnum,
+  never,
+  nonoptional,
+  nullable,
+  nullish,
+  number,
+  object,
+  optional,
+  parse,
+  parseAsync,
+  partialRecord,
+  pipe,
+  prefault,
+  preprocess,
+  prettifyError,
+  promise,
+  readonly,
+  record,
+  refine,
+  regexes_exports,
+  registry,
+  safeParse2 as safeParse,
+  safeParseAsync,
+  set,
+  setErrorMap,
+  strictObject,
+  string,
+  stringFormat,
+  stringbool,
+  success,
+  superRefine,
+  symbol,
+  templateLiteral,
+  toJSONSchema,
+  transform,
+  treeifyError,
+  tuple,
+  uint32,
+  uint64,
+  ulid,
+  union,
+  unknown,
+  url,
+  uuid,
+  uuidv4,
+  uuidv6,
+  uuidv7,
+  v4_default,
+  xid
+} from "./chunk-BI3DHYCN.js";
+import "./chunk-BRJX2PRC.js";
+export {
+  $brand,
+  $input,
+  $output,
+  NEVER,
+  TimePrecision,
+  ZodAny,
+  ZodArray,
+  ZodBase64,
+  ZodBase64URL,
+  ZodBigInt,
+  ZodBigIntFormat,
+  ZodBoolean,
+  ZodCIDRv4,
+  ZodCIDRv6,
+  ZodCUID,
+  ZodCUID2,
+  ZodCatch,
+  ZodCustom,
+  ZodCustomStringFormat,
+  ZodDate,
+  ZodDefault,
+  ZodDiscriminatedUnion,
+  ZodE164,
+  ZodEmail,
+  ZodEmoji,
+  ZodEnum,
+  ZodError,
+  ZodFile,
+  ZodGUID,
+  ZodIPv4,
+  ZodIPv6,
+  ZodISODate,
+  ZodISODateTime,
+  ZodISODuration,
+  ZodISOTime,
+  ZodIntersection,
+  ZodIssueCode,
+  ZodJWT,
+  ZodKSUID,
+  ZodLazy,
+  ZodLiteral,
+  ZodMap,
+  ZodNaN,
+  ZodNanoID,
+  ZodNever,
+  ZodNonOptional,
+  ZodNull,
+  ZodNullable,
+  ZodNumber,
+  ZodNumberFormat,
+  ZodObject,
+  ZodOptional,
+  ZodPipe,
+  ZodPrefault,
+  ZodPromise,
+  ZodReadonly,
+  ZodRealError,
+  ZodRecord,
+  ZodSet,
+  ZodString,
+  ZodStringFormat,
+  ZodSuccess,
+  ZodSymbol,
+  ZodTemplateLiteral,
+  ZodTransform,
+  ZodTuple,
+  ZodType,
+  ZodULID,
+  ZodURL,
+  ZodUUID,
+  ZodUndefined,
+  ZodUnion,
+  ZodUnknown,
+  ZodVoid,
+  ZodXID,
+  _ZodString,
+  _default,
+  any,
+  array,
+  base64,
+  base64url,
+  bigint,
+  boolean,
+  _catch as catch,
+  check,
+  cidrv4,
+  cidrv6,
+  clone,
+  coerce_exports as coerce,
+  config,
+  core_exports as core,
+  cuid,
+  cuid2,
+  custom,
+  date,
+  v4_default as default,
+  discriminatedUnion,
+  e164,
+  email,
+  emoji,
+  _endsWith as endsWith,
+  _enum as enum,
+  file,
+  flattenError,
+  float32,
+  float64,
+  formatError,
+  _function as function,
+  getErrorMap,
+  globalRegistry,
+  _gt as gt,
+  _gte as gte,
+  guid,
+  _includes as includes,
+  _instanceof as instanceof,
+  int,
+  int32,
+  int64,
+  intersection,
+  ipv4,
+  ipv6,
+  iso_exports as iso,
+  json,
+  jwt,
+  keyof,
+  ksuid,
+  lazy,
+  _length as length,
+  literal,
+  locales_exports as locales,
+  looseObject,
+  _lowercase as lowercase,
+  _lt as lt,
+  _lte as lte,
+  map,
+  _maxLength as maxLength,
+  _maxSize as maxSize,
+  _mime as mime,
+  _minLength as minLength,
+  _minSize as minSize,
+  _multipleOf as multipleOf,
+  nan,
+  nanoid,
+  nativeEnum,
+  _negative as negative,
+  never,
+  _nonnegative as nonnegative,
+  nonoptional,
+  _nonpositive as nonpositive,
+  _normalize as normalize,
+  _null as null,
+  nullable,
+  nullish,
+  number,
+  object,
+  optional,
+  _overwrite as overwrite,
+  parse,
+  parseAsync,
+  partialRecord,
+  pipe,
+  _positive as positive,
+  prefault,
+  preprocess,
+  prettifyError,
+  promise,
+  _property as property,
+  readonly,
+  record,
+  refine,
+  _regex as regex,
+  regexes_exports as regexes,
+  registry,
+  safeParse,
+  safeParseAsync,
+  set,
+  setErrorMap,
+  _size as size,
+  _startsWith as startsWith,
+  strictObject,
+  string,
+  stringFormat,
+  stringbool,
+  success,
+  superRefine,
+  symbol,
+  templateLiteral,
+  toJSONSchema,
+  _toLowerCase as toLowerCase,
+  _toUpperCase as toUpperCase,
+  transform,
+  treeifyError,
+  _trim as trim,
+  tuple,
+  uint32,
+  uint64,
+  ulid,
+  _undefined as undefined,
+  union,
+  unknown,
+  _uppercase as uppercase,
+  url,
+  uuid,
+  uuidv4,
+  uuidv6,
+  uuidv7,
+  _void as void,
+  xid,
+  external_exports as z
+};

package/dist/node-runtime/video-extract-ETA5RA7U.js

@@ -0,0 +1,304 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  isGeminiWebAvailable,
+  queryWithCookies
+} from "./chunk-XTHQ7XR7.js";
+import "./chunk-DMMTJQMQ.js";
+import {
+  API_BASE,
+  getApiKey,
+  queryGeminiApiWithVideo
+} from "./chunk-3WFAEVKS.js";
+import {
+  extractHeadingTitle
+} from "./chunk-J7QGQD45.js";
+import "./chunk-4SJWFTUP.js";
+import {
+  activityMonitor
+} from "./chunk-DAPBPCBP.js";
+import {
+  getWebSearchConfigPath,
+  mapFfmpegError,
+  readExecError,
+  trimErrorText
+} from "./chunk-VRB2IYGG.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/video-extract.js
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve, extname, basename, join, dirname } from "node:path";
+var CONFIG_PATH = getWebSearchConfigPath(), UPLOAD_BASE = "https://generativelanguage.googleapis.com/upload/v1beta", DEFAULT_VIDEO_PROMPT = `Extract the complete content of this video. Include:
+1. Video title (infer from content if not explicit), duration
+2. A brief summary (2-3 sentences)
+3. Full transcript with timestamps
+4. Descriptions of any code, terminal commands, diagrams, slides, or UI shown on screen
+
+Format as markdown.`, VIDEO_EXTENSIONS = {
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm",
+  ".avi": "video/x-msvideo",
+  ".mpeg": "video/mpeg",
+  ".mpg": "video/mpeg",
+  ".wmv": "video/x-ms-wmv",
+  ".flv": "video/x-flv",
+  ".3gp": "video/3gpp",
+  ".3gpp": "video/3gpp"
+};
+function shouldRethrow(err) {
+  return (err instanceof Error ? err.message : String(err)).startsWith("Failed to parse ");
+}
+function normalizePreferredModel(value, fallback) {
+  if (typeof value != "string")
+    return fallback;
+  let normalized = value.trim();
+  return normalized.length > 0 ? normalized : fallback;
+}
+function normalizeEnabled(value, fallback) {
+  return typeof value == "boolean" ? value : fallback;
+}
+function normalizeMaxSizeMB(value, fallback) {
+  return typeof value != "number" || !Number.isFinite(value) ? fallback : value > 0 ? value : fallback;
+}
+var VIDEO_CONFIG_DEFAULTS = {
+  enabled: !0,
+  preferredModel: "gemini-3-flash-preview",
+  maxSizeMB: 50
+}, cachedVideoConfig = null;
+function loadVideoConfig() {
+  if (cachedVideoConfig)
+    return cachedVideoConfig;
+  if (!existsSync(CONFIG_PATH))
+    return cachedVideoConfig = { ...VIDEO_CONFIG_DEFAULTS }, cachedVideoConfig;
+  let rawText = readFileSync(CONFIG_PATH, "utf-8"), raw;
+  try {
+    raw = JSON.parse(rawText);
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+  let v = raw.video ?? {};
+  return cachedVideoConfig = {
+    enabled: normalizeEnabled(v.enabled, VIDEO_CONFIG_DEFAULTS.enabled),
+    preferredModel: normalizePreferredModel(v.preferredModel, VIDEO_CONFIG_DEFAULTS.preferredModel),
+    maxSizeMB: normalizeMaxSizeMB(v.maxSizeMB, VIDEO_CONFIG_DEFAULTS.maxSizeMB)
+  }, cachedVideoConfig;
+}
+function isVideoFile(input) {
+  let config = loadVideoConfig();
+  if (!config.enabled || !(input.startsWith("/") || input.startsWith("./") || input.startsWith("../") || input.startsWith("file://")))
+    return null;
+  let filePath = input;
+  if (input.startsWith("file://"))
+    try {
+      filePath = decodeURIComponent(new URL(input).pathname);
+    } catch {
+      return null;
+    }
+  let ext = extname(filePath).toLowerCase(), mimeType = VIDEO_EXTENSIONS[ext];
+  if (!mimeType)
+    return null;
+  let absolutePath = resolveFilePath(filePath);
+  if (!absolutePath)
+    return null;
+  let stat;
+  try {
+    stat = statSync(absolutePath);
+  } catch {
+    return null;
+  }
+  if (!stat.isFile())
+    return null;
+  let maxBytes = config.maxSizeMB * 1024 * 1024;
+  return stat.size > maxBytes ? null : { absolutePath, mimeType, sizeBytes: stat.size };
+}
+function resolveFilePath(filePath) {
+  let absolutePath = resolve(filePath);
+  if (existsSync(absolutePath))
+    return absolutePath;
+  let dir = dirname(absolutePath), base = basename(absolutePath);
+  if (!existsSync(dir))
+    return null;
+  try {
+    let normalizedBase = normalizeSpaces(base), match = readdirSync(dir).find((f) => normalizeSpaces(f) === normalizedBase);
+    return match ? join(dir, match) : null;
+  } catch {
+    return null;
+  }
+}
+function normalizeSpaces(s) {
+  return s.replace(/[\u00A0\u2000-\u200B\u202F\u205F\u3000\uFEFF]/g, " ");
+}
+async function extractVideo(info, signal, options) {
+  let config = loadVideoConfig(), effectivePrompt = options?.prompt ?? DEFAULT_VIDEO_PROMPT, effectiveModel = options?.model ?? config.preferredModel, displayName = basename(info.absolutePath), activityId = activityMonitor.logStart({ type: "fetch", url: `video:${displayName}` }), result = await tryVideoGeminiApi(info, effectivePrompt, effectiveModel, signal) ?? await tryVideoGeminiWeb(info, effectivePrompt, effectiveModel, signal);
+  if (result) {
+    let thumbnail = await extractVideoFrame(info.absolutePath);
+    return "error" in thumbnail || (result.thumbnail = thumbnail), activityMonitor.logComplete(activityId, 200), result;
+  }
+  return signal?.aborted ? (activityMonitor.logComplete(activityId, 0), null) : (activityMonitor.logError(activityId, "all video extraction paths failed"), null);
+}
+function mapFfprobeError(err) {
+  let { code, stderr, message } = readExecError(err);
+  if (code === "ENOENT")
+    return "ffprobe is not installed. Install ffmpeg which includes ffprobe";
+  let snippet = trimErrorText(stderr || message);
+  return snippet ? `ffprobe failed: ${snippet}` : "ffprobe failed";
+}
+async function extractVideoFrame(filePath, seconds = 1) {
+  try {
+    let buffer = execFileSync("ffmpeg", [
+      "-ss",
+      String(seconds),
+      "-i",
+      filePath,
+      "-frames:v",
+      "1",
+      "-f",
+      "image2pipe",
+      "-vcodec",
+      "mjpeg",
+      "pipe:1"
+    ], { maxBuffer: 5242880, timeout: 1e4, stdio: ["pipe", "pipe", "pipe"] });
+    return buffer.length === 0 ? { error: "ffmpeg failed: empty output" } : { data: buffer.toString("base64"), mimeType: "image/jpeg" };
+  } catch (err) {
+    return { error: mapFfmpegError(err) };
+  }
+}
+async function getLocalVideoDuration(filePath) {
+  try {
+    let output = execFileSync("ffprobe", [
+      "-v",
+      "quiet",
+      "-show_entries",
+      "format=duration",
+      "-of",
+      "csv=p=0",
+      filePath
+    ], { timeout: 1e4, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim(), duration = Number.parseFloat(output);
+    return Number.isFinite(duration) ? duration : { error: "ffprobe failed: invalid duration output" };
+  } catch (err) {
+    return { error: mapFfprobeError(err) };
+  }
+}
+async function tryVideoGeminiWeb(info, prompt, model, signal) {
+  try {
+    let cookies = await isGeminiWebAvailable();
+    if (!cookies || signal?.aborted)
+      return null;
+    let text = await queryWithCookies(prompt, cookies, {
+      files: [info.absolutePath],
+      model,
+      signal,
+      timeoutMs: 18e4
+    });
+    return {
+      url: info.absolutePath,
+      title: extractVideoTitle(text, info.absolutePath),
+      content: text,
+      error: null
+    };
+  } catch (err) {
+    if (shouldRethrow(err))
+      throw err;
+    return null;
+  }
+}
+async function tryVideoGeminiApi(info, prompt, model, signal) {
+  let apiKey = getApiKey();
+  if (!apiKey || signal?.aborted)
+    return null;
+  let fileName = null;
+  try {
+    let uploaded = await uploadToFilesApi(info, apiKey, signal);
+    fileName = uploaded.name, await pollFileState(fileName, apiKey, signal, 12e4);
+    let text = await queryGeminiApiWithVideo(prompt, uploaded.uri, {
+      model,
+      mimeType: info.mimeType,
+      signal,
+      timeoutMs: 12e4
+    });
+    return {
+      url: info.absolutePath,
+      title: extractVideoTitle(text, info.absolutePath),
+      content: text,
+      error: null
+    };
+  } catch (err) {
+    if (shouldRethrow(err))
+      throw err;
+    return null;
+  } finally {
+    fileName && deleteGeminiFile(fileName, apiKey);
+  }
+}
+async function uploadToFilesApi(info, apiKey, signal) {
+  let displayName = basename(info.absolutePath), initRes = await fetch(`${UPLOAD_BASE}/files`, {
+    method: "POST",
+    headers: {
+      "x-goog-api-key": apiKey,
+      "X-Goog-Upload-Protocol": "resumable",
+      "X-Goog-Upload-Command": "start",
+      "X-Goog-Upload-Header-Content-Length": String(info.sizeBytes),
+      "X-Goog-Upload-Header-Content-Type": info.mimeType,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ file: { display_name: displayName } }),
+    signal
+  });
+  if (!initRes.ok) {
+    let text = await initRes.text();
+    throw new Error(`File upload init failed: ${initRes.status} (${text.slice(0, 200)})`);
+  }
+  let uploadUrl = initRes.headers.get("x-goog-upload-url");
+  if (!uploadUrl)
+    throw new Error("No upload URL in response headers");
+  let fileData = await readFile(info.absolutePath), uploadRes = await fetch(uploadUrl, {
+    method: "PUT",
+    headers: {
+      "Content-Length": String(info.sizeBytes),
+      "X-Goog-Upload-Offset": "0",
+      "X-Goog-Upload-Command": "upload, finalize"
+    },
+    body: fileData,
+    signal
+  });
+  if (!uploadRes.ok) {
+    let text = await uploadRes.text();
+    throw new Error(`File upload failed: ${uploadRes.status} (${text.slice(0, 200)})`);
+  }
+  return (await uploadRes.json()).file;
+}
+async function pollFileState(fileName, apiKey, signal, timeoutMs = 12e4) {
+  let deadline = Date.now() + timeoutMs;
+  for (; Date.now() < deadline; ) {
+    if (signal?.aborted)
+      throw new Error("Aborted");
+    let res = await fetch(`${API_BASE}/${fileName}?key=${apiKey}`, { signal });
+    if (!res.ok)
+      throw new Error(`File state check failed: ${res.status}`);
+    let data = await res.json();
+    if (data.state === "ACTIVE")
+      return;
+    if (data.state === "FAILED")
+      throw new Error("File processing failed");
+    await new Promise((r) => setTimeout(r, 5e3));
+  }
+  throw new Error("File processing timed out");
+}
+function deleteGeminiFile(fileName, apiKey) {
+  fetch(`${API_BASE}/${fileName}?key=${apiKey}`, { method: "DELETE" }).catch((err) => {
+    let message = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to delete Gemini file ${fileName}: ${message}`);
+  });
+}
+function extractVideoTitle(text, filePath) {
+  return extractHeadingTitle(text) ?? basename(filePath, extname(filePath));
+}
+export {
+  extractVideo,
+  extractVideoFrame,
+  getLocalVideoDuration,
+  isVideoFile
+};