ai-cli 0.1.1 → 0.2.1

package/src/lib/openh264.mjs

@@ -1,423 +0,0 @@
-async function Module(moduleArg = {}) {
-  var moduleRtn;
-  var Module = moduleArg;
-  var ENVIRONMENT_IS_NODE = true;
-  if (ENVIRONMENT_IS_NODE) {
-    const { createRequire } = await import("node:module");
-    var require = createRequire(import.meta.url);
-  }
-  var arguments_ = [];
-  var thisProgram = "./this.program";
-  var quit_ = (status, toThrow) => {
-    throw toThrow;
-  };
-  var _scriptName = import.meta.url;
-  var scriptDirectory = "";
-  function locateFile(path) {
-    if (Module["locateFile"]) {
-      return Module["locateFile"](path, scriptDirectory);
-    }
-    return scriptDirectory + path;
-  }
-  var readAsync, readBinary;
-  if (ENVIRONMENT_IS_NODE) {
-    var fs = require("node:fs");
-    if (_scriptName.startsWith("file:")) {
-      scriptDirectory =
-        require("node:path").dirname(
-          require("node:url").fileURLToPath(_scriptName)
-        ) + "/";
-    }
-    readBinary = (filename) => {
-      filename = isFileURI(filename) ? new URL(filename) : filename;
-      var ret = fs.readFileSync(filename);
-      return ret;
-    };
-    readAsync = async (filename, binary = true) => {
-      filename = isFileURI(filename) ? new URL(filename) : filename;
-      var ret = fs.readFileSync(filename, binary ? undefined : "utf8");
-      return ret;
-    };
-    if (process.argv.length > 1) {
-      thisProgram = process.argv[1].replace(/\\/g, "/");
-    }
-    arguments_ = process.argv.slice(2);
-    quit_ = (status, toThrow) => {
-      process.exitCode = status;
-      throw toThrow;
-    };
-  } else {
-  }
-  var out = console.log.bind(console);
-  var err = console.error.bind(console);
-  var wasmBinary;
-  var ABORT = false;
-  var isFileURI = (filename) => filename.startsWith("file://");
-  class EmscriptenEH {}
-  class EmscriptenSjLj extends EmscriptenEH {}
-  var readyPromiseResolve, readyPromiseReject;
-  var runtimeInitialized = false;
-  function updateMemoryViews() {
-    var b = wasmMemory.buffer;
-    HEAP8 = new Int8Array(b);
-    HEAP16 = new Int16Array(b);
-    Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
-    HEAPU16 = new Uint16Array(b);
-    HEAP32 = new Int32Array(b);
-    HEAPU32 = new Uint32Array(b);
-    HEAPF32 = new Float32Array(b);
-    HEAPF64 = new Float64Array(b);
-    HEAP64 = new BigInt64Array(b);
-    HEAPU64 = new BigUint64Array(b);
-  }
-  function preRun() {
-    if (Module["preRun"]) {
-      if (typeof Module["preRun"] == "function")
-        Module["preRun"] = [Module["preRun"]];
-      while (Module["preRun"].length) {
-        addOnPreRun(Module["preRun"].shift());
-      }
-    }
-    callRuntimeCallbacks(onPreRuns);
-  }
-  function initRuntime() {
-    runtimeInitialized = true;
-    wasmExports["__wasm_call_ctors"]();
-  }
-  function postRun() {
-    if (Module["postRun"]) {
-      if (typeof Module["postRun"] == "function")
-        Module["postRun"] = [Module["postRun"]];
-      while (Module["postRun"].length) {
-        addOnPostRun(Module["postRun"].shift());
-      }
-    }
-    callRuntimeCallbacks(onPostRuns);
-  }
-  function abort(what) {
-    Module["onAbort"]?.(what);
-    what = `Aborted(${what})`;
-    err(what);
-    ABORT = true;
-    what += ". Build with -sASSERTIONS for more info.";
-    var e = new WebAssembly.RuntimeError(what);
-    readyPromiseReject?.(e);
-    throw e;
-  }
-  var wasmBinaryFile;
-  function findWasmBinary() {
-    if (Module["locateFile"]) {
-      return locateFile("openh264.wasm");
-    }
-    return new URL("openh264.wasm", import.meta.url).href;
-  }
-  function getBinarySync(file) {
-    if (file == wasmBinaryFile && wasmBinary) {
-      return new Uint8Array(wasmBinary);
-    }
-    if (readBinary) {
-      return readBinary(file);
-    }
-    throw "both async and sync fetching of the wasm failed";
-  }
-  async function getWasmBinary(binaryFile) {
-    if (!wasmBinary) {
-      try {
-        var response = await readAsync(binaryFile);
-        return new Uint8Array(response);
-      } catch {}
-    }
-    return getBinarySync(binaryFile);
-  }
-  async function instantiateArrayBuffer(binaryFile, imports) {
-    try {
-      var binary = await getWasmBinary(binaryFile);
-      var instance = await WebAssembly.instantiate(binary, imports);
-      return instance;
-    } catch (reason) {
-      err(`failed to asynchronously prepare wasm: ${reason}`);
-      abort(reason);
-    }
-  }
-  async function instantiateAsync(binary, binaryFile, imports) {
-    if (!binary && !ENVIRONMENT_IS_NODE) {
-      try {
-        var response = fetch(binaryFile, { credentials: "same-origin" });
-        var instantiationResult = await WebAssembly.instantiateStreaming(
-          response,
-          imports
-        );
-        return instantiationResult;
-      } catch (reason) {
-        err(`wasm streaming compile failed: ${reason}`);
-        err("falling back to ArrayBuffer instantiation");
-      }
-    }
-    return instantiateArrayBuffer(binaryFile, imports);
-  }
-  function getWasmImports() {
-    var imports = { env: wasmImports, wasi_snapshot_preview1: wasmImports };
-    return imports;
-  }
-  async function createWasm() {
-    function receiveInstance(instance, module) {
-      wasmExports = instance.exports;
-      assignWasmExports(wasmExports);
-      updateMemoryViews();
-      return wasmExports;
-    }
-    function receiveInstantiationResult(result) {
-      return receiveInstance(result["instance"]);
-    }
-    var info = getWasmImports();
-    if (Module["instantiateWasm"]) {
-      return new Promise((resolve, reject) => {
-        Module["instantiateWasm"](info, (inst, mod) => {
-          resolve(receiveInstance(inst, mod));
-        });
-      });
-    }
-    wasmBinaryFile ??= findWasmBinary();
-    var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
-    var exports = receiveInstantiationResult(result);
-    return exports;
-  }
-  class ExitStatus {
-    name = "ExitStatus";
-    constructor(status) {
-      this.message = `Program terminated with exit(${status})`;
-      this.status = status;
-    }
-  }
-  var HEAP16;
-  var HEAP32;
-  var HEAP64;
-  var HEAP8;
-  var HEAPF32;
-  var HEAPF64;
-  var HEAPU16;
-  var HEAPU32;
-  var HEAPU64;
-  var HEAPU8;
-  var callRuntimeCallbacks = (callbacks) => {
-    while (callbacks.length > 0) {
-      callbacks.shift()(Module);
-    }
-  };
-  var onPostRuns = [];
-  var addOnPostRun = (cb) => onPostRuns.push(cb);
-  var onPreRuns = [];
-  var addOnPreRun = (cb) => onPreRuns.push(cb);
-  var noExitRuntime = true;
-  var __abort_js = () => abort("");
-  var _emscripten_date_now = () => Date.now();
-  var getHeapMax = () => 2147483648;
-  var alignMemory = (size, alignment) =>
-    Math.ceil(size / alignment) * alignment;
-  var growMemory = (size) => {
-    var oldHeapSize = wasmMemory.buffer.byteLength;
-    var pages = ((size - oldHeapSize + 65535) / 65536) | 0;
-    try {
-      wasmMemory.grow(pages);
-      updateMemoryViews();
-      return 1;
-    } catch (e) {}
-  };
-  var _emscripten_resize_heap = (requestedSize) => {
-    var oldSize = HEAPU8.length;
-    requestedSize >>>= 0;
-    var maxHeapSize = getHeapMax();
-    if (requestedSize > maxHeapSize) {
-      return false;
-    }
-    for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
-      var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
-      overGrownHeapSize = Math.min(
-        overGrownHeapSize,
-        requestedSize + 100663296
-      );
-      var newSize = Math.min(
-        maxHeapSize,
-        alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536)
-      );
-      var replacement = growMemory(newSize);
-      if (replacement) {
-        return true;
-      }
-    }
-    return false;
-  };
-  var _fd_close = (fd) => 52;
-  var INT53_MAX = 9007199254740992;
-  var INT53_MIN = -9007199254740992;
-  var bigintToI53Checked = (num) =>
-    num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
-  function _fd_seek(fd, offset, whence, newOffset) {
-    offset = bigintToI53Checked(offset);
-    return 70;
-  }
-  var printCharBuffers = [null, [], []];
-  var UTF8Decoder = globalThis.TextDecoder && new TextDecoder();
-  var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
-    var maxIdx = idx + maxBytesToRead;
-    if (ignoreNul) return maxIdx;
-    while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;
-    return idx;
-  };
-  var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {
-    var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);
-    if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
-      return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
-    }
-    var str = "";
-    while (idx < endPtr) {
-      var u0 = heapOrArray[idx++];
-      if (!(u0 & 128)) {
-        str += String.fromCharCode(u0);
-        continue;
-      }
-      var u1 = heapOrArray[idx++] & 63;
-      if ((u0 & 224) == 192) {
-        str += String.fromCharCode(((u0 & 31) << 6) | u1);
-        continue;
-      }
-      var u2 = heapOrArray[idx++] & 63;
-      if ((u0 & 240) == 224) {
-        u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
-      } else {
-        u0 =
-          ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
-      }
-      if (u0 < 65536) {
-        str += String.fromCharCode(u0);
-      } else {
-        var ch = u0 - 65536;
-        str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
-      }
-    }
-    return str;
-  };
-  var printChar = (stream, curr) => {
-    var buffer = printCharBuffers[stream];
-    if (curr === 0 || curr === 10) {
-      (stream === 1 ? out : err)(UTF8ArrayToString(buffer));
-      buffer.length = 0;
-    } else {
-      buffer.push(curr);
-    }
-  };
-  var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) =>
-    ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : "";
-  var _fd_write = (fd, iov, iovcnt, pnum) => {
-    var num = 0;
-    for (var i = 0; i < iovcnt; i++) {
-      var ptr = HEAPU32[iov >> 2];
-      var len = HEAPU32[(iov + 4) >> 2];
-      iov += 8;
-      for (var j = 0; j < len; j++) {
-        printChar(fd, HEAPU8[ptr + j]);
-      }
-      num += len;
-    }
-    HEAPU32[pnum >> 2] = num;
-    return 0;
-  };
-  {
-    if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
-    if (Module["print"]) out = Module["print"];
-    if (Module["printErr"]) err = Module["printErr"];
-    if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
-    if (Module["arguments"]) arguments_ = Module["arguments"];
-    if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
-    if (Module["preInit"]) {
-      if (typeof Module["preInit"] == "function")
-        Module["preInit"] = [Module["preInit"]];
-      while (Module["preInit"].length > 0) {
-        Module["preInit"].shift()();
-      }
-    }
-  }
-  var _decoder_init,
-    _decoder_feed,
-    _decoder_flush,
-    _get_has_frame,
-    _get_width,
-    _get_height,
-    _get_y_stride,
-    _get_uv_stride,
-    _get_y_ptr,
-    _get_u_ptr,
-    _get_v_ptr,
-    _decoder_destroy,
-    _malloc,
-    _free,
-    __emscripten_stack_restore,
-    __emscripten_stack_alloc,
-    _emscripten_stack_get_current,
-    memory,
-    __indirect_function_table,
-    wasmMemory;
-  function assignWasmExports(wasmExports) {
-    _decoder_init = Module["_decoder_init"] = wasmExports["decoder_init"];
-    _decoder_feed = Module["_decoder_feed"] = wasmExports["decoder_feed"];
-    _decoder_flush = Module["_decoder_flush"] = wasmExports["decoder_flush"];
-    _get_has_frame = Module["_get_has_frame"] = wasmExports["get_has_frame"];
-    _get_width = Module["_get_width"] = wasmExports["get_width"];
-    _get_height = Module["_get_height"] = wasmExports["get_height"];
-    _get_y_stride = Module["_get_y_stride"] = wasmExports["get_y_stride"];
-    _get_uv_stride = Module["_get_uv_stride"] = wasmExports["get_uv_stride"];
-    _get_y_ptr = Module["_get_y_ptr"] = wasmExports["get_y_ptr"];
-    _get_u_ptr = Module["_get_u_ptr"] = wasmExports["get_u_ptr"];
-    _get_v_ptr = Module["_get_v_ptr"] = wasmExports["get_v_ptr"];
-    _decoder_destroy = Module["_decoder_destroy"] =
-      wasmExports["decoder_destroy"];
-    _malloc = Module["_malloc"] = wasmExports["malloc"];
-    _free = Module["_free"] = wasmExports["free"];
-    __emscripten_stack_restore = wasmExports["_emscripten_stack_restore"];
-    __emscripten_stack_alloc = wasmExports["_emscripten_stack_alloc"];
-    _emscripten_stack_get_current = wasmExports["emscripten_stack_get_current"];
-    memory = wasmMemory = wasmExports["memory"];
-    __indirect_function_table = wasmExports["__indirect_function_table"];
-  }
-  var wasmImports = {
-    _abort_js: __abort_js,
-    emscripten_date_now: _emscripten_date_now,
-    emscripten_resize_heap: _emscripten_resize_heap,
-    fd_close: _fd_close,
-    fd_seek: _fd_seek,
-    fd_write: _fd_write,
-  };
-  function run() {
-    preRun();
-    function doRun() {
-      Module["calledRun"] = true;
-      if (ABORT) return;
-      initRuntime();
-      readyPromiseResolve?.(Module);
-      Module["onRuntimeInitialized"]?.();
-      postRun();
-    }
-    if (Module["setStatus"]) {
-      Module["setStatus"]("Running...");
-      setTimeout(() => {
-        setTimeout(() => Module["setStatus"](""), 1);
-        doRun();
-      }, 1);
-    } else {
-      doRun();
-    }
-  }
-  var wasmExports;
-  wasmExports = await createWasm();
-  run();
-  if (runtimeInitialized) {
-    moduleRtn = Module;
-  } else {
-    moduleRtn = new Promise((resolve, reject) => {
-      readyPromiseResolve = resolve;
-      readyPromiseReject = reject;
-    });
-  }
-  return moduleRtn;
-}
-export default Module;

package/src/lib/openh264.wasm.d.ts

@@ -1,2 +0,0 @@
-declare const path: string;
-export default path;

package/src/lib/output.ts

@@ -1,97 +0,0 @@
-import { writeFileSync, mkdirSync, statSync } from "fs";
-import { resolve, join, dirname } from "path";
-
-import {
-  supportsKittyGraphics,
-  displayImage,
-  displayVideoFrame,
-} from "./kitty.js";
-
-export type OutputFormat = "md" | "txt" | "image" | "video";
-
-const DEFAULT_EXTENSIONS: Record<OutputFormat, string> = {
-  md: ".md",
-  txt: ".txt",
-  image: ".png",
-  video: ".mp4",
-};
-
-export interface WriteOutputOptions {
-  data: Buffer | string;
-  format: OutputFormat;
-  outputPath?: string;
-  suffix?: string;
-  quiet?: boolean;
-  display?: boolean;
-}
-
-function defaultFilename(format: OutputFormat): string {
-  return `output${DEFAULT_EXTENSIONS[format]}`;
-}
-
-function isDirectory(p: string): boolean {
-  try {
-    return statSync(p).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-export async function writeOutput(
-  opts: WriteOutputOptions
-): Promise<string | null> {
-  const { data, format, suffix, quiet, display } = opts;
-  const effectiveOutput = opts.outputPath ?? process.env.AI_CLI_OUTPUT_DIR;
-  const buf = typeof data === "string" ? Buffer.from(data, "utf-8") : data;
-  const shouldDisplay =
-    display !== false &&
-    (format === "image" || format === "video") &&
-    process.stdout.isTTY &&
-    supportsKittyGraphics();
-
-  if (effectiveOutput) {
-    let filePath: string;
-    if (isDirectory(effectiveOutput)) {
-      filePath = join(
-        effectiveOutput,
-        addSuffix(defaultFilename(format), suffix)
-      );
-    } else {
-      filePath = addSuffix(effectiveOutput, suffix);
-    }
-    filePath = resolve(filePath);
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, buf);
-    if (!quiet) process.stderr.write(`Saved to ${filePath}\n`);
-    if (shouldDisplay) await showPreview(format, buf);
-    return filePath;
-  }
-
-  if (!process.stdout.isTTY) {
-    process.stdout.write(buf);
-    return null;
-  }
-
-  const filename = addSuffix(defaultFilename(format), suffix);
-  const path = resolve(filename);
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, buf);
-  if (!quiet) process.stderr.write(`Saved to ${path}\n`);
-  if (shouldDisplay) await showPreview(format, buf);
-  return path;
-}
-
-async function showPreview(format: OutputFormat, buf: Buffer): Promise<void> {
-  if (format === "video") {
-    await displayVideoFrame(buf);
-  } else {
-    displayImage(buf);
-  }
-}
-
-function addSuffix(filename: string, suffix?: string): string {
-  if (!suffix) return filename;
-  const dot = filename.lastIndexOf(".");
-  if (dot === -1) return `${filename}-${suffix}`;
-  return `${filename.slice(0, dot)}-${suffix}${filename.slice(dot)}`;
-}

package/src/lib/p-map.test.ts

@@ -1,63 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { pMap } from "./p-map.js";
-
-describe("pMap", () => {
-  test("maps items with fulfilled results", async () => {
-    const results = await pMap([1, 2, 3], async (x) => x * 2, 2);
-    expect(results).toEqual([
-      { status: "fulfilled", value: 2 },
-      { status: "fulfilled", value: 4 },
-      { status: "fulfilled", value: 6 },
-    ]);
-  });
-
-  test("captures rejections without stopping others", async () => {
-    const results = await pMap(
-      [1, 2, 3],
-      async (x) => {
-        if (x === 2) throw new Error("fail");
-        return x;
-      },
-      3
-    );
-    expect(results[0]).toEqual({ status: "fulfilled", value: 1 });
-    expect(results[1].status).toBe("rejected");
-    expect(results[2]).toEqual({ status: "fulfilled", value: 3 });
-  });
-
-  test("handles empty input", async () => {
-    const results = await pMap([], async (x: number) => x, 4);
-    expect(results).toEqual([]);
-  });
-
-  test("respects concurrency limit", async () => {
-    let active = 0;
-    let maxActive = 0;
-
-    await pMap(
-      [1, 2, 3, 4, 5, 6],
-      async () => {
-        active++;
-        maxActive = Math.max(maxActive, active);
-        await new Promise((r) => setTimeout(r, 10));
-        active--;
-      },
-      2
-    );
-
-    expect(maxActive).toBeLessThanOrEqual(2);
-  });
-
-  test("passes correct indices to callback", async () => {
-    const indices: number[] = [];
-    await pMap(
-      ["a", "b", "c"],
-      async (_, i) => {
-        indices.push(i);
-      },
-      1
-    );
-    expect(indices).toEqual([0, 1, 2]);
-  });
-});

package/src/lib/p-map.ts

@@ -1,30 +0,0 @@
-export async function pMap<T, R>(
-  items: T[],
-  fn: (item: T, index: number) => Promise<R>,
-  concurrency: number
-): Promise<PromiseSettledResult<R>[]> {
-  concurrency = Math.max(1, concurrency);
-  const results = Array.from<PromiseSettledResult<R>>({ length: items.length });
-  let nextIdx = 0;
-
-  async function worker() {
-    while (nextIdx < items.length) {
-      const idx = nextIdx++;
-      try {
-        results[idx] = {
-          status: "fulfilled",
-          value: await fn(items[idx], idx),
-        };
-      } catch (reason) {
-        results[idx] = { status: "rejected", reason };
-      }
-    }
-  }
-
-  const workers = Array.from(
-    { length: Math.min(concurrency, items.length) },
-    () => worker()
-  );
-  await Promise.all(workers);
-  return results;
-}