@realtimex/node-llama-cpp 0.1.0

package/llama/gpuInfo/vulkan-gpu-info.cpp

@@ -0,0 +1,207 @@
+#include <stddef.h>
+#include <cstdint>
+#include <map>
+#include <vector>
+
+#include <vulkan/vulkan.hpp>
+
+constexpr std::uint32_t VK_VENDOR_ID_AMD = 0x1002;
+constexpr std::uint32_t VK_VENDOR_ID_APPLE = 0x106b;
+constexpr std::uint32_t VK_VENDOR_ID_INTEL = 0x8086;
+constexpr std::uint32_t VK_VENDOR_ID_NVIDIA = 0x10de;
+constexpr std::uint32_t VK_VENDOR_ID_QUALCOMM = 0x5143;
+
+typedef void (*gpuInfoVulkanWarningLogCallback_t)(const char* message);
+
+static vk::Instance vulkanInstance() {
+    vk::ApplicationInfo appInfo("node-llama-cpp GPU info", 1, "llama.cpp", 1, VK_API_VERSION_1_2);
+    vk::InstanceCreateInfo createInfo(vk::InstanceCreateFlags(), &appInfo, {}, {});
+    return vk::createInstance(createInfo);
+}
+
+static std::vector<vk::PhysicalDevice> dedupedDevices() {
+    vk::Instance instance = vulkanInstance();
+    auto physicalDevices = instance.enumeratePhysicalDevices();
+    std::vector<vk::PhysicalDevice> dedupedDevices;
+    dedupedDevices.reserve(physicalDevices.size());
+
+    // adapted from `ggml_vk_instance_init` in `ggml-vulkan.cpp`
+    for (const auto& device : physicalDevices) {
+        vk::PhysicalDeviceProperties2 newProps;
+        vk::PhysicalDeviceDriverProperties newDriver;
+        vk::PhysicalDeviceIDProperties newId;
+        newProps.pNext = &newDriver;
+        newDriver.pNext = &newId;
+        device.getProperties2(&newProps);
+
+        auto oldDevice = std::find_if(
+            dedupedDevices.begin(),
+            dedupedDevices.end(),
+            [&newId, &newDriver](const vk::PhysicalDevice& oldDevice) {
+                vk::PhysicalDeviceProperties2 oldProps;
+                vk::PhysicalDeviceDriverProperties oldDriver;
+                vk::PhysicalDeviceIDProperties oldId;
+                oldProps.pNext = &oldDriver;
+                oldDriver.pNext = &oldId;
+                oldDevice.getProperties2(&oldProps);
+
+                bool sameUuid = std::equal(std::begin(oldId.deviceUUID), std::end(oldId.deviceUUID), std::begin(newId.deviceUUID));
+                sameUuid = sameUuid || (
+                    oldId.deviceLUIDValid && newId.deviceLUIDValid &&
+                    std::equal(std::begin(oldId.deviceLUID), std::end(oldId.deviceLUID), std::begin(newId.deviceLUID))
+                );
+                bool bothMoltenVk = (newDriver.driverID == vk::DriverId::eMoltenvk && oldDriver.driverID == vk::DriverId::eMoltenvk);
+
+                return sameUuid && !bothMoltenVk;
+            }
+        );
+
+        if (oldDevice == dedupedDevices.end()) {
+            dedupedDevices.push_back(device);
+            continue;
+        }
+
+        vk::PhysicalDeviceProperties2 oldProps;
+        vk::PhysicalDeviceDriverProperties oldDriver;
+        oldProps.pNext = &oldDriver;
+        oldDevice->getProperties2(&oldProps);
+
+        std::map<vk::DriverId, int> driverPriorities {};
+        int oldPriority = 1000;
+        int newPriority = 1000;
+
+        switch (oldProps.properties.vendorID) {
+            case VK_VENDOR_ID_AMD:
+                driverPriorities[vk::DriverId::eMesaRadv] = 1;
+                driverPriorities[vk::DriverId::eAmdOpenSource] = 2;
+                driverPriorities[vk::DriverId::eAmdProprietary] = 3;
+                break;
+            case VK_VENDOR_ID_INTEL:
+                driverPriorities[vk::DriverId::eIntelOpenSourceMESA] = 1;
+                driverPriorities[vk::DriverId::eIntelProprietaryWindows] = 2;
+                break;
+            case VK_VENDOR_ID_NVIDIA:
+                driverPriorities[vk::DriverId::eNvidiaProprietary] = 1;
+#if defined(VK_API_VERSION_1_3) && VK_HEADER_VERSION >= 235
+                driverPriorities[vk::DriverId::eMesaNvk] = 2;
+#endif
+                break;
+            case VK_VENDOR_ID_QUALCOMM:
+                driverPriorities[vk::DriverId::eQualcommProprietary] = 1;
+                driverPriorities[vk::DriverId::eMesaTurnip] = 2;
+                break;
+        }
+        driverPriorities[vk::DriverId::eMesaDozen] = 100;
+
+        if (driverPriorities.count(oldDriver.driverID)) {
+            oldPriority = driverPriorities[oldDriver.driverID];
+        }
+        if (driverPriorities.count(newDriver.driverID)) {
+            newPriority = driverPriorities[newDriver.driverID];
+        }
+
+        if (newPriority < oldPriority) {
+            dedupedDevices.erase(std::remove(dedupedDevices.begin(), dedupedDevices.end(), *oldDevice), dedupedDevices.end());
+            dedupedDevices.push_back(device);
+        }
+    }
+
+    return dedupedDevices;
+}
+
+static bool enumerateVulkanDevices(size_t* total, size_t* used, size_t* unifiedMemorySize, bool addDeviceNames, std::vector<std::string> * deviceNames, gpuInfoVulkanWarningLogCallback_t warningLogCallback, bool * checkSupported) {
+    auto physicalDevices = dedupedDevices();
+
+    size_t usedMem = 0;
+    size_t totalMem = 0;
+    size_t totalUnifiedMemorySize = 0;
+
+    for (size_t i = 0; i < physicalDevices.size(); i++) {
+        vk::PhysicalDevice physicalDevice = physicalDevices[i];
+        vk::PhysicalDeviceMemoryProperties memProps = physicalDevice.getMemoryProperties();
+        vk::PhysicalDeviceProperties deviceProps = physicalDevice.getProperties();
+
+        if (deviceProps.deviceType == vk::PhysicalDeviceType::eCpu) {
+            // ignore CPU devices, as we don't want to count RAM from the CPU as VRAM
+            continue;
+        }
+
+        std::vector<vk::ExtensionProperties> extensionProperties = physicalDevice.enumerateDeviceExtensionProperties();
+        bool memoryBudgetExtensionSupported =
+            std::any_of(
+                extensionProperties.begin(),
+                extensionProperties.end(),
+                [](const vk::ExtensionProperties& ext) { return std::string(ext.extensionName.data()) == VK_EXT_MEMORY_BUDGET_EXTENSION_NAME;}
+            );
+
+        if (memoryBudgetExtensionSupported) {
+            vk::PhysicalDeviceMemoryBudgetPropertiesEXT memoryBudgetProperties;
+            vk::PhysicalDeviceMemoryProperties2 memProps2 = {};
+            memProps2.pNext = &memoryBudgetProperties;
+
+            physicalDevice.getMemoryProperties2(&memProps2);
+
+            for (uint32_t i = 0; i < memProps.memoryHeapCount; ++i) {
+                const auto heap = memProps2.memoryProperties.memoryHeaps[i];
+
+                if (heap.flags & vk::MemoryHeapFlagBits::eDeviceLocal) {
+                    totalMem += heap.size;
+                    usedMem += memoryBudgetProperties.heapUsage[i] + (heap.size - memoryBudgetProperties.heapBudget[i]);
+
+                    if (heap.flags & vk::MemoryHeapFlagBits::eMultiInstance) {
+                        totalUnifiedMemorySize += heap.size;
+                    }
+
+                    if (heap.size > 0 && addDeviceNames) {
+                        (*deviceNames).push_back(std::string(deviceProps.deviceName.data()));
+                    }
+
+                    if (checkSupported != nullptr && checkSupported) {
+                        VkPhysicalDeviceFeatures2 features2 = {};
+                        features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+
+                        VkPhysicalDeviceVulkan11Features vk11Features = {};
+                        vk11Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
+                        features2.pNext = &vk11Features;
+
+                        vkGetPhysicalDeviceFeatures2(physicalDevice, &features2);
+
+                        if (!vk11Features.storageBuffer16BitAccess) {
+                            *checkSupported = false;
+                        }
+                    }
+                }
+            }
+        } else {
+            // VK_EXT_memory_budget extension is not supported, so we cannot determine used memory
+            warningLogCallback(
+                (
+                    "Vulkan VK_EXT_memory_budget extension not supported for device \"" +
+                    std::string(deviceProps.deviceName.data()) + "\", so VRAM info cannot be determined for it"
+                ).c_str()
+            );
+            return false;
+        }
+    }
+
+    *total = totalMem;
+    *used = usedMem;
+    *unifiedMemorySize = totalUnifiedMemorySize;
+
+    return true;
+}
+
+bool gpuInfoGetTotalVulkanDevicesInfo(size_t* total, size_t* used, size_t* unifiedMemorySize, gpuInfoVulkanWarningLogCallback_t warningLogCallback) {
+    return enumerateVulkanDevices(total, used, unifiedMemorySize, false, nullptr, warningLogCallback, nullptr);
+}
+
+bool checkIsVulkanEnvSupported(gpuInfoVulkanWarningLogCallback_t warningLogCallback) {
+    size_t total = 0;
+    size_t used = 0;
+    size_t unifiedMemorySize = 0;
+
+    bool isSupported = true;
+    enumerateVulkanDevices(&total, &used, &unifiedMemorySize, false, nullptr, warningLogCallback, &isSupported);
+
+    return isSupported;
+}

package/llama/gpuInfo/vulkan-gpu-info.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <stddef.h>
+#include <vector>
+
+typedef void (*gpuInfoVulkanWarningLogCallback_t)(const char* message);
+
+bool gpuInfoGetTotalVulkanDevicesInfo(size_t* total, size_t* used, size_t* unifiedMemorySize, gpuInfoVulkanWarningLogCallback_t warningLogCallback);
+bool checkIsVulkanEnvSupported(gpuInfoVulkanWarningLogCallback_t warningLogCallback);

package/llama/package.json

@@ -0,0 +1,5 @@
+{
+  "binary": {
+    "napi_versions": [7]
+  }
+}

package/llama/profiles/llvm.win32.host-arm64.target-arm64.cmake

@@ -0,0 +1,14 @@
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.programFilesPaths.cmake")
+setProgramFilesPaths("arm64")
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.ensureNodeLib.cmake")
+ensureNodeLib("arm64" "arm64")
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.llvmApplyGnuModeAdaptations.cmake")
+llvmApplyGnuModeAdaptations()
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.llvmEnsureCmakeAr.cmake")
+llvmEnsureCmakeAr("arm64")
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.ensureNinjaPath.cmake")
+ensureNinjaPath()

package/llama/profiles/llvm.win32.host-x64.target-arm64.cmake

@@ -0,0 +1,14 @@
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.programFilesPaths.cmake")
+setProgramFilesPaths("x64")
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.ensureNodeLib.cmake")
+ensureNodeLib("x64" "arm64")
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.llvmApplyGnuModeAdaptations.cmake")
+llvmApplyGnuModeAdaptations()
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.llvmEnsureCmakeAr.cmake")
+llvmEnsureCmakeAr("x64")
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.ensureNinjaPath.cmake")
+ensureNinjaPath()

package/llama/profiles/llvm.win32.host-x64.target-x64.cmake

@@ -0,0 +1,14 @@
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.programFilesPaths.cmake")
+setProgramFilesPaths("x64")
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.ensureNodeLib.cmake")
+ensureNodeLib("x64" "x64")
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.llvmApplyGnuModeAdaptations.cmake")
+llvmApplyGnuModeAdaptations()
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.llvmEnsureCmakeAr.cmake")
+llvmEnsureCmakeAr("x64")
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.ensureNinjaPath.cmake")
+ensureNinjaPath()

package/llama/toolchains/darwin.host-x64.target-arm64.cmake

@@ -0,0 +1,8 @@
+set(CMAKE_SYSTEM_NAME Darwin) # macOS
+set(CMAKE_SYSTEM_PROCESSOR arm64)
+
+set(CMAKE_C_COMPILER clang)
+set(CMAKE_CXX_COMPILER clang++)
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -arch arm64")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -arch arm64")

package/llama/toolchains/linux.host-arm64.target-x64.cmake

@@ -0,0 +1,5 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR x86_64)
+
+set(CMAKE_C_COMPILER x86_64-linux-gnu-gcc)
+set(CMAKE_CXX_COMPILER x86_64-linux-gnu-g++)

package/llama/toolchains/linux.host-x64.target-arm64.cmake

@@ -0,0 +1,5 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR aarch64)
+
+set(CMAKE_C_COMPILER aarch64-linux-gnu-gcc)
+set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)

package/llama/toolchains/linux.host-x64.target-arm71.cmake

@@ -0,0 +1,5 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR arm)
+
+set(CMAKE_C_COMPILER arm-linux-gnueabihf-gcc)
+set(CMAKE_CXX_COMPILER arm-linux-gnueabihf-g++)

package/llama/toolchains/llvm.win32.host-x64.target-x64.cmake

@@ -0,0 +1,20 @@
+set(CMAKE_SYSTEM_NAME Windows)
+set(CMAKE_SYSTEM_PROCESSOR x86_64)
+
+set(target x86_64-pc-windows-msvc)
+set(CMAKE_C_COMPILER_TARGET ${target})
+set(CMAKE_CXX_COMPILER_TARGET ${target})
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.programFilesPaths.cmake")
+setProgramFilesPaths("x64")
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.llvmUseGnuModeCompilers.cmake")
+llvmUseGnuModeCompilers("x64")
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.ensureNinjaPath.cmake")
+ensureNinjaPath()
+
+set(arch_c_flags "-march=native")
+
+set(CMAKE_C_FLAGS_INIT "${arch_c_flags}")
+set(CMAKE_CXX_FLAGS_INIT "${arch_c_flags}")

package/llama/toolchains/win32.host-arm64.target-arm64.cmake

@@ -0,0 +1,21 @@
+set(CMAKE_SYSTEM_NAME Windows)
+set(CMAKE_SYSTEM_PROCESSOR arm64)
+
+set(target arm64-pc-windows-msvc)
+set(CMAKE_C_COMPILER_TARGET ${target})
+set(CMAKE_CXX_COMPILER_TARGET ${target})
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.programFilesPaths.cmake")
+setProgramFilesPaths("arm64")
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.llvmUseGnuModeCompilers.cmake")
+llvmUseGnuModeCompilers("arm64")
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.ensureNinjaPath.cmake")
+ensureNinjaPath()
+
+set(arch_c_flags "-march=armv8.7-a -fvectorize -ffp-model=fast -fno-finite-math-only")
+set(warn_c_flags "-Wno-format -Wno-unused-variable -Wno-unused-function -Wno-gnu-zero-variadic-macro-arguments")
+
+set(CMAKE_C_FLAGS_INIT "${arch_c_flags} ${warn_c_flags}")
+set(CMAKE_CXX_FLAGS_INIT "${arch_c_flags} ${warn_c_flags}")

package/llama/toolchains/win32.host-x64.target-arm64.cmake

@@ -0,0 +1,21 @@
+set(CMAKE_SYSTEM_NAME Windows)
+set(CMAKE_SYSTEM_PROCESSOR arm64)
+
+set(target arm64-pc-windows-msvc)
+set(CMAKE_C_COMPILER_TARGET ${target})
+set(CMAKE_CXX_COMPILER_TARGET ${target})
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.programFilesPaths.cmake")
+setProgramFilesPaths("x64")
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.llvmUseGnuModeCompilers.cmake")
+llvmUseGnuModeCompilers("x64")
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/win32.ensureNinjaPath.cmake")
+ensureNinjaPath()
+
+set(arch_c_flags "-march=armv8.7-a -fvectorize -ffp-model=fast -fno-finite-math-only")
+set(warn_c_flags "-Wno-format -Wno-unused-variable -Wno-unused-function -Wno-gnu-zero-variadic-macro-arguments")
+
+set(CMAKE_C_FLAGS_INIT "${arch_c_flags} ${warn_c_flags}")
+set(CMAKE_CXX_FLAGS_INIT "${arch_c_flags} ${warn_c_flags}")

package/llama/xpack/package.json

@@ -0,0 +1,10 @@
+{
+  "xpack": {
+    "minimumXpmRequired": "0.16.3",
+    "dependencies": {},
+    "devDependencies": {},
+    "properties": {},
+    "actions": {},
+    "buildConfigurations": {}
+  }
+}

package/package.json

@@ -0,0 +1,241 @@
+{
+  "name": "@realtimex/node-llama-cpp",
+  "version": "0.1.0",
+  "description": "Run AI models locally on your machine with node.js bindings for llama.cpp. Enforce a JSON schema on the model output on the generation level",
+  "main": "./dist/index.js",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "node-llama-cpp": "dist/cli/cli.js",
+    "nlc": "dist/cli/cli.js"
+  },
+  "files": [
+    "dist/",
+    "templates/packed/",
+    "llama/",
+    "bins/",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "node": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./commands": {
+      "import": "./dist/commands.js",
+      "node": "./dist/commands.js",
+      "types": "./dist/commands.d.ts",
+      "default": "./dist/commands.js"
+    },
+    "./commands.js": {
+      "import": "./dist/commands.js",
+      "node": "./dist/commands.js",
+      "types": "./dist/commands.d.ts",
+      "default": "./dist/commands.js"
+    }
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "prepare": "node --experimental-require-module -e \"process.env.CI !== 'true' && console.log(require('husky').default())\"",
+    "postinstall": "cd templates && npm install",
+    "postversion": "vite-node scripts/postVersion.ts",
+    "prebuild": "rimraf ./dist ./tsconfig.tsbuildinfo",
+    "build": "tsc --build tsconfig.json --force && npm run build:packTemplates",
+    "build:packTemplates": "vite-node scripts/packTemplates.ts",
+    "addPostinstallScript": "npm pkg set scripts.postinstall=\"node ./dist/cli/cli.js postinstall\"",
+    "prewatch": "rimraf ./dist ./tsconfig.tsbuildinfo",
+    "watch": "tsc --build tsconfig.json --watch --force",
+    "cmake-js-llama": "cd llama && cmake-js",
+    "test": "npm run test:typescript && npm run lint:eslint && npm run test:vitest",
+    "test:vitest": "vitest run ./test",
+    "test:standalone": "vitest run ./test/standalone",
+    "test:standalone:interactive": "vitest watch ./test/standalone",
+    "test:modelDependent": "vitest run ./test/modelDependent",
+    "test:modelDependent:interactive": "vitest watch ./test/modelDependent",
+    "test:typescript": "tsc --noEmit --project tsconfig.json",
+    "lint": "npm run lint:eslint",
+    "lint:eslint": "eslint --report-unused-disable-directives .",
+    "format": "npm run lint:eslint -- --fix",
+    "dev:setup:downloadAllTestModels": "vite-node test/utils/scripts/downloadAllTestModels.ts",
+    "dev:setup": "npm run build && node ./dist/cli/cli.js source download --noUsageExample && npm run docs:generateTypedoc && npm run dev:setup:downloadAllTestModels",
+    "dev:build": "npm run build && node ./dist/cli/cli.js source build --noUsageExample",
+    "clean": "rm -rf ./node_modules ./dist ./tsconfig.tsbuildinfo ./test/.models ./docs/api ./docs/api-overrides ./templates/packed",
+    "docs:generateTypedoc": "typedoc && rimraf ./docs/api/index.md ./docs/api/globals.md ./docs/api/functions/LlamaText.md",
+    "docs:dev": "npm run docs:generateTypedoc && vitepress dev --cors",
+    "docs:build": "npm run docs:generateTypedoc && vitepress build",
+    "docs:preview": "npm run docs:generateTypedoc && vitepress preview"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/withcatai/node-llama-cpp.git"
+  },
+  "keywords": [
+    "llama",
+    "llama-cpp",
+    "llama.cpp",
+    "bindings",
+    "ai",
+    "cmake",
+    "cmake-js",
+    "prebuilt-binaries",
+    "llm",
+    "gguf",
+    "metal",
+    "cuda",
+    "vulkan",
+    "grammar",
+    "embedding",
+    "rerank",
+    "reranking",
+    "json-grammar",
+    "json-schema-grammar",
+    "functions",
+    "function-calling",
+    "token-prediction",
+    "speculative-decoding",
+    "temperature",
+    "minP",
+    "topK",
+    "topP",
+    "seed",
+    "xtc",
+    "json-schema",
+    "raspberry-pi",
+    "self-hosted",
+    "local",
+    "catai",
+    "mistral",
+    "deepseek",
+    "qwen",
+    "qwq",
+    "gpt",
+    "gpt-oss",
+    "typescript",
+    "lora",
+    "batching",
+    "gpu"
+  ],
+  "author": {
+    "name": "Gilad S.",
+    "url": "https://github.com/giladgd"
+  },
+  "license": "MIT",
+  "preferUnplugged": true,
+  "bugs": {
+    "url": "https://github.com/withcatai/node-llama-cpp/issues"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/giladgd"
+  },
+  "homepage": "https://node-llama-cpp.withcat.ai",
+  "devDependencies": {
+    "@commitlint/cli": "^20.4.1",
+    "@commitlint/config-conventional": "^20.4.1",
+    "@eslint/compat": "^2.0.2",
+    "@fontsource/inter": "^5.2.8",
+    "@nolebase/vitepress-plugin-git-changelog": "^2.18.2",
+    "@nolebase/vitepress-plugin-og-image": "^2.18.2",
+    "@resvg/resvg-js": "^2.6.2",
+    "@semantic-release/exec": "^7.1.0",
+    "@semantic-release/github": "^12.0.6",
+    "@semantic-release/npm": "^13.1.5",
+    "@shikijs/vitepress-twoslash": "^3.22.0",
+    "@stylistic/eslint-plugin": "^5.8.0",
+    "@types/async-retry": "^1.4.9",
+    "@types/bytes": "^3.1.5",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.19.33",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/semver": "^7.7.1",
+    "@types/validate-npm-package-name": "^4.0.2",
+    "@types/which": "^3.0.4",
+    "@types/yargs": "^17.0.33",
+    "@vitest/coverage-v8": "^4.1.0",
+    "@vitest/ui": "^4.1.0",
+    "electron": "^40.4.1",
+    "eslint": "^9.39.2",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-jsdoc": "^62.5.5",
+    "eslint-plugin-n": "^17.24.0",
+    "feed": "^5.2.0",
+    "husky": "^9.1.7",
+    "rehype": "^13.0.2",
+    "rimraf": "^6.1.3",
+    "semantic-release": "^25.0.3",
+    "sharp": "^0.34.5",
+    "tslib": "^2.8.1",
+    "typedoc": "^0.28.17",
+    "typedoc-plugin-markdown": "^4.10.0",
+    "typedoc-plugin-mdn-links": "^5.1.1",
+    "typedoc-vitepress-theme": "^1.1.2",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.0",
+    "vite-node": "^6.0.0",
+    "vitepress": "^1.6.4",
+    "vitepress-plugin-llms": "^1.11.0",
+    "vitest": "^4.1.0",
+    "zx": "^8.8.5"
+  },
+  "dependencies": {
+    "@huggingface/jinja": "^0.5.6",
+    "async-retry": "^1.3.3",
+    "bytes": "^3.1.2",
+    "chalk": "^5.6.2",
+    "chmodrp": "^1.0.2",
+    "cmake-js": "^8.0.0",
+    "cross-spawn": "^7.0.6",
+    "env-var": "^7.5.0",
+    "filenamify": "^6.0.0",
+    "fs-extra": "^11.3.4",
+    "ignore": "^7.0.4",
+    "ipull": "^3.9.5",
+    "is-unicode-supported": "^2.1.0",
+    "lifecycle-utils": "^3.1.1",
+    "log-symbols": "^7.0.1",
+    "nanoid": "^5.1.6",
+    "node-addon-api": "^8.6.0",
+    "ora": "^9.3.0",
+    "pretty-ms": "^9.3.0",
+    "proper-lockfile": "^4.1.2",
+    "semver": "^7.7.1",
+    "simple-git": "^3.33.0",
+    "slice-ansi": "^8.0.0",
+    "stdout-update": "^4.0.1",
+    "strip-ansi": "^7.2.0",
+    "validate-npm-package-name": "^7.0.2",
+    "which": "^6.0.1",
+    "yargs": "^17.7.2"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "optionalDependencies": {
+    "@node-llama-cpp/linux-arm64": "0.1.0",
+    "@node-llama-cpp/linux-armv7l": "0.1.0",
+    "@node-llama-cpp/linux-x64": "0.1.0",
+    "@node-llama-cpp/linux-x64-cuda": "0.1.0",
+    "@node-llama-cpp/linux-x64-cuda-ext": "0.1.0",
+    "@node-llama-cpp/linux-x64-vulkan": "0.1.0",
+    "@node-llama-cpp/mac-arm64-metal": "0.1.0",
+    "@node-llama-cpp/mac-x64": "0.1.0",
+    "@node-llama-cpp/win-arm64": "0.1.0",
+    "@node-llama-cpp/win-x64": "0.1.0",
+    "@node-llama-cpp/win-x64-cuda": "0.1.0",
+    "@node-llama-cpp/win-x64-cuda-ext": "0.1.0",
+    "@node-llama-cpp/win-x64-vulkan": "0.1.0"
+  }
+}

package/templates/README.md

@@ -0,0 +1,6 @@
+Use the following command to scaffold a project from a template:
+```bash
+npm create node-llama-cpp@latest
+```
+
+> Don't use the templates in this repository directly. They are built to be used with the `npm create` command ([learn more](https://node-llama-cpp.withcat.ai/guide/))

package/templates/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "eslint-dependencies-for-ci",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "devDependencies": {
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-react-refresh": "^0.4.5"
+  }
+}